@shipers-dev/multi 0.3.1 → 0.4.2

package/dist/index.js

@@ -101,6 +101,9 @@ var apiClient = {
   delete: (url) => request(url, { method: "DELETE" })
 };
 
+// src/index.ts
+import { Database } from "bun:sqlite";
+
 // ../../node_modules/.bun/zod@3.25.76/node_modules/zod/v3/external.js
 var exports_external = {};
 __export(exports_external, {
@@ -5377,6 +5380,8 @@ var PID_PATH = join(MULTI_DIR, "agent.pid");
 var LOG_PATH = join(MULTI_DIR, "logs", "agent.log");
 var SKILLS_DIR = join(MULTI_DIR, "skills");
 var STOP_PATH = join(MULTI_DIR, "stop.flag");
+var TASKS_DB_PATH = join(MULTI_DIR, "tasks.db");
+var VERSION = "0.4.2";
 var COMMANDS = {
   setup: "Register this device with a workspace",
   connect: "Connect device to realtime hub and execute assigned tasks",
@@ -5399,16 +5404,23 @@ function log(msg) {
   process.stdout.write(line);
 }
 async function main() {
+  const rawArgs = Bun.argv.slice(2);
+  if (rawArgs.includes("--version") || rawArgs.includes("-v")) {
+    console.log(VERSION);
+    process.exit(0);
+  }
   const args = parseArgs({
     args: Bun.argv,
     options: {
-      help: { type: "boolean", default: false },
+      help: { type: "boolean", default: false, short: "h" },
+      version: { type: "boolean", default: false },
       name: { type: "string" },
       workspace: { type: "string" },
       agent: { type: "string" },
       api: { type: "string" }
     },
-    allowPositionals: true
+    allowPositionals: true,
+    strict: false
   });
   const [command] = args.positionals.slice(2);
   if (args.values.help || !command) {
@@ -5447,7 +5459,7 @@ async function main() {
 }
 function printHelp() {
   console.log(`
-multi-agent - Device CLI for Multi platform
+multi-agent v${VERSION} - Device CLI for Multi platform
 
 Usage: multi-agent <command> [options]
 
@@ -5519,7 +5531,7 @@ async function cmdSetup(name, apiUrl) {
       continue;
     }
     if (poll.data?.status === "approved") {
-      approved = { device_id: poll.data.device_id, token: poll.data.token };
+      approved = { device_id: poll.data.device_id, token: poll.data.token, dispatch_secret: poll.data.dispatch_secret };
       break;
     }
   }
@@ -5530,12 +5542,12 @@ async function cmdSetup(name, apiUrl) {
   }
   console.log(`
 \u2705 Device paired. ID: ${approved.device_id}`);
-  saveConfig({ deviceId: approved.device_id, token: approved.token, apiUrl });
+  saveConfig({ deviceId: approved.device_id, token: approved.token, dispatchSecret: approved.dispatch_secret, apiUrl });
   setAuthToken(approved.token);
   const dev = await apiClient.get(`${apiUrl}/api/devices/${approved.device_id}`);
   const workspaceId = dev.data?.workspace_id;
   if (workspaceId) {
-    saveConfig({ deviceId: approved.device_id, token: approved.token, workspaceId, apiUrl });
+    saveConfig({ deviceId: approved.device_id, token: approved.token, dispatchSecret: approved.dispatch_secret, workspaceId, apiUrl });
     await syncSkills(apiUrl, workspaceId);
   }
   console.log(`
@@ -5570,10 +5582,14 @@ async function cmdLink(apiUrl, config, agentId) {
   console.log(`\u2705 Linked agent ${agentId} \u2194 device ${config.deviceId}`);
 }
 async function cmdConnect(apiUrl, config) {
-  if (!config.deviceId) {
+  if (!config.deviceId || !config.token) {
     console.log('\u274C Not registered. Run "multi-agent setup" first.');
     process.exit(1);
   }
+  if (!config.dispatchSecret) {
+    console.log('\u274C Missing dispatch secret. Re-pair via "multi-agent setup".');
+    process.exit(1);
+  }
   if (existsSync2(PID_PATH)) {
     const pid = Number(readFileSync2(PID_PATH, "utf8").trim());
     if (pid && isRunning(pid)) {
@@ -5587,11 +5603,63 @@ async function cmdConnect(apiUrl, config) {
   if (existsSync2(STOP_PATH))
     unlinkSync(STOP_PATH);
   const detected = await detectAgents();
-  log(`\uD83D\uDE80 Connecting device ${config.deviceId} (pid ${process.pid})`);
+  log(`\uD83D\uDE80 Starting daemon for device ${config.deviceId} (pid ${process.pid})`);
   log(`   runtimes: ${detected.map((d) => d.type).join(", ") || "stub"}`);
-  await apiClient.post(`${apiUrl}/api/devices/${config.deviceId}/heartbeat`, { status: "online" });
-  const wsUrl = apiUrl.replace(/^http/, "ws") + `/ws/devices/${config.deviceId}?token=${encodeURIComponent(config.token || "")}`;
-  let ws = null;
+  const db = openTasksDb();
+  db.run("UPDATE tasks SET status = 'pending' WHERE status = 'running'");
+  let workerWake = null;
+  const notifyWorker = () => {
+    try {
+      workerWake?.();
+      workerWake = null;
+    } catch {}
+  };
+  const port = await pickFreePort();
+  const expectedAuth = `Bearer ${config.dispatchSecret}`;
+  const server = Bun.serve({
+    port,
+    hostname: "127.0.0.1",
+    fetch(req) {
+      const url = new URL(req.url);
+      if (url.pathname === "/health")
+        return Response.json({ ok: true, device_id: config.deviceId });
+      if (url.pathname === "/run" && req.method === "POST") {
+        if (req.headers.get("authorization") !== expectedAuth)
+          return new Response("unauthorized", { status: 401 });
+        return (async () => {
+          try {
+            const body = await req.json();
+            const taskId = body?.task?.issue_id ? `${body.task.issue_id}-${Date.now()}` : crypto.randomUUID();
+            db.run("INSERT INTO tasks (id, status, payload) VALUES (?, ?, ?)", [taskId, "pending", JSON.stringify(body.task)]);
+            notifyWorker();
+            return Response.json({ accepted: true, task_id: taskId }, { status: 202 });
+          } catch (e) {
+            return Response.json({ error: String(e) }, { status: 400 });
+          }
+        })();
+      }
+      return new Response("not found", { status: 404 });
+    }
+  });
+  log(`\uD83C\uDF10 Local server: http://127.0.0.1:${port}`);
+  const cf = Bun.spawn(["cloudflared", "tunnel", "--no-autoupdate", "--url", `http://127.0.0.1:${port}`], {
+    stdout: "pipe",
+    stderr: "pipe",
+    stdin: "ignore"
+  });
+  const tunnelUrl = await parseTunnelUrl(cf.stderr);
+  if (!tunnelUrl) {
+    log("\u274C cloudflared did not emit a tunnel URL \u2014 is `cloudflared` installed? (`brew install cloudflared`)");
+    try {
+      cf.kill();
+    } catch {}
+    try {
+      server.stop();
+    } catch {}
+    process.exit(1);
+  }
+  log(`\u2601\uFE0F  Tunnel up: ${tunnelUrl}`);
+  await apiClient.post(`${apiUrl}/api/devices/${config.deviceId}/heartbeat`, { status: "online", tunnel_url: tunnelUrl });
   let running = true;
   const shutdown = async (reason) => {
     if (!running)
@@ -5599,40 +5667,45 @@ async function cmdConnect(apiUrl, config) {
     running = false;
     log(`\uD83D\uDED1 Shutting down (${reason})`);
     try {
-      ws?.close();
+      server.stop();
+    } catch {}
+    try {
+      cf.kill();
+    } catch {}
+    try {
+      await apiClient.post(`${apiUrl}/api/devices/${config.deviceId}/heartbeat`, { status: "offline", tunnel_url: null });
     } catch {}
-    await apiClient.post(`${apiUrl}/api/devices/${config.deviceId}/heartbeat`, { status: "offline" });
     if (existsSync2(PID_PATH))
       unlinkSync(PID_PATH);
     if (existsSync2(STOP_PATH))
       unlinkSync(STOP_PATH);
+    db.close();
     log("\uD83D\uDC4B Disconnected");
     process.exit(0);
   };
   process.on("SIGINT", () => shutdown("SIGINT"));
   process.on("SIGTERM", () => shutdown("SIGTERM"));
-  const connect = () => {
-    ws = new WebSocket(wsUrl);
-    ws.addEventListener("open", () => log(`\uD83D\uDD0C WS connected: ${wsUrl}`));
-    ws.addEventListener("message", async (ev) => {
+  (async () => {
+    while (running) {
+      const row = db.query("SELECT id, payload FROM tasks WHERE status = 'pending' ORDER BY created_at ASC LIMIT 1").get();
+      if (!row) {
+        await new Promise((resolve) => {
+          workerWake = resolve;
+          setTimeout(resolve, 5000);
+        });
+        continue;
+      }
+      db.run("UPDATE tasks SET status = 'running', started_at = unixepoch(), attempts = attempts + 1 WHERE id = ?", [row.id]);
       try {
-        const msg = JSON.parse(typeof ev.data === "string" ? ev.data : "");
-        if (msg.type === "run_task") {
-          await handleRunTask(apiUrl, config.deviceId, msg.task, detected);
-        }
+        const task = JSON.parse(row.payload);
+        await handleRunTask(apiUrl, config.deviceId, task, detected);
+        db.run("UPDATE tasks SET status = 'done', finished_at = unixepoch() WHERE id = ?", [row.id]);
       } catch (e) {
-        log(`msg parse error: ${String(e)}`);
+        log(`task ${row.id} error: ${String(e)}`);
+        db.run("UPDATE tasks SET status = 'failed', finished_at = unixepoch(), error = ? WHERE id = ?", [String(e), row.id]);
       }
-    });
-    ws.addEventListener("close", () => {
-      if (!running)
-        return;
-      log("\u26A0\uFE0F  WS closed, reconnecting in 3s");
-      setTimeout(connect, 3000);
-    });
-    ws.addEventListener("error", (e) => log(`WS error: ${String(e.message || e)}`));
-  };
-  connect();
+    }
+  })();
   while (running) {
     await sleep(20000);
     if (existsSync2(STOP_PATH)) {
@@ -5640,12 +5713,49 @@ async function cmdConnect(apiUrl, config) {
       break;
     }
     try {
-      await apiClient.post(`${apiUrl}/api/devices/${config.deviceId}/heartbeat`, { status: "online" });
+      await apiClient.post(`${apiUrl}/api/devices/${config.deviceId}/heartbeat`, { status: "online", tunnel_url: tunnelUrl });
     } catch (e) {
       log(`heartbeat error: ${String(e)}`);
     }
   }
 }
+async function pickFreePort() {
+  for (let i = 0;i < 10; i++) {
+    const p = 40000 + Math.floor(Math.random() * 20000);
+    try {
+      const s = Bun.serve({ port: p, hostname: "127.0.0.1", fetch: () => new Response("ok") });
+      s.stop();
+      return p;
+    } catch {}
+  }
+  return 47832;
+}
+async function parseTunnelUrl(stream2) {
+  const reader = stream2.getReader();
+  const dec = new TextDecoder;
+  const deadline = Date.now() + 30000;
+  let buf = "";
+  while (Date.now() < deadline) {
+    const { value, done } = await reader.read();
+    if (done)
+      break;
+    buf += dec.decode(value, { stream: true });
+    const m = buf.match(/(https:\/\/[a-z0-9-]+\.trycloudflare\.com)/i);
+    if (m) {
+      (async () => {
+        try {
+          while (true) {
+            const { done: done2 } = await reader.read();
+            if (done2)
+              break;
+          }
+        } catch {}
+      })();
+      return m[1];
+    }
+  }
+  return null;
+}
 async function handleRunTask(apiUrl, deviceId, task, detected) {
   const issueId = task.issue_id;
   const isFollowup = !!task.followup;
@@ -5935,7 +6045,7 @@ ${userPart}` : userPart;
         onEvent: eventHandler,
         onSession: async (sid) => {
           try {
-            await apiClient.patch(`${apiUrl}/api/issues/${issueId}`, { session_id: sid });
+            await apiClient.post(`${apiUrl}/api/issues/${issueId}/session`, { session_id: sid });
           } catch {}
         }
       });
@@ -6345,6 +6455,24 @@ function isRunning(pid) {
     return false;
   }
 }
+function openTasksDb() {
+  ensureDirs();
+  const db = new Database(TASKS_DB_PATH);
+  db.exec(`
+    CREATE TABLE IF NOT EXISTS tasks (
+      id TEXT PRIMARY KEY,
+      status TEXT NOT NULL DEFAULT 'pending',
+      payload TEXT NOT NULL,
+      attempts INTEGER NOT NULL DEFAULT 0,
+      created_at INTEGER NOT NULL DEFAULT (unixepoch()),
+      started_at INTEGER,
+      finished_at INTEGER,
+      error TEXT
+    );
+    CREATE INDEX IF NOT EXISTS idx_tasks_status ON tasks(status);
+  `);
+  return db;
+}
 function loadConfig() {
   try {
     if (!existsSync2(CONFIG_PATH))

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@shipers-dev/multi",
-  "version": "0.3.1",
+  "version": "0.4.2",
   "type": "module",
   "bin": {
     "multi-agent": "./dist/index.js"

package/src/index.ts

@@ -2,6 +2,7 @@
 
 import { detectAgents } from './detect';
 import { apiClient, setAuthToken } from './client';
+import { Database } from 'bun:sqlite';
 import { runAcp } from './acp-runner';
 import { parseArgs } from 'util';
 import { mkdirSync, existsSync, writeFileSync, readFileSync, appendFileSync, unlinkSync, readdirSync, statSync } from 'fs';
@@ -14,6 +15,8 @@ const PID_PATH = join(MULTI_DIR, 'agent.pid');
 const LOG_PATH = join(MULTI_DIR, 'logs', 'agent.log');
 const SKILLS_DIR = join(MULTI_DIR, 'skills');
 const STOP_PATH = join(MULTI_DIR, 'stop.flag');
+const TASKS_DB_PATH = join(MULTI_DIR, 'tasks.db');
+const VERSION = '0.4.2';
 
 const COMMANDS = {
   setup: 'Register this device with a workspace',
@@ -40,16 +43,24 @@ function log(msg: string) {
 }
 
 async function main() {
+  const rawArgs = Bun.argv.slice(2);
+  if (rawArgs.includes('--version') || rawArgs.includes('-v')) {
+    console.log(VERSION);
+    process.exit(0);
+  }
+
   const args = parseArgs({
     args: Bun.argv,
     options: {
-      help: { type: 'boolean', default: false },
+      help: { type: 'boolean', default: false, short: 'h' },
+      version: { type: 'boolean', default: false },
       name: { type: 'string' },
       workspace: { type: 'string' },
       agent: { type: 'string' },
       api: { type: 'string' },
     },
     allowPositionals: true,
+    strict: false,
   });
 
   const [command] = args.positionals.slice(2) as Command[];
@@ -92,7 +103,7 @@ async function main() {
 
 function printHelp() {
   console.log(`
-multi-agent - Device CLI for Multi platform
+multi-agent v${VERSION} - Device CLI for Multi platform
 
 Usage: multi-agent <command> [options]
 
@@ -148,7 +159,7 @@ async function cmdSetup(name?: string, apiUrl?: string) {
   console.log('\n⏳ Waiting for approval (10 min timeout)...');
 
   const deadline = Date.now() + 10 * 60 * 1000;
-  let approved: { device_id: string; token: string } | null = null;
+  let approved: { device_id: string; token: string; dispatch_secret: string } | null = null;
   while (Date.now() < deadline) {
     await sleep(3000);
     const poll = await apiClient.get<any>(`${apiUrl}/api/pair/poll/${code}`);
@@ -157,21 +168,21 @@ async function cmdSetup(name?: string, apiUrl?: string) {
       continue;
     }
     if (poll.data?.status === 'approved') {
-      approved = { device_id: poll.data.device_id, token: poll.data.token };
+      approved = { device_id: poll.data.device_id, token: poll.data.token, dispatch_secret: poll.data.dispatch_secret };
       break;
     }
   }
   if (!approved) { console.log('\n❌ Timed out.'); process.exit(1); }
 
   console.log(`\n✅ Device paired. ID: ${approved.device_id}`);
-  saveConfig({ deviceId: approved.device_id, token: approved.token, apiUrl });
+  saveConfig({ deviceId: approved.device_id, token: approved.token, dispatchSecret: approved.dispatch_secret, apiUrl });
   setAuthToken(approved.token);
 
   // Fetch workspace_id from device (now authed)
   const dev = await apiClient.get<any>(`${apiUrl}/api/devices/${approved.device_id}`);
   const workspaceId = dev.data?.workspace_id;
   if (workspaceId) {
-    saveConfig({ deviceId: approved.device_id, token: approved.token, workspaceId, apiUrl });
+    saveConfig({ deviceId: approved.device_id, token: approved.token, dispatchSecret: approved.dispatch_secret, workspaceId, apiUrl });
     await syncSkills(apiUrl!, workspaceId);
   }
   console.log('\nNext: link to an agent with: multi-agent link --agent <agentId>');
@@ -206,10 +217,14 @@ async function cmdLink(apiUrl: string, config: Config, agentId?: string) {
 }
 
 async function cmdConnect(apiUrl: string, config: Config) {
-  if (!config.deviceId) {
+  if (!config.deviceId || !config.token) {
     console.log('❌ Not registered. Run "multi-agent setup" first.');
     process.exit(1);
   }
+  if (!config.dispatchSecret) {
+    console.log('❌ Missing dispatch secret. Re-pair via "multi-agent setup".');
+    process.exit(1);
+  }
 
   if (existsSync(PID_PATH)) {
     const pid = Number(readFileSync(PID_PATH, 'utf8').trim());
@@ -224,63 +239,141 @@ async function cmdConnect(apiUrl: string, config: Config) {
   if (existsSync(STOP_PATH)) unlinkSync(STOP_PATH);
 
   const detected = await detectAgents();
-  log(`🚀 Connecting device ${config.deviceId} (pid ${process.pid})`);
+  log(`🚀 Starting daemon for device ${config.deviceId} (pid ${process.pid})`);
   log(`   runtimes: ${detected.map(d => d.type).join(', ') || 'stub'}`);
 
-  await apiClient.post(`${apiUrl}/api/devices/${config.deviceId}/heartbeat`, { status: 'online' });
+  const db = openTasksDb();
+
+  // Requeue orphaned 'running' tasks from previous crash
+  db.run("UPDATE tasks SET status = 'pending' WHERE status = 'running'");
+
+  let workerWake: (() => void) | null = null;
+  const notifyWorker = () => { try { workerWake?.(); workerWake = null; } catch {} };
+
+  // Local HTTP server on a free port
+  const port = await pickFreePort();
+  const expectedAuth = `Bearer ${config.dispatchSecret}`;
+  const server = Bun.serve({
+    port, hostname: '127.0.0.1',
+    fetch(req) {
+      const url = new URL(req.url);
+      if (url.pathname === '/health') return Response.json({ ok: true, device_id: config.deviceId });
+      if (url.pathname === '/run' && req.method === 'POST') {
+        if (req.headers.get('authorization') !== expectedAuth) return new Response('unauthorized', { status: 401 });
+        return (async () => {
+          try {
+            const body = await req.json() as { task: any };
+            const taskId = body?.task?.issue_id ? `${body.task.issue_id}-${Date.now()}` : crypto.randomUUID();
+            db.run('INSERT INTO tasks (id, status, payload) VALUES (?, ?, ?)', [taskId, 'pending', JSON.stringify(body.task)]);
+            notifyWorker();
+            return Response.json({ accepted: true, task_id: taskId }, { status: 202 });
+          } catch (e) {
+            return Response.json({ error: String(e) }, { status: 400 });
+          }
+        })();
+      }
+      return new Response('not found', { status: 404 });
+    },
+  });
+  log(`🌐 Local server: http://127.0.0.1:${port}`);
+
+  // Spawn cloudflared quick tunnel
+  const cf = Bun.spawn(['cloudflared', 'tunnel', '--no-autoupdate', '--url', `http://127.0.0.1:${port}`], {
+    stdout: 'pipe', stderr: 'pipe', stdin: 'ignore',
+  });
+  const tunnelUrl = await parseTunnelUrl(cf.stderr as ReadableStream<Uint8Array>);
+  if (!tunnelUrl) {
+    log('❌ cloudflared did not emit a tunnel URL — is `cloudflared` installed? (`brew install cloudflared`)');
+    try { cf.kill(); } catch {}
+    try { server.stop(); } catch {}
+    process.exit(1);
+  }
+  log(`☁️  Tunnel up: ${tunnelUrl}`);
+
+  await apiClient.post(`${apiUrl}/api/devices/${config.deviceId}/heartbeat`, { status: 'online', tunnel_url: tunnelUrl });
 
-  const wsUrl = apiUrl.replace(/^http/, 'ws') + `/ws/devices/${config.deviceId}?token=${encodeURIComponent(config.token || '')}`;
-  let ws: WebSocket | null = null;
   let running = true;
 
   const shutdown = async (reason: string) => {
     if (!running) return;
     running = false;
     log(`🛑 Shutting down (${reason})`);
-    try { ws?.close(); } catch {}
-    await apiClient.post(`${apiUrl}/api/devices/${config.deviceId}/heartbeat`, { status: 'offline' });
+    try { server.stop(); } catch {}
+    try { cf.kill(); } catch {}
+    try { await apiClient.post(`${apiUrl}/api/devices/${config.deviceId}/heartbeat`, { status: 'offline', tunnel_url: null }); } catch {}
     if (existsSync(PID_PATH)) unlinkSync(PID_PATH);
     if (existsSync(STOP_PATH)) unlinkSync(STOP_PATH);
+    db.close();
     log('👋 Disconnected');
     process.exit(0);
   };
   process.on('SIGINT', () => shutdown('SIGINT'));
   process.on('SIGTERM', () => shutdown('SIGTERM'));
 
-  const connect = () => {
-    ws = new WebSocket(wsUrl);
-    ws.addEventListener('open', () => log(`🔌 WS connected: ${wsUrl}`));
-    ws.addEventListener('message', async (ev) => {
+  // Worker loop: drain pending tasks
+  (async () => {
+    while (running) {
+      const row = db.query("SELECT id, payload FROM tasks WHERE status = 'pending' ORDER BY created_at ASC LIMIT 1").get() as { id: string; payload: string } | null;
+      if (!row) {
+        await new Promise<void>(resolve => { workerWake = resolve; setTimeout(resolve, 5000); });
+        continue;
+      }
+      db.run("UPDATE tasks SET status = 'running', started_at = unixepoch(), attempts = attempts + 1 WHERE id = ?", [row.id]);
       try {
-        const msg = JSON.parse(typeof ev.data === 'string' ? ev.data : '');
-        if (msg.type === 'run_task') {
-          await handleRunTask(apiUrl, config.deviceId!, msg.task, detected);
-        }
+        const task = JSON.parse(row.payload);
+        await handleRunTask(apiUrl, config.deviceId!, task, detected);
+        db.run("UPDATE tasks SET status = 'done', finished_at = unixepoch() WHERE id = ?", [row.id]);
       } catch (e) {
-        log(`msg parse error: ${String(e)}`);
+        log(`task ${row.id} error: ${String(e)}`);
+        db.run("UPDATE tasks SET status = 'failed', finished_at = unixepoch(), error = ? WHERE id = ?", [String(e), row.id]);
       }
-    });
-    ws.addEventListener('close', () => {
-      if (!running) return;
-      log('⚠️  WS closed, reconnecting in 3s');
-      setTimeout(connect, 3000);
-    });
-    ws.addEventListener('error', (e) => log(`WS error: ${String((e as any).message || e)}`));
-  };
-  connect();
+    }
+  })();
 
   // Heartbeat loop
   while (running) {
     await sleep(20000);
     if (existsSync(STOP_PATH)) { await shutdown('stop flag'); break; }
     try {
-      await apiClient.post(`${apiUrl}/api/devices/${config.deviceId}/heartbeat`, { status: 'online' });
+      await apiClient.post(`${apiUrl}/api/devices/${config.deviceId}/heartbeat`, { status: 'online', tunnel_url: tunnelUrl });
     } catch (e) {
       log(`heartbeat error: ${String(e)}`);
     }
   }
 }
 
+async function pickFreePort(): Promise<number> {
+  // Bind to 0, read assigned port, close immediately.
+  for (let i = 0; i < 10; i++) {
+    const p = 40000 + Math.floor(Math.random() * 20000);
+    try {
+      const s = Bun.serve({ port: p, hostname: '127.0.0.1', fetch: () => new Response('ok') });
+      s.stop();
+      return p;
+    } catch {}
+  }
+  return 47832;
+}
+
+async function parseTunnelUrl(stream: ReadableStream<Uint8Array>): Promise<string | null> {
+  const reader = stream.getReader();
+  const dec = new TextDecoder();
+  const deadline = Date.now() + 30000;
+  let buf = '';
+  while (Date.now() < deadline) {
+    const { value, done } = await reader.read();
+    if (done) break;
+    buf += dec.decode(value, { stream: true });
+    const m = buf.match(/(https:\/\/[a-z0-9-]+\.trycloudflare\.com)/i);
+    if (m) {
+      // Keep draining in background so pipe doesn't block
+      (async () => { try { while (true) { const { done } = await reader.read(); if (done) break; } } catch {} })();
+      return m[1];
+    }
+  }
+  return null;
+}
+
 async function handleRunTask(apiUrl: string, deviceId: string, task: any, detected: { type: string; path: string }[]) {
   const issueId = task.issue_id;
   const isFollowup = !!task.followup;
@@ -522,7 +615,7 @@ async function handleRunTask(apiUrl: string, deviceId: string, task: any, detect
         cwd: workingDir,
         onEvent: eventHandler,
         onSession: async (sid) => {
-          try { await apiClient.patch(`${apiUrl}/api/issues/${issueId}`, { session_id: sid } as any); } catch {}
+          try { await apiClient.post(`${apiUrl}/api/issues/${issueId}/session`, { session_id: sid }); } catch {}
         },
       });
       log(`  acp session ${sessionId.slice(0, 8)}`);
@@ -890,10 +983,30 @@ interface Config {
   workspaceId?: string;
   apiUrl?: string;
   token?: string;
+  dispatchSecret?: string;
   // legacy
   agentId?: string;
 }
 
+function openTasksDb(): Database {
+  ensureDirs();
+  const db = new Database(TASKS_DB_PATH);
+  db.exec(`
+    CREATE TABLE IF NOT EXISTS tasks (
+      id TEXT PRIMARY KEY,
+      status TEXT NOT NULL DEFAULT 'pending',
+      payload TEXT NOT NULL,
+      attempts INTEGER NOT NULL DEFAULT 0,
+      created_at INTEGER NOT NULL DEFAULT (unixepoch()),
+      started_at INTEGER,
+      finished_at INTEGER,
+      error TEXT
+    );
+    CREATE INDEX IF NOT EXISTS idx_tasks_status ON tasks(status);
+  `);
+  return db;
+}
+
 function loadConfig(): Config {
   try {
     if (!existsSync(CONFIG_PATH)) return {};