codex-chatgpt-control 0.5.1-alpha.2 → 0.5.1-alpha.4

package/dist/src/dom/composer-text.js

@@ -0,0 +1,85 @@
+/**
+ * Browser-serialized, bounded reader for the text inserted into a composer.
+ * Keep this self-contained: the Chrome bridge transfers the function, not its
+ * module. Contenteditable paragraph boundaries are part of the prompt.
+ */
+export function inspectComposerText(element) {
+    const maximum = 8 * 1024 * 1024;
+    const candidate = element;
+    const tag = typeof candidate.tagName === "string" ? candidate.tagName.toLowerCase() : "";
+    if (tag === "input" || tag === "textarea" || tag === "select") {
+        const value = candidate.value;
+        return typeof value === "string" && value.length <= maximum ? value : undefined;
+    }
+    const chunks = [];
+    let total = 0;
+    let visited = 0;
+    let lastCharacter = "";
+    const append = (text) => {
+        total += text.length;
+        if (total > maximum)
+            throw new Error("composer text limit exceeded");
+        if (text.length > 0) {
+            chunks.push(text);
+            lastCharacter = text.slice(-1);
+        }
+    };
+    const walk = (node, depth) => {
+        visited += 1;
+        if (visited > 4096 || depth > 128)
+            throw new Error("composer node limit exceeded");
+        if (node.nodeType === 3) {
+            append(node.nodeValue ?? "");
+            return;
+        }
+        const current = node;
+        const currentTag = typeof current.tagName === "string" ? current.tagName.toUpperCase() : "";
+        if (currentTag === "BR") {
+            const classes = (current.getAttribute("class") ?? "").split(/\s+/u);
+            // ProseMirror adds a caret placeholder after a real trailing hard break.
+            const soleChild = node.parentNode?.firstChild === node && node.nextSibling === null;
+            if (!classes.includes("ProseMirror-trailingBreak") && !soleChild)
+                append("\n");
+            return;
+        }
+        let previousBlock = false;
+        let previousEmptyBlock = false;
+        let hasPrevious = false;
+        let child = node.firstChild;
+        while (child !== null) {
+            const childTag = child.nodeType === 1 ? child.tagName.toUpperCase() : "";
+            const block = childTag === "P" || childTag === "DIV" || childTag === "LI";
+            const boundary = hasPrevious && (block || previousBlock)
+                && (lastCharacter !== "\n" || previousEmptyBlock);
+            // Reserve a position before walking the child. Empty inline nodes have
+            // no rendered text and must not create a paragraph boundary.
+            const boundaryIndex = chunks.length;
+            if (boundary)
+                chunks.push("");
+            const before = total;
+            walk(child, depth + 1);
+            const emitted = total > before;
+            if (emitted || block) {
+                if (boundary) {
+                    chunks[boundaryIndex] = "\n";
+                    total += 1;
+                    if (total > maximum)
+                        throw new Error("composer text limit exceeded");
+                    if (!emitted)
+                        lastCharacter = "\n";
+                }
+                hasPrevious = true;
+                previousBlock = block;
+                previousEmptyBlock = block && !emitted;
+            }
+            child = child.nextSibling;
+        }
+    };
+    try {
+        walk(candidate, 0);
+        return chunks.join("");
+    }
+    catch {
+        return undefined;
+    }
+}

package/dist/src/errors.d.ts

@@ -2,6 +2,15 @@ import type { BlockerKind, CommandContext, CommandResult } from "./types.js";
 type BlockerDetails = Partial<Omit<NonNullable<CommandResult["blocker"]>, "kind" | "message" | "visibleText">>;
 export declare const BROWSER_BRIDGE_UNAVAILABLE_MESSAGE = "Codex cannot access the ChatGPT browser bridge from this backend process. In an ordinary shell this is expected; for a live Codex Chrome run, assign the Chrome plugin runtime returned by setupBrowserRuntime() to globalThis.agent before using it.";
 export declare const BROWSER_BRIDGE_REMEDIATION: NonNullable<NonNullable<CommandResult["blocker"]>["remediation"]>;
+/**
+ * Read a Node-style errno code without relying on realm-sensitive
+ * `instanceof Error` checks or invoking an untrusted accessor.
+ *
+ * Browser-hosted modules can receive filesystem errors created by the host
+ * realm. Those values are genuine Node errno objects but are not necessarily
+ * instances of this bundle's `Error` constructor.
+ */
+export declare function nodeErrorCode(error: unknown): string | undefined;
 export declare class ChatGPTControlError extends Error {
     readonly kind: BlockerKind;
     readonly recoverable: boolean;

package/dist/src/errors.js

@@ -21,6 +21,28 @@ export const BROWSER_BRIDGE_REMEDIATION = [
         userActionRequired: true
     }
 ];
+/**
+ * Read a Node-style errno code without relying on realm-sensitive
+ * `instanceof Error` checks or invoking an untrusted accessor.
+ *
+ * Browser-hosted modules can receive filesystem errors created by the host
+ * realm. Those values are genuine Node errno objects but are not necessarily
+ * instances of this bundle's `Error` constructor.
+ */
+export function nodeErrorCode(error) {
+    if (error === null || (typeof error !== "object" && typeof error !== "function"))
+        return undefined;
+    try {
+        const descriptor = Object.getOwnPropertyDescriptor(error, "code");
+        if (descriptor === undefined || !("value" in descriptor) || typeof descriptor.value !== "string") {
+            return undefined;
+        }
+        return descriptor.value;
+    }
+    catch {
+        return undefined;
+    }
+}
 export class ChatGPTControlError extends Error {
     kind;
     recoverable;

package/dist/src/index.d.ts

@@ -40,3 +40,9 @@ export * from "./runner/index.js";
 export * from "./backend/client.js";
 export * from "./backend/protocol.js";
 export * from "./backend/session.js";
+export * from "./runtime/runtime-session.js";
+export * from "./runtime/tab-coordinator.js";
+export * from "./runtime/operation-context.js";
+export * from "./runtime/coordinated-page.js";
+export * from "./runtime/coordinated-browser.js";
+export * from "./operations/index.js";

package/dist/src/index.js

@@ -40,3 +40,12 @@ export * from "./runner/index.js";
 export * from "./backend/client.js";
 export * from "./backend/protocol.js";
 export * from "./backend/session.js";
+export * from "./runtime/runtime-session.js";
+// Public adapter options accept injected coordinator/context instances. Keep
+// their constructors and factories available alongside the facades so custom
+// integrations do not need an undocumented private-subpath import.
+export * from "./runtime/tab-coordinator.js";
+export * from "./runtime/operation-context.js";
+export * from "./runtime/coordinated-page.js";
+export * from "./runtime/coordinated-browser.js";
+export * from "./operations/index.js";

package/dist/src/operations/artifact-output.d.ts

@@ -0,0 +1,69 @@
+/** Fault boundaries are intentionally coarse: they model durable transitions,
+ * rather than exposing implementation-specific filesystem calls. */
+export type ArtifactOutputFaultPoint = "before_temp_open" | "after_temp_open" | "before_write" | "after_write" | "before_file_sync" | "after_file_sync" | "before_final_link" | "after_final_link" | "before_temp_cleanup" | "after_temp_cleanup" | "before_directory_sync" | "after_directory_sync";
+export type ArtifactOutputEntropy = (byteLength: number) => Uint8Array | Promise<Uint8Array>;
+export type ArtifactOutputHooks = {
+    entropy?: ArtifactOutputEntropy;
+    faultInjector?: (point: ArtifactOutputFaultPoint) => void | Promise<void>;
+};
+export type ArtifactOutputKeyInput = {
+    /** Opaque operation identity. It is hashed and never copied to the key. */
+    operationId: string;
+    /** Opaque source/artifact identity. It is hashed and never copied to the key. */
+    artifactIdentity: string;
+    /** Optional public filename extension, with or without a leading dot. */
+    extensionHint?: string;
+    /** Optional public MIME hint used only for vetted extension selection. */
+    mimeTypeHint?: string;
+};
+export type ArtifactOutputCommitOptions = ArtifactOutputKeyInput & {
+    /** Already-authorized destination. It must be absolute, existing, and real. */
+    outputDirectory: string;
+    source: AsyncIterable<Uint8Array>;
+    /** Durable browser/download receipt used to reconcile crash leftovers. */
+    expected?: Readonly<{
+        bytes: number;
+        sha256: string;
+    }>;
+    maxBytes?: number;
+    signal?: AbortSignal;
+    hooks?: ArtifactOutputHooks;
+    /** Optional absolute deadline for the local effect. */
+    deadlineAt?: number;
+    /** Optional relative deadline, evaluated by `now` at invocation start. */
+    timeoutMs?: number;
+    /** Injectable monotonic-ish wall clock used only for bounded checks. */
+    now?: () => number;
+};
+export type ArtifactOutputStatus = "committed" | "reconciled" | "collision" | "blocked";
+export type ArtifactOutputReason = "created" | "recovered_after_crash" | "already_present" | "existing_mismatch" | "existing_target_not_regular" | "destination_invalid" | "ambiguous_temp" | "byte_limit_exceeded" | "source_aborted" | "source_invalid" | "source_mismatch" | "source_read_failed" | "write_failed" | "file_sync_failed" | "commit_indeterminate" | "directory_sync_failed" | "temp_cleanup_pending" | "temp_cleanup_ambiguous" | "entropy_failed" | "operation_timeout" | "clock_invalid";
+/**
+ * A redacted, receipt-ready output result. The destination path and all
+ * source content are deliberately absent. For a blocked stream result,
+ * bytes/sha256 describe only the observed prefix (never a claimed final
+ * artifact); consumers must only create a durable transfer receipt for
+ * committed or reconciled results.
+ */
+export type ArtifactOutputResult = {
+    outputKey: string;
+    bytes: number;
+    sha256: string;
+    status: ArtifactOutputStatus;
+    reason: ArtifactOutputReason;
+};
+export declare class ArtifactOutputError extends Error {
+    readonly code: string;
+    constructor(code: string, message: string);
+}
+/**
+ * Derive one deterministic, path-safe output component from opaque identities.
+ * The only human-readable portion is the vetted public extension.
+ */
+export declare function deriveOperationOutputKey(input: ArtifactOutputKeyInput): string;
+/**
+ * Stream one artifact into an operation-owned temporary file, then install it
+ * from the retained source descriptor into an exclusive destination file.
+ * Existing byte-identical finals are reconciled; any other existing target is
+ * never overwritten.
+ */
+export declare function commitOperationOutput(options: ArtifactOutputCommitOptions): Promise<ArtifactOutputResult>;