@lelouchhe/webagent 0.1.9 → 0.2.1

package/lib/daemon.js

@@ -1,278 +0,0 @@
-import { spawn } from "node:child_process";
-import { closeSync, existsSync, openSync, readFileSync, unlinkSync, writeFileSync, } from "node:fs";
-import { dirname, isAbsolute, join, resolve } from "node:path";
-import { fileURLToPath } from "node:url";
-const __dirname = dirname(fileURLToPath(import.meta.url));
-// ---------------------------------------------------------------------------
-// Constants
-// ---------------------------------------------------------------------------
-const PID_FILE = "webagent.pid";
-const LOG_FILE = "webagent.log";
-const RESTART_DELAY_INITIAL = 1_000;
-const RESTART_DELAY_MAX = 30_000;
-const STABLE_THRESHOLD_MS = 60_000;
-const KILL_GRACE_MS = 5_000;
-const SUBCOMMANDS = ["start", "stop", "status", "restart"];
-/** Read and validate the PID file at `filePath`. Returns null if missing or stale. */
-export function readPidInfo(filePath) {
-    if (!existsSync(filePath))
-        return null;
-    try {
-        const info = JSON.parse(readFileSync(filePath, "utf8"));
-        if (typeof info.pid !== "number" || !Number.isFinite(info.pid))
-            return null;
-        process.kill(info.pid, 0); // existence check — throws if dead
-        return info;
-    }
-    catch {
-        // Process is dead or file corrupt — clean up
-        try {
-            unlinkSync(filePath);
-        }
-        catch { /* ignore */ }
-        return null;
-    }
-}
-/** Write PID info to `filePath`. */
-export function writePidInfo(filePath, info) {
-    writeFileSync(filePath, JSON.stringify(info) + "\n");
-}
-// ---------------------------------------------------------------------------
-// Arg helpers
-// ---------------------------------------------------------------------------
-export function isSubcommand(arg) {
-    return SUBCOMMANDS.includes(arg);
-}
-/** Resolve relative `--config` values to absolute paths (based on cwd). */
-export function resolveArgs(args) {
-    const result = [...args];
-    for (let i = 0; i < result.length; i++) {
-        if (result[i] === "--config" && i + 1 < result.length && !isAbsolute(result[i + 1])) {
-            result[i + 1] = resolve(result[i + 1]);
-        }
-    }
-    return result;
-}
-// ---------------------------------------------------------------------------
-// Command dispatch
-// ---------------------------------------------------------------------------
-export async function run(command, args) {
-    const pidFile = join(process.cwd(), PID_FILE);
-    const logFile = join(process.cwd(), LOG_FILE);
-    switch (command) {
-        case "start": return cmdStart(pidFile, logFile, args);
-        case "stop": return cmdStop(pidFile);
-        case "status": return cmdStatus(pidFile, logFile);
-        case "restart": return cmdRestart(pidFile, logFile);
-    }
-}
-// ---------------------------------------------------------------------------
-// Commands
-// ---------------------------------------------------------------------------
-async function cmdStart(pidFile, logFile, args) {
-    const existing = readPidInfo(pidFile);
-    if (existing) {
-        console.log(`webagent is already running (pid ${existing.pid})`);
-        process.exitCode = 1;
-        return;
-    }
-    const serverJs = join(__dirname, "server.js");
-    if (!existsSync(serverJs)) {
-        console.error(`server not found: ${serverJs}`);
-        console.error('run "npx tsc -p tsconfig.build.json" first if developing from source');
-        process.exitCode = 1;
-        return;
-    }
-    const resolved = resolveArgs(args);
-    const daemonJs = join(__dirname, "daemon.js");
-    const log = openSync(logFile, "a");
-    const child = spawn(process.execPath, [daemonJs, "__supervisor", ...resolved], { detached: true, stdio: ["ignore", log, log], cwd: process.cwd() });
-    child.unref();
-    closeSync(log);
-    // Poll for PID file (supervisor writes it on startup)
-    for (let i = 0; i < 6; i++) {
-        await sleep(500);
-        const info = readPidInfo(pidFile);
-        if (info) {
-            console.log(`webagent started (pid ${info.pid})`);
-            console.log(`log: ${logFile}`);
-            return;
-        }
-    }
-    console.error("webagent failed to start");
-    console.error(`check log: ${logFile}`);
-    process.exitCode = 1;
-}
-async function cmdStop(pidFile) {
-    const info = readPidInfo(pidFile);
-    if (!info) {
-        console.log("webagent is not running");
-        return;
-    }
-    try {
-        process.kill(info.pid, "SIGTERM");
-    }
-    catch {
-        console.log("webagent is not running (stale pid file removed)");
-        try {
-            unlinkSync(pidFile);
-        }
-        catch { /* ignore */ }
-        return;
-    }
-    // Wait for exit
-    const deadline = Date.now() + 10_000;
-    while (Date.now() < deadline) {
-        await sleep(300);
-        try {
-            process.kill(info.pid, 0);
-        }
-        catch {
-            // Gone — supervisor cleans up PID file, but be safe
-            try {
-                unlinkSync(pidFile);
-            }
-            catch { /* ignore */ }
-            console.log("webagent stopped");
-            return;
-        }
-    }
-    console.error(`webagent (pid ${info.pid}) did not stop within 10s`);
-    console.error(`try: kill -9 ${info.pid}`);
-    process.exitCode = 1;
-}
-async function cmdStatus(pidFile, logFile) {
-    const info = readPidInfo(pidFile);
-    if (!info) {
-        console.log("webagent is not running");
-        return;
-    }
-    const uptimeMs = Date.now() - new Date(info.started).getTime();
-    const h = Math.floor(uptimeMs / 3_600_000);
-    const m = Math.floor((uptimeMs % 3_600_000) / 60_000);
-    console.log(`webagent is running (pid ${info.pid})`);
-    console.log(`  started: ${info.started}`);
-    console.log(`  uptime:  ${h}h ${m}m`);
-    console.log(`  args:    ${info.args.join(" ") || "(none)"}`);
-    console.log(`  log:     ${logFile}`);
-}
-async function cmdRestart(pidFile, logFile) {
-    const info = readPidInfo(pidFile);
-    if (!info) {
-        console.log("webagent is not running");
-        process.exitCode = 1;
-        return;
-    }
-    if (process.platform === "win32") {
-        // No SIGHUP on Windows — fall back to stop + start (non-atomic)
-        await cmdStop(pidFile);
-        await cmdStart(pidFile, logFile, info.args);
-        return;
-    }
-    // Unix: atomic restart via SIGHUP to supervisor
-    try {
-        process.kill(info.pid, "SIGHUP");
-    }
-    catch {
-        console.error(`failed to signal webagent (pid ${info.pid})`);
-        process.exitCode = 1;
-        return;
-    }
-    // Wait briefly and verify
-    await sleep(2000);
-    const newInfo = readPidInfo(pidFile);
-    if (newInfo) {
-        console.log(`webagent restarted (pid ${newInfo.pid})`);
-    }
-    else {
-        console.error("webagent may have failed to restart");
-        console.error(`check log: ${logFile}`);
-        process.exitCode = 1;
-    }
-}
-// ---------------------------------------------------------------------------
-// Supervisor (internal — launched by `start` as a detached process)
-// ---------------------------------------------------------------------------
-function runSupervisor(serverArgs) {
-    const serverJs = join(__dirname, "server.js");
-    const pidFile = join(process.cwd(), PID_FILE);
-    writePidInfo(pidFile, { pid: process.pid, args: serverArgs, started: new Date().toISOString() });
-    let child = null;
-    let stopping = false;
-    let lastStart = 0;
-    let delay = RESTART_DELAY_INITIAL;
-    let timer = null;
-    function spawnServer() {
-        lastStart = Date.now();
-        child = spawn(process.execPath, [serverJs, ...serverArgs], { stdio: "inherit" });
-        child.on("exit", onChildExit);
-    }
-    function onChildExit(code, signal) {
-        child = null;
-        if (stopping)
-            return;
-        if (Date.now() - lastStart > STABLE_THRESHOLD_MS) {
-            delay = RESTART_DELAY_INITIAL;
-        }
-        else {
-            delay = Math.min(delay * 2, RESTART_DELAY_MAX);
-        }
-        console.log(`[supervisor] server exited (code=${code} signal=${signal}), restarting in ${delay}ms`);
-        timer = setTimeout(spawnServer, delay);
-    }
-    function killChild() {
-        if (timer) {
-            clearTimeout(timer);
-            timer = null;
-        }
-        return new Promise((resolve) => {
-            if (!child) {
-                resolve();
-                return;
-            }
-            const c = child;
-            c.once("exit", () => resolve());
-            c.kill("SIGTERM");
-            setTimeout(() => { try {
-                c.kill("SIGKILL");
-            }
-            catch { /* ignore */ } }, KILL_GRACE_MS);
-        });
-    }
-    async function shutdown() {
-        if (stopping)
-            return;
-        stopping = true;
-        await killChild();
-        try {
-            unlinkSync(pidFile);
-        }
-        catch { /* ignore */ }
-        process.exit(0);
-    }
-    process.on("SIGTERM", () => { shutdown(); });
-    process.on("SIGINT", () => { shutdown(); });
-    if (process.platform !== "win32") {
-        process.on("SIGHUP", async () => {
-            console.log("[supervisor] SIGHUP received, restarting server");
-            delay = RESTART_DELAY_INITIAL;
-            await killChild();
-            if (!stopping)
-                spawnServer();
-        });
-    }
-    console.log(`[supervisor] started (pid ${process.pid})`);
-    spawnServer();
-}
-// ---------------------------------------------------------------------------
-// Utility
-// ---------------------------------------------------------------------------
-function sleep(ms) {
-    return new Promise((r) => setTimeout(r, ms));
-}
-// ---------------------------------------------------------------------------
-// Direct execution: node daemon.js __supervisor [server args...]
-// ---------------------------------------------------------------------------
-if (process.argv[2] === "__supervisor") {
-    runSupervisor(process.argv.slice(3));
-}

package/lib/event-handler.js

@@ -1,104 +0,0 @@
-export function handleAgentEvent(event, sessions, store, bridge, config, sseManager, pushService) {
-    if ("sessionId" in event && event.sessionId && sessions.restoringSessions.has(event.sessionId))
-        return;
-    switch (event.type) {
-        case "connected":
-            event.cancelTimeout = config.cancelTimeout;
-            break;
-        case "session_created":
-            if (event.configOptions?.length)
-                sessions.cachedConfigOptions = event.configOptions;
-            for (const opt of event.configOptions ?? []) {
-                store.updateSessionConfig(event.sessionId, opt.id, opt.currentValue);
-            }
-            break;
-        case "config_option_update":
-            if (event.configOptions?.length)
-                sessions.cachedConfigOptions = event.configOptions;
-            for (const opt of event.configOptions ?? []) {
-                store.updateSessionConfig(event.sessionId, opt.id, opt.currentValue);
-            }
-            break;
-        case "message_chunk":
-            sessions.flushThinkingBuffer(event.sessionId);
-            sessions.appendAssistant(event.sessionId, event.text);
-            break;
-        case "thought_chunk":
-            sessions.flushAssistantBuffer(event.sessionId);
-            sessions.appendThinking(event.sessionId, event.text);
-            break;
-        case "tool_call":
-            sessions.flushBuffers(event.sessionId);
-            store.saveEvent(event.sessionId, event.type, { id: event.id, title: event.title, kind: event.kind, rawInput: event.rawInput });
-            break;
-        case "tool_call_update":
-            store.saveEvent(event.sessionId, event.type, { id: event.id, status: event.status, content: event.content });
-            break;
-        case "plan":
-            sessions.flushBuffers(event.sessionId);
-            store.saveEvent(event.sessionId, event.type, { entries: event.entries });
-            break;
-        case "permission_request": {
-            sessions.flushBuffers(event.sessionId);
-            store.saveEvent(event.sessionId, event.type, {
-                requestId: event.requestId, title: event.title, options: event.options,
-            });
-            sessions.pendingPermissions.set(event.requestId, {
-                requestId: event.requestId,
-                sessionId: event.sessionId,
-                title: event.title,
-                options: event.options.map((o) => ({ optionId: o.optionId, label: o.label ?? o.name ?? o.optionId })),
-            });
-            // Auto-approve permissions in autopilot mode (allow_once only to avoid persisting across mode switches)
-            const mode = store.getSession(event.sessionId)?.mode ?? "";
-            if (mode.includes("#autopilot")) {
-                const opt = event.options.find((o) => o.kind === "allow_once");
-                if (opt) {
-                    bridge.resolvePermission(event.requestId, opt.optionId);
-                    sessions.pendingPermissions.delete(event.requestId);
-                    const optionName = opt.label ?? opt.optionId;
-                    store.saveEvent(event.sessionId, "permission_response", {
-                        requestId: event.requestId, optionName, denied: false,
-                    });
-                    // Broadcast both so the frontend can render then collapse the permission card
-                    sseManager.broadcast(event);
-                    const resolvedEvent = {
-                        type: "permission_resolved",
-                        sessionId: event.sessionId,
-                        requestId: event.requestId,
-                        optionName,
-                        denied: false,
-                    };
-                    sseManager.broadcast(resolvedEvent);
-                    return;
-                }
-            }
-            break;
-        }
-        case "prompt_done":
-            sessions.activePrompts.delete(event.sessionId);
-            sessions.flushBuffers(event.sessionId);
-            store.saveEvent(event.sessionId, event.type, { stopReason: event.stopReason });
-            break;
-        case "error":
-            if (event.sessionId) {
-                sessions.activePrompts.delete(event.sessionId);
-            }
-            break;
-    }
-    sseManager.broadcast(event);
-    // Push notification check (after broadcast so clients get the event first)
-    if (pushService && "sessionId" in event && event.sessionId) {
-        const session = store.getSession(event.sessionId);
-        const eventData = {};
-        if (event.type === "permission_request") {
-            eventData.description = event.title;
-        }
-        if (pushService.maybeNotify(event.sessionId, session?.title ?? null, event.type, eventData)) {
-            const notification = pushService.formatNotification(event.sessionId, session?.title ?? null, event.type, eventData);
-            pushService.sendToAll(notification).catch((err) => {
-                console.error("[push] failed to send:", err);
-            });
-        }
-    }
-}

package/lib/push-service.js

@@ -1,168 +0,0 @@
-import webpush from "web-push";
-import { chmodSync, existsSync, readFileSync, writeFileSync } from "node:fs";
-import { join } from "node:path";
-const VAPID_FILE = "vapid.json";
-/** Remove a subscription after this many consecutive send failures. */
-const MAX_CONSECUTIVE_FAILURES = 5;
-export class PushService {
-    store;
-    vapidKeys;
-    clientVisibility = new Map(); // clientId → visible
-    clientEndpoints = new Map(); // clientId → push endpoint
-    clientSessions = new Map(); // clientId → currently viewed sessionId
-    /** endpoint → consecutive failure count (absent or 0 = healthy) */
-    failureCounts = new Map();
-    constructor(store, dataDir, vapidSubject) {
-        this.store = store;
-        this.vapidKeys = this.loadOrGenerateKeys(dataDir);
-        webpush.setVapidDetails(vapidSubject, this.vapidKeys.publicKey, this.vapidKeys.privateKey);
-    }
-    // ---------------------------------------------------------------------------
-    // VAPID keys
-    // ---------------------------------------------------------------------------
-    loadOrGenerateKeys(dataDir) {
-        const filePath = join(dataDir, VAPID_FILE);
-        if (existsSync(filePath)) {
-            chmodSync(filePath, 0o600);
-            const keys = JSON.parse(readFileSync(filePath, "utf8"));
-            console.log("[push] loaded VAPID keys");
-            return keys;
-        }
-        const keys = webpush.generateVAPIDKeys();
-        writeFileSync(filePath, JSON.stringify(keys, null, 2) + "\n", { mode: 0o600 });
-        console.log("[push] generated new VAPID keys");
-        return keys;
-    }
-    getPublicKey() {
-        return this.vapidKeys.publicKey;
-    }
-    // ---------------------------------------------------------------------------
-    // Notification formatting
-    // ---------------------------------------------------------------------------
-    formatNotification(sessionId, sessionTitle, eventType, eventData) {
-        const title = sessionTitle || "WebAgent";
-        let body;
-        switch (eventType) {
-            case "permission_request":
-                body = `⚿ ${eventData.description ?? "Permission requested"}`;
-                break;
-            case "prompt_done":
-                body = "✓ Task complete";
-                break;
-            case "bash_done": {
-                const cmd = eventData.command ?? "command";
-                const code = eventData.exitCode ?? "?";
-                body = `$ ${cmd} — exit ${code}`;
-                break;
-            }
-            default:
-                body = eventType;
-        }
-        return { title, body, data: { sessionId } };
-    }
-    // ---------------------------------------------------------------------------
-    // Client visibility tracking
-    // ---------------------------------------------------------------------------
-    setClientVisibility(clientId, visible) {
-        this.clientVisibility.set(clientId, visible);
-    }
-    setClientSession(clientId, sessionId) {
-        this.clientSessions.set(clientId, sessionId);
-    }
-    registerClient(clientId, endpoint) {
-        this.clientEndpoints.set(clientId, endpoint);
-    }
-    removeClient(clientId) {
-        this.clientVisibility.delete(clientId);
-        this.clientEndpoints.delete(clientId);
-        this.clientSessions.delete(clientId);
-    }
-    hasVisibleClient() {
-        for (const visible of this.clientVisibility.values()) {
-            if (visible)
-                return true;
-        }
-        return false;
-    }
-    /** Check if a specific endpoint has at least one visible client. */
-    isEndpointVisible(endpoint) {
-        for (const [clientId, ep] of this.clientEndpoints) {
-            if (ep === endpoint && this.clientVisibility.get(clientId))
-                return true;
-        }
-        return false;
-    }
-    /**
-     * Check if a specific endpoint has a visible client viewing the given session.
-     * A client with no session set does not suppress any session's push.
-     */
-    isEndpointVisibleForSession(endpoint, sessionId) {
-        for (const [clientId, ep] of this.clientEndpoints) {
-            if (ep === endpoint
-                && this.clientVisibility.get(clientId)
-                && this.clientSessions.get(clientId) === sessionId)
-                return true;
-        }
-        return false;
-    }
-    // ---------------------------------------------------------------------------
-    // High-level: decide whether to push, and if so, send
-    // ---------------------------------------------------------------------------
-    static NOTIFIABLE = new Set(["permission_request", "prompt_done", "bash_done"]);
-    /**
-     * Check if this event should trigger a push notification.
-     * Returns true if a notification should be sent (caller should then call sendToAll).
-     * Per-subscription visibility filtering happens inside sendToAll.
-     */
-    maybeNotify(sessionId, sessionTitle, eventType, eventData) {
-        if (!PushService.NOTIFIABLE.has(eventType))
-            return false;
-        return true;
-    }
-    // ---------------------------------------------------------------------------
-    // Send push to all subscriptions
-    // ---------------------------------------------------------------------------
-    async sendToAll(notification) {
-        const subs = this.store.getAllSubscriptions();
-        if (subs.length === 0)
-            return;
-        const payload = JSON.stringify(notification);
-        // Per-subscription visibility: skip endpoints where a visible client is viewing this session
-        const targets = subs.filter((sub) => !this.isEndpointVisibleForSession(sub.endpoint, notification.data.sessionId));
-        if (targets.length === 0)
-            return;
-        const results = await Promise.allSettled(targets.map((sub) => this.sendOne({ endpoint: sub.endpoint, keys: { auth: sub.auth, p256dh: sub.p256dh } }, payload)));
-        for (let i = 0; i < results.length; i++) {
-            const result = results[i];
-            const endpoint = targets[i].endpoint;
-            if (result.status === "fulfilled") {
-                this.failureCounts.delete(endpoint);
-            }
-            else {
-                const err = result.reason;
-                if (err.statusCode === 410) {
-                    // Subscription expired — clean up immediately
-                    this.store.removeSubscription(endpoint);
-                    this.failureCounts.delete(endpoint);
-                    console.log(`[push] removed expired subscription (410): ${endpoint.slice(0, 60)}…`);
-                }
-                else {
-                    const count = (this.failureCounts.get(endpoint) ?? 0) + 1;
-                    if (count >= MAX_CONSECUTIVE_FAILURES) {
-                        this.store.removeSubscription(endpoint);
-                        this.failureCounts.delete(endpoint);
-                        console.log(`[push] removed subscription after ${count} consecutive failures: ${endpoint.slice(0, 60)}…`);
-                    }
-                    else {
-                        this.failureCounts.set(endpoint, count);
-                        console.error(`[push] send failed (${count}/${MAX_CONSECUTIVE_FAILURES}) for ${endpoint.slice(0, 60)}…:`, result.reason);
-                    }
-                }
-            }
-        }
-    }
-    /** Send a single push notification. Extracted for testability. */
-    sendOne(sub, payload) {
-        return webpush.sendNotification(sub, payload);
-    }
-}