@roamcode.ai/server 1.0.0 → 1.0.1

package/dist/pane-status.js

@@ -1,145 +0,0 @@
-import { spawn } from "node:child_process";
-/**
- * The newest Claude Code MAJOR.MINOR the classifier's markers below were VERIFIED against on a live box.
- * The whole classifier is tied to Claude Code's ENGLISH TUI strings — the load-bearing markers are:
- *   - "Do you want to proceed" / "Would you like to proceed"   (blocked — permission/plan prompts)
- *   - the gerund ellipsis "…" + "↓ <n>k tokens" live counter    (working — main spinner + live agents)
- *   - a "…(<n>s"-style parenthesised spinner timer               (working — pre-token-flow window)
- *   - "Waiting for … to finish" / "esc to interrupt"             (working)
- * A NEWER claude may reword any of these and silently degrade every rail status to "idle", so boot logs a
- * one-time warning (see start.ts) when the installed claude's MAJOR.MINOR exceeds this. Bump it after
- * re-verifying the markers against a newer claude.
- */
-export const CLASSIFIER_TESTED_UP_TO = "2.1";
-/**
- * True iff `current`'s MAJOR.MINOR is strictly NEWER than `testedUpTo`'s. Patch versions are ignored — a
- * patch release doesn't reword the TUI. Unparseable input (either side) → false, so a weird version string
- * can never produce a spurious warning. Pure.
- */
-export function isNewerMajorMinor(current, testedUpTo) {
-    const parse = (v) => {
-        const m = /(\d+)\.(\d+)/.exec(v);
-        return m ? [Number(m[1]), Number(m[2])] : undefined;
-    };
-    const cur = parse(current);
-    const tested = parse(testedUpTo);
-    if (!cur || !tested)
-        return false; // can't decide → never warn spuriously
-    if (cur[0] !== tested[0])
-        return cur[0] > tested[0];
-    return cur[1] > tested[1];
-}
-/**
- * The one-line boot warning when the RUNNING claude is newer than the classifier was verified against —
- * or undefined when there is nothing to warn about (older/equal/unknown version). Pure so it's testable;
- * start.ts logs it once via console.warn and NEVER throws (a version bump must not affect boot).
- */
-export function classifierVersionWarning(claudeVersion) {
-    if (!claudeVersion || !isNewerMajorMinor(claudeVersion, CLASSIFIER_TESTED_UP_TO))
-        return undefined;
-    return (`pane-status markers were verified against claude <=${CLASSIFIER_TESTED_UP_TO}; ` +
-        `current is ${claudeVersion} — verify rail statuses after this upgrade`);
-}
-/**
- * Classify a session's live ACTIVITY from its RENDERED tmux pane (`capture-pane -p` — the CURRENT screen, not
- * scrollback). UNIVERSAL: works for any running session regardless of how claude was spawned (no per-session
- * hooks needed), and works while the browser is DETACHED (it reads the tmux session directly). Grounded in
- * Claude Code's real output — see pane-status.test.ts for captured samples.
- *
- *   working → something is actively generating. The strongest tell is a LIVE token-flow counter "↓ 216.5k
- *             tokens" — it appears on the MAIN spinner ("Schlepping… (1m 17s · ↓ 2.1k tokens)") AND on an
- *             ACTIVE background agent ("⏺ general-purpose  Listing f… 24m 23s · ↓ 216.5k tokens"), and is GONE
- *             the moment a turn finishes ("Baked for 23m 15s"). So a session whose MAIN loop is at the prompt
- *             but has agents still developing in the background reads "working" — NOT idle (the user's
- *             explicit correction). Also: a spinner's parenthesised timer, "Waiting for … to finish", or
- *             "esc to interrupt".
- *   blocked → claude is WAITING ON A DECISION FROM YOU: a permission prompt ("Do you want to proceed?"), a
- *             plan-mode approval ("Would you like to proceed?"). This is the ONLY state that earns the loud
- *             "needs you" — so it must stay RARE + real; that's why it's just the explicit-prompt phrasings.
- *   idle    → none of the above: claude finished a turn and is sitting at an empty prompt with nothing running
- *             and nothing to decide. A calm "your turn whenever" — NOT a loud alert.
- *
- * Order matters: blocked is checked first (a decision prompt overrides any stale spinner text), then working,
- * else idle.
- */
-export function classifyPaneStatus(pane) {
-    // Only look at the BOTTOM of the pane. Claude Code pins its live chrome — the spinner, the input box, the
-    // status line, and the background-agent block — to the last ~dozen rows; everything above is CONVERSATION
-    // SCROLLBACK. Restricting to the tail means a session whose scrollback happens to show these very marker
-    // strings (e.g. one editing roamcode's own source, or a diff mentioning "↓ … tokens" / "proceed") can't
-    // be misread — only claude's actual status chrome is classified.
-    const tail = pane.split("\n").slice(-22).join("\n");
-    // BLOCKED — an explicit decision prompt. Kept to Claude Code's exact permission/plan phrasings so the loud
-    // "needs you" it drives stays rare + trustworthy.
-    if (/\bDo you want to proceed\b/i.test(tail))
-        return "blocked";
-    if (/\bWould you like to proceed\b/i.test(tail))
-        return "blocked";
-    // WORKING — a LIVE token-flow counter "↓ <n>k tokens" is the reliable "actively generating" signal, present
-    // for BOTH the main spinner ("Schlepping… (1m 17s · ↓ 2.1k tokens)") and an active background agent
-    // ("⏺ general-purpose  Listing f… 24m 23s · ↓ 216.5k tokens"). We require a GERUND ellipsis "…" on the SAME
-    // line so a FINISHED thing's past-tense summary ("Done · ↓ 12k tokens") can't read as working — an active
-    // worker always shows "<Gerund>… <timer> · ↓ tokens".
-    if (/…[^\n]*↓\s*[\d.]+\s*[kKmM]?\s*tokens?\b/.test(tail))
-        return "working";
-    // A spinner's parenthesised elapsed timer (covers the brief window at a turn's start before tokens flow).
-    if (/…\s*\(\s*\d+\s*[ms]\b/.test(tail))
-        return "working";
-    // Main loop blocked on a foreground agent/tool.
-    if (/\bWaiting for\b[\s\S]{0,80}?\bto finish\b/i.test(tail))
-        return "working";
-    // Interruptible generation (may be truncated to "e…" on a narrow phone pane, so it's a bonus, not the only tell).
-    if (/\besc to interrupt\b/i.test(tail))
-        return "working";
-    return "idle";
-}
-/**
- * Capture a tmux session's CURRENT pane as plain text (`capture-pane -p`, no escape sequences). READ-ONLY —
- * it never sends input or resizes, so it can NEVER disturb a live session. Best-effort: resolves "" on any
- * error/timeout and never throws. Async (non-blocking) so the activity monitor doesn't stall the event loop.
- */
-export function capturePane(opts) {
-    return new Promise((resolve) => {
-        let out = "";
-        let done = false;
-        const finish = (s) => {
-            if (done)
-                return;
-            done = true;
-            resolve(s);
-        };
-        try {
-            const p = spawn(opts.tmuxBin ?? "tmux", ["-L", opts.socket, "capture-pane", "-p", "-t", opts.sessionName], {
-                stdio: ["ignore", "pipe", "ignore"],
-            });
-            p.stdout?.on("data", (d) => {
-                out += d.toString("utf8");
-                if (out.length > 65536) {
-                    try {
-                        p.kill();
-                    }
-                    catch {
-                        /* already gone */
-                    }
-                    finish(out);
-                }
-            });
-            p.on("error", () => finish("")); // tmux missing / spawn failed → treat as "no data"
-            p.on("close", () => finish(out));
-            const t = setTimeout(() => {
-                try {
-                    p.kill();
-                }
-                catch {
-                    /* already gone */
-                }
-                finish(out);
-            }, opts.timeoutMs ?? 2000);
-            if (typeof t.unref === "function")
-                t.unref();
-        }
-        catch {
-            finish("");
-        }
-    });
-}

package/dist/providers/claude-metadata-service.d.ts

@@ -1,58 +0,0 @@
-import { type SpawnOptions } from "node:child_process";
-export interface ClaudeModelCatalogItem {
-    value: string;
-    displayName: string;
-    description?: string;
-    supportedEffortLevels: string[];
-    isDefault: boolean;
-}
-export interface ClaudeMetadataRunner {
-    run(): Promise<unknown>;
-    /** Claude 2.1.207+ no longer includes models in initialize; `/model` is the catalog fallback. */
-    runModelList?(): Promise<unknown>;
-    dispose?(): void | Promise<void>;
-}
-interface ClaudeMetadataChildProcess {
-    readonly stdin: {
-        end(chunk: string): unknown;
-        on(event: "error", listener: (error: Error) => void): unknown;
-        off(event: "error", listener: (error: Error) => void): unknown;
-    };
-    readonly stdout: NodeJS.ReadableStream;
-    readonly stderr: NodeJS.ReadableStream;
-    on(event: "error", listener: (error: Error) => void): this;
-    on(event: "exit", listener: (code: number | null, signal: NodeJS.Signals | null) => void): this;
-    off(event: "error", listener: (error: Error) => void): this;
-    off(event: "exit", listener: (code: number | null, signal: NodeJS.Signals | null) => void): this;
-    kill(): boolean;
-}
-type ClaudeMetadataSpawnProcess = (command: string, args: readonly string[], options: SpawnOptions) => ClaudeMetadataChildProcess;
-interface CreateClaudeMetadataRunnerOptions {
-    claudeBin: string;
-    cwd: string;
-    env: NodeJS.ProcessEnv;
-    timeoutMs?: number;
-    maxOutputBytes?: number;
-    /** Process boundary injected by lifecycle tests. */
-    spawnProcess?: ClaudeMetadataSpawnProcess;
-    /** `/model` process boundary injected by fallback tests. */
-    modelListRun?: () => Promise<unknown>;
-}
-export declare class ClaudeMetadataService {
-    private readonly runner;
-    private readonly now;
-    private readonly ttlMs;
-    private cache?;
-    private inFlight?;
-    private disposed;
-    constructor(runner: ClaudeMetadataRunner, options?: {
-        now?: () => number;
-        ttlMs?: number;
-    });
-    getModels(force?: boolean): Promise<ClaudeModelCatalogItem[]>;
-    validateModelSelection(model: string, effort?: string): Promise<void>;
-    dispose(): void | Promise<void>;
-    private loadModels;
-}
-export declare function createClaudeMetadataRunner(options: CreateClaudeMetadataRunnerOptions): ClaudeMetadataRunner;
-export {};

package/dist/providers/claude-metadata-service.js

@@ -1,352 +0,0 @@
-import { execFile as nodeExecFile, spawn as nodeSpawn } from "node:child_process";
-import { randomUUID } from "node:crypto";
-import { StringDecoder } from "node:string_decoder";
-import { ProviderError } from "./types.js";
-const SAFE_VALUE = /^[A-Za-z0-9][A-Za-z0-9._:/\u005b\u005d-]*$/;
-const MAX_MODELS = 64;
-const MAX_EFFORTS = 32;
-const MAX_TOKEN = 128;
-const MAX_STREAM_OBJECTS = 256;
-const CLAUDE_BASELINE_EFFORTS = new Set(["low", "medium", "high", "xhigh", "max"]);
-const DEFAULT_TTL_MS = 5 * 60_000;
-const DEFAULT_TIMEOUT_MS = 10_000;
-const DEFAULT_MAX_OUTPUT_BYTES = 1024 * 1024;
-const CLAUDE_METADATA_ARGS = [
-    "--print",
-    "--input-format",
-    "stream-json",
-    "--output-format",
-    "stream-json",
-    "--verbose",
-    "--no-session-persistence",
-    "--permission-mode",
-    "plan",
-];
-function metadataUnavailable() {
-    const error = new Error("Claude model metadata is unavailable");
-    error.name = "ClaudeMetadataError";
-    return error;
-}
-function isRecord(value) {
-    return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-function isSafeToken(value) {
-    return typeof value === "string" && value.length <= MAX_TOKEN && SAFE_VALUE.test(value);
-}
-function normalizeCatalog(envelope) {
-    if (!isRecord(envelope) || !isRecord(envelope.response) || !isRecord(envelope.response.response)) {
-        throw metadataUnavailable();
-    }
-    const models = envelope.response.response.models;
-    if (!Array.isArray(models) || models.length === 0 || models.length > MAX_MODELS) {
-        throw metadataUnavailable();
-    }
-    const seenModels = new Set();
-    return models.map((candidate) => {
-        if (!isRecord(candidate) || !isSafeToken(candidate.value) || seenModels.has(candidate.value)) {
-            throw metadataUnavailable();
-        }
-        seenModels.add(candidate.value);
-        if (typeof candidate.displayName !== "string" ||
-            candidate.displayName.length === 0 ||
-            candidate.displayName.length > 512 ||
-            (candidate.description !== undefined &&
-                (typeof candidate.description !== "string" || candidate.description.length > 4_096)) ||
-            !Array.isArray(candidate.supportedEffortLevels) ||
-            candidate.supportedEffortLevels.length > MAX_EFFORTS ||
-            typeof candidate.isDefault !== "boolean") {
-            throw metadataUnavailable();
-        }
-        const seenEfforts = new Set();
-        const supportedEffortLevels = candidate.supportedEffortLevels.map((effort) => {
-            if (!isSafeToken(effort) || seenEfforts.has(effort))
-                throw metadataUnavailable();
-            seenEfforts.add(effort);
-            return effort;
-        });
-        return {
-            value: candidate.value,
-            displayName: candidate.displayName,
-            ...(candidate.description !== undefined ? { description: candidate.description } : {}),
-            supportedEffortLevels,
-            isDefault: candidate.isDefault,
-        };
-    });
-}
-const MODEL_LIST_EFFORTS = ["low", "medium", "high", "xhigh", "max"];
-const MODEL_DISPLAY_NAMES = {
-    sonnet: "Sonnet",
-    opus: "Opus",
-    haiku: "Haiku",
-    fable: "Fable",
-    best: "Best available",
-    opusplan: "Opus Plan",
-};
-/** Parse Claude's stable human-facing `/model` result, e.g.
- * `Available: sonnet, opus, fable[1m], default, or a full model ID.` The provider-default option already
- * exists as the picker's empty value, so the literal `default` alias is intentionally omitted here. */
-function normalizeModelList(result) {
-    const text = typeof result === "string" ? result : isRecord(result) && typeof result.result === "string" ? result.result : "";
-    const available = /Available:\s*(.*?)\s*,?\s*or a full model ID\b/is.exec(text)?.[1];
-    if (!available)
-        throw metadataUnavailable();
-    const values = available
-        .split(",")
-        .map((value) => value.trim())
-        .filter((value) => value.length > 0 && value !== "default");
-    if (values.length === 0 || values.length > MAX_MODELS)
-        throw metadataUnavailable();
-    const seen = new Set();
-    return values.map((value) => {
-        if (!isSafeToken(value) || seen.has(value))
-            throw metadataUnavailable();
-        seen.add(value);
-        const context = /\[1m\]$/i.test(value);
-        const base = value.replace(/\[1m\]$/i, "");
-        const displayName = `${MODEL_DISPLAY_NAMES[base] ?? base}${context ? " · 1M context" : ""}`;
-        return {
-            value,
-            displayName,
-            supportedEffortLevels: [...MODEL_LIST_EFFORTS],
-            isDefault: false,
-        };
-    });
-}
-function cloneCatalog(models) {
-    return models.map((model) => ({ ...model, supportedEffortLevels: [...model.supportedEffortLevels] }));
-}
-export class ClaudeMetadataService {
-    runner;
-    now;
-    ttlMs;
-    cache;
-    inFlight;
-    disposed = false;
-    constructor(runner, options = {}) {
-        this.runner = runner;
-        this.now = options.now ?? (() => Date.now());
-        this.ttlMs = options.ttlMs ?? DEFAULT_TTL_MS;
-    }
-    async getModels(force = false) {
-        if (!force && this.cache && this.now() - this.cache.at < this.ttlMs) {
-            return cloneCatalog(this.cache.models);
-        }
-        if (this.inFlight)
-            return cloneCatalog(await this.inFlight);
-        const request = this.loadModels();
-        this.inFlight = request;
-        try {
-            const models = await request;
-            this.cache = { at: this.now(), models: cloneCatalog(models) };
-            return cloneCatalog(models);
-        }
-        finally {
-            if (this.inFlight === request)
-                this.inFlight = undefined;
-        }
-    }
-    async validateModelSelection(model, effort) {
-        const models = await this.getModels();
-        const selected = models.find((candidate) => candidate.value === model);
-        if (!selected) {
-            if (effort === undefined || CLAUDE_BASELINE_EFFORTS.has(effort))
-                return;
-            throw new ProviderError("INVALID_PROVIDER_OPTIONS", "Invalid Claude custom model effort selection");
-        }
-        if (effort === undefined || selected.supportedEffortLevels.includes(effort))
-            return;
-        throw new ProviderError("INVALID_PROVIDER_OPTIONS", "Invalid Claude model and effort selection");
-    }
-    dispose() {
-        if (this.disposed)
-            return;
-        this.disposed = true;
-        return this.runner.dispose?.();
-    }
-    async loadModels() {
-        try {
-            return normalizeCatalog(await this.runner.run());
-        }
-        catch {
-            if (!this.runner.runModelList)
-                throw metadataUnavailable();
-            try {
-                return normalizeModelList(await this.runner.runModelList());
-            }
-            catch {
-                throw metadataUnavailable();
-            }
-        }
-    }
-}
-export function createClaudeMetadataRunner(options) {
-    const timeoutMs = options.timeoutMs ?? DEFAULT_TIMEOUT_MS;
-    const maxOutputBytes = options.maxOutputBytes ?? DEFAULT_MAX_OUTPUT_BYTES;
-    const spawnProcess = options.spawnProcess ?? nodeSpawn;
-    const activeRuns = new Set();
-    let disposed = false;
-    return {
-        runModelList() {
-            if (disposed)
-                return Promise.reject(metadataUnavailable());
-            if (options.modelListRun)
-                return options.modelListRun();
-            const env = { ...options.env };
-            delete env.ANTHROPIC_API_KEY;
-            return new Promise((resolve, reject) => {
-                nodeExecFile(options.claudeBin, ["-p", "/model", "--output-format", "json", "--dangerously-skip-permissions"], {
-                    cwd: options.cwd,
-                    env,
-                    timeout: timeoutMs,
-                    maxBuffer: maxOutputBytes,
-                    windowsHide: true,
-                }, (error, stdout) => {
-                    if (error) {
-                        reject(metadataUnavailable());
-                        return;
-                    }
-                    try {
-                        const parsed = JSON.parse(stdout);
-                        if (typeof parsed.result !== "string")
-                            throw metadataUnavailable();
-                        resolve(parsed.result);
-                    }
-                    catch {
-                        reject(metadataUnavailable());
-                    }
-                });
-            });
-        },
-        run() {
-            if (disposed)
-                return Promise.reject(metadataUnavailable());
-            return new Promise((resolve, reject) => {
-                const env = { ...options.env };
-                delete env.ANTHROPIC_API_KEY;
-                let child;
-                try {
-                    child = spawnProcess(options.claudeBin, CLAUDE_METADATA_ARGS, {
-                        cwd: options.cwd,
-                        env,
-                        stdio: ["pipe", "pipe", "pipe"],
-                    });
-                }
-                catch {
-                    reject(metadataUnavailable());
-                    return;
-                }
-                const requestId = `roamcode-models-${randomUUID()}`;
-                const decoder = new StringDecoder("utf8");
-                let stdoutBuffer = "";
-                let outputBytes = 0;
-                let streamObjects = 0;
-                let settled = false;
-                let timer = undefined;
-                const cleanup = () => {
-                    if (timer !== undefined)
-                        clearTimeout(timer);
-                    child.stdout.off("data", onStdout);
-                    child.stderr.off("data", onStderr);
-                    child.stdin.off("error", onStdinError);
-                    child.off("error", onError);
-                    child.off("exit", onExit);
-                    activeRuns.delete(cancel);
-                    try {
-                        child.kill();
-                    }
-                    catch {
-                        // Cleanup is best-effort and must not replace the original settlement.
-                    }
-                };
-                const settle = (value) => {
-                    if (settled)
-                        return;
-                    settled = true;
-                    cleanup();
-                    if (value === undefined)
-                        reject(metadataUnavailable());
-                    else
-                        resolve(value);
-                };
-                const addBytes = (chunk) => {
-                    const buffer = Buffer.isBuffer(chunk) ? chunk : Buffer.from(String(chunk));
-                    outputBytes += buffer.byteLength;
-                    if (outputBytes > maxOutputBytes) {
-                        settle();
-                        return undefined;
-                    }
-                    return buffer;
-                };
-                const onStdout = (chunk) => {
-                    const buffer = addBytes(chunk);
-                    if (!buffer || settled)
-                        return;
-                    stdoutBuffer += decoder.write(buffer);
-                    while (!settled) {
-                        const newline = stdoutBuffer.indexOf("\n");
-                        if (newline < 0)
-                            return;
-                        const line = stdoutBuffer.slice(0, newline).trim();
-                        stdoutBuffer = stdoutBuffer.slice(newline + 1);
-                        if (line.length === 0)
-                            continue;
-                        streamObjects += 1;
-                        if (streamObjects > MAX_STREAM_OBJECTS) {
-                            settle();
-                            return;
-                        }
-                        let message;
-                        try {
-                            message = JSON.parse(line);
-                        }
-                        catch {
-                            settle();
-                            return;
-                        }
-                        if (isRecord(message) &&
-                            message.type === "control_response" &&
-                            isRecord(message.response) &&
-                            message.response.request_id === requestId) {
-                            settle(message);
-                        }
-                    }
-                };
-                const onStderr = (chunk) => {
-                    addBytes(chunk);
-                };
-                const onStdinError = () => settle();
-                const onError = () => settle();
-                const onExit = () => settle();
-                const cancel = () => settle();
-                child.stdout.on("data", onStdout);
-                child.stderr.on("data", onStderr);
-                child.stdin.on("error", onStdinError);
-                child.on("error", onError);
-                child.on("exit", onExit);
-                activeRuns.add(cancel);
-                timer = setTimeout(cancel, timeoutMs);
-                const request = {
-                    type: "control_request",
-                    request_id: requestId,
-                    request: {
-                        subtype: "initialize",
-                        hooks: { PreToolUse: [{ matcher: "", hookCallbackIds: ["roamcode-metadata"] }] },
-                    },
-                };
-                try {
-                    child.stdin.end(`${JSON.stringify(request)}\n`);
-                }
-                catch {
-                    settle();
-                }
-            });
-        },
-        dispose() {
-            if (disposed)
-                return;
-            disposed = true;
-            for (const cancel of [...activeRuns])
-                cancel();
-        },
-    };
-}

package/dist/providers/claude-provider.d.ts

@@ -1,11 +0,0 @@
-import { type AttachSpawnOptions } from "../config.js";
-import { type AgentProvider } from "./types.js";
-import type { ProviderAvailability } from "./types.js";
-export interface CreateClaudeProviderOptions {
-    claudeBin: string;
-    env?: NodeJS.ProcessEnv;
-    attach?: AttachSpawnOptions;
-    getAttach?: () => AttachSpawnOptions | undefined;
-    probe?: () => Promise<ProviderAvailability>;
-}
-export declare function createClaudeProvider(options: CreateClaudeProviderOptions): AgentProvider;