gpt-connector 0.1.0

package/dist/src/page-bridge.js

@@ -0,0 +1,364 @@
+import { createHash } from "node:crypto";
+export const bridgeGlobalName = "__gptConnectorBridgeV1";
+const bridgeBootstrapSource = String.raw `async function(coreUrl, conversationUrl, expectedBuildId) {
+  const globalName = "__gptConnectorBridgeV1";
+  if (globalThis[globalName]?.version === 1 && globalThis[globalName]?.buildId === expectedBuildId) {
+    return globalThis[globalName].summary();
+  }
+
+  const [core, conversationModule] = await Promise.all([
+    import(coreUrl),
+    import(conversationUrl)
+  ]);
+
+  const entries = (module) => Object.entries(module);
+  const functionSource = (value) => Function.prototype.toString.call(value);
+  const unique = (role, candidates) => {
+    if (candidates.length !== 1) {
+      throw new Error("RUNTIME_DRIFT:" + role + ":" + candidates.length);
+    }
+    return candidates[0][1];
+  };
+
+  const sender = unique("sender", entries(core).filter(([, value]) => {
+    if (typeof value !== "function") return false;
+    const source = functionSource(value);
+    return source.includes("completion.submit.request.tpp_model_resolution") &&
+      source.includes("sendRequest({conduitToken") &&
+      source.includes("requestedModelId");
+  }));
+
+  const builder = unique("builder", entries(conversationModule).filter(([, value]) => {
+    if (typeof value !== "function") return false;
+    const source = functionSource(value);
+    return source.includes("contentToSend") &&
+      source.includes("allSystemHints") &&
+      source.includes("selectedSkillIds") &&
+      source.includes("build_request_params.prompt_message");
+  }));
+
+  const threadStore = unique("threadStore", entries(core).filter(([, value]) =>
+    value && typeof value === "object" &&
+    typeof value.initThread === "function" &&
+    typeof value.setServerIdForNewThread === "function" &&
+    typeof value.deleteThread === "function" &&
+    typeof value.retainThread === "function"
+  ));
+
+  const treeApi = unique("treeApi", entries(core).filter(([, value]) =>
+    value && typeof value === "object" &&
+    typeof value.getLastAssistantMessage === "function" &&
+    typeof value.getCurrentMessage === "function" &&
+    typeof value.getConversationTurns === "function"
+  ));
+
+  const apiClientCandidates = entries(core).filter(([, value]) =>
+    value && typeof value === "object" &&
+    typeof value.safeGet === "function" &&
+    typeof value.safePost === "function" &&
+    typeof value.safePatch === "function" &&
+    typeof value.safeDelete === "function"
+  );
+  const apiClientProbeResults = await Promise.all(apiClientCandidates.map(async ([, value]) => {
+    try {
+      const catalog = await value.safeGet("/models", {
+        parameters: { query: { supports_model_picker_upgrade_presets: true } }
+      });
+      return Array.isArray(catalog?.models) && typeof catalog?.default_model_slug === "string";
+    } catch {
+      return false;
+    }
+  }));
+  const apiClient = unique("apiClient", apiClientCandidates.filter((_, index) => apiClientProbeResults[index]));
+
+  const threadGetter = unique("threadGetter", entries(core).filter(([, value]) => {
+    if (typeof value !== "function" || value.length !== 1) return false;
+    const source = functionSource(value);
+    return /return [\w$]+\.threads\[[\w$]+\]\}$/.test(source);
+  }));
+
+  const factoryCandidates = entries(core).filter(([, value]) => {
+    if (typeof value !== "function") return false;
+    const source = functionSource(value);
+    return /^function [^(]+\([A-Za-z_$][\w$]*\)\{return [\w$]+\([\w$]+\(\),[\w$]+\(\),[A-Za-z_$][\w$]*\)\}$/.test(source);
+  });
+  const conversationFactory = unique("conversationFactory", factoryCandidates);
+
+  const sessions = new Map();
+  const operations = new Map();
+  const terminal = new Set(["succeeded", "failed"]);
+
+  const safeError = (error, fallbackCode) => ({
+    code: typeof error?.message === "string" && error.message.startsWith("RUNTIME_DRIFT:")
+      ? "RUNTIME_DRIFT"
+      : fallbackCode,
+    message: String(error?.message ?? error ?? "unknown error")
+      .slice(0, 240)
+      .replace(/[A-Za-z0-9_-]{32,}/g, "[redacted]")
+  });
+
+  const serverIdOf = (conversation) => {
+    const signal = conversation?.serverId$;
+    if (typeof signal === "function") return signal();
+    if (signal && typeof signal.get === "function") return signal.get();
+    return null;
+  };
+
+  const getCatalog = async () => {
+    const raw = await apiClient.safeGet("/models", {
+      parameters: { query: { supports_model_picker_upgrade_presets: true } }
+    });
+    const models = (raw.models ?? [])
+      .filter((model) => model?.is_work_mode_model !== true && typeof model?.slug === "string")
+      .map((model) => ({
+        id: model.slug,
+        title: typeof model.title === "string" ? model.title : model.slug,
+        reasoningType: typeof model.reasoning_type === "string" ? model.reasoning_type : null,
+        efforts: Array.isArray(model.thinking_efforts)
+          ? model.thinking_efforts.map((item) => item?.thinking_effort).filter((item) => typeof item === "string")
+          : [],
+        configurableEffort: model.configurable_thinking_effort === true,
+        maxTokens: typeof model.max_tokens === "number" ? model.max_tokens : null
+      }));
+    return {
+      defaultModel: models.some((model) => model.id === raw.default_model_slug)
+        ? raw.default_model_slug
+        : null,
+      models
+    };
+  };
+
+  const validateSelection = async (modelId, effort) => {
+    const catalog = await getCatalog();
+    if (modelId == null) {
+      if (effort != null) throw new Error("EFFORT_NOT_SUPPORTED:model_required");
+      return;
+    }
+    const model = catalog.models.find((candidate) => candidate.id === modelId);
+    if (!model) throw new Error("MODEL_NOT_AVAILABLE");
+    if (effort != null && !model.efforts.includes(effort)) {
+      throw new Error("EFFORT_NOT_SUPPORTED");
+    }
+  };
+
+  const extractResult = (conversation) => {
+    const thread = threadGetter(conversation.id);
+    const message = treeApi.getLastAssistantMessage(thread);
+    const text = Array.isArray(message?.content?.parts)
+      ? message.content.parts.filter((part) => typeof part === "string").join("")
+      : "";
+    if (!message || message.status !== "finished_successfully" || message.end_turn !== true || text.length === 0) {
+      throw new Error("STREAM_INCOMPLETE");
+    }
+    const metadata = message.metadata ?? {};
+    return {
+      text,
+      status: message.status,
+      endTurn: true,
+      resolvedModel: typeof metadata.resolved_model_slug === "string"
+        ? metadata.resolved_model_slug
+        : typeof metadata.model_slug === "string" ? metadata.model_slug : null,
+      resolvedEffort: typeof metadata.thinking_effort === "string"
+        ? metadata.thinking_effort
+        : null
+    };
+  };
+
+  const archive = async (conversation) => {
+    const serverId = serverIdOf(conversation);
+    if (!serverId) throw new Error("ARCHIVE_FAILED:no_server_id");
+    await apiClient.safePatch("/conversation/{conversation_id}", {
+      parameters: { path: { conversation_id: serverId } },
+      requestBody: { is_archived: true }
+    });
+    const data = await apiClient.safeGet("/conversation/{conversation_id}", {
+      parameters: { path: { conversation_id: serverId } }
+    });
+    if (data?.is_archived !== true) throw new Error("ARCHIVE_FAILED:not_confirmed");
+  };
+
+  const startOperation = (kind) => {
+    const id = crypto.randomUUID();
+    operations.set(id, { kind, state: "pending", result: null, error: null });
+    return id;
+  };
+
+  const finishFailure = (operation, error, fallbackCode) => {
+    operation.state = "failed";
+    operation.error = safeError(error, fallbackCode);
+  };
+
+  const bridge = {
+    version: 1,
+    buildId: expectedBuildId,
+    summary: () => ({ version: 1, buildId: expectedBuildId, ready: true }),
+    diagnostics: () => ({
+      sessionCount: sessions.size,
+      operationCount: operations.size
+    }),
+    startModels: () => {
+      const operationId = startOperation("models");
+      const operation = operations.get(operationId);
+      void getCatalog().then((catalog) => {
+        operation.state = "succeeded";
+        operation.result = catalog;
+      }, (error) => finishFailure(operation, error, "CHAT_FAILED"));
+      return { operationId };
+    },
+    startChat: (input) => {
+      const operationId = startOperation("chat");
+      const operation = operations.get(operationId);
+      const sessionId = input.sessionId ?? crypto.randomUUID();
+      let session = sessions.get(sessionId);
+      const createdSession = input.sessionId == null;
+      if (input.sessionId != null && !session) {
+        finishFailure(operation, new Error("SESSION_NOT_FOUND"), "SESSION_NOT_FOUND");
+        return { operationId };
+      }
+      if (session?.busy) {
+        finishFailure(operation, new Error("SESSION_BUSY"), "SESSION_BUSY");
+        return { operationId };
+      }
+      if (session) session.busy = true;
+
+      void (async () => {
+        try {
+          await validateSelection(input.model, input.effort);
+          if (!session) {
+            const conversation = conversationFactory();
+            if (!conversation || typeof conversation.id !== "string" || !conversation.id.startsWith("WEB:")) {
+              throw new Error("RUNTIME_DRIFT:factory_output");
+            }
+            threadStore.initThread({
+              clientThreadId: conversation.id,
+              conversationMode: { kind: "primary_assistant" },
+              conversationOrigin: null
+            });
+            session = { conversation, busy: true };
+            sessions.set(sessionId, session);
+          }
+          const prompt = String(input.prompt);
+          const params = await builder({
+            conversation: session.conversation,
+            attachments: [],
+            content: prompt,
+            contentToSend: { content: prompt, metadata: null },
+            conversationMode: { kind: "primary_assistant" },
+            hasSelectedApps: false,
+            desktopOrigin: null,
+            shouldCollectSidebarContext: false,
+            selectedApps: [],
+            selectedSources: undefined,
+            selectedMCPConnectors: undefined,
+            selectedConnectorIds: undefined,
+            searchConnectorIds: undefined,
+            startedWithByoMcp: false,
+            sourceEvent: undefined,
+            allSystemHints: [],
+            systemHints: [],
+            firstInputTimestampMs: performance.now(),
+            isN7jupdActive: false,
+            isForceAllowCustomMcpModeEnabled: false,
+            selectedSkillIds: [],
+            thinkingEffort: input.effort,
+            serviceTier: undefined
+          });
+          await sender({
+            ...params,
+            conversation: session.conversation,
+            requestedModelId: input.model,
+            thinkingEffort: input.effort,
+            serviceTier: undefined,
+            callsiteId: "request_completion.gpt_connector.1",
+            eventSource: "url"
+          });
+          const result = extractResult(session.conversation);
+          if (input.keepOpen === true) {
+            operation.result = { ...result, sessionId };
+          } else {
+            await archive(session.conversation);
+            sessions.delete(sessionId);
+            operation.result = result;
+          }
+          operation.state = "succeeded";
+        } catch (error) {
+          let cleanupError = null;
+          if (session && (createdSession || input.keepOpen !== true)) {
+            if (serverIdOf(session.conversation)) {
+              try {
+                await archive(session.conversation);
+              } catch (archiveError) {
+                cleanupError = archiveError;
+              }
+            }
+            sessions.delete(sessionId);
+          }
+          if (cleanupError) {
+            finishFailure(operation, cleanupError, "ARCHIVE_FAILED");
+            return;
+          }
+          const message = String(error?.message ?? error);
+          const code = message.startsWith("MODEL_NOT_AVAILABLE") ? "MODEL_NOT_AVAILABLE"
+            : message.startsWith("EFFORT_NOT_SUPPORTED") ? "EFFORT_NOT_SUPPORTED"
+            : message.startsWith("STREAM_INCOMPLETE") ? "STREAM_INCOMPLETE"
+            : message.startsWith("ARCHIVE_FAILED") ? "ARCHIVE_FAILED"
+            : message.startsWith("RUNTIME_DRIFT") ? "RUNTIME_DRIFT"
+            : "CHAT_FAILED";
+          finishFailure(operation, error, code);
+        } finally {
+          const current = sessions.get(sessionId);
+          if (current) current.busy = false;
+        }
+      })();
+      return { operationId };
+    },
+    startClose: (input) => {
+      const operationId = startOperation("close");
+      const operation = operations.get(operationId);
+      const session = sessions.get(input.sessionId);
+      if (!session) {
+        finishFailure(operation, new Error("SESSION_NOT_FOUND"), "SESSION_NOT_FOUND");
+        return { operationId };
+      }
+      if (session.busy) {
+        finishFailure(operation, new Error("SESSION_BUSY"), "SESSION_BUSY");
+        return { operationId };
+      }
+      session.busy = true;
+      void archive(session.conversation).then(() => {
+        sessions.delete(input.sessionId);
+        operation.state = "succeeded";
+        operation.result = { archived: true };
+      }, (error) => {
+        session.busy = false;
+        finishFailure(operation, error, "ARCHIVE_FAILED");
+      });
+      return { operationId };
+    },
+    poll: (operationId, consume) => {
+      const operation = operations.get(operationId);
+      if (!operation) return { state: "failed", error: { code: "CHAT_FAILED", message: "operation_not_found" } };
+      const result = {
+        state: operation.state,
+        result: operation.result,
+        error: operation.error
+      };
+      if (consume === true && terminal.has(operation.state)) operations.delete(operationId);
+      return result;
+    }
+  };
+
+  globalThis[globalName] = bridge;
+  return bridge.summary();
+}`;
+export const bridgeBuildId = createHash("sha256")
+    .update(bridgeBootstrapSource)
+    .digest("hex")
+    .slice(0, 16);
+export function createBridgeBootstrapExpression(coreUrl, conversationUrl) {
+    return `(${bridgeBootstrapSource})(${JSON.stringify(coreUrl)}, ${JSON.stringify(conversationUrl)}, ${JSON.stringify(bridgeBuildId)})`;
+}
+export function createBridgeCallExpression(method, args) {
+    return `globalThis[${JSON.stringify(bridgeGlobalName)}].${method}(...${JSON.stringify(args)})`;
+}
+//# sourceMappingURL=page-bridge.js.map

package/dist/src/page-bridge.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"page-bridge.js","sourceRoot":"","sources":["../../src/page-bridge.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,aAAa,CAAC;AAEzC,MAAM,CAAC,MAAM,gBAAgB,GAAG,wBAAwB,CAAC;AAEzD,MAAM,qBAAqB,GAAG,MAAM,CAAC,GAAG,CAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA8VtC,CAAC;AAEH,MAAM,CAAC,MAAM,aAAa,GAAG,UAAU,CAAC,QAAQ,CAAC;KAC9C,MAAM,CAAC,qBAAqB,CAAC;KAC7B,MAAM,CAAC,KAAK,CAAC;KACb,KAAK,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC;AAEhB,MAAM,UAAU,+BAA+B,CAC7C,OAAe,EACf,eAAuB;IAEvB,OAAO,IAAI,qBAAqB,KAAK,IAAI,CAAC,SAAS,CAAC,OAAO,CAAC,KAAK,IAAI,CAAC,SAAS,CAAC,eAAe,CAAC,KAAK,IAAI,CAAC,SAAS,CAAC,aAAa,CAAC,GAAG,CAAC;AACxI,CAAC;AAED,MAAM,UAAU,0BAA0B,CACxC,MAA2D,EAC3D,IAAwB;IAExB,OAAO,cAAc,IAAI,CAAC,SAAS,CAAC,gBAAgB,CAAC,KAAK,MAAM,OAAO,IAAI,CAAC,SAAS,CAAC,IAAI,CAAC,GAAG,CAAC;AACjG,CAAC"}

package/dist/src/redaction.d.ts

@@ -0,0 +1 @@
+export declare function redactDiagnostic(value: unknown): unknown;

package/dist/src/redaction.js

@@ -0,0 +1,17 @@
+const secretKeyPattern = /authorization|cookie|token|attestation|conduit|account.?id/i;
+const longIdentifierPattern = /\b[A-Za-z0-9_-]{32,}\b/g;
+export function redactDiagnostic(value) {
+    if (Array.isArray(value))
+        return value.map(redactDiagnostic);
+    if (typeof value === "object" && value !== null) {
+        return Object.fromEntries(Object.entries(value).map(([key, child]) => [
+            key,
+            secretKeyPattern.test(key) ? "[redacted]" : redactDiagnostic(child),
+        ]));
+    }
+    if (typeof value === "string") {
+        return value.replace(longIdentifierPattern, "[redacted]");
+    }
+    return value;
+}
+//# sourceMappingURL=redaction.js.map

package/dist/src/redaction.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"redaction.js","sourceRoot":"","sources":["../../src/redaction.ts"],"names":[],"mappings":"AAAA,MAAM,gBAAgB,GAAG,6DAA6D,CAAC;AACvF,MAAM,qBAAqB,GAAG,yBAAyB,CAAC;AAExD,MAAM,UAAU,gBAAgB,CAAC,KAAc;IAC7C,IAAI,KAAK,CAAC,OAAO,CAAC,KAAK,CAAC;QAAE,OAAO,KAAK,CAAC,GAAG,CAAC,gBAAgB,CAAC,CAAC;IAE7D,IAAI,OAAO,KAAK,KAAK,QAAQ,IAAI,KAAK,KAAK,IAAI,EAAE,CAAC;QAChD,OAAO,MAAM,CAAC,WAAW,CACvB,MAAM,CAAC,OAAO,CAAC,KAAK,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,GAAG,EAAE,KAAK,CAAC,EAAE,EAAE,CAAC;YAC1C,GAAG;YACH,gBAAgB,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,YAAY,CAAC,CAAC,CAAC,gBAAgB,CAAC,KAAK,CAAC;SACpE,CAAC,CACH,CAAC;IACJ,CAAC;IAED,IAAI,OAAO,KAAK,KAAK,QAAQ,EAAE,CAAC;QAC9B,OAAO,KAAK,CAAC,OAAO,CAAC,qBAAqB,EAAE,YAAY,CAAC,CAAC;IAC5D,CAAC;IAED,OAAO,KAAK,CAAC;AACf,CAAC"}

package/dist/src/runtime-evaluate.d.ts

@@ -0,0 +1,2 @@
+import type { CdpClient } from "./cdp.js";
+export declare function evaluateByValue<T>(client: CdpClient, expression: string, awaitPromise?: boolean): Promise<T>;

package/dist/src/runtime-evaluate.js

@@ -0,0 +1,14 @@
+import { ConnectorError } from "./errors.js";
+export async function evaluateByValue(client, expression, awaitPromise = true) {
+    const response = await client.call("Runtime.evaluate", {
+        expression,
+        awaitPromise,
+        returnByValue: true,
+        userGesture: false,
+    });
+    if (response.exceptionDetails !== undefined || response.result === undefined) {
+        throw new ConnectorError("RUNTIME_DRIFT", "ChatGPT page main worldで式を評価できませんでした。");
+    }
+    return response.result.value;
+}
+//# sourceMappingURL=runtime-evaluate.js.map

package/dist/src/runtime-evaluate.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"runtime-evaluate.js","sourceRoot":"","sources":["../../src/runtime-evaluate.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAAE,MAAM,aAAa,CAAC;AAa7C,MAAM,CAAC,KAAK,UAAU,eAAe,CACnC,MAAiB,EACjB,UAAkB,EAClB,YAAY,GAAG,IAAI;IAEnB,MAAM,QAAQ,GAAG,MAAM,MAAM,CAAC,IAAI,CAA0B,kBAAkB,EAAE;QAC9E,UAAU;QACV,YAAY;QACZ,aAAa,EAAE,IAAI;QACnB,WAAW,EAAE,KAAK;KACnB,CAAC,CAAC;IAEH,IAAI,QAAQ,CAAC,gBAAgB,KAAK,SAAS,IAAI,QAAQ,CAAC,MAAM,KAAK,SAAS,EAAE,CAAC;QAC7E,MAAM,IAAI,cAAc,CACtB,eAAe,EACf,uCAAuC,CACxC,CAAC;IACJ,CAAC;IAED,OAAO,QAAQ,CAAC,MAAM,CAAC,KAAU,CAAC;AACpC,CAAC"}

package/dist/src/session-registry.d.ts

@@ -0,0 +1,18 @@
+export interface SessionRecord {
+    readonly id: string;
+    readonly createdAt: number;
+    lastUsedAt: number;
+    busy: boolean;
+}
+export declare class SessionRegistry {
+    #private;
+    create(now?: number): SessionRecord;
+    register(id: string, now?: number): SessionRecord;
+    get(id: string): SessionRecord;
+    acquire(id: string, now?: number): SessionRecord;
+    release(id: string, now?: number): void;
+    delete(id: string): void;
+    has(id: string): boolean;
+    get size(): number;
+    ids(): readonly string[];
+}

package/dist/src/session-registry.js

@@ -0,0 +1,57 @@
+import { randomUUID } from "node:crypto";
+import { ConnectorError } from "./errors.js";
+export class SessionRegistry {
+    #sessions = new Map();
+    create(now = Date.now()) {
+        return this.register(randomUUID(), now);
+    }
+    register(id, now = Date.now()) {
+        if (this.#sessions.has(id)) {
+            throw new ConnectorError("SESSION_BUSY", "sessionはすでに登録されています。");
+        }
+        const record = {
+            id,
+            createdAt: now,
+            lastUsedAt: now,
+            busy: false,
+        };
+        this.#sessions.set(record.id, record);
+        return record;
+    }
+    get(id) {
+        const record = this.#sessions.get(id);
+        if (record === undefined) {
+            throw new ConnectorError("SESSION_NOT_FOUND", "sessionが見つかりません。");
+        }
+        return record;
+    }
+    acquire(id, now = Date.now()) {
+        const record = this.get(id);
+        if (record.busy) {
+            throw new ConnectorError("SESSION_BUSY", "sessionは別turnを処理中です。");
+        }
+        record.busy = true;
+        record.lastUsedAt = now;
+        return record;
+    }
+    release(id, now = Date.now()) {
+        const record = this.get(id);
+        record.busy = false;
+        record.lastUsedAt = now;
+    }
+    delete(id) {
+        if (!this.#sessions.delete(id)) {
+            throw new ConnectorError("SESSION_NOT_FOUND", "sessionが見つかりません。");
+        }
+    }
+    has(id) {
+        return this.#sessions.has(id);
+    }
+    get size() {
+        return this.#sessions.size;
+    }
+    ids() {
+        return [...this.#sessions.keys()];
+    }
+}
+//# sourceMappingURL=session-registry.js.map

package/dist/src/session-registry.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"session-registry.js","sourceRoot":"","sources":["../../src/session-registry.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,aAAa,CAAC;AAEzC,OAAO,EAAE,cAAc,EAAE,MAAM,aAAa,CAAC;AAS7C,MAAM,OAAO,eAAe;IACjB,SAAS,GAAG,IAAI,GAAG,EAAyB,CAAC;IAEtD,MAAM,CAAC,GAAG,GAAG,IAAI,CAAC,GAAG,EAAE;QACrB,OAAO,IAAI,CAAC,QAAQ,CAAC,UAAU,EAAE,EAAE,GAAG,CAAC,CAAC;IAC1C,CAAC;IAED,QAAQ,CAAC,EAAU,EAAE,GAAG,GAAG,IAAI,CAAC,GAAG,EAAE;QACnC,IAAI,IAAI,CAAC,SAAS,CAAC,GAAG,CAAC,EAAE,CAAC,EAAE,CAAC;YAC3B,MAAM,IAAI,cAAc,CAAC,cAAc,EAAE,sBAAsB,CAAC,CAAC;QACnE,CAAC;QACD,MAAM,MAAM,GAAkB;YAC5B,EAAE;YACF,SAAS,EAAE,GAAG;YACd,UAAU,EAAE,GAAG;YACf,IAAI,EAAE,KAAK;SACZ,CAAC;QACF,IAAI,CAAC,SAAS,CAAC,GAAG,CAAC,MAAM,CAAC,EAAE,EAAE,MAAM,CAAC,CAAC;QACtC,OAAO,MAAM,CAAC;IAChB,CAAC;IAED,GAAG,CAAC,EAAU;QACZ,MAAM,MAAM,GAAG,IAAI,CAAC,SAAS,CAAC,GAAG,CAAC,EAAE,CAAC,CAAC;QACtC,IAAI,MAAM,KAAK,SAAS,EAAE,CAAC;YACzB,MAAM,IAAI,cAAc,CAAC,mBAAmB,EAAE,kBAAkB,CAAC,CAAC;QACpE,CAAC;QACD,OAAO,MAAM,CAAC;IAChB,CAAC;IAED,OAAO,CAAC,EAAU,EAAE,GAAG,GAAG,IAAI,CAAC,GAAG,EAAE;QAClC,MAAM,MAAM,GAAG,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,CAAC;QAC5B,IAAI,MAAM,CAAC,IAAI,EAAE,CAAC;YAChB,MAAM,IAAI,cAAc,CAAC,cAAc,EAAE,sBAAsB,CAAC,CAAC;QACnE,CAAC;QACD,MAAM,CAAC,IAAI,GAAG,IAAI,CAAC;QACnB,MAAM,CAAC,UAAU,GAAG,GAAG,CAAC;QACxB,OAAO,MAAM,CAAC;IAChB,CAAC;IAED,OAAO,CAAC,EAAU,EAAE,GAAG,GAAG,IAAI,CAAC,GAAG,EAAE;QAClC,MAAM,MAAM,GAAG,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,CAAC;QAC5B,MAAM,CAAC,IAAI,GAAG,KAAK,CAAC;QACpB,MAAM,CAAC,UAAU,GAAG,GAAG,CAAC;IAC1B,CAAC;IAED,MAAM,CAAC,EAAU;QACf,IAAI,CAAC,IAAI,CAAC,SAAS,CAAC,MAAM,CAAC,EAAE,CAAC,EAAE,CAAC;YAC/B,MAAM,IAAI,cAAc,CAAC,mBAAmB,EAAE,kBAAkB,CAAC,CAAC;QACpE,CAAC;IACH,CAAC;IAED,GAAG,CAAC,EAAU;QACZ,OAAO,IAAI,CAAC,SAAS,CAAC,GAAG,CAAC,EAAE,CAAC,CAAC;IAChC,CAAC;IAED,IAAI,IAAI;QACN,OAAO,IAAI,CAAC,SAAS,CAAC,IAAI,CAAC;IAC7B,CAAC;IAED,GAAG;QACD,OAAO,CAAC,GAAG,IAAI,CAAC,SAAS,CAAC,IAAI,EAAE,CAAC,CAAC;IACpC,CAAC;CACF"}

package/package.json

@@ -0,0 +1,62 @@
+{
+  "name": "gpt-connector",
+  "version": "0.1.0",
+  "description": "UIに依存せず、ログイン済みChatGPT Web runtimeの通常ChatをCodexから呼び出すローカルconnector",
+  "license": "MIT",
+  "author": "kitepon-rgb",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/kitepon-rgb/gpt-connector.git"
+  },
+  "homepage": "https://github.com/kitepon-rgb/gpt-connector#readme",
+  "bugs": {
+    "url": "https://github.com/kitepon-rgb/gpt-connector/issues"
+  },
+  "type": "module",
+  "main": "dist/src/index.js",
+  "types": "dist/src/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/src/index.d.ts",
+      "import": "./dist/src/index.js"
+    }
+  },
+  "files": [
+    "dist/src",
+    "README.md",
+    "LICENSE"
+  ],
+  "bin": {
+    "gpt-connector": "dist/src/cli.js",
+    "gpt-connector-mcp": "dist/src/mcp.js"
+  },
+  "engines": {
+    "node": ">=26"
+  },
+  "scripts": {
+    "build": "tsc -p tsconfig.json",
+    "cli": "tsx src/cli.ts",
+    "typecheck": "tsc -p tsconfig.json --noEmit",
+    "lint": "eslint .",
+    "test": "tsx --test test/*.test.ts",
+    "check": "pnpm lint && pnpm typecheck && pnpm test",
+    "prepublishOnly": "pnpm check && pnpm build"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "1.29.0",
+    "ws": "8.21.0",
+    "zod": "4.4.3"
+  },
+  "devDependencies": {
+    "@eslint/js": "10.0.1",
+    "@types/node": "26.1.1",
+    "@types/ws": "8.18.1",
+    "eslint": "10.7.0",
+    "tsx": "4.23.0",
+    "typescript": "6.0.3",
+    "typescript-eslint": "8.63.0"
+  }
+}