@lelouchhe/webagent 0.1.7 → 0.1.10

package/lib/bridge.js

@@ -1,284 +0,0 @@
-import { spawn, ChildProcess } from "node:child_process";
-import { Writable, Readable } from "node:stream";
-import { EventEmitter } from "node:events";
-import * as acp from "@agentclientprotocol/sdk";
-export class AgentBridge extends EventEmitter {
-    proc = null;
-    conn = null;
-    permissionResolvers = new Map();
-    permissionRequestSessions = new Map();
-    silentSessions = new Set(); // Sessions that don't emit events
-    silentBuffers = new Map(); // Text buffers for silent sessions
-    agentCmd;
-    constructor(agentCmd) {
-        super();
-        this.agentCmd = agentCmd;
-    }
-    async start() {
-        const [cmd, ...args] = this.agentCmd.split(/\s+/);
-        this.proc = spawn(cmd, args, {
-            stdio: ["pipe", "pipe", "inherit"],
-        });
-        if (!this.proc.stdin || !this.proc.stdout) {
-            throw new Error(`Failed to start: ${this.agentCmd}`);
-        }
-        const input = Writable.toWeb(this.proc.stdin);
-        const output = Readable.toWeb(this.proc.stdout);
-        const stream = acp.ndJsonStream(input, output);
-        const client = {
-            requestPermission: async (params) => this.handlePermission(params),
-            sessionUpdate: async (params) => this.handleSessionUpdate(params),
-            readTextFile: async (params) => this.handleReadFile(params),
-            writeTextFile: async (params) => this.handleWriteFile(params),
-        };
-        this.conn = new acp.ClientSideConnection((_agent) => client, stream);
-        const init = await this.conn.initialize({
-            protocolVersion: acp.PROTOCOL_VERSION,
-            clientCapabilities: {
-                fs: { readTextFile: true, writeTextFile: true },
-                terminal: true,
-            },
-        });
-        const agentInfo = init.agentInfo;
-        this.emit("event", {
-            type: "connected",
-            agent: {
-                name: agentInfo?.name ?? "unknown",
-                version: agentInfo?.version ?? "?",
-            },
-            configOptions: [],
-        });
-    }
-    async newSession(cwd, opts) {
-        if (!this.conn)
-            throw new Error("Not connected");
-        const session = await this.conn.newSession({ cwd, mcpServers: [] });
-        if (!opts?.silent) {
-            this.emit("event", {
-                type: "session_created",
-                sessionId: session.sessionId,
-                cwd,
-                configOptions: session.configOptions ?? [],
-            });
-        }
-        return session.sessionId;
-    }
-    async loadSession(sessionId, cwd) {
-        if (!this.conn)
-            throw new Error("Not connected");
-        const session = await this.conn.loadSession({ sessionId, cwd, mcpServers: [] });
-        this.emit("event", {
-            type: "session_created",
-            sessionId: session.sessionId,
-            cwd,
-            configOptions: session.configOptions ?? [],
-        });
-        return { sessionId: session.sessionId, configOptions: session.configOptions ?? [] };
-    }
-    async setConfigOption(sessionId, configId, value) {
-        if (!this.conn)
-            throw new Error("Not connected");
-        const result = await this.conn.setSessionConfigOption({ sessionId, configId, value });
-        return result.configOptions ?? [];
-    }
-    async prompt(sessionId, text, images) {
-        if (!this.conn)
-            throw new Error("Not connected");
-        try {
-            const promptParts = [];
-            if (images) {
-                for (const img of images) {
-                    promptParts.push({ type: "image", data: img.data, mimeType: img.mimeType });
-                }
-            }
-            promptParts.push({ type: "text", text });
-            const result = await this.conn.prompt({
-                sessionId,
-                prompt: promptParts,
-            });
-            this.emit("event", {
-                type: "prompt_done",
-                sessionId,
-                stopReason: result.stopReason ?? "end_turn",
-            });
-        }
-        catch (err) {
-            const message = err instanceof Error ? err.message : (typeof err === "string" ? err : JSON.stringify(err));
-            if (/cancel/i.test(message)) {
-                this.emit("event", {
-                    type: "prompt_done",
-                    sessionId,
-                    stopReason: "cancelled",
-                });
-                return;
-            }
-            this.emit("event", { type: "error", sessionId, message });
-        }
-    }
-    async cancel(sessionId) {
-        for (const [requestId, requestSessionId] of this.permissionRequestSessions) {
-            if (requestSessionId === sessionId) {
-                this.denyPermission(requestId);
-            }
-        }
-        await this.conn?.cancel({ sessionId });
-    }
-    /** Send a prompt and collect the full text response without emitting events. */
-    async promptForText(sessionId, text) {
-        if (!this.conn)
-            throw new Error("Not connected");
-        this.silentSessions.add(sessionId);
-        this.silentBuffers.set(sessionId, "");
-        try {
-            await this.conn.prompt({ sessionId, prompt: [{ type: "text", text }] });
-            return this.silentBuffers.get(sessionId) ?? "";
-        }
-        catch (err) {
-            const message = err instanceof Error ? err.message : (typeof err === "string" ? err : JSON.stringify(err));
-            if (/cancel/i.test(message)) {
-                return "";
-            }
-            throw err;
-        }
-        finally {
-            this.silentSessions.delete(sessionId);
-            this.silentBuffers.delete(sessionId);
-        }
-    }
-    resolvePermission(requestId, optionId) {
-        const resolve = this.permissionResolvers.get(requestId);
-        if (resolve) {
-            resolve({ outcome: { outcome: "selected", optionId } });
-            this.permissionResolvers.delete(requestId);
-            this.permissionRequestSessions.delete(requestId);
-        }
-    }
-    denyPermission(requestId) {
-        const resolve = this.permissionResolvers.get(requestId);
-        if (resolve) {
-            resolve({ outcome: { outcome: "cancelled" } });
-            this.permissionResolvers.delete(requestId);
-            this.permissionRequestSessions.delete(requestId);
-        }
-    }
-    async shutdown() {
-        // Reject all pending permissions
-        for (const [id, resolve] of this.permissionResolvers) {
-            resolve({ outcome: { outcome: "cancelled" } });
-        }
-        this.permissionResolvers.clear();
-        this.permissionRequestSessions.clear();
-        if (this.proc && this.proc.exitCode === null) {
-            this.proc.kill();
-            await new Promise((resolve) => {
-                const timer = setTimeout(() => {
-                    this.proc?.kill(process.platform === "win32" ? undefined : "SIGKILL");
-                    resolve();
-                }, 5000);
-                this.proc?.on("exit", () => {
-                    clearTimeout(timer);
-                    resolve();
-                });
-            });
-        }
-        this.proc = null;
-        this.conn = null;
-    }
-    // --- ACP Client callbacks ---
-    handlePermission(params) {
-        const requestId = crypto.randomUUID();
-        const title = params.toolCall?.title ?? "Permission requested";
-        const toolCallId = params.toolCall?.toolCallId ?? null;
-        return new Promise((resolve) => {
-            // Register resolver BEFORE emitting, so synchronous auto-approve can find it
-            this.permissionResolvers.set(requestId, resolve);
-            this.permissionRequestSessions.set(requestId, params.sessionId);
-            this.emit("event", {
-                type: "permission_request",
-                requestId,
-                sessionId: params.sessionId,
-                title,
-                toolCallId,
-                options: params.options,
-            });
-        });
-    }
-    handleSessionUpdate(params) {
-        const update = params.update;
-        const sessionId = params.sessionId;
-        // Silent sessions: only buffer text, don't emit events
-        if (this.silentSessions.has(sessionId)) {
-            if (update.sessionUpdate === "agent_message_chunk" && update.content.type === "text") {
-                const buf = (this.silentBuffers.get(sessionId) ?? "") + update.content.text;
-                this.silentBuffers.set(sessionId, buf);
-            }
-            return Promise.resolve();
-        }
-        switch (update.sessionUpdate) {
-            case "agent_message_chunk":
-                if (update.content.type === "text") {
-                    this.emit("event", {
-                        type: "message_chunk",
-                        sessionId,
-                        text: update.content.text,
-                    });
-                }
-                break;
-            case "agent_thought_chunk":
-                if (update.content.type === "text") {
-                    this.emit("event", {
-                        type: "thought_chunk",
-                        sessionId,
-                        text: update.content.text,
-                    });
-                }
-                break;
-            case "tool_call":
-                this.emit("event", {
-                    type: "tool_call",
-                    sessionId,
-                    id: update.toolCallId ?? "",
-                    title: update.title ?? "",
-                    kind: update.kind ?? "unknown",
-                    rawInput: update.rawInput,
-                });
-                break;
-            case "tool_call_update":
-                this.emit("event", {
-                    type: "tool_call_update",
-                    sessionId,
-                    id: update.toolCallId ?? "",
-                    status: update.status ?? "",
-                    content: update.content ?? undefined,
-                });
-                break;
-            case "plan":
-                this.emit("event", {
-                    type: "plan",
-                    sessionId,
-                    entries: update.entries ?? [],
-                });
-                break;
-            case "config_option_update":
-                this.emit("event", {
-                    type: "config_option_update",
-                    sessionId,
-                    configOptions: update.configOptions ?? [],
-                });
-                break;
-        }
-        return Promise.resolve();
-    }
-    async handleReadFile(params) {
-        const { readFile } = await import("node:fs/promises");
-        const content = await readFile(params.path, "utf-8");
-        return { content };
-    }
-    async handleWriteFile(params) {
-        const { writeFile, mkdir } = await import("node:fs/promises");
-        const { dirname } = await import("node:path");
-        await mkdir(dirname(params.path), { recursive: true });
-        await writeFile(params.path, params.content);
-        return {};
-    }
-}

package/lib/config.js

@@ -1,62 +0,0 @@
-import { readFileSync } from "node:fs";
-import { parse as parseTOML } from "smol-toml";
-import { z } from "zod";
-const ConfigSchema = z.object({
-    port: z.number().int().positive().default(6800),
-    data_dir: z.string().default("data"),
-    default_cwd: z.string().default(process.cwd()),
-    public_dir: z.string().default("dist"),
-    agent_cmd: z.string().default("copilot --acp"),
-    limits: z.object({
-        bash_output: z.number().int().positive().default(1_048_576), // 1 MB
-        image_upload: z.number().int().positive().default(10_485_760), // 10 MB
-        cancel_timeout: z.number().int().nonnegative().default(10_000), // 10s; 0 disables
-    }).default({
-        bash_output: 1_048_576,
-        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() {
-    const idx = process.argv.indexOf("--config");
-    if (idx !== -1 && idx + 1 < process.argv.length) {
-        return process.argv[idx + 1];
-    }
-    return null;
-}
-export function loadConfig() {
-    const configPath = parseArgs();
-    let raw = {};
-    if (configPath) {
-        try {
-            const content = readFileSync(configPath, "utf-8");
-            raw = parseTOML(content);
-            console.log(`[config] loaded: ${configPath}`);
-        }
-        catch (err) {
-            console.error(`[config] failed to read ${configPath}:`, err);
-            process.exit(1);
-        }
-    }
-    else {
-        console.log("[config] no --config provided, using defaults");
-    }
-    const result = ConfigSchema.safeParse(raw);
-    if (!result.success) {
-        console.error("[config] validation error:", result.error.format());
-        process.exit(1);
-    }
-    _config = result.data;
-    return _config;
-}
-export function getConfig() {
-    if (!_config)
-        throw new Error("Config not loaded. Call loadConfig() first.");
-    return _config;
-}

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));
-}