@roamcode.ai/server 1.0.0 → 1.0.1

package/dist/static-routes.d.ts

@@ -1,101 +0,0 @@
-import type { FastifyInstance } from "fastify";
-/**
- * Server-side mirror of the web SW's `apiNavigationDenylist` (packages/web/src/pwa/sw-exclusions.ts),
- * EXTENDED with /health, /push and the /ws suffix. A request whose path matches one of these is a
- * live API/WS/health/push route — the SPA navigation fallback must NOT serve index.html for it (it
- * must hit the real handler), and the auth gate must NOT treat it as a public static asset.
- *
- * SYNC INVARIANT: this denylist (and `isPublicForRequest` below) decides which requests skip the
- * token gate, while Fastify's find-my-way router decides which handler a request reaches. The two
- * MUST agree on path normalization, or a request can look public to the gate yet reach a protected
- * handler (an auth bypass). We gate on the DECODED path (`pathForGate`) to match the router's
- * percent-decoding, and we reject encoded separators (`hasEncodedSep`). If Fastify is ever
- * configured with `caseSensitive:false` or `ignoreDuplicateSlashes:true`, this gate must apply the
- * SAME case/slash normalization first, or those options will silently reopen the bypass.
- */
-export declare const API_PATH_DENYLIST: RegExp[];
-/**
- * The EXPLICIT public-shell allowlist — the only paths the auth gate lets a REGISTERED route serve
- * without a token. It must cover exactly what an unauthenticated PWA boot needs (the login screen has to
- * render before a token exists): the root shell, the Vite asset dir, and the top-level bundle files
- * (index.html, sw.js, manifest.webmanifest, icons — matched by extension so a new icon the web build adds
- * doesn't need a server change). Everything else — including any FUTURE route nobody remembered to gate —
- * is token-gated by default (see the transport preHandler).
- *
- * SAFE because only static handlers live at these shapes: every API route is extensionless and no API
- * route sits at `/` or under `/assets/`. Keep it that way — an API route named like a top-level static
- * file (e.g. `/report.json`) would be silently public.
- */
-export declare const SHELL_PATH_ALLOWLIST: RegExp[];
-/** True for the static PWA shell paths above (the auth gate's explicit allowlist). */
-export declare function isShellPath(path: string): boolean;
-/**
- * Normalize a raw request URL to the path the FASTIFY ROUTER will route, for the auth gate.
- * find-my-way routes the percent-DECODED path, so we must gate on the decoded path too — otherwise
- * `GET /%73essions` (`%73`=`s`) looks public to a raw-path gate but routes to `/sessions`.
- * A malformed escape (decodeURIComponent throws) falls back to the raw path (still gated by the
- * caller's encoded-separator check), never crashing the gate.
- */
-export declare function pathForGate(rawUrl: string): string;
-/**
- * True if the RAW (pre-decode) path carries an encoded slash or backslash (`%2f`/`%2F`/`%5c`/`%5C`).
- * find-my-way's handling of encoded slashes can desync from a single `decodeURIComponent`, and any
- * request that needs an encoded separator to look public is inherently suspicious — so we treat such
- * requests as NON-public (gated) regardless of what they decode to.
- */
-export declare function hasEncodedSep(rawUrl: string): boolean;
-/**
- * The auth-boundary decision for a real request: a request is public (skips the token gate / may get
- * the SPA shell) IFF it has no encoded separator AND its decoded path is a public static/shell path.
- * Both the preHandler bypass (transport.ts) and the SPA `setNotFoundHandler` MUST use this, so the
- * gate and the router agree on what is reachable.
- */
-export declare function isPublicForRequest(rawUrl: string): boolean;
-/**
- * True for the PUBLIC static shell (HTML/JS/CSS/icons/manifest/sw + SPA navigations) — served WITHOUT
- * a token so the login screen can load and THEN authenticate. A path is public iff it is on the shell
- * allowlist, OR it is an extensionless NAVIGATION path (an SPA client route like `/login` gets
- * index.html on a hard refresh) outside the reserved API namespace. (The served bundle carries no
- * secret: the token lives only in the browser localStorage.)
- *
- * NOTE this predicate alone is NOT the auth boundary for routes: the transport preHandler is
- * DEFAULT-DENY — it only honors the navigation half of this when the request matched NO registered
- * route (fastify's `is404`), so a real handler can never hide behind an extensionless path. The
- * navigation half here also drives the SPA fallback in {@link registerStatic}'s notFound handler.
- *
- * INVARIANT: a built shell asset must NEVER live at a path starting `/sessions`, `/fs`, `/ws`,
- * `/health`, or `/push`. This holds for the Vite build (assets are emitted under `/assets/`, plus
- * root `/index.html`, `/icon-*.svg`, `/manifest.webmanifest`, `/sw.js`) — none collide with the
- * denylist. If a future asset were ever emitted under one of those prefixes, this default-deny would
- * wrongly 401 a real asset to an unauthenticated shell load (the shell would fail to boot). Keep the
- * Vite output prefixes clear of the denylist, or special-case the asset path here.
- */
-export declare function isPublicPath(path: string): boolean;
-/**
- * True if the path looks like a request for a static FILE — it lives under `/assets/` or its last
- * segment has an extension (e.g. `.js`/`.css`/`.png`/`.svg`). A file request that reaches the
- * notFound handler means the file does NOT exist on disk, so it must 404 — it must NOT fall back to
- * index.html. Serving the HTML shell for a missing `.js` makes the browser block the module script
- * (MIME mismatch → blank page) and can POISON a service-worker precache (HTML cached as the JS
- * entry). Only extensionless navigation paths (client routes like `/`, `/login`) get the SPA shell.
- *
- * Operational note: `@fastify/static` with `wildcard:false` globs the dist and registers one route
- * per file AT STARTUP, so after rebuilding the web bundle (new content-hashed filenames) the server
- * must be RESTARTED for the new assets to get routes — otherwise they reach this handler and (now)
- * correctly 404 instead of silently serving the shell.
- */
-export declare function looksLikeAssetRequest(path: string): boolean;
-export interface RegisterStaticOptions {
-    /** Absolute path to the built PWA (packages/web/dist). */
-    webDir: string;
-}
-/**
- * Serve the built PWA at `/` with an SPA fallback: a GET NAVIGATION (extensionless, public, non-API)
- * that no static file matched returns index.html, so client routes (e.g. /login) work on a hard
- * refresh. A request that looks like a missing FILE (`/assets/*`, or any `*.ext`) is served LIVE from
- * disk when the file exists under webDir but @fastify/static's startup glob missed it (a build that
- * landed after this server started — an OTA window / manual rebuild); otherwise it returns 404, never
- * the shell — so a missing asset fails loudly instead of poisoning a browser/SW cache with HTML. An
- * unknown /sessions/... still 404/401s from the real handlers / the gate.
- */
-export declare function registerStatic(app: FastifyInstance, opts: RegisterStaticOptions): void;

package/dist/static-routes.js

@@ -1,188 +0,0 @@
-import fastifyStatic from "@fastify/static";
-import { existsSync } from "node:fs";
-import { resolve, sep } from "node:path";
-/**
- * Server-side mirror of the web SW's `apiNavigationDenylist` (packages/web/src/pwa/sw-exclusions.ts),
- * EXTENDED with /health, /push and the /ws suffix. A request whose path matches one of these is a
- * live API/WS/health/push route — the SPA navigation fallback must NOT serve index.html for it (it
- * must hit the real handler), and the auth gate must NOT treat it as a public static asset.
- *
- * SYNC INVARIANT: this denylist (and `isPublicForRequest` below) decides which requests skip the
- * token gate, while Fastify's find-my-way router decides which handler a request reaches. The two
- * MUST agree on path normalization, or a request can look public to the gate yet reach a protected
- * handler (an auth bypass). We gate on the DECODED path (`pathForGate`) to match the router's
- * percent-decoding, and we reject encoded separators (`hasEncodedSep`). If Fastify is ever
- * configured with `caseSensitive:false` or `ignoreDuplicateSlashes:true`, this gate must apply the
- * SAME case/slash normalization first, or those options will silently reopen the bypass.
- */
-export const API_PATH_DENYLIST = [
-    /^\/sessions/,
-    /^\/resumable/,
-    /^\/fs/,
-    /^\/images/,
-    /^\/health/,
-    /^\/push/,
-    /^\/version/,
-    /^\/update/,
-    /^\/usage/,
-    /^\/diag/,
-    /^\/token\//,
-    /^\/auth\//,
-    /^\/claude\//,
-    /^\/ws-ticket/,
-    /\/ws$/,
-];
-/**
- * The EXPLICIT public-shell allowlist — the only paths the auth gate lets a REGISTERED route serve
- * without a token. It must cover exactly what an unauthenticated PWA boot needs (the login screen has to
- * render before a token exists): the root shell, the Vite asset dir, and the top-level bundle files
- * (index.html, sw.js, manifest.webmanifest, icons — matched by extension so a new icon the web build adds
- * doesn't need a server change). Everything else — including any FUTURE route nobody remembered to gate —
- * is token-gated by default (see the transport preHandler).
- *
- * SAFE because only static handlers live at these shapes: every API route is extensionless and no API
- * route sits at `/` or under `/assets/`. Keep it that way — an API route named like a top-level static
- * file (e.g. `/report.json`) would be silently public.
- */
-export const SHELL_PATH_ALLOWLIST = [
-    /^\/$/,
-    /^\/assets\//,
-    /^\/[^/]+\.(?:html|js|css|map|json|webmanifest|txt|ico|png|svg|jpg|jpeg|gif|webp|woff2?)$/,
-];
-/** True for the static PWA shell paths above (the auth gate's explicit allowlist). */
-export function isShellPath(path) {
-    return SHELL_PATH_ALLOWLIST.some((re) => re.test(path));
-}
-/**
- * Normalize a raw request URL to the path the FASTIFY ROUTER will route, for the auth gate.
- * find-my-way routes the percent-DECODED path, so we must gate on the decoded path too — otherwise
- * `GET /%73essions` (`%73`=`s`) looks public to a raw-path gate but routes to `/sessions`.
- * A malformed escape (decodeURIComponent throws) falls back to the raw path (still gated by the
- * caller's encoded-separator check), never crashing the gate.
- */
-export function pathForGate(rawUrl) {
-    const raw = rawUrl.split("?")[0] ?? "/";
-    try {
-        return decodeURIComponent(raw);
-    }
-    catch {
-        return raw;
-    }
-}
-/**
- * True if the RAW (pre-decode) path carries an encoded slash or backslash (`%2f`/`%2F`/`%5c`/`%5C`).
- * find-my-way's handling of encoded slashes can desync from a single `decodeURIComponent`, and any
- * request that needs an encoded separator to look public is inherently suspicious — so we treat such
- * requests as NON-public (gated) regardless of what they decode to.
- */
-export function hasEncodedSep(rawUrl) {
-    const raw = rawUrl.split("?")[0] ?? "/";
-    return /%2f|%5c/i.test(raw);
-}
-/**
- * The auth-boundary decision for a real request: a request is public (skips the token gate / may get
- * the SPA shell) IFF it has no encoded separator AND its decoded path is a public static/shell path.
- * Both the preHandler bypass (transport.ts) and the SPA `setNotFoundHandler` MUST use this, so the
- * gate and the router agree on what is reachable.
- */
-export function isPublicForRequest(rawUrl) {
-    return !hasEncodedSep(rawUrl) && isPublicPath(pathForGate(rawUrl));
-}
-/**
- * True for the PUBLIC static shell (HTML/JS/CSS/icons/manifest/sw + SPA navigations) — served WITHOUT
- * a token so the login screen can load and THEN authenticate. A path is public iff it is on the shell
- * allowlist, OR it is an extensionless NAVIGATION path (an SPA client route like `/login` gets
- * index.html on a hard refresh) outside the reserved API namespace. (The served bundle carries no
- * secret: the token lives only in the browser localStorage.)
- *
- * NOTE this predicate alone is NOT the auth boundary for routes: the transport preHandler is
- * DEFAULT-DENY — it only honors the navigation half of this when the request matched NO registered
- * route (fastify's `is404`), so a real handler can never hide behind an extensionless path. The
- * navigation half here also drives the SPA fallback in {@link registerStatic}'s notFound handler.
- *
- * INVARIANT: a built shell asset must NEVER live at a path starting `/sessions`, `/fs`, `/ws`,
- * `/health`, or `/push`. This holds for the Vite build (assets are emitted under `/assets/`, plus
- * root `/index.html`, `/icon-*.svg`, `/manifest.webmanifest`, `/sw.js`) — none collide with the
- * denylist. If a future asset were ever emitted under one of those prefixes, this default-deny would
- * wrongly 401 a real asset to an unauthenticated shell load (the shell would fail to boot). Keep the
- * Vite output prefixes clear of the denylist, or special-case the asset path here.
- */
-export function isPublicPath(path) {
-    if (isShellPath(path))
-        return true;
-    return !looksLikeAssetRequest(path) && !API_PATH_DENYLIST.some((re) => re.test(path));
-}
-/**
- * True if the path looks like a request for a static FILE — it lives under `/assets/` or its last
- * segment has an extension (e.g. `.js`/`.css`/`.png`/`.svg`). A file request that reaches the
- * notFound handler means the file does NOT exist on disk, so it must 404 — it must NOT fall back to
- * index.html. Serving the HTML shell for a missing `.js` makes the browser block the module script
- * (MIME mismatch → blank page) and can POISON a service-worker precache (HTML cached as the JS
- * entry). Only extensionless navigation paths (client routes like `/`, `/login`) get the SPA shell.
- *
- * Operational note: `@fastify/static` with `wildcard:false` globs the dist and registers one route
- * per file AT STARTUP, so after rebuilding the web bundle (new content-hashed filenames) the server
- * must be RESTARTED for the new assets to get routes — otherwise they reach this handler and (now)
- * correctly 404 instead of silently serving the shell.
- */
-export function looksLikeAssetRequest(path) {
-    return path.startsWith("/assets/") || /\/[^/]+\.[a-z0-9]+$/i.test(path);
-}
-/**
- * Serve the built PWA at `/` with an SPA fallback: a GET NAVIGATION (extensionless, public, non-API)
- * that no static file matched returns index.html, so client routes (e.g. /login) work on a hard
- * refresh. A request that looks like a missing FILE (`/assets/*`, or any `*.ext`) is served LIVE from
- * disk when the file exists under webDir but @fastify/static's startup glob missed it (a build that
- * landed after this server started — an OTA window / manual rebuild); otherwise it returns 404, never
- * the shell — so a missing asset fails loudly instead of poisoning a browser/SW cache with HTML. An
- * unknown /sessions/... still 404/401s from the real handlers / the gate.
- */
-export function registerStatic(app, opts) {
-    app.register(fastifyStatic, { root: opts.webDir, wildcard: false });
-    // The service worker is the OTA UPDATE TRIGGER: a client only swaps to a new bundle once the browser
-    // sees a CHANGED sw.js. A cacheable sw.js therefore pins clients to a STALE bundle — behind Cloudflare a
-    // cacheable sw.js inherits a multi-hour browser TTL, which silently blocked OTA updates from reaching
-    // clients until that cache expired (and reopening the PWA kept serving the old bundle). Force sw.js
-    // UNCACHED so every update check fetches it fresh and the OTA lands immediately. Cloudflare won't edge-
-    // cache a no-store response, so origin headers pass straight through — no CDN config needed. Done in
-    // onSend (not @fastify/static's setHeaders, which the plugin's own default cache-control overrides).
-    // Content-hashed `/assets/*` are immutable, so their default caching is left untouched.
-    // ALSO force the HTML SHELL (index.html — served at `/`, `/index.html`, and every SPA-fallback route)
-    // uncached: the shell embeds the content-hashed asset filenames, so a cached shell keeps pointing the
-    // browser at OLD assets — a stale bundle that survives an OTA even though the assets themselves rotated.
-    // Detected by content-type (text/html) so the SPA fallback routes are covered too; hashed `/assets/*`
-    // (JS/CSS) are immutable and keep their default long-cache.
-    app.addHook("onSend", async (request, reply, payload) => {
-        const contentType = String(reply.getHeader("content-type") ?? "");
-        if (pathForGate(request.url) === "/sw.js" || contentType.includes("text/html")) {
-            reply.header("cache-control", "no-store, no-cache, must-revalidate");
-        }
-        return payload;
-    });
-    app.setNotFoundHandler((request, reply) => {
-        const sendFile = reply.sendFile.bind(reply);
-        const path = pathForGate(request.url);
-        if (request.method === "GET" && isPublicForRequest(request.url)) {
-            if (looksLikeAssetRequest(path)) {
-                // An asset @fastify/static didn't serve. With `wildcard:false` it freezes the asset route list
-                // at STARTUP, so a build that landed AFTER this server started — an OTA's build→restart window,
-                // a manual rebuild, a parallel deploy — has new content-hashed `/assets/*` with NO route. The
-                // freshly-served index.html points at exactly those, so without this they 404 and the app fails
-                // to boot until a restart re-globs. Serve such a file LIVE from disk (constrained to webDir) so
-                // the update window never 404s; a genuinely missing file still 404s (never the HTML shell, which
-                // would poison a browser/SW cache).
-                const rel = path.replace(/^\/+/, "");
-                const abs = resolve(opts.webDir, rel);
-                const root = resolve(opts.webDir);
-                if ((abs === root || abs.startsWith(root + sep)) && existsSync(abs)) {
-                    return sendFile(rel);
-                }
-                reply.code(404).send({ error: "not found" });
-                return;
-            }
-            // A GET NAVIGATION (extensionless, public, non-API) that matched no file → the SPA shell.
-            return sendFile("index.html");
-        }
-        reply.code(404).send({ error: "not found" });
-    });
-}

package/dist/terminal-capability.d.ts

@@ -1,5 +0,0 @@
-/** Terminal mode needs BOTH a tmux binary and a loadable node-pty. Injectable for tests. */
-export declare function detectTerminalSupport(deps?: {
-    hasTmux?: () => boolean;
-    hasPty?: () => boolean;
-}): boolean;

package/dist/terminal-capability.js

@@ -1,27 +0,0 @@
-import { spawnSync } from "node:child_process";
-import { createRequire } from "node:module";
-const require = createRequire(import.meta.url);
-function tmuxOnPath() {
-    // spawnSync is FINE here: this runs exactly once, at BOOT (createServer's terminalAvailable probe),
-    // before any client is connected — there is no event loop latency to protect yet. Hot-path tmux calls
-    // (kill-session, capture-pane) are async elsewhere.
-    try {
-        return spawnSync("tmux", ["-V"], { stdio: "ignore" }).status === 0;
-    }
-    catch {
-        return false;
-    }
-}
-function ptyLoads() {
-    try {
-        require.resolve("node-pty");
-        return true;
-    }
-    catch {
-        return false;
-    }
-}
-/** Terminal mode needs BOTH a tmux binary and a loadable node-pty. Injectable for tests. */
-export function detectTerminalSupport(deps = {}) {
-    return (deps.hasTmux ?? tmuxOnPath)() && (deps.hasPty ?? ptyLoads)();
-}

package/dist/terminal-manager.d.ts

@@ -1,224 +0,0 @@
-import { type PtySpawn } from "./terminal-process.js";
-import { type PaneStatus } from "./pane-status.js";
-import { type AttachSpawnOptions } from "./config.js";
-import type { SessionStore } from "./session-store.js";
-import { ProviderRegistry } from "./providers/registry.js";
-import { type ClaudeSessionOptions, type CodexSessionOptions, type ProviderId } from "./providers/types.js";
-import type { CodexThreadResolver } from "./providers/codex-thread-resolver.js";
-export interface TerminalMeta {
-    id: string;
-    provider: ProviderId;
-    cwd: string;
-    mode: "terminal";
-    status: "running" | "ended";
-    createdAt: number;
-    lastActivityAt: number;
-    /**
-     * The session's LIVE activity, derived every ~2.5s from its rendered tmux pane by the capture-pane monitor
-     * (TerminalManager.refreshActivity → pane-status.classifyPaneStatus). UNIVERSAL (no hooks) + works while
-     * detached. Surfaced in GET /sessions to drive the rail's per-session status:
-     *   - "working" — actively generating (main spinner OR background agents still developing);
-     *   - "blocked" — claude is WAITING ON YOUR DECISION (a permission or plan prompt) → the loud
-     *     "needs you". This is the ONLY state that alerts;
-     *   - "idle"    — a finished turn sitting at an empty prompt, nothing running, nothing to decide (calm).
-     */
-    activity: PaneStatus;
-    /**
-     * Back-compat boolean = `activity === "blocked"`. Drives the loud "needs you" badge/chip, the away push, and
-     * the badge count. Kept as a distinct field so existing consumers (awaitingCount, the push gate) don't all
-     * have to learn the 3-state enum. Set together with `activity` by the monitor.
-     */
-    awaiting: boolean;
-    /**
-     * Whether this session's claude runs with `--dangerously-skip-permissions` (RCE-by-design: claude can run
-     * any tool without asking). Derived at create() from the spawn args, persisted, and surfaced in GET /sessions
-     * so the web rail can badge a session as running in skip-permissions mode.
-     */
-    dangerouslySkip: boolean;
-    /** The effective model: initialized from launch options, then refreshed from live provider chrome when the
-     *  TUI exposes it. Surfaced in GET /sessions so the chat header/rail follow in-session changes. */
-    model?: string;
-    /** Effective effort/reasoning: initialized from launch options, then refreshed from live provider chrome.
-     *  Absent means the provider controls its default. */
-    effort?: string;
-    /** Provider-native safety controls captured at launch for exact UI display. */
-    permissionMode?: ClaudeSessionOptions["permissionMode"];
-    sandbox?: CodexSessionOptions["sandbox"];
-    approvalPolicy?: CodexSessionOptions["approvalPolicy"];
-    /** User-set display name (PATCH /sessions/:id). SERVER-side so a rename shows on every device, not just
-     *  the one that typed it. Persisted; absent = unnamed (the UI falls back to the cwd). */
-    name?: string;
-    /** Codex exact-thread capture state. Claude sessions do not need a provider resume identity. */
-    identityState?: "pending" | "exact" | "ambiguous";
-    providerSessionId?: string;
-}
-export interface TerminalSub {
-    unsubscribe(): void;
-}
-export interface TerminalManagerDeps {
-    store: SessionStore;
-    providers: ProviderRegistry;
-    now: () => number;
-    ptySpawn?: PtySpawn;
-    runTmux?: (args: string[]) => void;
-    /** Dedicated tmux server socket. Defaults to the unchanged production socket; integration tests inject a
-     * unique socket so spawn, capture, resume, and cleanup cannot touch a live RoamCode instance. */
-    tmuxSocket?: string;
-    /**
-     * Best-effort notifier fired on a false→true `awaiting` transition WHEN NO CLIENT IS ATTACHED (i.e. the
-     * user is away from the desk). Wired by the transport to the push dispatcher; omitted in tests. Called in
-     * a try/catch — a throw here can NEVER break the terminal.
-     */
-    onAwaiting?: (id: string) => void;
-    /**
-     * Best-effort notifier fired when a session's claude exits (the "done" ping). `wasAttached` reports whether
-     * a client was still attached at the moment of exit — captured BEFORE the subs are torn down — so the
-     * transport can gate the away-from-desk push on "nobody was watching" (you already see the WS close when you
-     * are). Same never-throw contract.
-     */
-    onFinished?: (id: string, wasAttached: boolean) => void;
-    /**
-     * Capture a tmux session's CURRENT rendered pane as plain text (READ-ONLY). Injected for tests; in
-     * production it defaults to a real `capture-pane -p` on {@link TMUX_SOCKET}. Drives {@link refreshActivity},
-     * the universal (hook-free) working-vs-awaiting classifier.
-     */
-    capturePane?: (sessionName: string) => Promise<string>;
-    /** Builds the cwd-scoped exact-thread resolver used around a fresh Codex TUI spawn. */
-    codexThreadResolver?: (cwd: string) => CodexThreadResolver;
-}
-type CreateTerminalOptions = {
-    id: string;
-    cwd: string;
-    provider: "claude";
-    options: ClaudeSessionOptions;
-    cols?: number;
-    rows?: number;
-} | {
-    id: string;
-    cwd: string;
-    provider: "codex";
-    options: CodexSessionOptions;
-    cols?: number;
-    rows?: number;
-};
-type LegacyCreateTerminalOptions = {
-    id: string;
-    cwd: string;
-    claudeArgs?: string[];
-    cols?: number;
-    rows?: number;
-};
-export declare class TerminalManager {
-    private readonly deps;
-    private readonly records;
-    private readonly providers;
-    private attachConfig?;
-    constructor(deps: TerminalManagerDeps);
-    /** Late-bound (after listen(), which resolves the loopback port) — same config the chat SessionManager
-     *  gets. When set, each terminal's claude is spawned with `--mcp-config` so send_image/send_file work. */
-    setAttachConfig(attach: AttachSpawnOptions | undefined): void;
-    create(explicit: CreateTerminalOptions): TerminalMeta;
-    /** Temporary explicit-Claude seam for the pre-provider transport. */
-    createLegacyClaude(opts: LegacyCreateTerminalOptions): TerminalMeta;
-    /**
-     * Delete stale per-session 0600 files that hold the access token — `mcp-config-<id>.json`, `hooks-<id>.json`,
-     * `hook-auth-<id>`, and `codex-mcp-token-<id>`. A file is stale when no live session owns its id: leaked by a
-     * crash, an orphan-reap, a rehydrated record (which carries no such paths, so stop() never unlinks its files),
-     * or a token rotation. Call at boot AFTER rehydrate + setAttachConfig so `records` reflects the surviving
-     * sessions. No-op without an attach config.
-     */
-    sweepStaleMcpConfigs(): number;
-    /**
-     * Kill running terminal sessions with NO attached client that have been idle longer than `ttlMs`. OFF by
-     * default (ttlMs <= 0) and opt-in via env (SESSION_IDLE_TTL_MS): sessions intentionally survive a
-     * disconnect for later reattach, so reaping them must never be the default — it's only for hosts that
-     * choose to bound the accumulation of detached claude+tmux processes. Returns the number reaped.
-     */
-    reapIdle(ttlMs: number): number;
-    /**
-     * Push a JSON control message to every attached client of a terminal session. An `attach` (file/image)
-     * frame is ALSO buffered (bounded, oldest-dropped) so a client that (re)connects later still sees files
-     * that arrived while it was away — see {@link attach}'s replay. Other control frames (e.g. `ask`, which
-     * has its own answer/replay flow in the transport) are delivered live only.
-     */
-    pushControl(id: string, msg: unknown): boolean;
-    /**
-     * Set a session's `awaiting` flag ("claude is blocked on YOU"). The capture-pane monitor
-     * ({@link refreshActivity}) is the authority for this flag in production; this explicit setter exists for
-     * direct overrides and is exercised by the manager's tests. Deterministic — no timers, no terminal scraping.
-     * A missing session is a no-op. Does NOT fire the away-from-desk push — the monitor owns that so it can gate
-     * on {@link isAttached}.
-     */
-    setAwaiting(id: string, value: boolean): void;
-    /** Clear the awaiting flag (user is active / session ended). */
-    private clearAwaiting;
-    /** Whether a session currently has ≥1 attached client (a live browser WS). The hook route uses this so the
-     *  away-from-desk push fires ONLY when nobody is watching. */
-    isAttached(id: string): boolean;
-    /** How many sessions are currently `awaiting` you. Threaded into each away-from-desk push as `badgeCount`
-     *  so the home-screen app badge tracks "how many sessions need you" (Android/desktop badge; iOS can't). */
-    awaitingCount(): number;
-    /**
-     * Set/clear a session's display name (PATCH /sessions/:id). `undefined` clears back to unnamed. Written
-     * through to the store so the name survives restarts + rehydrate. Returns false for an unknown id so the
-     * route can 404 without a separate lookup.
-     */
-    setName(id: string, name: string | undefined): boolean;
-    /**
-     * Re-derive every RUNNING session's `awaiting` flag from its LIVE rendered tmux pane (`capture-pane`) — the
-     * single, UNIVERSAL source of truth for working / blocked / idle. Works for EVERY session (no per-session
-     * hooks needed → correct for sessions created before hooks existed) and works while the browser is DETACHED
-     * (it reads tmux directly). Called on a ~2.5s timer from start.ts. Read-only: it can never disturb a live
-     * session.
-     *
-     * {@link classifyPaneStatus} decides. A capture that returns "" (tmux hiccup) leaves the last value
-     * untouched so the status never flaps on a transient miss.
-     *
-     * `awaiting` (the loud "needs you" flag) tracks activity==="blocked" ONLY — a finished-but-idle session, or
-     * one whose background agents are still developing, is NOT "needs you". Fires
-     * {@link TerminalManagerDeps.onAwaiting} (the away push) on a not-blocked→blocked transition when no client is
-     * attached, so the nudge is universal + fires only for a genuine block.
-     */
-    refreshActivity(): Promise<void>;
-    /**
-     * Nudge tmux to repaint the WHOLE screen for a session whose pty is already running — used when a client
-     * REATTACHES (a fresh xterm) to a still-live tmux client that drew its screen earlier and won't redraw on
-     * its own, so the new client would otherwise show only a blinking cursor until something changes. A brief
-     * pty size wiggle (+1 row, then back) sends SIGWINCH, which makes tmux redraw — exactly what the manual
-     * window-resize the user found does, minus the manual part. Deferred so the new client's own initial resize
-     * lands first (rec.cols/rec.rows are then the final size we wiggle around). Best-effort + unref'd timers.
-     */
-    private forceRedraw;
-    /** Subscribe to provider output, spawning lazily through the owning provider on the first attach. */
-    attach(id: string, handlers: {
-        onData: (chunk: string) => void;
-        onExit?: () => void;
-        onControl?: (msg: string) => void;
-    }, size?: {
-        cols: number;
-        rows: number;
-    }, opts?: {
-        respawn?: "continue" | "fresh";
-        signal?: AbortSignal;
-    }): Promise<TerminalSub | undefined>;
-    private spawnForRecord;
-    private cleanupProviderPaths;
-    private cleanupRecordPaths;
-    private applyRuntimeSignal;
-    write(id: string, data: string): void;
-    resize(id: string, cols: number, rows: number): void;
-    stop(id: string): void;
-    get(id: string): TerminalMeta | undefined;
-    list(): TerminalMeta[];
-    /**
-     * After a server/OTA restart: adopt stored terminal sessions whose tmux session is still alive (so they
-     * reappear, resumable), prune store rows whose tmux session is gone, AND kill ORPHAN tmux sessions — live
-     * `rc-*` sessions with no store row (leaked by a crash or an interrupted cleanup) — so they don't pile up.
-     */
-    rehydrate(opts: {
-        liveTmuxNames: string[];
-    }): void;
-    /** Kill a tmux session for an id without needing a live proc (reuses TerminalProcess's socketed kill). */
-    private killTmux;
-}
-export {};