0agent 1.0.27 → 1.0.28

package/bin/0agent.js

@@ -126,6 +126,10 @@ switch (cmd) {
     await runMemoryCommand(args.slice(1));
     break;
 
+  case 'codespace':
+    await runCodespaceCommand(args.slice(1));
+    break;
+
   default:
     showHelp();
     break;
@@ -1095,6 +1099,58 @@ async function daemonMemorySync(direction) {
   } catch { return null; }
 }
 
+// ─── Codespace commands ───────────────────────────────────────────────────────
+
+async function runCodespaceCommand(csArgs) {
+  const sub = csArgs[0] ?? 'status';
+
+  switch (sub) {
+    case 'setup': {
+      console.log('\n  Setting up GitHub Codespace browser backend...\n');
+      const result = await fetch(`${BASE_URL}/api/codespace/setup`, { method: 'POST' }).catch(() => null);
+      const data = result?.ok ? await result.json().catch(() => null) : null;
+      if (data?.started) {
+        console.log(`  \x1b[32m✓\x1b[0m Codespace provisioning started`);
+        console.log(`  \x1b[2mFirst time: ~2-3 min. Check with: 0agent codespace status\x1b[0m\n`);
+      } else {
+        console.log(`  \x1b[33m⚠\x1b[0m ${data?.error ?? 'Configure GitHub memory first: 0agent memory connect github'}\n`);
+      }
+      break;
+    }
+    case 'status': {
+      const result = await fetch(`${BASE_URL}/api/codespace/status`).catch(() => null);
+      const data = result?.ok ? await result.json().catch(() => null) : null;
+      if (data) {
+        const state = data.state ?? 'unknown';
+        const icon = state === 'Available' ? '\x1b[32m✓\x1b[0m' : state === 'Shutdown' ? '\x1b[33m●\x1b[0m' : '\x1b[2m○\x1b[0m';
+        console.log(`\n  Browser backend: ${icon} ${state}`);
+        if (data.ready) console.log(`  Tunnel:          \x1b[32m✓ open\x1b[0m → http://localhost:3001`);
+        if (data.name) console.log(`  Codespace:       ${data.name}`);
+        console.log(`  Cost:            ~60 hours/month free on GitHub personal\n`);
+      } else {
+        console.log('\n  Codespace not configured. Run: 0agent codespace setup\n');
+      }
+      break;
+    }
+    case 'start': {
+      process.stdout.write('  Starting codespace...');
+      const result = await fetch(`${BASE_URL}/api/codespace/start`, { method: 'POST' }).catch(() => null);
+      const data = result?.ok ? await result.json().catch(() => null) : null;
+      console.log(data?.ok ? ' \x1b[32m✓\x1b[0m' : ` \x1b[31m✗\x1b[0m ${data?.error ?? 'failed'}`);
+      break;
+    }
+    case 'stop': {
+      process.stdout.write('  Stopping codespace (preserves state)...');
+      const result = await fetch(`${BASE_URL}/api/codespace/stop`, { method: 'POST' }).catch(() => null);
+      const data = result?.ok ? await result.json().catch(() => null) : null;
+      console.log(data?.ok ? ' \x1b[32m✓\x1b[0m Stopped. Hours saved.' : ` \x1b[31m✗\x1b[0m`);
+      break;
+    }
+    default:
+      console.log('  Usage: 0agent codespace setup | status | start | stop');
+  }
+}
+
 // ─── Result preview — confirms the agent's work actually ran ────────────────
 
 async function showResultPreview(result) {

package/dist/daemon.mjs

@@ -1,5 +1,7 @@
 var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
 var __esm = (fn, res) => function __init() {
   return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
 };
@@ -7,6 +9,15 @@ var __export = (target, all) => {
   for (var name in all)
     __defProp(target, name, { get: all[name], enumerable: true });
 };
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
 // packages/core/src/graph/GraphNode.ts
 function createNode(params) {
@@ -2418,6 +2429,80 @@ var init_FileCapability = __esm({
   }
 });
 
+// packages/daemon/src/capabilities/CodespaceBrowserCapability.ts
+var CodespaceBrowserCapability_exports = {};
+__export(CodespaceBrowserCapability_exports, {
+  CodespaceBrowserCapability: () => CodespaceBrowserCapability
+});
+var CodespaceBrowserCapability;
+var init_CodespaceBrowserCapability = __esm({
+  "packages/daemon/src/capabilities/CodespaceBrowserCapability.ts"() {
+    "use strict";
+    init_BrowserCapability();
+    CodespaceBrowserCapability = class {
+      constructor(manager) {
+        this.manager = manager;
+      }
+      name = "browser_open";
+      description = "Open a URL in a cloud Linux browser (GitHub Codespace). Full JS, screenshots, clicks. Falls back to local Chrome.";
+      fallback = new BrowserCapability();
+      provisioningPromise = null;
+      toolDefinition = {
+        name: "browser_open",
+        description: "Open URL in cloud Linux browser (GitHub Codespace). Handles JS-heavy SPAs, auth flows, screenshots. Fallback: local Chrome.",
+        input_schema: {
+          type: "object",
+          properties: {
+            url: { type: "string", description: "URL to open" },
+            action: { type: "string", description: '"read" (default) | "screenshot" | "links" | "click" | "fill" | "snapshot"' },
+            selector: { type: "string", description: "CSS selector for element to extract or interact with" },
+            wait_for: { type: "string", description: "CSS selector to wait for before extracting" },
+            wait_ms: { type: "number", description: "Additional wait after page load (for JS-heavy pages)" },
+            value: { type: "string", description: "Value to fill (for action: fill)" }
+          },
+          required: ["url"]
+        }
+      };
+      async execute(input, cwd) {
+        const start = Date.now();
+        try {
+          if (!this.manager.isReady()) {
+            if (!this.provisioningPromise) {
+              this.provisioningPromise = this.manager.getReadyUrl().finally(() => {
+                this.provisioningPromise = null;
+              });
+            }
+            await this.provisioningPromise;
+          }
+          const res = await fetch(`${this.manager.localUrl}/browse`, {
+            method: "POST",
+            headers: { "Content-Type": "application/json" },
+            body: JSON.stringify(input),
+            signal: AbortSignal.timeout(6e4)
+          });
+          const data = await res.json();
+          if (!data.ok) throw new Error(String(data.error ?? "Browse failed"));
+          return {
+            success: true,
+            output: String(data.data ?? ""),
+            structured: data,
+            duration_ms: Date.now() - start
+          };
+        } catch (err) {
+          const errMsg = err instanceof Error ? err.message : String(err);
+          console.warn("[CodespaceBrowser] Falling back to local Chrome:", errMsg);
+          const result = await this.fallback.execute(input, cwd);
+          return {
+            ...result,
+            fallback_used: "local-chrome",
+            duration_ms: Date.now() - start
+          };
+        }
+      }
+    };
+  }
+});
+
 // packages/daemon/src/capabilities/CapabilityRegistry.ts
 var CapabilityRegistry;
 var init_CapabilityRegistry = __esm({
@@ -2430,9 +2515,28 @@ var init_CapabilityRegistry = __esm({
     init_FileCapability();
     CapabilityRegistry = class {
       capabilities = /* @__PURE__ */ new Map();
-      constructor() {
+      /**
+       * Constructor optionally accepts a CodespaceManager.
+       * If provided and the gh CLI is available, uses CodespaceBrowserCapability
+       * for browser_open — cloud Linux browser via SSH tunnel.
+       *
+       * SECURITY: The registry is only instantiated inside AgentExecutor,
+       * which is only created for AUTHORISED subagents (trust_level: 1,
+       * task_type: browser_task). The main agent does NOT have direct access
+       * to browser_open without going through a subagent spawn.
+       */
+      constructor(codespaceManager) {
         this.register(new WebSearchCapability());
-        this.register(new BrowserCapability());
+        if (codespaceManager) {
+          try {
+            const { CodespaceBrowserCapability: CodespaceBrowserCapability2 } = (init_CodespaceBrowserCapability(), __toCommonJS(CodespaceBrowserCapability_exports));
+            this.register(new CodespaceBrowserCapability2(codespaceManager));
+          } catch {
+            this.register(new BrowserCapability());
+          }
+        } else {
+          this.register(new BrowserCapability());
+        }
         this.register(new ScraperCapability());
         this.register(new ShellCapability());
         this.register(new FileCapability());
@@ -2932,7 +3036,7 @@ var ProactiveSurface_exports = {};
 __export(ProactiveSurface_exports, {
   ProactiveSurface: () => ProactiveSurface
 });
-import { execSync as execSync4 } from "node:child_process";
+import { execSync as execSync5 } from "node:child_process";
 import { existsSync as existsSync12, readFileSync as readFileSync12, statSync, readdirSync as readdirSync5 } from "node:fs";
 import { resolve as resolve11, join as join3 } from "node:path";
 function readdirSafe(dir) {
@@ -3001,7 +3105,7 @@ var init_ProactiveSurface = __esm({
         try {
           const currentHead = this.getGitHead();
           if (!currentHead || currentHead === this.lastKnownHead) return null;
-          const log = execSync4(
+          const log = execSync5(
             `git log ${this.lastKnownHead}..${currentHead} --oneline --stat`,
             { cwd: this.cwd, timeout: 3e3, encoding: "utf8" }
           ).trim();
@@ -3077,7 +3181,7 @@ var init_ProactiveSurface = __esm({
       }
       getGitHead() {
         try {
-          return execSync4("git rev-parse HEAD", { cwd: this.cwd, timeout: 1e3, encoding: "utf8" }).trim();
+          return execSync5("git rev-parse HEAD", { cwd: this.cwd, timeout: 1e3, encoding: "utf8" }).trim();
         } catch {
           return "";
         }
@@ -4644,7 +4748,7 @@ var SkillRegistry = class {
 };
 
 // packages/daemon/src/HTTPServer.ts
-import { Hono as Hono11 } from "hono";
+import { Hono as Hono12 } from "hono";
 import { serve } from "@hono/node-server";
 import { readFileSync as readFileSync8 } from "node:fs";
 import { resolve as resolve7, dirname as dirname3 } from "node:path";
@@ -4989,6 +5093,50 @@ function llmRoutes() {
   return app;
 }
 
+// packages/daemon/src/routes/codespace.ts
+import { Hono as Hono11 } from "hono";
+function codespaceRoutes(deps) {
+  const app = new Hono11();
+  app.get("/status", async (c) => {
+    const mgr = deps.getManager();
+    if (!mgr) return c.json({ configured: false, state: "not_configured" });
+    const info = mgr.findExisting();
+    const ping = mgr.isReady() ? await mgr.ping().catch(() => null) : null;
+    return c.json({
+      configured: true,
+      state: info?.state ?? "not_found",
+      name: info?.name ?? null,
+      ready: mgr.isReady(),
+      browser_ok: ping?.ok ?? false
+    });
+  });
+  app.post("/setup", async (c) => {
+    const result = await deps.setup();
+    return c.json(result);
+  });
+  app.post("/start", async (c) => {
+    const mgr = deps.getManager();
+    if (!mgr) return c.json({ ok: false, error: "Not configured" }, 404);
+    try {
+      const url = await mgr.getReadyUrl();
+      return c.json({ ok: true, url });
+    } catch (err) {
+      return c.json({ ok: false, error: err instanceof Error ? err.message : String(err) });
+    }
+  });
+  app.post("/stop", async (c) => {
+    const mgr = deps.getManager();
+    if (!mgr) return c.json({ ok: false, error: "Not configured" }, 404);
+    try {
+      await mgr.stop();
+      return c.json({ ok: true });
+    } catch (err) {
+      return c.json({ ok: false, error: err instanceof Error ? err.message : String(err) });
+    }
+  });
+  return app;
+}
+
 // packages/daemon/src/HTTPServer.ts
 function findGraphHtml() {
   const candidates = [
@@ -5014,7 +5162,7 @@ var HTTPServer = class {
   deps;
   constructor(deps) {
     this.deps = deps;
-    this.app = new Hono11();
+    this.app = new Hono12();
     this.app.route("/api/health", healthRoutes({ getStatus: deps.getStatus }));
     this.app.route("/api/sessions", sessionRoutes({ sessions: deps.sessions }));
     this.app.route("/api/graph", graphRoutes({ graph: deps.graph }));
@@ -5025,6 +5173,10 @@ var HTTPServer = class {
     this.app.route("/api/insights", insightsRoutes({ proactiveSurface: deps.proactiveSurface ?? null }));
     this.app.route("/api/memory", memoryRoutes({ getSync: deps.getMemorySync ?? (() => null) }));
     this.app.route("/api/llm", llmRoutes());
+    this.app.route("/api/codespace", codespaceRoutes({
+      getManager: deps.getCodespaceManager ?? (() => null),
+      setup: deps.setupCodespace ?? (async () => ({ started: false, error: "Not configured" }))
+    }));
     const serveGraph = (c) => {
       try {
         const html = readFileSync8(GRAPH_HTML_PATH, "utf8");
@@ -5428,6 +5580,7 @@ var GitHubMemorySync = class {
       }
       const readme = this.generateReadme(nodes.length, edges.length);
       pushes.push(putFile(token, owner, repo, "README.md", readme, commitMsg));
+      await this.ensureCodespaceFiles(token, owner, repo, commitMsg);
       await Promise.all(pushes);
       this.lastPushAt = now;
       this.pendingChanges = false;
@@ -5623,6 +5776,36 @@ var GitHubMemorySync = class {
     } catch {
     }
   }
+  /**
+   * Push the codespace browser server files to the memory repo.
+   * This makes the memory repo a valid Codespace template — one repo for everything.
+   * Only pushes if the files don't exist yet (idempotent).
+   */
+  async ensureCodespaceFiles(token, owner, repo, msg) {
+    const existing = await getFileSha(token, owner, repo, ".devcontainer/devcontainer.json");
+    if (existing) return;
+    const devcontainer = JSON.stringify({
+      name: "0agent Browser Sandbox",
+      image: "mcr.microsoft.com/devcontainers/javascript-node:22",
+      postCreateCommand: "cd /workspaces && npm install && npx playwright install chromium --with-deps && pip3 install scrapling --quiet 2>/dev/null || true",
+      postStartCommand: 'cd /workspaces && pkill -f "node server.js" 2>/dev/null; nohup node server.js > /tmp/browser-server.log 2>&1 &',
+      forwardPorts: [3e3],
+      portsAttributes: {
+        "3000": { label: "0agent Browser", onAutoForward: "silent", visibility: "private" }
+      }
+    }, null, 2);
+    const packageJson = JSON.stringify({
+      name: "0agent-browser-server",
+      version: "1.0.0",
+      dependencies: { playwright: "^1.42.0" }
+    }, null, 2);
+    await Promise.all([
+      putFile(token, owner, repo, ".devcontainer/devcontainer.json", devcontainer, msg),
+      putFile(token, owner, repo, "package.json", packageJson, msg),
+      // Note: server.js is too large to inline here — users pull it from the npm package at codespace start
+      putFile(token, owner, repo, ".gitignore", "node_modules/\n*.log\n", msg)
+    ]);
+  }
   generateReadme(nodeCount, edgeCount) {
     return `# 0agent Memory
 
@@ -5663,6 +5846,189 @@ git checkout <commit> graph/         # restore graph files
   }
 };
 
+// packages/daemon/src/CodespaceManager.ts
+import { execSync as execSync4, spawn as spawn3 } from "node:child_process";
+var BROWSER_PORT_REMOTE = 3e3;
+var BROWSER_PORT_LOCAL = 3001;
+var DISPLAY_NAME = "0agent-browser";
+var FORWARD_TIMEOUT_S = 60;
+var CodespaceManager = class {
+  forwardProcess = null;
+  _ready = false;
+  _localUrl = `http://localhost:${BROWSER_PORT_LOCAL}`;
+  memoryRepo;
+  // e.g. "cadetmaze/0agent-memory"
+  constructor(memoryRepo) {
+    this.memoryRepo = memoryRepo;
+  }
+  /** Is the tunnel open and browser server responding? */
+  isReady() {
+    return this._ready;
+  }
+  /** URL to call the browser server (via SSH tunnel). */
+  get localUrl() {
+    return this._localUrl;
+  }
+  // ─── Main entry point ──────────────────────────────────────────────────────
+  /**
+   * Ensure the codespace is running, browser server is started, and tunnel is open.
+   * Returns the local URL to call (http://localhost:3001).
+   * First call: 2-3 minutes (cold provision). Subsequent: 30s or instant.
+   */
+  async getReadyUrl() {
+    const name = await this.ensureRunning();
+    await this.startBrowserServer(name);
+    await this.openTunnel(name);
+    return this._localUrl;
+  }
+  // ─── Lifecycle ────────────────────────────────────────────────────────────
+  /** Find existing 0agent-browser codespace, or create one from the memory repo. */
+  async getOrCreate() {
+    const existing = this.findExisting();
+    if (existing) return existing.name;
+    console.log(`[Codespace] Creating browser codespace from ${this.memoryRepo}...`);
+    console.log("[Codespace] First time: ~2-3 minutes. Subsequent starts: ~30 seconds.");
+    try {
+      const result = execSync4(
+        `gh codespace create --repo "${this.memoryRepo}" --machine basicLinux32gb --display-name "${DISPLAY_NAME}" --json name`,
+        { encoding: "utf8", timeout: 3e5 }
+      );
+      const parsed = JSON.parse(result.trim());
+      console.log(`[Codespace] Created: ${parsed.name}`);
+      return parsed.name;
+    } catch (err) {
+      throw new Error(`Failed to create codespace: ${err instanceof Error ? err.message : String(err)}`);
+    }
+  }
+  /** Find the 0agent-browser codespace by display name. */
+  findExisting() {
+    try {
+      const out = execSync4("gh codespace list --json name,state,displayName,repository", {
+        encoding: "utf8",
+        timeout: 1e4
+      });
+      const list = JSON.parse(out.trim());
+      return list.find((c) => c.displayName === DISPLAY_NAME) ?? null;
+    } catch {
+      return null;
+    }
+  }
+  /** Ensure the codespace is in Available state. */
+  async ensureRunning() {
+    const name = await this.getOrCreate();
+    const info = this.findExisting();
+    if (info?.state === "Shutdown") {
+      console.log("[Codespace] Starting stopped codespace (~30s)...");
+      execSync4(`gh codespace start --codespace "${name}"`, { timeout: 12e4 });
+      await this.waitForState(name, "Available", 60);
+      console.log("[Codespace] Codespace is running");
+    } else if (info?.state === "Starting") {
+      console.log("[Codespace] Codespace is starting...");
+      await this.waitForState(name, "Available", 120);
+    }
+    return name;
+  }
+  /** Start the browser server inside the codespace (idempotent). */
+  async startBrowserServer(name) {
+    try {
+      execSync4(
+        `gh codespace exec --codespace "${name}" -- bash -c "pgrep -f 'node server.js' > /dev/null 2>&1 || (cd /workspaces && nohup node server.js > /tmp/browser-server.log 2>&1 &)"`,
+        { timeout: 3e4 }
+      );
+    } catch {
+    }
+  }
+  /** Open an SSH tunnel via gh CLI: codespace:3000 → localhost:3001. */
+  async openTunnel(name) {
+    this.closeTunnel();
+    console.log(`[Codespace] Opening tunnel port ${BROWSER_PORT_REMOTE} \u2192 localhost:${BROWSER_PORT_LOCAL}...`);
+    this.forwardProcess = spawn3(
+      "gh",
+      ["codespace", "ports", "forward", `${BROWSER_PORT_REMOTE}:${BROWSER_PORT_LOCAL}`, "--codespace", name],
+      { stdio: ["ignore", "ignore", "ignore"] }
+    );
+    this.forwardProcess.unref();
+    this.forwardProcess.on("close", (code) => {
+      if (this._ready) {
+        console.log("[Codespace] Tunnel closed \u2014 reconnecting...");
+        this._ready = false;
+        this.openTunnel(name).catch(() => {
+        });
+      }
+    });
+    const deadline = Date.now() + FORWARD_TIMEOUT_S * 1e3;
+    while (Date.now() < deadline) {
+      await new Promise((r) => setTimeout(r, 1e3));
+      try {
+        const res = await fetch(`${this._localUrl}/health`, { signal: AbortSignal.timeout(2e3) });
+        if (res.ok) {
+          this._ready = true;
+          console.log("[Codespace] Browser server ready at " + this._localUrl);
+          return;
+        }
+      } catch {
+      }
+    }
+    throw new Error(`Browser server did not respond within ${FORWARD_TIMEOUT_S}s`);
+  }
+  closeTunnel() {
+    if (this.forwardProcess) {
+      try {
+        this.forwardProcess.kill("SIGTERM");
+      } catch {
+      }
+      this.forwardProcess = null;
+    }
+    this._ready = false;
+  }
+  /** Stop the codespace to save free-tier hours. State is preserved. */
+  async stop() {
+    this.closeTunnel();
+    const info = this.findExisting();
+    if (info?.state === "Available") {
+      execSync4(`gh codespace stop --codespace "${info.name}"`, { timeout: 3e4 });
+      console.log("[Codespace] Stopped (state preserved, restarts in 30s when needed)");
+    }
+  }
+  /** Delete the codespace entirely. */
+  async delete() {
+    this.closeTunnel();
+    const info = this.findExisting();
+    if (info) {
+      execSync4(`gh codespace delete --codespace "${info.name}" --force`, { timeout: 3e4 });
+      console.log("[Codespace] Deleted");
+    }
+  }
+  // ─── Health checking ───────────────────────────────────────────────────────
+  /** Ping the browser server. Returns null if not reachable. */
+  async ping() {
+    try {
+      const res = await fetch(`${this._localUrl}/health`, { signal: AbortSignal.timeout(3e3) });
+      return res.ok ? await res.json() : null;
+    } catch {
+      return null;
+    }
+  }
+  // ─── Helpers ───────────────────────────────────────────────────────────────
+  async waitForState(name, target, maxSeconds) {
+    for (let i = 0; i < maxSeconds / 2; i++) {
+      await new Promise((r) => setTimeout(r, 2e3));
+      const info = this.findExisting();
+      if (info?.state === target) return;
+    }
+    throw new Error(`Codespace did not reach ${target} state within ${maxSeconds}s`);
+  }
+  /** Check if gh CLI is installed and authenticated. */
+  static isAvailable() {
+    try {
+      execSync4("gh auth status", { stdio: "ignore", timeout: 5e3 });
+      return true;
+    } catch {
+      return false;
+    }
+  }
+};
+
 // packages/daemon/src/ZeroAgentDaemon.ts
 var ZeroAgentDaemon = class {
   config = null;
@@ -5678,6 +6044,7 @@ var ZeroAgentDaemon = class {
   githubMemorySync = null;
   memorySyncTimer = null;
   proactiveSurfaceInstance = null;
+  codespaceManager = null;
   startedAt = 0;
   pidFilePath;
   constructor() {
@@ -5718,6 +6085,13 @@ var ZeroAgentDaemon = class {
         this.graph
       );
       console.log(`[0agent] Memory sync: github.com/${ghMemCfg.owner}/${ghMemCfg.repo}`);
+      if (CodespaceManager.isAvailable()) {
+        const memRepo = `${ghMemCfg.owner}/${ghMemCfg.repo}`;
+        this.codespaceManager = new CodespaceManager(memRepo);
+        this.codespaceManager.getReadyUrl().catch(() => {
+        });
+        console.log(`[0agent] Browser backend: github.com codespace (from ${memRepo})`);
+      }
       this.githubMemorySync.pull().then((r) => {
         if (r.pulled) console.log(`[0agent] Memory pulled: +${r.nodes_synced} nodes, +${r.edges_synced} edges`);
       }).catch(() => {
@@ -5792,7 +6166,17 @@ var ZeroAgentDaemon = class {
       skillRegistry: this.skillRegistry,
       getStatus: () => this.getStatus(),
       getMemorySync: () => memSyncRef,
-      proactiveSurface
+      proactiveSurface,
+      getCodespaceManager: () => this.codespaceManager,
+      setupCodespace: async () => {
+        if (!this.codespaceManager) return { started: false, error: "GitHub memory not configured. Run: 0agent memory connect github" };
+        try {
+          this.codespaceManager.getReadyUrl().catch(console.error);
+          return { started: true };
+        } catch (err) {
+          return { started: false, error: err instanceof Error ? err.message : String(err) };
+        }
+      }
     });
     await this.httpServer.start();
     writeFileSync7(this.pidFilePath, String(process.pid), "utf8");
@@ -5829,6 +6213,8 @@ var ZeroAgentDaemon = class {
       this.memorySyncTimer = null;
     }
     this.githubMemorySync = null;
+    this.codespaceManager?.closeTunnel();
+    this.codespaceManager = null;
     this.sessionManager = null;
     this.skillRegistry = null;
     this.inferenceEngine = null;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "0agent",
-  "version": "1.0.27",
+  "version": "1.0.28",
   "description": "A persistent, learning AI agent that runs on your machine. An agent that learns.",
   "private": false,
   "license": "Apache-2.0",