@myagentroam/node 0.1.3 → 0.1.6

package/dist/control-outbound-scheduler.d.ts

@@ -0,0 +1,26 @@
+import type { NodeEnvelope } from '@myagentroam/protocol';
+interface WritableControlSocket {
+    readonly readyState: number;
+    readonly bufferedAmount: number;
+    send(value: string): void;
+}
+/** Keeps control responses responsive while reliable Workbench events are busy. */
+export declare class ControlOutboundScheduler {
+    private readonly socket;
+    private readonly high;
+    private readonly normal;
+    private scheduled;
+    private retryTimer;
+    private backpressureStartedAt;
+    private backpressureLogged;
+    private maximumHighDepth;
+    private maximumNormalDepth;
+    constructor(socket: () => WritableControlSocket | undefined);
+    enqueue(envelope: NodeEnvelope, priority: 'high' | 'normal'): void;
+    reset(): void;
+    private schedule;
+    private flush;
+    private waitForBackpressure;
+    private finishBackpressure;
+}
+export {};

package/dist/control-outbound-scheduler.js

@@ -0,0 +1,121 @@
+import { nodeLog } from './operational.js';
+const MAX_FRAMES_PER_TURN = 32;
+const MAX_BYTES_PER_TURN = 256 * 1024;
+const SOCKET_NORMAL_DIRECT_WATER_BYTES = 256 * 1024;
+const SOCKET_HIGH_WATER_BYTES = 1024 * 1024;
+const BACKPRESSURE_RETRY_MS = 5;
+/** Keeps control responses responsive while reliable Workbench events are busy. */
+export class ControlOutboundScheduler {
+    socket;
+    high = [];
+    normal = [];
+    scheduled = false;
+    retryTimer;
+    backpressureStartedAt;
+    backpressureLogged = false;
+    maximumHighDepth = 0;
+    maximumNormalDepth = 0;
+    constructor(socket) {
+        this.socket = socket;
+    }
+    enqueue(envelope, priority) {
+        const socket = this.socket();
+        const bufferedAmount = socket?.bufferedAmount ?? 0;
+        if (socket !== undefined &&
+            socket.readyState === 1 &&
+            this.high.length === 0 &&
+            (priority === 'high' || this.normal.length === 0) &&
+            bufferedAmount <= SOCKET_NORMAL_DIRECT_WATER_BYTES) {
+            socket.send(JSON.stringify(envelope));
+            return;
+        }
+        (priority === 'high' ? this.high : this.normal).push(envelope);
+        this.maximumHighDepth = Math.max(this.maximumHighDepth, this.high.length);
+        this.maximumNormalDepth = Math.max(this.maximumNormalDepth, this.normal.length);
+        this.schedule();
+    }
+    reset() {
+        this.high.length = 0;
+        this.normal.length = 0;
+        this.scheduled = false;
+        if (this.retryTimer !== undefined)
+            clearTimeout(this.retryTimer);
+        this.retryTimer = undefined;
+        this.finishBackpressure('reset');
+    }
+    schedule() {
+        if (this.scheduled || this.retryTimer !== undefined)
+            return;
+        this.scheduled = true;
+        setImmediate(() => this.flush());
+    }
+    flush() {
+        this.scheduled = false;
+        const socket = this.socket();
+        if (socket === undefined || socket.readyState !== 1)
+            return;
+        if ((socket.bufferedAmount ?? 0) > SOCKET_HIGH_WATER_BYTES) {
+            this.waitForBackpressure(socket, 'high');
+            return;
+        }
+        let frames = 0;
+        let bytes = 0;
+        while (frames < MAX_FRAMES_PER_TURN) {
+            const queue = this.high.length > 0 ? this.high : this.normal;
+            const envelope = queue[0];
+            if (envelope === undefined)
+                break;
+            // Reliable Workbench events may be replayed in a large burst after a
+            // reconnect. Stop normal traffic early so a later HTTP/control response
+            // always has WebSocket buffer headroom instead of waiting behind that burst.
+            if (queue === this.normal &&
+                (socket.bufferedAmount ?? 0) > SOCKET_NORMAL_DIRECT_WATER_BYTES) {
+                this.waitForBackpressure(socket, 'normal');
+                return;
+            }
+            const serialized = JSON.stringify(envelope);
+            const size = Buffer.byteLength(serialized);
+            if (frames > 0 && bytes + size > MAX_BYTES_PER_TURN)
+                break;
+            queue.shift();
+            socket.send(serialized);
+            frames += 1;
+            bytes += size;
+            if ((socket.bufferedAmount ?? 0) > SOCKET_HIGH_WATER_BYTES)
+                break;
+        }
+        if (this.high.length > 0 || this.normal.length > 0)
+            this.schedule();
+        else
+            this.finishBackpressure('drained');
+    }
+    waitForBackpressure(socket, level) {
+        this.backpressureStartedAt ??= Date.now();
+        if (!this.backpressureLogged && Date.now() - this.backpressureStartedAt >= 250) {
+            this.backpressureLogged = true;
+            nodeLog('control.outbound.backpressure', {
+                level,
+                bufferedBytes: socket.bufferedAmount,
+                highDepth: this.high.length,
+                normalDepth: this.normal.length
+            });
+        }
+        this.retryTimer = setTimeout(() => {
+            this.retryTimer = undefined;
+            this.schedule();
+        }, BACKPRESSURE_RETRY_MS);
+    }
+    finishBackpressure(reason) {
+        if (this.backpressureLogged)
+            nodeLog('control.outbound.backpressure.recovered', {
+                reason,
+                durationMs: Date.now() - (this.backpressureStartedAt ?? Date.now()),
+                maximumHighDepth: this.maximumHighDepth,
+                maximumNormalDepth: this.maximumNormalDepth
+            });
+        this.backpressureStartedAt = undefined;
+        this.backpressureLogged = false;
+        this.maximumHighDepth = 0;
+        this.maximumNormalDepth = 0;
+    }
+}

package/dist/database.d.ts

@@ -106,6 +106,10 @@ export interface NodeConversationTurn {
     readonly model: string | null;
     readonly effort: string | null;
     readonly access: string | null;
+    readonly rewind?: {
+        readonly before: string | null;
+        readonly after: string;
+    };
     readonly items: readonly NodeConversationItem[];
     readonly startedAt: number | null;
     readonly completedAt: number | null;

package/dist/database.js

@@ -4,8 +4,9 @@ import { dirname } from 'node:path';
 import { DatabaseSync } from 'node:sqlite';
 import { runnerDefaultConfigurationSchema } from '@myagentroam/protocol';
 import { assertNodeSchema, NODE_SCHEMA_V1 } from './migrations/v001.js';
-import { assertNodeSchemaV2, migrateNodeSchemaV2, NODE_SCHEMA_VERSION_V2 } from './migrations/v002.js';
-const NODE_SCHEMA_VERSION = NODE_SCHEMA_VERSION_V2;
+import { assertNodeSchemaV2, migrateNodeSchemaV2 } from './migrations/v002.js';
+import { assertNodeSchemaV3, migrateNodeSchemaV3, NODE_SCHEMA_VERSION_V3 } from './migrations/v003.js';
+const NODE_SCHEMA_VERSION = NODE_SCHEMA_VERSION_V3;
 export class NodeDatabase {
     now;
     activeWorkspaceLeaseCount() {
@@ -610,7 +611,7 @@ export class NodeDatabase {
          ORDER BY rowid DESC LIMIT ?`)
             .all(input.sessionId, input.nativeOnly === true ? 1 : 0, cursor?.value ?? null, cursor?.value ?? 0, limit + 1);
         const page = rows.slice(0, limit);
-        const turns = page.map((row) => this.readConversationTurn(row));
+        const turns = page.map((row) => this.readConversationTurn(row)).reverse();
         const last = page.at(-1);
         return {
             turns,
@@ -1025,6 +1026,8 @@ function migrate(database) {
                 .prepare('INSERT INTO node_schema_migrations (version, applied_at) VALUES (?, ?), (?, ?)')
                 .run(1, Date.now(), 2, Date.now());
             database.exec('COMMIT');
+            migrateNodeSchemaV3(database);
+            assertNodeSchemaV3(database);
             return;
         }
         catch (error) {
@@ -1061,6 +1064,8 @@ function migrate(database) {
         }
         migrateNodeSchemaV2(database);
         assertNodeSchemaV2(database);
+        migrateNodeSchemaV3(database);
+        assertNodeSchemaV3(database);
         return;
     }
     if (current === 0) {
@@ -1082,12 +1087,12 @@ function migrate(database) {
         .get();
     if (numberValue(afterBaseline, 'version') === 1)
         migrateNodeSchemaV2(database);
-    if (NODE_SCHEMA_VERSION === 2) {
-        assertNodeSchemaV2(database);
-    }
-    else {
-        assertNodeSchema(database);
-    }
+    const afterV2 = database
+        .prepare('SELECT MAX(version) AS version FROM node_schema_migrations')
+        .get();
+    if (numberValue(afterV2, 'version') === 2)
+        migrateNodeSchemaV3(database);
+    assertNodeSchemaV3(database);
 }
 function sessionMetadata(row) {
     const raw = JSON.parse(stringValue(row, 'metadata'));
@@ -1130,6 +1135,7 @@ function initializeEphemeralRuntimeTables(database) {
         if (match === null || !runtimeTables.has(match[1] ?? ''))
             continue;
         database.exec(statement
+            .replaceAll("runner IN ('codex', 'claude-code')", "runner IN ('codex', 'claude-code', 'opencode')")
             .replace(/^CREATE TABLE IF NOT EXISTS/, 'CREATE TEMP TABLE IF NOT EXISTS')
             .replace('CREATE TEMP TABLE IF NOT EXISTS agent_sessions', 'CREATE TEMP TABLE IF NOT EXISTS legacy_agent_sessions')
             .replaceAll('REFERENCES agent_sessions', 'REFERENCES legacy_agent_sessions')
@@ -1389,4 +1395,3 @@ function transitionAllowed(current, next) {
         (current === 'CANCELLING' &&
             (next === 'CANCELLED' || next === 'FAILED' || next === 'INTERRUPTED')));
 }
-//# sourceMappingURL=database.js.map

package/dist/event-buffer.js

@@ -26,4 +26,3 @@ export class ReliableWorkbenchEventBuffer {
         return this.pending.size;
     }
 }
-//# sourceMappingURL=event-buffer.js.map

package/dist/fake-runner.js

@@ -127,4 +127,3 @@ export class FakeRunner {
             resolve(undefined);
     }
 }
-//# sourceMappingURL=fake-runner.js.map

package/dist/health.js

@@ -1,4 +1,3 @@
 export function getNodeHealth() {
     return { status: 'ok', platform: process.platform };
 }
-//# sourceMappingURL=health.js.map

package/dist/main.js

@@ -4,6 +4,7 @@ import { NodeConnector } from './connector.js';
 import { loadNodeConfig, nodeConfigPath, nodeDatabasePath } from './config.js';
 import { getNodeHealth } from './health.js';
 import { removeServiceDefinition, writeServiceDefinition } from './service.js';
+import { superviseNode } from './supervisor.js';
 const [command = 'status', ...args] = process.argv.slice(2);
 const config = readOption(args, '--config') ?? nodeConfigPath();
 const output = readOption(args, '--output') ?? defaultServicePath();
@@ -14,6 +15,11 @@ if (command === 'run') {
         process.once(signal, () => connector.stop());
     }
 }
+else if (command === 'supervise') {
+    if (process.argv[1] === undefined)
+        throw new Error('NODE_ENTRYPOINT_UNAVAILABLE');
+    await superviseNode(config, process.argv[1]);
+}
 else if (command === 'install') {
     await writeCurrentServiceDefinition(output, config);
     process.stdout.write(`${output}\n`);
@@ -44,4 +50,3 @@ async function writeCurrentServiceDefinition(output, configPath) {
     const nodeConfig = await loadNodeConfig(configPath);
     await writeServiceDefinition(output, process.execPath, configPath, process.platform, process.argv[1], [dirname(nodeDatabasePath(nodeConfig, configPath)), ...nodeConfig.allowedRoots]);
 }
-//# sourceMappingURL=main.js.map

package/dist/migrations/v001.js

@@ -246,4 +246,3 @@ export function assertNodeSchema(database) {
         throw new Error('NODE_DATABASE_BASELINE_MISMATCH:approvals');
     }
 }
-//# sourceMappingURL=v001.js.map

package/dist/migrations/v002.js

@@ -141,4 +141,3 @@ function integer(row, key) {
 function nullableInteger(row, key) {
     return row[key] === null || row[key] === undefined ? null : integer(row, key);
 }
-//# sourceMappingURL=v002.js.map

package/dist/migrations/v003.d.ts

@@ -0,0 +1,4 @@
+import type { DatabaseSync } from 'node:sqlite';
+export declare const NODE_SCHEMA_VERSION_V3 = 3;
+export declare function migrateNodeSchemaV3(database: DatabaseSync): void;
+export declare function assertNodeSchemaV3(database: DatabaseSync): void;

package/dist/migrations/v003.js

@@ -0,0 +1,44 @@
+export const NODE_SCHEMA_VERSION_V3 = 3;
+export function migrateNodeSchemaV3(database) {
+    database.exec('PRAGMA foreign_keys = OFF');
+    database.exec('BEGIN IMMEDIATE');
+    try {
+        database.exec(`ALTER TABLE agent_sessions RENAME TO agent_sessions_v2;
+      CREATE TABLE agent_sessions (
+        id TEXT PRIMARY KEY,
+        workspace_id TEXT NOT NULL REFERENCES workspaces(id) ON DELETE CASCADE,
+        runner TEXT NOT NULL CHECK (runner IN ('codex', 'claude-code', 'opencode')),
+        pin_order INTEGER CHECK (pin_order IS NULL OR pin_order >= 0),
+        metadata TEXT NOT NULL CHECK (json_valid(metadata))
+      ) STRICT;
+      INSERT INTO agent_sessions SELECT * FROM agent_sessions_v2;
+      DROP TABLE agent_sessions_v2;
+      ALTER TABLE runner_defaults RENAME TO runner_defaults_v2;
+      CREATE TABLE runner_defaults (
+        runner TEXT PRIMARY KEY CHECK (runner IN ('codex', 'claude-code', 'opencode')),
+        model TEXT NOT NULL, effort TEXT NOT NULL, access TEXT NOT NULL
+      ) STRICT;
+      INSERT INTO runner_defaults SELECT * FROM runner_defaults_v2;
+      DROP TABLE runner_defaults_v2;`);
+        database
+            .prepare('INSERT INTO node_schema_migrations (version, applied_at) VALUES (?, ?)')
+            .run(NODE_SCHEMA_VERSION_V3, Date.now());
+        database.exec('COMMIT');
+    }
+    catch (error) {
+        database.exec('ROLLBACK');
+        throw error;
+    }
+    finally {
+        database.exec('PRAGMA foreign_keys = ON');
+    }
+}
+export function assertNodeSchemaV3(database) {
+    for (const table of ['agent_sessions', 'runner_defaults']) {
+        const row = database
+            .prepare("SELECT sql FROM sqlite_master WHERE type = 'table' AND name = ?")
+            .get(table);
+        if (typeof row?.sql !== 'string' || !row.sql.includes("'opencode'"))
+            throw new Error(`NODE_DATABASE_SCHEMA_INVALID:${table}:runner`);
+    }
+}

package/dist/native-jsonl-reader.d.ts

@@ -0,0 +1,14 @@
+export interface JsonlWindow {
+    readonly content: string;
+    readonly truncated: boolean;
+    readonly size: number;
+}
+/** Reads bounded head/tail windows without ever loading an unbounded transcript. */
+export declare function readJsonlWindow(path: string, options: {
+    readonly headBytes?: number;
+    readonly tailBytes?: number;
+}): Promise<JsonlWindow | undefined>;
+/** Parses records one at a time, avoiding the allocation of a full line array. */
+export declare function forEachJsonlRecord(content: string, visit: (record: Record<string, unknown>) => void): void;
+export declare function listJsonlFiles(directory: string): Promise<readonly string[]>;
+export declare function mapConcurrent<T, R>(values: readonly T[], concurrency: number, map: (value: T, index: number) => Promise<R>): Promise<readonly R[]>;

package/dist/native-jsonl-reader.js

@@ -0,0 +1,97 @@
+import { open, readdir } from 'node:fs/promises';
+import { join } from 'node:path';
+/** Reads bounded head/tail windows without ever loading an unbounded transcript. */
+export async function readJsonlWindow(path, options) {
+    try {
+        const handle = await open(path, 'r');
+        try {
+            const metadata = await handle.stat();
+            const headSize = Math.min(options.headBytes ?? 0, metadata.size);
+            const remaining = metadata.size - headSize;
+            const tailSize = Math.min(options.tailBytes ?? 0, remaining);
+            const head = await readAt(handle, headSize, 0);
+            const tailOffset = metadata.size - tailSize;
+            const tail = await readAt(handle, tailSize, tailOffset);
+            const contiguous = headSize > 0 && tailSize > 0 && tailOffset === headSize;
+            return {
+                content: contiguous
+                    ? Buffer.concat([head, tail]).toString('utf8')
+                    : `${head.toString('utf8')}${headSize > 0 && tailSize > 0 ? '\n' : ''}${tail.toString('utf8')}`,
+                truncated: headSize + tailSize < metadata.size,
+                size: metadata.size
+            };
+        }
+        finally {
+            await handle.close();
+        }
+    }
+    catch {
+        return undefined;
+    }
+}
+/** Parses records one at a time, avoiding the allocation of a full line array. */
+export function forEachJsonlRecord(content, visit) {
+    let start = 0;
+    while (start < content.length) {
+        const newline = content.indexOf('\n', start);
+        const end = newline < 0 ? content.length : newline;
+        if (end > start) {
+            try {
+                const value = JSON.parse(content.slice(start, end));
+                if (isRecord(value))
+                    visit(value);
+            }
+            catch {
+                // A partial or damaged record does not hide subsequent valid records.
+            }
+        }
+        if (newline < 0)
+            return;
+        start = newline + 1;
+    }
+}
+export async function listJsonlFiles(directory) {
+    const files = [];
+    const walk = async (current) => {
+        let entries;
+        try {
+            entries = await readdir(current, { withFileTypes: true });
+        }
+        catch {
+            return;
+        }
+        for (const entry of entries) {
+            const path = join(current, entry.name);
+            if (entry.isDirectory())
+                await walk(path);
+            else if (entry.isFile() && entry.name.endsWith('.jsonl'))
+                files.push(path);
+        }
+    };
+    await walk(directory);
+    return files;
+}
+export async function mapConcurrent(values, concurrency, map) {
+    const results = Array(values.length);
+    let next = 0;
+    const worker = async () => {
+        while (true) {
+            const index = next++;
+            if (index >= values.length)
+                return;
+            results[index] = await map(values[index], index);
+        }
+    };
+    await Promise.all(Array.from({ length: Math.min(Math.max(1, concurrency), values.length) }, worker));
+    return results;
+}
+async function readAt(handle, size, position) {
+    if (size === 0)
+        return Buffer.alloc(0);
+    const buffer = Buffer.allocUnsafe(size);
+    const { bytesRead } = await handle.read(buffer, 0, size, position);
+    return buffer.subarray(0, bytesRead);
+}
+function isRecord(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}

package/dist/native-session-history.d.ts

@@ -4,6 +4,7 @@ export interface NativeTranscriptMessage {
     readonly role: 'USER' | 'ASSISTANT';
     readonly text: string;
     readonly createdAt: number | null;
+    readonly nativeId?: string;
 }
 export interface NativeTranscriptToolCall {
     readonly kind: 'tool_call';
@@ -14,10 +15,35 @@ export interface NativeTranscriptToolCall {
     readonly inputTruncated: boolean;
     readonly outputSummary: string | null;
     readonly outputTruncated: boolean;
+    /** Metadata only: native transcript image bytes are never retained here. */
+    readonly imageAttachments?: readonly NativeTranscriptImageAttachment[];
     readonly failed: boolean;
     readonly createdAt: number | null;
+    readonly nativeId?: string;
 }
-export type NativeTranscriptItem = NativeTranscriptMessage | NativeTranscriptToolCall;
+export interface NativeTranscriptUnknown {
+    readonly kind: 'unknown';
+    readonly sourceEventType: string;
+    readonly label: string;
+    readonly createdAt: number | null;
+    readonly nativeId?: string;
+}
+export interface NativeTranscriptReasoningSummary {
+    readonly kind: 'reasoning_summary';
+    readonly sections: readonly {
+        readonly index: number;
+        readonly text: string;
+    }[];
+    readonly createdAt: number | null;
+    readonly nativeId?: string;
+}
+export interface NativeTranscriptImageAttachment {
+    readonly name: string;
+    readonly mime: string;
+    /** Codex-owned local artifact path; never sent to Web. */
+    readonly localPath?: string;
+}
+export type NativeTranscriptItem = NativeTranscriptMessage | NativeTranscriptToolCall | NativeTranscriptReasoningSummary | NativeTranscriptUnknown;
 export interface NativeSessionHistory {
     readonly runner: RunnerName;
     readonly externalSessionId: string;
@@ -39,9 +65,11 @@ export interface NativeCodexContextUsage {
     readonly usedTokens: number;
     readonly maxTokens: number;
 }
-export type NativeCodexTaskActivity = 'ACTIVE' | 'IDLE' | 'STALE';
-/** Reads the latest durable Codex task lifecycle event without exposing it. */
-export declare function readCodexNativeTaskActivity(workspacePath: string, externalSessionId: string, now?: number): Promise<NativeCodexTaskActivity | undefined>;
+export interface NativeClaudeContextUsage {
+    readonly model: string;
+    readonly usedTokens: number;
+    readonly maxTokens: number;
+}
 /**
  * Read-only adapter for the supported vendor JSONL stores.  It requires an
  * explicit cwd on the record and returns normalized visible messages and tool
@@ -63,6 +91,15 @@ export declare function readNativeSession(runner: RunnerName, workspacePath: str
  * full-history scan.
  */
 export declare function readCodexNativeContextUsage(workspacePath: string, externalSessionId: string): Promise<NativeCodexContextUsage | undefined>;
+/** Reads the latest actual Claude prompt occupancy without starting a CLI/SDK control stream. */
+export declare function readClaudeNativeContextUsage(workspacePath: string, externalSessionId: string, options?: {
+    readonly environment?: NodeJS.ProcessEnv;
+    readonly settingsPath?: string;
+}): Promise<NativeClaudeContextUsage | undefined>;
+export declare function claudeContextWindowTokens(options?: {
+    readonly environment?: NodeJS.ProcessEnv;
+    readonly settingsPath?: string;
+}): Promise<number>;
 /**
  * Permanently removes exactly one previously discovered transcript. The
  * caller supplies no path: the in-process discovery index resolves it, then