@cmetech/otto 1.1.0 → 1.2.4

package/packages/coworker-scratchpad/dist/cell-archive.js

@@ -0,0 +1,77 @@
+import { appendFileSync, existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs';
+import { join } from 'node:path';
+export const CELLS_SCHEMA_VERSION = 1;
+export class CellArchive {
+    dir;
+    now;
+    path;
+    nextId;
+    #lastId;
+    #leafId;
+    constructor(dir, now = Date.now) {
+        this.dir = dir;
+        this.now = now;
+        this.path = join(dir, 'cells.jsonl');
+        const { nextId, lastId } = this.scan();
+        this.nextId = nextId;
+        this.#lastId = lastId;
+        this.#leafId = lastId;
+    }
+    scan() {
+        if (!existsSync(this.path))
+            return { nextId: 1, lastId: null };
+        let lastId = null;
+        for (const line of readFileSync(this.path, 'utf8').split('\n')) {
+            if (!line.trim())
+                continue;
+            try {
+                const obj = JSON.parse(line);
+                if (typeof obj.id === 'number')
+                    lastId = obj.id;
+            }
+            catch {
+                // header or corrupt line -> ignore
+            }
+        }
+        return { nextId: (lastId ?? 0) + 1, lastId };
+    }
+    ensureHeader() {
+        if (existsSync(this.path))
+            return;
+        mkdirSync(this.dir, { recursive: true });
+        appendFileSync(this.path, JSON.stringify({ type: 'header', version: CELLS_SCHEMA_VERSION }) + '\n');
+    }
+    append(input) {
+        this.ensureHeader();
+        const id = this.nextId++;
+        const entry = {
+            id,
+            parentId: this.#leafId,
+            code: input.code,
+            ok: input.ok,
+            ...(input.ok ? { value: input.value } : { error: input.error }),
+            stdout: input.stdout,
+            ts: new Date(this.now()).toISOString(),
+        };
+        appendFileSync(this.path, JSON.stringify(entry) + '\n');
+        this.#lastId = id;
+        this.#leafId = id;
+        return entry;
+    }
+    get lastId() {
+        return this.#lastId;
+    }
+    get leafId() {
+        return this.#leafId;
+    }
+    setLeaf(id) {
+        this.#leafId = id;
+    }
+    reset() {
+        mkdirSync(this.dir, { recursive: true });
+        writeFileSync(this.path, JSON.stringify({ type: 'header', version: CELLS_SCHEMA_VERSION }) + '\n');
+        this.nextId = 1;
+        this.#lastId = null;
+        this.#leafId = null;
+    }
+}

package/packages/coworker-scratchpad/dist/cell-tree.d.ts

@@ -0,0 +1,14 @@
+import type { CellEntry } from './cell-archive.js';
+export interface TreeNode {
+    cell: CellEntry;
+    children: TreeNode[];
+}
+export interface CellTree {
+    root: TreeNode | null;
+    byId: Map<number, TreeNode>;
+    orphans: TreeNode[];
+}
+export declare function projectTree(cells: CellEntry[]): CellTree;
+export declare function findLeaves(tree: CellTree): TreeNode[];
+export declare function validateLeafId(tree: CellTree, id: number): void;
+export declare function formatTreeText(tree: CellTree, currentLeaf?: number | null): string;

package/packages/coworker-scratchpad/dist/cell-tree.js

@@ -0,0 +1,72 @@
+export function projectTree(cells) {
+    const byId = new Map();
+    for (const cell of cells)
+        byId.set(cell.id, { cell, children: [] });
+    const orphans = [];
+    const rootCandidates = [];
+    for (const cell of cells) {
+        const node = byId.get(cell.id);
+        if (cell.parentId === null) {
+            rootCandidates.push(node);
+            continue;
+        }
+        const parent = byId.get(cell.parentId);
+        if (parent)
+            parent.children.push(node);
+        else
+            orphans.push(node);
+    }
+    let root = null;
+    if (rootCandidates.length >= 1) {
+        root = rootCandidates[0];
+        // 1d/1d2 invariant: exactly one root. Defensive: extra roots become orphans.
+        for (let i = 1; i < rootCandidates.length; i++)
+            orphans.push(rootCandidates[i]);
+    }
+    return { root, byId, orphans };
+}
+export function findLeaves(tree) {
+    const out = [];
+    for (const node of tree.byId.values()) {
+        if (node.children.length === 0)
+            out.push(node);
+    }
+    return out;
+}
+export function validateLeafId(tree, id) {
+    if (!tree.byId.has(id)) {
+        throw new Error(`cell id ${id} not found`);
+    }
+}
+function truncate(s, max) {
+    if (s.length <= max)
+        return s;
+    return s.slice(0, max - 1) + '…';
+}
+function summarizeCell(cell) {
+    const okFlag = cell.ok ? 'ok ' : 'err';
+    const detail = cell.ok
+        ? `value=${truncate(JSON.stringify(cell.value ?? null), 40)}`
+        : `error=${truncate(cell.error?.message ?? '', 40)}`;
+    const codePreview = truncate(cell.code.split('\n')[0], 60);
+    return `#${cell.id} ${okFlag} ${detail.padEnd(45)} ${codePreview}`;
+}
+function renderNode(node, depth, lastSibling, currentLeaf, out) {
+    const indent = '  '.repeat(depth);
+    const connector = lastSibling ? '└─' : '├─';
+    const marker = currentLeaf === node.cell.id ? ' *' : '';
+    out.push(`${indent}${connector} ${summarizeCell(node.cell)}${marker}`);
+    const last = node.children.length - 1;
+    node.children.forEach((child, i) => renderNode(child, depth + 1, i === last, currentLeaf, out));
+}
+export function formatTreeText(tree, currentLeaf) {
+    const lines = [];
+    if (tree.root)
+        renderNode(tree.root, 0, true, currentLeaf ?? null, lines);
+    if (tree.orphans.length > 0) {
+        lines.push('# orphans:');
+        const last = tree.orphans.length - 1;
+        tree.orphans.forEach((o, i) => renderNode(o, 0, i === last, currentLeaf ?? null, lines));
+    }
+    return lines.join('\n');
+}

package/packages/coworker-scratchpad/dist/child-process-runtime.d.ts

@@ -0,0 +1,129 @@
+import type { CredentialInjector } from '@otto/coworker-vault';
+import type { ArtifactCreateDrawer, DataLoadDrawer, RecoveryNote, SnapshotResult } from './kernel-protocol.js';
+export interface CellResult {
+    value: unknown;
+    stdout: string;
+}
+export interface ChildProcessRuntimeOptions {
+    workspace: string;
+    onDataLoad?: (drawer: DataLoadDrawer) => void;
+    cellTimeoutMs?: number;
+    inactivityTimeoutMs?: number;
+    inactivityAfterProgressMs?: number;
+    cancelGraceMs?: number;
+    entryPath?: string;
+    scratchpadDir?: string;
+    /**
+     * Phase 2 Task 13: optional vault credential injector. When provided alongside
+     * a non-empty `bindings`, the runtime adds OTTO_DS_* env vars to the spawned
+     * kernel's environment (after the existing env filter). Absent => no-op; the
+     * runtime behaves exactly as it did pre-Phase-2.
+     */
+    injector?: CredentialInjector;
+    bindings?: string[];
+    /**
+     * Phase 2 Task 13: identifies this runtime's scratchpad for audit records the
+     * injector emits. The runtime itself doesn't otherwise use this field.
+     */
+    scratchpadName?: string;
+    /**
+     * Phase 2 Task 13: session id stamped on audit records the injector emits.
+     * Empty string is a valid no-session value.
+     */
+    sessionId?: string;
+    /**
+     * Phase 4 Task 10: Layer-B fan-out for artifact_create events. The kernel
+     * emits one of these after every successful otto.artifact.create RPC; the
+     * runtime forwards the drawer to this callback so the manager can record it
+     * into memory. Absent => artifact_create events are dropped.
+     */
+    onArtifactCreate?: (drawer: ArtifactCreateDrawer) => void;
+    /**
+     * Phase 4 Task 10: parent-side handler for `artifact_create` RPC requests.
+     * The runtime calls this when it sees an `{type:'request', request:'artifact_create'}`
+     * frame on the child's stdout and writes the resolved response (or an error
+     * frame) back to the child's stdin. If absent, the request is rejected with
+     * "artifacts unavailable" so the cell fails fast instead of hanging.
+     */
+    handleArtifactCreate?: (req: {
+        kind: string;
+        name: string;
+    }) => Promise<{
+        slug: string;
+        uri: string;
+        primary_path: string;
+    }>;
+    /**
+     * Phase 4 Task 10: parent-side handler for `artifact_update` RPC requests.
+     * Mirror of handleArtifactCreate for the update path.
+     */
+    handleArtifactUpdate?: (req: {
+        slug: string;
+        files: Array<{
+            path: string;
+            content: string;
+        }>;
+    }) => Promise<{
+        files_touched: string[];
+    }>;
+}
+export declare class ChildProcessRuntime {
+    private readonly options;
+    private child;
+    private readonly pending;
+    private readonly pendingSnapshots;
+    private activeId;
+    private nextId;
+    private alive;
+    private childReady;
+    private disposed;
+    private restartsSinceSuccess;
+    private recoveryNotes_;
+    private resolveReady;
+    private rejectReady;
+    private ready;
+    /**
+     * Phase 2 Task 13: timestamp of the most recent successful spawn(). Used by
+     * higher-level staleness checks (Task 15) to decide whether a warm kernel's
+     * env-injected credentials need to be refreshed. Pre-start() value is epoch
+     * so callers can distinguish "never spawned" without nullable juggling.
+     */
+    spawnTime: Date;
+    constructor(options: ChildProcessRuntimeOptions);
+    start(): Promise<void>;
+    /**
+     * Phase 2 Task 13: env construction split out so the injector hop has a clean
+     * seam to extend. Existing semantics unchanged: filterEnv applies the kernel's
+     * allowlist/denylist, then (when configured) the injector overlays OTTO_DS_*
+     * vars from vault entries. Only the spawned child sees the result; the parent
+     * process.env is never mutated.
+     */
+    private buildBaseEnv;
+    private spawnChild;
+    private readLoop;
+    private resetInactivity;
+    private onInactivityTimeout;
+    private onTotalTimeout;
+    runCell(code: string): Promise<CellResult>;
+    cancel(): Promise<void>;
+    snapshot(): Promise<SnapshotResult>;
+    /**
+     * Phase 4 Task 10: service an `artifact_create` RPC request from the kernel.
+     * Calls the manager-supplied handler (if any), serializes the result into a
+     * `{type:'response', request:'artifact_create'}` frame, and writes it back
+     * to the child's stdin. Errors are surfaced to the kernel as `ok:false`
+     * frames so the awaiting cell rejects cleanly rather than hanging.
+     */
+    private handleArtifactCreateRpc;
+    /**
+     * Phase 4 Task 10: service an `artifact_update` RPC request. Mirror of
+     * handleArtifactCreateRpc for the update path.
+     */
+    private handleArtifactUpdateRpc;
+    private rejectActive;
+    private failAllPending;
+    private markDead;
+    get hasActiveCell(): boolean;
+    get recoveryNotes(): readonly RecoveryNote[];
+    dispose(): Promise<void>;
+}