@infomity/remogent 0.0.0-stage → 0.2.0

package/dist/server.js

@@ -0,0 +1,161 @@
+import { timingSafeEqual } from "node:crypto";
+import { createServer } from "node:https";
+import { WebSocketServer } from "ws";
+import { PROTOCOL_VERSION, ProtocolError, parseClientMessage } from "./protocol.js";
+import { SessionManager } from "./sessions.js";
+export { PROTOCOL_VERSION };
+function tokenMatches(expected, provided) {
+    if (!provided)
+        return false;
+    const a = Buffer.from(expected);
+    const b = Buffer.from(provided);
+    return a.length === b.length && timingSafeEqual(a, b);
+}
+function bearerFrom(req) {
+    const header = req.headers["authorization"];
+    if (header?.startsWith("Bearer "))
+        return header.slice(7);
+    // Fallback for clients that cannot set headers on the WS handshake.
+    const proto = req.headers["sec-websocket-protocol"];
+    if (typeof proto === "string") {
+        const part = proto.split(",").map((s) => s.trim()).find((s) => s.startsWith("remogent.token."));
+        if (part)
+            return part.slice("remogent.token.".length);
+    }
+    return undefined;
+}
+async function handleMessage(msg, sessions, viewer, ws) {
+    switch (msg.type) {
+        case "ping":
+            viewer.send({ type: "pong", t: msg.t ?? Date.now() });
+            return;
+        case "client_hello":
+            if (msg.protocol > PROTOCOL_VERSION) {
+                viewer.send({ type: "error", code: "invalid_message", message: `host speaks protocol ${PROTOCOL_VERSION}` });
+                ws.close(1002, "protocol version");
+            }
+            return;
+        case "session_create": {
+            const session = await sessions.create(msg.engine, msg.cwd, msg.permissionMode, msg.reqId);
+            viewer.send({ type: "session_created", reqId: msg.reqId, session });
+            return;
+        }
+        case "session_list":
+            sessions.addListener(viewer);
+            viewer.send({ type: "session_list", reqId: msg.reqId, sessions: sessions.list() });
+            return;
+        case "session_resume":
+            // Resume of exited engines arrives with the adapters (native session/load or `claude --resume`).
+            throw new ProtocolError("engine_unavailable", "session_resume is not implemented yet", msg.reqId);
+        case "session_attach":
+            sessions.attach(msg.sessionId, viewer, msg.afterSeq, msg.reqId);
+            return;
+        case "session_detach":
+            sessions.detach(msg.sessionId, viewer);
+            return;
+        case "session_prompt":
+            sessions.prompt(msg.sessionId, msg.text, msg.reqId);
+            viewer.send({ type: "ack", reqId: msg.reqId });
+            return;
+        case "session_cancel":
+            sessions.cancel(msg.sessionId);
+            if (msg.reqId)
+                viewer.send({ type: "ack", reqId: msg.reqId });
+            return;
+        case "session_close":
+            sessions.close(msg.sessionId, msg.reqId);
+            viewer.send({ type: "ack", reqId: msg.reqId });
+            return;
+        case "session_delete":
+            sessions.delete(msg.sessionId, msg.reqId);
+            viewer.send({ type: "ack", reqId: msg.reqId });
+            return;
+        case "session_rename":
+            sessions.rename(msg.sessionId, msg.title, msg.reqId);
+            viewer.send({ type: "ack", reqId: msg.reqId });
+            return;
+        case "permission_response":
+            sessions.respond(msg.sessionId, msg.requestId, msg.decision);
+            return;
+    }
+}
+export function startServer(identity, log = console.log, opts = {}) {
+    const sessions = opts.sessions ?? new SessionManager();
+    let connections = 0; // authenticated phone connections since start; `pair` watches it to know the scan worked
+    const https = createServer({ cert: identity.certPem, key: identity.keyPem }, (req, res) => {
+        if (req.url === "/health") {
+            res.writeHead(200, { "content-type": "application/json" });
+            res.end(JSON.stringify({ ok: true, name: identity.name, protocol: PROTOCOL_VERSION, connections }));
+            return;
+        }
+        res.writeHead(404).end();
+    });
+    const wss = new WebSocketServer({ noServer: true, maxPayload: 8 * 1024 * 1024 });
+    https.on("upgrade", (req, socket, head) => {
+        if (!tokenMatches(identity.token, bearerFrom(req))) {
+            socket.write("HTTP/1.1 401 Unauthorized\r\nConnection: close\r\n\r\n");
+            socket.destroy();
+            return;
+        }
+        wss.handleUpgrade(req, socket, head, (ws) => wss.emit("connection", ws, req));
+    });
+    wss.on("connection", (ws) => {
+        log("client connected");
+        connections++;
+        const viewer = {
+            send: (m) => {
+                if (ws.readyState === ws.OPEN)
+                    ws.send(JSON.stringify(m));
+            },
+        };
+        viewer.send({ type: "hello", protocol: PROTOCOL_VERSION, name: identity.name, engines: sessions.engines() });
+        ws.on("message", (data, isBinary) => {
+            if (isBinary)
+                return; // PTY stream: Phase 1 later step
+            let raw;
+            try {
+                raw = JSON.parse(data.toString());
+            }
+            catch {
+                viewer.send({ type: "error", code: "invalid_json", message: "invalid JSON" });
+                return;
+            }
+            void (async () => {
+                let reqId = raw?.reqId;
+                try {
+                    const msg = parseClientMessage(raw);
+                    await handleMessage(msg, sessions, viewer, ws);
+                }
+                catch (e) {
+                    if (e instanceof ProtocolError) {
+                        reqId = e.reqId ?? (typeof reqId === "string" ? reqId : undefined);
+                        viewer.send({ type: "error", ...(reqId ? { reqId } : {}), code: e.code, message: e.message });
+                    }
+                    else {
+                        log("internal error: " + (e instanceof Error ? e.message : String(e)));
+                        viewer.send({ type: "error", ...(typeof reqId === "string" ? { reqId } : {}), code: "internal", message: "internal error" });
+                    }
+                }
+            })();
+        });
+        ws.on("close", () => {
+            sessions.viewerGone(viewer);
+            log("client disconnected");
+        });
+    });
+    return new Promise((resolve, reject) => {
+        https.once("error", reject);
+        https.listen(identity.port, "0.0.0.0", () => {
+            resolve({
+                sessions,
+                close: () => new Promise((done) => {
+                    sessions.closeAll();
+                    for (const c of wss.clients)
+                        c.terminate();
+                    wss.close(() => https.close(() => done()));
+                }),
+            });
+        });
+    });
+}
+//# sourceMappingURL=server.js.map

package/dist/service.js

@@ -0,0 +1,244 @@
+import { spawnSync } from "node:child_process";
+import { existsSync, mkdirSync, rmSync, writeFileSync } from "node:fs";
+import { request } from "node:https";
+import { homedir, userInfo } from "node:os";
+import { join } from "node:path";
+import { fileURLToPath } from "node:url";
+import { REMOGENT_DIR } from "./identity.js";
+// Autostart for the host daemon, as the *current user* (not SYSTEM): the Gemini/Claude CLIs authenticate from the user's
+// profile, so a machine-level service could not use them. Consequence: the daemon starts when you sign in, not before.
+//  - Windows: a Task Scheduler task (logon trigger, restart on failure) that runs a hidden wscript launcher.
+//  - macOS:   a launchd LaunchAgent (RunAtLoad + KeepAlive).        [written from docs, NOT yet run on a Mac]
+//  - Linux:   a systemd --user unit (+ loginctl enable-linger).     [written from docs, NOT yet run on Linux]
+export const LOG_FILE = join(REMOGENT_DIR, "daemon.log");
+const TASK_NAME = "Remogent Host";
+const LABEL = "io.github.infomity.remogent";
+const UNIT = "remogent.service";
+const INDEX_JS = fileURLToPath(new URL("./index.js", import.meta.url));
+function daemonArgs(port) {
+    return [INDEX_JS, "start", "--port", String(port), "--no-qr", "--log", LOG_FILE];
+}
+function run(cmd, args) {
+    const r = spawnSync(cmd, args, { encoding: "utf8", windowsHide: true });
+    if (r.error)
+        return { ok: false, out: r.error.message };
+    const out = (r.stdout ?? "").trim();
+    const err = (r.stderr ?? "").trim();
+    const ok = r.status === 0;
+    // stderr is only interesting when something failed (PowerShell also writes progress noise there).
+    return { ok, out: ok ? out : [out, err].filter(Boolean).join("\n") };
+}
+// ---------------------------------------------------------------- health
+/** Asks a running daemon on this machine for /health (self-signed cert, so verification is off: it is loopback only). */
+export function probeHealth(port, timeoutMs = 2000) {
+    return new Promise((resolve) => {
+        const req = request({ host: "127.0.0.1", port, path: "/health", method: "GET", rejectUnauthorized: false, timeout: timeoutMs }, (res) => {
+            let body = "";
+            res.on("data", (d) => (body += d.toString()));
+            res.on("end", () => {
+                try {
+                    const j = JSON.parse(body);
+                    resolve(j.ok ? { ...(j.name ? { name: j.name } : {}), ...(typeof j.connections === "number" ? { connections: j.connections } : {}) } : undefined);
+                }
+                catch {
+                    resolve(undefined);
+                }
+            });
+        });
+        req.on("timeout", () => {
+            req.destroy();
+            resolve(undefined);
+        });
+        req.on("error", () => resolve(undefined));
+        req.end();
+    });
+}
+export async function waitHealthy(port, totalMs) {
+    const end = Date.now() + totalMs;
+    while (Date.now() < end) {
+        if (await probeHealth(port, 1500))
+            return true;
+        await new Promise((r) => setTimeout(r, 500));
+    }
+    return false;
+}
+// ---------------------------------------------------------------- Windows
+const POWERSHELL = join(process.env["SystemRoot"] ?? "C:\\Windows", "System32", "WindowsPowerShell", "v1.0", "powershell.exe");
+export function ps(script) {
+    const encoded = Buffer.from(`$ProgressPreference = 'SilentlyContinue'\n${script}`, "utf16le").toString("base64");
+    return run(POWERSHELL, ["-NoProfile", "-NonInteractive", "-ExecutionPolicy", "Bypass", "-EncodedCommand", encoded]);
+}
+const psq = (s) => `'${s.replace(/'/g, "''")}'`;
+const WIN_VBS = join(REMOGENT_DIR, "remogent-host.vbs");
+function winInstall(port) {
+    mkdirSync(REMOGENT_DIR, { recursive: true });
+    // wscript runs node with a hidden window and waits, passing node's exit code on, so a crash makes the task fail and
+    // Task Scheduler restarts it (a clean Ctrl+C-style exit 0 is not restarted).
+    const cmdline = [process.execPath, ...daemonArgs(port)].map((a) => `"${a}"`).join(" ");
+    writeFileSync(WIN_VBS, `' Started by the "${TASK_NAME}" scheduled task. Do not edit: \`remogent install\` rewrites it.\r\n` +
+        `Set sh = CreateObject("WScript.Shell")\r\n` +
+        `WScript.Quit sh.Run("${cmdline.replace(/"/g, '""')}", 0, True)\r\n`);
+    const r = ps(`
+$ErrorActionPreference = 'Stop'
+$me = [System.Security.Principal.WindowsIdentity]::GetCurrent().Name
+$action = New-ScheduledTaskAction -Execute 'wscript.exe' -Argument ${psq(`"${WIN_VBS}"`)}
+$trigger = New-ScheduledTaskTrigger -AtLogOn -User $me
+$settings = New-ScheduledTaskSettingsSet -AllowStartIfOnBatteries -DontStopIfGoingOnBatteries -StartWhenAvailable -ExecutionTimeLimit ([TimeSpan]::Zero) -RestartCount 999 -RestartInterval (New-TimeSpan -Minutes 1) -MultipleInstances IgnoreNew
+$principal = New-ScheduledTaskPrincipal -UserId $me -LogonType Interactive -RunLevel Limited
+Register-ScheduledTask -TaskName ${psq(TASK_NAME)} -Action $action -Trigger $trigger -Settings $settings -Principal $principal -Description 'Remogent host companion (starts at sign-in, restarts on crash)' -Force | Out-Null
+Start-ScheduledTask -TaskName ${psq(TASK_NAME)}
+`);
+    return r.ok
+        ? { ok: true, message: `Registered the "${TASK_NAME}" scheduled task (starts at sign-in, restarts on crash) and started it.` }
+        : { ok: false, message: `Could not register the scheduled task: ${r.out}` };
+}
+function winStop() {
+    // Stop-ScheduledTask only ends the hidden wscript launcher; the node host it started keeps running and keeps the port
+    // (a re-install would then fail with "port in use" and keep the old secret). So also end the host the service started,
+    // found by its `--log <our log file>` command line (a hand-started `start` has no --log and is left alone), with its CLIs.
+    ps(`
+Stop-ScheduledTask -TaskName ${psq(TASK_NAME)} -ErrorAction SilentlyContinue
+$pattern = ${psq(`*--log*${LOG_FILE}*`)}
+Get-CimInstance Win32_Process -Filter "Name='node.exe'" | Where-Object { $_.CommandLine -like $pattern } | ForEach-Object { & taskkill.exe /t /f /pid $_.ProcessId | Out-Null }
+`);
+}
+function winUninstall() {
+    winStop();
+    const r = ps(`Unregister-ScheduledTask -TaskName ${psq(TASK_NAME)} -Confirm:$false -ErrorAction SilentlyContinue`);
+    rmSync(WIN_VBS, { force: true });
+    return { ok: r.ok, message: r.ok ? `Removed the "${TASK_NAME}" scheduled task.` : `Could not remove the task: ${r.out}` };
+}
+function winStatus() {
+    const r = ps(`
+$t = Get-ScheduledTask -TaskName ${psq(TASK_NAME)} -ErrorAction SilentlyContinue
+if (-not $t) { 'missing' } else { $i = $t | Get-ScheduledTaskInfo; "$($t.State)|$($i.LastTaskResult)|$($i.LastRunTime)" }
+`);
+    if (!r.ok || r.out === "missing" || !r.out)
+        return { platformSupported: true, registered: false, detail: "not installed" };
+    const [state, last, when] = r.out.split("|");
+    // 267009 (0x41301) is just "currently running"; only show the last result when the task is not running.
+    const detail = state === "Running" ? `Running (since ${when})` : `${state}, last result ${last}, last run ${when}`;
+    return { platformSupported: true, registered: true, detail: `scheduled task "${TASK_NAME}": ${detail}` };
+}
+// ---------------------------------------------------------------- macOS
+const MAC_PLIST = join(homedir(), "Library", "LaunchAgents", `${LABEL}.plist`);
+const xmlEsc = (s) => s.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
+const uid = () => (typeof process.getuid === "function" ? process.getuid() : userInfo().uid);
+function macInstall(port) {
+    mkdirSync(join(homedir(), "Library", "LaunchAgents"), { recursive: true });
+    const args = [process.execPath, ...daemonArgs(port)].map((a) => `<string>${xmlEsc(a)}</string>`).join("");
+    // launchd starts agents with a minimal PATH, so pass the installer's PATH (where gemini/claude were found).
+    writeFileSync(MAC_PLIST, `<?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>${args}</array>
+<key>EnvironmentVariables</key><dict><key>PATH</key><string>${xmlEsc(process.env["PATH"] ?? "")}</string></dict>
+<key>WorkingDirectory</key><string>${xmlEsc(homedir())}</string>
+<key>RunAtLoad</key><true/>
+<key>KeepAlive</key><true/>
+<key>ThrottleInterval</key><integer>10</integer>
+</dict></plist>
+`);
+    run("launchctl", ["bootout", `gui/${uid()}/${LABEL}`]);
+    const r = run("launchctl", ["bootstrap", `gui/${uid()}`, MAC_PLIST]);
+    return r.ok
+        ? { ok: true, message: `Installed the LaunchAgent ${MAC_PLIST} (starts at login, restarts on exit).` }
+        : { ok: false, message: `launchctl bootstrap failed: ${r.out}` };
+}
+function macUninstall() {
+    run("launchctl", ["bootout", `gui/${uid()}/${LABEL}`]);
+    rmSync(MAC_PLIST, { force: true });
+    return { ok: true, message: "Removed the LaunchAgent." };
+}
+function macStatus() {
+    if (!existsSync(MAC_PLIST))
+        return { platformSupported: true, registered: false, detail: "not installed" };
+    const r = run("launchctl", ["print", `gui/${uid()}/${LABEL}`]);
+    const state = /state = (\w+)/.exec(r.out)?.[1];
+    return { platformSupported: true, registered: true, detail: r.ok ? `LaunchAgent loaded${state ? `, state ${state}` : ""}` : "plist present but not loaded" };
+}
+// ---------------------------------------------------------------- Linux
+const LINUX_UNIT = join(homedir(), ".config", "systemd", "user", UNIT);
+const sdq = (s) => `"${s.replace(/\\/g, "\\\\").replace(/"/g, '\\"').replace(/%/g, "%%")}"`;
+function linuxInstall(port) {
+    mkdirSync(join(homedir(), ".config", "systemd", "user"), { recursive: true });
+    const exec = [process.execPath, ...daemonArgs(port)].map(sdq).join(" ");
+    writeFileSync(LINUX_UNIT, `[Unit]
+Description=Remogent host companion
+After=network-online.target
+
+[Service]
+ExecStart=${exec}
+Environment=${sdq(`PATH=${process.env["PATH"] ?? ""}`)}
+Restart=on-failure
+RestartSec=5
+
+[Install]
+WantedBy=default.target
+`);
+    run("systemctl", ["--user", "daemon-reload"]);
+    const r = run("systemctl", ["--user", "enable", "--now", UNIT]);
+    if (!r.ok)
+        return { ok: false, message: `systemctl --user enable failed: ${r.out}` };
+    // Without lingering, a user unit only runs while you are logged in (and stops at logout).
+    const linger = run("loginctl", ["enable-linger", userInfo().username]);
+    return {
+        ok: true,
+        message: `Installed ${LINUX_UNIT} (restarts on failure).` +
+            (linger.ok ? " Lingering enabled: it also starts at boot without a login." : ` Could not enable lingering (${linger.out}); run \`sudo loginctl enable-linger ${userInfo().username}\` to start at boot without logging in.`),
+    };
+}
+function linuxUninstall() {
+    run("systemctl", ["--user", "disable", "--now", UNIT]);
+    rmSync(LINUX_UNIT, { force: true });
+    run("systemctl", ["--user", "daemon-reload"]);
+    return { ok: true, message: "Removed the systemd user unit." };
+}
+function linuxStatus() {
+    if (!existsSync(LINUX_UNIT))
+        return { platformSupported: true, registered: false, detail: "not installed" };
+    const active = run("systemctl", ["--user", "is-active", UNIT]).out;
+    const enabled = run("systemctl", ["--user", "is-enabled", UNIT]).out;
+    return { platformSupported: true, registered: true, detail: `systemd user unit ${UNIT}: ${active}, ${enabled}` };
+}
+// ---------------------------------------------------------------- public API
+const unsupported = { ok: false, message: `Autostart is not supported on ${process.platform}.` };
+/** Registers the daemon to start at sign-in and starts it now. Replaces an earlier registration. */
+export function installService(port) {
+    if (process.platform === "win32")
+        return winInstall(port);
+    if (process.platform === "darwin")
+        return macInstall(port);
+    if (process.platform === "linux")
+        return linuxInstall(port);
+    return unsupported;
+}
+/** Stops a registered service (if any) without unregistering it. */
+export function stopService() {
+    if (process.platform === "win32")
+        winStop();
+    else if (process.platform === "darwin")
+        run("launchctl", ["bootout", `gui/${uid()}/${LABEL}`]);
+    else if (process.platform === "linux")
+        run("systemctl", ["--user", "stop", UNIT]);
+}
+export function uninstallService() {
+    if (process.platform === "win32")
+        return winUninstall();
+    if (process.platform === "darwin")
+        return macUninstall();
+    if (process.platform === "linux")
+        return linuxUninstall();
+    return unsupported;
+}
+export function serviceStatus() {
+    if (process.platform === "win32")
+        return winStatus();
+    if (process.platform === "darwin")
+        return macStatus();
+    if (process.platform === "linux")
+        return linuxStatus();
+    return { platformSupported: false, registered: false, detail: unsupported.message };
+}
+//# sourceMappingURL=service.js.map