@threadbase-sh/streamer 1.62.0 → 1.64.0

package/dist/pty-host/remote-session-runner.d.ts

@@ -0,0 +1,133 @@
+import type { ManagedSession, PTYManagerOptions, SessionRunner, StartFreshSessionOptions, StartSessionOptions, UserMessage } from "../types";
+import { type HostHeartbeatState, type HostTransport } from "./protocol";
+export declare class PtyHostProtocolMismatchError extends Error {
+    readonly hostVersion: number;
+    readonly streamerVersion: number;
+    constructor(hostVersion: number, streamerVersion: number);
+}
+export declare const HOST_HEARTBEAT_INTERVAL_MS = 10000;
+export declare const HOST_HEARTBEAT_REQUEST_TIMEOUT_MS = 5000;
+export declare const HOST_SHUTDOWN_REQUEST_TIMEOUT_MS = 1000;
+/**
+ * `SessionRunner` backed by an out-of-process pty-host (plan Phase 6a).
+ *
+ * `LiveSessionManager` selects this runner at boot when the `ptyHost` feature
+ * flag is enabled; the default-off path keeps the in-process runners.
+ *
+ * **The mirror is the whole design problem.** `SessionRunner` is mostly
+ * synchronous — `hasSession`, `getPid`, `listSessions`, `getOutput` and
+ * `sendInput` all return values, not promises — and they are called from
+ * request handlers that cannot await a socket round-trip. So the runner keeps a
+ * local copy of session state, seeded by `status` on connect and kept current
+ * by pushed events. Reads answer from the mirror; only mutations and the two
+ * genuinely async methods cross the wire.
+ *
+ * The consequence worth stating: a mirror can be stale, and the honest failure
+ * for a stale mirror is the same one an in-process runner gives for an unknown
+ * session — throw. It must never invent a session, and it must never answer
+ * "no such session" for one the host is holding, which is why `status` is
+ * awaited before the runner is handed out (see `connect`).
+ */
+export declare class RemoteSessionRunner implements SessionRunner {
+    private transport;
+    private options;
+    private decoder;
+    private nextRequestId;
+    private pending;
+    /** The mirror. Rebuilt wholesale by `status`, patched by events. */
+    private sessions;
+    /** Ring buffers, fed by `output` events so `getOutput` stays synchronous. */
+    private output;
+    private inputHistory;
+    /** Fixed for a session's lifetime, so only spawn and status carry it. */
+    private pids;
+    private closed;
+    private heartbeatTimer;
+    private heartbeatInFlight;
+    /**
+     * The only supported way to build one: a runner whose mirror has not been
+     * seeded yet would answer `hasSession` with a confident, wrong `false` for
+     * every session the host is holding — which reads as "the agent is gone" and
+     * routes the user to start a new one.
+     */
+    static connect(transport: HostTransport, options?: PTYManagerOptions): Promise<RemoteSessionRunner>;
+    private constructor();
+    private handleLine;
+    /**
+     * Fail every in-flight request when the socket drops.
+     *
+     * Without this each one stays pending forever and the caller — a session
+     * start, an input write — hangs rather than erroring. PR 9 adds reconnection;
+     * until then a dropped host is a hard failure that says so.
+     */
+    private handleClose;
+    private request;
+    /**
+     * Fire-and-forget for the synchronous parts of `SessionRunner`.
+     *
+     * `sendKeys`, `cancel`, `killPid` and `putOnHold` all return void, so there is
+     * no channel to report a failure through even if we waited for one. The
+     * response is still consumed — an unhandled rejection would take the process
+     * down over a keystroke that failed to land.
+     */
+    private fireAndForget;
+    private readStatus;
+    private refreshMirror;
+    heartbeat(state: HostHeartbeatState, timeoutMs?: number): Promise<void>;
+    startHeartbeat(getState: () => HostHeartbeatState, intervalMs?: number): void;
+    private stopHeartbeat;
+    private handleEvent;
+    start(sessionId: string, options: StartSessionOptions): Promise<ManagedSession>;
+    startFresh(options: StartFreshSessionOptions): Promise<ManagedSession>;
+    /**
+     * Take a spawn answer into the mirror.
+     *
+     * The pid lands here and nowhere else in the live path: `recordSessionSpawn`
+     * reads it immediately after start to write the durable registry row, and a
+     * null there costs the next boot its ability to probe whether the agent
+     * outlived us.
+     */
+    private adopt;
+    /**
+     * Returns the mirror's promptCount, optimistically incremented.
+     *
+     * The interface is synchronous, so there is no way to return the host's
+     * authoritative count. The increment matches what an in-process runner does
+     * for the same call, and the next `status-change` event overwrites it — so a
+     * mirror that guessed wrong is corrected within one round trip rather than
+     * drifting.
+     */
+    sendInput(sessionId: string, input: string): number;
+    sendKeys(sessionId: string, keys: string): void;
+    cancel(sessionId: string): void;
+    killPid(pid: number): void;
+    putOnHold(sessionId: string): void;
+    getOutput(sessionId: string): string;
+    getOutputLines(sessionId: string, maxLines: number): Promise<string[]>;
+    /**
+     * Synchronous, so it answers from the mirror rather than the host.
+     *
+     * Seeded lazily: `user-message` events append as they arrive, and a session
+     * this streamer did not start has none until `hydrateInputHistory` fetches
+     * them. Empty is the same answer an in-process runner gives for an unknown
+     * session, so a caller cannot tell "none yet" from "not fetched" — which is
+     * why the fetch is explicit rather than hidden behind this getter.
+     */
+    getInputHistory(sessionId: string): UserMessage[];
+    /** Pull a session's recorded messages from the host into the mirror. */
+    hydrateInputHistory(sessionId: string): Promise<UserMessage[]>;
+    getPid(sessionId: string): number | null;
+    getSession(sessionId: string): ManagedSession | null;
+    hasSession(sessionId: string): boolean;
+    listSessions(): ManagedSession[];
+    /**
+     * Drops this streamer's connection and nothing else.
+     *
+     * Emphatically NOT the in-process `dispose()`, which signals every child. The
+     * entire point of the host is that its PTYs outlive the streamer, so tearing
+     * them down here would spend the feature to implement a method name.
+     */
+    dispose(): void;
+    private requireSession;
+}
+//# sourceMappingURL=remote-session-runner.d.ts.map

package/dist/pty-host/remote-session-runner.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"remote-session-runner.d.ts","sourceRoot":"","sources":["../../src/pty-host/remote-session-runner.ts"],"names":[],"mappings":"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"}

package/dist/pty-host/socket.d.ts

@@ -0,0 +1,54 @@
+import { type Server, type Socket } from "node:net";
+import { encodeMessage, type HostTransport } from "./protocol";
+/**
+ * Socket plumbing for the pty-host (plan Phase 6b).
+ *
+ * A unix domain socket on POSIX, a named pipe on Windows. Both are local-only
+ * by construction, which is the security property that matters: the host can
+ * spawn arbitrary agent processes, so it must never be reachable over a TCP
+ * port that something else on the network could find.
+ */
+/**
+ * Where the host listens.
+ *
+ * Scoped by instance id, so two streamers configured as separate instances on
+ * one machine do not fight over one host — the same reason DB-persisted
+ * sessions are scoped by it.
+ *
+ * POSIX puts it under the config dir rather than /tmp: `THREADBASE_CONFIG_DIR`
+ * already redirects the whole config tree in tests, and a path under a
+ * user-owned directory cannot be pre-created by another user to hijack the
+ * bind. Windows named pipes are not filesystem paths at all, so the config dir
+ * has nothing to say about them.
+ */
+export declare function hostSocketPath(instanceId: string): string;
+/** Wrap a connected socket as the duplex line channel the runner expects. */
+export declare function socketTransport(socket: Socket): HostTransport;
+/** Connect to a host that is already listening. Rejects if none is. */
+export declare function connectToHost(socketPath: string): Promise<HostTransport>;
+export type PtyHostStatusProbe = {
+    reachable: true;
+    protocolVersion: number;
+    sessionCount: number;
+} | {
+    reachable: false;
+    error: string;
+};
+/** Query host status without subscribing to events or adopting its sessions. */
+export declare function probePtyHostStatus(socketPath: string, timeoutMs?: number): Promise<PtyHostStatusProbe>;
+export interface HostServerHandlers {
+    /** One connected streamer. Returns a disposer run when it disconnects. */
+    onConnection: (transport: HostTransport) => () => void;
+}
+/**
+ * Listen for streamer connections.
+ *
+ * A stale socket file from a host that died without cleaning up would make
+ * `listen` fail with EADDRINUSE forever, so an unconnectable one is removed
+ * first — but only after a probe confirms nothing answers on it, because
+ * deleting a live host's socket would strand every session it holds.
+ */
+export declare function listenForStreamers(socketPath: string, handlers: HostServerHandlers): Promise<Server>;
+/** Broadcast helper: a message to every currently-connected streamer. */
+export declare function broadcast(transports: Iterable<HostTransport>, message: Parameters<typeof encodeMessage>[0]): void;
+//# sourceMappingURL=socket.d.ts.map

package/dist/pty-host/socket.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"socket.d.ts","sourceRoot":"","sources":["../../src/pty-host/socket.ts"],"names":[],"mappings":"AAAA,OAAO,EAAkC,KAAK,MAAM,EAAE,KAAK,MAAM,EAAE,MAAM,UAAU,CAAC;AAGpF,OAAO,EACL,aAAa,EAEb,KAAK,aAAa,EAGnB,MAAM,YAAY,CAAC;AAEpB;;;;;;;GAOG;AAEH;;;;;;;;;;;;GAYG;AACH,wBAAgB,cAAc,CAAC,UAAU,EAAE,MAAM,GAAG,MAAM,CAMzD;AAED,6EAA6E;AAC7E,wBAAgB,eAAe,CAAC,MAAM,EAAE,MAAM,GAAG,aAAa,CA2B7D;AAED,uEAAuE;AACvE,wBAAgB,aAAa,CAAC,UAAU,EAAE,MAAM,GAAG,OAAO,CAAC,aAAa,CAAC,CASxE;AAED,MAAM,MAAM,kBAAkB,GAC1B;IAAE,SAAS,EAAE,IAAI,CAAC;IAAC,eAAe,EAAE,MAAM,CAAC;IAAC,YAAY,EAAE,MAAM,CAAA;CAAE,GAClE;IAAE,SAAS,EAAE,KAAK,CAAC;IAAC,KAAK,EAAE,MAAM,CAAA;CAAE,CAAC;AAExC,gFAAgF;AAChF,wBAAsB,kBAAkB,CACtC,UAAU,EAAE,MAAM,EAClB,SAAS,SAAQ,GAChB,OAAO,CAAC,kBAAkB,CAAC,CA2E7B;AAED,MAAM,WAAW,kBAAkB;IACjC,0EAA0E;IAC1E,YAAY,EAAE,CAAC,SAAS,EAAE,aAAa,KAAK,MAAM,IAAI,CAAC;CACxD;AAED;;;;;;;GAOG;AACH,wBAAsB,kBAAkB,CACtC,UAAU,EAAE,MAAM,EAClB,QAAQ,EAAE,kBAAkB,GAC3B,OAAO,CAAC,MAAM,CAAC,CA6BjB;AAED,yEAAyE;AACzE,wBAAgB,SAAS,CACvB,UAAU,EAAE,QAAQ,CAAC,aAAa,CAAC,EACnC,OAAO,EAAE,UAAU,CAAC,OAAO,aAAa,CAAC,CAAC,CAAC,CAAC,GAC3C,IAAI,CAUN"}

package/dist/pty-host/spawn-host.d.ts

@@ -0,0 +1,30 @@
+import type { HostTransport } from "./protocol";
+export interface SpawnHostOptions {
+    instanceId: string;
+    /** argv[1] for the child — the CLI entry point. Defaults to this process's. */
+    entryPoint?: string;
+    timeoutMs?: number;
+}
+/**
+ * Connect to the host for this instance, spawning it if none is listening.
+ *
+ * Attach-first rather than spawn-first: the host outliving the streamer is the
+ * feature, so the common case after a restart is that one is already there.
+ */
+export declare function connectOrSpawnHost(options: SpawnHostOptions): Promise<HostTransport>;
+/**
+ * Spawn the host so it survives this process.
+ *
+ * Three properties, each load-bearing:
+ *
+ *  - `detached` puts it in its own process group, so a Ctrl-C or a group kill
+ *    aimed at the streamer does not take the agents with it.
+ *  - `stdio: "ignore"` means it holds none of our descriptors. A child that
+ *    inherited our stdout keeps a pipe open that the parent's exit cannot
+ *    close, and on POSIX would also receive our terminal's SIGHUP — which is
+ *    precisely the hangup this whole feature exists to avoid.
+ *  - `unref()` removes it from our event loop, so the streamer can exit while
+ *    the host keeps running.
+ */
+export declare function spawnDetachedHost(socketPath: string, entryPoint?: string): void;
+//# sourceMappingURL=spawn-host.d.ts.map

package/dist/pty-host/spawn-host.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"spawn-host.d.ts","sourceRoot":"","sources":["../../src/pty-host/spawn-host.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,YAAY,CAAC;AAahD,MAAM,WAAW,gBAAgB;IAC/B,UAAU,EAAE,MAAM,CAAC;IACnB,+EAA+E;IAC/E,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,SAAS,CAAC,EAAE,MAAM,CAAC;CACpB;AAED;;;;;GAKG;AACH,wBAAsB,kBAAkB,CAAC,OAAO,EAAE,gBAAgB,GAAG,OAAO,CAAC,aAAa,CAAC,CA4B1F;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAgB,iBAAiB,CAAC,UAAU,EAAE,MAAM,EAAE,UAAU,CAAC,EAAE,MAAM,GAAG,IAAI,CAO/E"}

package/dist/pty-manager.d.ts

@@ -0,0 +1,65 @@
+import type { ManagedSession, PTYManagerOptions, SessionRunner, StartFreshSessionOptions, StartSessionOptions, UserMessage } from "./types";
+export declare class PTYManager implements SessionRunner {
+    private sessions;
+    private onOutput;
+    private onStatusChange;
+    private onReady;
+    private onPermissionChange;
+    private onPhaseChange;
+    private onLiveQuestion;
+    private onLiveQuestionGone;
+    private onUserMessage;
+    private permissionOpen;
+    private oscTail;
+    private lastDetectAt;
+    private lastScreenQuestionKey;
+    private shellPromptOpen;
+    private closedGateKey;
+    private pendingReady;
+    private queuedInputs;
+    private log;
+    private firstChunkAt;
+    private chunkIndex;
+    private lastChunkAt;
+    private quietCheckers;
+    private readyFallbackTimers;
+    private startPromises;
+    constructor(options?: PTYManagerOptions);
+    start(sessionId: string, options: StartSessionOptions): Promise<ManagedSession>;
+    private doStart;
+    startFresh(options: StartFreshSessionOptions): Promise<ManagedSession>;
+    sendKeys(sessionId: string, keys: string): void;
+    sendInput(sessionId: string, input: string): number;
+    private writeSubmit;
+    private flushQueuedInputs;
+    cancel(sessionId: string): void;
+    killPid(pid: number): void;
+    putOnHold(sessionId: string): void;
+    getOutput(sessionId: string): string;
+    getOutputLines(sessionId: string, maxLines: number): Promise<string[]>;
+    getInputHistory(sessionId: string): UserMessage[];
+    getPid(sessionId: string): number | null;
+    private recordUserMessage;
+    getSession(sessionId: string): ManagedSession | null;
+    hasSession(sessionId: string): boolean;
+    listSessions(): ManagedSession[];
+    dispose(): void;
+    private handleOutput;
+    private detectLivePrompts;
+    private handleQuiet;
+    private recheckReadyFromScreen;
+    private armReadyFallback;
+    private clearReadyFallback;
+    /**
+     * Record the agent's phase and notify only on a real change.
+     *
+     * The change guard is load-bearing, not an optimisation: the scrape pass runs
+     * on every chunk, so an unguarded setter would fire the callback — and the
+     * WS frame behind it — several times a second for the entire duration of a
+     * turn while reporting the same value.
+     */
+    private setPhase;
+    private markReady;
+    private handleExit;
+}
+//# sourceMappingURL=pty-manager.d.ts.map

package/dist/pty-manager.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"pty-manager.d.ts","sourceRoot":"","sources":["../src/pty-manager.ts"],"names":[],"mappings":"AA4BA,OAAO,KAAK,EAEV,cAAc,EACd,iBAAiB,EACjB,aAAa,EACb,wBAAwB,EACxB,mBAAmB,EAEnB,WAAW,EACZ,MAAM,SAAS,CAAC;AAyHjB,qBAAa,UAAW,YAAW,aAAa;IAC9C,OAAO,CAAC,QAAQ,CAAsC;IACtD,OAAO,CAAC,QAAQ,CAAgC;IAChD,OAAO,CAAC,cAAc,CAAsC;IAC5D,OAAO,CAAC,OAAO,CAA+B;IAC9C,OAAO,CAAC,kBAAkB,CAA0C;IACpE,OAAO,CAAC,aAAa,CAAqC;IAC1D,OAAO,CAAC,cAAc,CAAsC;IAC5D,OAAO,CAAC,kBAAkB,CAA0C;IACpE,OAAO,CAAC,aAAa,CAAqC;IAI1D,OAAO,CAAC,cAAc,CAAqB;IAG3C,OAAO,CAAC,OAAO,CAA6B;IAG5C,OAAO,CAAC,YAAY,CAA6B;IAGjD,OAAO,CAAC,qBAAqB,CAA6B;IAK1D,OAAO,CAAC,eAAe,CAA6B;IAOpD,OAAO,CAAC,aAAa,CAA6B;IAGlD,OAAO,CAAC,YAAY,CAAqB;IAMzC,OAAO,CAAC,YAAY,CAA+B;IACnD,OAAO,CAAC,GAAG,CAAS;IAGpB,OAAO,CAAC,YAAY,CAA6B;IAIjD,OAAO,CAAC,UAAU,CAA6B;IAC/C,OAAO,CAAC,WAAW,CAA6B;IAIhD,OAAO,CAAC,aAAa,CAAkD;IAEvE,OAAO,CAAC,mBAAmB,CAAqC;IAIhE,OAAO,CAAC,aAAa,CAA8C;IAEnE,YAAY,OAAO,GAAE,iBAAsB,EAU1C;IAkBK,KAAK,CAAC,SAAS,EAAE,MAAM,EAAE,OAAO,EAAE,mBAAmB,GAAG,OAAO,CAAC,cAAc,CAAC,CAkBpF;YAEa,OAAO;IAkFf,UAAU,CAAC,OAAO,EAAE,wBAAwB,GAAG,OAAO,CAAC,cAAc,CAAC,CA2E3E;IAID,QAAQ,CAAC,SAAS,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,IAAI,CAmB9C;IAED,SAAS,CAAC,SAAS,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,MAAM,CAyClD;IAgBD,OAAO,CAAC,WAAW;IAwDnB,OAAO,CAAC,iBAAiB;IA8BzB,MAAM,CAAC,SAAS,EAAE,MAAM,GAAG,IAAI,CAI9B;IAED,OAAO,CAAC,GAAG,EAAE,MAAM,GAAG,IAAI,CAMzB;IAGD,SAAS,CAAC,SAAS,EAAE,MAAM,GAAG,IAAI,CA2BjC;IAED,SAAS,CAAC,SAAS,EAAE,MAAM,GAAG,MAAM,CAInC;IAUK,cAAc,CAAC,SAAS,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,EAAE,CAAC,CAkB3E;IAED,eAAe,CAAC,SAAS,EAAE,MAAM,GAAG,WAAW,EAAE,CAEhD;IAMD,MAAM,CAAC,SAAS,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAEvC;IAKD,OAAO,CAAC,iBAAiB;IAgBzB,UAAU,CAAC,SAAS,EAAE,MAAM,GAAG,cAAc,GAAG,IAAI,CAGnD;IAED,UAAU,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO,CAErC;IAED,YAAY,IAAI,cAAc,EAAE,CAE/B;IAED,OAAO,IAAI,IAAI,CAuBd;IAED,OAAO,CAAC,YAAY;YA2FN,iBAAiB;IAmN/B,OAAO,CAAC,WAAW;YAkDL,sBAAsB;IAgBpC,OAAO,CAAC,gBAAgB;IAYxB,OAAO,CAAC,kBAAkB;IAQ1B;;;;;;;OAOG;IACH,OAAO,CAAC,QAAQ;IAOhB,OAAO,CAAC,SAAS;IA2CjB,OAAO,CAAC,UAAU;CAoCnB"}

package/dist/pty-shared.d.ts

@@ -0,0 +1,27 @@
+import { Terminal } from "@xterm/headless";
+import type { ManagedSession, UserMessage } from "./types";
+/**
+ * Plumbing shared by the two PTY runners (`pty-manager.ts` for Claude,
+ * `codex-pty-runner.ts` for Codex). These were duplicated byte-for-byte in both
+ * files; the copies drifted only in their comments.
+ *
+ * Deliberately plumbing only. The two runners' *detection* logic stays
+ * provider-specific and is not shared: Claude signals readiness with OSC 777
+ * plus prompt markers, Codex with rendered status-bar predicates and no OSC at
+ * all. Merging those would couple two independent provider contracts.
+ */
+export declare const PTY_COLS = 120;
+export declare const PTY_ROWS = 40;
+export declare const SCREEN_SCROLLBACK = 1000;
+export declare const REPLAY_MAX_LINES: number;
+export declare function digestBytes(s: string): string;
+export declare function loadPty(): Promise<typeof import("node-pty")>;
+export interface InternalSession extends ManagedSession {
+    process: any;
+    outputBuffer: Buffer;
+    screen: Terminal;
+    inputHistory: UserMessage[];
+}
+export declare function createScreen(): Terminal;
+export declare function stripAnsi(str: string): string;
+//# sourceMappingURL=pty-shared.d.ts.map

package/dist/pty-shared.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"pty-shared.d.ts","sourceRoot":"","sources":["../src/pty-shared.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,MAAM,iBAAiB,CAAC;AAC3C,OAAO,KAAK,EAAE,cAAc,EAAE,WAAW,EAAE,MAAM,SAAS,CAAC;AAE3D;;;;;;;;;GASG;AAKH,eAAO,MAAM,QAAQ,MAAM,CAAC;AAC5B,eAAO,MAAM,QAAQ,KAAK,CAAC;AAE3B,eAAO,MAAM,iBAAiB,OAAO,CAAC;AAOtC,eAAO,MAAM,gBAAgB,QAA+B,CAAC;AAE7D,wBAAgB,WAAW,CAAC,CAAC,EAAE,MAAM,GAAG,MAAM,CAW7C;AAKD,wBAAsB,OAAO,IAAI,OAAO,CAAC,cAAc,UAAU,CAAC,CAAC,CAYlE;AAED,MAAM,WAAW,eAAgB,SAAQ,cAAc;IACrD,OAAO,EAAE,GAAG,CAAC;IACb,YAAY,EAAE,MAAM,CAAC;IAKrB,MAAM,EAAE,QAAQ,CAAC;IAGjB,YAAY,EAAE,WAAW,EAAE,CAAC;CAC7B;AAED,wBAAgB,YAAY,IAAI,QAAQ,CAOvC;AAGD,wBAAgB,SAAS,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAG7C"}

package/dist/scanner-manager.d.ts

@@ -0,0 +1,126 @@
+import { type Conversation, type ConversationMeta, ConversationScanner, type FileStatEntry } from "@threadbase-sh/scanner";
+import type { ConversationCache } from "./conversation-cache";
+import type { CacheMetadataRepository } from "./db/repositories/cacheMetadata.repository";
+import type { ConversationsRepository } from "./db/repositories/conversations.repository";
+import type { ProjectsRepository } from "./db/repositories/projects.repository";
+import type { CacheIntegrityMonitor } from "./services/cache-integrity/cacheIntegrityMonitor";
+import { debounce } from "./utils/debounce";
+export type ConversationReconcileMode = "files" | "full";
+export type ScanProfile = {
+    id: string;
+    label: string;
+    configDir: string;
+    enabled: boolean;
+    emoji: string;
+};
+/**
+ * Everything ScannerManager reads from the server. Nullable collaborators are
+ * thunks rather than values because they are opened during listen() and
+ * rebound by the integrity monitor's reset-and-rescan — the same reason
+ * ApiDeps passes `cache: () => ConversationCache | null`.
+ */
+export type ScannerManagerDeps = {
+    scanProfiles: ScanProfile[] | undefined;
+    codexRoots: string[];
+    directoryDebounceMs: number;
+    persistenceDisabled: boolean;
+    cache: () => ConversationCache | null;
+    cacheMonitor: () => CacheIntegrityMonitor | null;
+    projectsRepo: () => ProjectsRepository | null;
+    conversationsRepo: () => ConversationsRepository | null;
+    cacheMetadataRepo: () => CacheMetadataRepository | null;
+    trackCacheWrite: (task: Promise<unknown>) => void;
+};
+/**
+ * Owns the conversation scanner's lifecycle and freshness state: which scanner
+ * instance is current, whether a scan is in flight, which files went stale, and
+ * the cache↔disk reconcile that closes the gap.
+ *
+ * Extracted from StreamerServer so scanner work stops editing the server file
+ * (see docs/plans/2026-07-12-server-ts-split.md, PR 2).
+ */
+export declare class ScannerManager {
+    private deps;
+    private scanner;
+    private scannerReady;
+    private scannerStale;
+    private persistenceDisabled;
+    private allScanners;
+    private stalePaths;
+    private reconcileInFlight;
+    private lastAutoFullReconcileAt;
+    private static readonly AUTO_FULL_RECONCILE_COOLDOWN_MS;
+    private refreshInFlight;
+    private log;
+    /**
+     * Trailing-debounced "the directory changed" signal. Kept public because the
+     * server wires it straight into the watcher callback and cancels it in
+     * close(); `.cancel()` is part of its contract.
+     */
+    readonly markStaleDebounced: ReturnType<typeof debounce>;
+    constructor(deps: ScannerManagerDeps);
+    /** The current scanner without triggering a scan; null before the first one. */
+    get current(): ConversationScanner | null;
+    /** The in-flight (or settled) scan promise; null when no scanner was ever built. */
+    get ready(): Promise<unknown> | null;
+    get stale(): boolean;
+    set stale(value: boolean);
+    /** The stale-path set itself, so callers can add/clear/size it in place. */
+    get staleFiles(): Set<string>;
+    /** Drop the current scanner so the next get() builds a fresh one. */
+    invalidate(): void;
+    /**
+     * A new JSONL bound to a live session: the index must pick it up.
+     *
+     * Arm the stale flag when a scan already exists, so the next get() reconciles
+     * in place. With no scanner yet there is nothing to mark, so drop it instead
+     * and let the next get() build one. Exactly one of the two happens — dropping
+     * the scanner in both cases would throw away a live index on every bind.
+     */
+    markStaleOrDrop(): void;
+    /** Persistent indexes are disabled for the rest of this process's life. */
+    disablePersistence(): void;
+    /** Track a scanner the server built itself so close() still tears it down. */
+    track(scanner: ConversationScanner): void;
+    /**
+     * Adopt the warm-up scanner as the live one, but only if nothing else claimed
+     * the slot while the warm-up scan ran.
+     */
+    adoptIfUnclaimed(scanner: ConversationScanner): boolean;
+    buildStatCache(previousScanner: ConversationScanner | null): Map<string, {
+        stat: FileStatEntry;
+        meta: ConversationMeta;
+    }> | undefined;
+    codexScanOpts(): {
+        providers: ("claude-code" | "codex-cli")[];
+        codexRoots: string[];
+    };
+    newScanner(options?: ConstructorParameters<typeof ConversationScanner>[0]): ConversationScanner;
+    /**
+     * The projects dirs disk discovery should walk — the single source of truth
+     * for "where do this server's JSONLs live", mirroring the warm-up watcher
+     * (see listen()). Derived from the enabled scanProfiles' configDirs, or the
+     * real ~/.claude/projects when no profiles are configured. An all-disabled
+     * profile set intentionally yields [] (nothing to discover), matching the
+     * watcher — it does NOT fall back to home in that case.
+     */
+    projectsDirs(): string[];
+    takeStaleFiles(): string[];
+    refreshStaleFiles(scanner: ConversationScanner, paths: string[]): Promise<ConversationMeta[]>;
+    isConversationSnapshotStale(conv: Conversation): boolean;
+    refreshFileGuarded(scanner: ConversationScanner, filePath: string): Promise<Awaited<ReturnType<ConversationScanner["refreshFile"]>> | null>;
+    get(skipStaleRescan?: boolean): Promise<ConversationScanner>;
+    getFresh(): Promise<ConversationScanner>;
+    rescanForRefresh(onProgress?: (scanned: number, total: number) => void): Promise<ConversationScanner>;
+    /**
+     * Full-glob scan + cache upsert/delete reconcile. Used by ?refresh=1 and by
+     * the automatic freshness path when the directory watcher marked the scanner
+     * stale or shouldRefreshProjectsFromHdd detected disk drift.
+     */
+    reconcileFromDisk(onProgress?: (scanned: number, total: number) => void): Promise<void>;
+    startBackgroundReconcile(mode?: ConversationReconcileMode): void;
+    reconcileMode(): ConversationReconcileMode | null;
+    private reconcileStaleFilesFromDisk;
+    close(): Promise<void>;
+}
+//# sourceMappingURL=scanner-manager.d.ts.map

package/dist/scanner-manager.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"scanner-manager.d.ts","sourceRoot":"","sources":["../src/scanner-manager.ts"],"names":[],"mappings":"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"}

package/dist/schemas/cacheAlert.schema.d.ts

@@ -0,0 +1,14 @@
+import { z } from "zod";
+/** Body for POST /api/cache/alert/resolve. */
+export declare const ResolveCacheAlertSchema: z.ZodObject<{
+    fingerprint: z.ZodString;
+    action: z.ZodEnum<{
+        ignore: "ignore";
+        prune_all: "prune_all";
+        prune_selected: "prune_selected";
+        reset_rescan: "reset_rescan";
+    }>;
+    ids: z.ZodOptional<z.ZodArray<z.ZodString>>;
+}, z.core.$strip>;
+export type ResolveCacheAlertBody = z.infer<typeof ResolveCacheAlertSchema>;
+//# sourceMappingURL=cacheAlert.schema.d.ts.map

package/dist/schemas/cacheAlert.schema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cacheAlert.schema.d.ts","sourceRoot":"","sources":["../../src/schemas/cacheAlert.schema.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,8CAA8C;AAC9C,eAAO,MAAM,uBAAuB;;;;;;;;;iBAShC,CAAC;AAEL,MAAM,MAAM,qBAAqB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,uBAAuB,CAAC,CAAC"}

package/dist/schemas/claudeFlags.schema.d.ts

@@ -0,0 +1,7 @@
+import { z } from "zod";
+export declare const ClaudeFlagsBodySchema: z.ZodObject<{
+    values: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodString, z.ZodBoolean, z.ZodArray<z.ZodString>]>>>;
+    extraArgs: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>;
+export type ClaudeFlagsBody = z.infer<typeof ClaudeFlagsBodySchema>;
+//# sourceMappingURL=claudeFlags.schema.d.ts.map

package/dist/schemas/claudeFlags.schema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"claudeFlags.schema.d.ts","sourceRoot":"","sources":["../../src/schemas/claudeFlags.schema.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAYxB,eAAO,MAAM,qBAAqB;;;kBAYvB,CAAC;AAEZ,MAAM,MAAM,eAAe,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,qBAAqB,CAAC,CAAC"}

package/dist/schemas/project.schema.d.ts

@@ -0,0 +1,18 @@
+import { z } from "zod";
+/**
+ * Persisted Project row. Mirrors the projects SQLite table.
+ */
+export declare const ProjectSchema: z.ZodObject<{
+    id: z.ZodString;
+    path: z.ZodString;
+    name: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    lastConversationId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    lastConversationCreatedAt: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    lastIndexedAt: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    latestMessageAt: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    latestMessageId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    createdAt: z.ZodString;
+    updatedAt: z.ZodString;
+}, z.core.$strip>;
+export type Project = z.infer<typeof ProjectSchema>;
+//# sourceMappingURL=project.schema.d.ts.map

package/dist/schemas/project.schema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"project.schema.d.ts","sourceRoot":"","sources":["../../src/schemas/project.schema.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB;;GAEG;AACH,eAAO,MAAM,aAAa;;;;;;;;;;;iBAcxB,CAAC;AAEH,MAAM,MAAM,OAAO,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,aAAa,CAAC,CAAC"}

package/dist/schemas/updateConfig.schema.d.ts

@@ -0,0 +1,19 @@
+import { z } from "zod";
+export declare const UpdateConfigSchema: z.ZodObject<{
+    auto_update: z.ZodDefault<z.ZodBoolean>;
+    channel: z.ZodDefault<z.ZodEnum<{
+        next: "next";
+        stable: "stable";
+    }>>;
+    allow: z.ZodDefault<z.ZodArray<z.ZodEnum<{
+        major: "major";
+        minor: "minor";
+        patch: "patch";
+    }>>>;
+    poll_interval_minutes: z.ZodDefault<z.ZodNumber>;
+    defer_if_active_sessions: z.ZodDefault<z.ZodBoolean>;
+    github_repo: z.ZodString;
+    webhook_secret: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+}, z.core.$strict>;
+export type UpdateConfig = z.infer<typeof UpdateConfigSchema>;
+//# sourceMappingURL=updateConfig.schema.d.ts.map

package/dist/schemas/updateConfig.schema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"updateConfig.schema.d.ts","sourceRoot":"","sources":["../../src/schemas/updateConfig.schema.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,eAAO,MAAM,kBAAkB;;;;;;;;;;;;;;;kBAUpB,CAAC;AAEZ,MAAM,MAAM,YAAY,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,kBAAkB,CAAC,CAAC"}

package/dist/seal.d.ts

@@ -0,0 +1,14 @@
+export interface SealedPayload {
+    ciphertext: string;
+    nonce: string;
+    ephemeralPublicKey: string;
+}
+/**
+ * Encrypts a plaintext to a recipient's X25519 public key using NaCl box with
+ * an ephemeral sender keypair. The phone holds the recipient private key in
+ * its own memory and decrypts with nacl.box.open(ciphertext, nonce, ephemeralPublicKey, recipientPrivateKey).
+ *
+ * The wire format is custom (not libsodium crypto_box_seal) but cryptographically equivalent.
+ */
+export declare function seal(plaintext: string, recipientPublicKeyBase64: string): SealedPayload;
+//# sourceMappingURL=seal.d.ts.map

package/dist/seal.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"seal.d.ts","sourceRoot":"","sources":["../src/seal.ts"],"names":[],"mappings":"AAGA,MAAM,WAAW,aAAa;IAC5B,UAAU,EAAE,MAAM,CAAC;IACnB,KAAK,EAAE,MAAM,CAAC;IACd,kBAAkB,EAAE,MAAM,CAAC;CAC5B;AAED;;;;;;GAMG;AACH,wBAAgB,IAAI,CAAC,SAAS,EAAE,MAAM,EAAE,wBAAwB,EAAE,MAAM,GAAG,aAAa,CAgBvF"}

package/dist/server-identity.d.ts

@@ -0,0 +1,43 @@
+import { type KeyObject } from "crypto";
+export interface ServerIdentity {
+    /** Raw X25519 public key, base64url, 43 chars. Public: the QR, /api/info, logs. */
+    publicKey: string;
+    /** Never leaves the process — not a log line, not a response, not an error message. */
+    privateKey: KeyObject;
+}
+/**
+ * `~/.threadbase/keys/server-identity.key`.
+ *
+ * Its own file, not a `server.yaml` key: that file is parsed by single-line
+ * regex and users are invited to hand-edit it, which is no place for a private
+ * key. The config dir is resolved per call, and inlined rather than imported
+ * from auth.ts, matching runtime-store.ts / pty-host/socket.ts /
+ * codexGateAnswers.ts — tests redirect it with THREADBASE_CONFIG_DIR.
+ */
+export declare function serverIdentityKeyPath(): string;
+/**
+ * The server identity, generated on first call and stable forever after —
+ * across restarts and across API-key rotation.
+ *
+ * Stability is the whole point. The public half goes into a pair QR, so minting
+ * a second key would silently invalidate every device that scanned the first.
+ * A file that exists but cannot be read therefore **throws** rather than
+ * regenerating: losing this key must be a deliberate act (delete the file), not
+ * the recovery path for a bad read.
+ */
+export declare function loadOrCreateServerIdentity(): ServerIdentity;
+/** The public half alone, for callers that must never hold the private key. */
+export declare function serverIdentityPublicKey(): string;
+/**
+ * The fingerprint a user compares out of band (design.md §2.2): SHA-256 over
+ * the raw 32 public-key bytes, truncated to the first 16, printed as 8
+ * space-separated groups of 4 lowercase hex characters.
+ *
+ * Pure function of the base64url string `serverIdentityPublicKey()` returns —
+ * decode that, not the JWK or any other encoding, or this hashes different
+ * bytes than the phone does and the two fingerprints never match.
+ */
+export declare function serverIdentityFingerprint(publicKeyBase64url: string): string;
+/** Convenience over the real, on-disk identity key. */
+export declare function currentServerIdentityFingerprint(): string;
+//# sourceMappingURL=server-identity.d.ts.map

package/dist/server-identity.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"server-identity.d.ts","sourceRoot":"","sources":["../src/server-identity.ts"],"names":[],"mappings":"AAcA,OAAO,EAKL,KAAK,SAAS,EACf,MAAM,QAAQ,CAAC;AAqBhB,MAAM,WAAW,cAAc;IAC7B,mFAAmF;IACnF,SAAS,EAAE,MAAM,CAAC;IAClB,uFAAuF;IACvF,UAAU,EAAE,SAAS,CAAC;CACvB;AAED;;;;;;;;GAQG;AACH,wBAAgB,qBAAqB,IAAI,MAAM,CAG9C;AAED;;;;;;;;;GASG;AACH,wBAAgB,0BAA0B,IAAI,cAAc,CAuB3D;AAED,+EAA+E;AAC/E,wBAAgB,uBAAuB,IAAI,MAAM,CAEhD;AAED;;;;;;;;GAQG;AACH,wBAAgB,yBAAyB,CAAC,kBAAkB,EAAE,MAAM,GAAG,MAAM,CAI5E;AAED,uDAAuD;AACvD,wBAAgB,gCAAgC,IAAI,MAAM,CAEzD"}