codex-chatgpt-control 0.1.0-alpha.1 → 0.2.0-alpha.1

package/dist/src/commands/files.js

@@ -1,44 +1,175 @@
 import { access, readFile, stat } from "node:fs/promises";
-import { basename, resolve } from "node:path";
 import { constants } from "node:fs";
+import path from "node:path";
+import { downloadLatestArtifact, locatorCountWithTimeout } from "./artifacts.js";
 import { waitForDownloadFromClick } from "../browser/downloads.js";
 import { resultError, resultOk } from "../errors.js";
 import { addFilesButton, cssSelectors, requiredLocator } from "../dom/selectors.js";
+import { localeLabels } from "../dom/locale-labels.js";
+import { basenameForHostPath, isHostAbsolutePath, resolveForHostPath } from "../platform/local-paths.js";
 import { contextFromPage } from "./context.js";
 import { bootstrap } from "./session.js";
+import { localGuardTimeout } from "./timeouts.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.";
+const DEFAULT_MAX_BYTES_PER_FILE = 512 * 1024 * 1024;
+const DEFAULT_MAX_TOTAL_BYTES = 2 * 1024 * 1024 * 1024;
 export async function validateAttachPaths(paths) {
+    const result = await preflightFiles({}, { paths });
+    if (!result.ok || result.data === undefined) {
+        throw new Error(result.blocker?.message ?? result.error?.message ?? "File attachment preflight failed.");
+    }
+    return result.data.files.map(file => ({
+        path: file.path,
+        name: file.name,
+        bytes: file.bytes
+    }));
+}
+export async function preflightFiles(env, args) {
+    const maxBytesPerFile = args.maxBytesPerFile ?? DEFAULT_MAX_BYTES_PER_FILE;
+    const maxTotalBytes = args.maxTotalBytes ?? DEFAULT_MAX_TOTAL_BYTES;
     const files = [];
-    for (const path of paths) {
-        if (!path.startsWith("/")) {
-            throw new Error(`File attachment path must be absolute: ${path}`);
+    const warnings = [];
+    for (const [index, inputPath] of args.paths.entries()) {
+        const fieldPath = `paths[${index}]`;
+        if (!isHostAbsolutePath(inputPath)) {
+            return filePreflightBlocker({
+                env,
+                status: "blocked",
+                kind: "upload_failed",
+                code: "file_path_not_absolute",
+                fieldPath,
+                message: `File attachment path must be absolute for the backend host: ${inputPath}`
+            });
+        }
+        const absolute = resolveForHostPath(inputPath);
+        let fileStat;
+        try {
+            fileStat = await stat(absolute);
+        }
+        catch (error) {
+            if (isNodeError(error) && error.code === "ENOENT") {
+                return filePreflightBlocker({
+                    env,
+                    status: "not_found",
+                    kind: "not_found",
+                    code: "file_missing",
+                    fieldPath,
+                    message: `File attachment path does not exist: ${absolute}`
+                });
+            }
+            if (isNodeError(error) && (error.code === "EACCES" || error.code === "EPERM")) {
+                return filePreflightBlocker({
+                    env,
+                    status: "blocked",
+                    kind: "permission",
+                    code: "file_not_readable",
+                    fieldPath,
+                    message: `File attachment path is not readable: ${absolute}`
+                });
+            }
+            return resultError(error instanceof Error ? error : new Error(String(error)), filePreflightContext(env));
         }
-        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}`);
+            return filePreflightBlocker({
+                env,
+                status: "blocked",
+                kind: "upload_failed",
+                code: fileStat.isDirectory() ? "file_path_is_directory" : "file_path_not_file",
+                fieldPath,
+                message: `File attachment path is not a file: ${absolute}`
+            });
+        }
+        try {
+            await access(absolute, constants.R_OK);
+        }
+        catch (error) {
+            return filePreflightBlocker({
+                env,
+                status: "blocked",
+                kind: "permission",
+                code: "file_not_readable",
+                fieldPath,
+                message: `File attachment path is not readable: ${absolute}`
+            });
+        }
+        if (fileStat.size > maxBytesPerFile) {
+            return filePreflightBlocker({
+                env,
+                status: "blocked",
+                kind: "upload_failed",
+                code: "file_too_large",
+                fieldPath,
+                message: `File attachment exceeds the configured per-file preflight limit: ${absolute} (${fileStat.size}/${maxBytesPerFile} bytes)`
+            });
         }
-        files.push({
-            path: absolute,
-            name: basename(absolute),
-            bytes: fileStat.size
+        const metadata = fileMetadata(absolute, fileStat.size);
+        files.push(metadata);
+    }
+    const totalBytes = files.reduce((sum, file) => sum + file.bytes, 0);
+    if (totalBytes > maxTotalBytes) {
+        return filePreflightBlocker({
+            env,
+            status: "blocked",
+            kind: "upload_failed",
+            code: "file_total_bytes_exceeded",
+            fieldPath: "paths",
+            message: `File attachments exceed the configured total preflight limit: ${totalBytes}/${maxTotalBytes} bytes`
         });
     }
-    return files;
+    collectFilePreflightWarnings(files, warnings);
+    return resultOk({ files, totalBytes }, filePreflightContext(env), warnings);
 }
 export async function attachFiles(env, args) {
+    const preflight = await preflightFiles(env, { paths: args.paths });
+    if (!preflight.ok || preflight.data === undefined) {
+        return preflight;
+    }
     const boot = await ensurePage(env);
     if (!boot.ok) {
         return boot;
     }
     const page = env.page;
     try {
-        const files = await validateAttachPaths(args.paths);
+        const files = preflight.data.files.map(file => ({
+            path: file.path,
+            name: file.name,
+            bytes: file.bytes
+        }));
         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));
+        const readiness = await waitForAttachedFilesReady(page, files, args.timeoutMs ?? 30000);
+        if (!readiness.ready) {
+            const blocker = {
+                kind: "upload_failed",
+                code: "attachment_processing",
+                message: "ChatGPT still appears to be processing the attached file, so the prompt was not submitted.",
+                remediation: [
+                    {
+                        label: "Wait for upload",
+                        instruction: "Wait until the visible attachment finishes uploading or processing, then retry the askWithFiles call.",
+                        userActionRequired: false
+                    },
+                    {
+                        label: "Retry smaller file",
+                        instruction: "If processing never finishes, retry with a smaller file or a different supported file type.",
+                        userActionRequired: true
+                    }
+                ],
+                resumable: true
+            };
+            if (readiness.processingText !== undefined) {
+                blocker.visibleText = readiness.processingText;
+            }
+            return {
+                ok: false,
+                status: "blocked",
+                warnings: [],
+                blocker,
+                context: await contextFromPage(page)
+            };
+        }
+        return resultOk({ files }, await contextFromPage(page), preflight.warnings);
     }
     catch (error) {
         if (isUploadBridgeBlocker(error)) {
@@ -60,6 +191,185 @@ export async function attachFiles(env, args) {
         return resultError(error instanceof Error ? error : new Error(String(error)), await contextFromPage(page));
     }
 }
+function filePreflightBlocker(args) {
+    return {
+        ok: false,
+        status: args.status,
+        warnings: [],
+        blocker: {
+            kind: args.kind,
+            code: args.code,
+            fieldPath: args.fieldPath,
+            message: args.message,
+            resumable: true
+        },
+        context: filePreflightContext(args.env)
+    };
+}
+function filePreflightContext(env) {
+    return { timestamp: (env.now?.() ?? new Date()).toISOString() };
+}
+function fileMetadata(absolute, bytes) {
+    const extension = extensionForHostPath(absolute);
+    const { mimeType, category } = guessFileType(extension);
+    return {
+        path: absolute,
+        name: basenameForHostPath(absolute),
+        bytes,
+        extension,
+        mimeType,
+        category
+    };
+}
+function extensionForHostPath(value) {
+    return process.platform === "win32"
+        ? path.win32.extname(value).toLowerCase()
+        : path.posix.extname(value).toLowerCase();
+}
+function collectFilePreflightWarnings(files, warnings) {
+    const byPath = new Map();
+    const byName = new Map();
+    for (const file of files) {
+        if (file.bytes === 0) {
+            warnings.push(`Zero-byte file will be attached if ChatGPT accepts it: ${file.name}`);
+        }
+        const pathCount = (byPath.get(file.path) ?? 0) + 1;
+        byPath.set(file.path, pathCount);
+        if (pathCount === 2) {
+            warnings.push(`Duplicate resolved file path requested: ${file.path}`);
+        }
+        const normalizedName = file.name.toLocaleLowerCase();
+        const nameCount = (byName.get(normalizedName) ?? 0) + 1;
+        byName.set(normalizedName, nameCount);
+        if (nameCount === 2) {
+            warnings.push(`Duplicate file basename requested: ${file.name}`);
+        }
+    }
+}
+function guessFileType(extension) {
+    switch (extension) {
+        case ".txt":
+            return { mimeType: "text/plain", category: "text" };
+        case ".md":
+        case ".markdown":
+            return { mimeType: "text/markdown", category: "text" };
+        case ".csv":
+            return { mimeType: "text/csv", category: "spreadsheet" };
+        case ".tsv":
+            return { mimeType: "text/tab-separated-values", category: "spreadsheet" };
+        case ".json":
+            return { mimeType: "application/json", category: "data" };
+        case ".jsonl":
+        case ".ndjson":
+            return { mimeType: "application/x-ndjson", category: "data" };
+        case ".pdf":
+            return { mimeType: "application/pdf", category: "document" };
+        case ".doc":
+            return { mimeType: "application/msword", category: "document" };
+        case ".docx":
+            return { mimeType: "application/vnd.openxmlformats-officedocument.wordprocessingml.document", category: "document" };
+        case ".xls":
+            return { mimeType: "application/vnd.ms-excel", category: "spreadsheet" };
+        case ".xlsx":
+            return { mimeType: "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet", category: "spreadsheet" };
+        case ".png":
+            return { mimeType: "image/png", category: "image" };
+        case ".jpg":
+        case ".jpeg":
+            return { mimeType: "image/jpeg", category: "image" };
+        case ".gif":
+            return { mimeType: "image/gif", category: "image" };
+        case ".webp":
+            return { mimeType: "image/webp", category: "image" };
+        case ".svg":
+            return { mimeType: "image/svg+xml", category: "image" };
+        case ".mp3":
+            return { mimeType: "audio/mpeg", category: "audio" };
+        case ".wav":
+            return { mimeType: "audio/wav", category: "audio" };
+        case ".mp4":
+            return { mimeType: "video/mp4", category: "video" };
+        case ".mov":
+            return { mimeType: "video/quicktime", category: "video" };
+        case ".zip":
+            return { mimeType: "application/zip", category: "archive" };
+        case ".gz":
+            return { mimeType: "application/gzip", category: "archive" };
+        default:
+            return { mimeType: guessMimeType(extension), category: "unknown" };
+    }
+}
+function isNodeError(error) {
+    return error instanceof Error && "code" in error;
+}
+async function waitForAttachedFilesReady(page, files, timeoutMs) {
+    const started = Date.now();
+    let lastProcessingText;
+    while (Date.now() - started < timeoutMs) {
+        const snapshot = await readAttachmentReadiness(page, files).catch(() => undefined);
+        if (snapshot === undefined) {
+            return { ready: true };
+        }
+        const allNamesVisible = snapshot.files.length > 0 && snapshot.files.every(file => file.visible);
+        if (!snapshot.processing && allNamesVisible) {
+            return { ready: true };
+        }
+        if (!snapshot.processing && Date.now() - started >= Math.min(timeoutMs, 1000)) {
+            return { ready: true };
+        }
+        if (snapshot.processingText !== undefined) {
+            lastProcessingText = snapshot.processingText;
+        }
+        await page.waitForTimeout?.(250);
+    }
+    const blocked = { ready: false };
+    if (lastProcessingText !== undefined) {
+        blocked.processingText = lastProcessingText;
+    }
+    return blocked;
+}
+async function readAttachmentReadiness(page, files) {
+    if (typeof page.evaluate !== "function") {
+        return undefined;
+    }
+    return page.evaluate((fileNames) => {
+        const visibleText = document.body?.innerText ?? "";
+        const normalize = (value) => value.toLocaleLowerCase();
+        const normalizedVisibleText = normalize(visibleText);
+        const files = fileNames.map(name => ({
+            name,
+            visible: normalizedVisibleText.includes(normalize(name))
+        }));
+        const attachmentSelectors = [
+            "[data-testid*='attachment' i]",
+            "[data-testid*='file' i]",
+            "[aria-label*='attachment' i]",
+            "[aria-label*='upload' i]",
+            "[aria-label*='file' i]",
+            "[class*='attachment' i]",
+            "[class*='upload' i]",
+            "[class*='file' i]",
+            "[role='progressbar']"
+        ].join(", ");
+        const attachmentText = Array.from(document.querySelectorAll(attachmentSelectors))
+            .map(element => [
+            element.textContent ?? "",
+            element.getAttribute("aria-label") ?? "",
+            element.getAttribute("title") ?? ""
+        ].join(" "))
+            .join(" ");
+        const relevantText = attachmentText.length > 0 ? attachmentText : visibleText;
+        const processingMatch = /\b(uploading|processing|attaching|preparing|reading|scanning|analyzing)\b/i.exec(relevantText);
+        const snapshot = {
+            files,
+            processing: processingMatch !== null
+        };
+        if (processingMatch !== null) {
+            snapshot.processingText = relevantText.slice(0, 500);
+        }
+        return snapshot;
+    }, files.map(file => file.name));
+}
 async function uploadFiles(page, files, timeoutMs) {
     const paths = files.map(file => file.path);
     const errors = [];
@@ -101,7 +411,10 @@ async function uploadFiles(page, files, timeoutMs) {
     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" });
+    // The `#composer-plus-btn` id is the language-agnostic primary; the aria-label and the
+    // menu-item text are locale-sensitive (menu text sourced from the locale registry).
+    const addPhotosFilesText = localeLabels.addPhotosFilesMenuItem[0];
+    const menuItem = requiredLocator(page, "div[role='menuitem']").filter?.({ hasText: addPhotosFilesText });
     if (await locatorCount(menuItem) !== 1) {
         const plusButton = requiredLocator(page, "#composer-plus-btn, button[aria-label='Add files and more']");
         if (await locatorCount(plusButton) !== 1) {
@@ -110,7 +423,7 @@ async function clickChatGPTAddPhotosMenuItem(page, paths, timeoutMs) {
         await plusButton.click?.({ timeoutMs: Math.min(timeoutMs, 10000) });
         await page.waitForTimeout?.(250);
     }
-    const refreshedMenuItem = requiredLocator(page, "div[role='menuitem']").filter?.({ hasText: "Add photos & files" });
+    const refreshedMenuItem = requiredLocator(page, "div[role='menuitem']").filter?.({ hasText: addPhotosFilesText });
     await clickFileChooserLocator(page, refreshedMenuItem, paths, timeoutMs);
 }
 async function clickFileChooserTarget(page, selector, paths, timeoutMs, options = {}) {
@@ -188,8 +501,29 @@ export async function downloadLatestFile(env, args) {
     const page = env.page;
     try {
         const controls = requiredLocator(page, cssSelectors.downloadControls);
-        const count = await controls.count?.();
+        let count;
+        try {
+            count = await locatorCountWithTimeout(controls, localGuardTimeout(args.timeoutMs, 5000), "download_control_timeout");
+        }
+        catch (error) {
+            return {
+                ok: false,
+                status: "unsupported",
+                warnings: [],
+                blocker: {
+                    kind: "download_unavailable",
+                    code: "download_control_timeout",
+                    message: `No visible ChatGPT download control could be counted before the local guard timeout: ${error instanceof Error ? error.message : String(error)}`,
+                    resumable: true
+                },
+                context: await contextFromPage(page)
+            };
+        }
         if (count === 0) {
+            const artifactDownload = await downloadLatestArtifact(env, args);
+            if (artifactDownload.ok) {
+                return artifactDownload;
+            }
             return {
                 ok: false,
                 status: "unsupported",

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

@@ -1,8 +1,9 @@
+import { type AssistantGenerationState } from "../dom/generation-state.js";
 import type { AskArgs, AskReadData, CommandResult, ComposeArgs, ComposeData, ReadLatestArgs, ReadLatestData, RuntimeEnv, SubmitArgs, SubmitData, WaitAndReadArgs, WaitArgs, WaitData } from "../types.js";
 export type CompletionSnapshot = {
     textStableForMs: number;
     stableMs: number;
-    hasStopButton: boolean;
+    generation: AssistantGenerationState;
     hasResponseActions: boolean;
     latestText: string;
 };