codexgpt 1.0.0

package/scripts/g8-u-live-probe.mjs

@@ -0,0 +1,208 @@
+#!/usr/bin/env node
+
+import { createHash, randomBytes } from "node:crypto";
+import { spawnSync } from "node:child_process";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+
+const scriptDir = path.dirname(fileURLToPath(import.meta.url));
+const projectRoot = path.resolve(scriptDir, "..");
+const entry = path.join(projectRoot, "scripts", "codexgpt-entry.mjs");
+const root = "D:\\Dev\\codexpro";
+const base = "https://codexpro-oauth.drliang.uk";
+const resource = `${base}/mcp`;
+const redirectUri = "https://chatgpt.com/connector_platform_oauth_redirect";
+const scopes = "codexgpt:read codexgpt:write codexgpt:execute";
+
+function safeText(value) {
+  return String(value)
+    .replace(/("(?:access_token|refresh_token|code)"\s*:\s*")[^"]+("?)/gi, "$1<redacted>$2")
+    .replace(/([?&](?:code|access_token|refresh_token)=)[^&\s]+/gi, "$1<redacted>")
+    .slice(0, 2000);
+}
+
+async function expectStatus(stage, response, expected) {
+  if (response.status === expected) return response;
+  const body = await response.text().catch(() => "");
+  throw new Error(`${stage}: HTTP ${response.status}: ${safeText(body)}`);
+}
+
+function form(values) {
+  return new URLSearchParams(values).toString();
+}
+
+function rpcHeaders(accessToken, sessionId = "") {
+  return {
+    authorization: `Bearer ${accessToken}`,
+    accept: "application/json, text/event-stream",
+    "content-type": "application/json",
+    ...(sessionId ? { "mcp-session-id": sessionId } : {})
+  };
+}
+
+function parseRpc(text) {
+  const trimmed = text.trim();
+  if (trimmed.startsWith("{")) return JSON.parse(trimmed);
+  const data = trimmed
+    .split(/\r?\n/)
+    .filter((line) => line.startsWith("data:"))
+    .map((line) => line.slice(5).trim())
+    .find(Boolean);
+  if (!data) throw new Error(`MCP response was not JSON or SSE: ${safeText(trimmed)}`);
+  return JSON.parse(data);
+}
+
+function runOwnerCommand(args) {
+  const result = spawnSync(process.execPath, [entry, ...args], {
+    cwd: projectRoot,
+    env: process.env,
+    encoding: "utf8",
+    windowsHide: true,
+    timeout: 30_000
+  });
+  if (result.error || result.status !== 0) {
+    throw new Error(`Owner command failed: ${safeText(result.stderr || result.stdout || result.error?.message)}`);
+  }
+  return String(result.stdout ?? "").trim();
+}
+
+let clientId = "";
+let refreshToken = "";
+let stage = "register";
+try {
+  const registration = await expectStatus(stage, await fetch(`${base}/register`, {
+    method: "POST",
+    headers: { "content-type": "application/json" },
+    body: JSON.stringify({
+      redirect_uris: [redirectUri],
+      client_name: "ChatGPT G8-U live probe",
+      scope: scopes
+    })
+  }), 201);
+  const client = await registration.json();
+  clientId = client.client_id;
+
+  const verifier = randomBytes(32).toString("base64url");
+  const challenge = createHash("sha256").update(verifier, "ascii").digest("base64url");
+  const state = `g8u_${randomBytes(16).toString("hex")}`;
+  const query = new URLSearchParams({
+    response_type: "code",
+    client_id: clientId,
+    redirect_uri: redirectUri,
+    state,
+    resource,
+    scope: scopes,
+    code_challenge: challenge,
+    code_challenge_method: "S256"
+  });
+
+  stage = "authorize";
+  const authorize = await expectStatus(stage, await fetch(`${base}/authorize?${query}`, {
+    redirect: "manual"
+  }), 200);
+  const cookie = authorize.headers.get("set-cookie")?.split(";", 1)[0] ?? "";
+  const waiting = await authorize.text();
+  const pendingId = waiting.match(/const id="([^"]+)"/)?.[1] ?? "";
+  const correlationCode = waiting.match(/Correlation code: <strong>([^<]+)</)?.[1] ?? "";
+  if (!cookie || !pendingId || !correlationCode) throw new Error("authorize: waiting page did not contain the bounded approval state");
+
+  stage = "approve";
+  runOwnerCommand(["auth", "approve", correlationCode, "--root", root]);
+
+  stage = "continue";
+  const continued = await expectStatus(stage, await fetch(`${base}/authorize/continue/${encodeURIComponent(pendingId)}`, {
+    headers: { cookie },
+    redirect: "manual"
+  }), 302);
+  const callback = new URL(continued.headers.get("location") ?? "");
+  if (callback.searchParams.get("state") !== state) throw new Error("continue: state mismatch");
+  if (callback.searchParams.get("iss") !== base) throw new Error("continue: issuer mismatch");
+  const code = callback.searchParams.get("code") ?? "";
+  if (!code) throw new Error("continue: authorization code missing");
+
+  stage = "token";
+  const tokenResponse = await expectStatus(stage, await fetch(`${base}/token`, {
+    method: "POST",
+    headers: { "content-type": "application/x-www-form-urlencoded" },
+    body: form({
+      grant_type: "authorization_code",
+      client_id: clientId,
+      code,
+      code_verifier: verifier,
+      redirect_uri: redirectUri,
+      resource
+    })
+  }), 200);
+  const tokens = await tokenResponse.json();
+  const accessToken = tokens.access_token;
+  refreshToken = tokens.refresh_token;
+  if (typeof accessToken !== "string" || typeof refreshToken !== "string") throw new Error("token: token response incomplete");
+
+  stage = "initialize";
+  const initializeResponse = await fetch(resource, {
+    method: "POST",
+    headers: rpcHeaders(accessToken),
+    body: JSON.stringify({
+      jsonrpc: "2.0",
+      id: 1,
+      method: "initialize",
+      params: {
+        protocolVersion: "2025-06-18",
+        capabilities: {},
+        clientInfo: { name: "g8-u-live-probe", version: "1.0.0" }
+      }
+    })
+  });
+  const initializeText = await initializeResponse.text();
+  if (initializeResponse.status !== 200) {
+    throw new Error(`initialize: HTTP ${initializeResponse.status}: ${safeText(initializeText)}`);
+  }
+  const initialized = parseRpc(initializeText);
+  if (initialized.error) throw new Error(`initialize: RPC error ${safeText(JSON.stringify(initialized.error))}`);
+  const sessionId = initializeResponse.headers.get("mcp-session-id") ?? "";
+  if (!sessionId) throw new Error("initialize: MCP session id missing");
+
+  stage = "initialized-notification";
+  const notificationResponse = await fetch(resource, {
+    method: "POST",
+    headers: rpcHeaders(accessToken, sessionId),
+    body: JSON.stringify({ jsonrpc: "2.0", method: "notifications/initialized" })
+  });
+  if (notificationResponse.status !== 202 && notificationResponse.status !== 200) {
+    throw new Error(`initialized-notification: HTTP ${notificationResponse.status}: ${safeText(await notificationResponse.text())}`);
+  }
+
+  stage = "tools-list";
+  const toolsResponse = await fetch(resource, {
+    method: "POST",
+    headers: rpcHeaders(accessToken, sessionId),
+    body: JSON.stringify({ jsonrpc: "2.0", id: 2, method: "tools/list", params: {} })
+  });
+  const toolsText = await toolsResponse.text();
+  if (toolsResponse.status !== 200) throw new Error(`tools-list: HTTP ${toolsResponse.status}: ${safeText(toolsText)}`);
+  const tools = parseRpc(toolsText);
+  if (tools.error) throw new Error(`tools-list: RPC error ${safeText(JSON.stringify(tools.error))}`);
+  const count = Array.isArray(tools.result?.tools) ? tools.result.tools.length : -1;
+  if (count < 1) throw new Error("tools-list: no tools returned");
+
+  console.log(JSON.stringify({ result: "PASS", initializeProtocol: initialized.result?.protocolVersion, toolCount: count }));
+} catch (error) {
+  console.error(JSON.stringify({ result: "FAIL", stage, error: safeText(error instanceof Error ? error.message : error) }));
+  process.exitCode = 1;
+} finally {
+  if (clientId && refreshToken) {
+    await fetch(`${base}/revoke`, {
+      method: "POST",
+      headers: { "content-type": "application/x-www-form-urlencoded" },
+      body: form({ client_id: clientId, token: refreshToken, token_type_hint: "refresh_token" })
+    }).catch(() => undefined);
+  }
+  if (clientId) {
+    try {
+      runOwnerCommand(["auth", "client", "remove", clientId, "--root", root]);
+    } catch (error) {
+      console.error(JSON.stringify({ result: "CLEANUP_FAILED", error: safeText(error instanceof Error ? error.message : error) }));
+      process.exitCode = 1;
+    }
+  }
+}

package/scripts/http-smoke-compat.mjs

@@ -0,0 +1,151 @@
+import fs from "node:fs/promises";
+import { createRequire } from "node:module";
+import { pathToFileURL } from "node:url";
+
+process.env["CODEXGPT_ALLOW_QUERY_" + "TOKEN"] = "1";
+process.env.CODEXGPT_GUIDANCE_MODE = "legacy";
+
+const require = createRequire(import.meta.url);
+const sourceUrl = new URL("./http-smoke.mjs", import.meta.url);
+let source = await fs.readFile(sourceUrl, "utf8");
+
+function replaceExactCount(source, oldText, newText, expectedCount) {
+  const actualCount = source.split(oldText).length - 1;
+  if (actualCount !== expectedCount) {
+    throw new Error(
+      `HTTP smoke compatibility replacement expected ${expectedCount} matches but found ${actualCount}: ${oldText}`
+    );
+  }
+  return source.split(oldText).join(newText);
+}
+
+const replacements = [
+  [
+    "from '@modelcontextprotocol/sdk/client/index.js'",
+    `from '${pathToFileURL(require.resolve("@modelcontextprotocol/sdk/client/index.js")).href}'`
+  ],
+  [
+    "from '@modelcontextprotocol/sdk/client/streamableHttp.js'",
+    `from '${pathToFileURL(require.resolve("@modelcontextprotocol/sdk/client/streamableHttp.js")).href}'`
+  ],
+  [
+    "result.structuredContent.skill_inventory?.length",
+    "result.structuredContent.data?.skill_inventory?.length"
+  ],
+  [
+    "withSkills.structuredContent.skill_inventory?.some?.",
+    "withSkills.structuredContent.data?.skill_inventory?.some?."
+  ],
+  [
+    "return result.structuredContent.workspace_id;",
+    "return result.structuredContent.data?.workspace_id;"
+  ],
+  [
+    "snapshot.structuredContent.workspace_id !== opened",
+    "snapshot.structuredContent.data?.workspace_id !== opened"
+  ],
+  [
+    "${snapshot.structuredContent.workspace_id}, expected",
+    "${snapshot.structuredContent.data?.workspace_id}, expected"
+  ],
+  [
+    "list.structuredContent.workspaces.map",
+    "list.structuredContent.data?.workspaces.map"
+  ],
+  [
+    "loadedSkill.structuredContent.skill?.name",
+    "loadedSkill.structuredContent.data?.skill?.name"
+  ],
+  [
+    "loadedSkill.structuredContent.text",
+    "loadedSkill.structuredContent.data?.text"
+  ]
+];
+
+for (const [oldText, newText] of replacements) {
+  const firstIndex = source.indexOf(oldText);
+  const lastIndex = source.lastIndexOf(oldText);
+  if (firstIndex < 0 || firstIndex !== lastIndex) {
+    throw new Error(`HTTP smoke compatibility replacement must match exactly once: ${oldText}`);
+  }
+  source = source.replace(oldText, newText);
+}
+
+source = replaceExactCount(
+  source,
+  "codexContext.structuredContent.workspace_id",
+  "codexContext.structuredContent.data?.workspace_id",
+  2
+);
+
+source = replaceExactCount(
+  source,
+  "exported.structuredContent.path",
+  "exported.structuredContent.data?.path",
+  2
+);
+
+const lifecycleBlockPattern = /  if \(opened !== currentOpened\) \{[\s\S]*?    if \(codexContext\.structuredContent\.data\?\.workspace_id !== opened\) \{[\s\S]*?  \}\);\r?\n/;
+const lifecycleBlockMatches = source.match(new RegExp(lifecycleBlockPattern.source, "g")) ?? [];
+if (lifecycleBlockMatches.length !== 1) {
+  throw new Error(`HTTP smoke compatibility lifecycle replacement expected 1 match but found ${lifecycleBlockMatches.length}`);
+}
+source = source.replace(lifecycleBlockPattern, `  if (!/^ws_[0-9a-f]{32}$/.test(currentOpened) || !/^ws_[0-9a-f]{32}$/.test(opened)) {
+    throw new Error(\`workspace lifecycle returned malformed handles: \${currentOpened}, \${opened}\`);
+  }
+  if (opened === currentOpened) {
+    throw new Error(\`independent HTTP sessions reused workspace handle \${opened}\`);
+  }
+
+  await withClient(mcpUrl, async (client) => {
+    const list = await callTool(client, 'list_workspaces');
+    const ids = list.structuredContent.data?.workspaces.map((workspace) => workspace.id);
+    if (ids.length !== 0) {
+      throw new Error(\`new HTTP session inherited workspace handles: \${ids.join(', ')}\`);
+    }
+
+    const foreign = await client.callTool({
+      name: 'tree',
+      arguments: { workspace_id: opened, max_depth: 1, max_entries: 10 }
+    });
+    if (!foreign.isError || foreign.structuredContent?.error?.code !== 'WORKSPACE_NOT_FOUND') {
+      throw new Error(\`foreign workspace handle was not rejected: \${JSON.stringify(foreign.structuredContent)}\`);
+    }
+
+    const sessionOpen = await callTool(client, 'open_workspace', { include_tree: false });
+    const active = sessionOpen.structuredContent.data?.workspace_id;
+    if (!/^ws_[0-9a-f]{32}$/.test(active) || active === opened || active === currentOpened) {
+      throw new Error(\`new HTTP session did not receive a fresh workspace handle: \${active}\`);
+    }
+
+    const snapshot = await callTool(client, 'workspace_snapshot', { workspace_id: active, max_depth: 1 });
+    if (snapshot.structuredContent.data?.workspace_id !== active) {
+      throw new Error(\`workspace_snapshot returned \${snapshot.structuredContent.data?.workspace_id}, expected \${active}\`);
+    }
+
+    const tree = await callTool(client, 'tree', { workspace_id: active, max_depth: 1, max_entries: 10 });
+    if (tree.structuredContent.data?.workspace_id !== active) {
+      throw new Error(\`tree returned \${tree.structuredContent.data?.workspace_id}, expected \${active}\`);
+    }
+
+    const codexContext = await callTool(client, 'codex_context', { workspace_id: active });
+    if (codexContext.structuredContent.data?.workspace_id !== active) {
+      throw new Error(\`codex_context returned \${codexContext.structuredContent.data?.workspace_id}, expected \${active}\`);
+    }
+  });
+`);
+
+const exportBlockPattern = /  await withClient\(mcpUrl, async \(client\) => \{\r?\n    const exported = await callTool\(client, 'export_pro_context', \{\r?\n      workspace_id: opened,/;
+const exportBlockMatches = source.match(new RegExp(exportBlockPattern.source, "g")) ?? [];
+if (exportBlockMatches.length !== 1) {
+  throw new Error(`HTTP smoke compatibility export replacement expected 1 match but found ${exportBlockMatches.length}`);
+}
+source = source.replace(exportBlockPattern, `  await withClient(mcpUrl, async (client) => {
+    const exportOpen = await callTool(client, 'open_workspace', { include_tree: false });
+    const exportWorkspaceId = exportOpen.structuredContent.data?.workspace_id;
+    const exported = await callTool(client, 'export_pro_context', {
+      workspace_id: exportWorkspaceId,`);
+
+source += "\n//# sourceURL=codexgpt-http-smoke-compat.mjs";
+const encoded = Buffer.from(source, "utf8").toString("base64");
+await import(`data:text/javascript;base64,${encoded}`);