parasor 0.1.0

package/server/pty/host-daemon/entry.d.ts

@@ -0,0 +1,3 @@
+#!/usr/bin/env node
+export {};
+//# sourceMappingURL=entry.d.ts.map

package/server/pty/host-daemon/entry.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"entry.d.ts","sourceRoot":"","sources":["../../../src/pty/host-daemon/entry.ts"],"names":[],"mappings":""}

package/server/pty/host-daemon/entry.js

@@ -0,0 +1,72 @@
+#!/usr/bin/env node
+/*
+ * -- `parasor-pty-host` CLI entry point.
+ *
+ * Boots a daemon, runs until SIGTERM/SIGINT, exits 0 on graceful stop or
+ * non-zero on bootstrap failure. No subcommands yet; this entry is what
+ * lifecycle commands invoke under the hood (or what a launchd/systemd unit
+ * wraps directly).
+ *
+ * Logging: opt-in via `PARASOR_PTY_HOST_DEBUG=1`. Default is silent so
+ * background-spawned daemons don't pollute the terminal that started
+ * them.
+ */
+import { appendFileSync } from "node:fs";
+import { UploadStaging } from "../../fs/upload-staging.js";
+import { bootstrapDaemon } from "./bootstrap.js";
+import { DaemonAlreadyRunningError } from "./lockfile.js";
+import { resolveDaemonPaths } from "./paths.js";
+async function main() {
+    const paths = resolveDaemonPaths();
+    const debug = process.env.PARASOR_PTY_HOST_DEBUG === "1";
+    const log = (line) => {
+        const stamped = `${new Date().toISOString()} [pty-host] ${line}\n`;
+        try {
+            appendFileSync(paths.logFile, stamped);
+        }
+        catch {
+            /* log file write best-effort */
+        }
+        if (debug)
+            process.stderr.write(stamped);
+    };
+    try {
+        /*
+         * Upload staging isolation  -- daemon-side per-session env injection.
+         * The daemon is its own process so it cannot share the server's
+         * `UploadStaging` instance; we instantiate one here purely for the
+         * canonical `uploadsDir` path. The constructor's symlink/owner
+         * guards run again as a defence-in-depth check (cheap idempotent
+         * mkdir + lstat). The L3 sweep stays in the server process -- the
+         * daemon never ticks `sweepStale` to avoid duplicate work, but it
+         * does need the canonical path so `InProcessPtyHost.buildSessionEnv`
+         * can stamp `PARASOR_UPLOAD_DIR=<dir>/<sid>` on every spawned PTY.
+         */
+        const uploadStaging = new UploadStaging({});
+        const running = await bootstrapDaemon({
+            paths,
+            log,
+            uploadsDir: uploadStaging.uploadsDir,
+        });
+        log(`pid=${process.pid} ready socket=${running.paths.socketPath}`);
+    }
+    catch (err) {
+        if (err instanceof DaemonAlreadyRunningError) {
+            //  R4 -- when foreground bootstrap collides with an
+            // installed daemon the bare error doesn't tell the user *why* their
+            // socket is busy or how to coexist. Emit an explicit hint pointing
+            // at `parasor service status` (verifies installed daemon ownership)
+            // and the per-PID opt-in (`PARASOR_PTY_SOCK_PER_PID=1`) which gives
+            // the foreground process its own socket basename.
+            process.stderr.write(`${err.message}\n`);
+            process.stderr.write("\nThe installed parasor service may own this socket. Try:\n");
+            process.stderr.write("  parasor service status         # check installed service state\n");
+            process.stderr.write("  PARASOR_PTY_SOCK_PER_PID=1 parasor server   # foreground daemon on a per-PID socket\n");
+            process.exit(2);
+        }
+        process.stderr.write(`parasor-pty-host fatal: ${err.stack ?? err}\n`);
+        process.exit(1);
+    }
+}
+void main();
+//# sourceMappingURL=entry.js.map

package/server/pty/host-daemon/entry.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"entry.js","sourceRoot":"","sources":["../../../src/pty/host-daemon/entry.ts"],"names":[],"mappings":";AACA;;;;;;;;;;;GAWG;AAEH,OAAO,EAAE,cAAc,EAAE,MAAM,SAAS,CAAC;AACzC,OAAO,EAAE,aAAa,EAAE,MAAM,4BAA4B,CAAC;AAC3D,OAAO,EAAE,eAAe,EAAE,MAAM,gBAAgB,CAAC;AACjD,OAAO,EAAE,yBAAyB,EAAE,MAAM,eAAe,CAAC;AAC1D,OAAO,EAAE,kBAAkB,EAAE,MAAM,YAAY,CAAC;AAEhD,KAAK,UAAU,IAAI;IACjB,MAAM,KAAK,GAAG,kBAAkB,EAAE,CAAC;IACnC,MAAM,KAAK,GAAG,OAAO,CAAC,GAAG,CAAC,sBAAsB,KAAK,GAAG,CAAC;IAEzD,MAAM,GAAG,GAAG,CAAC,IAAY,EAAQ,EAAE;QACjC,MAAM,OAAO,GAAG,GAAG,IAAI,IAAI,EAAE,CAAC,WAAW,EAAE,eAAe,IAAI,IAAI,CAAC;QACnE,IAAI,CAAC;YACH,cAAc,CAAC,KAAK,CAAC,OAAO,EAAE,OAAO,CAAC,CAAC;QACzC,CAAC;QAAC,MAAM,CAAC;YACP,gCAAgC;QAClC,CAAC;QACD,IAAI,KAAK;YAAE,OAAO,CAAC,MAAM,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC;IAC3C,CAAC,CAAC;IAEF,IAAI,CAAC;QACH;;;;;;;;;;WAUG;QACH,MAAM,aAAa,GAAG,IAAI,aAAa,CAAC,EAAE,CAAC,CAAC;QAC5C,MAAM,OAAO,GAAG,MAAM,eAAe,CAAC;YACpC,KAAK;YACL,GAAG;YACH,UAAU,EAAE,aAAa,CAAC,UAAU;SACrC,CAAC,CAAC;QACH,GAAG,CAAC,OAAO,OAAO,CAAC,GAAG,iBAAiB,OAAO,CAAC,KAAK,CAAC,UAAU,EAAE,CAAC,CAAC;IACrE,CAAC;IAAC,OAAO,GAAG,EAAE,CAAC;QACb,IAAI,GAAG,YAAY,yBAAyB,EAAE,CAAC;YAC7C,oDAAoD;YACpD,oEAAoE;YACpE,mEAAmE;YACnE,oEAAoE;YACpE,oEAAoE;YACpE,kDAAkD;YAClD,OAAO,CAAC,MAAM,CAAC,KAAK,CAAC,GAAG,GAAG,CAAC,OAAO,IAAI,CAAC,CAAC;YACzC,OAAO,CAAC,MAAM,CAAC,KAAK,CAClB,6DAA6D,CAC9D,CAAC;YACF,OAAO,CAAC,MAAM,CAAC,KAAK,CAClB,oEAAoE,CACrE,CAAC;YACF,OAAO,CAAC,MAAM,CAAC,KAAK,CAClB,yFAAyF,CAC1F,CAAC;YACF,OAAO,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC;QAClB,CAAC;QACD,OAAO,CAAC,MAAM,CAAC,KAAK,CAClB,2BAA4B,GAAa,CAAC,KAAK,IAAI,GAAG,IAAI,CAC3D,CAAC;QACF,OAAO,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC;IAClB,CAAC;AACH,CAAC;AAED,KAAK,IAAI,EAAE,CAAC"}

package/server/pty/host-daemon/lockfile.d.ts

@@ -0,0 +1,12 @@
+import type { DaemonPaths } from "./paths.js";
+export interface DaemonLock {
+    pidFile: string;
+    release: () => Promise<void>;
+}
+export declare class DaemonAlreadyRunningError extends Error {
+    readonly pid: number;
+    readonly pidFile: string;
+    constructor(pid: number, pidFile: string);
+}
+export declare function acquireDaemonLock(paths: DaemonPaths, ourPid?: number): Promise<DaemonLock>;
+//# sourceMappingURL=lockfile.d.ts.map

package/server/pty/host-daemon/lockfile.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"lockfile.d.ts","sourceRoot":"","sources":["../../../src/pty/host-daemon/lockfile.ts"],"names":[],"mappings":"AAuBA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,YAAY,CAAC;AAE9C,MAAM,WAAW,UAAU;IACzB,OAAO,EAAE,MAAM,CAAC;IAChB,OAAO,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,CAAC;CAC9B;AAED,qBAAa,yBAA0B,SAAQ,KAAK;IAEhD,QAAQ,CAAC,GAAG,EAAE,MAAM;IACpB,QAAQ,CAAC,OAAO,EAAE,MAAM;gBADf,GAAG,EAAE,MAAM,EACX,OAAO,EAAE,MAAM;CAK3B;AAED,wBAAsB,iBAAiB,CACrC,KAAK,EAAE,WAAW,EAClB,MAAM,GAAE,MAAoB,GAC3B,OAAO,CAAC,UAAU,CAAC,CA+CrB"}

package/server/pty/host-daemon/lockfile.js

@@ -0,0 +1,120 @@
+/*
+ * -- daemon single-instance enforcement.
+ *
+ * `proper-lockfile` advisory flock on `paths.lockFile` is the *sole*
+ * source of truth for "another daemon owns this runtime dir". It is held
+ * across the daemon's whole lifetime and released either by graceful
+ * shutdown or by stale-timeout (60s) if the holder dies.
+ *
+ * The pidfile is purely informational: humans (and `parasor pty-host
+ * status`) read it to find the daemon's PID; the recorded pid liveness
+ * probe (`kill(pid, 0)`) is only consulted to populate
+ * `DaemonAlreadyRunningError.pid` for nicer error messages. We do *not*
+ * cross-validate the pidfile post-flock -- once flock returned success,
+ * the recycled-PID corner case (previous daemon died, OS handed the same
+ * PID to an unrelated process before stale-timeout fired) would
+ * otherwise spuriously block startup.  *
+ * Mode marker is enforced by the server-side factory
+ * (`createPtyHost`) because it polices in-process vs daemon ownership of
+ * the AppStateStore -- out of scope here.
+ */
+import { existsSync, readFileSync, unlinkSync, writeFileSync } from "node:fs";
+import lockfile from "proper-lockfile";
+export class DaemonAlreadyRunningError extends Error {
+    pid;
+    pidFile;
+    constructor(pid, pidFile) {
+        super(`parasor-pty-host already running (pid=${pid}, lock=${pidFile})`);
+        this.pid = pid;
+        this.pidFile = pidFile;
+        this.name = "DaemonAlreadyRunningError";
+    }
+}
+export async function acquireDaemonLock(paths, ourPid = process.pid) {
+    if (!existsSync(paths.lockFile)) {
+        writeFileSync(paths.lockFile, "");
+    }
+    let release;
+    try {
+        release = await lockfile.lock(paths.lockFile, {
+            stale: 60_000,
+            retries: 0,
+        });
+    }
+    catch (err) {
+        // ELOCKED is the only signal that another live daemon owns the
+        // lockfile. We surface the recorded pid (if alive) for diagnostics,
+        // but the rejection itself is decided entirely by flock -- the
+        // pidfile content cannot vote.
+        if (isLockHeldError(err)) {
+            const livePid = readPidIfAlive(paths.pidFile);
+            throw new DaemonAlreadyRunningError(livePid ?? -1, paths.pidFile);
+        }
+        throw err;
+    }
+    // flock acquired: we own the runtime dir. Stamp our pid for `parasor
+    // pty-host status` consumers; do NOT recheck the pidfile, because a
+    // stale pid that has been recycled by an unrelated live process would
+    // otherwise block legitimate takeover.
+    writeFileSync(paths.pidFile, `${ourPid}\n`);
+    return {
+        pidFile: paths.pidFile,
+        release: async () => {
+            try {
+                if (existsSync(paths.pidFile)) {
+                    const recorded = readPidStrict(paths.pidFile);
+                    if (recorded === ourPid)
+                        unlinkSync(paths.pidFile);
+                }
+            }
+            catch {
+                /* best-effort cleanup */
+            }
+            try {
+                await release();
+            }
+            catch {
+                /* lockfile already released or removed */
+            }
+        },
+    };
+}
+function readPidIfAlive(pidFile) {
+    if (!existsSync(pidFile))
+        return null;
+    let raw;
+    try {
+        raw = readFileSync(pidFile, "utf8").trim();
+    }
+    catch {
+        return null;
+    }
+    const pid = Number(raw);
+    if (!Number.isFinite(pid) || pid <= 0)
+        return null;
+    try {
+        process.kill(pid, 0);
+        return pid;
+    }
+    catch {
+        return null;
+    }
+}
+function isLockHeldError(err) {
+    if (!(err instanceof Error))
+        return false;
+    const code = err.code;
+    if (code === "ELOCKED")
+        return true;
+    return /lock file is already being held/i.test(err.message);
+}
+function readPidStrict(pidFile) {
+    try {
+        const pid = Number(readFileSync(pidFile, "utf8").trim());
+        return Number.isFinite(pid) && pid > 0 ? pid : null;
+    }
+    catch {
+        return null;
+    }
+}
+//# sourceMappingURL=lockfile.js.map

package/server/pty/host-daemon/lockfile.js.map

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

package/server/pty/host-daemon/mode-marker.d.ts

@@ -0,0 +1,77 @@
+export type AppStateMode = "in-process" | "daemon";
+export interface ModeMarker {
+    mode: AppStateMode;
+    pid: number;
+    startedAt: string;
+    hostname: string;
+}
+export declare class AppStateOwnerConflictError extends Error {
+    readonly currentMode: AppStateMode;
+    readonly existing: ModeMarker | null;
+    readonly markerFile: string;
+    constructor(currentMode: AppStateMode, existing: ModeMarker | null, markerFile: string);
+}
+export interface AppStateOwner {
+    marker: ModeMarker;
+    release: () => Promise<void>;
+}
+/**
+ * Read and parse the marker file body. Returns null when the file does
+ * not exist or is malformed. Body is purely informational -- readers
+ * MUST NOT use it as a mutex; the proper-lockfile lock on the same
+ * path is what serialises ownership.
+ */
+export declare function readMarker(markerFile: string): ModeMarker | null;
+/**
+ * Write the marker body. Caller MUST already hold the proper-lockfile
+ * advisory lock on `markerFile` (see `acquireAppStateOwnership`).
+ */
+export declare function writeMarker(markerFile: string, mode: AppStateMode, pid?: number, startedAt?: string, hostname?: string): ModeMarker;
+/** Best-effort delete; not an error if the file is already gone. */
+export declare function unlinkMarker(markerFile: string): void;
+/**
+ * Liveness probe via `process.kill(pid, 0)`. Used only to enrich the
+ * conflict error -- the proper-lockfile hold is the source of truth for
+ * whether the recorded owner is still alive.
+ */
+export declare function isPidAlive(pid: number): boolean;
+/**
+ * Conventional marker location: the AppState dir (i.e. the directory
+ * that holds `state.json`). Co-locating with state.json -- rather than
+ * the daemon runtime dir -- means any process that opens this state.json
+ * passes through the same marker file, which is the actual mutual-
+ * exclusion target. The daemon runtime dir varies with `XDG_RUNTIME_DIR`
+ * / `PARASOR_PTY_SOCK` overrides, so an in-process server with a custom
+ * `PARASOR_CONFIG_DIR` and a daemon with a custom `XDG_RUNTIME_DIR`
+ * could otherwise both write the same `state.json` undetected.
+ */
+export declare function markerFileFor(appStateDir: string): string;
+interface AcquireOptions {
+    pid?: number;
+    startedAt?: string;
+    hostname?: string;
+    /** Test seam -- production callers always use proper-lockfile defaults. */
+    retries?: number;
+}
+/**
+ * Acquire exclusive ownership of the AppState directory. On success
+ * returns an `AppStateOwner` whose `release()` MUST be called from the
+ * graceful-shutdown path. The lock is held until release; long-running
+ * owners are kept alive by proper-lockfile's mtime refresh interval
+ * (default `stale/2 = 30s`).
+ *
+ * `proper-lockfile.lock()` is the *sole* mutex (mirrors
+ * `host-daemon/lockfile.ts`'s decision for the daemon runtime lock).
+ * The marker file body is purely informational -- populated for
+ * `AppStateOwnerConflictError` diagnostics, NOT cross-validated post-
+ * acquisition. a post-flock `kill(pid, 0)` recheck
+ * spuriously rejects legitimate stale takeover when the OS has
+ * recycled the prior owner's PID to an unrelated live process during
+ * the 60s stale window. The daemon lockfile path documents the same
+ * choice ("flock acquired: we own the runtime dir … do NOT recheck …
+ * because a stale pid that has been recycled by an unrelated live
+ * process would otherwise block legitimate takeover").
+ */
+export declare function acquireAppStateOwnership(markerFile: string, currentMode: AppStateMode, opts?: AcquireOptions): Promise<AppStateOwner>;
+export {};
+//# sourceMappingURL=mode-marker.d.ts.map

package/server/pty/host-daemon/mode-marker.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mode-marker.d.ts","sourceRoot":"","sources":["../../../src/pty/host-daemon/mode-marker.ts"],"names":[],"mappings":"AA+BA,MAAM,MAAM,YAAY,GAAG,YAAY,GAAG,QAAQ,CAAC;AAEnD,MAAM,WAAW,UAAU;IACzB,IAAI,EAAE,YAAY,CAAC;IACnB,GAAG,EAAE,MAAM,CAAC;IACZ,SAAS,EAAE,MAAM,CAAC;IAClB,QAAQ,EAAE,MAAM,CAAC;CAClB;AAED,qBAAa,0BAA2B,SAAQ,KAAK;IAEjD,QAAQ,CAAC,WAAW,EAAE,YAAY;IAClC,QAAQ,CAAC,QAAQ,EAAE,UAAU,GAAG,IAAI;IACpC,QAAQ,CAAC,UAAU,EAAE,MAAM;gBAFlB,WAAW,EAAE,YAAY,EACzB,QAAQ,EAAE,UAAU,GAAG,IAAI,EAC3B,UAAU,EAAE,MAAM;CAY9B;AAED,MAAM,WAAW,aAAa;IAC5B,MAAM,EAAE,UAAU,CAAC;IACnB,OAAO,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,CAAC;CAC9B;AAED;;;;;GAKG;AACH,wBAAgB,UAAU,CAAC,UAAU,EAAE,MAAM,GAAG,UAAU,GAAG,IAAI,CAkBhE;AAED;;;GAGG;AACH,wBAAgB,WAAW,CACzB,UAAU,EAAE,MAAM,EAClB,IAAI,EAAE,YAAY,EAClB,GAAG,GAAE,MAAoB,EACzB,SAAS,GAAE,MAAiC,EAC5C,QAAQ,GAAE,MAAqB,GAC9B,UAAU,CAIZ;AAED,oEAAoE;AACpE,wBAAgB,YAAY,CAAC,UAAU,EAAE,MAAM,GAAG,IAAI,CAMrD;AAED;;;;GAIG;AACH,wBAAgB,UAAU,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAc/C;AAED;;;;;;;;;GASG;AACH,wBAAgB,aAAa,CAAC,WAAW,EAAE,MAAM,GAAG,MAAM,CAEzD;AAED,UAAU,cAAc;IACtB,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,2EAA2E;IAC3E,OAAO,CAAC,EAAE,MAAM,CAAC;CAClB;AAED;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAsB,wBAAwB,CAC5C,UAAU,EAAE,MAAM,EAClB,WAAW,EAAE,YAAY,EACzB,IAAI,GAAE,cAAmB,GACxB,OAAO,CAAC,aAAa,CAAC,CAiFxB"}

package/server/pty/host-daemon/mode-marker.js

@@ -0,0 +1,228 @@
+/*
+ * -- cross-mode mutual exclusion ownership lock.
+ *
+ * Both runtime modes (in-process server / daemon) write to the same
+ * AppStateStore on disk. If both run concurrently against the same
+ * runtime dir they corrupt each other's view. This module acquires an
+ * exclusive `proper-lockfile` advisory lock on a marker file next to
+ * `state.json` and holds it for the lifetime of the owning process.
+ *
+ * Design parallels `host-daemon/lockfile.ts`:
+ *   - `proper-lockfile` is the *sole* mutex (kernel-backed via
+ *     graceful-fs's atomic mkdir of `<marker>.lock`/). Held across the
+ *     owner's whole lifetime; released via `AppStateOwner.release()` on
+ *     graceful shutdown or by stale-timeout (60s) if the holder dies.
+ *   - The marker file body is purely informational -- humans (and a
+ *     future `parasor doctor`) read it to see who owns the dir; the
+ *     conflict error pretty-prints those fields. Body content cannot
+ *     vote against the lockfile decision.
+ *   - PID liveness (`process.kill(pid, 0)`) is consulted only to
+ *     populate `AppStateOwnerConflictError` for nicer messages.
+ *
+ * Wire format: a single TSV line `mode\tpid\tstartedAt\thostname`. TSV
+ * keeps the file shell-readable during incident response (`cat
+ * appstate.mode`). The parser rejects lines that don't match the
+ * 4-field shape.
+ */
+import { existsSync, readFileSync, unlinkSync, writeFileSync } from "node:fs";
+import { hostname as osHostname } from "node:os";
+import lockfile from "proper-lockfile";
+export class AppStateOwnerConflictError extends Error {
+    currentMode;
+    existing;
+    markerFile;
+    constructor(currentMode, existing, markerFile) {
+        const tail = existing !== null
+            ? `${existing.mode} mode (pid=${existing.pid}, host=${existing.hostname}, started=${existing.startedAt})`
+            : "an unidentified owner (lockfile held but marker body unreadable)";
+        super(`appstate is owned by ${tail}; refusing to start ${currentMode} mode against the same runtime dir. ` +
+            `Marker file: ${markerFile}`);
+        this.currentMode = currentMode;
+        this.existing = existing;
+        this.markerFile = markerFile;
+        this.name = "AppStateOwnerConflictError";
+    }
+}
+/**
+ * Read and parse the marker file body. Returns null when the file does
+ * not exist or is malformed. Body is purely informational -- readers
+ * MUST NOT use it as a mutex; the proper-lockfile lock on the same
+ * path is what serialises ownership.
+ */
+export function readMarker(markerFile) {
+    if (!existsSync(markerFile))
+        return null;
+    let raw;
+    try {
+        raw = readFileSync(markerFile, "utf8");
+    }
+    catch {
+        return null;
+    }
+    const line = raw.split(/\r?\n/)[0] ?? "";
+    const fields = line.split("\t");
+    if (fields.length !== 4)
+        return null;
+    const [mode, pidStr, startedAt, hostname] = fields;
+    if (mode !== "in-process" && mode !== "daemon")
+        return null;
+    const pid = Number(pidStr);
+    if (!Number.isFinite(pid) || pid <= 0)
+        return null;
+    if (typeof startedAt !== "string" || startedAt.length === 0)
+        return null;
+    if (typeof hostname !== "string" || hostname.length === 0)
+        return null;
+    return { mode, pid, startedAt, hostname };
+}
+/**
+ * Write the marker body. Caller MUST already hold the proper-lockfile
+ * advisory lock on `markerFile` (see `acquireAppStateOwnership`).
+ */
+export function writeMarker(markerFile, mode, pid = process.pid, startedAt = new Date().toISOString(), hostname = osHostname()) {
+    const line = `${mode}\t${pid}\t${startedAt}\t${hostname}\n`;
+    writeFileSync(markerFile, line, { encoding: "utf8", mode: 0o600 });
+    return { mode, pid, startedAt, hostname };
+}
+/** Best-effort delete; not an error if the file is already gone. */
+export function unlinkMarker(markerFile) {
+    try {
+        if (existsSync(markerFile))
+            unlinkSync(markerFile);
+    }
+    catch {
+        /* leave-on-error */
+    }
+}
+/**
+ * Liveness probe via `process.kill(pid, 0)`. Used only to enrich the
+ * conflict error -- the proper-lockfile hold is the source of truth for
+ * whether the recorded owner is still alive.
+ */
+export function isPidAlive(pid) {
+    if (!Number.isFinite(pid) || pid <= 0)
+        return false;
+    try {
+        process.kill(pid, 0);
+        return true;
+    }
+    catch (err) {
+        /*
+         * EPERM = PID exists but belongs to another user. From this
+         * module's standpoint that is "alive" because the runtime dir is
+         * per-user -- another user's PID inside our home dir would be a
+         * permissions misconfiguration we should not paper over.
+         */
+        return err.code === "EPERM";
+    }
+}
+/**
+ * Conventional marker location: the AppState dir (i.e. the directory
+ * that holds `state.json`). Co-locating with state.json -- rather than
+ * the daemon runtime dir -- means any process that opens this state.json
+ * passes through the same marker file, which is the actual mutual-
+ * exclusion target. The daemon runtime dir varies with `XDG_RUNTIME_DIR`
+ * / `PARASOR_PTY_SOCK` overrides, so an in-process server with a custom
+ * `PARASOR_CONFIG_DIR` and a daemon with a custom `XDG_RUNTIME_DIR`
+ * could otherwise both write the same `state.json` undetected.
+ */
+export function markerFileFor(appStateDir) {
+    return `${appStateDir}/appstate.mode`;
+}
+/**
+ * Acquire exclusive ownership of the AppState directory. On success
+ * returns an `AppStateOwner` whose `release()` MUST be called from the
+ * graceful-shutdown path. The lock is held until release; long-running
+ * owners are kept alive by proper-lockfile's mtime refresh interval
+ * (default `stale/2 = 30s`).
+ *
+ * `proper-lockfile.lock()` is the *sole* mutex (mirrors
+ * `host-daemon/lockfile.ts`'s decision for the daemon runtime lock).
+ * The marker file body is purely informational -- populated for
+ * `AppStateOwnerConflictError` diagnostics, NOT cross-validated post-
+ * acquisition. a post-flock `kill(pid, 0)` recheck
+ * spuriously rejects legitimate stale takeover when the OS has
+ * recycled the prior owner's PID to an unrelated live process during
+ * the 60s stale window. The daemon lockfile path documents the same
+ * choice ("flock acquired: we own the runtime dir … do NOT recheck …
+ * because a stale pid that has been recycled by an unrelated live
+ * process would otherwise block legitimate takeover").
+ */
+export async function acquireAppStateOwnership(markerFile, currentMode, opts = {}) {
+    const ourPid = opts.pid ?? process.pid;
+    const startedAt = opts.startedAt ?? new Date().toISOString();
+    const hostname = opts.hostname ?? osHostname();
+    /*
+     * `proper-lockfile.lock()` resolves the file's realpath and stats it,
+     * so the marker file must already exist. Touch an empty file when
+     * none is present; the body is overwritten further down once we own
+     * the lock. Same pattern as `host-daemon/lockfile.ts`.
+     */
+    if (!existsSync(markerFile)) {
+        writeFileSync(markerFile, "", { mode: 0o600 });
+    }
+    let release;
+    try {
+        release = await lockfile.lock(markerFile, {
+            stale: 60_000,
+            retries: opts.retries ?? 0,
+        });
+    }
+    catch (err) {
+        if (isLockHeldError(err)) {
+            const existing = readMarker(markerFile);
+            throw new AppStateOwnerConflictError(currentMode, existing, markerFile);
+        }
+        throw err;
+    }
+    // Lock acquired: we own the AppState dir. Stamp the marker body for
+    // diagnostics (`parasor doctor`, incident response). Stale body
+    // content from a previous owner is overwritten unconditionally --
+    // proper-lockfile already decided that owner is gone.
+    const marker = writeMarker(markerFile, currentMode, ourPid, startedAt, hostname);
+    return {
+        marker,
+        release: async () => {
+            /*
+             * Owner-verified body unlink (reviewed for correctness): only delete the
+             * marker body if it still names *us*. A previous owner whose
+             * lock got stale-stolen could otherwise unlink the new owner's
+             * body during a delayed shutdown handler. Same pattern as the
+             * daemon pidfile cleanup in `host-daemon/lockfile.ts`.
+             */
+            try {
+                const recorded = readMarker(markerFile);
+                if (recorded !== null &&
+                    recorded.pid === ourPid &&
+                    recorded.startedAt === startedAt) {
+                    unlinkMarker(markerFile);
+                }
+            }
+            catch {
+                /* best-effort body cleanup */
+            }
+            try {
+                await release();
+            }
+            catch (err) {
+                /*
+                 * surface release failure to stderr so a
+                 * leftover `<marker>.lock/` directory after a crashy shutdown
+                 * is observable. proper-lockfile's stale-timeout (60s) makes
+                 * the next boot self-recover, but the operator still wants to
+                 * know.
+                 */
+                console.error(`[mode-marker] release error for ${markerFile}: ${err.message}`);
+            }
+        },
+    };
+}
+function isLockHeldError(err) {
+    if (!(err instanceof Error))
+        return false;
+    const code = err.code;
+    if (code === "ELOCKED")
+        return true;
+    return /lock file is already being held/i.test(err.message);
+}
+//# sourceMappingURL=mode-marker.js.map

package/server/pty/host-daemon/mode-marker.js.map

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

package/server/pty/host-daemon/orphan-cleanup.d.ts

@@ -0,0 +1,42 @@
+import type { SessionRecord } from "@parasor/shared";
+export type OrphanReconcileTransition = {
+    type: "kept";
+    id: string;
+} | {
+    type: "orphaned";
+    id: string;
+    previousDaemonPid: number;
+} | {
+    type: "lost";
+    id: string;
+    reason: "no-pid" | "dead-pid";
+};
+export interface OrphanReconcileResult {
+    /** Snapshots after reconciliation, in input order. */
+    records: SessionRecord[];
+    /** Per-id transition summary (helpful for logging / tests). */
+    transitions: OrphanReconcileTransition[];
+}
+export interface ReconcileOpts {
+    currentDaemonPid: number;
+    /**
+     * ISO8601 timestamp of *this* daemon's start. Combined with
+     * `currentDaemonPid` to form the writer-generation tuple -- a record
+     * with a matching pid but a stale `daemonStartedAt` is treated as
+     * orphaned, defending against PID recycling between daemon restarts
+     * (reviewed for correctness). Required for correctness; an undefined value
+     * would silently degrade to PID-only matching.
+     */
+    currentDaemonStartedAt: string;
+    /** Liveness probe; defaults to `process.kill(pid, 0)`. Test seam. */
+    isPidAlive?: (pid: number) => boolean;
+}
+/**
+ * Pure function -- no side effects. Caller is responsible for persisting
+ * the resulting array via `AppStateStore.internalMutate`.
+ *
+ * Already-terminal records (state in {exited,lost,orphaned}) are passed
+ * through unchanged. Only `state === "running"` records are evaluated.
+ */
+export declare function reconcileSessionRecords(input: readonly SessionRecord[], opts: ReconcileOpts): OrphanReconcileResult;
+//# sourceMappingURL=orphan-cleanup.d.ts.map

package/server/pty/host-daemon/orphan-cleanup.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"orphan-cleanup.d.ts","sourceRoot":"","sources":["../../../src/pty/host-daemon/orphan-cleanup.ts"],"names":[],"mappings":"AAgCA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,iBAAiB,CAAC;AAErD,MAAM,MAAM,yBAAyB,GACjC;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,EAAE,EAAE,MAAM,CAAA;CAAE,GAC5B;IAAE,IAAI,EAAE,UAAU,CAAC;IAAC,EAAE,EAAE,MAAM,CAAC;IAAC,iBAAiB,EAAE,MAAM,CAAA;CAAE,GAC3D;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,EAAE,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,QAAQ,GAAG,UAAU,CAAA;CAAE,CAAC;AAEhE,MAAM,WAAW,qBAAqB;IACpC,sDAAsD;IACtD,OAAO,EAAE,aAAa,EAAE,CAAC;IACzB,+DAA+D;IAC/D,WAAW,EAAE,yBAAyB,EAAE,CAAC;CAC1C;AAED,MAAM,WAAW,aAAa;IAC5B,gBAAgB,EAAE,MAAM,CAAC;IACzB;;;;;;;OAOG;IACH,sBAAsB,EAAE,MAAM,CAAC;IAC/B,qEAAqE;IACrE,UAAU,CAAC,EAAE,CAAC,GAAG,EAAE,MAAM,KAAK,OAAO,CAAC;CACvC;AAYD;;;;;;GAMG;AACH,wBAAgB,uBAAuB,CACrC,KAAK,EAAE,SAAS,aAAa,EAAE,EAC/B,IAAI,EAAE,aAAa,GAClB,qBAAqB,CAyCvB"}