@roamcode.ai/server 1.0.0 → 1.0.1

package/dist/providers/claude-provider.js

@@ -1,166 +0,0 @@
-import { buildHooksSettingsDocument, buildMcpConfigDocument, hookAuthFileContent, hookAuthPathFor, hooksSettingsPathFor, mcpConfigPathFor, } from "../config.js";
-import { classifyPaneStatus } from "../pane-status.js";
-import { cleanupProviderArtifacts, writeProviderArtifact0600 } from "./provider-artifacts.js";
-import { ProviderError } from "./types.js";
-const OWNED_VALUE_FLAGS = new Map([
-    ["--resume", "optional"],
-    ["--session-id", "one"],
-    ["--model", "one"],
-    ["--effort", "one"],
-    ["--permission-mode", "one"],
-    ["--add-dir", "variadic"],
-    ["--mcp-config", "variadic"],
-    ["--settings", "one"],
-]);
-const OWNED_BOOLEAN_FLAGS = ["--continue", "--dangerously-skip-permissions"];
-function invalidLegacyArg(message) {
-    return new ProviderError("INVALID_PROVIDER_OPTIONS", `Invalid provider options: ${message}`);
-}
-function requireLegacyValue(args, index, flag) {
-    const value = args[index + 1];
-    if (value === undefined || value.startsWith("-"))
-        throw invalidLegacyArg(`${flag} requires a value`);
-    return index + 1;
-}
-function sanitizeLegacyArgs(legacyArgs) {
-    const preserved = [];
-    for (let index = 0; index < legacyArgs.length; index += 1) {
-        const arg = legacyArgs[index];
-        if (arg === "--") {
-            preserved.push(...legacyArgs.slice(index));
-            break;
-        }
-        if (arg === "-c")
-            continue;
-        if (arg.startsWith("-c")) {
-            throw invalidLegacyArg("-c has an ambiguous attached value");
-        }
-        if (arg === "-r") {
-            const value = legacyArgs[index + 1];
-            if (value !== undefined && !value.startsWith("-"))
-                index += 1;
-            continue;
-        }
-        if (arg.startsWith("-r")) {
-            if (arg === "-r=" || arg.length === 2)
-                throw invalidLegacyArg("-r has an ambiguous empty value");
-            continue;
-        }
-        let handled = false;
-        for (const flag of OWNED_BOOLEAN_FLAGS) {
-            if (arg === flag) {
-                handled = true;
-                break;
-            }
-            if (arg.startsWith(`${flag}=`)) {
-                if (arg.length === flag.length + 1)
-                    throw invalidLegacyArg(`${flag} has an ambiguous empty value`);
-                handled = true;
-                break;
-            }
-        }
-        if (handled)
-            continue;
-        for (const [flag, arity] of OWNED_VALUE_FLAGS) {
-            if (arg.startsWith(`${flag}=`)) {
-                if (arg.length === flag.length + 1) {
-                    const detail = arity === "optional" ? "has an ambiguous empty value" : "requires a value";
-                    throw invalidLegacyArg(`${flag} ${detail}`);
-                }
-                handled = true;
-                break;
-            }
-            if (arg !== flag)
-                continue;
-            handled = true;
-            if (arity === "optional") {
-                const value = legacyArgs[index + 1];
-                if (value !== undefined && !value.startsWith("-"))
-                    index += 1;
-            }
-            else {
-                index = requireLegacyValue(legacyArgs, index, flag);
-                if (arity === "variadic") {
-                    while (legacyArgs[index + 1] !== undefined && !legacyArgs[index + 1].startsWith("-"))
-                        index += 1;
-                }
-            }
-            break;
-        }
-        if (!handled)
-            preserved.push(arg);
-    }
-    return preserved;
-}
-function insertBeforeSeparator(args, ownedArgs) {
-    const separatorIndex = args.indexOf("--");
-    args.splice(separatorIndex === -1 ? args.length : separatorIndex, 0, ...ownedArgs);
-}
-function claudeArgs(options) {
-    const args = [];
-    if (options.model)
-        args.push("--model", options.model);
-    if (options.effort)
-        args.push("--effort", options.effort);
-    if (options.dangerouslySkip)
-        args.push("--dangerously-skip-permissions");
-    else if (options.permissionMode)
-        args.push("--permission-mode", options.permissionMode);
-    for (const dir of options.addDirs ?? [])
-        args.push("--add-dir", dir);
-    // Legacy arguments exist only for rollback-readable Claude rows. Provider-owned model, safety, session,
-    // and attachment flags are rebuilt from typed options so historical argv cannot override adapter policy.
-    args.push(...sanitizeLegacyArgs(options.legacyArgs ?? []));
-    return args;
-}
-export function createClaudeProvider(options) {
-    return {
-        id: "claude",
-        displayName: "Claude Code",
-        resumeIdentity: "optional",
-        probe: options.probe ?? (() => Promise.resolve({ terminalAvailable: true, metadataAvailable: true })),
-        buildProcess: async (context) => {
-            if (context.options.provider !== "claude") {
-                throw new ProviderError("INVALID_PROVIDER_OPTIONS", "Claude provider received non-Claude options");
-            }
-            const args = claudeArgs(context.options);
-            const ownedPaths = [];
-            const attach = context.attach ?? options.getAttach?.() ?? options.attach;
-            if (attach) {
-                try {
-                    const mcpPath = mcpConfigPathFor(attach.dataDir, context.roamSessionId);
-                    if (writeProviderArtifact0600(mcpPath, JSON.stringify(buildMcpConfigDocument(context.roamSessionId, attach)), context, ownedPaths)) {
-                        insertBeforeSeparator(args, ["--mcp-config", mcpPath]);
-                    }
-                    const authPath = hookAuthPathFor(attach.dataDir, context.roamSessionId);
-                    const settingsPath = hooksSettingsPathFor(attach.dataDir, context.roamSessionId);
-                    if (writeProviderArtifact0600(authPath, hookAuthFileContent(attach.token), context, ownedPaths)) {
-                        if (writeProviderArtifact0600(settingsPath, JSON.stringify(buildHooksSettingsDocument(context.roamSessionId, attach, authPath)), context, ownedPaths)) {
-                            insertBeforeSeparator(args, ["--settings", settingsPath]);
-                        }
-                        else {
-                            cleanupProviderArtifacts([authPath]);
-                        }
-                    }
-                }
-                catch (error) {
-                    cleanupProviderArtifacts(ownedPaths);
-                    throw error;
-                }
-            }
-            if (context.intent === "resume")
-                insertBeforeSeparator(args, ["--continue"]);
-            const env = { ...(options.env ?? process.env) };
-            delete env.ANTHROPIC_API_KEY;
-            return {
-                executable: options.claudeBin,
-                args,
-                env,
-                cleanupPaths: ownedPaths,
-            };
-        },
-        runtimeSignals: () => [],
-        classifyPane: classifyPaneStatus,
-        cleanup: cleanupProviderArtifacts,
-    };
-}

package/dist/providers/codex-activity.d.ts

@@ -1,21 +0,0 @@
-import { type PaneStatus } from "../pane-status.js";
-import type { ProviderRuntimeMetadata, ProviderRuntimeSignal, ProviderRuntimeSignalParser } from "./types.js";
-export declare const CODEX_OSC_MAX_CARRY: number;
-export declare const CODEX_CLASSIFIER_TESTED_UP_TO = "0.144";
-export interface CodexOscParser extends ProviderRuntimeSignalParser {
-    readonly bufferedLength: number;
-}
-export declare function createCodexOscParser(): CodexOscParser;
-export declare function parseCodexOscNotifications(input: string): ProviderRuntimeSignal[];
-export declare function classifyCodexPane(pane: string): PaneStatus;
-/**
- * Read Codex's LIVE model + reasoning level from the pinned bottom status row. Unlike launch options, this
- * changes immediately when the user switches reasoning inside the TUI. Only the final non-empty row is
- * considered, so conversation text that happens to mention a model/effort pair cannot rewrite metadata.
- *
- * Supported real Codex layouts:
- *   gpt-5.6-sol xhigh · ~/Developer/remote-coder
- *   gpt-5.6 · high · 91% left
- */
-export declare function parseCodexRuntimeMetadata(pane: string): ProviderRuntimeMetadata | undefined;
-export declare function codexClassifierVersionWarning(codexVersion: string | undefined): string | undefined;

package/dist/providers/codex-activity.js

@@ -1,122 +0,0 @@
-import { isNewerMajorMinor } from "../pane-status.js";
-export const CODEX_OSC_MAX_CARRY = 8 * 1024;
-export const CODEX_CLASSIFIER_TESTED_UP_TO = "0.144";
-const OSC_START = "\u001b]";
-const OSC_9_START = "\u001b]9;";
-const ST = "\u001b\\";
-function signalForPayload(payload) {
-    if (payload.startsWith("Approval requested: ") ||
-        payload.startsWith("Codex wants to edit ") ||
-        payload.startsWith("Approval requested by ") ||
-        payload.startsWith("Plan mode prompt: ")) {
-        return { type: "blocked" };
-    }
-    return payload.length > 0 ? { type: "idle" } : undefined;
-}
-function terminatorAt(input, from) {
-    const bel = input.indexOf("\u0007", from);
-    const st = input.indexOf(ST, from);
-    if (bel === -1 && st === -1)
-        return undefined;
-    if (bel !== -1 && (st === -1 || bel < st))
-        return { index: bel, width: 1 };
-    return { index: st, width: 2 };
-}
-export function createCodexOscParser() {
-    let carry = "";
-    return {
-        get bufferedLength() {
-            return carry.length;
-        },
-        push(chunk) {
-            const input = carry + chunk;
-            carry = "";
-            const signals = [];
-            let cursor = 0;
-            while (cursor < input.length) {
-                const start = input.indexOf("\u001b", cursor);
-                if (start === -1)
-                    break;
-                if (start === input.length - 1) {
-                    carry = "\u001b";
-                    break;
-                }
-                if (!input.startsWith(OSC_START, start)) {
-                    cursor = start + 1;
-                    continue;
-                }
-                if (input.length < start + OSC_9_START.length) {
-                    carry = input.slice(start);
-                    break;
-                }
-                if (!input.startsWith(OSC_9_START, start)) {
-                    cursor = start + OSC_START.length;
-                    continue;
-                }
-                const payloadStart = start + OSC_9_START.length;
-                const terminator = terminatorAt(input, payloadStart);
-                if (!terminator) {
-                    const pending = input.slice(start);
-                    carry = pending.length <= CODEX_OSC_MAX_CARRY ? pending : "";
-                    break;
-                }
-                const frameLength = terminator.index + terminator.width - start;
-                if (frameLength <= CODEX_OSC_MAX_CARRY) {
-                    const signal = signalForPayload(input.slice(payloadStart, terminator.index));
-                    if (signal)
-                        signals.push(signal);
-                }
-                cursor = terminator.index + terminator.width;
-            }
-            return signals;
-        },
-    };
-}
-export function parseCodexOscNotifications(input) {
-    return createCodexOscParser().push(input);
-}
-export function classifyCodexPane(pane) {
-    const tail = pane.split("\n").slice(-24).join("\n");
-    if (/\bWould you like to run the following command\b/i.test(tail))
-        return "blocked";
-    if (/\bDo you want to allow\b/i.test(tail))
-        return "blocked";
-    if (/\bPress enter to confirm or esc to cancel\b/i.test(tail))
-        return "blocked";
-    if (/\besc to interrupt\b/i.test(tail))
-        return "working";
-    if (/[•●]\s*(?:Working|Thinking|Running)\s*\(\s*\d+\s*[ms]\b/i.test(tail))
-        return "working";
-    return "idle";
-}
-const RUNTIME_TOKEN = "[A-Za-z0-9][A-Za-z0-9._:/-]{0,127}";
-const EFFORT_TOKEN = "[A-Za-z0-9][A-Za-z0-9._-]{0,127}";
-/**
- * Read Codex's LIVE model + reasoning level from the pinned bottom status row. Unlike launch options, this
- * changes immediately when the user switches reasoning inside the TUI. Only the final non-empty row is
- * considered, so conversation text that happens to mention a model/effort pair cannot rewrite metadata.
- *
- * Supported real Codex layouts:
- *   gpt-5.6-sol xhigh · ~/Developer/remote-coder
- *   gpt-5.6 · high · 91% left
- */
-export function parseCodexRuntimeMetadata(pane) {
-    const line = pane
-        .split(/\r?\n/)
-        .map((value) => value.trim())
-        .filter(Boolean)
-        .at(-1);
-    if (!line)
-        return undefined;
-    const current = new RegExp(`^(${RUNTIME_TOKEN})\\s+(${EFFORT_TOKEN})\\s+·\\s+(?:~/|/).+$`).exec(line);
-    if (current)
-        return { model: current[1], effort: current[2] };
-    const legacy = new RegExp(`^(${RUNTIME_TOKEN})\\s+·\\s+(${EFFORT_TOKEN})\\s+·\\s+.+$`).exec(line);
-    return legacy ? { model: legacy[1], effort: legacy[2] } : undefined;
-}
-export function codexClassifierVersionWarning(codexVersion) {
-    if (!codexVersion || !isNewerMajorMinor(codexVersion, CODEX_CLASSIFIER_TESTED_UP_TO))
-        return undefined;
-    return (`Codex pane-status markers were verified against Codex <=${CODEX_CLASSIFIER_TESTED_UP_TO}; ` +
-        `current is ${codexVersion} — verify rail statuses after this upgrade`);
-}

package/dist/providers/codex-app-server-client.d.ts

@@ -1,90 +0,0 @@
-import { EventEmitter } from "node:events";
-import { type ZodType } from "zod";
-export declare const CODEX_METADATA_ERROR_CODE: "CODEX_METADATA_UNAVAILABLE";
-export declare const DEFAULT_CODEX_APP_SERVER_TIMEOUT_MS = 15000;
-export declare const DEFAULT_CODEX_APP_SERVER_MAX_STDOUT_LINE_BYTES: number;
-export declare const DEFAULT_CODEX_APP_SERVER_MAX_STDOUT_BUFFER_BYTES: number;
-export declare const DEFAULT_CODEX_APP_SERVER_MAX_STDERR_BYTES: number;
-type DiagnosticIssue = "exit" | "malformed_json" | "notification_listener" | "spawn" | "stderr_limit" | "stdout_limit" | "transport_error" | "unknown_message" | "write_error";
-export interface CodexMetadataDiagnostics {
-    readonly lastIssue?: DiagnosticIssue;
-    readonly stderrBytes: number;
-    readonly stderrTruncated: boolean;
-}
-export interface CodexAppServerNotification {
-    readonly method: string;
-    readonly params?: unknown;
-}
-interface WritableTransport extends EventEmitter {
-    write(value: string | Uint8Array, callback?: (error?: Error | null) => void): boolean;
-    end(): void;
-}
-type ReadableTransport = EventEmitter;
-/** The intentionally small child-process surface used by the protocol client and its fake tests. */
-export interface CodexAppServerTransport extends EventEmitter {
-    readonly stdin: WritableTransport;
-    readonly stdout: ReadableTransport;
-    readonly stderr: ReadableTransport;
-    kill(signal?: NodeJS.Signals): boolean | void;
-}
-export type SpawnCodexAppServerTransport = (command: string, args: readonly string[], options?: {
-    readonly env?: NodeJS.ProcessEnv;
-}) => CodexAppServerTransport;
-export interface CodexAppServerClientOptions {
-    readonly codexBin?: string;
-    /** Selects one validated `$CODEX_HOME/<name>.config.toml` layer before app-server starts. */
-    readonly profile?: string;
-    readonly env?: NodeJS.ProcessEnv;
-    readonly spawnTransport?: SpawnCodexAppServerTransport;
-    readonly timeoutMs?: number;
-    readonly maxStdoutLineBytes?: number;
-    readonly maxStdoutBufferBytes?: number;
-    readonly maxStderrBytes?: number;
-}
-export declare class CodexMetadataUnavailableError extends Error {
-    readonly code: "CODEX_METADATA_UNAVAILABLE";
-    constructor();
-}
-/**
- * Bounded JSON-lines client for the auxiliary Codex app-server metadata channel.
- * It never participates in terminal streaming and deliberately knows no method-specific result schemas.
- */
-export declare class CodexAppServerClient {
-    readonly limits: {
-        readonly timeoutMs: number;
-        readonly maxStdoutLineBytes: number;
-        readonly maxStdoutBufferBytes: number;
-        readonly maxStderrBytes: number;
-    };
-    private readonly codexBin;
-    private readonly profile?;
-    private readonly env?;
-    private readonly spawnTransport;
-    private readonly notificationListeners;
-    private active?;
-    private startPromise?;
-    private stopPromise?;
-    private nextRequestId;
-    private nextGeneration;
-    private lastDiagnostics;
-    constructor(options?: CodexAppServerClientOptions);
-    get diagnostics(): CodexMetadataDiagnostics;
-    start(): Promise<void>;
-    request<T>(method: string, params: unknown, schema: ZodType<T>): Promise<T>;
-    onNotification(listener: (notification: CodexAppServerNotification) => void): () => void;
-    stop(): Promise<void>;
-    private createGeneration;
-    private installListeners;
-    private sendRequest;
-    private writeFrame;
-    private flushWrites;
-    private onStdout;
-    private onMessage;
-    private resolveResponse;
-    private rejectResponse;
-    private onStderr;
-    private failGeneration;
-    private removeListeners;
-    private recordIssue;
-}
-export {};