parasor 0.1.0

package/server/bootstrap/shutdown-marker.js

@@ -0,0 +1,100 @@
+import { closeSync, existsSync, fsyncSync, mkdirSync, openSync, unlinkSync, writeSync, } from "node:fs";
+import { dirname, join } from "node:path";
+const SERVER_MARKER_FILENAME = "shutdown.marker";
+const DAEMON_MARKER_FILENAME = "daemon-shutdown.marker";
+/**
+ * Write a marker file at the end of a graceful shutdown. On next startup
+ * the absence of this file means the previous run crashed, which in turn
+ * means child PTY processes may be orphaned and unsafe to respawn with
+ * the same command (potential double-run).
+ *
+ * The default filename `shutdown.marker` belongs to the in-process
+ * server. Daemon-mode passes `daemon-shutdown.marker` so the two writers
+ * never collide on the same `state.json` directory -- a graceful
+ * server-side shutdown does not imply the daemon (which owns the PTY
+ * children in remote mode) also exited gracefully.
+ *
+ * The write is open->write->fsync(file)->close->fsync(dir) so a kernel
+ * panic between the graceful-exit code path and the next boot does not
+ * let the marker "exist" only in dirty page-cache while the post-panic
+ * boot reads its absence as graceful. The directory fsync is essential
+ * because the marker's *existence* (not its content) is what subsequent
+ * boots check -- without it, the directory entry created by `openSync`
+ * may live in dirty inode cache only (). Both fsyncs
+ * are best-effort: if either fails we still close the fd; worst case the
+ * marker is read as absent on the next boot, which is the conservative
+ * "treat as crash" side.
+ */
+export function writeShutdownMarker(configDir, filename = SERVER_MARKER_FILENAME) {
+    const path = join(configDir, filename);
+    const dir = dirname(path);
+    try {
+        mkdirSync(dir, { recursive: true });
+        const fd = openSync(path, "w");
+        try {
+            writeSync(fd, String(Date.now()));
+            try {
+                fsyncSync(fd);
+            }
+            catch {
+                // fsync may fail on filesystems that do not support it (tmpfs on
+                // some Linux configurations). The data is still committed to the
+                // page cache; on a clean shutdown that is sufficient. Falling
+                // through to close keeps the marker in the conservative state.
+            }
+        }
+        finally {
+            closeSync(fd);
+        }
+        // fsync the parent directory so the new directory entry survives a
+        // kernel panic. On Linux this guarantees the marker file is visible
+        // post-reboot; on macOS HFS+/APFS it is also durable. F_FULLFSYNC
+        // would be stronger but is not exposed by node's stdlib.
+        try {
+            const dirFd = openSync(dir, "r");
+            try {
+                fsyncSync(dirFd);
+            }
+            finally {
+                closeSync(dirFd);
+            }
+        }
+        catch {
+            // Some platforms (notably Windows) reject fsync on a directory
+            // handle. Skip silently -- the file fsync above is the best we can
+            // do, and the conservative "treat absent as crash" rule still
+            // catches a missing marker on the next boot.
+        }
+    }
+    catch {
+        // best-effort: failing to write the marker degrades to "treat as crash"
+        // which is the conservative side and not catastrophic.
+    }
+}
+/**
+ * Read the marker on startup. Returns true if the previous shutdown was
+ * graceful. The marker is always cleared so that a subsequent crash is
+ * correctly detected.
+ */
+export function readAndClearShutdownMarker(configDir, filename = SERVER_MARKER_FILENAME) {
+    const path = join(configDir, filename);
+    const present = existsSync(path);
+    if (present) {
+        try {
+            unlinkSync(path);
+        }
+        catch {
+            // ignore -- stale marker is harmless; it will be overwritten next shutdown
+        }
+    }
+    return present;
+}
+/** Convenience wrappers -- daemon-side callers should prefer these to keep
+ *  the marker filename centralised here. */
+export function writeDaemonShutdownMarker(stateDir) {
+    writeShutdownMarker(stateDir, DAEMON_MARKER_FILENAME);
+}
+export function readAndClearDaemonShutdownMarker(stateDir) {
+    return readAndClearShutdownMarker(stateDir, DAEMON_MARKER_FILENAME);
+}
+//# sourceMappingURL=shutdown-marker.js.map

package/server/bootstrap/shutdown-marker.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"shutdown-marker.js","sourceRoot":"","sources":["../../src/bootstrap/shutdown-marker.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,SAAS,EACT,UAAU,EACV,SAAS,EACT,SAAS,EACT,QAAQ,EACR,UAAU,EACV,SAAS,GACV,MAAM,SAAS,CAAC;AACjB,OAAO,EAAE,OAAO,EAAE,IAAI,EAAE,MAAM,WAAW,CAAC;AAE1C,MAAM,sBAAsB,GAAG,iBAAiB,CAAC;AACjD,MAAM,sBAAsB,GAAG,wBAAwB,CAAC;AAExD;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,MAAM,UAAU,mBAAmB,CACjC,SAAiB,EACjB,WAAmB,sBAAsB;IAEzC,MAAM,IAAI,GAAG,IAAI,CAAC,SAAS,EAAE,QAAQ,CAAC,CAAC;IACvC,MAAM,GAAG,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IAC1B,IAAI,CAAC;QACH,SAAS,CAAC,GAAG,EAAE,EAAE,SAAS,EAAE,IAAI,EAAE,CAAC,CAAC;QACpC,MAAM,EAAE,GAAG,QAAQ,CAAC,IAAI,EAAE,GAAG,CAAC,CAAC;QAC/B,IAAI,CAAC;YACH,SAAS,CAAC,EAAE,EAAE,MAAM,CAAC,IAAI,CAAC,GAAG,EAAE,CAAC,CAAC,CAAC;YAClC,IAAI,CAAC;gBACH,SAAS,CAAC,EAAE,CAAC,CAAC;YAChB,CAAC;YAAC,MAAM,CAAC;gBACP,iEAAiE;gBACjE,iEAAiE;gBACjE,8DAA8D;gBAC9D,+DAA+D;YACjE,CAAC;QACH,CAAC;gBAAS,CAAC;YACT,SAAS,CAAC,EAAE,CAAC,CAAC;QAChB,CAAC;QACD,mEAAmE;QACnE,oEAAoE;QACpE,kEAAkE;QAClE,yDAAyD;QACzD,IAAI,CAAC;YACH,MAAM,KAAK,GAAG,QAAQ,CAAC,GAAG,EAAE,GAAG,CAAC,CAAC;YACjC,IAAI,CAAC;gBACH,SAAS,CAAC,KAAK,CAAC,CAAC;YACnB,CAAC;oBAAS,CAAC;gBACT,SAAS,CAAC,KAAK,CAAC,CAAC;YACnB,CAAC;QACH,CAAC;QAAC,MAAM,CAAC;YACP,+DAA+D;YAC/D,mEAAmE;YACnE,8DAA8D;YAC9D,6CAA6C;QAC/C,CAAC;IACH,CAAC;IAAC,MAAM,CAAC;QACP,wEAAwE;QACxE,uDAAuD;IACzD,CAAC;AACH,CAAC;AAED;;;;GAIG;AACH,MAAM,UAAU,0BAA0B,CACxC,SAAiB,EACjB,WAAmB,sBAAsB;IAEzC,MAAM,IAAI,GAAG,IAAI,CAAC,SAAS,EAAE,QAAQ,CAAC,CAAC;IACvC,MAAM,OAAO,GAAG,UAAU,CAAC,IAAI,CAAC,CAAC;IACjC,IAAI,OAAO,EAAE,CAAC;QACZ,IAAI,CAAC;YACH,UAAU,CAAC,IAAI,CAAC,CAAC;QACnB,CAAC;QAAC,MAAM,CAAC;YACP,2EAA2E;QAC7E,CAAC;IACH,CAAC;IACD,OAAO,OAAO,CAAC;AACjB,CAAC;AAED;4CAC4C;AAC5C,MAAM,UAAU,yBAAyB,CAAC,QAAgB;IACxD,mBAAmB,CAAC,QAAQ,EAAE,sBAAsB,CAAC,CAAC;AACxD,CAAC;AAED,MAAM,UAAU,gCAAgC,CAAC,QAAgB;IAC/D,OAAO,0BAA0B,CAAC,QAAQ,EAAE,sBAAsB,CAAC,CAAC;AACtE,CAAC"}

package/server/bootstrap/shutdown-runtime.d.ts

@@ -0,0 +1,62 @@
+interface RuntimeLoops {
+    stop(): void;
+}
+interface FlushableStateStore {
+    flush(): Promise<void>;
+    /**
+     * daemon state ownership -- true ⇒ remote daemon mode (daemon owns session-domain
+     * writes; server is a mirror). Used by the shutdown handler to
+     * decide whether the post-shutdownAll flush is needed: remote =
+     * skip (delegate dead post-detach + nothing to flush, daemon owns
+     * sessions), in-process = required (must persist server-graceful
+     * endReasons; failures must propagate so a stale state.json never
+     * pairs with a graceful marker).
+     */
+    isSessionsReadOnly(): boolean;
+}
+interface DisposableProjectRuntime {
+    dispose(): Promise<void>;
+}
+/**
+ * Server SIGTERM handler dependency. Today the in-process PtyHost's
+ * `shutdownAll()` kills every PTY and persists `server-graceful` end
+ * reasons (see comment at the call site below).
+ *
+ * In daemon mode, `RemotePtyHost.shutdownAll()` MUST detach from the daemon
+ * socket only -- not kill daemon-side PTYs. The intent is server graceful
+ * shutdown WITHOUT taking the agent processes down. The dedicated
+ * `parasor pty-host terminate-all` CLI does the destructive operation.
+ */
+interface DisposablePtyHost {
+    shutdownAll(): Promise<void>;
+}
+interface StoppableIpcServer {
+    stop(): Promise<void>;
+}
+interface ShutdownableService {
+    shutdown(): void;
+}
+interface CreateShutdownHandlerDeps {
+    appStateStore: FlushableStateStore;
+    caffeinate?: ShutdownableService;
+    configDir: string;
+    ipcServer: StoppableIpcServer;
+    processExit?: (code: number) => void;
+    projectRuntime: DisposableProjectRuntime;
+    ptyManager: DisposablePtyHost;
+    removeRuntime?: (runtimeFile: string) => void;
+    runtimeFile: string;
+    runtimeLoops: RuntimeLoops;
+    writeMarker?: (configDir: string) => void;
+    /**
+     * -- release the in-process AppState owner
+     * (proper-lockfile + marker body) on graceful shutdown. Optional
+     * because daemon mode (where the daemon owns the marker) and tests
+     * pass `undefined`. Best-effort -- failures are swallowed.
+     */
+    releaseModeMarker?: () => Promise<void> | void;
+}
+export declare function createShutdownHandler({ appStateStore, caffeinate, configDir, ipcServer, processExit, projectRuntime, ptyManager, removeRuntime, runtimeFile, runtimeLoops, writeMarker, releaseModeMarker, }: CreateShutdownHandlerDeps): () => Promise<void>;
+export declare function registerShutdownSignals(shutdown: () => Promise<void>, register?: typeof process.on): void;
+export {};
+//# sourceMappingURL=shutdown-runtime.d.ts.map

package/server/bootstrap/shutdown-runtime.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"shutdown-runtime.d.ts","sourceRoot":"","sources":["../../src/bootstrap/shutdown-runtime.ts"],"names":[],"mappings":"AAGA,UAAU,YAAY;IACpB,IAAI,IAAI,IAAI,CAAC;CACd;AAED,UAAU,mBAAmB;IAC3B,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;IACvB;;;;;;;;OAQG;IACH,kBAAkB,IAAI,OAAO,CAAC;CAC/B;AAED,UAAU,wBAAwB;IAChC,OAAO,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;CAC1B;AAED;;;;;;;;;GASG;AACH,UAAU,iBAAiB;IACzB,WAAW,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;CAC9B;AAED,UAAU,kBAAkB;IAC1B,IAAI,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;CACvB;AAED,UAAU,mBAAmB;IAC3B,QAAQ,IAAI,IAAI,CAAC;CAClB;AAED,UAAU,yBAAyB;IACjC,aAAa,EAAE,mBAAmB,CAAC;IACnC,UAAU,CAAC,EAAE,mBAAmB,CAAC;IACjC,SAAS,EAAE,MAAM,CAAC;IAClB,SAAS,EAAE,kBAAkB,CAAC;IAC9B,WAAW,CAAC,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,IAAI,CAAC;IACrC,cAAc,EAAE,wBAAwB,CAAC;IACzC,UAAU,EAAE,iBAAiB,CAAC;IAC9B,aAAa,CAAC,EAAE,CAAC,WAAW,EAAE,MAAM,KAAK,IAAI,CAAC;IAC9C,WAAW,EAAE,MAAM,CAAC;IACpB,YAAY,EAAE,YAAY,CAAC;IAC3B,WAAW,CAAC,EAAE,CAAC,SAAS,EAAE,MAAM,KAAK,IAAI,CAAC;IAC1C;;;;;OAKG;IACH,iBAAiB,CAAC,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,GAAG,IAAI,CAAC;CAChD;AAED,wBAAgB,qBAAqB,CAAC,EACpC,aAAa,EACb,UAAU,EACV,SAAS,EACT,SAAS,EACT,WAA0B,EAC1B,cAAc,EACd,UAAU,EACV,aAAiC,EACjC,WAAW,EACX,YAAY,EACZ,WAAiC,EACjC,iBAAiB,GAClB,EAAE,yBAAyB,GAAG,MAAM,OAAO,CAAC,IAAI,CAAC,CAuDjD;AAED,wBAAgB,uBAAuB,CACrC,QAAQ,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,EAC7B,QAAQ,GAAE,OAAO,OAAO,CAAC,EAA6B,GACrD,IAAI,CAON"}

package/server/bootstrap/shutdown-runtime.js

@@ -0,0 +1,66 @@
+import { removeRuntimeFile } from "./runtime-port.js";
+import { writeShutdownMarker } from "./shutdown-marker.js";
+export function createShutdownHandler({ appStateStore, caffeinate, configDir, ipcServer, processExit = process.exit, projectRuntime, ptyManager, removeRuntime = removeRuntimeFile, runtimeFile, runtimeLoops, writeMarker = writeShutdownMarker, releaseModeMarker, }) {
+    let inFlight = null;
+    return () => {
+        if (inFlight)
+            return inFlight;
+        inFlight = (async () => {
+            runtimeLoops.stop();
+            caffeinate?.shutdown();
+            await projectRuntime.dispose();
+            /*
+             * -- flush server-owned domains (projects /
+             * projectStates / serviceConfig) BEFORE shutdownAll detaches the
+             * IPC delegate. In remote mode `appStateStore.flush()` ships the
+             * latest snapshot through the live RemotePtyHost connection so
+             * the daemon persists it before the socket goes away. Skipping
+             * this step lets in-flight project / config writes evaporate on
+             * SIGTERM. In in-process mode this is a no-op aside from draining
+             * the debounce timer, harmless.
+             */
+            await appStateStore.flush();
+            // Kill PTYs and mark each session as server-graceful (in-process
+            // only -- RemotePtyHost.shutdownAll is detach-only because the
+            // daemon owns session state). disposeAll() (which deletes
+            // sessions outright) is NOT used here -- we want the sessions to
+            // come back with scrollback on next start.
+            await ptyManager.shutdownAll();
+            /*
+             * -- the post-shutdownAll flush is
+             * REQUIRED in in-process mode (must persist server-graceful
+             * endReasons before the marker; a swallowed failure pairs a
+             * stale state.json with a graceful marker, mis-classifying
+             * sessions as cleanly-ended on next boot). In remote mode the
+             * IPC delegate is dead post-detach AND the daemon already owns
+             * session-domain persistence -- so we skip the flush entirely
+             * rather than catching a guaranteed-fail call.
+             */
+            if (!appStateStore.isSessionsReadOnly()) {
+                await appStateStore.flush();
+            }
+            writeMarker(configDir);
+            await ipcServer.stop();
+            removeRuntime(runtimeFile);
+            if (releaseModeMarker) {
+                try {
+                    await releaseModeMarker();
+                }
+                catch {
+                    /* best-effort */
+                }
+            }
+            processExit(0);
+        })();
+        return inFlight;
+    };
+}
+export function registerShutdownSignals(shutdown, register = process.on.bind(process)) {
+    register("SIGTERM", shutdown);
+    register("SIGINT", shutdown);
+    // Terminal close / parent shell exit. Without this, SIGHUP terminates
+    // node before `releaseModeMarker()` runs and leaks
+    // `appstate.mode.lock/` for up to the proper-lockfile stale window.
+    register("SIGHUP", shutdown);
+}
+//# sourceMappingURL=shutdown-runtime.js.map

package/server/bootstrap/shutdown-runtime.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"shutdown-runtime.js","sourceRoot":"","sources":["../../src/bootstrap/shutdown-runtime.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,iBAAiB,EAAE,MAAM,mBAAmB,CAAC;AACtD,OAAO,EAAE,mBAAmB,EAAE,MAAM,sBAAsB,CAAC;AAmE3D,MAAM,UAAU,qBAAqB,CAAC,EACpC,aAAa,EACb,UAAU,EACV,SAAS,EACT,SAAS,EACT,WAAW,GAAG,OAAO,CAAC,IAAI,EAC1B,cAAc,EACd,UAAU,EACV,aAAa,GAAG,iBAAiB,EACjC,WAAW,EACX,YAAY,EACZ,WAAW,GAAG,mBAAmB,EACjC,iBAAiB,GACS;IAC1B,IAAI,QAAQ,GAAyB,IAAI,CAAC;IAE1C,OAAO,GAAG,EAAE;QACV,IAAI,QAAQ;YAAE,OAAO,QAAQ,CAAC;QAE9B,QAAQ,GAAG,CAAC,KAAK,IAAI,EAAE;YACrB,YAAY,CAAC,IAAI,EAAE,CAAC;YACpB,UAAU,EAAE,QAAQ,EAAE,CAAC;YACvB,MAAM,cAAc,CAAC,OAAO,EAAE,CAAC;YAC/B;;;;;;;;;eASG;YACH,MAAM,aAAa,CAAC,KAAK,EAAE,CAAC;YAC5B,iEAAiE;YACjE,+DAA+D;YAC/D,0DAA0D;YAC1D,iEAAiE;YACjE,2CAA2C;YAC3C,MAAM,UAAU,CAAC,WAAW,EAAE,CAAC;YAC/B;;;;;;;;;eASG;YACH,IAAI,CAAC,aAAa,CAAC,kBAAkB,EAAE,EAAE,CAAC;gBACxC,MAAM,aAAa,CAAC,KAAK,EAAE,CAAC;YAC9B,CAAC;YACD,WAAW,CAAC,SAAS,CAAC,CAAC;YACvB,MAAM,SAAS,CAAC,IAAI,EAAE,CAAC;YACvB,aAAa,CAAC,WAAW,CAAC,CAAC;YAC3B,IAAI,iBAAiB,EAAE,CAAC;gBACtB,IAAI,CAAC;oBACH,MAAM,iBAAiB,EAAE,CAAC;gBAC5B,CAAC;gBAAC,MAAM,CAAC;oBACP,iBAAiB;gBACnB,CAAC;YACH,CAAC;YACD,WAAW,CAAC,CAAC,CAAC,CAAC;QACjB,CAAC,CAAC,EAAE,CAAC;QAEL,OAAO,QAAQ,CAAC;IAClB,CAAC,CAAC;AACJ,CAAC;AAED,MAAM,UAAU,uBAAuB,CACrC,QAA6B,EAC7B,WAA8B,OAAO,CAAC,EAAE,CAAC,IAAI,CAAC,OAAO,CAAC;IAEtD,QAAQ,CAAC,SAAS,EAAE,QAAQ,CAAC,CAAC;IAC9B,QAAQ,CAAC,QAAQ,EAAE,QAAQ,CAAC,CAAC;IAC7B,sEAAsE;IACtE,mDAAmD;IACnD,oEAAoE;IACpE,QAAQ,CAAC,QAAQ,EAAE,QAAQ,CAAC,CAAC;AAC/B,CAAC"}

package/server/bootstrap/startup-banner.d.ts

@@ -0,0 +1,34 @@
+import type { NetworkEndpoint, TailscaleStatus } from "../network/endpoints.js";
+import type { AuthMode } from "./create-app-server.js";
+export interface QrOptions {
+    enabled: boolean;
+    iface?: string;
+}
+export interface BindInfo {
+    /** True when the user passed `--host` (or `HOST=`); false on the default. */
+    explicit: boolean;
+    host: string;
+}
+interface BuildStartupBannerOptions {
+    authMode: AuthMode;
+    configDir: string;
+    endpoints: NetworkEndpoint[];
+    port: number;
+    tailscaleStatus: TailscaleStatus;
+    token?: string;
+    makeAccessUrl?: (endpoint: NetworkEndpoint) => string;
+    qr?: QrOptions;
+    bind?: BindInfo;
+    /**
+     * When true, wrap URLs in OSC 8 hyperlinks so terminals that support it
+     * render them as a single clickable region -- even after the line wraps.
+     * `right click -> Copy link` then yields the full URL without injected
+     * newlines, which is the failure mode that makes a wrapped `?t=<token>`
+     * URL useless to copy/paste.
+     */
+    clickable?: boolean;
+}
+export declare function buildStartupBanner({ authMode, configDir, endpoints, port, tailscaleStatus, token, makeAccessUrl, qr, bind, clickable, }: BuildStartupBannerOptions): string[];
+export declare function printStartupBanner(options: BuildStartupBannerOptions, log?: (line: string) => void): void;
+export {};
+//# sourceMappingURL=startup-banner.d.ts.map

package/server/bootstrap/startup-banner.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"startup-banner.d.ts","sourceRoot":"","sources":["../../src/bootstrap/startup-banner.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,eAAe,EAAE,eAAe,EAAE,MAAM,yBAAyB,CAAC;AAEhF,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,wBAAwB,CAAC;AAEvD,MAAM,WAAW,SAAS;IACxB,OAAO,EAAE,OAAO,CAAC;IACjB,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB;AAED,MAAM,WAAW,QAAQ;IACvB,6EAA6E;IAC7E,QAAQ,EAAE,OAAO,CAAC;IAClB,IAAI,EAAE,MAAM,CAAC;CACd;AAED,UAAU,yBAAyB;IACjC,QAAQ,EAAE,QAAQ,CAAC;IACnB,SAAS,EAAE,MAAM,CAAC;IAClB,SAAS,EAAE,eAAe,EAAE,CAAC;IAC7B,IAAI,EAAE,MAAM,CAAC;IACb,eAAe,EAAE,eAAe,CAAC;IACjC,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,aAAa,CAAC,EAAE,CAAC,QAAQ,EAAE,eAAe,KAAK,MAAM,CAAC;IACtD,EAAE,CAAC,EAAE,SAAS,CAAC;IACf,IAAI,CAAC,EAAE,QAAQ,CAAC;IAChB;;;;;;OAMG;IACH,SAAS,CAAC,EAAE,OAAO,CAAC;CACrB;AA8DD,wBAAgB,kBAAkB,CAAC,EACjC,QAAQ,EACR,SAAS,EACT,SAAS,EACT,IAAI,EACJ,eAAe,EACf,KAAK,EACL,aAAa,EACb,EAAE,EACF,IAAI,EACJ,SAAiB,GAClB,EAAE,yBAAyB,GAAG,MAAM,EAAE,CA6DtC;AAED,wBAAgB,kBAAkB,CAChC,OAAO,EAAE,yBAAyB,EAClC,GAAG,GAAE,CAAC,IAAI,EAAE,MAAM,KAAK,IAAkB,GACxC,IAAI,CAYN"}

package/server/bootstrap/startup-banner.js

@@ -0,0 +1,114 @@
+import { join } from "node:path";
+import { buildAuthUrl, buildQrSection } from "../network/qr.js";
+const OSC8_START = "\x1b]8;;";
+const OSC8_DELIM = "\x1b\\";
+const OSC8_END = "\x1b]8;;\x1b\\";
+/*
+ * OSC 8 hyperlinks delimit the URL with `ESC \` (ST) and start with `ESC ]
+ * 8 ;;`. Any control character in the URL or label can break or hijack the
+ * sequence, so refuse to wrap when one is present and emit the plain text
+ * instead. `NetworkEndpoint.address` is OS-sourced today and unlikely to
+ * carry such bytes, but the function is exported and re-used for QR
+ * fallback paths, so the check stays defensive.
+ */
+// biome-ignore lint/suspicious/noControlCharactersInRegex: OSC8 labels/URLs must reject terminal control bytes.
+const TERMINAL_CONTROL_RE = /[\x00-\x1f\x7f]/;
+function hyperlink(url, label, clickable) {
+    if (!clickable)
+        return label;
+    if (TERMINAL_CONTROL_RE.test(url) || TERMINAL_CONTROL_RE.test(label)) {
+        return label;
+    }
+    return `${OSC8_START}${url}${OSC8_DELIM}${label}${OSC8_END}`;
+}
+/**
+ * Filter endpoints to those actually reachable given the bind host.
+ *
+ * `0.0.0.0` / `::` (the default) listens on every interface, so all endpoints
+ * stay. A specific host (loopback, LAN IP, Tailscale CGNAT) is single-bind --
+ * only that address is reachable. MagicDNS rides along when the bind matches
+ * the Tailscale endpoint, since the friendly hostname resolves to it.
+ */
+function filterReachableEndpoints(endpoints, bind) {
+    if (!bind)
+        return endpoints;
+    const { host } = bind;
+    if (host === "0.0.0.0" || host === "::" || host === "::0")
+        return endpoints;
+    const tailscaleHostMatch = endpoints.some((e) => e.address === host && e.category === "Tailscale");
+    return endpoints.filter((e) => {
+        if (e.address === host)
+            return true;
+        if (e.iface === "MagicDNS" && tailscaleHostMatch)
+            return true;
+        return false;
+    });
+}
+function buildDefaultAccessUrl(endpoint, port, authMode, token) {
+    if (authMode === "token" && !token) {
+        throw new Error("token or makeAccessUrl is required for token auth URLs");
+    }
+    return buildAuthUrl(endpoint.address, port, authMode, token ?? "");
+}
+export function buildStartupBanner({ authMode, configDir, endpoints, port, tailscaleStatus, token, makeAccessUrl, qr, bind, clickable = false, }) {
+    const lines = [];
+    lines.push(``, `parasor running on port ${port}`, ``, "Access URLs:");
+    const visibleEndpoints = filterReachableEndpoints(endpoints, bind);
+    for (const endpoint of visibleEndpoints) {
+        const authUrl = makeAccessUrl?.(endpoint) ??
+            buildDefaultAccessUrl(endpoint, port, authMode, token);
+        const label = endpoint.iface
+            ? `${endpoint.category} (${endpoint.iface})`
+            : endpoint.category;
+        /*
+         * URL goes on its own line so a terminal that wraps a long
+         * `?t=<64-hex>` URL still puts the whole token on a single visual row
+         * (or at least a wrap that the OS clipboard can handle). Inline
+         * `label  url` was prone to copy-paste truncation when the URL wrapped
+         * across two terminal columns.
+         */
+        lines.push(`  ${label}`);
+        lines.push(`    ${hyperlink(authUrl, authUrl, clickable)}`);
+    }
+    if (tailscaleStatus.state === "stopped") {
+        lines.push("", "  Tailscale is installed but not running. Run `tailscale up` for remote access.");
+    }
+    if (authMode === "token") {
+        lines.push("", `Auth: token (saved to ${join(configDir, "token")})`);
+    }
+    else if (authMode === "none") {
+        lines.push("", "Auth: none (trusted network mode)");
+    }
+    if (bind && !bind.explicit && bind.host === "0.0.0.0") {
+        lines.push("", "Tip: bind to loopback only with `parasor --host 127.0.0.1`");
+    }
+    if (qr?.enabled) {
+        lines.push("");
+        for (const row of buildQrSection({
+            endpoints: visibleEndpoints,
+            port,
+            authMode,
+            token,
+            makeAccessUrl,
+            iface: qr.iface,
+            clickable,
+        })) {
+            lines.push(row);
+        }
+    }
+    lines.push("");
+    return lines;
+}
+export function printStartupBanner(options, log = console.log) {
+    /*
+     * Default `clickable` to TTY detection so OSC 8 escape sequences only go
+     * to interactive terminals -- log files / piped output stay plain text.
+     */
+    const resolved = options.clickable === undefined
+        ? { ...options, clickable: process.stdout.isTTY === true }
+        : options;
+    for (const line of buildStartupBanner(resolved)) {
+        log(line);
+    }
+}
+//# sourceMappingURL=startup-banner.js.map

package/server/bootstrap/startup-banner.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"startup-banner.js","sourceRoot":"","sources":["../../src/bootstrap/startup-banner.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,IAAI,EAAE,MAAM,WAAW,CAAC;AAEjC,OAAO,EAAE,YAAY,EAAE,cAAc,EAAE,MAAM,kBAAkB,CAAC;AAkChE,MAAM,UAAU,GAAG,UAAU,CAAC;AAC9B,MAAM,UAAU,GAAG,QAAQ,CAAC;AAC5B,MAAM,QAAQ,GAAG,gBAAgB,CAAC;AAElC;;;;;;;GAOG;AACH,gHAAgH;AAChH,MAAM,mBAAmB,GAAG,iBAAiB,CAAC;AAE9C,SAAS,SAAS,CAAC,GAAW,EAAE,KAAa,EAAE,SAAkB;IAC/D,IAAI,CAAC,SAAS;QAAE,OAAO,KAAK,CAAC;IAC7B,IAAI,mBAAmB,CAAC,IAAI,CAAC,GAAG,CAAC,IAAI,mBAAmB,CAAC,IAAI,CAAC,KAAK,CAAC,EAAE,CAAC;QACrE,OAAO,KAAK,CAAC;IACf,CAAC;IACD,OAAO,GAAG,UAAU,GAAG,GAAG,GAAG,UAAU,GAAG,KAAK,GAAG,QAAQ,EAAE,CAAC;AAC/D,CAAC;AAED;;;;;;;GAOG;AACH,SAAS,wBAAwB,CAC/B,SAA4B,EAC5B,IAA0B;IAE1B,IAAI,CAAC,IAAI;QAAE,OAAO,SAAS,CAAC;IAC5B,MAAM,EAAE,IAAI,EAAE,GAAG,IAAI,CAAC;IACtB,IAAI,IAAI,KAAK,SAAS,IAAI,IAAI,KAAK,IAAI,IAAI,IAAI,KAAK,KAAK;QAAE,OAAO,SAAS,CAAC;IAC5E,MAAM,kBAAkB,GAAG,SAAS,CAAC,IAAI,CACvC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,OAAO,KAAK,IAAI,IAAI,CAAC,CAAC,QAAQ,KAAK,WAAW,CACxD,CAAC;IACF,OAAO,SAAS,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,EAAE;QAC5B,IAAI,CAAC,CAAC,OAAO,KAAK,IAAI;YAAE,OAAO,IAAI,CAAC;QACpC,IAAI,CAAC,CAAC,KAAK,KAAK,UAAU,IAAI,kBAAkB;YAAE,OAAO,IAAI,CAAC;QAC9D,OAAO,KAAK,CAAC;IACf,CAAC,CAAC,CAAC;AACL,CAAC;AAED,SAAS,qBAAqB,CAC5B,QAAyB,EACzB,IAAY,EACZ,QAAkB,EAClB,KAAyB;IAEzB,IAAI,QAAQ,KAAK,OAAO,IAAI,CAAC,KAAK,EAAE,CAAC;QACnC,MAAM,IAAI,KAAK,CAAC,wDAAwD,CAAC,CAAC;IAC5E,CAAC;IACD,OAAO,YAAY,CAAC,QAAQ,CAAC,OAAO,EAAE,IAAI,EAAE,QAAQ,EAAE,KAAK,IAAI,EAAE,CAAC,CAAC;AACrE,CAAC;AAED,MAAM,UAAU,kBAAkB,CAAC,EACjC,QAAQ,EACR,SAAS,EACT,SAAS,EACT,IAAI,EACJ,eAAe,EACf,KAAK,EACL,aAAa,EACb,EAAE,EACF,IAAI,EACJ,SAAS,GAAG,KAAK,GACS;IAC1B,MAAM,KAAK,GAAa,EAAE,CAAC;IAE3B,KAAK,CAAC,IAAI,CAAC,EAAE,EAAE,2BAA2B,IAAI,EAAE,EAAE,EAAE,EAAE,cAAc,CAAC,CAAC;IAEtE,MAAM,gBAAgB,GAAG,wBAAwB,CAAC,SAAS,EAAE,IAAI,CAAC,CAAC;IACnE,KAAK,MAAM,QAAQ,IAAI,gBAAgB,EAAE,CAAC;QACxC,MAAM,OAAO,GACX,aAAa,EAAE,CAAC,QAAQ,CAAC;YACzB,qBAAqB,CAAC,QAAQ,EAAE,IAAI,EAAE,QAAQ,EAAE,KAAK,CAAC,CAAC;QACzD,MAAM,KAAK,GAAG,QAAQ,CAAC,KAAK;YAC1B,CAAC,CAAC,GAAG,QAAQ,CAAC,QAAQ,KAAK,QAAQ,CAAC,KAAK,GAAG;YAC5C,CAAC,CAAC,QAAQ,CAAC,QAAQ,CAAC;QACtB;;;;;;WAMG;QACH,KAAK,CAAC,IAAI,CAAC,KAAK,KAAK,EAAE,CAAC,CAAC;QACzB,KAAK,CAAC,IAAI,CAAC,OAAO,SAAS,CAAC,OAAO,EAAE,OAAO,EAAE,SAAS,CAAC,EAAE,CAAC,CAAC;IAC9D,CAAC;IAED,IAAI,eAAe,CAAC,KAAK,KAAK,SAAS,EAAE,CAAC;QACxC,KAAK,CAAC,IAAI,CACR,EAAE,EACF,iFAAiF,CAClF,CAAC;IACJ,CAAC;IAED,IAAI,QAAQ,KAAK,OAAO,EAAE,CAAC;QACzB,KAAK,CAAC,IAAI,CAAC,EAAE,EAAE,yBAAyB,IAAI,CAAC,SAAS,EAAE,OAAO,CAAC,GAAG,CAAC,CAAC;IACvE,CAAC;SAAM,IAAI,QAAQ,KAAK,MAAM,EAAE,CAAC;QAC/B,KAAK,CAAC,IAAI,CAAC,EAAE,EAAE,mCAAmC,CAAC,CAAC;IACtD,CAAC;IAED,IAAI,IAAI,IAAI,CAAC,IAAI,CAAC,QAAQ,IAAI,IAAI,CAAC,IAAI,KAAK,SAAS,EAAE,CAAC;QACtD,KAAK,CAAC,IAAI,CACR,EAAE,EACF,4DAA4D,CAC7D,CAAC;IACJ,CAAC;IAED,IAAI,EAAE,EAAE,OAAO,EAAE,CAAC;QAChB,KAAK,CAAC,IAAI,CAAC,EAAE,CAAC,CAAC;QACf,KAAK,MAAM,GAAG,IAAI,cAAc,CAAC;YAC/B,SAAS,EAAE,gBAAgB;YAC3B,IAAI;YACJ,QAAQ;YACR,KAAK;YACL,aAAa;YACb,KAAK,EAAE,EAAE,CAAC,KAAK;YACf,SAAS;SACV,CAAC,EAAE,CAAC;YACH,KAAK,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;QAClB,CAAC;IACH,CAAC;IAED,KAAK,CAAC,IAAI,CAAC,EAAE,CAAC,CAAC;IACf,OAAO,KAAK,CAAC;AACf,CAAC;AAED,MAAM,UAAU,kBAAkB,CAChC,OAAkC,EAClC,MAA8B,OAAO,CAAC,GAAG;IAEzC;;;OAGG;IACH,MAAM,QAAQ,GACZ,OAAO,CAAC,SAAS,KAAK,SAAS;QAC7B,CAAC,CAAC,EAAE,GAAG,OAAO,EAAE,SAAS,EAAE,OAAO,CAAC,MAAM,CAAC,KAAK,KAAK,IAAI,EAAE;QAC1D,CAAC,CAAC,OAAO,CAAC;IACd,KAAK,MAAM,IAAI,IAAI,kBAAkB,CAAC,QAAQ,CAAC,EAAE,CAAC;QAChD,GAAG,CAAC,IAAI,CAAC,CAAC;IACZ,CAAC;AACH,CAAC"}

package/server/bootstrap/wire-runtime.d.ts

@@ -0,0 +1,42 @@
+import type { AppState, Notification } from "@parasor/shared";
+import type { AgentStateStore } from "../agent-detector/agent-state-store.js";
+import type { AgentDetector } from "../agent-detector/detector.js";
+import type { AgentStatusRecorder } from "../debug/agent-status-recorder.js";
+import type { UploadStaging } from "../fs/upload-staging.js";
+import type { IpcServer } from "../ipc/socket-server.js";
+import type { PortForwarder } from "../port-forwarder/forwarder.js";
+import type { PortScanner } from "../port-scanner/scanner.js";
+import type { PtyHost } from "../pty/host.js";
+import type { AppStateStore } from "../state/app-state.js";
+import type { ProjectManager } from "../state/project-manager.js";
+import type { WorktreeCache } from "../state/worktree-cache.js";
+import type { EventBus } from "../ws/events.js";
+import type { ProjectRuntime } from "./project-runtime.js";
+export interface WireRuntimeDeps {
+    appStateStore: AppStateStore;
+    eventBus: EventBus;
+    portScanner: PortScanner;
+    /**
+     * The shared per-port TCP forwarder (same instance handed to
+     * `startRuntimeLoops`). Used to enrich the hydration snapshot's ports with
+     * `reachable`/`reachablePort` so a reloaded/reconnected client can resolve
+     * already-open browser panes without waiting for the next port-set change.
+     */
+    portForwarder: PortForwarder;
+    ptyManager: PtyHost;
+    agentDetector: AgentDetector;
+    agentStateStore: AgentStateStore;
+    debugRecorder?: AgentStatusRecorder;
+    ipcServer: IpcServer;
+    projectManager: ProjectManager;
+    projectRuntime: ProjectRuntime;
+    worktreeCache: WorktreeCache;
+    uploadStaging: UploadStaging;
+}
+export declare function createWaitingNotification(sessionId: string, projectId: string, now?: number): Notification;
+export declare function buildHydrationStateSnapshot({ appStateStore, ptyManager, }: {
+    appStateStore: AppStateStore;
+    ptyManager: PtyHost;
+}): AppState;
+export declare function wireRuntime({ appStateStore, eventBus, portScanner, portForwarder, ptyManager, agentDetector, agentStateStore, debugRecorder, ipcServer, projectManager, projectRuntime, worktreeCache, uploadStaging, }: WireRuntimeDeps): void;
+//# sourceMappingURL=wire-runtime.d.ts.map

package/server/bootstrap/wire-runtime.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"wire-runtime.d.ts","sourceRoot":"","sources":["../../src/bootstrap/wire-runtime.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,QAAQ,EAAE,YAAY,EAAY,MAAM,iBAAiB,CAAC;AACxE,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,wCAAwC,CAAC;AAC9E,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,+BAA+B,CAAC;AAInE,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,mCAAmC,CAAC;AAC7E,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,yBAAyB,CAAC;AAC7D,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,yBAAyB,CAAC;AACzD,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,gCAAgC,CAAC;AACpE,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,4BAA4B,CAAC;AAC9D,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,gBAAgB,CAAC;AAE9C,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,uBAAuB,CAAC;AAC3D,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,6BAA6B,CAAC;AAClE,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,4BAA4B,CAAC;AAChE,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,iBAAiB,CAAC;AAChD,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,sBAAsB,CAAC;AAG3D,MAAM,WAAW,eAAe;IAC9B,aAAa,EAAE,aAAa,CAAC;IAC7B,QAAQ,EAAE,QAAQ,CAAC;IACnB,WAAW,EAAE,WAAW,CAAC;IACzB;;;;;OAKG;IACH,aAAa,EAAE,aAAa,CAAC;IAC7B,UAAU,EAAE,OAAO,CAAC;IACpB,aAAa,EAAE,aAAa,CAAC;IAC7B,eAAe,EAAE,eAAe,CAAC;IACjC,aAAa,CAAC,EAAE,mBAAmB,CAAC;IACpC,SAAS,EAAE,SAAS,CAAC;IACrB,cAAc,EAAE,cAAc,CAAC;IAC/B,cAAc,EAAE,cAAc,CAAC;IAC/B,aAAa,EAAE,aAAa,CAAC;IAC7B,aAAa,EAAE,aAAa,CAAC;CAC9B;AAED,wBAAgB,yBAAyB,CACvC,SAAS,EAAE,MAAM,EACjB,SAAS,EAAE,MAAM,EACjB,GAAG,SAAa,GACf,YAAY,CAWd;AAED,wBAAgB,2BAA2B,CAAC,EAC1C,aAAa,EACb,UAAU,GACX,EAAE;IACD,aAAa,EAAE,aAAa,CAAC;IAC7B,UAAU,EAAE,OAAO,CAAC;CACrB,GAAG,QAAQ,CAMX;AAED,wBAAgB,WAAW,CAAC,EAC1B,aAAa,EACb,QAAQ,EACR,WAAW,EACX,aAAa,EACb,UAAU,EACV,aAAa,EACb,eAAe,EACf,aAAa,EACb,SAAS,EACT,cAAc,EACd,cAAc,EACd,aAAa,EACb,aAAa,GACd,EAAE,eAAe,GAAG,IAAI,CAiMxB"}

package/server/bootstrap/wire-runtime.js

@@ -0,0 +1,205 @@
+import { randomUUID } from "node:crypto";
+import { ManualAgentTracker } from "../agent-detector/manual-agent-tracker.js";
+import { shouldObserveAgentOutput } from "../agent-detector/output-eligibility.js";
+import { createProjectQueries } from "../application/workspace/project-queries.js";
+import { Osc7Lifecycle } from "../pty/osc7-lifecycle.js";
+import { enrichPorts } from "./runtime-loops.js";
+export function createWaitingNotification(sessionId, projectId, now = Date.now()) {
+    return {
+        id: randomUUID(),
+        projectId,
+        sessionId,
+        type: "agent-waiting",
+        title: "Agent waiting",
+        message: "Agent is waiting for input",
+        timestamp: now,
+        read: false,
+    };
+}
+export function buildHydrationStateSnapshot({ appStateStore, ptyManager, }) {
+    const state = appStateStore.get();
+    return {
+        ...state,
+        sessions: ptyManager.list(),
+    };
+}
+export function wireRuntime({ appStateStore, eventBus, portScanner, portForwarder, ptyManager, agentDetector, agentStateStore, debugRecorder, ipcServer, projectManager, projectRuntime, worktreeCache, uploadStaging, }) {
+    const projectQueries = createProjectQueries({ projectManager });
+    const getLiveSessionIds = () => ptyManager
+        .list()
+        .flatMap((session) => (session.state === "ended" ? [] : [session.id]));
+    eventBus.setHydrationSources({
+        getState: () => buildHydrationStateSnapshot({ appStateStore, ptyManager }),
+        getAgentStates: () => agentStateStore.getStates({ liveSessionIds: getLiveSessionIds() }),
+        getNotifications: () => eventBus.getNotifications(),
+        getPorts: () => {
+            const out = {};
+            for (const [projectId, ports] of Object.entries(portScanner.getAllPorts())) {
+                out[projectId] = enrichPorts(ports, projectId, portForwarder);
+            }
+            return out;
+        },
+        getGitStates: () => projectRuntime.getGitStates(),
+        getWorktrees: () => worktreeCache.get(),
+    });
+    const osc7Lifecycle = new Osc7Lifecycle();
+    const manualAgentTracker = new ManualAgentTracker({
+        onDebug: (sessionId, message) => {
+            debugRecorder?.record("manual-tracker", { message }, sessionId);
+        },
+    });
+    const originalBroadcast = eventBus.broadcast.bind(eventBus);
+    eventBus.broadcast = (message) => {
+        // Cache mutations must happen BEFORE broadcast so that a client
+        // hydrating in the same tick (post-broadcast addClient) reads the
+        // updated cache. Snapshot is sync inside `addClient`, so a
+        // broadcast-then-snapshot ordering is consistent only when cache is
+        // already updated by the broadcast wrapper here.
+        if (message.type === "worktree-created") {
+            worktreeCache.appendWorktree(message.projectId, message.worktree);
+        }
+        else if (message.type === "worktree-removed") {
+            worktreeCache.removeWorktree(message.projectId, message.worktreePath);
+        }
+        else if (message.type === "project-deleted") {
+            worktreeCache.removeProject(message.projectId);
+        }
+        else if (message.type === "project-created") {
+            // Refresh asynchronously: a freshly imported project may already
+            // have linked worktrees on disk that the cache has never seen.
+            // Each discovered worktree is re-broadcast so live clients update
+            // their store; new clients will hydrate the cache directly.
+            const projectId = message.project.id;
+            void projectQueries
+                .getProjectWorktrees(projectId)
+                .then((worktrees) => {
+                // Race guard: a project-deleted may have arrived during the
+                // git enumeration. Skip the cache update + re-broadcast so
+                // orphan worktrees do not resurface server- or client-side.
+                if (!projectManager.get(projectId))
+                    return;
+                worktreeCache.setProject(projectId, worktrees);
+                for (const worktree of worktrees) {
+                    eventBus.broadcast({
+                        type: "worktree-created",
+                        projectId,
+                        worktree,
+                    });
+                }
+            })
+                .catch(() => {
+                /* getProjectWorktrees swallows git errors -> empty list */
+            });
+        }
+        originalBroadcast(message);
+        if (message.type === "session-closed") {
+            osc7Lifecycle.removeSession(message.sessionId);
+            agentDetector.removeSession(message.sessionId);
+            agentStateStore.remove(message.sessionId);
+            manualAgentTracker.removeSession(message.sessionId);
+        }
+        projectRuntime.handleBroadcast(message);
+    };
+    ptyManager.onSessionInput((sessionId, data) => {
+        manualAgentTracker.observeInput(sessionId, data);
+    });
+    ptyManager.onSessionData((sessionId, data, generation) => {
+        const detectorSession = ptyManager.get(sessionId);
+        /*
+         * PTY generation gate: drop stale-gen DATA at the listener boundary.
+         * After auto-resume, an old PTY can still emit a residual OSC7 cwd
+         * report or agent-output marker. The per-client / scrollback fanout
+         * already gates on generation, but every onSessionData listener used
+         * to be invoked with stale bytes -- corrupting agent detection state
+         * and broadcasting `session-cwd-changed` for the new shell with the
+         * old PTY's cwd. Skip every derived state mutation when the chunk's
+         * emit-time generation no longer matches the live session.
+         */
+        if (detectorSession && generation < detectorSession.generation) {
+            return;
+        }
+        const foregroundProcess = ptyManager.getForegroundProcess(sessionId);
+        const observeOutput = shouldObserveAgentOutput(detectorSession, foregroundProcess) ||
+            manualAgentTracker.shouldObserve(sessionId);
+        agentDetector.feed(sessionId, data, {
+            observeOutput,
+        });
+        manualAgentTracker.observeOutput(sessionId, data);
+        const newCwd = osc7Lifecycle.feed(sessionId, data);
+        if (!newCwd)
+            return;
+        const session = ptyManager.get(sessionId);
+        if (!session || session.cwd === newCwd)
+            return;
+        /*
+         * In remote daemon mode the session domain is owned by the daemon
+         * (daemon state ownership). The server's `state.sessions` is empty/stale
+         * -- sessions live in `RemotePtyHost.mirror` -- so the in-process
+         * persistence path doesn't apply. The daemon does not currently run
+         * osc7 detection on its side; the cwd-change broadcast is still
+         * useful for live UI even without persistence, so emit it
+         * unconditionally and skip the mutate when the session domain is
+         * read-only.
+         */
+        if (!appStateStore.isSessionsReadOnly()) {
+            appStateStore.mutateSessions((state) => {
+                const target = state.sessions.find((candidate) => candidate.id === sessionId);
+                if (target)
+                    target.cwd = newCwd;
+            });
+        }
+        eventBus.broadcast({
+            type: "session-cwd-changed",
+            sessionId,
+            cwd: newCwd,
+        });
+    });
+    ptyManager.onSessionExit = (sessionId, generation, endReason) => {
+        eventBus.broadcast({
+            type: "session-ended",
+            sessionId,
+            generation,
+            endReason,
+        });
+        osc7Lifecycle.removeSession(sessionId);
+        agentDetector.removeSession(sessionId);
+        agentStateStore.remove(sessionId);
+        manualAgentTracker.removeSession(sessionId);
+        const session = ptyManager.get(sessionId);
+        if (session) {
+            projectRuntime.handleSessionEnded(session.projectId);
+        }
+        // L1 GC for upload staging isolation -- drop the session's upload staging dir
+        // immediately on PTY exit. Best-effort: a failure here is logged
+        // and the L2/L3 sweep will reap it later.
+        uploadStaging.releaseSession(sessionId).catch((err) => {
+            console.error(`[upload-staging] releaseSession(${sessionId}) failed:`, err);
+        });
+    };
+    agentDetector.onStateChange((state) => {
+        agentStateStore.set(state);
+        debugRecorder?.recordState(state);
+        eventBus.broadcast({
+            type: "agent-state",
+            state,
+        });
+        if (state.lifecycle !== "waiting" || state.confidence !== "high")
+            return;
+        const session = ptyManager.get(state.sessionId);
+        const notification = createWaitingNotification(state.sessionId, session?.projectId ?? "");
+        eventBus.addNotification(notification);
+        eventBus.broadcast({ type: "notification", notification });
+    });
+    ipcServer.onCommand("open", (args) => {
+        const url = args.url;
+        if (!url)
+            return { ok: false, error: "url required" };
+        eventBus.broadcast({
+            type: "browser-url-changed",
+            paneId: "__route_open__",
+            url,
+        });
+        return { ok: true };
+    });
+}
+//# sourceMappingURL=wire-runtime.js.map