@lelouchhe/webagent 0.1.4 → 0.1.5

package/dist/js/{images.mmk25uhc.js → images.mmlj0xfy.js}

@@ -1,6 +1,6 @@
 // Image attach, preview, and paste handling
 
-import { state, dom } from './state.mmk25uhc.js';
+import { state, dom } from './state.mmlj0xfy.js';
 
 function readFileAsBase64(file) {
   return new Promise((resolve) => {

package/dist/js/{input.mmk25uhc.js → input.mmlj0xfy.js}

@@ -3,10 +3,14 @@
 import {
   state, dom, setBusy, sendCancel,
   getConfigOption, getConfigValue, updateNewBtnVisibility,
-} from './state.mmk25uhc.js';
-import { addMessage, addSystem, addBashBlock, showWaiting } from './render.mmk25uhc.js';
-import { handleSlashCommand, hideSlashMenu, handleSlashMenuKey, updateSlashMenu } from './commands.mmk25uhc.js';
-import { renderAttachPreview } from './images.mmk25uhc.js';
+} from './state.mmlj0xfy.js';
+import { addMessage, addSystem, addBashBlock, showWaiting } from './render.mmlj0xfy.js';
+import { handleSlashCommand, hideSlashMenu, handleSlashMenuKey, updateSlashMenu } from './commands.mmlj0xfy.js';
+import { renderAttachPreview } from './images.mmlj0xfy.js';
+
+function wsReady() {
+  return state.ws && state.ws.readyState === 1;
+}
 
 // Wire up cancel-timeout feedback (state.js cannot import render.js directly)
 state._onCancelTimeout = () => addSystem('warn: Agent not responding to cancel');
@@ -32,6 +36,10 @@ function sendMessage() {
       addSystem('warn: Session not ready yet, please wait…');
       return;
     }
+    if (!wsReady()) {
+      addSystem('warn: Not connected, please retry');
+      return;
+    }
     dom.input.value = '';
     dom.input.style.height = 'auto';
     dom.inputArea.classList.remove('bash-mode');
@@ -55,6 +63,11 @@ function sendMessage() {
     return;
   }
 
+  if (!wsReady()) {
+    addSystem('warn: Not connected, please retry');
+    return;
+  }
+
   // Show user message with image thumbnails
   const msgEl = addMessage('user', text || '(image)');
   for (const img of state.pendingImages) {
@@ -77,6 +90,12 @@ function sendMessage() {
         body: JSON.stringify({ data: img.data, mimeType: img.mimeType }),
       }).then(r => r.json()).then(j => ({ data: img.data, mimeType: img.mimeType, path: j.path }))
     )).then(uploaded => {
+      if (!wsReady()) {
+        msgEl.remove();
+        addSystem('warn: Not connected, please retry');
+        setBusy(false);
+        return;
+      }
       state.ws.send(JSON.stringify({ type: 'prompt', sessionId: state.sessionId, text: text || 'What is in this image?', images: uploaded }));
     });
   } else {

package/dist/js/{render.mmk25uhc.js → render.mmlj0xfy.js}

@@ -1,6 +1,6 @@
 // Rendering functions, theme, markdown, bash UI
 
-import { dom, state } from './state.mmk25uhc.js';
+import { dom, state } from './state.mmlj0xfy.js';
 
 // --- Markdown ---
 marked.setOptions({ breaks: true, gfm: true });

package/dist/js/{state.mmk25uhc.js → state.mmlj0xfy.js}

@@ -43,6 +43,7 @@ export const state = {
   lastEventSeq: 0,
   replayInProgress: false,
   replayQueue: [],
+  unconfirmedPermissions: new Map(),
 };
 
 const CONNECTION_STATUS_CLASSES = {
@@ -112,6 +113,7 @@ export function resetSessionUI() {
   state.followMessages = true;
   state.pendingToolCallIds.clear();
   state.pendingPermissionRequestIds.clear();
+  state.unconfirmedPermissions.clear();
   state.pendingPromptDone = false;
   state.turnEnded = false;
   state._cancelTimerId = null;

package/dist/sw.js

@@ -1,5 +1,51 @@
-// Minimal service worker for PWA installability.
+// Minimal service worker for PWA installability + push notifications.
 // No offline caching — app requires WebSocket connection.
 
 self.addEventListener('install', () => self.skipWaiting());
 self.addEventListener('activate', (e) => e.waitUntil(self.clients.claim()));
+
+// --- Push notifications ---
+
+self.addEventListener('push', (e) => {
+  if (!e.data) return;
+
+  let payload;
+  try {
+    payload = e.data.json();
+  } catch {
+    return;
+  }
+
+  const { title, body, data } = payload;
+  e.waitUntil(
+    self.registration.showNotification(title || 'WebAgent', {
+      body: body || '',
+      icon: '/icon-192.png',
+      badge: '/icon-192.png',
+      tag: data?.sessionId || 'default',
+      data: data || {},
+    })
+  );
+});
+
+self.addEventListener('notificationclick', (e) => {
+  e.notification.close();
+
+  const sessionId = e.notification.data?.sessionId;
+  const urlHash = sessionId ? `/#${sessionId}` : '/';
+
+  e.waitUntil(
+    self.clients.matchAll({ type: 'window', includeUncontrolled: true }).then((clients) => {
+      // Focus existing window if open
+      for (const client of clients) {
+        if (client.url.includes(self.location.origin)) {
+          client.focus();
+          client.postMessage({ type: 'navigate', sessionId });
+          return;
+        }
+      }
+      // Otherwise open a new window
+      return self.clients.openWindow(urlHash);
+    })
+  );
+});

package/lib/config.js

@@ -16,6 +16,11 @@ const ConfigSchema = z.object({
         image_upload: 10_485_760,
         cancel_timeout: 10_000,
     }),
+    push: z.object({
+        vapid_subject: z.string().default("mailto:webagent@localhost"),
+    }).default({
+        vapid_subject: "mailto:webagent@localhost",
+    }),
 });
 let _config = null;
 function parseArgs() {

package/lib/daemon.js

@@ -0,0 +1,278 @@
+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

@@ -0,0 +1,95 @@
+import { broadcast } from "./ws-handler.js";
+export function handleAgentEvent(event, sessions, store, wss, bridge, config, 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,
+            });
+            // 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);
+                    const optionName = opt.label ?? opt.optionId;
+                    store.saveEvent(event.sessionId, "permission_response", {
+                        requestId: event.requestId, optionName, denied: false,
+                    });
+                    broadcast(wss, {
+                        type: "permission_resolved",
+                        sessionId: event.sessionId,
+                        requestId: event.requestId,
+                        optionName,
+                        denied: false,
+                    });
+                    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;
+    }
+    broadcast(wss, event);
+    // Push notification check (after broadcast so WS 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

@@ -0,0 +1,112 @@
+import webpush from "web-push";
+import { chmodSync, existsSync, readFileSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+const VAPID_FILE = "vapid.json";
+export class PushService {
+    store;
+    vapidKeys;
+    clientVisibility = new Map(); // clientId → visible
+    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 · ${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);
+    }
+    removeClient(clientId) {
+        this.clientVisibility.delete(clientId);
+    }
+    hasVisibleClient() {
+        for (const visible of this.clientVisibility.values()) {
+            if (visible)
+                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 was queued (caller should then call sendToAll).
+     */
+    maybeNotify(sessionId, sessionTitle, eventType, eventData) {
+        if (!PushService.NOTIFIABLE.has(eventType))
+            return false;
+        if (this.hasVisibleClient())
+            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);
+        const results = await Promise.allSettled(subs.map((sub) => webpush.sendNotification({ endpoint: sub.endpoint, keys: { auth: sub.auth, p256dh: sub.p256dh } }, payload)));
+        for (let i = 0; i < results.length; i++) {
+            const result = results[i];
+            if (result.status === "rejected") {
+                const err = result.reason;
+                if (err.statusCode === 410) {
+                    // Subscription expired — clean up
+                    this.store.removeSubscription(subs[i].endpoint);
+                    console.log(`[push] removed expired subscription: ${subs[i].endpoint}`);
+                }
+                else {
+                    console.error(`[push] send failed for ${subs[i].endpoint}:`, result.reason);
+                }
+            }
+        }
+    }
+}