@addai/node 0.4.0

package/dist/control-server.js

@@ -0,0 +1,292 @@
+"use strict";
+// Local HTTP control surface, bound only to 127.0.0.1. The CodeFlows
+// desktop polls this to detect whether the daemon is running and to
+// surface stats / sessions / projects for THIS computer's runtime
+// without needing the user to sign in.
+//
+// The daemon authenticates as the runtime on the user's behalf via
+// its pairing token. Routes that hit Supabase fail gracefully (return
+// 503 with `error: 'not_paired'`) when the daemon is unpaired.
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.startControlServer = startControlServer;
+const http = __importStar(require("http"));
+const fs = __importStar(require("fs"));
+const store_1 = require("./store");
+const supabase_client_1 = require("./supabase-client");
+const events_1 = require("./events");
+const request_pump_1 = require("./request-pump");
+const VERSION = (() => {
+    try {
+        // eslint-disable-next-line @typescript-eslint/no-require-imports
+        const pkg = require('../package.json');
+        if (typeof pkg.version === 'string' && pkg.version.length > 0)
+            return pkg.version;
+    }
+    catch { /* fall through */ }
+    return '0.0.0';
+})();
+const STARTED_AT = Date.now();
+let server = null;
+let resolvedPort = 0;
+function send(res, code, body) {
+    res.statusCode = code;
+    res.setHeader('content-type', 'application/json');
+    res.setHeader('cache-control', 'no-store');
+    res.end(JSON.stringify(body));
+}
+function token() {
+    const p = (0, store_1.readPairing)();
+    return p?.daemonToken ?? null;
+}
+async function rpcOr503(res, fn, params) {
+    const t = token();
+    if (!t) {
+        send(res, 503, { error: 'not_paired' });
+        return null;
+    }
+    try {
+        return await (0, supabase_client_1.rpc)(fn, { p_token: t, ...params });
+    }
+    catch (err) {
+        const code = err instanceof supabase_client_1.RpcError ? err.status : 500;
+        send(res, code === 401 ? 401 : 502, { error: err.message });
+        return null;
+    }
+}
+async function handleRequest(req, res) {
+    const url = new URL(req.url ?? '/', `http://${req.headers.host}`);
+    const path = url.pathname;
+    const method = req.method ?? 'GET';
+    if (path === '/status' && method === 'GET') {
+        return send(res, 200, {
+            ok: true,
+            version: VERSION,
+            pid: process.pid,
+            paired: (0, store_1.isPaired)(),
+            startedAt: STARTED_AT,
+        });
+    }
+    // Runtime metadata (name, hostname, capabilities) for THIS runtime.
+    if (path === '/self' && method === 'GET') {
+        const data = await rpcOr503(res, 'runtime_self', {});
+        if (data == null)
+            return;
+        return send(res, 200, { runtime: data });
+    }
+    // Time-window request counts. Augment with in-process pump health
+    // (inflight count) so the UI can show "pump is busy" / "pump is stuck"
+    // without needing a separate endpoint.
+    if (path === '/stats' && method === 'GET') {
+        const data = await rpcOr503(res, 'runtime_self_stats', {});
+        if (data == null)
+            return;
+        const inflight = (0, request_pump_1.inflightCount)();
+        return send(res, 200, { ...data, inflight });
+    }
+    // Recent requests (most recent first). ?limit=20 caps the count.
+    if (path === '/requests' && method === 'GET') {
+        const limit = Math.min(100, Math.max(1, Number(url.searchParams.get('limit') ?? 50)));
+        const data = await rpcOr503(res, 'runtime_self_recent_requests', { p_limit: limit });
+        if (data == null)
+            return;
+        return send(res, 200, { requests: data ?? [] });
+    }
+    // Full detail for one request (row + recent events + project).
+    const reqDetail = /^\/requests\/([0-9a-f-]{36})$/i.exec(path);
+    if (reqDetail && method === 'GET') {
+        const data = await rpcOr503(res, 'runtime_self_request_detail', { p_request_id: reqDetail[1] });
+        if (data == null)
+            return;
+        if (data === null)
+            return send(res, 404, { error: 'not_found' });
+        return send(res, 200, data);
+    }
+    // Full transcript for one request — normalized message list. For
+    // Claude TUI we parse the on-disk JSONL (which captures the whole
+    // conversation across turns). For agents without a JSONL we
+    // synthesise from the request row's prompt + accumulated
+    // assistant_text + emitted runtime_events.
+    const reqTranscript = /^\/requests\/([0-9a-f-]{36})\/transcript$/i.exec(path);
+    if (reqTranscript && method === 'GET') {
+        const detail = await rpcOr503(res, 'runtime_self_request_detail', { p_request_id: reqTranscript[1] });
+        if (detail == null)
+            return;
+        const r = detail.request;
+        if (!r)
+            return send(res, 404, { error: 'not_found' });
+        const messages = [];
+        // 1) The user's prompt is always the first message of THIS request.
+        if (typeof r.prompt === 'string' && r.prompt) {
+            messages.push({
+                role: 'user', text: r.prompt,
+                ts: r.created_at, source: 'request',
+            });
+        }
+        // 2) If there's a JSONL on disk, read it and normalise. This captures
+        //    multi-turn TUI history. We skip lines we can't parse.
+        const jsonlPath = r.jsonl_path ?? null;
+        if (jsonlPath && fs.existsSync(jsonlPath)) {
+            try {
+                const text = fs.readFileSync(jsonlPath, 'utf-8');
+                const lines = text.split(/\r?\n/).filter(Boolean);
+                for (const raw of lines) {
+                    let line = null;
+                    try {
+                        line = JSON.parse(raw);
+                    }
+                    catch {
+                        continue;
+                    }
+                    if (!line)
+                        continue;
+                    const ts = line.timestamp
+                        ?? line.ts
+                        ?? null;
+                    // Claude TUI: lines have a `type` field; reuse normalizeJsonlLine
+                    // for the same content extraction the runtime uses for events.
+                    const type = typeof line.type === 'string' ? line.type : '';
+                    if (type === 'user') {
+                        const message = line.message;
+                        const content = message?.content;
+                        if (typeof content === 'string') {
+                            messages.push({ role: 'user', text: content, ts, source: 'jsonl' });
+                        }
+                        else if (Array.isArray(content)) {
+                            for (const block of content) {
+                                if (block?.type === 'text' && typeof block.text === 'string') {
+                                    messages.push({ role: 'user', text: block.text, ts, source: 'jsonl' });
+                                }
+                                else if (block?.type === 'tool_result') {
+                                    messages.push({
+                                        role: 'tool_result',
+                                        id: String(block.tool_use_id ?? ''),
+                                        content: block.content,
+                                        isError: block.is_error === true,
+                                        ts, source: 'jsonl',
+                                    });
+                                }
+                            }
+                        }
+                    }
+                    else if (type === 'assistant') {
+                        for (const ev of (0, events_1.normalizeJsonlLine)(line)) {
+                            if (ev.type === 'assistant_text') {
+                                messages.push({ role: 'assistant', text: ev.delta ?? '', ts, source: 'jsonl' });
+                            }
+                            else if (ev.type === 'tool_use') {
+                                const tu = ev;
+                                messages.push({ role: 'tool_use', id: tu.id, name: tu.name, input: tu.input, ts, source: 'jsonl' });
+                            }
+                        }
+                    }
+                }
+            }
+            catch (err) {
+                // Read failure shouldn't kill the whole response — fall through.
+                console.error(`[control-server] transcript read failed: ${err.message}`);
+            }
+        }
+        else {
+            // No JSONL — for claude --print / codex / kimi / gemini we have
+            // (a) accumulated assistant_text, and (b) runtime_events for tool
+            // use. The text is one message; tool uses become their own rows.
+            if (typeof r.assistant_text === 'string' && r.assistant_text) {
+                messages.push({
+                    role: 'assistant', text: r.assistant_text,
+                    ts: r.finished_at ?? r.picked_up_at ?? r.created_at,
+                    source: 'request',
+                });
+            }
+            // Interleave tool_use events that were emitted during the run.
+            const events = Array.isArray(detail.events) ? detail.events : [];
+            for (const ev of [...events].reverse()) {
+                if (ev.type === 'tool_use') {
+                    const p = (ev.payload ?? {});
+                    messages.push({ role: 'tool_use', id: p.id, name: p.name, input: p.input, ts: ev.emitted_at, source: 'event' });
+                }
+                else if (ev.type === 'tool_result') {
+                    const p = (ev.payload ?? {});
+                    messages.push({ role: 'tool_result', id: p.id, content: p.content, isError: p.isError === true, ts: ev.emitted_at, source: 'event' });
+                }
+            }
+        }
+        return send(res, 200, {
+            requestId: reqTranscript[1],
+            agent: r.agent ?? null,
+            mode: r.mode ?? null,
+            status: r.status ?? null,
+            jsonlPath,
+            messages,
+        });
+    }
+    // Projects on THIS runtime.
+    if (path === '/projects' && method === 'GET') {
+        const data = await rpcOr503(res, 'runtime_self_projects', {});
+        if (data == null)
+            return;
+        return send(res, 200, { projects: data ?? [] });
+    }
+    if (path === '/' && method === 'GET') {
+        return send(res, 200, {
+            service: 'ainode',
+            version: VERSION,
+            endpoints: [
+                'GET /status', 'GET /self',
+                'GET /stats', 'GET /requests', 'GET /requests/:id',
+                'GET /requests/:id/transcript', 'GET /projects',
+            ],
+        });
+    }
+    return send(res, 404, { error: 'not_found' });
+}
+async function startControlServer() {
+    if (server)
+        throw new Error('control server already running');
+    server = http.createServer(handleRequest);
+    await new Promise((resolve, reject) => {
+        server.once('error', reject);
+        server.listen(0, '127.0.0.1', () => resolve());
+    });
+    const addr = server.address();
+    resolvedPort = typeof addr === 'object' && addr ? addr.port : 0;
+    return {
+        port: resolvedPort,
+        async close() {
+            await new Promise(resolve => server.close(() => resolve()));
+            server = null;
+        },
+    };
+}

package/dist/diskguard.d.ts

@@ -0,0 +1,96 @@
+export interface DiskGuardConfig {
+    enabled: boolean;
+    highWaterPct: number;
+    lowWaterPct: number;
+    minAgeMs: number;
+    checkIntervalMs: number;
+    dryRun: boolean;
+    /** Filesystem root the scratch dirs live under (os.tmpdir()). */
+    tempRoot: string;
+    /** Dir-name prefixes eligible for eviction. */
+    prefixes: string[];
+}
+/** One scratch dir considered for eviction. */
+export interface Candidate {
+    path: string;
+    /** Last-activity timestamp (ms) — lock heartbeat if present, else mtime.
+     *  Used to sort oldest-first. */
+    activityMs: number;
+    /** now - mtime (ms). Guards against evicting freshly-created dirs. */
+    ageMs: number;
+    /** Best-effort recursive size in bytes. Only populated for dry-run
+     *  (measuring thousands of dirs every live sweep is too expensive). */
+    sizeBytes: number;
+    /** True if a live session (in-process or a live-PID lock) owns this dir. */
+    active: boolean;
+}
+export interface SweepResult {
+    /** True if a sweep actually evaluated candidates (i.e. usage readable
+     *  and at/over the high-water mark). */
+    ran: boolean;
+    usedBefore: number | null;
+    usedAfter: number | null;
+    /** Paths evicted (or, in dry-run, that WOULD be evicted). */
+    evicted: string[];
+    bytesFreed: number;
+    skippedActive: number;
+    skippedYoung: number;
+    reason: string;
+}
+export declare function loadDiskGuardConfig(env?: NodeJS.ProcessEnv): DiskGuardConfig;
+export interface EvictionDeps {
+    listCandidates: () => Promise<Candidate[]>;
+    /** Current used-percentage of the volume, or null if unreadable. */
+    readUsedPct: () => Promise<number | null>;
+    /** Delete a scratch dir. Only called in live (non-dry-run) mode. */
+    deleteDir: (p: string) => Promise<void>;
+    /** Volume size in bytes — used to report bytes-freed and to estimate the
+     *  dry-run stopping point. Optional. */
+    totalBytes?: number;
+}
+export interface EvictionOptions {
+    highWaterPct: number;
+    lowWaterPct: number;
+    minAgeMs: number;
+    dryRun: boolean;
+}
+export declare function runEvictionLoop(deps: EvictionDeps, opts: EvictionOptions): Promise<SweepResult>;
+/** Single-flight wrapper: while a call is in flight, concurrent callers get
+ *  the same promise instead of starting a second sweep (the mutex). */
+export declare function makeSingleFlight<T>(): (fn: () => Promise<T>) => Promise<T>;
+/** Remove a scratch dir. `recursive+force` unlinks symlink ENTRIES without
+ *  following them, so the ~/.codex targets behind `sessions`/`auth.json`
+ *  are never touched. ENOENT is swallowed by `force`. */
+export declare function removeSessionDir(dir: string): Promise<void>;
+/** Handle returned by beginSession — dispose it (with removeDir=true) when
+ *  the run ends to stop the heartbeat, drop the active mark, and delete the
+ *  scratch dir. Idempotent. */
+export interface SessionHandle {
+    dispose(removeDir: boolean): Promise<void>;
+}
+export declare class DiskGuard {
+    readonly config: DiskGuardConfig;
+    private timer;
+    private readonly runExclusive;
+    /** Realpath'd scratch dirs owned by a live in-process session. */
+    private readonly activeDirs;
+    constructor(overrides?: Partial<DiskGuardConfig>);
+    /** Start the periodic sweeper. No-op (beyond a log line) if disabled;
+     *  cleanup-on-exit via beginSession still works regardless. */
+    start(): void;
+    stop(): void;
+    /** Run one sweep. Concurrent calls share a single in-flight sweep. */
+    sweep(reason: string): Promise<SweepResult>;
+    private runSweep;
+    /** Register a live session: mark its dir active in-process and write a
+     *  PID lock (with a periodic heartbeat) so a DIFFERENT runtime process
+     *  can tell the dir is still owned and not evict it. */
+    beginSession(dir: string): SessionHandle;
+    private readUsedPct;
+    private readTotalBytes;
+    private listCandidates;
+    /** Decide whether a scratch dir is owned by a live session, and compute
+     *  its last-activity time for oldest-first ordering. */
+    private classifyActivity;
+}
+export declare function getDiskGuard(): DiskGuard;