feat: initial commit - Jhonny Editor

- Adicionado estrutura completa do projeto
- Configurado MCP server para Premiere Pro
- Adicionado documentação e skills
- Configurado Gitignore para o projeto

code/tests/update-fetch.test.ts

@@ -0,0 +1,109 @@
+import { EventEmitter } from "node:events";
+import { afterEach, describe, expect, it, vi } from "vitest";
+
+const mocks = vi.hoisted(() => ({ get: vi.fn() }));
+
+vi.mock("node:https", () => ({ default: { get: mocks.get } }));
+
+function request() {
+  const value = new EventEmitter() as EventEmitter & {
+    destroy: ReturnType<typeof vi.fn>;
+    setTimeout: ReturnType<typeof vi.fn>;
+  };
+  value.destroy = vi.fn((error?: Error) => {
+    if (error) value.emit("error", error);
+  });
+  value.setTimeout = vi.fn();
+  return value;
+}
+
+function response(statusCode = 200) {
+  const value = new EventEmitter() as EventEmitter & {
+    resume: ReturnType<typeof vi.fn>;
+    setEncoding: ReturnType<typeof vi.fn>;
+    statusCode: number;
+  };
+  value.statusCode = statusCode;
+  value.resume = vi.fn();
+  value.setEncoding = vi.fn();
+  return value;
+}
+
+afterEach(() => {
+  vi.resetModules();
+  vi.clearAllMocks();
+});
+
+describe("npm update registry checks", () => {
+  it("returns the latest registry version from a bounded successful response", async () => {
+    const received = response();
+    const pending = request();
+    mocks.get.mockImplementation((_url, _options, callback) => {
+      callback(received);
+      queueMicrotask(() => {
+        received.emit("data", '{"dist-tags":{"latest":"v1.14.5"}}');
+        received.emit("end");
+      });
+      return pending;
+    });
+
+    const { fetchLatestNpmVersion } = await import("../src/update.js");
+    await expect(fetchLatestNpmVersion("premiere-pro-mcp")).resolves.toBe("1.14.5");
+    expect(received.setEncoding).toHaveBeenCalledWith("utf8");
+    expect(pending.setTimeout).toHaveBeenCalledWith(10_000, expect.any(Function));
+  });
+
+  it("rejects a non-success response and a malformed registry record", async () => {
+    const unavailable = response(503);
+    const unavailableRequest = request();
+    mocks.get.mockImplementationOnce((_url, _options, callback) => {
+      callback(unavailable);
+      return unavailableRequest;
+    });
+
+    let update = await import("../src/update.js");
+    await expect(update.fetchLatestNpmVersion("premiere-pro-mcp")).rejects.toThrow("HTTP 503");
+    expect(unavailable.resume).toHaveBeenCalledOnce();
+
+    vi.resetModules();
+    const malformed = response();
+    const malformedRequest = request();
+    mocks.get.mockImplementationOnce((_url, _options, callback) => {
+      callback(malformed);
+      queueMicrotask(() => {
+        malformed.emit("data", '{"dist-tags":{"latest":"nightly"}}');
+        malformed.emit("end");
+      });
+      return malformedRequest;
+    });
+    update = await import("../src/update.js");
+    await expect(update.fetchLatestNpmVersion("premiere-pro-mcp")).rejects.toThrow("valid latest version");
+  });
+
+  it("times out and rejects unexpectedly large responses", async () => {
+    const timedOut = response();
+    const timeoutRequest = request();
+    mocks.get.mockImplementationOnce((_url, _options, callback) => {
+      callback(timedOut);
+      return timeoutRequest;
+    });
+
+    let update = await import("../src/update.js");
+    const timeout = update.fetchLatestNpmVersion("premiere-pro-mcp");
+    const timeoutHandler = timeoutRequest.setTimeout.mock.calls[0][1] as () => void;
+    timeoutHandler();
+    await expect(timeout).rejects.toThrow("timed out");
+
+    vi.resetModules();
+    const oversized = response();
+    const oversizedRequest = request();
+    mocks.get.mockImplementationOnce((_url, _options, callback) => {
+      callback(oversized);
+      queueMicrotask(() => oversized.emit("data", "x".repeat(64 * 1024 + 1)));
+      return oversizedRequest;
+    });
+    update = await import("../src/update.js");
+    await expect(update.fetchLatestNpmVersion("premiere-pro-mcp")).rejects.toThrow("unexpectedly large");
+    expect(oversizedRequest.destroy).toHaveBeenCalledOnce();
+  });
+});