codex-chatgpt-control 0.1.0-alpha.1

package/dist/src/scripts/live-smoke/types.d.ts

@@ -0,0 +1,53 @@
+import type { BrowserLike, CommandResult } from "../../types.js";
+export type LiveSmokeStatus = "pass" | "fail" | "skip";
+export type LiveSmokeCleanupResult = {
+    attempted: boolean;
+    ok: boolean;
+    reason?: string;
+    error?: {
+        name: string;
+        message: string;
+    };
+};
+export type LiveSmokeScenarioResult = {
+    name: string;
+    status: LiveSmokeStatus;
+    required: boolean;
+    startedAt: string;
+    endedAt: string;
+    durationMs: number;
+    command?: CommandResult<unknown>;
+    details?: Record<string, unknown>;
+    error?: {
+        name: string;
+        message: string;
+    };
+    cleanup?: LiveSmokeCleanupResult;
+};
+export type LiveSmokeBrowser = BrowserLike & {
+    tabs?: BrowserLike["tabs"] & {
+        finalize?: (options: {
+            keep?: unknown[];
+        }) => Promise<void>;
+    };
+};
+export type LiveSmokeContext = {
+    agent: unknown;
+    browser?: LiveSmokeBrowser;
+    env?: Record<string, string | undefined>;
+    reportDir: string;
+    knownThreadQuery?: string;
+    knownThreadUrl?: string;
+    knownConversationId?: string;
+};
+export type LiveSmokeScenario = {
+    name: string;
+    required: boolean;
+    enabled: (context: LiveSmokeContext) => boolean;
+    run: (context: LiveSmokeContext) => Promise<LiveSmokeScenarioResult>;
+};
+export type LiveSmokeRunResult = {
+    reportPath: string;
+    results: LiveSmokeScenarioResult[];
+    requiredFailures: LiveSmokeScenarioResult[];
+};

package/dist/src/scripts/live-smoke/types.js

@@ -0,0 +1 @@
+export {};

package/dist/src/scripts/live-smoke-module.d.ts

@@ -0,0 +1,3 @@
+export { contextEnvFlag, contextEnvText, envFlag, envText, filterScenarios, requiredFailures, runLiveSmoke, runScenario, writeReport } from "./live-smoke/harness.js";
+export { optionalScenarios, requiredScenarios } from "./live-smoke/scenarios.js";
+export type { LiveSmokeBrowser, LiveSmokeCleanupResult, LiveSmokeContext, LiveSmokeRunResult, LiveSmokeScenario, LiveSmokeScenarioResult, LiveSmokeStatus } from "./live-smoke/types.js";

package/dist/src/scripts/live-smoke-module.js

@@ -0,0 +1,2 @@
+export { contextEnvFlag, contextEnvText, envFlag, envText, filterScenarios, requiredFailures, runLiveSmoke, runScenario, writeReport } from "./live-smoke/harness.js";
+export { optionalScenarios, requiredScenarios } from "./live-smoke/scenarios.js";

package/dist/src/scripts/live-smoke.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/src/scripts/live-smoke.js

@@ -0,0 +1,54 @@
+import { join } from "node:path";
+import { BROWSER_BRIDGE_REMEDIATION, BROWSER_BRIDGE_UNAVAILABLE_MESSAGE } from "../errors.js";
+import { envText, filterScenarios, runLiveSmoke } from "./live-smoke/harness.js";
+import { optionalScenarios, requiredScenarios } from "./live-smoke/scenarios.js";
+const globals = globalThis;
+const agent = globals.agent;
+if (agent === undefined) {
+    console.log(JSON.stringify({
+        ok: false,
+        status: "blocked",
+        blocker: {
+            kind: "browser_bridge_unavailable",
+            code: "codex_chrome_bridge_unavailable",
+            message: BROWSER_BRIDGE_UNAVAILABLE_MESSAGE,
+            remediation: BROWSER_BRIDGE_REMEDIATION
+        }
+    }, null, 2));
+    process.exitCode = 2;
+}
+else {
+    const context = {
+        agent,
+        reportDir: join(process.cwd(), "reports", "live-smoke")
+    };
+    const browser = globals.browser;
+    if (browser !== undefined) {
+        context.browser = browser;
+    }
+    const knownThreadQuery = envText("CHATGPT_SMOKE_QUERY");
+    if (knownThreadQuery !== undefined) {
+        context.knownThreadQuery = knownThreadQuery;
+    }
+    const knownThreadUrl = envText("CHATGPT_SMOKE_THREAD_URL");
+    if (knownThreadUrl !== undefined) {
+        context.knownThreadUrl = knownThreadUrl;
+    }
+    const knownConversationId = envText("CHATGPT_SMOKE_CONVERSATION_ID");
+    if (knownConversationId !== undefined) {
+        context.knownConversationId = knownConversationId;
+    }
+    context.env = {
+        CHATGPT_E2E_CREATE_IMAGE: envText("CHATGPT_E2E_CREATE_IMAGE"),
+        CHATGPT_E2E_DEEP_RESEARCH: envText("CHATGPT_E2E_DEEP_RESEARCH"),
+        CHATGPT_E2E_DOWNLOAD: envText("CHATGPT_E2E_DOWNLOAD"),
+        CHATGPT_E2E_LOGIN_PROFILE: envText("CHATGPT_E2E_LOGIN_PROFILE"),
+        CHATGPT_E2E_MODE_LABEL: envText("CHATGPT_E2E_MODE_LABEL"),
+        CHATGPT_E2E_STREAM: envText("CHATGPT_E2E_STREAM"),
+        CHATGPT_E2E_UPLOAD_PERMISSION_MANUAL: envText("CHATGPT_E2E_UPLOAD_PERMISSION_MANUAL"),
+        CHATGPT_E2E_WEB_SEARCH: envText("CHATGPT_E2E_WEB_SEARCH")
+    };
+    const scenarios = filterScenarios([...requiredScenarios, ...optionalScenarios], envText("CHATGPT_E2E_SCENARIOS"));
+    const result = await runLiveSmoke(context, scenarios);
+    process.exitCode = result.requiredFailures.length === 0 ? 0 : 1;
+}

package/dist/src/scripts/smoke-attach-file.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/src/scripts/smoke-attach-file.js

@@ -0,0 +1,39 @@
+import { mkdtemp, writeFile } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { attachFiles } from "../commands/files.js";
+import { askMessage } from "../commands/messages.js";
+import { bootstrap } from "../commands/session.js";
+import { newThread } from "../commands/threads.js";
+const dir = await mkdtemp(join(tmpdir(), "chatgpt-control-smoke-"));
+const file = join(dir, "chatgpt-control-smoke.txt");
+await writeFile(file, "This is a ChatGPT control smoke fixture.\n");
+const env = { agent: globalThis.agent };
+const boot = await bootstrap(env);
+if (!boot.ok) {
+    console.log(JSON.stringify(boot, null, 2));
+    process.exitCode = 2;
+}
+else {
+    const created = await newThread(env);
+    if (!created.ok) {
+        console.log(JSON.stringify(created, null, 2));
+        process.exitCode = 2;
+    }
+    else {
+        const attached = await attachFiles(env, { paths: [file], timeoutMs: 180000 });
+        if (!attached.ok) {
+            console.log(JSON.stringify(attached, null, 2));
+            process.exitCode = 1;
+        }
+        else {
+            const result = await askMessage(env, {
+                text: "Reply with the attached filename only.",
+                wait: { timeoutMs: 180000, stableMs: 2000 },
+                read: true
+            });
+            console.log(JSON.stringify(result, null, 2));
+            process.exitCode = result.ok && result.data?.responseText?.includes("chatgpt-control-smoke.txt") ? 0 : 1;
+        }
+    }
+}

package/dist/src/scripts/smoke-hi.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/src/scripts/smoke-hi.js

@@ -0,0 +1,25 @@
+import { newThread } from "../commands/threads.js";
+import { askMessage } from "../commands/messages.js";
+import { bootstrap } from "../commands/session.js";
+const env = { agent: globalThis.agent };
+const boot = await bootstrap(env);
+if (!boot.ok) {
+    console.log(JSON.stringify(boot, null, 2));
+    process.exitCode = 2;
+}
+else {
+    const created = await newThread(env);
+    if (!created.ok) {
+        console.log(JSON.stringify(created, null, 2));
+        process.exitCode = 2;
+    }
+    else {
+        const result = await askMessage(env, {
+            text: "reply with the word hi",
+            wait: { timeoutMs: 120000, stableMs: 2000 },
+            read: true
+        });
+        console.log(JSON.stringify(result, null, 2));
+        process.exitCode = result.ok && result.data?.responseText?.trim().toLowerCase() === "hi" ? 0 : 1;
+    }
+}

package/dist/src/scripts/smoke-search-open-read.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/src/scripts/smoke-search-open-read.js

@@ -0,0 +1,41 @@
+import { readLatest } from "../commands/messages.js";
+import { bootstrap } from "../commands/session.js";
+import { openThread, searchThreads } from "../commands/threads.js";
+const query = process.env.CHATGPT_SMOKE_QUERY;
+if (query === undefined || query.trim().length === 0) {
+    console.error("Set CHATGPT_SMOKE_QUERY to a known ChatGPT thread title or exact search phrase.");
+    process.exit(2);
+}
+const env = { agent: globalThis.agent };
+const boot = await bootstrap(env);
+if (!boot.ok) {
+    console.log(JSON.stringify(boot, null, 2));
+    process.exitCode = 2;
+}
+else {
+    const search = await searchThreads(env, { query, limit: 5 });
+    if (!search.ok || search.data?.results[0] === undefined) {
+        console.log(JSON.stringify(search, null, 2));
+        process.exitCode = 1;
+    }
+    else {
+        const opened = await openThread(env, { fromStep: "find", select: "first" }, new Map([["find", search]]));
+        if (!opened.ok) {
+            console.log(JSON.stringify(opened, null, 2));
+            process.exitCode = 1;
+        }
+        else {
+            const read = await readLatest(env, { role: "assistant", format: "normalized_text" });
+            console.log(JSON.stringify({
+                ok: read.ok,
+                status: read.status,
+                title: opened.data?.title,
+                url: opened.context.url,
+                preview: read.data?.text.slice(0, 200),
+                warnings: read.warnings,
+                blocker: read.blocker
+            }, null, 2));
+            process.exitCode = read.ok ? 0 : 1;
+        }
+    }
+}

package/dist/src/testing/parity-suite.d.ts

@@ -0,0 +1,12 @@
+export type ParitySuiteReport = {
+    evidenceMode: "full-repo" | "package-local";
+    surfaceCount: number;
+    fixtureCount: number;
+    commandCount: number;
+    gateCount: number;
+    manifestFixtures: string[];
+    coveredFixtures: string[];
+    sourceCommands: string[];
+    coveredCommands: string[];
+};
+export declare function validateParitySuite(packageRootInput?: URL | string): ParitySuiteReport;

package/dist/src/testing/parity-suite.js

@@ -0,0 +1,213 @@
+import { existsSync, readFileSync, readdirSync } from "node:fs";
+import { dirname, join, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+import ts from "typescript";
+const PARITY_SUITE_SCHEMA_VERSION = "chatgpt.browser_control.parity_suite.v1";
+export function validateParitySuite(packageRootInput = defaultPackageRoot()) {
+    const packageRoot = toPath(packageRootInput);
+    const repoLayout = resolveRepoLayout(packageRoot);
+    const contractRoot = join(packageRoot, "contracts", "v1");
+    const matrixPath = join(contractRoot, "parity-suite.json");
+    const manifestPath = join(contractRoot, "manifest.json");
+    const matrix = readJson(matrixPath);
+    const manifest = readJson(manifestPath);
+    const errors = [];
+    if (matrix.schemaVersion !== PARITY_SUITE_SCHEMA_VERSION) {
+        errors.push(`parity-suite.json has unsupported schemaVersion ${String(matrix.schemaVersion)}.`);
+    }
+    const surfaceIds = new Set(matrix.surfaces.map(surface => surface.id));
+    if (surfaceIds.size !== matrix.surfaces.length) {
+        errors.push("parity-suite.json contains duplicate surface ids.");
+    }
+    const manifestFixtures = sortedUnique(manifest.fixtures.map(fixture => fixture.file));
+    const sourceCommands = readBackendCommands(join(packageRoot, "src", "backend", "protocol.ts"));
+    const coveredFixtures = sortedUnique([
+        ...matrix.surfaces.flatMap(surface => surface.fixtures ?? []),
+        ...Object.values(matrix.backendCommands).flatMap(command => command.fixtures ?? [])
+    ]);
+    const coveredCommands = sortedUnique(Object.keys(matrix.backendCommands));
+    compareSets("fixture coverage", coveredFixtures, manifestFixtures, errors);
+    compareSets("backend command coverage", coveredCommands, sourceCommands, errors);
+    validateSurfaces(matrix.surfaces, surfaceIds, manifestFixtures, packageRoot, repoLayout, errors);
+    validateCommands(matrix.backendCommands, surfaceIds, manifestFixtures, packageRoot, repoLayout, errors);
+    validateGates(matrix.gates, packageRoot, repoLayout, errors);
+    if (errors.length > 0) {
+        throw new Error(`Parity suite validation failed:\n- ${errors.join("\n- ")}`);
+    }
+    return {
+        evidenceMode: repoLayout.fullRepo ? "full-repo" : "package-local",
+        surfaceCount: matrix.surfaces.length,
+        fixtureCount: manifestFixtures.length,
+        commandCount: sourceCommands.length,
+        gateCount: matrix.gates.length,
+        manifestFixtures,
+        coveredFixtures,
+        sourceCommands,
+        coveredCommands
+    };
+}
+function validateSurfaces(surfaces, surfaceIds, manifestFixtures, packageRoot, repoLayout, errors) {
+    for (const surface of surfaces) {
+        const label = `surface ${surface.id}`;
+        if (surface.summary.length === 0)
+            errors.push(`${label} must include a summary.`);
+        validateEvidence(label, surface, surfaceIds, manifestFixtures, packageRoot, repoLayout, errors);
+    }
+}
+function validateCommands(commands, surfaceIds, manifestFixtures, packageRoot, repoLayout, errors) {
+    for (const [command, coverage] of Object.entries(commands)) {
+        const label = `backend command ${command}`;
+        if (!surfaceIds.has(coverage.surface)) {
+            errors.push(`${label} references unknown surface ${coverage.surface}.`);
+        }
+        validateEvidence(label, coverage, surfaceIds, manifestFixtures, packageRoot, repoLayout, errors);
+        if ((coverage.nodeTests ?? []).length === 0)
+            errors.push(`${label} must include nodeTests evidence.`);
+        if ((coverage.pythonTests ?? []).length === 0)
+            errors.push(`${label} must include pythonTests evidence.`);
+        if ((coverage.docs ?? []).length === 0)
+            errors.push(`${label} must include docs evidence.`);
+    }
+}
+function validateEvidence(label, evidence, _surfaceIds, manifestFixtures, packageRoot, repoLayout, errors) {
+    for (const fixture of evidence.fixtures ?? []) {
+        if (!manifestFixtures.includes(fixture)) {
+            errors.push(`${label} references unknown fixture ${fixture}.`);
+        }
+        assertExists(`${label} fixture ${fixture}`, join(packageRoot, "contracts", "v1", "fixtures", fixture), errors);
+    }
+    for (const sourceFile of evidence.sourceFiles ?? []) {
+        assertExists(`${label} source ${sourceFile}`, join(packageRoot, sourceFile), errors);
+    }
+    for (const nodeTest of evidence.nodeTests ?? []) {
+        assertExists(`${label} node test ${nodeTest}`, join(packageRoot, nodeTest), errors);
+    }
+    for (const pythonTest of evidence.pythonTests ?? []) {
+        if (repoLayout.pythonRoot !== undefined) {
+            assertExists(`${label} python test ${pythonTest}`, join(repoLayout.pythonRoot, pythonTest), errors);
+        }
+    }
+    for (const doc of evidence.docs ?? []) {
+        if (!existsAtAny([join(packageRoot, doc), join(repoLayout.repoRoot, doc)])) {
+            if (!repoLayout.fullRepo && doc.startsWith("../")) {
+                continue;
+            }
+            errors.push(`${label} docs ${doc} does not exist.`);
+        }
+    }
+}
+function validateGates(gates, packageRoot, repoLayout, errors) {
+    const ids = new Set();
+    const packageJson = readJson(join(packageRoot, "package.json"));
+    const workflowText = repoLayout.fullRepo ? readWorkflowText(join(repoLayout.repoRoot, ".github", "workflows")) : "";
+    for (const gate of gates) {
+        if (ids.has(gate.id))
+            errors.push(`gate ${gate.id} is duplicated.`);
+        ids.add(gate.id);
+        if (repoLayout.fullRepo) {
+            assertExists(`gate ${gate.id} cwd ${gate.cwd}`, join(repoLayout.repoRoot, gate.cwd), errors);
+        }
+        const script = npmRunScriptName(gate.command);
+        if (script !== undefined && packageJson.scripts?.[script] === undefined) {
+            errors.push(`gate ${gate.id} references missing npm script ${script}.`);
+        }
+        if (repoLayout.fullRepo && gate.ciRequired !== false && !workflowText.includes(gate.command)) {
+            errors.push(`gate ${gate.id} command is missing from chatgpt-sdk-parity.yml: ${gate.command}`);
+        }
+    }
+}
+function readWorkflowText(workflowsDir) {
+    if (!existsSync(workflowsDir))
+        return "";
+    return readdirSync(workflowsDir)
+        .filter(file => /\.(ya?ml)$/i.test(file))
+        .map(file => readFileSync(join(workflowsDir, file), "utf8"))
+        .join("\n");
+}
+function resolveRepoLayout(packageRoot) {
+    const repoRoot = resolve(packageRoot, "..", "..");
+    const packageFromRepoRoot = join(repoRoot, "packages", "node");
+    const pythonFromRepoRoot = join(repoRoot, "packages", "python");
+    if (existsSync(packageFromRepoRoot) && existsSync(pythonFromRepoRoot)) {
+        return { repoRoot, pythonRoot: pythonFromRepoRoot, fullRepo: true };
+    }
+    const siblingPythonRoot = resolve(packageRoot, "..", "python");
+    if (existsSync(siblingPythonRoot)) {
+        return { repoRoot, pythonRoot: siblingPythonRoot, fullRepo: false };
+    }
+    return { repoRoot, fullRepo: false };
+}
+function readBackendCommands(protocolPath) {
+    const sourceText = readFileSync(protocolPath, "utf8");
+    const sourceFile = ts.createSourceFile(protocolPath, sourceText, ts.ScriptTarget.Latest, true, ts.ScriptKind.TS);
+    const commands = [];
+    function visit(node) {
+        if (ts.isVariableStatement(node)) {
+            for (const declaration of node.declarationList.declarations) {
+                if (ts.isIdentifier(declaration.name)
+                    && declaration.name.text === "backendCommands"
+                    && declaration.initializer !== undefined) {
+                    const array = unwrapConstAssertion(declaration.initializer);
+                    if (!ts.isArrayLiteralExpression(array)) {
+                        throw new Error("backendCommands must be declared as an array literal.");
+                    }
+                    for (const element of array.elements) {
+                        if (!ts.isStringLiteral(element)) {
+                            throw new Error("backendCommands may only contain string literals.");
+                        }
+                        commands.push(element.text);
+                    }
+                }
+            }
+        }
+        ts.forEachChild(node, visit);
+    }
+    visit(sourceFile);
+    if (commands.length === 0)
+        throw new Error("Unable to find backendCommands in backend protocol source.");
+    return sortedUnique(commands);
+}
+function unwrapConstAssertion(node) {
+    if (ts.isAsExpression(node))
+        return unwrapConstAssertion(node.expression);
+    return node;
+}
+function compareSets(label, actual, expected, errors) {
+    const actualSet = new Set(actual);
+    const expectedSet = new Set(expected);
+    const missing = expected.filter(item => !actualSet.has(item));
+    const extra = actual.filter(item => !expectedSet.has(item));
+    if (missing.length > 0)
+        errors.push(`${label} missing: ${missing.join(", ")}`);
+    if (extra.length > 0)
+        errors.push(`${label} extra: ${extra.join(", ")}`);
+}
+function assertExists(label, path, errors) {
+    if (!existsSync(path))
+        errors.push(`${label} does not exist at ${path}.`);
+}
+function existsAtAny(paths) {
+    return paths.some(path => existsSync(path));
+}
+function npmRunScriptName(command) {
+    const match = command.match(/^npm run ([^\s]+)$/);
+    if (match !== null)
+        return match[1];
+    if (command === "npm test")
+        return "test";
+    return undefined;
+}
+function sortedUnique(values) {
+    return [...new Set(values)].sort((left, right) => left.localeCompare(right));
+}
+function readJson(path) {
+    return JSON.parse(readFileSync(path, "utf8"));
+}
+function toPath(input) {
+    if (input instanceof URL)
+        return fileURLToPath(input);
+    return input;
+}
+function defaultPackageRoot() {
+    return resolve(dirname(fileURLToPath(import.meta.url)), "..", "..");
+}