@event4u/agent-switch 1.0.0

package/dist/service.js

@@ -0,0 +1,223 @@
+/**
+ * Background-service control + per-OS installers.
+ *
+ * `service run` is the foreground loop (for debuggers and service managers);
+ * `start/stop/status` manage a detached background process; `install/uninstall`
+ * wire the OS's user-level autostart (launchd LaunchAgent, systemd --user unit,
+ * Windows Task Scheduler logon task) and record every generated file in a
+ * manifest so uninstall removes exactly what was installed.
+ *
+ * The per-OS file generators are pure (golden-tested). Registration is the only
+ * OS-integration step.
+ */
+import { spawn, spawnSync } from "node:child_process";
+import * as fs from "node:fs";
+import * as os from "node:os";
+import * as path from "node:path";
+import { fileURLToPath } from "node:url";
+import { ROOT, die } from "./profiles.js";
+import { readDaemonState, readPid, processAlive } from "./daemon.js";
+import { runDaemon } from "./daemon.js";
+const LABEL = "com.event4u.agent-switch";
+const LOG = path.join(ROOT, "daemon.log");
+const MANIFEST = path.join(ROOT, "service-manifest.json");
+const LOG_CAP_BYTES = 1_000_000; // 1 MB, single-generation rotation
+/** The command a service manager runs: this node + this index.js + `service run`. */
+function runInvocation() {
+    const index = path.join(path.dirname(fileURLToPath(import.meta.url)), "index.js");
+    return { exec: process.execPath, args: [index, "service", "run"] };
+}
+// ---------- per-OS service files (pure, golden-tested) ----------
+export function launchdPlist(exec, args, log, label = LABEL) {
+    const argv = [exec, ...args].map((a) => `    <string>${a}</string>`).join("\n");
+    return `<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+  <key>Label</key><string>${label}</string>
+  <key>ProgramArguments</key>
+  <array>
+${argv}
+  </array>
+  <key>RunAtLoad</key><true/>
+  <key>KeepAlive</key><true/>
+  <key>StandardOutPath</key><string>${log}</string>
+  <key>StandardErrorPath</key><string>${log}</string>
+</dict>
+</plist>
+`;
+}
+export function systemdUnit(exec, args) {
+    return `[Unit]
+Description=agent-switch usage daemon
+After=network-online.target
+
+[Service]
+Type=simple
+ExecStart=${exec} ${args.join(" ")}
+Restart=on-failure
+RestartSec=30
+
+[Install]
+WantedBy=default.target
+`;
+}
+/** Args for `schtasks /create` registering a logon-triggered task. */
+export function schtasksCreateArgs(exec, args, label = LABEL) {
+    const cmd = `"${exec}" ${args.map((a) => `"${a}"`).join(" ")}`;
+    return ["/create", "/tn", label, "/tr", cmd, "/sc", "onlogon", "/f"];
+}
+// ---------- manifest ----------
+function readManifest() {
+    try {
+        const d = JSON.parse(fs.readFileSync(MANIFEST, "utf8"));
+        return Array.isArray(d?.files) ? d.files : [];
+    }
+    catch {
+        return [];
+    }
+}
+function writeManifest(files) {
+    fs.mkdirSync(ROOT, { recursive: true });
+    fs.writeFileSync(MANIFEST, JSON.stringify({ label: LABEL, files }, null, 2) + "\n", { mode: 0o600 });
+}
+// ---------- install / uninstall ----------
+export function serviceInstall() {
+    const { exec, args } = runInvocation();
+    fs.mkdirSync(ROOT, { recursive: true });
+    if (process.platform === "darwin") {
+        const plist = path.join(os.homedir(), "Library", "LaunchAgents", `${LABEL}.plist`);
+        fs.mkdirSync(path.dirname(plist), { recursive: true });
+        fs.writeFileSync(plist, launchdPlist(exec, args, LOG));
+        spawnSync("launchctl", ["unload", plist], { stdio: "ignore" }); // idempotent
+        const r = spawnSync("launchctl", ["load", plist], { encoding: "utf8" });
+        if (r.status !== 0)
+            die(`launchctl load failed: ${r.stderr || r.stdout}`);
+        writeManifest([plist]);
+        console.log(`Installed LaunchAgent ${plist} (loaded).`);
+    }
+    else if (process.platform === "linux") {
+        const unit = path.join(os.homedir(), ".config", "systemd", "user", "agent-switch.service");
+        fs.mkdirSync(path.dirname(unit), { recursive: true });
+        fs.writeFileSync(unit, systemdUnit(exec, args));
+        spawnSync("systemctl", ["--user", "daemon-reload"], { stdio: "ignore" });
+        const r = spawnSync("systemctl", ["--user", "enable", "--now", "agent-switch.service"], { encoding: "utf8" });
+        if (r.status !== 0)
+            console.log(`(note: \`systemctl --user enable --now\` returned nonzero — unit written to ${unit}; enable manually if needed)`);
+        writeManifest([unit]);
+        console.log(`Installed systemd user unit ${unit}.`);
+    }
+    else if (process.platform === "win32") {
+        const r = spawnSync("schtasks", schtasksCreateArgs(exec, args), { encoding: "utf8" });
+        if (r.status !== 0)
+            die(`schtasks /create failed: ${r.stderr || r.stdout}`);
+        writeManifest([`schtasks:${LABEL}`]); // a task, not a file
+        console.log(`Installed Task Scheduler logon task ${LABEL}.`);
+    }
+    else {
+        die(`service install is not supported on ${process.platform}`);
+    }
+}
+export function serviceUninstall() {
+    const files = readManifest();
+    if (process.platform === "darwin") {
+        for (const f of files) {
+            spawnSync("launchctl", ["unload", f], { stdio: "ignore" });
+            fs.rmSync(f, { force: true });
+        }
+    }
+    else if (process.platform === "linux") {
+        spawnSync("systemctl", ["--user", "disable", "--now", "agent-switch.service"], { stdio: "ignore" });
+        for (const f of files)
+            fs.rmSync(f, { force: true });
+        spawnSync("systemctl", ["--user", "daemon-reload"], { stdio: "ignore" });
+    }
+    else if (process.platform === "win32") {
+        spawnSync("schtasks", ["/delete", "/tn", LABEL, "/f"], { stdio: "ignore" });
+    }
+    fs.rmSync(MANIFEST, { force: true });
+    console.log(files.length ? `Uninstalled service (removed: ${files.join(", ")}).` : "Nothing installed.");
+}
+// ---------- log rotation ----------
+/** Single-generation rotation: when the log exceeds the cap, move it to `.1`
+ *  (overwriting any previous `.1`) and start fresh. */
+export function rotateLog(logFile = LOG, capBytes = LOG_CAP_BYTES) {
+    try {
+        if (fs.statSync(logFile).size > capBytes)
+            fs.renameSync(logFile, logFile + ".1");
+    }
+    catch {
+        /* no log yet */
+    }
+}
+// ---------- start / stop / status ----------
+export function serviceRun() {
+    rotateLog();
+    void runDaemon();
+}
+export function serviceStart() {
+    const pid = readPid();
+    if (pid && processAlive(pid)) {
+        console.log(`Daemon already running (pid ${pid}).`);
+        return;
+    }
+    rotateLog();
+    const { exec, args } = runInvocation();
+    const out = fs.openSync(LOG, "a");
+    const child = spawn(exec, args, { detached: true, stdio: ["ignore", out, out] });
+    child.unref();
+    console.log(`Started daemon (pid ${child.pid}). Logs: ${LOG}`);
+}
+export function serviceStop() {
+    const pid = readPid();
+    if (!pid || !processAlive(pid)) {
+        console.log("Daemon is not running.");
+        return;
+    }
+    try {
+        process.kill(pid, "SIGTERM");
+        console.log(`Sent SIGTERM to daemon (pid ${pid}).`);
+    }
+    catch (err) {
+        die(`failed to stop daemon: ${err?.message ?? err}`);
+    }
+}
+export function serviceStatus() {
+    const pid = readPid();
+    const running = pid !== null && processAlive(pid);
+    console.log(running ? `Daemon: running (pid ${pid})` : "Daemon: not running");
+    const state = readDaemonState();
+    if (state) {
+        console.log(`  last poll: ${state.lastPoll ?? "never"}`);
+        console.log(`  poll interval: ${Math.round(state.pollIntervalMs / 1000)}s`);
+        console.log(`  cached profiles: ${Object.keys(state.profiles).join(", ") || "none"}`);
+        if (state.lastError)
+            console.log(`  last error: ${state.lastError}`);
+    }
+    else {
+        console.log("  (no daemon-state.json yet)");
+    }
+    try {
+        const lines = fs.readFileSync(LOG, "utf8").trimEnd().split("\n");
+        const tail = lines.slice(-5);
+        if (tail.length && tail[0]) {
+            console.log("  recent log:");
+            for (const l of tail)
+                console.log(`    ${l}`);
+        }
+    }
+    catch {
+        /* no log */
+    }
+}
+export function cmdService(sub) {
+    switch (sub) {
+        case "run": return serviceRun();
+        case "start": return serviceStart();
+        case "stop": return serviceStop();
+        case "status": return serviceStatus();
+        case "install": return serviceInstall();
+        case "uninstall": return serviceUninstall();
+        default: die("usage: agent-switch service run|start|stop|status|install|uninstall");
+    }
+}

package/dist/session-preview.js

@@ -0,0 +1,163 @@
+/**
+ * Session preview — the SECOND sanctioned transcript reader, alongside
+ * `src/telemetry.ts` (roadmap: road-to-agent-switch-statusline-usage does NOT
+ * own this; it is sanctioned by ADR-002, which reopens the "transcripts are
+ * opaque" lock of road-to-session-handoff for a bounded, read-only preview).
+ *
+ * Iron rule amendment (ADR-002): transcripts remain OPAQUE, version-unstable
+ * blobs *for transfer* (see sessions.ts — takeover never parses beyond line 1).
+ * Two read-only exceptions now exist, and ONLY these two: telemetry
+ * (context/token counts, telemetry.ts) and this preview (the first few
+ * conversation turns, for the GUI Sessions list). Both obey the same discipline:
+ *   1. capped read      — only the first PREVIEW_BYTE_CAP bytes (the HEAD, in
+ *                         contrast to telemetry's tail), never the whole file.
+ *   2. fenced parse     — every line parse is try/caught; a malformed line is
+ *                         skipped, never thrown.
+ *   3. degraded mode    — an unreadable / empty / bodyless transcript returns
+ *                         null, never an exception (the caller shows nothing).
+ *   4. bounded output   — at most PREVIEW_MAX_MESSAGES turns, each truncated to
+ *                         PREVIEW_TEXT_CAP chars; tool noise + meta lines dropped.
+ *
+ * Zero deps (node built-ins only). Pure + fixture-tested. Own-session only —
+ * this reads a session's OWN early turns, never a cross-account view. Claude
+ * only: the codex rollout blob is opaque + often .zst-compressed, so a codex
+ * preview is deferred (readCodexPreview returns null by construction).
+ *
+ * Ground truth (a real claude 2.1.x transcript): each JSONL line carries a
+ * `type` (`user` | `assistant` | `attachment` | `mode` | `file-history-snapshot`
+ * | …). A conversational line is `type:"user"|"assistant"` with
+ * `message.content` that is either a string or an array of blocks
+ * `{ type:"text", text } | { type:"tool_use"|"tool_result"|"thinking"|"image", … }`.
+ * Only `text` blocks carry human-readable content; everything else is skipped.
+ */
+import * as fs from "node:fs";
+/** Bytes read from the START of a transcript. The first turns live at the head;
+ *  capping keeps a preview read cheap even on a multi-MB transcript. */
+export const PREVIEW_BYTE_CAP = 128 * 1024;
+/** Most conversation turns a preview ever carries. */
+export const PREVIEW_MAX_MESSAGES = 6;
+/** Per-turn character cap; longer turns are truncated with an ellipsis. */
+export const PREVIEW_TEXT_CAP = 240;
+/** Read the first `cap` bytes of a file as complete lines. When the file is
+ *  larger than the cap the last (partial) line is dropped. Returns
+ *  { lines, capped } — capped signals the head did not reach EOF. Never throws. */
+export function headLines(file, cap = PREVIEW_BYTE_CAP) {
+    let fd;
+    try {
+        fd = fs.openSync(file, "r");
+    }
+    catch {
+        return { lines: [], capped: false };
+    }
+    try {
+        const size = fs.fstatSync(fd).size;
+        const len = Math.min(size, cap);
+        const buf = Buffer.alloc(len);
+        fs.readSync(fd, buf, 0, len, 0);
+        const text = buf.toString("utf8");
+        const capped = size > cap;
+        const lines = text.split("\n");
+        // If we stopped short of EOF, the final line is partial — drop it.
+        if (capped && lines.length > 0)
+            lines.pop();
+        return { lines: lines.filter((l) => l.length > 0), capped };
+    }
+    catch {
+        return { lines: [], capped: false };
+    }
+    finally {
+        fs.closeSync(fd);
+    }
+}
+/** Human-readable text out of a message `content` field (string or block array).
+ *  Only `text` blocks contribute; tool_use / tool_result / thinking / image are
+ *  ignored. Returns "" when there is no textual content. */
+export function extractText(content) {
+    if (typeof content === "string")
+        return content;
+    if (!Array.isArray(content))
+        return "";
+    const parts = [];
+    for (const block of content) {
+        if (block && typeof block === "object" && block.type === "text") {
+            const t = block.text;
+            if (typeof t === "string")
+                parts.push(t);
+        }
+    }
+    return parts.join("\n");
+}
+/** Strip the wrapper tags Claude Code injects into user turns (slash-command
+ *  envelopes, system reminders, local-command output) so a preview shows the
+ *  human's words, not machinery. Whitespace-collapsed. */
+export function cleanText(raw) {
+    return raw
+        // Drop whole tag blocks that carry machine content (can be large).
+        .replace(/<system-reminder>[\s\S]*?<\/system-reminder>/gi, " ")
+        .replace(/<local-command-(?:stdout|stderr)>[\s\S]*?<\/local-command-(?:stdout|stderr)>/gi, " ")
+        .replace(/<user-prompt-submit-hook>[\s\S]*?<\/user-prompt-submit-hook>/gi, " ")
+        // Drop the slash-command envelope tags but keep any surrounding words.
+        .replace(/<\/?command-(?:message|name|args)>/gi, " ")
+        .replace(/\s+/g, " ")
+        .trim();
+}
+function truncate(text, cap) {
+    if (text.length <= cap)
+        return { text, cut: false };
+    return { text: text.slice(0, cap).trimEnd() + "…", cut: true };
+}
+/**
+ * The first few conversational turns of a Claude transcript, for the GUI
+ * preview. Walks the capped head forward, keeping `user`/`assistant` turns that
+ * carry visible text (tool-only turns, attachments, and meta lines are skipped),
+ * up to PREVIEW_MAX_MESSAGES, each truncated to PREVIEW_TEXT_CAP. Returns null
+ * when the transcript yields no visible turn (degraded mode — caller shows
+ * nothing). Never throws.
+ */
+export function readClaudePreview(file, opts = {}) {
+    const maxMessages = opts.maxMessages ?? PREVIEW_MAX_MESSAGES;
+    const textCap = opts.textCap ?? PREVIEW_TEXT_CAP;
+    const { lines, capped } = headLines(file, opts.cap ?? PREVIEW_BYTE_CAP);
+    if (lines.length === 0)
+        return null;
+    const messages = [];
+    let moreAvailable = capped;
+    for (const line of lines) {
+        let o;
+        try {
+            o = JSON.parse(line);
+        }
+        catch {
+            continue; // fenced — malformed line never fails a preview
+        }
+        if (o?.type !== "user" && o?.type !== "assistant")
+            continue;
+        const msg = o.message;
+        if (!msg || typeof msg !== "object")
+            continue;
+        const role = o.type; // "user" | "assistant"
+        const cleaned = role === "user" ? cleanText(extractText(msg.content)) : extractText(msg.content).trim();
+        if (cleaned.length === 0)
+            continue; // tool-only / attachment-only turn
+        if (messages.length >= maxMessages) {
+            moreAvailable = true;
+            break;
+        }
+        const { text, cut } = truncate(cleaned, textCap);
+        if (cut)
+            moreAvailable = true;
+        messages.push({ role, text });
+    }
+    if (messages.length === 0)
+        return null;
+    return { messages, truncated: moreAvailable };
+}
+/** Codex preview is deferred (opaque, often .zst-compressed rollout blob). Null
+ *  by construction so the dispatcher + caller degrade cleanly. */
+export function readCodexPreview(_file) {
+    return null;
+}
+/** Provider-dispatching preview reader. Codex → null (deferred). */
+export function readPreview(provider, file, opts = {}) {
+    return provider === "codex" ? readCodexPreview(file) : readClaudePreview(file, opts);
+}