@roamcode.ai/server 1.0.0 → 1.0.1

package/dist/service-install.js

@@ -1,221 +0,0 @@
-import { chmodSync, existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
-import { homedir, platform } from "node:os";
-import { dirname, join } from "node:path";
-import { spawnSync } from "node:child_process";
-function escapeXml(value) {
-    return value
-        .replace(/&/g, "&")
-        .replace(/</g, "&lt;")
-        .replace(/>/g, "&gt;")
-        .replace(/\"/g, "&quot;")
-        .replace(/'/g, "&apos;");
-}
-function quoteSystemd(value) {
-    return /[\s\"\\]/.test(value) ? `"${value.replace(/\\/g, "\\\\").replace(/\"/g, '\\"')}"` : value;
-}
-export function buildServicePath(nodePath, home) {
-    return [
-        dirname(nodePath),
-        "/opt/homebrew/bin",
-        "/usr/local/bin",
-        join(home, ".local", "bin"),
-        join(home, ".local", "share", "pnpm"),
-        join(home, "Library", "pnpm"),
-        "/usr/bin",
-        "/bin",
-    ].join(":");
-}
-function programArguments(opts) {
-    if (opts.executablePath)
-        return [opts.executablePath];
-    if (opts.nodePath && opts.cliPath)
-        return [opts.nodePath, opts.cliPath];
-    throw new Error("service requires executablePath or nodePath + cliPath");
-}
-export function renderLaunchdPlist(opts) {
-    const args = programArguments(opts)
-        .map((arg) => `    <string>${escapeXml(arg)}</string>`)
-        .join("\n");
-    const pathEntry = opts.servicePath
-        ? `\n    <key>PATH</key>\n    <string>${escapeXml(opts.servicePath)}</string>`
-        : "";
-    const installEntry = opts.installRoot
-        ? `\n    <key>ROAMCODE_INSTALL_ROOT</key>\n    <string>${escapeXml(opts.installRoot)}</string>`
-        : "";
-    return `<?xml version="1.0" encoding="UTF-8"?>
-<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
-<plist version="1.0">
-<dict>
-  <key>Label</key>
-  <string>${escapeXml(opts.label)}</string>
-  <key>ProgramArguments</key>
-  <array>
-${args}
-  </array>
-  <key>EnvironmentVariables</key>
-  <dict>
-    <key>ROAMCODE_DATA_DIR</key>
-    <string>${escapeXml(opts.dataDir)}</string>${installEntry}${pathEntry}
-  </dict>
-  <key>RunAtLoad</key>
-  <true/>
-  <key>KeepAlive</key>
-  <true/>
-  <key>StandardOutPath</key>
-  <string>${escapeXml(join(opts.dataDir, "roamcode.log"))}</string>
-  <key>StandardErrorPath</key>
-  <string>${escapeXml(join(opts.dataDir, "roamcode.err.log"))}</string>
-</dict>
-</plist>
-`;
-}
-export function renderSystemdUnit(opts) {
-    const command = programArguments(opts).map(quoteSystemd).join(" ");
-    const pathLine = opts.servicePath ? `\nEnvironment=PATH=${opts.servicePath}` : "";
-    const installLine = opts.installRoot ? `\nEnvironment=ROAMCODE_INSTALL_ROOT=${opts.installRoot}` : "";
-    return `[Unit]
-Description=roamcode — operate Claude Code or Codex sessions remotely
-After=network-online.target
-
-[Service]
-ExecStart=${command}
-Environment=ROAMCODE_DATA_DIR=${opts.dataDir}${installLine}${pathLine}
-Restart=always
-RestartSec=3
-
-[Install]
-WantedBy=default.target
-`;
-}
-function persistRecord(dataDir, record) {
-    mkdirSync(dataDir, { recursive: true, mode: 0o700 });
-    const path = join(dataDir, "service.json");
-    writeFileSync(path, JSON.stringify(record, null, 2) + "\n", { mode: 0o600 });
-    chmodSync(path, 0o600);
-}
-export function installService(ctx) {
-    const home = ctx.home ?? homedir();
-    const os = ctx.os ?? platform();
-    const servicePath = buildServicePath(ctx.nodePath, home);
-    if (os === "darwin") {
-        const label = ctx.label ?? "com.roamcode";
-        const dir = join(home, "Library", "LaunchAgents");
-        const path = join(dir, `${label}.plist`);
-        mkdirSync(dir, { recursive: true });
-        writeFileSync(path, renderLaunchdPlist({
-            label,
-            nodePath: ctx.nodePath,
-            cliPath: ctx.cliPath,
-            executablePath: ctx.executablePath,
-            dataDir: ctx.dataDir,
-            installRoot: ctx.installRoot,
-            servicePath,
-        }));
-        chmodSync(path, 0o644);
-        const record = {
-            manager: "launchd",
-            label,
-            path,
-            ...(ctx.executablePath ? { launcherPath: ctx.executablePath } : {}),
-            ...(ctx.installRoot ? { installRoot: ctx.installRoot } : {}),
-        };
-        persistRecord(ctx.dataDir, record);
-        return {
-            path,
-            record,
-            instructions: `launchctl load -w "${path}"   # start now + at login\nlaunchctl unload -w "${path}"  # stop`,
-        };
-    }
-    if (os === "linux") {
-        const label = ctx.label ?? "roamcode";
-        const dir = join(home, ".config", "systemd", "user");
-        const path = join(dir, `${label}.service`);
-        mkdirSync(dir, { recursive: true });
-        writeFileSync(path, renderSystemdUnit({
-            nodePath: ctx.nodePath,
-            cliPath: ctx.cliPath,
-            executablePath: ctx.executablePath,
-            dataDir: ctx.dataDir,
-            installRoot: ctx.installRoot,
-            servicePath,
-        }));
-        chmodSync(path, 0o644);
-        const record = {
-            manager: "systemd",
-            label,
-            path,
-            ...(ctx.executablePath ? { launcherPath: ctx.executablePath } : {}),
-            ...(ctx.installRoot ? { installRoot: ctx.installRoot } : {}),
-        };
-        persistRecord(ctx.dataDir, record);
-        return {
-            path,
-            record,
-            instructions: [
-                "systemctl --user daemon-reload",
-                `systemctl --user enable --now ${label}   # start now + at login`,
-                `systemctl --user disable --now ${label}  # stop`,
-                "(run 'loginctl enable-linger $USER' so it runs without an active login session)",
-            ].join("\n"),
-        };
-    }
-    throw new Error(`unsupported platform: ${os} — run roamcode manually or under a user-level supervisor`);
-}
-export function readServiceRecord(dataDir) {
-    try {
-        const parsed = JSON.parse(readFileSync(join(dataDir, "service.json"), "utf8"));
-        if ((parsed.manager !== "launchd" && parsed.manager !== "systemd") || typeof parsed.label !== "string") {
-            return undefined;
-        }
-        const fallbackPath = parsed.manager === "launchd"
-            ? join(homedir(), "Library", "LaunchAgents", `${parsed.label}.plist`)
-            : join(homedir(), ".config", "systemd", "user", `${parsed.label}.service`);
-        return { ...parsed, path: typeof parsed.path === "string" ? parsed.path : fallbackPath };
-    }
-    catch {
-        return undefined;
-    }
-}
-export function migrateServiceToLauncher(opts) {
-    const current = readServiceRecord(opts.dataDir);
-    if (!current)
-        return undefined;
-    return installService({
-        nodePath: opts.nodePath,
-        executablePath: opts.launcherPath,
-        dataDir: opts.dataDir,
-        installRoot: opts.installRoot,
-        os: current.manager === "launchd" ? "darwin" : "linux",
-        label: current.label,
-    }).record;
-}
-export function restartService(record) {
-    if (!existsSync(record.path))
-        return { ok: false, error: `service file not found: ${record.path}` };
-    if (record.manager === "launchd") {
-        spawnSync("launchctl", ["unload", record.path], { stdio: "ignore" });
-        const res = spawnSync("launchctl", ["load", "-w", record.path], { encoding: "utf8" });
-        return res.status === 0 ? { ok: true } : { ok: false, error: res.stderr || "launchctl load failed" };
-    }
-    const reload = spawnSync("systemctl", ["--user", "daemon-reload"], { encoding: "utf8" });
-    if (reload.status !== 0)
-        return { ok: false, error: reload.stderr || "systemctl daemon-reload failed" };
-    const restart = spawnSync("systemctl", ["--user", "restart", record.label], { encoding: "utf8" });
-    return restart.status === 0 ? { ok: true } : { ok: false, error: restart.stderr || "systemctl restart failed" };
-}
-/** Enable the per-user service and start it immediately. This is only called by the explicit
- * `roamcode install` command; OTA updates use restartService and never change enablement. */
-export function enableService(record) {
-    if (!existsSync(record.path))
-        return { ok: false, error: `service file not found: ${record.path}` };
-    if (record.manager === "launchd") {
-        spawnSync("launchctl", ["unload", record.path], { stdio: "ignore" });
-        const result = spawnSync("launchctl", ["load", "-w", record.path], { encoding: "utf8" });
-        return result.status === 0 ? { ok: true } : { ok: false, error: result.stderr || "launchctl load failed" };
-    }
-    const reload = spawnSync("systemctl", ["--user", "daemon-reload"], { encoding: "utf8" });
-    if (reload.status !== 0)
-        return { ok: false, error: reload.stderr || "systemctl daemon-reload failed" };
-    const result = spawnSync("systemctl", ["--user", "enable", "--now", record.label], { encoding: "utf8" });
-    return result.status === 0 ? { ok: true } : { ok: false, error: result.stderr || "systemctl enable failed" };
-}

package/dist/session-defaults.d.ts

@@ -1,26 +0,0 @@
-export interface SessionDefaults {
-    effort: string;
-    model?: string;
-    dangerouslySkip: boolean;
-    permissionMode?: string;
-    codex?: {
-        model?: string;
-        reasoningEffort?: string;
-        sandbox?: "read-only" | "workspace-write" | "danger-full-access";
-        approvalPolicy?: "untrusted" | "on-request" | "never";
-        profile?: string;
-        webSearch?: boolean;
-        addDirs?: string[];
-        dangerouslyBypassApprovalsAndSandbox?: boolean;
-    };
-}
-export interface StoredSessionDefaults {
-    defaults: SessionDefaults;
-    revision: number;
-    updatedAt: number;
-}
-export declare function normalizeSessionDefaults(value: unknown): SessionDefaults;
-export declare class SessionDefaultsConflictError extends Error {
-    readonly current: StoredSessionDefaults | undefined;
-    constructor(current: StoredSessionDefaults | undefined);
-}

package/dist/session-defaults.js

@@ -1,60 +0,0 @@
-import { z } from "zod";
-const MAX_MODEL = 128;
-const MAX_PROFILE = 128;
-const MAX_PATH = 4096;
-const MAX_ADD_DIRS = 32;
-const SAFE_MODEL = /^[A-Za-z0-9][A-Za-z0-9._:/\u005b\u005d-]*$/;
-const SAFE_EFFORT = /^[A-Za-z0-9][A-Za-z0-9._-]*$/;
-const SAFE_PROFILE = /^[A-Za-z0-9][A-Za-z0-9._-]*$/;
-const SAFE_PATH = /^\/[^\x00-\x1f\x7f]*$/;
-const modelToken = z.string().min(1).max(MAX_MODEL).regex(SAFE_MODEL, "must be a safe model token");
-const effortToken = z.string().min(1).max(128).regex(SAFE_EFFORT, "must be a safe effort token");
-const profileToken = z.string().min(1).max(MAX_PROFILE).regex(SAFE_PROFILE, "must be a safe profile token");
-const pathToken = z.string().min(1).max(MAX_PATH).regex(SAFE_PATH, "must be a safe absolute path");
-const codexDefaultsSchema = z
-    .object({
-    model: modelToken.optional(),
-    reasoningEffort: effortToken.optional(),
-    sandbox: z.enum(["read-only", "workspace-write", "danger-full-access"]).optional(),
-    approvalPolicy: z.enum(["untrusted", "on-request", "never"]).optional(),
-    profile: profileToken.optional(),
-    webSearch: z.boolean().optional(),
-    addDirs: z.array(pathToken).max(MAX_ADD_DIRS).optional(),
-    dangerouslyBypassApprovalsAndSandbox: z.boolean().optional(),
-})
-    .strict()
-    .transform((codex) => {
-    if (codex.dangerouslyBypassApprovalsAndSandbox !== true)
-        return codex;
-    const dangerousCodex = { ...codex };
-    delete dangerousCodex.sandbox;
-    delete dangerousCodex.approvalPolicy;
-    return dangerousCodex;
-});
-const sessionDefaultsSchema = z
-    .object({
-    effort: effortToken.default("medium"),
-    model: modelToken.optional(),
-    dangerouslySkip: z.boolean().default(false),
-    permissionMode: z.enum(["default", "acceptEdits", "plan", "bypassPermissions"]).optional(),
-    codex: codexDefaultsSchema.optional(),
-})
-    .strict()
-    .transform((defaults) => {
-    if (!defaults.dangerouslySkip)
-        return defaults;
-    const dangerousDefaults = { ...defaults };
-    delete dangerousDefaults.permissionMode;
-    return dangerousDefaults;
-});
-export function normalizeSessionDefaults(value) {
-    return sessionDefaultsSchema.parse(value === undefined ? {} : value);
-}
-export class SessionDefaultsConflictError extends Error {
-    current;
-    constructor(current) {
-        super("Session defaults revision conflict");
-        this.current = current;
-        this.name = "SessionDefaultsConflictError";
-    }
-}

package/dist/session-store.d.ts

@@ -1,81 +0,0 @@
-import type { CodexSessionOptions } from "./providers/types.js";
-import { type SessionDefaults, type StoredSessionDefaults } from "./session-defaults.js";
-export type StoredStatus = "running" | "dormant" | "errored" | "stopped";
-interface StoredSessionBase {
-    id: string;
-    cwd: string;
-    status: StoredStatus;
-    createdAt: number;
-    lastActivityAt: number;
-    /** Always "terminal" — the only session kind. Kept so rehydrate can filter/guard on it. */
-    mode: "terminal";
-    /** Optional user-set display name (PATCH /sessions/:id). Absent = unnamed (the UI shows the cwd). */
-    name?: string;
-}
-export interface StoredClaudeSession extends StoredSessionBase {
-    provider: "claude";
-    dangerouslySkip: boolean;
-    /** The USER-chosen spawn flags the session was created with (`--model`/`--effort`/`--permission-mode`/
-     *  `--dangerously-skip-permissions`/`--add-dir …`) — everything EXCEPT the ephemeral per-session
-     *  `--mcp-config`/`--settings` paths (those are regenerated per spawn). Persisted so a RESTART can
-     *  respawn the ended session with the same settings instead of a bare claude. Absent = no extra flags. */
-    spawnArgs?: string[];
-    providerSessionId?: never;
-    launchOptions?: never;
-    integrationStatus?: never;
-}
-export interface StoredIntegrationStatus {
-    attachments: "ready" | "degraded";
-    activity: "ready" | "degraded";
-    detail?: string;
-}
-export interface StoredCodexSession extends StoredSessionBase {
-    provider: "codex";
-    launchOptions: CodexSessionOptions;
-    providerSessionId?: string;
-    integrationStatus?: StoredIntegrationStatus;
-    dangerouslySkip?: never;
-    spawnArgs?: never;
-}
-export type StoredSession = StoredClaudeSession | StoredCodexSession;
-/** How a store is actually backed: "sqlite" (durable) or "memory-fallback" (the native module failed to
- *  load — NOT durable across restarts). Surfaced so start.ts can warn loudly + /diag can report it. */
-export type StoreMode = "sqlite" | "memory-fallback";
-export interface SessionStore {
-    /** Atomically claim a brand-new physical id. Rejects any existing owner without changing its data. */
-    claimNew(session: StoredSession): void;
-    upsert(session: StoredSession): void;
-    /** True when any physical provider table owns the id, including corrupt or cross-table ambiguous rows. */
-    has(id: string): boolean;
-    get(id: string): StoredSession | undefined;
-    list(): StoredSession[];
-    setStatus(id: string, status: StoredStatus): void;
-    touch(id: string, at: number): void;
-    /** Set/clear a session's display name (undefined clears — the row's `name` goes back to NULL). */
-    setName(id: string, name: string | undefined): void;
-    /** Persist/clear the exact resumable identity for Codex sessions only. Claude rows are never touched. */
-    setProviderSessionId(id: string, value: string | undefined): void;
-    /** Claim a hidden, non-resumable identity pending exact-thread cross-check. */
-    markProvisionalProviderSessionId(id: string, value: string): void;
-    /** Remove only the matching hidden provisional identity. */
-    clearProvisionalProviderSessionId(id: string, value: string): void;
-    /** Atomically promote only the matching hidden provisional identity to resumable state. */
-    commitProvisionalProviderSessionId(id: string, value: string): void;
-    getSessionDefaults(): StoredSessionDefaults | undefined;
-    putSessionDefaults(defaults: SessionDefaults, expectedRevision: number, updatedAt: number): StoredSessionDefaults;
-    delete(id: string): void;
-    close(): void;
-    /** "sqlite" when better-sqlite3 loaded; "memory-fallback" when it didn't (non-durable). */
-    readonly mode: StoreMode;
-}
-/** Internal trust check used by security-sensitive capabilities; only stores opened by this module are accepted. */
-export declare function isConcreteSessionStore(store: SessionStore): boolean;
-export interface OpenSessionStoreOptions {
-    /** Path to the SQLite file. ":memory:" uses an in-process DB. */
-    dbPath: string;
-    /** Injectable better-sqlite3 loader (the seam tests use to FORCE the in-memory fallback by throwing).
-     *  Defaults to `require("better-sqlite3")`. */
-    loadDatabase?: () => typeof import("better-sqlite3");
-}
-export declare function openSessionStore(opts: OpenSessionStoreOptions): SessionStore;
-export {};