codex-chatgpt-control 0.1.0-alpha.1

package/dist/src/backend/protocol.js

@@ -0,0 +1,128 @@
+export const BACKEND_REQUEST_SCHEMA_VERSION = "chatgpt.browser_control.backend_request.v1";
+export const BACKEND_RESPONSE_SCHEMA_VERSION = "chatgpt.browser_control.backend_response.v1";
+export const BACKEND_EVENT_SCHEMA_VERSION = "chatgpt.browser_control.backend_event.v1";
+export const backendCommands = [
+    "backend.version",
+    "backend.health",
+    "backend.capabilities",
+    "runner.run",
+    "runner.plan",
+    "runner.stream",
+    "responses.create",
+    "ask",
+    "askInThread",
+    "askWithFiles",
+    "askAndDownload",
+    "runMessages",
+    "openThread",
+    "readLatest",
+    "copyLatest",
+    "downloadLatest",
+    "runPlan",
+    "doctor",
+    "createReport",
+    "reports.create",
+    "reports.redact",
+    "reports.summarize",
+    "commands",
+    "describe",
+    "help",
+    "session.bootstrap",
+    "threads.new",
+    "threads.search",
+    "threads.open",
+    "messages.compose",
+    "messages.submit",
+    "messages.ask",
+    "messages.wait",
+    "messages.readLatest",
+    "messages.waitAndRead",
+    "files.attach",
+    "files.downloadLatest",
+    "modes.set",
+    "tools.select",
+    "response.copy"
+];
+export class ProtocolError extends Error {
+    code;
+    recoverable;
+    constructor(code, message, recoverable) {
+        super(message);
+        this.code = code;
+        this.recoverable = recoverable;
+        this.name = "ProtocolError";
+    }
+}
+const commandSet = new Set(backendCommands);
+export function parseBackendRequest(raw) {
+    if (!isRecord(raw)) {
+        throw new ProtocolError("invalid_request", "Backend request must be an object.", false);
+    }
+    const schemaVersion = raw.schemaVersion;
+    if (schemaVersion !== BACKEND_REQUEST_SCHEMA_VERSION) {
+        throw new ProtocolError("unsupported_schema_version", `Unsupported backend request schemaVersion: ${String(schemaVersion)}`, false);
+    }
+    const command = raw.command;
+    if (typeof command !== "string" || !commandSet.has(command)) {
+        throw new ProtocolError("unknown_command", `Unknown backend command: ${String(command)}`, false);
+    }
+    const request = {
+        schemaVersion: BACKEND_REQUEST_SCHEMA_VERSION,
+        command: command,
+        payload: normalizePayload(raw.payload)
+    };
+    if (raw.requestId !== undefined) {
+        if (typeof raw.requestId !== "string" || raw.requestId.length === 0) {
+            throw new ProtocolError("invalid_request", "Backend request requestId must be a non-empty string when provided.", false);
+        }
+        request.requestId = raw.requestId;
+    }
+    return request;
+}
+export function backendResponseOk(requestId, result) {
+    const response = {
+        schemaVersion: BACKEND_RESPONSE_SCHEMA_VERSION,
+        ok: true,
+        result
+    };
+    if (requestId !== undefined)
+        response.requestId = requestId;
+    return response;
+}
+export function backendResponseError(requestId, error) {
+    const response = {
+        schemaVersion: BACKEND_RESPONSE_SCHEMA_VERSION,
+        ok: false,
+        error: {
+            code: error instanceof ProtocolError ? error.code : "invalid_request",
+            message: error.message,
+            recoverable: error instanceof ProtocolError ? error.recoverable : false
+        }
+    };
+    if (requestId !== undefined)
+        response.requestId = requestId;
+    return response;
+}
+export function backendEvent(requestId, payload) {
+    const event = {
+        schemaVersion: BACKEND_EVENT_SCHEMA_VERSION,
+        ...payload
+    };
+    if (requestId !== undefined)
+        event.requestId = requestId;
+    return event;
+}
+export function backendEventCompleted(requestId, result) {
+    return backendEvent(requestId, { type: "completed", result });
+}
+function normalizePayload(value) {
+    if (value === undefined)
+        return {};
+    if (!isRecord(value)) {
+        throw new ProtocolError("invalid_request", "Backend request payload must be an object when provided.", false);
+    }
+    return value;
+}
+function isRecord(value) {
+    return value !== null && typeof value === "object" && !Array.isArray(value);
+}

package/dist/src/backend/session.d.ts

@@ -0,0 +1,11 @@
+import { type ChatGPTClientOptions } from "../client.js";
+import { type BackendEvent, type BackendRequest, type BackendResponse } from "./protocol.js";
+export type BackendSessionOptions = ChatGPTClientOptions;
+export declare class BackendSession {
+    private readonly options;
+    private clientInstance;
+    constructor(options?: BackendSessionOptions);
+    dispatch(request: BackendRequest): Promise<BackendResponse>;
+    stream(request: BackendRequest): AsyncIterable<BackendEvent>;
+    private client;
+}

package/dist/src/backend/session.js

@@ -0,0 +1,223 @@
+import { createChatGPT } from "../client.js";
+import { BACKEND_REQUEST_SCHEMA_VERSION, backendCommands, backendResponseError, backendEvent, backendEventCompleted, backendResponseOk, ProtocolError } from "./protocol.js";
+export class BackendSession {
+    options;
+    clientInstance;
+    constructor(options = {}) {
+        this.options = options;
+    }
+    async dispatch(request) {
+        try {
+            const result = await dispatchBackendCommand(this.client(), request);
+            return backendResponseOk(request.requestId, result);
+        }
+        catch (error) {
+            return backendResponseError(request.requestId, error instanceof Error ? error : new Error(String(error)));
+        }
+    }
+    async *stream(request) {
+        try {
+            if (request.command !== "runner.stream") {
+                const response = await this.dispatch(request);
+                if (response.ok) {
+                    yield backendEventCompleted(request.requestId, response.result);
+                }
+                else {
+                    yield backendEvent(request.requestId, { type: "error", error: response.error });
+                }
+                return;
+            }
+            const payload = request.payload;
+            const agent = this.client().agent(agentConfig(payload));
+            const stream = this.client().runner.run(agent, runInput(payload), { stream: true });
+            for await (const event of stream) {
+                yield backendEvent(request.requestId, {
+                    type: "run_item_stream_event",
+                    name: event.name,
+                    item: event.item
+                });
+            }
+            yield backendEventCompleted(request.requestId, await stream.completed);
+        }
+        catch (error) {
+            const protocolError = error instanceof ProtocolError
+                ? error
+                : new ProtocolError("invalid_request", error instanceof Error ? error.message : String(error), false);
+            yield backendEvent(request.requestId, {
+                type: "error",
+                error: {
+                    code: protocolError.code,
+                    message: protocolError.message,
+                    recoverable: protocolError.recoverable
+                }
+            });
+        }
+    }
+    client() {
+        this.clientInstance ??= createChatGPT(this.options);
+        return this.clientInstance;
+    }
+}
+async function dispatchBackendCommand(client, request) {
+    const payload = request.payload;
+    switch (request.command) {
+        case "backend.version":
+            return {
+                name: "codex-chatgpt-control-backend",
+                runtime: "node",
+                protocolVersion: BACKEND_REQUEST_SCHEMA_VERSION
+            };
+        case "backend.health":
+            return {
+                ok: true,
+                status: "ok",
+                timestamp: new Date().toISOString()
+            };
+        case "backend.capabilities":
+            return backendCapabilities();
+        case "runner.run": {
+            const agent = client.agent(agentConfig(payload));
+            return client.runner.run(agent, runInput(payload));
+        }
+        case "runner.plan": {
+            const agent = client.agent(agentConfig(payload));
+            return client.runner.plan(agent, runInput(payload));
+        }
+        case "responses.create":
+            return client.responses.create(payload);
+        case "commands":
+            return client.commands(commandFilter(payload));
+        case "describe":
+            return client.describe(requiredString(payload, "name"));
+        case "help":
+            return client.help(optionalString(payload, "topic"));
+        case "doctor":
+            return client.doctor(payload);
+        case "ask":
+            return client.ask(payload);
+        case "askInThread":
+            return client.askInThread(payload);
+        case "askWithFiles":
+            return client.askWithFiles(payload);
+        case "askAndDownload":
+            return client.askAndDownload(payload);
+        case "runMessages":
+            return client.runMessages(payload);
+        case "openThread":
+            return client.openThread(payload);
+        case "readLatest":
+            return client.readLatest(emptyToUndefined(payload));
+        case "copyLatest":
+            return client.copyLatest(emptyToUndefined(payload));
+        case "downloadLatest":
+            return client.downloadLatest(payload);
+        case "runPlan":
+            return client.runPlan(runPlanPayload(payload));
+        case "createReport":
+            return client.createReport(requiredRecord(payload, "result"), optionalRecord(payload, "args"));
+        case "reports.create":
+            return client.reports.create(requiredRecord(payload, "result"), optionalRecord(payload, "args"));
+        case "reports.redact":
+            return client.reports.redact(payload.value, optionalRecord(payload, "args"));
+        case "reports.summarize":
+            return client.reports.summarize(requiredRecord(payload, "result"), optionalRecord(payload, "args"));
+        case "session.bootstrap":
+            return client.session.bootstrap(emptyToUndefined(payload));
+        case "threads.new":
+            return client.threads.new(emptyToUndefined(payload));
+        case "threads.search":
+            return client.threads.search(payload);
+        case "threads.open":
+            return client.threads.open(payload);
+        case "messages.compose":
+            return client.messages.compose(payload);
+        case "messages.submit":
+            return client.messages.submit(emptyToUndefined(payload));
+        case "messages.ask":
+            return client.messages.ask(payload);
+        case "messages.wait":
+            return client.messages.wait(emptyToUndefined(payload));
+        case "messages.readLatest":
+            return client.messages.readLatest(emptyToUndefined(payload));
+        case "messages.waitAndRead":
+            return client.messages.waitAndRead(payload);
+        case "files.attach":
+            return client.files.attach(payload);
+        case "files.downloadLatest":
+            return client.files.downloadLatest(payload);
+        case "modes.set":
+            return client.modes.set(payload);
+        case "tools.select":
+            return client.tools.select(payload);
+        case "response.copy":
+            return client.response.copy(emptyToUndefined(payload));
+    }
+}
+function backendCapabilities() {
+    return {
+        protocolVersion: BACKEND_REQUEST_SCHEMA_VERSION,
+        commands: [...backendCommands],
+        transports: ["stdio"],
+        streaming: {
+            modes: ["ndjson"],
+            tokenDeltas: false
+        }
+    };
+}
+function agentConfig(payload) {
+    return requiredRecord(payload, "agent");
+}
+function runInput(payload) {
+    if (!Object.hasOwn(payload, "input")) {
+        throw new ProtocolError("invalid_request", "Backend runner command requires payload.input.", false);
+    }
+    return payload.input;
+}
+function runPlanPayload(payload) {
+    if (isRecord(payload.plan))
+        return payload.plan;
+    return payload;
+}
+function commandFilter(payload) {
+    if (isRecord(payload.filter))
+        return payload.filter;
+    return Object.keys(payload).length === 0 ? undefined : payload;
+}
+function requiredString(payload, key) {
+    const value = payload[key];
+    if (typeof value !== "string" || value.length === 0) {
+        throw new ProtocolError("invalid_request", `Backend command requires payload.${key} as a non-empty string.`, false);
+    }
+    return value;
+}
+function optionalString(payload, key) {
+    const value = payload[key];
+    if (value === undefined)
+        return undefined;
+    if (typeof value !== "string") {
+        throw new ProtocolError("invalid_request", `Backend command payload.${key} must be a string when provided.`, false);
+    }
+    return value;
+}
+function requiredRecord(payload, key) {
+    const value = payload[key];
+    if (!isRecord(value)) {
+        throw new ProtocolError("invalid_request", `Backend command requires payload.${key} as an object.`, false);
+    }
+    return value;
+}
+function optionalRecord(payload, key) {
+    const value = payload[key];
+    if (value === undefined)
+        return undefined;
+    if (!isRecord(value)) {
+        throw new ProtocolError("invalid_request", `Backend command payload.${key} must be an object when provided.`, false);
+    }
+    return value;
+}
+function emptyToUndefined(payload) {
+    return Object.keys(payload).length === 0 ? undefined : payload;
+}
+function isRecord(value) {
+    return value !== null && typeof value === "object" && !Array.isArray(value);
+}

package/dist/src/backend/stdio-server.d.ts

@@ -0,0 +1,9 @@
+import type { Readable, Writable } from "node:stream";
+import { BackendSession } from "./session.js";
+export type BackendStdioServerOptions = {
+    input: Readable;
+    output: Writable;
+    error?: Writable;
+    session?: BackendSession;
+};
+export declare function runBackendStdioServer(options: BackendStdioServerOptions): Promise<void>;

package/dist/src/backend/stdio-server.js

@@ -0,0 +1,88 @@
+import { createInterface } from "node:readline";
+import { BackendSession } from "./session.js";
+import { backendResponseError, parseBackendRequest, ProtocolError } from "./protocol.js";
+export async function runBackendStdioServer(options) {
+    const session = options.session ?? new BackendSession();
+    const lines = createInterface({
+        input: options.input,
+        crlfDelay: Infinity
+    });
+    const writeJson = createJsonLineWriter(options.output);
+    const tasks = new Set();
+    for await (const line of lines) {
+        const trimmed = line.trim();
+        if (trimmed.length === 0)
+            continue;
+        const task = handleLine(session, trimmed, writeJson, options.error);
+        tasks.add(task);
+        void task.finally(() => {
+            tasks.delete(task);
+        }).catch(() => { });
+    }
+    await Promise.allSettled(tasks);
+}
+async function handleLine(session, line, writeJson, error) {
+    let request;
+    try {
+        const raw = JSON.parse(line);
+        request = parseBackendRequest(raw);
+        if (request.command === "runner.stream") {
+            for await (const event of session.stream(request)) {
+                await writeJson(event);
+            }
+            return;
+        }
+        await writeJson(await session.dispatch(request));
+    }
+    catch (caught) {
+        const response = backendResponseError(request?.requestId ?? requestIdFromLine(line), normalizeError(caught));
+        await writeJson(response);
+        if (!(caught instanceof ProtocolError)) {
+            await writeDiagnostic(error, caught);
+        }
+    }
+}
+function normalizeError(error) {
+    if (error instanceof SyntaxError) {
+        return new ProtocolError("invalid_request", `Invalid JSON backend request line: ${error.message}`, false);
+    }
+    if (error instanceof Error)
+        return error;
+    return new ProtocolError("invalid_request", String(error), false);
+}
+function requestIdFromLine(line) {
+    try {
+        const parsed = JSON.parse(line);
+        if (isRecord(parsed) && typeof parsed.requestId === "string" && parsed.requestId.length > 0) {
+            return parsed.requestId;
+        }
+    }
+    catch {
+        return undefined;
+    }
+    return undefined;
+}
+function createJsonLineWriter(output) {
+    let tail = Promise.resolve();
+    return value => {
+        const next = tail.then(() => writeLine(output, JSON.stringify(value)));
+        tail = next.catch(() => { });
+        return next;
+    };
+}
+async function writeDiagnostic(error, value) {
+    if (error === undefined)
+        return;
+    const message = value instanceof Error ? `${value.name}: ${value.message}` : String(value);
+    await writeLine(error, message);
+}
+async function writeLine(output, line) {
+    if (output.write(`${line}\n`))
+        return;
+    await new Promise(resolve => {
+        output.once("drain", resolve);
+    });
+}
+function isRecord(value) {
+    return value !== null && typeof value === "object" && !Array.isArray(value);
+}

package/dist/src/browser/attach.d.ts

@@ -0,0 +1,8 @@
+import type { BootstrapArgs, BrowserLike, PageLike, RuntimeEnv } from "../types.js";
+export type AttachedBrowser = {
+    browser: BrowserLike;
+    page: PageLike;
+    browserName: string;
+    tabId?: string;
+};
+export declare function attachChatGPTBrowser(env: RuntimeEnv, args?: BootstrapArgs): Promise<AttachedBrowser>;