@particle-academy/fancy-term-host 0.1.0

package/dist/pty-host.js

@@ -0,0 +1,236 @@
+import { socketPathFor, FrameDecoder, pidfilePath, PROTOCOL_VERSION, encodeFrame } from './chunk-2DQJKTG5.js';
+import net from 'net';
+import fs from 'fs';
+import path from 'path';
+import { spawn } from 'node-pty';
+
+var SCROLLBACK_MAX = 1e6;
+var IDLE_TIMEOUT_MS = 10 * 60 * 1e3;
+var IDLE_CHECK_MS = 60 * 1e3;
+var userData = process.env.GENIE_USERDATA;
+if (!userData) {
+  process.exit(2);
+}
+var ptys = /* @__PURE__ */ new Map();
+var clients = /* @__PURE__ */ new Set();
+var lastActivity = Date.now();
+function broadcast(msg) {
+  const frame = encodeFrame(msg);
+  for (const sock of clients) {
+    try {
+      sock.write(frame);
+    } catch {
+    }
+  }
+}
+function createPty(opts) {
+  const existing = ptys.get(opts.id);
+  if (existing) {
+    return {
+      pid: existing.pty.pid,
+      shell: existing.shell,
+      existing: true,
+      scrollback: existing.scrollback
+    };
+  }
+  const shell = opts.shell ?? defaultShell();
+  const env = { ...process.env, ...opts.env ?? {} };
+  env.TERM = env.TERM || "xterm-256color";
+  const pty = spawn(shell, opts.args ?? [], {
+    name: "xterm-color",
+    cwd: opts.cwd,
+    cols: opts.cols ?? 80,
+    rows: opts.rows ?? 24,
+    env
+  });
+  const entry = { pty, shell, scrollback: "" };
+  ptys.set(opts.id, entry);
+  pty.onData((data) => {
+    const next = entry.scrollback + data;
+    entry.scrollback = next.length > SCROLLBACK_MAX ? next.slice(-SCROLLBACK_MAX) : next;
+    broadcast({ kind: "data", id: opts.id, data });
+  });
+  pty.onExit(({ exitCode, signal }) => {
+    ptys.delete(opts.id);
+    broadcast({ kind: "exit", id: opts.id, exitCode, signal });
+    lastActivity = Date.now();
+  });
+  return { pid: pty.pid, shell, existing: false, scrollback: "" };
+}
+function defaultShell() {
+  if (process.platform === "win32") return process.env.COMSPEC ?? "cmd.exe";
+  return process.env.SHELL ?? "/bin/bash";
+}
+function handleClientMessage(sock, msg) {
+  lastActivity = Date.now();
+  switch (msg.kind) {
+    case "hello":
+      reply(sock, {
+        kind: "hello-ok",
+        seq: msg.seq,
+        protocolVersion: PROTOCOL_VERSION,
+        pid: process.pid
+      });
+      break;
+    case "create": {
+      const r = createPty(msg.opts);
+      reply(sock, {
+        kind: "created",
+        seq: msg.seq,
+        result: {
+          id: msg.opts.id,
+          pid: r.pid,
+          shell: r.shell,
+          existing: r.existing,
+          scrollback: r.scrollback
+        }
+      });
+      break;
+    }
+    case "write": {
+      const e = ptys.get(msg.id);
+      if (e) e.pty.write(msg.data);
+      break;
+    }
+    case "resize": {
+      const e = ptys.get(msg.id);
+      if (e) {
+        try {
+          e.pty.resize(Math.max(1, msg.cols | 0), Math.max(1, msg.rows | 0));
+        } catch {
+        }
+      }
+      break;
+    }
+    case "kill": {
+      const e = ptys.get(msg.id);
+      if (e) {
+        try {
+          e.pty.kill();
+        } catch {
+        }
+        ptys.delete(msg.id);
+      }
+      break;
+    }
+    case "list":
+      reply(sock, {
+        kind: "list-result",
+        seq: msg.seq,
+        terminals: Array.from(ptys.entries()).map(([id, e]) => ({
+          id,
+          pid: e.pty.pid,
+          shell: e.shell
+        }))
+      });
+      break;
+    case "set-retained":
+      break;
+    case "get-scrollback":
+      reply(sock, {
+        kind: "scrollback-result",
+        seq: msg.seq,
+        scrollback: ptys.get(msg.id)?.scrollback ?? null
+      });
+      break;
+    case "ping":
+      reply(sock, { kind: "pong", seq: msg.seq });
+      break;
+  }
+}
+function reply(sock, msg) {
+  try {
+    sock.write(encodeFrame(msg));
+  } catch {
+  }
+}
+function startServer(socketPath2) {
+  if (process.platform !== "win32") {
+    try {
+      fs.rmSync(socketPath2, { force: true });
+    } catch {
+    }
+    try {
+      fs.mkdirSync(path.dirname(socketPath2), { recursive: true });
+    } catch {
+    }
+  }
+  const server = net.createServer((sock) => {
+    clients.add(sock);
+    lastActivity = Date.now();
+    const decoder = new FrameDecoder();
+    sock.on("data", (chunk) => {
+      const frames = decoder.push(chunk);
+      if (decoder.desynced) {
+        try {
+          sock.destroy();
+        } catch {
+        }
+        return;
+      }
+      for (const f of frames) handleClientMessage(sock, f);
+    });
+    const drop = () => {
+      clients.delete(sock);
+      lastActivity = Date.now();
+    };
+    sock.on("close", drop);
+    sock.on("error", drop);
+  });
+  server.on("error", (err) => {
+    console.error("[pty-host] server error:", err.message);
+    process.exit(3);
+  });
+  server.listen(socketPath2, () => {
+    try {
+      writePidfileLocal(socketPath2);
+    } catch (err) {
+      console.error("[pty-host] pidfile write failed:", err.message);
+    }
+  });
+  const idle = setInterval(() => {
+    if (ptys.size === 0 && clients.size === 0 && Date.now() - lastActivity > IDLE_TIMEOUT_MS) {
+      cleanupAndExit(socketPath2, server);
+    }
+  }, IDLE_CHECK_MS);
+  if (typeof idle.unref === "function") idle.unref();
+}
+function writePidfileLocal(socketPath2) {
+  const target = pidfilePath(userData);
+  const tmp = `${target}.tmp`;
+  fs.writeFileSync(
+    tmp,
+    JSON.stringify({
+      pid: process.pid,
+      socketPath: socketPath2,
+      protocolVersion: PROTOCOL_VERSION,
+      startedAt: Date.now()
+    })
+  );
+  fs.renameSync(tmp, target);
+}
+function cleanupAndExit(socketPath2, server) {
+  try {
+    const pf = JSON.parse(fs.readFileSync(pidfilePath(userData), "utf8"));
+    if (pf?.pid === process.pid) fs.rmSync(pidfilePath(userData), { force: true });
+  } catch {
+  }
+  if (process.platform !== "win32") {
+    try {
+      fs.rmSync(socketPath2, { force: true });
+    } catch {
+    }
+  }
+  try {
+    server.close();
+  } catch {
+  }
+  process.exit(0);
+}
+var socketPath = socketPathFor(userData);
+process.on("uncaughtException", (err) => {
+  console.error("[pty-host] uncaught:", err);
+});
+startServer(socketPath);
+//# sourceMappingURL=pty-host.js.map
+//# sourceMappingURL=pty-host.js.map

package/dist/pty-host.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/pty-host.ts"],"names":["socketPath"],"mappings":"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","file":"pty-host.js","sourcesContent":["/**\n * Genie detached pty-host (Tier 3).\n *\n * A HEADLESS Node process — NO electron import — that owns the real node-pty\n * instances so they survive a full quit of the Electron app. The in-app\n * HostClient connects over a local socket (named pipe on Windows, unix domain\n * socket on POSIX) and proxies create/write/resize/kill; the host pushes back\n * `data`/`exit`. The host keeps its OWN scrollback ring buffer per pty so a\n * reattach AFTER a full quit can replay history.\n *\n * Launched detached by background.ts:\n *   spawn(process.execPath, [hostScript], {\n *     detached: true, stdio: 'ignore',\n *     env: { ELECTRON_RUN_AS_NODE: '1', GENIE_USERDATA: <userData>, … }\n *   }).unref()\n *\n * ELECTRON_RUN_AS_NODE makes Electron's binary run as plain Node so node-pty's\n * native ABI matches the one the app was built against (critical — a system Node\n * with a different ABI would fail to load the .node).\n *\n * Self-terminates after an idle period with zero live ptys AND no connected\n * client, so a host can never become a forever-orphan.\n */\n\nimport net from 'node:net';\nimport fs from 'node:fs';\nimport path from 'node:path';\nimport { spawn, IPty } from 'node-pty';\nimport {\n    encodeFrame,\n    FrameDecoder,\n    PROTOCOL_VERSION,\n    type ClientMessage,\n    type HostMessage,\n} from './host-protocol';\nimport { socketPathFor, pidfilePath } from './host-locate';\n\nconst SCROLLBACK_MAX = 1_000_000;\n/** Self-exit after this long with no ptys AND no connected client. */\nconst IDLE_TIMEOUT_MS = 10 * 60 * 1000;\nconst IDLE_CHECK_MS = 60 * 1000;\n\nconst userData = process.env.GENIE_USERDATA;\nif (!userData) {\n    // Without a userData path we can't write a pidfile the client can find.\n    process.exit(2);\n}\n\ninterface HostPty {\n    pty: IPty;\n    shell: string;\n    scrollback: string;\n}\n\nconst ptys = new Map<string, HostPty>();\nconst clients = new Set<net.Socket>();\nlet lastActivity = Date.now();\n\nfunction broadcast(msg: HostMessage): void {\n    const frame = encodeFrame(msg);\n    for (const sock of clients) {\n        try {\n            sock.write(frame);\n        } catch {\n            /* dropped client — close handler cleans it up */\n        }\n    }\n}\n\nfunction createPty(opts: {\n    id: string;\n    cwd: string;\n    shell?: string;\n    args?: string[];\n    cols?: number;\n    rows?: number;\n    env?: Record<string, string>;\n}): { pid: number; shell: string; existing: boolean; scrollback: string } {\n    const existing = ptys.get(opts.id);\n    if (existing) {\n        return {\n            pid: existing.pty.pid,\n            shell: existing.shell,\n            existing: true,\n            scrollback: existing.scrollback,\n        };\n    }\n    const shell = opts.shell ?? defaultShell();\n    const env = { ...process.env, ...(opts.env ?? {}) } as Record<string, string>;\n    env.TERM = env.TERM || 'xterm-256color';\n\n    const pty = spawn(shell, opts.args ?? [], {\n        name: 'xterm-color',\n        cwd: opts.cwd,\n        cols: opts.cols ?? 80,\n        rows: opts.rows ?? 24,\n        env,\n    });\n\n    const entry: HostPty = { pty, shell, scrollback: '' };\n    ptys.set(opts.id, entry);\n\n    pty.onData((data) => {\n        const next = entry.scrollback + data;\n        entry.scrollback =\n            next.length > SCROLLBACK_MAX ? next.slice(-SCROLLBACK_MAX) : next;\n        broadcast({ kind: 'data', id: opts.id, data });\n    });\n    pty.onExit(({ exitCode, signal }) => {\n        ptys.delete(opts.id);\n        broadcast({ kind: 'exit', id: opts.id, exitCode, signal });\n        lastActivity = Date.now();\n    });\n\n    return { pid: pty.pid, shell, existing: false, scrollback: '' };\n}\n\nfunction defaultShell(): string {\n    if (process.platform === 'win32') return process.env.COMSPEC ?? 'cmd.exe';\n    return process.env.SHELL ?? '/bin/bash';\n}\n\nfunction handleClientMessage(sock: net.Socket, msg: ClientMessage): void {\n    lastActivity = Date.now();\n    switch (msg.kind) {\n        case 'hello':\n            reply(sock, {\n                kind: 'hello-ok',\n                seq: msg.seq,\n                protocolVersion: PROTOCOL_VERSION,\n                pid: process.pid,\n            });\n            break;\n        case 'create': {\n            const r = createPty(msg.opts);\n            reply(sock, {\n                kind: 'created',\n                seq: msg.seq,\n                result: {\n                    id: msg.opts.id,\n                    pid: r.pid,\n                    shell: r.shell,\n                    existing: r.existing,\n                    scrollback: r.scrollback,\n                },\n            });\n            break;\n        }\n        case 'write': {\n            const e = ptys.get(msg.id);\n            if (e) e.pty.write(msg.data);\n            break;\n        }\n        case 'resize': {\n            const e = ptys.get(msg.id);\n            if (e) {\n                try {\n                    e.pty.resize(Math.max(1, msg.cols | 0), Math.max(1, msg.rows | 0));\n                } catch {\n                    /* transient 0×0 during layout */\n                }\n            }\n            break;\n        }\n        case 'kill': {\n            const e = ptys.get(msg.id);\n            if (e) {\n                try {\n                    e.pty.kill();\n                } catch {\n                    /* already exited */\n                }\n                ptys.delete(msg.id);\n            }\n            break;\n        }\n        case 'list':\n            reply(sock, {\n                kind: 'list-result',\n                seq: msg.seq,\n                terminals: Array.from(ptys.entries()).map(([id, e]) => ({\n                    id,\n                    pid: e.pty.pid,\n                    shell: e.shell,\n                })),\n            });\n            break;\n        case 'set-retained':\n            // The host keeps EVERYTHING alive across quit regardless; the\n            // retained flag is meaningful to the client (fallback/UX). The host\n            // only needs to not-die, which it doesn't. Acknowledge by no-op.\n            break;\n        case 'get-scrollback':\n            reply(sock, {\n                kind: 'scrollback-result',\n                seq: msg.seq,\n                scrollback: ptys.get(msg.id)?.scrollback ?? null,\n            });\n            break;\n        case 'ping':\n            reply(sock, { kind: 'pong', seq: msg.seq });\n            break;\n    }\n}\n\nfunction reply(sock: net.Socket, msg: HostMessage): void {\n    try {\n        sock.write(encodeFrame(msg));\n    } catch {\n        /* client gone */\n    }\n}\n\nfunction startServer(socketPath: string): void {\n    // On POSIX a stale socket file blocks bind; remove it first. (On Windows the\n    // pipe namespace handles this.)\n    if (process.platform !== 'win32') {\n        try {\n            fs.rmSync(socketPath, { force: true });\n        } catch {\n            /* ignore */\n        }\n        try {\n            fs.mkdirSync(path.dirname(socketPath), { recursive: true });\n        } catch {\n            /* ignore */\n        }\n    }\n\n    const server = net.createServer((sock) => {\n        clients.add(sock);\n        lastActivity = Date.now();\n        const decoder = new FrameDecoder();\n        sock.on('data', (chunk: Buffer) => {\n            const frames = decoder.push(chunk);\n            if (decoder.desynced) {\n                try {\n                    sock.destroy();\n                } catch {\n                    /* ignore */\n                }\n                return;\n            }\n            for (const f of frames) handleClientMessage(sock, f as ClientMessage);\n        });\n        const drop = () => {\n            clients.delete(sock);\n            lastActivity = Date.now();\n        };\n        sock.on('close', drop);\n        sock.on('error', drop);\n    });\n\n    server.on('error', (err) => {\n        // EADDRINUSE: another host beat us to it. Exit quietly — the client will\n        // connect to the winner.\n        // eslint-disable-next-line no-console\n        console.error('[pty-host] server error:', (err as Error).message);\n        process.exit(3);\n    });\n\n    server.listen(socketPath, () => {\n        try {\n            writePidfileLocal(socketPath);\n        } catch (err) {\n            // eslint-disable-next-line no-console\n            console.error('[pty-host] pidfile write failed:', (err as Error).message);\n        }\n    });\n\n    // Idle watchdog: exit when nothing is running and nobody is connected.\n    const idle = setInterval(() => {\n        if (ptys.size === 0 && clients.size === 0 && Date.now() - lastActivity > IDLE_TIMEOUT_MS) {\n            cleanupAndExit(socketPath, server);\n        }\n    }, IDLE_CHECK_MS);\n    if (typeof idle.unref === 'function') idle.unref();\n}\n\nfunction writePidfileLocal(socketPath: string): void {\n    const target = pidfilePath(userData!);\n    const tmp = `${target}.tmp`;\n    fs.writeFileSync(\n        tmp,\n        JSON.stringify({\n            pid: process.pid,\n            socketPath,\n            protocolVersion: PROTOCOL_VERSION,\n            startedAt: Date.now(),\n        }),\n    );\n    fs.renameSync(tmp, target);\n}\n\nfunction cleanupAndExit(socketPath: string, server: net.Server): void {\n    try {\n        // Only remove the pidfile if it still points at US (avoid clobbering a\n        // successor host that took over the socket).\n        const pf = JSON.parse(fs.readFileSync(pidfilePath(userData!), 'utf8'));\n        if (pf?.pid === process.pid) fs.rmSync(pidfilePath(userData!), { force: true });\n    } catch {\n        /* ignore */\n    }\n    if (process.platform !== 'win32') {\n        try {\n            fs.rmSync(socketPath, { force: true });\n        } catch {\n            /* ignore */\n        }\n    }\n    try {\n        server.close();\n    } catch {\n        /* ignore */\n    }\n    process.exit(0);\n}\n\n// --- main ------------------------------------------------------------------\n\nconst socketPath = socketPathFor(userData);\n\n// A dead-mans-switch so we don't keep a host with no shells AND no client when\n// the parent vanished without a clean disconnect: covered by the idle watchdog.\nprocess.on('uncaughtException', (err) => {\n    // eslint-disable-next-line no-console\n    console.error('[pty-host] uncaught:', err);\n});\n\nstartServer(socketPath);\n"]}

package/docs/persistence.md

@@ -0,0 +1,92 @@
+# Persistence model (T1 / T2 / T3) + OSC-7 cwd
+
+A terminal is expensive context — scrollback, the running shell, the working
+directory. `fancy-term-host` keeps that context alive across three escalating
+tiers, all switchable behind one `PtyBackend` interface so the wire code never
+changes.
+
+## The one interface
+
+Both implementations satisfy the same `PtyBackend`:
+
+- **`InProcessBackend`** — PTYs live in *this* Node process. The T1/T2 floor.
+- **`HostClient`** — PTYs live in a *detached* pty-host process (T3); every call
+  is proxied over a local socket.
+
+`create` / `write` / `resize` / `kill` / `list` / `isLive`, the Tier-2 retained
+methods, and the `data` / `exit` / `cwd` events are identical on both. The active
+backend is chosen once at startup and swapped behind the interface.
+
+## T1 — snapshot & replay
+
+On capture, a terminal's serialized state is (optionally) encrypted via your
+[`Encryptor`](./ports.md#2-encryptor--at-rest-cipher-for-snapshots-t1), gzipped,
+and written to `<baseDir>/sessions/<id>.snap` by the store from
+`createSnapshotStore({ baseDir, encryptor })`. When encryption is unavailable
+(`isAvailable() === false`) the bytes are stored as **plaintext gzip** with a
+magic marker, so the same file path round-trips either way. A cold start reads
+the snapshot back and replays it, so a reopened terminal shows where it was —
+even after a full process exit.
+
+## T2 — retained PTYs
+
+Flag a terminal with `backend.setRetained(id, true)` and its PTY is **not killed
+when the last window detaches** — the live shell keeps running and its scrollback
+replays on reattach (`getScrollback(id)`), instead of degrading to a T1 replay of
+stale state. `retainedCount()` / `retainedIds()` let a host cap how many live
+shells it keeps. A real quit still tears these down (that's what T3 is for).
+
+## T3 — detached host
+
+The **pty-host** is a separate, headless Node process that owns the PTYs and
+their scrollback ring buffers. Because it's a different process, the shells
+**survive a full quit** of your app — reopening reattaches to them live.
+
+- **Transport.** Windows: a named pipe `\\.\pipe\…-<userHash>` (per-logon-session
+  ACL). POSIX: a unix socket under `userDataDir` (`ptyhost.sock`), per-user by
+  directory perms. See `socketPathFor()`.
+- **Discovery.** A pidfile (`ptyhost.json`: `{ pid, socketPath, protocolVersion,
+  startedAt }`) lets a fresh client find a running host. `pidfileUsable()` checks
+  the pid is alive *and* the protocol version matches; a stale/dead/mismatched
+  pidfile means spawn a fresh host.
+- **Lifecycle.** `configureHostLifecycle({ spawner, settings, snapshots,
+  onHostStatus })` then `initTerminalBackend()` does connect-or-spawn-or-fall-
+  back: connect to a usable host, else spawn one via your
+  [`HostSpawner`](./ports.md#4-hostspawner--launch-the-detached-pty-host-t3), else
+  fall back to the in-process backend. T3 is gated by the `detached_terminals`
+  setting (default **off**).
+- **Self-exit.** The host shuts itself down once it owns zero PTYs and has zero
+  connected clients past an idle window, so it never lingers.
+
+## OSC-7 cwd tracking (Tier 1.5)
+
+So a resumed shell starts in the *right directory*, the host learns each
+terminal's cwd from **OSC-7** escape sequences the shell emits on every prompt:
+
+```
+ESC ] 7 ; file://HOST/PATH  (BEL | ST)
+```
+
+`scanOsc7Cwd(chunk)` parses the last such report out of raw PTY output;
+`InProcessBackend` watches its own data stream, debounces, and **emits a `cwd`
+event** (rather than writing a DB) so your adapter can persist it. Windows drive
+paths (`file:///C:/Users/...`) and percent-encoding are handled.
+
+### Injecting the prompt hook
+
+Shells don't emit OSC-7 unless told to. `cwdHookSpawn(command, settings)` returns
+the env + launch-arg additions that make each shell report its cwd — **overlaying
+your config, never replacing it** — gated by `track_cwd` (default on):
+
+| Shell | Mechanism |
+|---|---|
+| **bash** | prepends an OSC-7 `printf` to `PROMPT_COMMAND` (env only) |
+| **zsh** | generated `ZDOTDIR`; its `.zshrc` restores `ZDOTDIR`, sources your real `.zshrc`/`.zshenv`, then appends a `precmd` emitter |
+| **fish** | generated `vendor_conf.d/osc7.fish` overlaid via `XDG_DATA_DIRS` (hooks `--on-event fish_prompt`) |
+| **PowerShell** | dot-sourced profile shim wrapping your existing `prompt`, loaded via appended `-NoExit -Command ". '<shim>'"` |
+| **cmd.exe** | `PROMPT` using the `$E` escape — **best-effort**, only where the console interprets VT sequences in the prompt; otherwise degrades to the static cwd |
+
+The manager applies `cwdHookSpawn` automatically on `create()`. Generated shims
+live under `os.tmpdir()/fancy-term-host/<userHash>/`. Any shell family that can't
+be hooked returns an empty hook, and the terminal simply uses the static `cwd`
+you passed to `create()`.

package/docs/ports.md

@@ -0,0 +1,229 @@
+# Implementing the four ports
+
+`fancy-term-host`'s core is **runtime-agnostic**: it never imports `electron`, a
+database, or any host framework. Everything host-specific is injected through
+four small ports. You implement them once for your environment; the core does
+snapshot/replay, retained PTYs, the detached host, and the OSC-7 cwd hook on top.
+
+```ts
+import type {
+  SettingsProvider,
+  Encryptor,
+  SnapshotStoreConfig, // { baseDir, encryptor }
+  HostSpawner,
+} from "@particle-academy/fancy-term-host";
+```
+
+The reference implementation is Genie's Electron adapter (`genie-adapter.ts` +
+`ipc.ts` in the [genie](https://github.com/Renaissance-Analytics/genie) repo) —
+the *one* place that imports `electron` + the DB and builds these ports. The
+annotated excerpts below are drawn from it; alongside each is the **plain-Node**
+shape you'd write for a non-Electron host.
+
+---
+
+## 1. `SettingsProvider` — read-only config
+
+Gates the OSC-7 cwd hook (`track_cwd`, default on) and T3 (`detached_terminals`,
+default off), plus the default-shell resolution keys (`terminal_shell`,
+`terminal_custom_cmd`).
+
+```ts
+export interface SettingsProvider {
+  get(key: string): string | undefined;
+}
+```
+
+**Genie (over its SQLite settings table):**
+
+```ts
+export function dbSettingsProvider(): SettingsProvider {
+  return {
+    get: (key) => {
+      try {
+        return (getAllSettings() as Record<string, string | undefined>)[key];
+      } catch {
+        return undefined;       // db not ready → best-effort defaults
+      }
+    },
+  };
+}
+```
+
+**Plain Node** — a literal, env, or JSON file is enough:
+
+```ts
+const settings: SettingsProvider = {
+  get: (k) => ({ track_cwd: "on", detached_terminals: "off" })[k],
+};
+```
+
+> A missing key returns `undefined`, and the core applies its own default — so a
+> `{ get: () => undefined }` provider is a valid (all-defaults) starting point.
+
+---
+
+## 2. `Encryptor` — at-rest cipher for snapshots (T1)
+
+Wraps whatever encryption your host has. `isAvailable()` decides whether
+snapshots are encrypted or fall back to **plaintext gzip** (the store handles the
+fallback for you, exactly as before).
+
+```ts
+export interface Encryptor {
+  isAvailable(): boolean;
+  encrypt(b: Buffer): Buffer;
+  decrypt(b: Buffer): Buffer;
+}
+```
+
+**Genie (over Electron `safeStorage`):**
+
+```ts
+export function electronEncryptor(): Encryptor {
+  return {
+    isAvailable: () => {
+      try { return safeStorage.isEncryptionAvailable(); } catch { return false; }
+    },
+    encrypt: (b) => safeStorage.encryptString(b.toString("utf8")),
+    decrypt: (b) => Buffer.from(safeStorage.decryptString(b), "utf8"),
+  };
+}
+```
+
+**Plain Node** — a passthrough (plaintext) to start, or libsodium/`node:crypto`
+for real at-rest encryption:
+
+```ts
+const passthrough: Encryptor = {
+  isAvailable: () => false,   // → snapshots stored as plaintext gzip
+  encrypt: (b) => b,
+  decrypt: (b) => b,
+};
+```
+
+You don't construct the store by hand — pass `{ baseDir, encryptor }` to
+`createSnapshotStore(...)`. It appends `/sessions` under `baseDir` and writes
+`<id>.snap`, matching the historical on-disk layout.
+
+```ts
+const snapshots = createSnapshotStore({ baseDir: userDataDir, encryptor });
+```
+
+---
+
+## 3. `SnapshotStoreConfig` — where snapshots live
+
+Just the two inputs the store needs (the cipher above + a base directory). The
+store itself is the core's `createSnapshotStore`.
+
+```ts
+export interface SnapshotStoreConfig {
+  baseDir: string;     // was app.getPath("userData")
+  encryptor: Encryptor;
+}
+```
+
+**Genie** builds it once and shares the instance between the core backends and
+its quit-time snapshot flow:
+
+```ts
+snapshotStore = createSnapshotStore({
+  baseDir: app.getPath("userData"),
+  encryptor: electronEncryptor(),
+});
+```
+
+**Plain Node** — any writable directory you control:
+
+```ts
+const snapshots = createSnapshotStore({ baseDir: "/var/app/state", encryptor });
+```
+
+---
+
+## 4. `HostSpawner` — launch the detached pty-host (T3)
+
+Only three OS-specific operations are injected; the *connect-or-spawn-or-fall-
+back* logic is core.
+
+```ts
+export interface HostSpawner {
+  resolveHostScript(): string | null;          // path to the pty-host script
+  spawnDetached(scriptPath: string, env: Record<string, string>): void;
+  userDataDir(): string;                        // pidfile/socket live here
+}
+```
+
+**Genie (Electron — runs the host as plain Node via `ELECTRON_RUN_AS_NODE`):**
+
+```ts
+export function electronHostSpawner(dirname: string): HostSpawner {
+  return {
+    resolveHostScript: () => resolveHostScriptAt(dirname),
+    userDataDir: () => app.getPath("userData"),
+    spawnDetached: (scriptPath, env) => {
+      const child = spawn(process.execPath, [scriptPath], {
+        detached: true,
+        stdio: "ignore",
+        env: { ...process.env, ELECTRON_RUN_AS_NODE: "1", ...env },
+      });
+      child.unref();
+    },
+  };
+}
+```
+
+**Plain Node** — use the package's own `ptyHostScriptPath()` to locate the
+bundled host, and `process.execPath` (the node binary) to run it:
+
+```ts
+import { ptyHostScriptPath } from "@particle-academy/fancy-term-host";
+import { spawn } from "node:child_process";
+
+const hostSpawner: HostSpawner = {
+  resolveHostScript: () => ptyHostScriptPath(),
+  userDataDir: () => "/var/app/state",
+  spawnDetached: (scriptPath, env) => {
+    const child = spawn(process.execPath, [scriptPath], {
+      detached: true,
+      stdio: "ignore",
+      env: { ...process.env, ...env },
+    });
+    child.unref();
+  },
+};
+```
+
+---
+
+## Composition
+
+Wire the ports once, before spawning any terminal:
+
+```ts
+import {
+  configureInProcessBackend,
+  inProcessBackend,
+  configureHostLifecycle,
+} from "@particle-academy/fancy-term-host";
+
+// T1/T2: settings (cwd-hook gating) + snapshot store (cold-spawn restore).
+configureInProcessBackend({ settings, snapshots });
+
+// The core EMITS 'cwd' (from OSC-7) instead of writing a DB directly — subscribe
+// and persist it yourself if you want live-cwd to survive a restart.
+inProcessBackend().on("cwd", (id, cwd) => persistLiveCwd(id, cwd));
+
+// T3 (optional): spawner + settings + snapshot store + a host-status sink.
+configureHostLifecycle({
+  spawner: hostSpawner,
+  settings,
+  snapshots,
+  onHostStatus: (s) => notify(s.level, s.message),
+});
+```
+
+Genie's `wireTerminalAdapter()` is exactly this, plus DB persistence of the
+emitted `cwd` events and a `BrowserWindow` broadcast for host-status — a useful
+template for any host that needs to durably mirror live state.

package/package.json

@@ -0,0 +1,79 @@
+{
+  "name": "@particle-academy/fancy-term-host",
+  "version": "0.1.0",
+  "description": "Headless Node terminal backend for @particle-academy/fancy-term — owns the PTYs (node-pty) and the T1/T2/T3 persistence engine (snapshot+replay, retained PTYs, detached pty-host) behind four injected ports. OS-agnostic, zero hard third-party deps.",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/Particle-Academy/fancy-term-host.git"
+  },
+  "homepage": "https://github.com/Particle-Academy/fancy-term-host#readme",
+  "bugs": "https://github.com/Particle-Academy/fancy-term-host/issues",
+  "type": "module",
+  "main": "./dist/index.cjs",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "import": {
+        "types": "./dist/index.d.ts",
+        "default": "./dist/index.js"
+      },
+      "require": {
+        "types": "./dist/index.d.cts",
+        "default": "./dist/index.cjs"
+      }
+    },
+    "./pty-host": {
+      "import": "./dist/pty-host.js",
+      "require": "./dist/pty-host.cjs"
+    },
+    "./package.json": "./package.json"
+  },
+  "files": [
+    "dist",
+    "docs",
+    "README.md",
+    "LICENSE"
+  ],
+  "scripts": {
+    "build": "tsup",
+    "dev": "tsup --watch",
+    "lint": "tsc --noEmit",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "clean": "rm -rf dist",
+    "prepublishOnly": "tsup"
+  },
+  "keywords": [
+    "terminal",
+    "pty",
+    "node-pty",
+    "xterm",
+    "shell",
+    "fancy",
+    "fancy-term",
+    "human-plus",
+    "osc7",
+    "agent"
+  ],
+  "peerDependencies": {
+    "node-pty": "^1.0.0"
+  },
+  "overrides": {
+    "esbuild": "^0.28.1"
+  },
+  "devDependencies": {
+    "@types/node": "^20.0.0",
+    "node-pty": "^1.0.0",
+    "tsup": "^8.5.0",
+    "typescript": "^5.8.0",
+    "vitest": "^3.2.0"
+  },
+  "engines": {
+    "node": ">=18"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "license": "MIT"
+}