codex-chatgpt-control 0.1.0-alpha.1

package/dist/src/commands/confirmations.js

@@ -0,0 +1,33 @@
+export function requireConfirmation(confirm, expected) {
+    if (confirm?.understood === true
+        && confirm.targetKind === expected.targetKind
+        && confirm.targetDisplayName === expected.targetDisplayName
+        && confirm.action === expected.action) {
+        return undefined;
+    }
+    return {
+        ok: false,
+        status: "needs_confirmation",
+        warnings: [],
+        blocker: {
+            kind: "confirmation",
+            message: `Confirmation required before ${expected.action} on ${expected.targetKind} "${expected.targetDisplayName}".`
+        },
+        context: { timestamp: new Date().toISOString() }
+    };
+}
+export function rejectNetworkCommand(command) {
+    if (!command.startsWith("network.")) {
+        return undefined;
+    }
+    return {
+        ok: false,
+        status: "unsupported",
+        warnings: [],
+        blocker: {
+            kind: "confirmation",
+            message: "Private ChatGPT network replay commands are intentionally unsupported."
+        },
+        context: { timestamp: new Date().toISOString() }
+    };
+}

package/dist/src/commands/context.d.ts

@@ -0,0 +1,2 @@
+import type { CommandContext, PageLike } from "../types.js";
+export declare function contextFromPage(page: PageLike | undefined, partial?: Partial<CommandContext>): Promise<CommandContext>;

package/dist/src/commands/context.js

@@ -0,0 +1,32 @@
+import { countPageMessages } from "../dom/messages.js";
+import { parseConversationId } from "../browser/page-state.js";
+export async function contextFromPage(page, partial = {}) {
+    if (page === undefined) {
+        return { timestamp: new Date().toISOString(), ...partial };
+    }
+    const url = typeof page.url === "function" ? await Promise.resolve(page.url()).catch(() => partial.url) : partial.url;
+    const title = typeof page.title === "function" ? await page.title().catch(() => undefined) : partial.title;
+    const turnCount = await countPageMessages(page).catch(() => partial.turnCount);
+    const assistantTurnCount = await countPageMessages(page, "assistant").catch(() => partial.assistantTurnCount);
+    const conversationId = url !== undefined ? parseConversationId(url) : partial.conversationId;
+    const context = {
+        timestamp: new Date().toISOString(),
+        ...partial
+    };
+    if (url !== undefined) {
+        context.url = url;
+    }
+    if (title !== undefined) {
+        context.title = title;
+    }
+    if (turnCount !== undefined) {
+        context.turnCount = turnCount;
+    }
+    if (assistantTurnCount !== undefined) {
+        context.assistantTurnCount = assistantTurnCount;
+    }
+    if (conversationId !== undefined) {
+        context.conversationId = conversationId;
+    }
+    return context;
+}

package/dist/src/commands/doctor.d.ts

@@ -0,0 +1,16 @@
+import type { CommandResult, RuntimeEnv } from "../types.js";
+export type DoctorCheckName = "bridge" | "login" | "upload" | "download" | "clipboard" | "modes" | "tools" | "selectors";
+export type CapabilityStatus = "ok" | "blocked" | "unsupported" | "unknown";
+export type CapabilityCheck = {
+    status: CapabilityStatus;
+    message: string;
+    remediation?: string[];
+};
+export type DoctorArgs = {
+    check?: DoctorCheckName[];
+};
+export type DoctorReport = {
+    ready: boolean;
+    checks: Partial<Record<DoctorCheckName, CapabilityCheck>>;
+};
+export declare function doctor(env: RuntimeEnv, args?: DoctorArgs): Promise<CommandResult<DoctorReport>>;

package/dist/src/commands/doctor.js

@@ -0,0 +1,120 @@
+import { readSystemClipboard } from "../browser/clipboard.js";
+import { readPageState } from "../browser/page-state.js";
+import { BROWSER_BRIDGE_REMEDIATION, resultOk } from "../errors.js";
+import { contextFromPage } from "./context.js";
+import { bootstrap } from "./session.js";
+const DEFAULT_CHECKS = ["bridge", "login", "upload", "download", "clipboard", "modes", "tools", "selectors"];
+const UPLOAD_REMEDIATION = [
+    "Codex Settings > Computer Use > Chrome > Permissions > Uploads: set to Always allow, or add chatgpt.com to the allowed upload domains.",
+    "Chrome chrome://extensions > Codex extension > Details: enable Allow access to file URLs."
+];
+export async function doctor(env, args = {}) {
+    const wanted = args.check ?? DEFAULT_CHECKS;
+    const checks = {};
+    const boot = await bootstrap(env, { preferExistingTab: true, timeoutMs: 30000 });
+    for (const check of wanted) {
+        switch (check) {
+            case "bridge":
+                checks.bridge = boot.ok
+                    ? ok("Chrome bridge is available.")
+                    : bridgeCheck(boot);
+                break;
+            case "login":
+                checks.login = await loginCheck(env, boot);
+                break;
+            case "upload":
+                checks.upload = uploadCheck(env);
+                break;
+            case "download":
+                checks.download = downloadCheck(env);
+                break;
+            case "clipboard":
+                checks.clipboard = await clipboardCheck();
+                break;
+            case "modes":
+                checks.modes = selectorCheck(env, "Mode/tool selection requires role/text selectors in the current ChatGPT page.");
+                break;
+            case "tools":
+                checks.tools = selectorCheck(env, "Tool selection requires role/text selectors in the current ChatGPT page.");
+                break;
+            case "selectors":
+                checks.selectors = selectorCheck(env, "Basic page selectors are available.");
+                break;
+        }
+    }
+    const ready = Object.values(checks).every(check => check?.status === "ok" || check?.status === "unknown");
+    return resultOk({ ready, checks }, await contextFromPage(env.page));
+}
+function bridgeCheck(boot) {
+    if (boot.blocker?.kind === "browser_bridge_unavailable") {
+        return blocked(boot.blocker.message, bridgeRemediation(boot));
+    }
+    if (boot.blocker?.kind === "login_required") {
+        return ok("Chrome bridge is available; ChatGPT login is required before browser-control commands can continue.");
+    }
+    if (boot.blocker !== undefined) {
+        return unknown(`Chrome bridge responded, but bootstrap is blocked by ${boot.blocker.kind}: ${boot.blocker.message}`);
+    }
+    return blocked(boot.error?.message ?? "Chrome bridge is unavailable.");
+}
+async function loginCheck(env, boot) {
+    if (!boot.ok && boot.blocker?.kind === "login_required") {
+        return blocked("ChatGPT login is required.", ["Ask the user to sign in to ChatGPT in Chrome, then retry."]);
+    }
+    if (env.page === undefined) {
+        return boot.ok ? ok("Bootstrap completed; login appears usable.") : blocked("Cannot determine login because bootstrap failed.");
+    }
+    const state = await readPageState(env.page).catch(() => undefined);
+    if (state?.blocker?.kind === "login_required") {
+        return blocked("ChatGPT login is required.", ["Ask the user to sign in to ChatGPT in Chrome, then retry."]);
+    }
+    return state?.signedIn === true ? ok("ChatGPT appears signed in.") : unknown("Could not prove signed-in state from the visible page.");
+}
+function uploadCheck(env) {
+    const page = env.page;
+    if (page === undefined) {
+        return unknown("Upload readiness requires a bootstrapped ChatGPT page.", UPLOAD_REMEDIATION);
+    }
+    if (typeof page.waitForEvent !== "function" && typeof page.evaluate !== "function") {
+        return blocked("The active browser page exposes no upload-capable file chooser or DOM fallback.", UPLOAD_REMEDIATION);
+    }
+    return unknown("Upload permissions can only be proven by a live attach attempt.", UPLOAD_REMEDIATION);
+}
+function downloadCheck(env) {
+    const page = env.page;
+    if (page === undefined)
+        return unknown("Download readiness requires a bootstrapped ChatGPT page.");
+    return typeof page.waitForEvent === "function"
+        ? ok("Browser download events are available.")
+        : unsupported("The active browser page does not expose download events.");
+}
+async function clipboardCheck() {
+    const value = await readSystemClipboard();
+    return value === undefined
+        ? unknown("System clipboard could not be read; response.copy will use DOM fallback if copy does not change.")
+        : ok("System clipboard can be read.");
+}
+function selectorCheck(env, message) {
+    const page = env.page;
+    if (page === undefined)
+        return unknown("Selector readiness requires a bootstrapped ChatGPT page.");
+    return typeof page.locator === "function" || typeof page.getByRole === "function"
+        ? ok(message)
+        : unsupported("The active page object does not expose locator or role selector helpers.");
+}
+function bridgeRemediation(boot) {
+    const remediation = boot.blocker?.remediation ?? BROWSER_BRIDGE_REMEDIATION;
+    return remediation.map(step => `${step.label}: ${step.instruction}`);
+}
+function ok(message) {
+    return { status: "ok", message };
+}
+function blocked(message, remediation) {
+    return remediation === undefined ? { status: "blocked", message } : { status: "blocked", message, remediation };
+}
+function unsupported(message, remediation) {
+    return remediation === undefined ? { status: "unsupported", message } : { status: "unsupported", message, remediation };
+}
+function unknown(message, remediation) {
+    return remediation === undefined ? { status: "unknown", message } : { status: "unknown", message, remediation };
+}

package/dist/src/commands/files.d.ts

@@ -0,0 +1,4 @@
+import type { AttachedFile, AttachFilesArgs, AttachFilesData, CommandResult, DownloadedFile, DownloadLatestArgs, RuntimeEnv } from "../types.js";
+export declare function validateAttachPaths(paths: string[]): Promise<AttachedFile[]>;
+export declare function attachFiles(env: RuntimeEnv, args: AttachFilesArgs): Promise<CommandResult<AttachFilesData>>;
+export declare function downloadLatestFile(env: RuntimeEnv, args: DownloadLatestArgs): Promise<CommandResult<DownloadedFile>>;

package/dist/src/commands/files.js

@@ -0,0 +1,314 @@
+import { access, readFile, stat } from "node:fs/promises";
+import { basename, resolve } from "node:path";
+import { constants } from "node:fs";
+import { waitForDownloadFromClick } from "../browser/downloads.js";
+import { resultError, resultOk } from "../errors.js";
+import { addFilesButton, cssSelectors, requiredLocator } from "../dom/selectors.js";
+import { contextFromPage } from "./context.js";
+import { bootstrap } from "./session.js";
+const CODEX_UPLOAD_PERMISSION_FIX = "Codex Settings > Computer Use > Chrome > Permissions > Uploads: set to Always allow, or add chatgpt.com to the allowed upload domains.";
+const CHROME_FILE_URL_PERMISSION_FIX = "Chrome chrome://extensions > Codex extension > Details: enable Allow access to file URLs.";
+export async function validateAttachPaths(paths) {
+    const files = [];
+    for (const path of paths) {
+        if (!path.startsWith("/")) {
+            throw new Error(`File attachment path must be absolute: ${path}`);
+        }
+        const absolute = resolve(path);
+        await access(absolute, constants.R_OK);
+        const fileStat = await stat(absolute);
+        if (!fileStat.isFile()) {
+            throw new Error(`Attachment path is not a file: ${absolute}`);
+        }
+        files.push({
+            path: absolute,
+            name: basename(absolute),
+            bytes: fileStat.size
+        });
+    }
+    return files;
+}
+export async function attachFiles(env, args) {
+    const boot = await ensurePage(env);
+    if (!boot.ok) {
+        return boot;
+    }
+    const page = env.page;
+    try {
+        const files = await validateAttachPaths(args.paths);
+        await uploadFiles(page, files, args.timeoutMs ?? 30000);
+        await page.waitForTimeout?.(args.timeoutMs === undefined ? 1000 : Math.min(args.timeoutMs, 3000));
+        return resultOk({ files }, await contextFromPage(page));
+    }
+    catch (error) {
+        if (isUploadBridgeBlocker(error)) {
+            return {
+                ok: false,
+                status: "blocked",
+                warnings: [],
+                blocker: {
+                    kind: "permission",
+                    code: "upload_permission_required",
+                    message: uploadPermissionMessage(error),
+                    visibleText: uploadPermissionDetails(error),
+                    remediation: uploadPermissionRemediation(),
+                    resumable: true
+                },
+                context: await contextFromPage(page)
+            };
+        }
+        return resultError(error instanceof Error ? error : new Error(String(error)), await contextFromPage(page));
+    }
+}
+async function uploadFiles(page, files, timeoutMs) {
+    const paths = files.map(file => file.path);
+    const errors = [];
+    const attempts = [
+        {
+            name: "visible-chatgpt-file-input",
+            run: async () => {
+                await clickFileChooserTarget(page, "#upload-files", paths, timeoutMs, { requireVisible: true });
+            }
+        },
+        {
+            name: "add-photos-files-menu-item",
+            run: async () => {
+                await clickChatGPTAddPhotosMenuItem(page, paths, timeoutMs);
+            }
+        },
+        {
+            name: "generic-add-files-button",
+            run: async () => {
+                await clickFileChooserLocator(page, addFilesButton(page), paths, timeoutMs);
+            }
+        },
+        {
+            name: "direct-file-input-set",
+            run: async () => {
+                await setHiddenFileInput(page, files);
+            }
+        }
+    ];
+    for (const attempt of attempts) {
+        try {
+            await attempt.run();
+            return;
+        }
+        catch (error) {
+            errors.push(`${attempt.name}: ${error instanceof Error ? error.message : String(error)}`);
+        }
+    }
+    throw new Error(`No ChatGPT upload path completed.\n${errors.join("\n")}`);
+}
+async function clickChatGPTAddPhotosMenuItem(page, paths, timeoutMs) {
+    const menuItem = requiredLocator(page, "div[role='menuitem']").filter?.({ hasText: "Add photos & files" });
+    if (await locatorCount(menuItem) !== 1) {
+        const plusButton = requiredLocator(page, "#composer-plus-btn, button[aria-label='Add files and more']");
+        if (await locatorCount(plusButton) !== 1) {
+            throw new Error("ChatGPT Add files button was not uniquely available.");
+        }
+        await plusButton.click?.({ timeoutMs: Math.min(timeoutMs, 10000) });
+        await page.waitForTimeout?.(250);
+    }
+    const refreshedMenuItem = requiredLocator(page, "div[role='menuitem']").filter?.({ hasText: "Add photos & files" });
+    await clickFileChooserLocator(page, refreshedMenuItem, paths, timeoutMs);
+}
+async function clickFileChooserTarget(page, selector, paths, timeoutMs, options = {}) {
+    const locator = requiredLocator(page, selector);
+    if (await locatorCount(locator) !== 1) {
+        throw new Error(`Upload target was not uniquely available: ${selector}`);
+    }
+    if (options.requireVisible === true && locator.isVisible !== undefined && !await locator.isVisible({ timeoutMs: 1000 })) {
+        throw new Error(`Upload target is hidden: ${selector}`);
+    }
+    await clickFileChooserLocator(page, locator, paths, timeoutMs);
+}
+async function clickFileChooserLocator(page, locator, paths, timeoutMs) {
+    if (locator === undefined) {
+        throw new Error("Upload locator was not available.");
+    }
+    if (typeof page.waitForEvent !== "function") {
+        throw new Error("The active browser page does not expose file chooser events.");
+    }
+    if (typeof locator.click !== "function") {
+        throw new Error("Upload locator does not expose click().");
+    }
+    const chooserPromise = waitForFileChooser(page, timeoutMs);
+    try {
+        await locator.click({ timeoutMs: Math.min(timeoutMs, 10000) });
+    }
+    catch (error) {
+        await chooserPromise.catch(() => undefined);
+        throw error;
+    }
+    const chooser = await chooserPromise;
+    await validateChooserMultiplicity(chooser, paths);
+    try {
+        await chooser.setFiles(paths);
+    }
+    catch (error) {
+        throw new Error(`fileChooser.setFiles failed. ${error instanceof Error ? error.message : String(error)}`);
+    }
+}
+async function waitForFileChooser(page, timeoutMs) {
+    const rawChooser = await page.waitForEvent?.("filechooser", {
+        timeout: timeoutMs,
+        timeoutMs
+    });
+    if (!isFileChooserLike(rawChooser)) {
+        throw new Error("File chooser event did not return a setFiles-capable chooser.");
+    }
+    return rawChooser;
+}
+async function validateChooserMultiplicity(chooser, paths) {
+    if (paths.length <= 1 || typeof chooser.isMultiple !== "function") {
+        return;
+    }
+    const isMultiple = await chooser.isMultiple();
+    if (!isMultiple) {
+        throw new Error("The active ChatGPT file chooser only accepts one file.");
+    }
+}
+function isFileChooserLike(value) {
+    return value !== null
+        && typeof value === "object"
+        && typeof value.setFiles === "function";
+}
+async function locatorCount(locator) {
+    if (locator === undefined || typeof locator.count !== "function") {
+        return 0;
+    }
+    return locator.count();
+}
+export async function downloadLatestFile(env, args) {
+    const boot = await ensurePage(env);
+    if (!boot.ok) {
+        return boot;
+    }
+    const page = env.page;
+    try {
+        const controls = requiredLocator(page, cssSelectors.downloadControls);
+        const count = await controls.count?.();
+        if (count === 0) {
+            return {
+                ok: false,
+                status: "unsupported",
+                warnings: [],
+                blocker: {
+                    kind: "download_unavailable",
+                    message: "No visible ChatGPT download control was found."
+                },
+                context: await contextFromPage(page)
+            };
+        }
+        const target = args.from === "visible_conversation" ? controls.last?.() ?? controls : controls.last?.() ?? controls;
+        const downloaded = await waitForDownloadFromClick(page, async () => {
+            await target.click?.();
+        }, args.destDir, args.timeoutMs ?? 120000);
+        return resultOk(downloaded, await contextFromPage(page));
+    }
+    catch (error) {
+        return resultError(error instanceof Error ? error : new Error(String(error)), await contextFromPage(page));
+    }
+}
+async function setHiddenFileInput(page, files) {
+    if (page === undefined) {
+        throw new Error("No active page is available for file upload.");
+    }
+    const input = requiredLocator(page, cssSelectors.hiddenFileInputs).last?.() ?? requiredLocator(page, cssSelectors.hiddenFileInputs);
+    if (typeof input.setInputFiles !== "function") {
+        await setFilesViaDomDataTransfer(page, files);
+        return;
+    }
+    await input.setInputFiles(files.map(file => file.path));
+}
+async function ensurePage(env) {
+    if (env.page !== undefined) {
+        return resultOk({}, await contextFromPage(env.page));
+    }
+    return bootstrap(env, { preferExistingTab: true });
+}
+async function setFilesViaDomDataTransfer(page, files) {
+    const totalBytes = files.reduce((sum, file) => sum + file.bytes, 0);
+    const maxInlineBytes = 25 * 1024 * 1024;
+    if (totalBytes > maxInlineBytes) {
+        throw new Error(`No file chooser or setInputFiles support is available for large uploads. ${CODEX_UPLOAD_PERMISSION_FIX} ${CHROME_FILE_URL_PERMISSION_FIX}`);
+    }
+    if (typeof page.evaluate !== "function") {
+        throw new Error(`No file chooser, setInputFiles, or page.evaluate support is available for file upload. ${CODEX_UPLOAD_PERMISSION_FIX} ${CHROME_FILE_URL_PERMISSION_FIX}`);
+    }
+    const payload = await Promise.all(files.map(async (file) => ({
+        name: file.name,
+        bytesBase64: (await readFile(file.path)).toString("base64"),
+        type: guessMimeType(file.name)
+    })));
+    await page.evaluate(async (payload) => {
+        const input = (document.querySelector("#upload-files") || document.querySelector("input[type='file']:not([accept='image/*'])") || document.querySelector("input[type='file']"));
+        if (!input) {
+            throw new Error("No ChatGPT file input found in the DOM.");
+        }
+        const dataTransfer = new DataTransfer();
+        for (const item of payload) {
+            const binary = atob(item.bytesBase64);
+            const bytes = new Uint8Array(binary.length);
+            for (let index = 0; index < binary.length; index += 1) {
+                bytes[index] = binary.charCodeAt(index);
+            }
+            dataTransfer.items.add(new File([bytes], item.name, { type: item.type }));
+        }
+        input.files = dataTransfer.files;
+        input.dispatchEvent(new Event("input", { bubbles: true }));
+        input.dispatchEvent(new Event("change", { bubbles: true }));
+    }, payload);
+}
+function guessMimeType(name) {
+    if (/\.txt$/i.test(name))
+        return "text/plain";
+    if (/\.pdf$/i.test(name))
+        return "application/pdf";
+    if (/\.csv$/i.test(name))
+        return "text/csv";
+    if (/\.json$/i.test(name))
+        return "application/json";
+    if (/\.md$/i.test(name))
+        return "text/markdown";
+    return "application/octet-stream";
+}
+function isUploadBridgeBlocker(error) {
+    const message = error instanceof Error ? error.message : String(error);
+    return /DataTransfer is not a constructor|No file chooser|setInputFiles|Allow access to file URLs|file upload|fileChooser\.setFiles failed|Not allowed|No ChatGPT upload path completed/i.test(message);
+}
+function uploadPermissionMessage(error) {
+    const message = error instanceof Error ? error.message : String(error);
+    if (/fileChooser\.setFiles failed|Not allowed/i.test(message)) {
+        return `ChatGPT's file chooser opened, but Chrome refused the local file handoff. Ask the user to enable both upload permission gates, then retry: ${CODEX_UPLOAD_PERMISSION_FIX} ${CHROME_FILE_URL_PERMISSION_FIX}`;
+    }
+    if (/Browser Use rejected|requested that files not be uploaded|upload files|permission denied|browser blocked/i.test(message)) {
+        return `Codex/Chrome upload permission is blocking file attachment. Ask the user to enable both upload permission gates, then retry: ${CODEX_UPLOAD_PERMISSION_FIX} ${CHROME_FILE_URL_PERMISSION_FIX}`;
+    }
+    return `File upload is not available until both upload permission gates are enabled. Ask the user to enable them, then retry: ${CODEX_UPLOAD_PERMISSION_FIX} ${CHROME_FILE_URL_PERMISSION_FIX}`;
+}
+function uploadPermissionDetails(error) {
+    const message = error instanceof Error ? error.message : String(error);
+    return [
+        "Upload permission troubleshooting:",
+        `1. ${CODEX_UPLOAD_PERMISSION_FIX}`,
+        `2. ${CHROME_FILE_URL_PERMISSION_FIX}`,
+        "Observed failure:",
+        message
+    ].join("\n");
+}
+function uploadPermissionRemediation() {
+    return [
+        {
+            label: "Codex Chrome uploads",
+            instruction: CODEX_UPLOAD_PERMISSION_FIX,
+            userActionRequired: true
+        },
+        {
+            label: "Chrome file URLs",
+            instruction: CHROME_FILE_URL_PERMISSION_FIX,
+            userActionRequired: true
+        }
+    ];
+}

package/dist/src/commands/helpers.d.ts

@@ -0,0 +1,16 @@
+import type { AskHelperArgs, AskInThreadArgs, AttachAskReadArgs, CommandResult, DownloadLatestArgs, PrecannedResponseArgs, RuntimeEnv, SearchOpenCopyArgs, SendAndWaitArgs, SequencePlan, TwoTurnExchangeArgs } from "../types.js";
+export declare function planAsk(args: AskHelperArgs): SequencePlan;
+export declare function planAskInThread(args: AskInThreadArgs): SequencePlan;
+export declare function planAttachAskRead(args: AttachAskReadArgs): SequencePlan;
+export declare function planDownloadLatestAttachment(args: DownloadLatestArgs): SequencePlan;
+export declare function planSearchOpenCopyLatest(args: SearchOpenCopyArgs): SequencePlan;
+export declare function planTwoTurnExchange(args: TwoTurnExchangeArgs): SequencePlan;
+export declare function ask(args: AskHelperArgs, env?: RuntimeEnv): Promise<CommandResult<unknown>>;
+export declare function askInThread(args: AskInThreadArgs, env?: RuntimeEnv): Promise<CommandResult<unknown>>;
+export declare function findSwitchAskWaitRead(args: AskInThreadArgs, env?: RuntimeEnv): Promise<CommandResult<unknown>>;
+export declare function sendAndWait(args: SendAndWaitArgs, env?: RuntimeEnv): Promise<CommandResult<unknown>>;
+export declare function sendPrecannedResponse(args: PrecannedResponseArgs, env?: RuntimeEnv): Promise<CommandResult<unknown>>;
+export declare function attachAskRead(args: AttachAskReadArgs, env?: RuntimeEnv): Promise<CommandResult<unknown>>;
+export declare function downloadLatestAttachment(args: DownloadLatestArgs, env?: RuntimeEnv): Promise<CommandResult<unknown>>;
+export declare function searchOpenCopyLatest(args: SearchOpenCopyArgs, env?: RuntimeEnv): Promise<CommandResult<unknown>>;
+export declare function twoTurnExchange(args: TwoTurnExchangeArgs, env?: RuntimeEnv): Promise<CommandResult<unknown>>;

package/dist/src/commands/helpers.js

@@ -0,0 +1,128 @@
+import { runSequence } from "./sequence.js";
+export function planAsk(args) {
+    const steps = [
+        { id: "bootstrap", command: "session.bootstrap" }
+    ];
+    if (args.thread !== undefined) {
+        steps.push(...threadOpenSteps(args.thread));
+    }
+    steps.push({ id: "ask", command: "messages.ask", args: askStepArgs(args) });
+    return { name: "ask", steps };
+}
+export function planAskInThread(args) {
+    return {
+        name: "ask-in-thread",
+        policy: {
+            stopOnError: true,
+            returnPartial: true,
+            allowPromptResubmit: "only_if_no_matching_user_turn"
+        },
+        steps: [
+            { id: "bootstrap", command: "session.bootstrap" },
+            ...threadOpenSteps(args.thread),
+            { id: "ask", command: "messages.ask", args: askStepArgs(args) }
+        ]
+    };
+}
+export function planAttachAskRead(args) {
+    return {
+        name: "attach-ask-read",
+        policy: { stopOnError: true, returnPartial: true },
+        steps: [
+            { id: "bootstrap", command: "session.bootstrap" },
+            ...threadOpenSteps(args.thread),
+            { id: "attach", command: "files.attach", args: { paths: args.files } },
+            { id: "ask", command: "messages.ask", args: { text: args.text, wait: args.wait ?? true, read: args.read ?? true } }
+        ]
+    };
+}
+export function planDownloadLatestAttachment(args) {
+    return {
+        name: "download-latest-attachment",
+        steps: [
+            { id: "bootstrap", command: "session.bootstrap" },
+            { id: "download", command: "files.downloadLatest", args }
+        ]
+    };
+}
+export function planSearchOpenCopyLatest(args) {
+    return {
+        name: "search-open-copy-latest",
+        steps: [
+            { id: "bootstrap", command: "session.bootstrap" },
+            ...threadOpenSteps(args.thread),
+            { id: "copy", command: "response.copy", args: { which: "latest" } }
+        ]
+    };
+}
+export function planTwoTurnExchange(args) {
+    return {
+        name: "two-turn-exchange",
+        policy: { stopOnError: true, returnPartial: true },
+        steps: [
+            { id: "bootstrap", command: "session.bootstrap" },
+            ...threadOpenSteps(args.thread),
+            { id: "ask1", command: "messages.ask", args: { text: args.text, wait: true, read: true } },
+            { id: "ask2", command: "messages.ask", args: { text: args.followupText, wait: true, read: true } }
+        ]
+    };
+}
+export async function ask(args, env = {}) {
+    return runSequence(planAsk(args), env);
+}
+export async function askInThread(args, env = {}) {
+    return runSequence(planAskInThread(args), env);
+}
+export async function findSwitchAskWaitRead(args, env = {}) {
+    return askInThread(args, env);
+}
+export async function sendAndWait(args, env = {}) {
+    return runSequence({
+        name: "send-and-wait",
+        steps: [
+            { id: "bootstrap", command: "session.bootstrap" },
+            { id: "ask", command: "messages.ask", args: { text: args.text, wait: args.wait ?? true, read: true } }
+        ]
+    }, env);
+}
+export async function sendPrecannedResponse(args, env = {}) {
+    return askInThread(args, env);
+}
+export async function attachAskRead(args, env = {}) {
+    return runSequence(planAttachAskRead(args), env);
+}
+export async function downloadLatestAttachment(args, env = {}) {
+    return runSequence(planDownloadLatestAttachment(args), env);
+}
+export async function searchOpenCopyLatest(args, env = {}) {
+    return runSequence(planSearchOpenCopyLatest(args), env);
+}
+export async function twoTurnExchange(args, env = {}) {
+    return runSequence(planTwoTurnExchange(args), env);
+}
+function threadOpenSteps(thread) {
+    if (thread.url !== undefined) {
+        return [{ id: "open", command: "threads.open", args: { url: thread.url } }];
+    }
+    if (thread.conversationId !== undefined) {
+        return [{ id: "open", command: "threads.open", args: { conversationId: thread.conversationId } }];
+    }
+    const query = thread.query ?? thread.title;
+    if (query !== undefined) {
+        return [
+            { id: "find", command: "threads.search", args: { query, limit: 5 } },
+            { id: "open", command: "threads.open", args: { fromStep: "find", select: thread.title === undefined ? "first" : { title: thread.title } } }
+        ];
+    }
+    return [];
+}
+function askStepArgs(args) {
+    const askArgs = { text: args.text };
+    if (args.wait !== undefined) {
+        askArgs.wait = args.wait;
+    }
+    if (args.read !== undefined) {
+        askArgs.read = args.read;
+    }
+    return askArgs;
+}