@agentdeck/bridge 1.0.22 → 1.0.24

package/dist/daemon-server.js

@@ -102,7 +102,8 @@ import { codexTurnOutcomeFromRollout, lastAgentMessageFromCodexRollout } from '.
 import { callFoundationModelsHelper } from './foundation-models-helper.js';
 import { initModules, stopModules, createDefaultModules, } from './modules/index.js';
 import { bindHostFor, daemonModuleConfigs, describeDaemonPosture, resolveDaemonPosture, } from './network-posture.js';
-import { esp32ConnectionCount, getESP32DeviceInfo, onESP32Message, sendAuthProvisionToAll, sendWifiProvision, sendWifiProvisionToAll, handleESP32Wake, getESP32Ports, getSerialConnectionStatus, getSerialLastError, getSerialReachableBoards } from './esp32-serial.js';
+import { esp32ConnectionCount, getESP32DeviceInfo, onESP32Message, sendAuthProvisionToAll, sendWifiProvision, sendWifiProvisionToAll, handleESP32Wake, getESP32Ports, getSerialConnectionStatus, getSerialLastError, getSerialReachableBoards, releaseESP32SerialPorts } from './esp32-serial.js';
+import { clampLeaseSeconds, clearLease, readLease, writeLease } from './esp32-flash-lease.js';
 import { loadWifiConfig } from './wifi-config.js';
 import { getConnectedAdbDevices, hasAdb, getAdbDeviceCount } from './adb-reverse.js';
 import { getPixooDeviceDetails, pixooDeviceCount } from './pixoo/pixoo-bridge.js';
@@ -1134,6 +1135,10 @@ export async function startDaemon(opts) {
     /** Produces live timeline rows for observed Kiro sessions — see the class
      *  doc for why Kiro needs a producer when hook agents do not. */
     const kiroTimelineFeed = new KiroTimelineFeed();
+    /** Kiro has no CLI hooks, so transcript rows also feed APME. These maps are
+     *  bounded by the observer's current live set and discarded on disappearance. */
+    const kiroApmeSessions = new Set();
+    const kiroApmeResponseBySession = new Map();
     /** Observed Claude sessions whose AskUserQuestion PreToolUse is held open for
      *  a device answer, keyed by the bare Claude session UUID. Its presence is
      *  what makes the session's options pressable (`liveAnswerable`) and what
@@ -1647,6 +1652,62 @@ export async function startDaemon(opts) {
             }
             return;
         }
+        // ===== Serial suspend / resume (USB flashing) =====
+        // Both sit BEHIND the normal auth gate — `isAuthorizedHttpRequest()` treats
+        // same-machine as authenticated, which is exactly the audience here, so
+        // this adds no standing unauthenticated route. The one always-on pre-auth
+        // route is still `GET /health`.
+        //
+        // `agentdeck esp32 flash` calls suspend, flashes, and calls resume in a
+        // `finally`. Neither call is load-bearing on its own: expiry is enforced
+        // when the lease is READ, so a CLI that is killed mid-flash recovers with
+        // nothing running.
+        if (req.method === 'POST' && pathname === '/esp32/serial/suspend') {
+            (async () => {
+                const body = await readJsonBody(req);
+                const seconds = clampLeaseSeconds(body.seconds ?? 120);
+                const lease = writeLease({
+                    until: Date.now() + seconds * 1000,
+                    reason: typeof body.reason === 'string' ? body.reason : 'usb flash',
+                    pid: typeof body.pid === 'number' ? body.pid : undefined,
+                    board: typeof body.board === 'string' ? body.board : undefined,
+                });
+                // Refusing to OPEN is only half of it — a port this daemon already
+                // holds still blocks the flasher, and two readers on one TTY steal
+                // each other's bytes instead of failing cleanly.
+                const released = releaseESP32SerialPorts(`flash lease (${lease.board ?? 'usb flash'})`);
+                return { ok: true, until: lease.until, seconds, released };
+            })().then((result) => {
+                res.writeHead(200, { 'Content-Type': 'application/json' });
+                res.end(JSON.stringify(result));
+            }).catch((err) => {
+                res.writeHead(500, { 'Content-Type': 'application/json' });
+                res.end(JSON.stringify({ ok: false, error: err instanceof Error ? err.message : String(err) }));
+            });
+            return;
+        }
+        if (req.method === 'POST' && pathname === '/esp32/serial/resume') {
+            // Idempotent by contract: resuming when nothing is suspended is a
+            // success. The CLI calls this from a `finally`, where it may well run
+            // after the lease has already expired on its own.
+            const was = readLease();
+            clearLease();
+            res.writeHead(200, { 'Content-Type': 'application/json' });
+            res.end(JSON.stringify({ ok: true, wasSuspended: was !== null }));
+            return;
+        }
+        if (req.method === 'GET' && pathname === '/esp32/serial/status') {
+            const lease = readLease();
+            res.writeHead(200, { 'Content-Type': 'application/json' });
+            res.end(JSON.stringify({
+                ok: true,
+                suspended: lease !== null,
+                until: lease?.until,
+                board: lease?.board,
+                ports: getESP32Ports(),
+            }));
+            return;
+        }
         if (req.method === 'POST' && pathname === '/esp32/ota') {
             (async () => {
                 const body = await readJsonBody(req);
@@ -3512,11 +3573,46 @@ export async function startDaemon(opts) {
         // beside it stays empty. #218 taught the per-session QUERY to read Kiro's
         // own transcript; the main timeline is a STREAM, and this is what feeds it.
         try {
-            const kiroIds = passiveSessionObserver.collect([])
-                .filter((s) => typeof s.agentType === 'string' && s.agentType.startsWith('kiro'))
-                .map((s) => s.id);
+            const observedKiro = passiveSessionObserver.collect([])
+                .filter((s) => typeof s.agentType === 'string' && s.agentType.startsWith('kiro'));
+            const kiroIds = observedKiro.map((s) => s.id);
+            const projectBySession = new Map(observedKiro.map((s) => [rawSessionId(s.id), s.projectName]));
+            const currentSessions = new Set(kiroIds.map(rawSessionId));
+            for (const sessionId of kiroApmeSessions) {
+                if (currentSessions.has(sessionId))
+                    continue;
+                apme?.collector.closeRun(sessionId);
+                kiroApmeSessions.delete(sessionId);
+                kiroApmeResponseBySession.delete(sessionId);
+            }
             for (const entry of kiroTimelineFeed.pump(kiroIds)) {
                 core.bridgeTimeline.addEntry(entry);
+                if (!apme || !entry.sessionId)
+                    continue;
+                const sessionId = rawSessionId(entry.sessionId);
+                if (entry.type === 'chat_start') {
+                    if (!apme.collector.getRunId(sessionId)) {
+                        apme.collector.openRun({
+                            sessionId,
+                            agentType: 'kiro-cli',
+                            projectName: projectBySession.get(sessionId) ?? undefined,
+                        });
+                    }
+                    kiroApmeSessions.add(sessionId);
+                    kiroApmeResponseBySession.delete(sessionId);
+                    apme.collector.ingestHook(sessionId, 'user_prompt_submit', {
+                        prompt: entry.detail || entry.raw,
+                        agent_type: 'kiro-cli',
+                        project_name: projectBySession.get(sessionId),
+                    });
+                }
+                else if (entry.type === 'chat_response' && apme.collector.getRunId(sessionId)) {
+                    const piece = entry.detail || entry.raw;
+                    const response = [kiroApmeResponseBySession.get(sessionId), piece].filter(Boolean).join('\n');
+                    kiroApmeResponseBySession.set(sessionId, response);
+                    apme.collector.setTurnResponse(sessionId, response);
+                    apme.collector.noteTurnStop(sessionId);
+                }
             }
         }
         catch (err) {