@bytetrue/byspace 0.14.6 → 0.16.0

package/node_modules/@bytetrue/server/dist/server/server/session/daemon/daemon-service-install.js

@@ -0,0 +1,182 @@
+import { spawnSync } from "node:child_process";
+import { existsSync, mkdirSync, readFileSync, rmSync, writeFileSync } from "node:fs";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import { resolveBySpaceHome } from "../../byspace-home.js";
+export function buildServerServiceSpec(home) {
+    const env = {};
+    for (const [key, value] of Object.entries(process.env)) {
+        if (key.startsWith("BYSPACE_") && value !== undefined)
+            env[key] = value;
+    }
+    env.PATH = process.env.PATH ?? "/usr/local/bin:/usr/bin:/bin:/usr/sbin:/sbin";
+    return {
+        label: "cc.cd.byspace.daemon",
+        nodePath: process.execPath,
+        // The running daemon knows its own entry: the supervisor entry resolved this
+        // process. Use the daemon-worker path via the server package root.
+        runnerEntry: resolveSelfRunnerEntry(),
+        logPath: path.join(home, "daemon.log"),
+        env,
+    };
+}
+function resolveSelfRunnerEntry() {
+    // Walk up from this module to the @bytetrue/server package root (name-checked, so
+    // it works under both src/ (tsx) and dist/ (compiled) tree shapes), then locate the
+    // supervisor entrypoint the way the CLI's resolveDaemonRunnerEntry does.
+    const here = import.meta.dirname ?? path.dirname(fileURLToPath(import.meta.url));
+    let dir = here;
+    let packageRoot = null;
+    for (let i = 0; i < 12; i += 1) {
+        const pkgPath = path.join(dir, "package.json");
+        if (existsSync(pkgPath)) {
+            const parsed = JSON.parse(readFileSync(pkgPath, "utf8"));
+            if (parsed.name === "@bytetrue/server") {
+                packageRoot = dir;
+                break;
+            }
+        }
+        const parent = path.dirname(dir);
+        if (parent === dir)
+            break;
+        dir = parent;
+    }
+    if (!packageRoot) {
+        throw new Error("Unable to locate the @bytetrue/server package root from the daemon module");
+    }
+    const distRunner = path.join(packageRoot, "dist", "scripts", "supervisor-entrypoint.js");
+    if (existsSync(distRunner))
+        return distRunner;
+    const srcRunner = path.join(packageRoot, "scripts", "supervisor-entrypoint.ts");
+    if (existsSync(srcRunner))
+        return srcRunner;
+    throw new Error("Unable to locate the supervisor entrypoint in the server package");
+}
+function escapeXml(value) {
+    return value
+        .replace(/&/g, "&amp;")
+        .replace(/</g, "&lt;")
+        .replace(/>/g, "&gt;")
+        .replace(/"/g, "&quot;");
+}
+export function renderLaunchdPlist(spec) {
+    const programArgs = [spec.nodePath, spec.runnerEntry];
+    const args = programArgs.map((a) => `    <string>${escapeXml(a)}</string>`).join("\n");
+    const envEntries = Object.entries(spec.env)
+        .map(([key, value]) => `    <key>${escapeXml(key)}</key>\n    <string>${escapeXml(value)}</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>${escapeXml(spec.label)}</string>
+  <key>ProgramArguments</key>
+  <array>
+${args}
+  </array>
+  <key>EnvironmentVariables</key>
+  <dict>
+${envEntries}
+  </dict>
+  <key>RunAtLoad</key>
+  <true/>
+  <key>KeepAlive</key>
+  <false/>
+  <key>StandardOutPath</key>
+  <string>${escapeXml(spec.logPath)}</string>
+  <key>StandardErrorPath</key>
+  <string>${escapeXml(spec.logPath)}</string>
+  <key>ProcessType</key>
+  <string>Background</string>
+</dict>
+</plist>
+`;
+}
+function launchctl(args) {
+    const result = spawnSync("launchctl", args, { encoding: "utf8", timeout: 15000 });
+    const output = `${result.stdout ?? ""}${result.stderr ?? ""}`.trim();
+    return { ok: result.status === 0, output };
+}
+/** Write the plist and load it. The daemon exits after install; launchd takes over. */
+export function installLaunchdServiceServer(spec) {
+    const home = resolveBySpaceHome();
+    const plistPath = path.join(home, "Library", "LaunchAgents", `${spec.label}.plist`);
+    mkdirSync(path.dirname(plistPath), { recursive: true });
+    writeFileSync(plistPath, renderLaunchdPlist(spec), { mode: 0o644 });
+    const uid = process.getuid?.();
+    if (uid === undefined)
+        throw new Error("cannot resolve uid for launchctl bootstrap");
+    launchctl(["bootout", `gui/${uid}/${spec.label}`]);
+    const boot = launchctl(["bootstrap", `gui/${String(uid)}`, plistPath]);
+    if (!boot.ok) {
+        throw new Error(`launchctl bootstrap failed: ${boot.output}`);
+    }
+}
+/** Stop and remove the service definition. The daemon keeps running until stopped. */
+export function uninstallLaunchdServiceServer(label) {
+    const uid = process.getuid?.();
+    if (uid !== undefined) {
+        launchctl(["bootout", `gui/${uid}/${label}`]);
+    }
+    const home = resolveBySpaceHome();
+    rmSync(path.join(home, "Library", "LaunchAgents", `${label}.plist`), { force: true });
+}
+export function installSystemdServiceServer(spec) {
+    const configHome = process.env.XDG_CONFIG_HOME ?? path.join(process.env.HOME ?? "", ".config");
+    const unitPath = path.join(configHome, "systemd", "user", `${spec.label}.service`);
+    mkdirSync(path.dirname(unitPath), { recursive: true });
+    writeFileSync(unitPath, renderSystemdUnit(spec), { mode: 0o644 });
+    const run = (args) => {
+        const result = spawnSync("systemctl", ["--user", ...args], {
+            encoding: "utf8",
+            timeout: 20000,
+        });
+        if (result.status !== 0) {
+            throw new Error(`systemctl --user ${args[0]} failed: ${result.stderr ?? result.stdout ?? ""}`);
+        }
+    };
+    run(["daemon-reload"]);
+    run(["enable", "--now", `${spec.label}.service`]);
+}
+function renderSystemdUnit(spec) {
+    const execStart = [spec.nodePath, spec.runnerEntry]
+        .map((part) => part.replace(/([\\"])/g, "\\$1"))
+        .join(" ");
+    const envLines = Object.entries(spec.env)
+        .map(([key, value]) => `Environment="${key}=${value.replace(/([\\"])/g, "\\$1")}"`)
+        .join("\n");
+    return `# Generated by the BySpace daemon (install-service). Edits are overwritten on reinstall.
+[Unit]
+Description=BySpace daemon
+After=network-online.target
+
+[Service]
+Type=exec
+ExecStart=${execStart}
+${envLines}
+Restart=on-failure
+RestartSec=5
+
+[Install]
+WantedBy=default.target
+`;
+}
+export function uninstallSystemdServiceServer(label) {
+    const run = (args) => {
+        spawnSync("systemctl", ["--user", ...args], { encoding: "utf8", timeout: 20000 });
+    };
+    run(["disable", "--now", `${label}.service`]);
+    const configHome = process.env.XDG_CONFIG_HOME ?? path.join(process.env.HOME ?? "", ".config");
+    rmSync(path.join(configHome, "systemd", "user", `${label}.service`), { force: true });
+    run(["daemon-reload"]);
+}
+export function uninstallWindowsTaskServer(label) {
+    spawnSync("powershell.exe", [
+        "-NoProfile",
+        "-NonInteractive",
+        "-Command",
+        `Unregister-ScheduledTask -TaskPath '\\BySpace\\' -TaskName '${label}' -Confirm:$false -ErrorAction SilentlyContinue`,
+    ], { encoding: "utf8", timeout: 30000 });
+}
+//# sourceMappingURL=daemon-service-install.js.map

package/node_modules/@bytetrue/server/dist/server/server/session/daemon/daemon-service-manager.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Daemon-side OS service management (issue 043). The daemon manages its own service
+ * registration because install requires the daemon's install-origin context — the
+ * npm-global verification and the runner entry resolution live in this process.
+ *
+ * KeepAlive/Restart is deliberately not "always": `byspace daemon stop` must stay a
+ * real stop. The supervisor's own crash-restart handles worker failures.
+ */
+export declare const DAEMON_SERVICE_LABEL = "cc.cd.byspace.daemon";
+export type DaemonServiceState = "not-installed" | "installed-stopped" | "installed-running-not-this-process" | "managed-by-service" | "unknown";
+export interface DaemonServiceView {
+    state: DaemonServiceState;
+    label: string;
+    /** Linux only: whether the user manager survives logout (systemd linger). */
+    linger?: boolean;
+}
+/** Guard: only a daemon from the published npm global install may self-register. */
+export declare function validateServiceOriginSync(): string | null;
+/** Query the current service view. Never caches: each call re-probes the manager. */
+export declare function queryDaemonServiceView(): DaemonServiceView;
+//# sourceMappingURL=daemon-service-manager.d.ts.map

package/node_modules/@bytetrue/server/dist/server/server/session/daemon/daemon-service-manager.js

@@ -0,0 +1,154 @@
+import { execFileSync } from "node:child_process";
+import { existsSync, readFileSync } from "node:fs";
+import { BYSPACE_CLI_PACKAGE } from "./npm-global-cli.js";
+import path from "node:path";
+import { validateDaemonInstallOrigin, daemonInstallOriginRuntime } from "./install-origin.js";
+/**
+ * Daemon-side OS service management (issue 043). The daemon manages its own service
+ * registration because install requires the daemon's install-origin context — the
+ * npm-global verification and the runner entry resolution live in this process.
+ *
+ * KeepAlive/Restart is deliberately not "always": `byspace daemon stop` must stay a
+ * real stop. The supervisor's own crash-restart handles worker failures.
+ */
+export const DAEMON_SERVICE_LABEL = "cc.cd.byspace.daemon";
+function launchdProbe(home) {
+    const plistPath = path.join(home, "Library", "LaunchAgents", `${DAEMON_SERVICE_LABEL}.plist`);
+    return {
+        definitionExists: () => existsSync(plistPath),
+        servicePid: () => {
+            try {
+                const uid = process.getuid?.();
+                if (uid === undefined)
+                    return null;
+                const output = execFileSync("launchctl", ["print", `gui/${uid}/${DAEMON_SERVICE_LABEL}`], {
+                    encoding: "utf8",
+                    timeout: 10000,
+                });
+                const match = output.match(/^\s*pid\s*=\s*(\d+)/m);
+                return match ? Number(match[1]) : null;
+            }
+            catch {
+                return null;
+            }
+        },
+        viewFlags: () => ({}),
+    };
+}
+function systemdProbe() {
+    const configHome = process.env.XDG_CONFIG_HOME ?? path.join(process.env.HOME ?? "", ".config");
+    const unitPath = path.join(configHome, "systemd", "user", `${DAEMON_SERVICE_LABEL}.service`);
+    return {
+        definitionExists: () => existsSync(unitPath),
+        servicePid: () => {
+            try {
+                const output = execFileSync("systemctl", ["--user", "show", `${DAEMON_SERVICE_LABEL}.service`, "--property", "MainPID"], { encoding: "utf8", timeout: 10000 });
+                const match = output.match(/^MainPID=(\d+)$/m);
+                const pid = match ? Number(match[1]) : 0;
+                return pid > 0 ? pid : null;
+            }
+            catch {
+                return null;
+            }
+        },
+        viewFlags: () => {
+            try {
+                const output = execFileSync("loginctl", ["show-user", process.env.USER ?? "", "--property", "Linger"], { encoding: "utf8", timeout: 10000 });
+                return { linger: /Linger=yes/.test(output) };
+            }
+            catch {
+                return {};
+            }
+        },
+    };
+}
+function windowsProbe() {
+    return {
+        definitionExists: () => {
+            try {
+                const output = execFileSync("powershell.exe", [
+                    "-NoProfile",
+                    "-NonInteractive",
+                    "-Command",
+                    `(Get-ScheduledTask -TaskPath '\\BySpace\\' -TaskName '${DAEMON_SERVICE_LABEL}' -ErrorAction SilentlyContinue) -ne $null`,
+                ], { encoding: "utf8", timeout: 15000 });
+                return output.trim() === "True";
+            }
+            catch {
+                return false;
+            }
+        },
+        servicePid: () => null,
+        viewFlags: () => ({}),
+    };
+}
+function probeForPlatform() {
+    switch (process.platform) {
+        case "darwin":
+            return launchdProbe(resolveBySpaceHomeForService());
+        case "linux":
+            return systemdProbe();
+        case "win32":
+            return windowsProbe();
+        default:
+            return null;
+    }
+}
+function resolveBySpaceHomeForService() {
+    return process.env.BYSPACE_HOME ?? path.join(process.env.HOME ?? "", ".byspace");
+}
+/** Guard: only a daemon from the published npm global install may self-register. */
+export function validateServiceOriginSync() {
+    if (existsSync("/.dockerenv") || existsSync("/run/.containerenv")) {
+        return "Registering a service is not supported inside Docker. Use the container runtime's restart policy instead.";
+    }
+    // The npm -g listing is the authoritative origin: it proves the published install
+    // exists on this host. validateDaemonInstallOrigin then checks that THIS daemon
+    // process actually runs from it — a dev checkout parses fine but fails the
+    // package-root containment check, which is exactly the guard that matters here.
+    try {
+        const npmPrefix = execFileSync("npm", ["prefix", "-g"], {
+            encoding: "utf8",
+            timeout: 15000,
+        }).trim();
+        const packagePath = path.join(npmPrefix, "lib", "node_modules", "@bytetrue", "byspace");
+        const pkgJsonPath = path.join(packagePath, "package.json");
+        if (!existsSync(pkgJsonPath)) {
+            return `${BYSPACE_CLI_PACKAGE} is not installed with npm -g on this host`;
+        }
+        const version = JSON.parse(readFileSync(pkgJsonPath, "utf8")).version ?? "";
+        const install = {
+            version,
+            packagePath,
+            globalRootPath: npmPrefix,
+            isLinked: false,
+        };
+        return validateDaemonInstallOrigin(install, process.env.npm_package_version ?? version, daemonInstallOriginRuntime);
+    }
+    catch (error) {
+        return error instanceof Error ? error.message : String(error);
+    }
+}
+/** Query the current service view. Never caches: each call re-probes the manager. */
+export function queryDaemonServiceView() {
+    const probe = probeForPlatform();
+    if (!probe) {
+        return { state: "unknown", label: DAEMON_SERVICE_LABEL };
+    }
+    if (!probe.definitionExists()) {
+        return { state: "not-installed", label: DAEMON_SERVICE_LABEL, ...probe.viewFlags() };
+    }
+    const servicePid = probe.servicePid();
+    if (servicePid === null) {
+        return { state: "installed-stopped", label: DAEMON_SERVICE_LABEL, ...probe.viewFlags() };
+    }
+    if (servicePid === process.pid) {
+        return { state: "managed-by-service", label: DAEMON_SERVICE_LABEL, ...probe.viewFlags() };
+    }
+    return {
+        state: "installed-running-not-this-process",
+        label: DAEMON_SERVICE_LABEL,
+        ...probe.viewFlags(),
+    };
+}
+//# sourceMappingURL=daemon-service-manager.js.map

package/node_modules/@bytetrue/server/dist/server/server/websocket-server.js

@@ -1170,6 +1170,8 @@ export class DaemonWebSocketServer {
                 agentConfigApply: true,
                 // COMPAT(daemonNetworkConfig): added in v0.14.3, remove gate after 2027-07-14.
                 daemonNetworkConfig: true,
+                // COMPAT(daemonServiceInstall): added in v0.14.7, remove gate after 2027-09-20.
+                daemonServiceInstall: true,
             },
         };
     }

package/node_modules/@bytetrue/server/dist/server/terminal/agent-hooks/pi/pi-extension.d.ts

@@ -1,2 +1,2 @@
-export declare const PI_TERMINAL_ACTIVITY_EXTENSION_SOURCE = "// byspace.pi-terminal-activity\nconst ownerPidKey = \"BYSPACE_PI_TERMINAL_HOOK_OWNER_PID\";\n\n// Keep one request in flight and only the latest state waiting behind it.\nexport function createReportQueue(sendReport) {\n  let pendingReport;\n  let reporting;\n\n  async function flushReports() {\n    while (pendingReport) {\n      const next = pendingReport;\n      pendingReport = undefined;\n      try {\n        await sendReport(next);\n      } catch {}\n    }\n    reporting = undefined;\n  }\n\n  return {\n    enqueue(next) {\n      pendingReport = next;\n      reporting ??= Promise.resolve().then(flushReports);\n      return reporting;\n    },\n    wait() {\n      return reporting ?? Promise.resolve();\n    },\n  };\n}\n\nasync function sendReport(next) {\n  await fetch(next.url, {\n    method: \"POST\",\n    headers: { \"content-type\": \"application/json\" },\n    body: JSON.stringify({\n      terminalId: next.terminalId,\n      token: next.token,\n      state: next.state,\n    }),\n    signal: AbortSignal.timeout(1_000),\n  });\n}\n\nconst reportQueue = createReportQueue(sendReport);\n\nfunction report(state) {\n  const url =\n    process.env.BYSPACE_TERMINAL_ACTIVITY_URL;\n  const terminalId = process.env.BYSPACE_TERMINAL_ID;\n  const token = process.env.BYSPACE_ACTIVITY_TOKEN;\n  if (!url || !terminalId || !token) return reportQueue.wait();\n\n  return reportQueue.enqueue({ url, terminalId, token, state });\n}\n\nexport default function byspaceTerminalActivity(pi) {\n  const ownerPid = process.env[ownerPidKey];\n  if (ownerPid && ownerPid !== String(process.pid)) return;\n  process.env[ownerPidKey] = String(process.pid);\n\n  pi.on(\"agent_start\", () => void report(\"running\"));\n  pi.on(\"ui_prompt_start\", () => void report(\"needs-input\"));\n  pi.on(\"ui_prompt_end\", () => void report(\"running\"));\n  pi.on(\"agent_settled\", () => void report(\"idle\"));\n  pi.on(\"session_shutdown\", () => report(\"idle\"));\n}\n";
+export declare const PI_TERMINAL_ACTIVITY_EXTENSION_SOURCE = "// byspace.pi-terminal-activity\nconst ownerPidKey = \"BYSPACE_PI_TERMINAL_HOOK_OWNER_PID\";\n\n// Keep one request in flight and only the latest state waiting behind it.\nexport function createReportQueue(sendReport) {\n  let pendingReport;\n  let reporting;\n\n  async function flushReports() {\n    while (pendingReport) {\n      const next = pendingReport;\n      pendingReport = undefined;\n      try {\n        await sendReport(next);\n      } catch {}\n    }\n    reporting = undefined;\n  }\n\n  return {\n    enqueue(next) {\n      pendingReport = next;\n      reporting ??= Promise.resolve().then(flushReports);\n      return reporting;\n    },\n    wait() {\n      return reporting ?? Promise.resolve();\n    },\n  };\n}\n\nasync function sendReport(next) {\n  await fetch(next.url, {\n    method: \"POST\",\n    headers: { \"content-type\": \"application/json\" },\n    body: JSON.stringify({\n      terminalId: next.terminalId,\n      token: next.token,\n      state: next.state,\n    }),\n    signal: AbortSignal.timeout(1_000),\n  });\n}\n\nconst reportQueue = createReportQueue(sendReport);\n\n// The marker is inherited by Pi child processes so they do not register a second\n// reporter for the same terminal. A marker left by a process that is gone is\n// stale, not an owner: treating it as an owner makes this Pi report nothing at\n// all, which looks exactly like \"the terminal stopped showing running\".\nfunction ownerIsLive(ownerPid) {\n  const pid = Number(ownerPid);\n  if (!Number.isInteger(pid) || pid <= 0) return false;\n  try {\n    process.kill(pid, 0);\n    return true;\n  } catch (error) {\n    return error?.code === \"EPERM\";\n  }\n}\n\nfunction report(state) {\n  const url =\n    process.env.BYSPACE_TERMINAL_ACTIVITY_URL;\n  const terminalId = process.env.BYSPACE_TERMINAL_ID;\n  const token = process.env.BYSPACE_ACTIVITY_TOKEN;\n  if (!url || !terminalId || !token) return reportQueue.wait();\n\n  return reportQueue.enqueue({ url, terminalId, token, state });\n}\n\nexport default function byspaceTerminalActivity(pi) {\n  const ownerPid = process.env[ownerPidKey];\n  if (ownerPid && ownerPid !== String(process.pid) && ownerIsLive(ownerPid)) return;\n  process.env[ownerPidKey] = String(process.pid);\n\n  pi.on(\"agent_start\", () => void report(\"running\"));\n  pi.on(\"ui_prompt_start\", () => void report(\"needs-input\"));\n  pi.on(\"ui_prompt_end\", () => void report(\"running\"));\n  pi.on(\"agent_settled\", () => void report(\"idle\"));\n  pi.on(\"session_shutdown\", () => report(\"idle\"));\n}\n";
 //# sourceMappingURL=pi-extension.d.ts.map

package/node_modules/@bytetrue/server/dist/server/terminal/agent-hooks/pi/pi-extension.js

@@ -44,6 +44,21 @@ async function sendReport(next) {
 
 const reportQueue = createReportQueue(sendReport);
 
+// The marker is inherited by Pi child processes so they do not register a second
+// reporter for the same terminal. A marker left by a process that is gone is
+// stale, not an owner: treating it as an owner makes this Pi report nothing at
+// all, which looks exactly like "the terminal stopped showing running".
+function ownerIsLive(ownerPid) {
+  const pid = Number(ownerPid);
+  if (!Number.isInteger(pid) || pid <= 0) return false;
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (error) {
+    return error?.code === "EPERM";
+  }
+}
+
 function report(state) {
   const url =
     process.env.BYSPACE_TERMINAL_ACTIVITY_URL;
@@ -56,7 +71,7 @@ function report(state) {
 
 export default function byspaceTerminalActivity(pi) {
   const ownerPid = process.env[ownerPidKey];
-  if (ownerPid && ownerPid !== String(process.pid)) return;
+  if (ownerPid && ownerPid !== String(process.pid) && ownerIsLive(ownerPid)) return;
   process.env[ownerPidKey] = String(process.pid);
 
   pi.on("agent_start", () => void report("running"));

package/node_modules/@bytetrue/server/dist/server/terminal/terminal.js

@@ -786,6 +786,12 @@ export async function createTerminal(options) {
         if (!commandFinished) {
             return true;
         }
+        // The interactive shell only emits this when its foreground job ends. A
+        // terminal agent that exits without reporting idle (SIGKILL, crash, a
+        // suspend that never resumes) leaves `working` set forever, so treat the
+        // shell regaining the prompt as proof that the agent is gone. `interrupt`
+        // only clears `working`; a finished-attention idle state is untouched.
+        activityTracker.interrupt();
         for (const listener of Array.from(commandFinishedListeners)) {
             try {
                 listener(commandFinished);