agentroam 0.2.0-preview.2 → 0.2.0-preview.3

package/dist/tunnel/child-process.js

@@ -0,0 +1,23 @@
+export async function stopChildProcess(child, timeoutMs = 3_000) {
+    if (child.exitCode !== null || !child.pid)
+        return;
+    const exited = new Promise((resolvePromise) => child.once("exit", () => resolvePromise()));
+    signal(child, "SIGTERM");
+    await Promise.race([exited, new Promise((resolvePromise) => setTimeout(resolvePromise, timeoutMs))]);
+    if (child.exitCode === null)
+        signal(child, "SIGKILL");
+}
+function signal(child, name) {
+    try {
+        if (process.platform !== "win32" && child.pid)
+            process.kill(-child.pid, name);
+        else
+            child.kill(name);
+    }
+    catch {
+        try {
+            child.kill(name);
+        }
+        catch { }
+    }
+}

package/dist/tunnel/cloudflare-provider.js

@@ -1,15 +1,59 @@
 import { spawn } from "node:child_process";
+import { stopChildProcess } from "./child-process.js";
 export class CloudflareTunnelProvider {
     executable;
     constructor(executable) {
         this.executable = executable;
     }
-    async start({ localUrl, signal, log }) { const child = spawn(this.executable, ["tunnel", "--no-autoupdate", "--url", localUrl], { stdio: ["ignore", "pipe", "pipe"], windowsHide: true }); const publicUrl = await waitForUrl(child, log, 30000); signal.addEventListener("abort", () => child.kill(), { once: true }); const exited = new Promise(resolve => child.once("exit", (code, sig) => resolve({ code, signal: sig }))); return { publicUrl, exited, close: async () => { if (child.exitCode === null)
-            child.kill(); await Promise.race([exited, new Promise(resolve => setTimeout(resolve, 3000))]); } }; }
+    async start({ localUrl, signal, log }) {
+        const child = spawn(this.executable, ["tunnel", "--no-autoupdate", "--url", localUrl], {
+            stdio: ["ignore", "pipe", "pipe"],
+            windowsHide: true,
+            detached: process.platform !== "win32",
+        });
+        const abort = () => void stopChildProcess(child);
+        signal.addEventListener("abort", abort, { once: true });
+        if (signal.aborted)
+            abort();
+        try {
+            const publicUrl = await waitForUrl(child, log, 30_000);
+            const exited = new Promise((resolvePromise) => child.once("exit", (code, childSignal) => resolvePromise({ code, signal: childSignal })));
+            return { publicUrl, exited, close: () => stopChildProcess(child) };
+        }
+        catch (error) {
+            await stopChildProcess(child);
+            throw error;
+        }
+    }
+}
+function waitForUrl(child, log, timeoutMs) {
+    return new Promise((resolvePromise, reject) => {
+        let buffer = "";
+        let settled = false;
+        const finish = (error, url) => {
+            if (settled)
+                return;
+            settled = true;
+            clearTimeout(timer);
+            if (error)
+                reject(error);
+            else
+                resolvePromise(url);
+        };
+        const timer = setTimeout(() => finish(new Error("cloudflared tunnel URL timeout")), timeoutMs);
+        const read = (chunk) => {
+            const text = chunk.toString();
+            buffer = (buffer + text).slice(-8192);
+            for (const line of text.split(/\r?\n/))
+                if (line)
+                    log(line.replace(/pair=[^\s&]+/g, "pair=[REDACTED]"));
+            const match = buffer.match(/https:\/\/[a-z0-9-]+\.trycloudflare\.com/i);
+            if (match)
+                finish(undefined, match[0]);
+        };
+        child.stdout?.on("data", read);
+        child.stderr?.on("data", read);
+        child.once("exit", (code) => finish(new Error(`cloudflared exited before URL (${code})`)));
+        child.once("error", (error) => finish(error));
+    });
 }
-async function waitForUrl(child, log, timeoutMs) { return new Promise((resolve, reject) => { let buffer = ""; const timer = setTimeout(() => reject(new Error("cloudflared tunnel URL timeout")), timeoutMs); const read = (chunk) => { const text = chunk.toString(); buffer = (buffer + text).slice(-8192); for (const line of text.split(/\r?\n/))
-    if (line)
-        log(line.replace(/pair=[^\s&]+/g, "pair=[REDACTED]")); const match = buffer.match(/https:\/\/[a-z0-9-]+\.trycloudflare\.com/i); if (match) {
-    clearTimeout(timer);
-    resolve(match[0]);
-} }; child.stdout?.on("data", read); child.stderr?.on("data", read); child.once("exit", code => { clearTimeout(timer); reject(new Error(`cloudflared exited before URL (${code})`)); }); child.once("error", reject); }); }

package/dist/tunnel/custom-command-provider.js

@@ -1,4 +1,5 @@
 import { spawn } from "node:child_process";
+import { stopChildProcess } from "./child-process.js";
 export class CustomCommandTunnelProvider {
     command;
     port;
@@ -6,8 +7,57 @@ export class CustomCommandTunnelProvider {
         this.command = command;
         this.port = port;
     }
-    async start({ signal, log }) { const rendered = this.command.replaceAll("{port}", String(this.port)); const child = spawn(rendered, { shell: true, stdio: ["ignore", "pipe", "pipe"], windowsHide: true }); const publicUrl = await new Promise((resolve, reject) => { let buffer = ""; const timer = setTimeout(() => reject(new Error("custom tunnel URL timeout")), 30000); const read = (chunk) => { const text = chunk.toString(); buffer = (buffer + text).slice(-8192); log(text.trim()); const match = buffer.match(/https:\/\/[^\s]+/i); if (match) {
-        clearTimeout(timer);
-        resolve(match[0].replace(/[),.;]+$/, ""));
-    } }; child.stdout?.on("data", read); child.stderr?.on("data", read); child.once("error", reject); }); signal.addEventListener("abort", () => child.kill(), { once: true }); const exited = new Promise(resolve => child.once("exit", (code, sig) => resolve({ code, signal: sig }))); return { publicUrl, exited, close: async () => { child.kill(); } }; }
+    async start({ signal, log }) {
+        const rendered = this.command.replaceAll("{port}", String(this.port));
+        const child = spawn(rendered, {
+            shell: true,
+            stdio: ["ignore", "pipe", "pipe"],
+            windowsHide: true,
+            detached: process.platform !== "win32",
+        });
+        const abort = () => void stopChildProcess(child);
+        signal.addEventListener("abort", abort, { once: true });
+        if (signal.aborted)
+            abort();
+        try {
+            const publicUrl = await waitForCustomUrl(child, log, 30_000);
+            const exited = new Promise((resolvePromise) => child.once("exit", (code, childSignal) => resolvePromise({ code, signal: childSignal })));
+            return { publicUrl, exited, close: () => stopChildProcess(child) };
+        }
+        catch (error) {
+            await stopChildProcess(child);
+            throw error;
+        }
+    }
+}
+function waitForCustomUrl(child, log, timeoutMs) {
+    return new Promise((resolvePromise, reject) => {
+        let buffer = "";
+        let settled = false;
+        const finish = (error, url) => {
+            if (settled)
+                return;
+            settled = true;
+            clearTimeout(timer);
+            if (error)
+                reject(error);
+            else
+                resolvePromise(url);
+        };
+        const timer = setTimeout(() => finish(new Error("custom tunnel URL timeout")), timeoutMs);
+        const read = (chunk) => {
+            const text = chunk.toString();
+            buffer = (buffer + text).slice(-8192);
+            for (const line of text.split(/\r?\n/))
+                if (line)
+                    log(line.replace(/pair=[^\s&]+/g, "pair=[REDACTED]"));
+            const match = buffer.match(/https:\/\/[^\s]+/i);
+            if (match)
+                finish(undefined, match[0].replace(/[),.;]+$/, ""));
+        };
+        child.stdout?.on("data", read);
+        child.stderr?.on("data", read);
+        child.once("error", (error) => finish(error));
+        child.once("exit", (code) => finish(new Error(`custom tunnel exited before URL (${code})`)));
+    });
 }

package/dist/tunnel/pinggy-provider.js

@@ -0,0 +1,84 @@
+import { spawn } from "node:child_process";
+import { mkdir } from "node:fs/promises";
+import { resolve } from "node:path";
+import { stopChildProcess } from "./child-process.js";
+export class PinggyTunnelProvider {
+    port;
+    dataDir;
+    spawnImpl;
+    constructor(port, dataDir, spawnImpl = spawn) {
+        this.port = port;
+        this.dataDir = dataDir;
+        this.spawnImpl = spawnImpl;
+    }
+    async start({ signal, log }) {
+        const sshDir = resolve(this.dataDir, "ssh");
+        await mkdir(sshDir, { recursive: true });
+        const knownHosts = resolve(sshDir, "known_hosts");
+        const args = [
+            "-p", "443",
+            "-o", "ExitOnForwardFailure=yes",
+            "-o", "ServerAliveInterval=30",
+            "-o", "ServerAliveCountMax=3",
+            "-o", "StrictHostKeyChecking=accept-new",
+            "-o", `UserKnownHostsFile=${knownHosts}`,
+            "-R", `0:localhost:${this.port}`,
+            "free.pinggy.io",
+        ];
+        const child = this.spawnImpl("ssh", args, {
+            stdio: ["ignore", "pipe", "pipe"],
+            windowsHide: true,
+            detached: process.platform !== "win32",
+        });
+        const abort = () => void stopChildProcess(child);
+        signal.addEventListener("abort", abort, { once: true });
+        if (signal.aborted)
+            abort();
+        try {
+            const publicUrl = await waitForPinggyUrl(child, log, 30_000);
+            const exited = new Promise((resolvePromise) => child.once("exit", (code, childSignal) => resolvePromise({ code, signal: childSignal })));
+            return { publicUrl, exited, close: () => stopChildProcess(child) };
+        }
+        catch (error) {
+            await stopChildProcess(child);
+            throw error;
+        }
+    }
+}
+export function parsePinggyUrl(text) {
+    return text.match(/https:\/\/[a-z0-9-]+(?:\.[a-z0-9-]+)*\.pinggy-free\.link/i)?.[0] ?? null;
+}
+function waitForPinggyUrl(child, log, timeoutMs) {
+    return new Promise((resolvePromise, reject) => {
+        let buffer = "";
+        let settled = false;
+        const finish = (error, url) => {
+            if (settled)
+                return;
+            settled = true;
+            clearTimeout(timer);
+            if (error)
+                reject(error);
+            else
+                resolvePromise(url);
+        };
+        const timer = setTimeout(() => finish(new Error("Pinggy tunnel URL timeout")), timeoutMs);
+        const read = (chunk) => {
+            const text = chunk.toString();
+            buffer = (buffer + text).slice(-16_384);
+            for (const line of text.split(/\r?\n/))
+                if (line)
+                    log(redact(line));
+            const url = parsePinggyUrl(buffer);
+            if (url)
+                finish(undefined, url);
+        };
+        child.stdout?.on("data", read);
+        child.stderr?.on("data", read);
+        child.once("error", (error) => finish(error));
+        child.once("exit", (code) => finish(new Error(`Pinggy SSH exited before URL (${code})`)));
+    });
+}
+function redact(text) {
+    return text.replace(/pair=[^\s&]+/g, "pair=[REDACTED]");
+}

package/dist/tunnel/pinggy-provider.test.js

@@ -0,0 +1,40 @@
+import { EventEmitter } from "node:events";
+import { PassThrough } from "node:stream";
+import { describe, expect, it, vi } from "vitest";
+import { PinggyTunnelProvider, parsePinggyUrl } from "./pinggy-provider.js";
+describe("parsePinggyUrl", () => {
+    it("accepts only Pinggy free HTTPS URLs", () => {
+        expect(parsePinggyUrl("open https://abc-123.run.pinggy-free.link now")).toBe("https://abc-123.run.pinggy-free.link");
+        expect(parsePinggyUrl("https://example.com")).toBeNull();
+        expect(parsePinggyUrl("http://abc.run.pinggy-free.link")).toBeNull();
+    });
+});
+describe("PinggyTunnelProvider", () => {
+    it("starts SSH on port 443 with persistent host-key checking", async () => {
+        const child = fakeChild();
+        const spawnImpl = vi.fn((_command, _args) => child);
+        const provider = new PinggyTunnelProvider(43210, "/tmp/agentroam-test", spawnImpl);
+        const started = provider.start({ localUrl: "http://127.0.0.1:43210", signal: new AbortController().signal, log: vi.fn() });
+        queueMicrotask(() => child.stderr.write("https://sample.run.pinggy-free.link\n"));
+        const handle = await started;
+        expect(handle.publicUrl).toBe("https://sample.run.pinggy-free.link");
+        const args = spawnImpl.mock.calls[0][1];
+        expect(args).toContain("443");
+        expect(args).toContain("StrictHostKeyChecking=accept-new");
+        expect(args).toContain("0:localhost:43210");
+        expect(args.some((value) => value.startsWith("UserKnownHostsFile="))).toBe(true);
+    });
+});
+function fakeChild() {
+    const child = new EventEmitter();
+    child.stdout = new PassThrough();
+    child.stderr = new PassThrough();
+    Object.defineProperty(child, "exitCode", { value: null, writable: true });
+    Object.defineProperty(child, "pid", { value: undefined, writable: true });
+    child.kill = vi.fn(() => {
+        child.exitCode = 0;
+        child.emit("exit", 0, null);
+        return true;
+    });
+    return child;
+}

package/dist/tunnel/public-readiness.js

@@ -0,0 +1,58 @@
+export async function waitForPublicReadiness(publicUrl, options = {}) {
+    const timeoutMs = options.timeoutMs ?? 30_000;
+    const intervalMs = options.intervalMs ?? 750;
+    const fetchImpl = options.fetchImpl ?? fetch;
+    const endpoint = new URL("/api/web-auth/status", `${publicUrl.replace(/\/$/, "")}/`);
+    const deadline = Date.now() + timeoutMs;
+    let lastFailure = "no response";
+    while (Date.now() <= deadline) {
+        if (options.signal?.aborted)
+            throw new Error("public tunnel readiness aborted");
+        try {
+            const response = await fetchImpl(endpoint, {
+                cache: "no-store",
+                headers: { "user-agent": "agentroam-readiness/0.2.0-preview.3" },
+                signal: options.signal,
+            });
+            if (response.ok) {
+                let body;
+                try {
+                    body = (await response.json());
+                }
+                catch {
+                    throw new FatalReadinessError("HTTP 200 with invalid auth status JSON");
+                }
+                if (typeof body.authenticated === "boolean" && typeof body.needsSetup === "boolean")
+                    return;
+                throw new FatalReadinessError("HTTP 200 with invalid auth status JSON");
+            }
+            else {
+                lastFailure = `HTTP ${response.status}`;
+                if (![404, 502, 503, 530].includes(response.status))
+                    throw new FatalReadinessError(lastFailure);
+            }
+        }
+        catch (error) {
+            if (options.signal?.aborted)
+                throw new Error("public tunnel readiness aborted");
+            if (error instanceof FatalReadinessError)
+                throw new Error(`public tunnel not ready: ${error.message}`);
+            lastFailure = error instanceof Error ? error.message : String(error);
+        }
+        if (Date.now() + intervalMs > deadline)
+            break;
+        await delay(intervalMs, options.signal);
+    }
+    throw new Error(`public tunnel not ready: ${lastFailure}`);
+}
+class FatalReadinessError extends Error {
+}
+function delay(milliseconds, signal) {
+    return new Promise((resolvePromise, reject) => {
+        const timer = setTimeout(resolvePromise, milliseconds);
+        signal?.addEventListener("abort", () => {
+            clearTimeout(timer);
+            reject(new Error("public tunnel readiness aborted"));
+        }, { once: true });
+    });
+}

package/dist/tunnel/public-readiness.test.js

@@ -0,0 +1,24 @@
+import { describe, expect, it, vi } from "vitest";
+import { waitForPublicReadiness } from "./public-readiness.js";
+describe("waitForPublicReadiness", () => {
+    it("retries a transient 530 and accepts the expected auth status", async () => {
+        const fetchImpl = vi
+            .fn()
+            .mockResolvedValueOnce(new Response("unavailable", { status: 530 }))
+            .mockResolvedValueOnce(Response.json({ authenticated: false, needsSetup: true }, { status: 200 }));
+        await waitForPublicReadiness("https://example.test", {
+            fetchImpl,
+            intervalMs: 1,
+            timeoutMs: 100,
+        });
+        expect(fetchImpl).toHaveBeenCalledTimes(2);
+    });
+    it("rejects an invalid HTTP 200 payload", async () => {
+        const fetchImpl = vi.fn().mockResolvedValue(Response.json({ ok: true }));
+        await expect(waitForPublicReadiness("https://example.test", { fetchImpl, intervalMs: 1, timeoutMs: 5 })).rejects.toThrow("invalid auth status JSON");
+    });
+    it("includes the last HTTP status in timeout diagnostics", async () => {
+        const fetchImpl = vi.fn().mockResolvedValue(new Response("bad gateway", { status: 502 }));
+        await expect(waitForPublicReadiness("https://example.test", { fetchImpl, intervalMs: 1, timeoutMs: 5 })).rejects.toThrow("HTTP 502");
+    });
+});

package/dist/tunnel/relay-orchestrator.js

@@ -0,0 +1,43 @@
+import { ensureCloudflared } from "../cloudflared/installer.js";
+import { CloudflareTunnelProvider } from "./cloudflare-provider.js";
+import { CustomCommandTunnelProvider } from "./custom-command-provider.js";
+import { PinggyTunnelProvider } from "./pinggy-provider.js";
+import { waitForPublicReadiness } from "./public-readiness.js";
+export async function selectRelay(options) {
+    if (options.cli.localOnly)
+        return { tunnel: null, publicUrl: options.lanUrl, provider: "lan", failures: [] };
+    const providers = options.cli.relay === "auto" ? ["cloudflare", "pinggy"] : [options.cli.relay];
+    const failures = [];
+    const readiness = options.readiness ?? waitForPublicReadiness;
+    for (const providerName of providers) {
+        options.onAttempt?.(providerName);
+        let tunnel = null;
+        try {
+            const provider = await createProvider(providerName, options);
+            tunnel = await provider.start({ localUrl: options.localUrl, signal: options.signal, log: options.log });
+            await readiness(tunnel.publicUrl, { signal: options.signal });
+            return { tunnel, publicUrl: tunnel.publicUrl, provider: providerName, failures };
+        }
+        catch (error) {
+            await tunnel?.close().catch(() => { });
+            const message = error instanceof Error ? error.message : String(error);
+            failures.push({ provider: providerName, message });
+            options.onFailure?.(providerName, message);
+            if (options.signal.aborted)
+                break;
+        }
+    }
+    return { tunnel: null, publicUrl: options.lanUrl, provider: "lan", failures };
+}
+async function createProvider(name, options) {
+    const override = options.providerFactories?.[name];
+    if (override)
+        return await override();
+    if (name === "cloudflare") {
+        const executable = await ensureCloudflared(options.target, options.cli.dataDir);
+        return new CloudflareTunnelProvider(executable);
+    }
+    if (name === "pinggy")
+        return new PinggyTunnelProvider(options.port, options.cli.dataDir);
+    return new CustomCommandTunnelProvider(options.cli.tunnelCommand, options.port);
+}

package/dist/tunnel/relay-orchestrator.test.js

@@ -0,0 +1,72 @@
+import { describe, expect, it, vi } from "vitest";
+import { selectRelay } from "./relay-orchestrator.js";
+describe("selectRelay", () => {
+    it("selects Cloudflare when it becomes ready", async () => {
+        const cloudflare = fakeProvider("https://ready.trycloudflare.com");
+        const result = await selectRelay(options("auto", { cloudflare }));
+        expect(result.provider).toBe("cloudflare");
+        expect(result.publicUrl).toContain("trycloudflare.com");
+    });
+    it("closes failed Cloudflare and selects Pinggy", async () => {
+        const cloudflare = fakeProvider("https://bad.trycloudflare.com");
+        const pinggy = fakeProvider("https://good.run.pinggy-free.link");
+        const readiness = vi.fn(async (url) => {
+            if (url.includes("bad"))
+                throw new Error("HTTP 530");
+        });
+        const result = await selectRelay(options("auto", { cloudflare, pinggy }, readiness));
+        expect(cloudflare.handle.close).toHaveBeenCalledOnce();
+        expect(result.provider).toBe("pinggy");
+        expect(result.failures).toEqual([{ provider: "cloudflare", message: "HTTP 530" }]);
+    });
+    it("falls back to LAN when both public providers fail", async () => {
+        const cloudflare = fakeProvider("https://bad.trycloudflare.com");
+        const pinggy = fakeProvider("https://bad.run.pinggy-free.link");
+        const result = await selectRelay(options("auto", { cloudflare, pinggy }, async () => { throw new Error("blocked"); }));
+        expect(result.provider).toBe("lan");
+        expect(result.publicUrl).toBe("http://10.0.0.2:43210");
+        expect(result.failures).toHaveLength(2);
+    });
+    it("bypasses every public provider in local-only mode", async () => {
+        const cloudflare = fakeProvider("https://unused.trycloudflare.com");
+        const result = await selectRelay({ ...options("auto", { cloudflare }), cli: cli("auto", true) });
+        expect(result.provider).toBe("lan");
+        expect(cloudflare.provider.start).not.toHaveBeenCalled();
+    });
+});
+function options(relay, providers, readiness = async () => { }) {
+    return {
+        cli: cli(relay),
+        target: "darwin-arm64",
+        localUrl: "http://127.0.0.1:43210",
+        lanUrl: "http://10.0.0.2:43210",
+        port: 43210,
+        signal: new AbortController().signal,
+        log: vi.fn(),
+        readiness: readiness,
+        providerFactories: Object.fromEntries(Object.entries(providers).map(([name, value]) => [name, async () => value.provider])),
+    };
+}
+function cli(relay, localOnly = false) {
+    return {
+        command: "start",
+        roots: [process.cwd()],
+        port: null,
+        relay,
+        tunnelCommand: relay === "custom" ? "relay {port}" : null,
+        localOnly,
+        qr: false,
+        dataDir: "/tmp/agentroam-test",
+    };
+}
+function fakeProvider(publicUrl) {
+    const handle = {
+        publicUrl,
+        close: vi.fn(async () => { }),
+        exited: new Promise(() => { }),
+    };
+    const provider = {
+        start: vi.fn(async () => handle),
+    };
+    return { provider, handle };
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agentroam",
-  "version": "0.2.0-preview.2",
+  "version": "0.2.0-preview.3",
   "description": "Zero-install mobile remote terminal and file console",
   "type": "module",
   "bin": { "agentroam": "./bin/agentroam.mjs" },
@@ -16,6 +16,9 @@
   "dependencies": {
     "qrcode-terminal": "^0.12.0"
   },
+  "optionalDependencies": {
+    "agentroam-cloudflared-darwin-arm64": "0.2.0-preview.3"
+  },
   "devDependencies": {
     "@types/node": "^22.0.0",
     "@types/qrcode-terminal": "^0.12.2",

package/runtime/.next/BUILD_ID

@@ -1 +1 @@
-47UkTmBGxP5qz2mnMbNEp
+OszWLAB2kMAnNfSwJzpyw

package/runtime/.next/app-build-manifest.json

@@ -1,25 +1,25 @@
 {
   "pages": {
     "/_not-found/page": [
-      "static/chunks/webpack-e56f3a1950168597.js",
+      "static/chunks/webpack-d91bc49de770fd58.js",
       "static/chunks/3cc391f0-17a90b8b534c353f.js",
       "static/chunks/183-9c8ca0c781655214.js",
       "static/chunks/main-app-07d67f2d4e96ecb8.js",
       "static/chunks/app/_not-found/page-e98edbffee24e843.js"
     ],
     "/layout": [
-      "static/chunks/webpack-e56f3a1950168597.js",
+      "static/chunks/webpack-d91bc49de770fd58.js",
       "static/chunks/3cc391f0-17a90b8b534c353f.js",
       "static/chunks/183-9c8ca0c781655214.js",
       "static/chunks/main-app-07d67f2d4e96ecb8.js",
       "static/chunks/app/layout-9176f750902030b5.js"
     ],
     "/web/page": [
-      "static/chunks/webpack-e56f3a1950168597.js",
+      "static/chunks/webpack-d91bc49de770fd58.js",
       "static/chunks/3cc391f0-17a90b8b534c353f.js",
       "static/chunks/183-9c8ca0c781655214.js",
       "static/chunks/main-app-07d67f2d4e96ecb8.js",
-      "static/chunks/app/web/page-800bcc7d84eb45e4.js"
+      "static/chunks/app/web/page-0ee508ac538f72d3.js"
     ]
   }
 }

package/runtime/.next/app-path-routes-manifest.json

@@ -1 +1 @@
-{"/_not-found/page":"/_not-found","/api/agent/abort/route":"/api/agent/abort","/api/agent/answer/route":"/api/agent/answer","/api/agent/run/route":"/api/agent/run","/api/agent/stream/route":"/api/agent/stream","/api/auth/verify/route":"/api/auth/verify","/api/mcp/connect/route":"/api/mcp/connect","/api/mcp/disconnect/route":"/api/mcp/disconnect","/api/mcp/servers/route":"/api/mcp/servers","/api/memory/[key]/route":"/api/memory/[key]","/api/memory/route":"/api/memory","/api/plugins/load/route":"/api/plugins/load","/api/remote-tools/register/route":"/api/remote-tools/register","/api/sessions/[id]/route":"/api/sessions/[id]","/api/sessions/route":"/api/sessions","/api/skills/route":"/api/skills","/api/tools/route":"/api/tools","/api/web-auth/login/route":"/api/web-auth/login","/api/web-auth/logout/route":"/api/web-auth/logout","/api/web-auth/revoke-all/route":"/api/web-auth/revoke-all","/api/web-auth/setup/route":"/api/web-auth/setup","/api/web-auth/status/route":"/api/web-auth/status","/api/web-console/bootstrap/route":"/api/web-console/bootstrap","/api/web-console/device-state/route":"/api/web-console/device-state","/api/web-console/history/route":"/api/web-console/history","/web/page":"/web","/api/web-console/preferences/route":"/api/web-console/preferences"}
+{"/_not-found/page":"/_not-found","/api/agent/abort/route":"/api/agent/abort","/api/agent/answer/route":"/api/agent/answer","/api/agent/stream/route":"/api/agent/stream","/api/agent/run/route":"/api/agent/run","/api/mcp/connect/route":"/api/mcp/connect","/api/mcp/disconnect/route":"/api/mcp/disconnect","/api/mcp/servers/route":"/api/mcp/servers","/api/memory/[key]/route":"/api/memory/[key]","/api/memory/route":"/api/memory","/api/plugins/load/route":"/api/plugins/load","/api/auth/verify/route":"/api/auth/verify","/api/tools/route":"/api/tools","/api/sessions/[id]/route":"/api/sessions/[id]","/api/sessions/route":"/api/sessions","/api/remote-tools/register/route":"/api/remote-tools/register","/api/web-auth/setup/route":"/api/web-auth/setup","/api/web-console/bootstrap/route":"/api/web-console/bootstrap","/api/web-console/device-state/route":"/api/web-console/device-state","/api/web-auth/logout/route":"/api/web-auth/logout","/api/web-auth/login/route":"/api/web-auth/login","/api/web-console/preferences/route":"/api/web-console/preferences","/web/page":"/web","/api/web-auth/status/route":"/api/web-auth/status","/api/web-auth/revoke-all/route":"/api/web-auth/revoke-all","/api/web-console/history/route":"/api/web-console/history","/api/skills/route":"/api/skills"}

package/runtime/.next/build-manifest.json

@@ -5,24 +5,24 @@
   "devFiles": [],
   "ampDevFiles": [],
   "lowPriorityFiles": [
-    "static/47UkTmBGxP5qz2mnMbNEp/_buildManifest.js",
-    "static/47UkTmBGxP5qz2mnMbNEp/_ssgManifest.js"
+    "static/OszWLAB2kMAnNfSwJzpyw/_buildManifest.js",
+    "static/OszWLAB2kMAnNfSwJzpyw/_ssgManifest.js"
   ],
   "rootMainFiles": [
-    "static/chunks/webpack-e56f3a1950168597.js",
+    "static/chunks/webpack-d91bc49de770fd58.js",
     "static/chunks/3cc391f0-17a90b8b534c353f.js",
     "static/chunks/183-9c8ca0c781655214.js",
     "static/chunks/main-app-07d67f2d4e96ecb8.js"
   ],
   "pages": {
     "/_app": [
-      "static/chunks/webpack-e56f3a1950168597.js",
+      "static/chunks/webpack-d91bc49de770fd58.js",
       "static/chunks/framework-7bac12ed8564755e.js",
       "static/chunks/main-a7dd8c98b48af038.js",
       "static/chunks/pages/_app-389e6eb8abb0af2d.js"
     ],
     "/_error": [
-      "static/chunks/webpack-e56f3a1950168597.js",
+      "static/chunks/webpack-d91bc49de770fd58.js",
       "static/chunks/framework-7bac12ed8564755e.js",
       "static/chunks/main-a7dd8c98b48af038.js",
       "static/chunks/pages/_error-7cee5565b5ef9bcb.js"

package/runtime/.next/prerender-manifest.json

@@ -1 +1 @@
-{"version":4,"routes":{"/api/mcp/servers":{"initialHeaders":{"content-type":"application/json","x-next-cache-tags":"_N_T_/layout,_N_T_/api/layout,_N_T_/api/mcp/layout,_N_T_/api/mcp/servers/layout,_N_T_/api/mcp/servers/route,_N_T_/api/mcp/servers"},"experimentalBypassFor":[{"type":"header","key":"Next-Action"},{"type":"header","key":"content-type","value":"multipart/form-data;.*"}],"initialRevalidateSeconds":false,"srcRoute":"/api/mcp/servers","dataRoute":null},"/api/tools":{"initialHeaders":{"content-type":"application/json","x-next-cache-tags":"_N_T_/layout,_N_T_/api/layout,_N_T_/api/tools/layout,_N_T_/api/tools/route,_N_T_/api/tools"},"experimentalBypassFor":[{"type":"header","key":"Next-Action"},{"type":"header","key":"content-type","value":"multipart/form-data;.*"}],"initialRevalidateSeconds":false,"srcRoute":"/api/tools","dataRoute":null},"/web":{"experimentalBypassFor":[{"type":"header","key":"Next-Action"},{"type":"header","key":"content-type","value":"multipart/form-data;.*"}],"initialRevalidateSeconds":false,"srcRoute":"/web","dataRoute":"/web.rsc"}},"dynamicRoutes":{},"notFoundRoutes":[],"preview":{"previewModeId":"0af636afc19ab68c44e9bd62292fc881","previewModeSigningKey":"caa70e362b360c34d50464aedc11fc9f87188558c2f73db64aa140e202537a99","previewModeEncryptionKey":"cde15007d3b688af515c866e64c77d1c2c48b51c17aea455daf25708b0bf1baa"}}
+{"version":4,"routes":{"/api/mcp/servers":{"initialHeaders":{"content-type":"application/json","x-next-cache-tags":"_N_T_/layout,_N_T_/api/layout,_N_T_/api/mcp/layout,_N_T_/api/mcp/servers/layout,_N_T_/api/mcp/servers/route,_N_T_/api/mcp/servers"},"experimentalBypassFor":[{"type":"header","key":"Next-Action"},{"type":"header","key":"content-type","value":"multipart/form-data;.*"}],"initialRevalidateSeconds":false,"srcRoute":"/api/mcp/servers","dataRoute":null},"/api/tools":{"initialHeaders":{"content-type":"application/json","x-next-cache-tags":"_N_T_/layout,_N_T_/api/layout,_N_T_/api/tools/layout,_N_T_/api/tools/route,_N_T_/api/tools"},"experimentalBypassFor":[{"type":"header","key":"Next-Action"},{"type":"header","key":"content-type","value":"multipart/form-data;.*"}],"initialRevalidateSeconds":false,"srcRoute":"/api/tools","dataRoute":null},"/web":{"experimentalBypassFor":[{"type":"header","key":"Next-Action"},{"type":"header","key":"content-type","value":"multipart/form-data;.*"}],"initialRevalidateSeconds":false,"srcRoute":"/web","dataRoute":"/web.rsc"}},"dynamicRoutes":{},"notFoundRoutes":[],"preview":{"previewModeId":"74b5b86f37416c499418aee65000a795","previewModeSigningKey":"1b075952bdcf92f99117ccf12d93c6436030034bea431ecb07532837dfcccf31","previewModeEncryptionKey":"475fe62bfb206339f353c1d47780da5282a63c1236fbff02745cb4565822255d"}}

package/runtime/.next/react-loadable-manifest.json

@@ -12,11 +12,11 @@
     ]
   },
   "app/web/page.tsx -> ./TerminalPane": {
-    "id": 1587,
+    "id": 3366,
     "files": [
       "static/css/ac3c182a4b5bc5f1.css",
       "static/chunks/f3dd23f1.b423f4328b6ce988.js",
-      "static/chunks/804.0e20fa702013ffef.js"
+      "static/chunks/982.bf2e6e7fe55cd5ca.js"
     ]
   }
 }