parasor 0.1.0

package/server/pty/host.js

@@ -0,0 +1,184 @@
+/**
+ * Read the runtime mode from env. Daemon mode is the default so that a
+ * foreground `parasor` invocation gets the same session-survival
+ * properties as the canonical service install -- npm-style updates and
+ * server-process restarts can preserve PTY children when they live in a
+ * detached daemon. Set `PARASOR_PTY_DAEMON=0` to opt back into
+ * in-process mode (used by the dev script to keep PTYs scoped to the
+ * tsx-watch process and the legacy single-process layout).
+ */
+export function resolvePtyHostMode(env = process.env) {
+    return env.PARASOR_PTY_DAEMON === "0" ? "in-process" : "remote";
+}
+export async function createPtyHost(deps) {
+    const mode = deps.mode ?? resolvePtyHostMode();
+    if (mode === "remote") {
+        const [{ RemotePtyHost }, { resolveDaemonPaths }, { spawnDaemon }, { terminateDaemon }, { PROTOCOL_VERSION, parseVersionMismatch }, { isServiceManagedDaemonInstalled }, { connectToDaemonSocket, decideAutoSpawn, formatNoDaemonError }, { recoverFromVersionMismatch },] = await Promise.all([
+            import("./remote-host.js"),
+            import("./host-daemon/paths.js"),
+            import("./host-daemon/spawn-daemon.js"),
+            import("./host-daemon/terminate-daemon.js"),
+            import("./host-protocol/messages.js"),
+            import("./host-daemon/service-detection.js"),
+            import("./daemon-connect.js"),
+            import("./version-mismatch-recovery.js"),
+        ]);
+        /*
+         * `net.Socket` references below resolve through the top-level
+         * `import type * as net from "node:net"` -- runtime `net.connect` is
+         * now owned by `daemon-connect.ts` so no runtime `node:net` import
+         * is needed here.
+         */
+        const paths = resolveDaemonPaths();
+        /*
+         * -- first connect attempt; if it fails with
+         * a "no daemon" error and auto-spawn is enabled (default), fork
+         * the daemon and retry once. Auto-spawn opt-out lets ops who run
+         * launchd/systemd avoid double-supervision.
+         */
+        let socket;
+        try {
+            socket = await connectToDaemonSocket(paths.socketPath);
+        }
+        catch (err) {
+            const serviceInstalled = isServiceManagedDaemonInstalled();
+            const { noDaemon, autoStart } = decideAutoSpawn({
+                code: err.code,
+                explicit: process.env.PARASOR_PTY_AUTOSTART,
+                serviceInstalled,
+            });
+            if (noDaemon && autoStart) {
+                try {
+                    await spawnDaemon({ paths });
+                }
+                catch (spawnErr) {
+                    throw new Error(`parasor-pty-host: cannot connect to ${paths.socketPath}: ${err.message}. ` +
+                        `Auto-spawn also failed: ${spawnErr.message}`);
+                }
+                // review: the post-spawn retry can also fail (rare:
+                // daemon crashed between probe-ready and our reconnect). Wrap
+                // it in a try/catch so the caller sees the original "could not
+                // connect" context instead of a bare ECONNREFUSED.
+                try {
+                    socket = await connectToDaemonSocket(paths.socketPath);
+                }
+                catch (retryErr) {
+                    throw new Error(`parasor-pty-host: spawn succeeded but reconnect to ${paths.socketPath} failed: ` +
+                        `${retryErr.message}. Check ${paths.logFile} for daemon-side errors.`);
+                }
+            }
+            else {
+                throw new Error(formatNoDaemonError({
+                    err: err,
+                    socketPath: paths.socketPath,
+                    noDaemon,
+                    serviceInstalled,
+                }));
+            }
+        }
+        /*
+         * (narrowed by daemon state ownership) -- remote mode pivots
+         * the *session domain* (`sessions`, `sessionRecords`) into read-only
+         * mirror. Server-side `mutateSessions()` calls after this point
+         * throw; legitimate session updates flow through the daemon-IPC
+         * reconciler via `store.internalMutate()`. Project / projectStates
+         * / serviceConfig stay writable in both modes (the daemon never
+         * touches them). Set this BEFORE we construct RemotePtyHost so any
+         * reconcile call inside `connect()` uses the correct write path.
+         */
+        deps.store.setSessionsReadOnly(true);
+        /*
+         * state persistence delegate -- install the IPC persistence delegate. Server-owned
+         * mutations (mutateProjects / mutateProjectStates / mutateServiceConfig)
+         * route their debounced flush through the live wire instead of
+         * writeFileSync, so the daemon (sole writer of state.json under
+         * daemon state ownership ) ends up with an authoritative snapshot. Without this,
+         * server and daemon would race to overwrite each other's view of
+         * the file (daemon's stale projects clobber freshly added ones on
+         * the next session-update flush).
+         */
+        const wirePersistDelegate = (host) => {
+            deps.store.setPersistenceDelegate({
+                persist: (state) => host.persist(state),
+            });
+            return host;
+        };
+        // if RemotePtyHost.connect rejects (HELLO
+        // timeout, version mismatch, evicted), the connected socket would
+        // be leaked. Take ownership here and destroy() on rejection -- the
+        // happy path hands the socket to RemotePtyHost which manages it
+        // for the rest of its lifetime.
+        try {
+            return wirePersistDelegate(await RemotePtyHost.connect({
+                socket,
+                scrollbackLog: deps.scrollbackLog ?? null,
+            }));
+        }
+        catch (connectErr) {
+            try {
+                socket.destroy();
+            }
+            catch {
+                /* socket may already be in error state */
+            }
+            const code = connectErr?.code;
+            /*
+             * translate the typed handshake-timeout
+             * into actionable operator guidance. A daemon that bound the
+             * socket but never replies looks identical to a healthy connect
+             * from the kernel's perspective; the user needs to know to
+             * inspect the daemon log rather than retry blindly.
+             */
+            if (code === "handshake-timeout") {
+                throw new Error(`parasor-pty-host: ${connectErr.message}. ` +
+                    `The daemon accepted the connection but did not reply. ` +
+                    `Check ${paths.logFile} for daemon-side errors, ` +
+                    `or run \`parasor pty-host doctor\` for a full diagnostic dump.`);
+            }
+            /*
+             * daemon protocol mismatch recovery -- when the running daemon's PROTOCOL_VERSION is
+             * incompatible with the freshly-installed server binary, the
+             * daemon NACKs HELLO with code "version-mismatch" before any
+             * application traffic. The old daemon's PTY children are
+             * already orphaned from this server's perspective (the new
+             * server cannot speak the old protocol), so terminating it and
+             * spawning a fresh daemon is the only recovery path: surfacing
+             * a stack trace and exiting would loop forever under launchd
+             * or systemd-user supervision. Active PTY sessions die -- that
+             * cost is paid once per protocol upgrade; the web banner
+             * (recorded via onDaemonAutoRestarted -> ServerNoticesStore)
+             * tells the user why their list is empty after reconnect.
+             */
+            if (code === "version-mismatch") {
+                const host = await recoverFromVersionMismatch({
+                    originalError: connectErr,
+                    paths,
+                    protocolVersion: PROTOCOL_VERSION,
+                    scrollbackLog: deps.scrollbackLog ?? null,
+                    onDaemonAutoRestarted: deps.onDaemonAutoRestarted,
+                }, {
+                    terminateDaemon,
+                    spawnDaemon,
+                    connectSocket: connectToDaemonSocket,
+                    connectHost: (opts) => RemotePtyHost.connect(opts),
+                    parseVersionMismatch,
+                    logStderr: (line) => {
+                        process.stderr.write(line);
+                    },
+                });
+                return wirePersistDelegate(host);
+            }
+            throw connectErr;
+        }
+    }
+    /*
+     * In-process: the server itself owns the session domain. Idempotent
+     * setSessionsReadOnly(false) keeps factory recreation (e.g. test
+     * re-spinup) deterministic instead of inheriting whatever the
+     * previous host left.
+     */
+    deps.store.setSessionsReadOnly(false);
+    const { InProcessPtyHost } = await import("./in-process-host.js");
+    return new InProcessPtyHost(deps.store, deps.scrollbackLog ?? null, deps.daemonContext ?? null, deps.uploadsDir ?? null);
+}
+//# sourceMappingURL=host.js.map

package/server/pty/host.js.map

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

package/server/pty/in-process-host.d.ts

@@ -0,0 +1,224 @@
+import type { Session, SessionEndReason } from "@parasor/shared";
+import type { AppStateStore } from "../state/app-state.js";
+import type { AttachClientCapabilities, AttachClientResult, AttachClientSink, CreateSessionInput, PtyHost } from "./host.js";
+import type { ScrollbackLog } from "./scrollback-log.js";
+export type { CreateSessionInput };
+/**
+ * Identity of the process that owns AppState writes (
+ * ). Persisted into every `SessionRecord.daemonPid /
+ * daemonStartedAt`, then read back by `reconcileSessionRecords` on
+ * daemon startup to distinguish *this* generation's records from
+ * orphans inherited from a previous daemon process.
+ *
+ * Optional at construction: in-process tests that don't exercise
+ * orphan reconciliation can omit it, in which case `SessionRecord`
+ * persistence is skipped entirely (sessions are still tracked for the
+ * lifetime of the host, but `appState.sessionRecords` stays empty).
+ * Production callers -- both the daemon bootstrap and the in-process
+ * server entry -- always supply a context so the doctor CLI works in
+ * either mode.
+ */
+export interface InProcessPtyHostDaemonContext {
+    /** PID of the process owning AppStateStore writes. */
+    pid: number;
+    /** ISO8601 timestamp identifying the writer generation. */
+    startedAt: string;
+}
+export declare class InProcessPtyHost implements PtyHost {
+    private readonly store;
+    /**
+     * Disk-backed scrollback log. When null (daemon-side host, contract
+     * tests), this host records no scrollback and every replay path
+     * returns empty. That is intentional: the daemon forwards OUTPUT to
+     * the client over IPC and the client-side `RemotePtyHost` owns its
+     * own `ScrollbackLog` -- keeping a redundant copy on the daemon side
+     * would just double the disk footprint. `getScrollback()` and the
+     * `initClient` legacy replay degrade to "no replay" in that mode.
+     */
+    private readonly scrollbackLog;
+    private readonly daemonContext;
+    /**
+     * Canonical absolute path of `<rootDir>/uploads`. When supplied, every
+     * spawned PTY's env gets `PARASOR_UPLOAD_DIR=<uploadsDir>/<sessionId>`
+     * -- the per-session subdir, NOT the shared root -- so the Claude shim's
+     * `--add-dir` allowlists only that PTY's own drops (upload staging isolation codex
+     * Shared-root isolation review: the shared-root variant let session A read session
+     * B's uploads via `--add-dir`). Null in tests that don't exercise the
+     * upload pipeline.
+     */
+    private readonly uploadsDir;
+    private sessions;
+    private globalDataListeners;
+    private inputListeners;
+    private ptyEnv;
+    private readonly inProcessLegacyReplayMaxBytes;
+    private readonly headlessReplayEnabled;
+    private readonly headlessReplayScrollbackLines;
+    private readonly headlessReplayMaxBytes;
+    private readonly headlessStateCache;
+    /**
+     * Attach fencing monotonic counter -- incremented per attach (initClient or
+     * attachClient), stamped on the resulting `AttachedClient` entry, and
+     * compared on `detachClient(..., expectedToken)`. Plain integer is fine
+     * because tokens are scoped to this host instance and the comparison
+     * is identity, not magnitude.
+     */
+    private nextAttachToken;
+    private mintAttachToken;
+    onSessionExit: ((sessionId: string, generation: number, endReason: SessionEndReason) => void) | null;
+    constructor(store: AppStateStore, 
+    /**
+     * Disk-backed scrollback log. When null (daemon-side host, contract
+     * tests), this host records no scrollback and every replay path
+     * returns empty. That is intentional: the daemon forwards OUTPUT to
+     * the client over IPC and the client-side `RemotePtyHost` owns its
+     * own `ScrollbackLog` -- keeping a redundant copy on the daemon side
+     * would just double the disk footprint. `getScrollback()` and the
+     * `initClient` legacy replay degrade to "no replay" in that mode.
+     */
+    scrollbackLog?: ScrollbackLog | null, daemonContext?: InProcessPtyHostDaemonContext | null, 
+    /**
+     * Canonical absolute path of `<rootDir>/uploads`. When supplied, every
+     * spawned PTY's env gets `PARASOR_UPLOAD_DIR=<uploadsDir>/<sessionId>`
+     * -- the per-session subdir, NOT the shared root -- so the Claude shim's
+     * `--add-dir` allowlists only that PTY's own drops (upload staging isolation codex
+     * Shared-root isolation review: the shared-root variant let session A read session
+     * B's uploads via `--add-dir`). Null in tests that don't exercise the
+     * upload pipeline.
+     */
+    uploadsDir?: string | null);
+    /**
+     * Merge env vars into the per-PTY environment. Multiple calls accumulate
+     * (later calls override individual keys but preserve everything else),
+     * so the server can set the static shim PATH early during init and add
+     * the dynamic PARASOR_PORT later once probePort has resolved the actual
+     * listening port.
+     */
+    setPtyEnv(env: Record<string, string>): void;
+    private buildSessionEnv;
+    /**
+     * Create a session stub. The PTY is NOT spawned here -- it is deferred
+     * until the first WebSocket attach provides real viewport dimensions.
+     * This is the whole point of the deferred-spawn model: spawning at the
+     * exact client dims eliminates the SIGWINCH-driven prompt redraw that
+     * otherwise walks zsh's prompt down one row on every new-session open.
+     */
+    create(input: CreateSessionInput): Promise<Session>;
+    restart(id: string): Promise<Session>;
+    get(id: string): Session | undefined;
+    getScrollback(id: string): string | null;
+    list(): Session[];
+    getForegroundProcess(id: string): string | null;
+    setTitle(id: string, title: string, titleManual?: boolean): boolean;
+    setPinned(id: string, pinned: boolean): boolean;
+    listByProject(projectId: string): Session[];
+    onSessionInput(listener: (sessionId: string, data: string) => void): void;
+    write(id: string, data: string, generation?: number): void;
+    /**
+     * Resize the underlying PTY. The explicit resize caller is authoritative,
+     * but duplicate claims for the current PTY size must not issue another
+     * SIGWINCH.
+     */
+    resize(id: string, cols: number, rows: number): void;
+    /**
+     * Force a SIGWINCH without changing dims so a TUI repaints from scratch.
+     * Used when a client surface returns to the foreground (iOS background
+     * tab freeze, mobile visibilitychange). node-pty's resize() is a no-op
+     * when new dims equal current ones, so we briefly bump rows and snap
+     * back -- INK collapses the two calls into a single repaint.
+     */
+    refresh(id: string): void;
+    pauseOutput(id: string, clientId: string): void;
+    resumeOutput(id: string, clientId: string): void;
+    private shouldPauseOutput;
+    private applyOutputPauseState;
+    /**
+     * Attach a WebSocket client. Spawns the PTY on first call (using the
+     * client's viewport dims), replays scrollback to the fresh listener,
+     * and adds the listener to the broadcast set. A subsequent call with
+     * the same clientId replaces the existing listener in place (no
+     * duplicate broadcast).
+     */
+    initClient(id: string, clientId: string, cols: number, rows: number, listener: (data: string) => void, callerToken?: number): Promise<{
+        ok: true;
+        attachToken: number;
+    } | {
+        ok: false;
+    }>;
+    /**
+     * capable attach.
+     *
+     * Held under `managed.mutex` for the entire negotiation so that any
+     * concurrent PTY broadcast queues behind us -- the live chunk listener
+     * is registered last, after we have already decided the replay strategy
+     * and snapshotted the chunk ring. This prevents init-ack / replay /
+     * live OUTPUT from interleaving on the wire.
+     *
+     * Falls back to JSON-path semantics when `capabilities.binary === false`
+     * (the WS handler will not call us in that case, but the contract
+     * stays well-defined).
+     */
+    attachClient(id: string, clientId: string, cols: number, rows: number, capabilities: AttachClientCapabilities, sink: AttachClientSink): Promise<AttachClientResult>;
+    private buildFullReplay;
+    private updateHeadlessState;
+    detachClient(id: string, clientId: string, expectedToken?: number): void;
+    dispose(id: string): Promise<void>;
+    disposeAll(): Promise<void>;
+    /**
+     * Graceful-shutdown variant: kill every live PTY and mark each session
+     * as graceful, but keep the session in state so it can be restored
+     * (with scrollback) on the next server start. Unlike dispose, does not
+     * remove sessions from the store. The optional `reason` lets the
+     * daemon shutdown path distinguish itself from the server shutdown
+     * path so the UI can pick the correct error/recovery branch -- a
+     * "daemon-graceful" exit means the PTY children themselves are gone
+     * (the daemon owned them), while a "server-graceful" exit in daemon
+     * mode would be unusual (server unit shutdown but the daemon's PTYs
+     * survive).
+     */
+    shutdownAll(reason?: SessionEndReason): Promise<void>;
+    /**
+     * Restore a session from persisted AppState. Sessions that were running
+     * or spawning at server/daemon exit time carry no `endReason` yet --
+     * fill it in based on whether the previous shutdown was graceful
+     * (marker present) or a crash (marker absent). The host context picks
+     * the correct prefix: `daemon-*` when this is the host instance owned
+     * by the `parasor-pty-host` daemon (PTY children belonged to the
+     * daemon), `server-*` otherwise. Sessions that already have
+     * `endReason` (either from an earlier process exit or from
+     * `shutdownAll`) keep it.
+     */
+    loadPersistedSession(session: Session, wasGracefulShutdown: boolean): void;
+    onSessionData(callback: (sessionId: string, data: string, generation: number) => void): void;
+    /**
+     * Attempt a silent re-spawn, preserving the previous scrollback (so
+     * the user sees continuity) plus a visible separator line that says
+     * exactly when the restart happened. Caller must hold managed.mutex.
+     * Returns true if re-spawn was initiated; false if the session is not
+     * auto-resumable (caller should surface an error).
+     */
+    private autoResumeIfSafe;
+    /**
+     * Spawn the underlying PTY process and wire up its handlers. Called
+     * from `initClient` (deferred spawn) and from the test-only eager path.
+     * Caller must hold managed.mutex.
+     */
+    private spawnProcess;
+    private attachProcHandlers;
+    private persistSession;
+    /**
+     * Upsert a SessionRecord into AppState. Mirror of `persistSession` for
+     * the daemon-orphan-tracking side of the data model. Caller must hold
+     * managed.mutex (record updates are interleaved with session updates,
+     * single-record-per-session invariant guards against torn writes).
+     */
+    private persistRecord;
+    /**
+     * Test-only eager spawn. Production code path is always deferred via
+     * `initClient`. This helper exists so unit tests that need a live PTY
+     * without a WebSocket can still drive the manager.
+     */
+    testEagerSpawn(id: string, cols?: number, rows?: number): Promise<void>;
+    private resolveCommand;
+}
+//# sourceMappingURL=in-process-host.d.ts.map

package/server/pty/in-process-host.d.ts.map

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