@easonwumac/computer-linker 0.1.2

package/dist/client.d.ts

@@ -0,0 +1,217 @@
+import type { PublicWorkspaceOperationRegistryEntry, WorkspaceOperationContract, WorkspaceOperationEnvelope, WorkspaceOperationName } from "./workspace-operations.js";
+import type { CapabilityPolicy } from "./capability-policy.js";
+import type { CodexRunRecord } from "./codex-runs.js";
+import type { ComputerOperationContract, ComputerOperationRegistryEntry } from "./computer-operation-registry.js";
+import type { FailedReplayItem, HistoryInsight } from "./history-insights.js";
+import type { ChatGptSetupStatus, ChatGptVerifyMode } from "./chatgpt.js";
+import type { WorkspaceLinkerClientSmokeOptions, WorkspaceLinkerClientSmokeReport } from "./client-smoke.js";
+export type { WorkspaceLinkerClientSmokeCheck, WorkspaceLinkerClientSmokeCheckId, WorkspaceLinkerClientSmokeOptions, WorkspaceLinkerClientSmokeReport, WorkspaceLinkerClientSmokeStatus, } from "./client-smoke.js";
+export interface WorkspaceLinkerClientOptions {
+    baseUrl: string;
+    ownerToken?: string;
+    fetch?: typeof fetch;
+}
+export interface WorkspaceLinkerWorkspace {
+    id: string;
+    name: string;
+    path: string;
+    permissions: {
+        read: boolean;
+        write: boolean;
+        shell: boolean;
+        codex: boolean;
+        screen?: boolean;
+    };
+    capabilityPolicy?: CapabilityPolicy;
+    allowedOperations: WorkspaceOperationName[];
+}
+export interface WorkspaceLinkerWorkspaces {
+    machineId?: string;
+    machineName: string;
+    workspaces: WorkspaceLinkerWorkspace[];
+}
+export interface WorkspaceLinkerRunOptions {
+    target?: string;
+    input?: Record<string, unknown>;
+    options?: Record<string, unknown>;
+}
+export interface WorkspaceLinkerReplayOptions {
+    workspace?: string;
+    target?: string;
+    input?: Record<string, unknown>;
+    options?: Record<string, unknown>;
+}
+export interface WorkspaceLinkerOperationRequest {
+    workspace: string;
+    op: WorkspaceOperationName;
+    target?: string;
+    input?: Record<string, unknown>;
+    options?: Record<string, unknown>;
+}
+export interface WorkspaceLinkerComputerOperationRequest {
+    scope: string;
+    op: string;
+    target?: string;
+    input?: Record<string, unknown>;
+    options?: Record<string, unknown>;
+}
+export interface WorkspaceLinkerOperationHistoryFilters {
+    scope?: string;
+    view?: "last" | "timeline" | "sessions" | "connections" | "failed_replay" | "debug_bundle" | "raw" | string;
+    limit?: number;
+    query?: string;
+}
+export interface WorkspaceLinkerOperationRegistryFilters {
+    contract?: "computer" | "workspace";
+    compatibility?: "workspace";
+    category?: string;
+    permission?: string;
+    query?: string;
+}
+export interface WorkspaceLinkerComputerOperationRegistry {
+    kind: "computer-operation-registry";
+    schemaVersion: 1;
+    contract: ComputerOperationContract;
+    filters: WorkspaceLinkerOperationRegistryFilters & {
+        contract?: "computer";
+    };
+    count: number;
+    operations: ComputerOperationRegistryEntry[];
+    compatibility?: {
+        workspaceRegistry?: {
+            action: string;
+            input: Record<string, unknown>;
+        };
+    };
+}
+export interface WorkspaceLinkerWorkspaceOperationRegistry {
+    kind: "operation-registry";
+    schemaVersion: 1;
+    contract: WorkspaceOperationContract;
+    filters: WorkspaceLinkerOperationRegistryFilters & {
+        contract?: "workspace";
+    };
+    count: number;
+    operations: PublicWorkspaceOperationRegistryEntry[];
+}
+export type WorkspaceLinkerOperationRegistry = WorkspaceLinkerComputerOperationRegistry | WorkspaceLinkerWorkspaceOperationRegistry;
+export interface WorkspaceLinkerMcpClientSetup {
+    kind: "computer-linker-mcp-client-setup";
+    schemaVersion: 1;
+    machineId?: string;
+    machineName: string;
+    localReady: boolean;
+    ready: boolean;
+    remoteReady: boolean;
+    blockingReasons: string[];
+    remoteBlockingReasons: string[];
+    warnings: string[];
+    nextActions: string[];
+    connection?: Record<string, unknown>;
+    auth?: Record<string, unknown>;
+    tools?: string[];
+    operationShape?: Record<string, unknown>;
+    firstPrompt?: string;
+    agentInstructions?: string[];
+}
+export interface WorkspaceLinkerConnectReadinessOptions {
+    /** @deprecated Only used by chatGptSetup(); connectReadiness() is generic. */
+    mode?: ChatGptVerifyMode;
+    registry?: WorkspaceLinkerOperationRegistryFilters;
+}
+export interface WorkspaceLinkerConnectReadiness {
+    kind: "computer-linker-connect-readiness";
+    schemaVersion: 1;
+    ready: boolean;
+    status: "ready" | "needs_action" | "blocked";
+    machine: {
+        machineId?: string;
+        machineName: string;
+    } | null;
+    recommendedWorkspace: {
+        id: string;
+        name: string;
+        allowedOperations: WorkspaceOperationName[];
+    } | null;
+    clientSetup: WorkspaceLinkerMcpClientSetup;
+    workspaces: WorkspaceLinkerWorkspace[];
+    operationRegistry: WorkspaceLinkerOperationRegistry;
+    blockingReasons: string[];
+    warnings: string[];
+    nextActions: string[];
+}
+export type WorkspaceLinkerGitOperation = "repo_status" | "git_changes" | "git_diff" | "git_log" | "git_show" | "git_stage" | "git_unstage" | "git_commit" | "git_worktree_list" | "git_worktree_create";
+export declare class WorkspaceLinkerClient {
+    private readonly baseUrl;
+    private readonly fetchImpl;
+    private readonly ownerToken?;
+    constructor(options: WorkspaceLinkerClientOptions);
+    health(): Promise<unknown>;
+    getCapabilities<T = unknown>(): Promise<T>;
+    doctor<T = unknown>(): Promise<T>;
+    getComputerInfo<T = unknown>(): Promise<T>;
+    clientSetup<T = unknown>(): Promise<T>;
+    smoke(options?: WorkspaceLinkerClientSmokeOptions): Promise<WorkspaceLinkerClientSmokeReport>;
+    computerOperation<T = unknown>(request: WorkspaceLinkerComputerOperationRequest): Promise<T>;
+    getOperationHistory<T = unknown>(filters?: WorkspaceLinkerOperationHistoryFilters): Promise<T>;
+    /**
+     * @deprecated Prefer clientSetup() for generic setup discovery. This remains
+     * available for older ChatGPT-specific setup UIs.
+     */
+    chatGptSetup<T = ChatGptSetupStatus>(mode?: ChatGptVerifyMode): Promise<T>;
+    listWorkspaces(): Promise<WorkspaceLinkerWorkspaces>;
+    history(filters?: Record<string, unknown>): Promise<unknown>;
+    historyInsight<T = HistoryInsight>(filters?: Record<string, unknown>): Promise<T>;
+    operationRegistry(filters?: WorkspaceLinkerOperationRegistryFilters): Promise<WorkspaceLinkerOperationRegistry>;
+    workspaceOperationRegistry(filters?: Omit<WorkspaceLinkerOperationRegistryFilters, "contract" | "compatibility">): Promise<WorkspaceLinkerWorkspaceOperationRegistry>;
+    connectReadiness(options?: WorkspaceLinkerConnectReadinessOptions): Promise<WorkspaceLinkerConnectReadiness>;
+    historyLast<T = HistoryInsight>(filters?: Record<string, unknown>): Promise<T>;
+    historySessions<T = HistoryInsight>(filters?: Record<string, unknown>): Promise<T>;
+    historyConnections<T = HistoryInsight>(filters?: Record<string, unknown>): Promise<T>;
+    failedReplay(filters?: Record<string, unknown>): Promise<FailedReplayItem[]>;
+    workspaceOperation<T = unknown>(workspace: string, operation: WorkspaceOperationEnvelope): Promise<T>;
+    operation<T = unknown>(request: WorkspaceLinkerOperationRequest): Promise<T>;
+    run<T = unknown>(workspace: string, op: WorkspaceOperationName, input?: Record<string, unknown>, options?: Record<string, unknown>, target?: string): Promise<T>;
+    replayFailed<T = unknown>(item: FailedReplayItem, replayOptions?: WorkspaceLinkerReplayOptions): Promise<T>;
+    read(workspace: string, target: string, options?: Record<string, unknown>): Promise<unknown>;
+    readMany(workspace: string, paths: string[], options?: Record<string, unknown>): Promise<unknown>;
+    listFiles(workspace: string, target?: string, options?: Record<string, unknown>): Promise<unknown>;
+    tree(workspace: string, target?: string, options?: Record<string, unknown>): Promise<unknown>;
+    write(workspace: string, target: string, content: string, options?: Record<string, unknown>): Promise<unknown>;
+    patch(workspace: string, patch: string, options?: Record<string, unknown>, target?: string): Promise<unknown>;
+    search(workspace: string, query: string, options?: Record<string, unknown>, target?: string): Promise<unknown>;
+    searchText(workspace: string, query: string, options?: Record<string, unknown>, target?: string): Promise<unknown>;
+    command(workspace: string, command: string, options?: Record<string, unknown>, target?: string): Promise<unknown>;
+    processStart(workspace: string, command: string, options?: Record<string, unknown>, target?: string): Promise<unknown>;
+    processList(workspace: string, options?: Record<string, unknown>): Promise<unknown>;
+    processRead(workspace: string, processId: string, options?: Record<string, unknown>): Promise<unknown>;
+    processStop(workspace: string, processId: string, options?: Record<string, unknown>): Promise<unknown>;
+    screenList<T = unknown>(scope: string): Promise<T>;
+    screenCapture<T = unknown>(scope: string, target?: string, options?: Record<string, unknown>): Promise<T>;
+    screenCaptureWindow<T = unknown>(scope: string, windowId: string, options?: Record<string, unknown>): Promise<T>;
+    screenCaptureProcess<T = unknown>(scope: string, processIdOrName: string, options?: Record<string, unknown>): Promise<T>;
+    git<T = unknown>(workspace: string, op: WorkspaceLinkerGitOperation, input?: Record<string, unknown>, options?: Record<string, unknown>, target?: string): Promise<T>;
+    repoStatus(workspace: string, options?: Record<string, unknown>, target?: string): Promise<unknown>;
+    gitDiff(workspace: string, paths?: string[], options?: Record<string, unknown>, target?: string): Promise<unknown>;
+    workspaceHistory(workspace: string, options?: Record<string, unknown>): Promise<unknown>;
+    workspaceHistoryInsight(workspace: string, options?: Record<string, unknown>): Promise<unknown>;
+    workspaceHistoryLast(workspace: string, options?: Record<string, unknown>): Promise<unknown>;
+    workspaceHistorySessions(workspace: string, options?: Record<string, unknown>): Promise<unknown>;
+    codex(workspace: string, prompt: string, options?: Record<string, unknown>, target?: string): Promise<unknown>;
+    codexPlan(workspace: string, prompt: string, options?: Record<string, unknown>, target?: string): Promise<unknown>;
+    codexReview(workspace: string, prompt?: string, options?: Record<string, unknown>, target?: string): Promise<unknown>;
+    codexFix(workspace: string, prompt: string, options?: Record<string, unknown>, target?: string): Promise<unknown>;
+    codexTest(workspace: string, options?: Record<string, unknown>, target?: string): Promise<unknown>;
+    codexContinue(workspace: string, options?: Record<string, unknown>, target?: string): Promise<unknown>;
+    codexRuns(workspace: string, options?: {
+        workflowId?: string;
+        maxResults?: number;
+    }): Promise<CodexRunRecord[]>;
+    private control;
+    private get;
+    private post;
+    private getJson;
+    private request;
+    private authHeaders;
+}
+export { WorkspaceLinkerClient as ComputerLinkerClient };

package/dist/client.js

@@ -0,0 +1,357 @@
+import { runWorkspaceLinkerSdkClientSmoke } from "./client-smoke.js";
+export class WorkspaceLinkerClient {
+    baseUrl;
+    fetchImpl;
+    ownerToken;
+    constructor(options) {
+        this.baseUrl = new URL(options.baseUrl.replace(/\/+$/, "") + "/");
+        this.fetchImpl = options.fetch ?? fetch;
+        this.ownerToken = options.ownerToken;
+    }
+    async health() {
+        return this.get("health");
+    }
+    async getCapabilities() {
+        return this.get("capabilities");
+    }
+    async doctor() {
+        return this.control("doctor");
+    }
+    async getComputerInfo() {
+        return this.control("get_computer_info");
+    }
+    async clientSetup() {
+        return this.control("client_setup");
+    }
+    async smoke(options = {}) {
+        return runWorkspaceLinkerSdkClientSmoke({
+            apiBaseUrl: this.baseUrl,
+            ownerToken: this.ownerToken,
+            fetchImpl: this.fetchImpl,
+            ...options,
+        });
+    }
+    async computerOperation(request) {
+        return this.control("computer_operation", {
+            scope: request.scope,
+            op: request.op,
+            target: request.target,
+            input: request.input ?? {},
+            options: request.options ?? {},
+        });
+    }
+    async getOperationHistory(filters = {}) {
+        return this.control("get_operation_history", {
+            input: filters,
+        });
+    }
+    /**
+     * @deprecated Prefer clientSetup() for generic setup discovery. This remains
+     * available for older ChatGPT-specific setup UIs.
+     */
+    async chatGptSetup(mode = "coding") {
+        return this.control("chatgpt_setup", {
+            input: { mode },
+        });
+    }
+    async listWorkspaces() {
+        return this.control("list_workspaces");
+    }
+    async history(filters = {}) {
+        return this.control("history", { filters });
+    }
+    async historyInsight(filters = {}) {
+        return this.control("history_insight", { filters });
+    }
+    async operationRegistry(filters = {}) {
+        return this.control("operation_registry", {
+            input: filters,
+        });
+    }
+    async workspaceOperationRegistry(filters = {}) {
+        return this.control("workspace_operation_registry", {
+            input: filters,
+        });
+    }
+    async connectReadiness(options = {}) {
+        const [clientSetup, workspaces, operationRegistry] = await Promise.all([
+            this.clientSetup(),
+            this.listWorkspaces(),
+            this.operationRegistry(options.registry),
+        ]);
+        const blockingReasons = [
+            ...clientSetup.blockingReasons,
+            ...workspaceBlockingReasons(workspaces),
+            ...operationRegistryBlockingReasons(operationRegistry),
+        ];
+        const warnings = [...clientSetup.warnings];
+        const nextActions = dedupeStrings([
+            ...blockingReasons.map((reason) => `Resolve: ${reason}`),
+            ...warnings.map((warning) => `Review: ${warning}`),
+            ...clientSetup.nextActions,
+        ]);
+        return {
+            kind: "computer-linker-connect-readiness",
+            schemaVersion: 1,
+            ready: blockingReasons.length === 0 && clientSetup.ready,
+            status: connectReadinessStatus(blockingReasons, clientSetup.ready),
+            machine: {
+                machineId: workspaces.machineId,
+                machineName: workspaces.machineName,
+            },
+            recommendedWorkspace: recommendedWorkspace(workspaces.workspaces),
+            clientSetup,
+            workspaces: workspaces.workspaces,
+            operationRegistry,
+            blockingReasons,
+            warnings,
+            nextActions,
+        };
+    }
+    async historyLast(filters = {}) {
+        return this.historyInsight({
+            ...filters,
+            view: "last",
+        });
+    }
+    async historySessions(filters = {}) {
+        return this.historyInsight({
+            ...filters,
+            view: "sessions",
+        });
+    }
+    async historyConnections(filters = {}) {
+        return this.historyInsight({
+            ...filters,
+            view: "connections",
+        });
+    }
+    async failedReplay(filters = {}) {
+        const insight = await this.historyInsight({
+            ...filters,
+            view: "failed_replay",
+        });
+        return insight.failedReplay ?? [];
+    }
+    async workspaceOperation(workspace, operation) {
+        return this.control("workspace_operation", {
+            workspace,
+            input: operation,
+        });
+    }
+    async operation(request) {
+        return this.control("operation", {
+            workspace: request.workspace,
+            op: request.op,
+            target: request.target,
+            input: request.input ?? {},
+            options: request.options ?? {},
+        });
+    }
+    async run(workspace, op, input = {}, options = {}, target) {
+        return this.operation({
+            workspace,
+            op,
+            target,
+            input,
+            options,
+        });
+    }
+    async replayFailed(item, replayOptions = {}) {
+        if (!item.request) {
+            throw new Error(item.reason ?? "Failed replay item does not include a request template");
+        }
+        const input = {
+            ...item.request.input.input,
+            ...replayOptions.input,
+        };
+        const missing = (item.requiresInput ?? []).filter((key) => input[key] === undefined);
+        if (missing.length > 0) {
+            throw new Error(`Failed replay requires input: ${missing.join(", ")}`);
+        }
+        if (!item.replayable && (item.requiresInput ?? []).length === 0) {
+            throw new Error(item.reason ?? "Failed replay item is not replayable");
+        }
+        return this.operation({
+            workspace: replayOptions.workspace ?? item.request.workspace,
+            op: item.request.input.op,
+            target: replayOptions.target ?? item.request.input.target,
+            input,
+            options: {
+                ...item.request.input.options,
+                ...replayOptions.options,
+            },
+        });
+    }
+    async read(workspace, target, options = {}) {
+        return this.run(workspace, "read", {}, options, target);
+    }
+    async readMany(workspace, paths, options = {}) {
+        return this.run(workspace, "read_many", { paths }, options);
+    }
+    async listFiles(workspace, target = ".", options = {}) {
+        return this.run(workspace, "list_details", {}, options, target);
+    }
+    async tree(workspace, target = ".", options = {}) {
+        return this.run(workspace, "tree", {}, options, target);
+    }
+    async write(workspace, target, content, options = {}) {
+        return this.run(workspace, "write", { content }, options, target);
+    }
+    async patch(workspace, patch, options = {}, target = ".") {
+        return this.run(workspace, "patch", { patch }, options, target);
+    }
+    async search(workspace, query, options = {}, target = ".") {
+        return this.searchText(workspace, query, options, target);
+    }
+    async searchText(workspace, query, options = {}, target = ".") {
+        return this.run(workspace, "search_text", { query }, options, target);
+    }
+    async command(workspace, command, options = {}, target = ".") {
+        return this.run(workspace, "command", { command }, options, target);
+    }
+    async processStart(workspace, command, options = {}, target = ".") {
+        return this.run(workspace, "process_start", { command }, options, target);
+    }
+    async processList(workspace, options = {}) {
+        return this.run(workspace, "process_list", {}, options);
+    }
+    async processRead(workspace, processId, options = {}) {
+        return this.run(workspace, "process_read", {}, options, processId);
+    }
+    async processStop(workspace, processId, options = {}) {
+        return this.run(workspace, "process_stop", {}, options, processId);
+    }
+    async screenList(scope) {
+        return this.computerOperation({ scope, op: "screen.list" });
+    }
+    async screenCapture(scope, target = "primary", options = {}) {
+        return this.computerOperation({ scope, op: "screen.capture", target, options });
+    }
+    async screenCaptureWindow(scope, windowId, options = {}) {
+        return this.computerOperation({ scope, op: "screen.capture_window", target: windowId, options });
+    }
+    async screenCaptureProcess(scope, processIdOrName, options = {}) {
+        return this.computerOperation({ scope, op: "screen.capture_process", target: processIdOrName, options });
+    }
+    async git(workspace, op, input = {}, options = {}, target = ".") {
+        return this.run(workspace, op, input, options, target);
+    }
+    async repoStatus(workspace, options = {}, target = ".") {
+        return this.git(workspace, "repo_status", {}, options, target);
+    }
+    async gitDiff(workspace, paths = [], options = {}, target = ".") {
+        return this.git(workspace, "git_diff", { paths }, options, target);
+    }
+    async workspaceHistory(workspace, options = {}) {
+        return this.run(workspace, "history", {}, options);
+    }
+    async workspaceHistoryInsight(workspace, options = {}) {
+        return this.run(workspace, "history_insight", {}, options);
+    }
+    async workspaceHistoryLast(workspace, options = {}) {
+        return this.workspaceHistoryInsight(workspace, {
+            ...options,
+            view: "last",
+        });
+    }
+    async workspaceHistorySessions(workspace, options = {}) {
+        return this.workspaceHistoryInsight(workspace, {
+            ...options,
+            view: "sessions",
+        });
+    }
+    async codex(workspace, prompt, options = {}, target = ".") {
+        return this.run(workspace, "codex", { prompt, ...options }, {}, target);
+    }
+    async codexPlan(workspace, prompt, options = {}, target = ".") {
+        return this.run(workspace, "codex_plan", { prompt, ...options }, {}, target);
+    }
+    async codexReview(workspace, prompt, options = {}, target = ".") {
+        return this.run(workspace, "codex_review", prompt ? { prompt, ...options } : options, {}, target);
+    }
+    async codexFix(workspace, prompt, options = {}, target = ".") {
+        return this.run(workspace, "codex_fix", { prompt, ...options }, {}, target);
+    }
+    async codexTest(workspace, options = {}, target = ".") {
+        return this.run(workspace, "codex_test", options, {}, target);
+    }
+    async codexContinue(workspace, options = {}, target = ".") {
+        return this.run(workspace, "codex_continue", options, {}, target);
+    }
+    async codexRuns(workspace, options = {}) {
+        const result = await this.run(workspace, "codex_runs", options.maxResults === undefined ? {} : { maxResults: options.maxResults }, {}, options.workflowId);
+        return result.runs;
+    }
+    async control(action, body = {}) {
+        return this.post("control", { action, ...body });
+    }
+    async get(path) {
+        return this.request(path, { method: "GET" });
+    }
+    async post(path, body) {
+        return this.request(path, {
+            method: "POST",
+            headers: { "content-type": "application/json" },
+            body: JSON.stringify(body),
+        });
+    }
+    async getJson(path) {
+        const response = await this.fetchImpl(new URL(path, this.baseUrl), {
+            method: "GET",
+            headers: this.authHeaders(),
+        });
+        const payload = await response.json();
+        if (!response.ok) {
+            const error = payload && typeof payload === "object" && "error" in payload
+                ? String(payload.error)
+                : `Computer Linker request failed with HTTP ${response.status}`;
+            throw new Error(error);
+        }
+        return payload;
+    }
+    async request(path, init) {
+        const response = await this.fetchImpl(new URL(path, this.baseUrl), {
+            ...init,
+            headers: {
+                ...this.authHeaders(),
+                ...init.headers,
+            },
+        });
+        const payload = await response.json();
+        if (!response.ok || payload.ok === false) {
+            throw new Error(payload.error ?? `Computer Linker request failed with HTTP ${response.status}`);
+        }
+        return payload.data;
+    }
+    authHeaders() {
+        return this.ownerToken ? { authorization: `Bearer ${this.ownerToken}` } : {};
+    }
+}
+export { WorkspaceLinkerClient as ComputerLinkerClient };
+function connectReadinessStatus(blockingReasons, setupReady) {
+    if (blockingReasons.length > 0)
+        return "blocked";
+    return setupReady ? "ready" : "needs_action";
+}
+function workspaceBlockingReasons(workspaces) {
+    return workspaces.workspaces.length > 0 ? [] : ["No workspaces are configured"];
+}
+function operationRegistryBlockingReasons(registry) {
+    return registry.operations.length > 0 ? [] : ["Operation registry returned no operations"];
+}
+function recommendedWorkspace(workspaces) {
+    const workspace = workspaces.find((entry) => (entry.permissions.read &&
+        entry.allowedOperations.includes("coding_context") &&
+        entry.allowedOperations.includes("search_text"))) ?? workspaces[0];
+    if (!workspace)
+        return null;
+    return {
+        id: workspace.id,
+        name: workspace.name,
+        allowedOperations: workspace.allowedOperations,
+    };
+}
+function dedupeStrings(values) {
+    return [...new Set(values.filter(Boolean))];
+}

package/dist/codex-runs.d.ts

@@ -0,0 +1,35 @@
+import type { ProcessResult, WorkspaceOperationName } from "./workspace-operations.js";
+export interface CodexRunRecord {
+    timestamp: string;
+    workflowId: string;
+    workflowType: Extract<WorkspaceOperationName, "codex_plan" | "codex_review" | "codex_fix" | "codex_test" | "codex_continue">;
+    workspaceId: string;
+    workspaceRoot: string;
+    workingDirectory: string;
+    continuedFromWorkflowId?: string;
+    promptPreview: string;
+    userPromptPreview?: string;
+    exitCode: number | null;
+    signal?: string;
+    timedOut: boolean;
+    stdoutPreview: string;
+    stderrPreview: string;
+    stdoutBytes: number;
+    stderrBytes: number;
+    stdoutTruncated: boolean;
+    stderrTruncated: boolean;
+    preRunChangeSummary: unknown;
+    postRunChangeSummary: unknown;
+    historyInsight?: unknown;
+}
+export interface WriteCodexRunRecordInput extends Omit<CodexRunRecord, "timestamp" | "exitCode" | "signal" | "timedOut" | "stdoutPreview" | "stderrPreview" | "stdoutBytes" | "stderrBytes" | "stdoutTruncated" | "stderrTruncated"> {
+    result: ProcessResult;
+    maxPreviewBytes?: number;
+}
+export interface ReadCodexRunRecordsOptions {
+    workspaceId?: string;
+    workflowId?: string;
+    maxResults?: number;
+}
+export declare function writeCodexRunRecord(input: WriteCodexRunRecordInput): CodexRunRecord;
+export declare function readCodexRunRecords(options?: ReadCodexRunRecordsOptions): CodexRunRecord[];

package/dist/codex-runs.js

@@ -0,0 +1,66 @@
+import { appendFileSync, existsSync, mkdirSync, readFileSync } from "node:fs";
+import { dirname } from "node:path";
+import { codexRunsPath } from "./config.js";
+export function writeCodexRunRecord(input) {
+    const stdout = previewText(input.result.stdout, input.maxPreviewBytes ?? 32 * 1024);
+    const stderr = previewText(input.result.stderr, input.maxPreviewBytes ?? 32 * 1024);
+    const record = {
+        timestamp: new Date().toISOString(),
+        workflowId: input.workflowId,
+        workflowType: input.workflowType,
+        workspaceId: input.workspaceId,
+        workspaceRoot: input.workspaceRoot,
+        workingDirectory: input.workingDirectory,
+        continuedFromWorkflowId: input.continuedFromWorkflowId,
+        promptPreview: input.promptPreview,
+        userPromptPreview: input.userPromptPreview,
+        exitCode: input.result.exitCode,
+        signal: input.result.signal,
+        timedOut: input.result.timedOut,
+        stdoutPreview: stdout.text,
+        stderrPreview: stderr.text,
+        stdoutBytes: stdout.bytes,
+        stderrBytes: stderr.bytes,
+        stdoutTruncated: stdout.truncated,
+        stderrTruncated: stderr.truncated,
+        preRunChangeSummary: input.preRunChangeSummary,
+        postRunChangeSummary: input.postRunChangeSummary,
+        historyInsight: input.historyInsight,
+    };
+    const path = codexRunsPath();
+    mkdirSync(dirname(path), { recursive: true });
+    appendFileSync(path, `${JSON.stringify(record)}\n`, { mode: 0o600 });
+    return record;
+}
+export function readCodexRunRecords(options = {}) {
+    const path = codexRunsPath();
+    if (!existsSync(path))
+        return [];
+    let records = readFileSync(path, "utf8")
+        .trimEnd()
+        .split("\n")
+        .filter(Boolean)
+        .map((line) => JSON.parse(line))
+        .reverse();
+    if (options.workspaceId) {
+        records = records.filter((record) => record.workspaceId === options.workspaceId);
+    }
+    if (options.workflowId) {
+        records = records.filter((record) => record.workflowId === options.workflowId);
+    }
+    const limit = Number.isInteger(options.maxResults) && options.maxResults && options.maxResults > 0
+        ? Math.min(options.maxResults, 1000)
+        : 50;
+    return records.slice(0, limit);
+}
+function previewText(value, maxBytes) {
+    const bytes = Buffer.byteLength(value, "utf8");
+    if (bytes <= maxBytes) {
+        return { text: value, bytes, truncated: false };
+    }
+    return {
+        text: Buffer.from(value, "utf8").subarray(0, maxBytes).toString("utf8"),
+        bytes,
+        truncated: true,
+    };
+}