sliccy 6.105.1 → 6.106.0

package/README.md

@@ -187,29 +187,31 @@ Why the name? SLICC stands for **Self-Licking Ice Cream Cone**: a recursive syst
 
 ## Keyboard mode
 
-SLICC's main control is a text field, so it has no always-on shortcuts to collide with your typing. Instead it has a **mode**, like vim: press <kbd>Esc</kbd> to leave the composer and enter keyboard mode, and every key below is a bare letter. Press <kbd>Esc</kbd> again to leave (a second press is also what exits full screen — the first one belongs to the mode). While the mode is on, a pill above the composer says so.
-
-| Key                                        | Action                                                      |
-| ------------------------------------------ | ----------------------------------------------------------- |
-| <kbd>Esc</kbd>                             | Enter keyboard mode — press again to leave                  |
-| <kbd>1</kbd>…<kbd>9</kbd>                  | Switch to that agent in the tab strip (<kbd>9</kbd> = last) |
-| <kbd>d</kbd>                               | Next agent, looping                                         |
-| <kbd>c</kbd> or <kbd>⏎</kbd>               | Back to the composer                                        |
-| <kbd>n</kbd>                               | New conversation                                            |
-| <kbd>b</kbd>                               | Toggle the left rail                                        |
-| <kbd>x</kbd>                               | Toggle the right panel                                      |
-| <kbd>f</kbd>                               | File browser                                                |
-| <kbd>t</kbd>                               | Browser tabs                                                |
-| <kbd>e</kbd>                               | Terminal                                                    |
-| <kbd>m</kbd>                               | Memory                                                      |
-| <kbd>s</kbd>                               | Sprinkles, looping                                          |
-| <kbd>l</kbd>                               | Model picker                                                |
-| <kbd>a</kbd>                               | Accounts                                                    |
-| <kbd>h</kbd>, <kbd>?</kbd> or <kbd>/</kbd> | This list, in an overlay                                    |
+SLICC's main control is a text field, so it has no always-on shortcuts to collide with your typing. Instead it has a **mode**, like vim — and, like vim, the mode is where you rest: keyboard mode is on whenever nothing is focused for typing, and every key below is a bare letter. Press <kbd>Esc</kbd> to leave the composer for it, or just click somewhere that is not a text field. To type again, press <kbd>⏎</kbd> or <kbd>c</kbd> (or click into the composer). While the mode is on, a pill above the composer says so.
+
+| Key                                        | Action                                                         |
+| ------------------------------------------ | -------------------------------------------------------------- |
+| <kbd>Esc</kbd>                             | Leave the composer for keyboard mode (again: exit full screen) |
+| <kbd>1</kbd>…<kbd>9</kbd>                  | Switch to that agent in the tab strip (<kbd>9</kbd> = last)    |
+| <kbd>d</kbd>                               | Next agent, looping                                            |
+| <kbd>c</kbd> or <kbd>⏎</kbd>               | Back to the composer                                           |
+| <kbd>n</kbd>                               | New conversation                                               |
+| <kbd>b</kbd>                               | Toggle the left rail                                           |
+| <kbd>x</kbd>                               | Toggle the right panel                                         |
+| <kbd>f</kbd>                               | File browser                                                   |
+| <kbd>t</kbd>                               | Browser tabs                                                   |
+| <kbd>e</kbd>                               | Terminal                                                       |
+| <kbd>m</kbd>                               | Memory                                                         |
+| <kbd>s</kbd>                               | Sprinkles, looping                                             |
+| <kbd>l</kbd>                               | Model picker                                                   |
+| <kbd>a</kbd>                               | Accounts                                                       |
+| <kbd>h</kbd>, <kbd>?</kbd> or <kbd>/</kbd> | This list, in an overlay                                       |
 
 Every key you press shows up as a cap on the pill — dimmed if it was not bound to anything, so a mistyped key reads as "that did nothing" rather than as a dead keyboard. The strip clears after a moment of quiet.
 
-Keys that navigate, or toggle chrome (digits, <kbd>d</kbd>, <kbd>b</kbd>, <kbd>x</kbd>, <kbd>s</kbd>, help), keep the mode on; anything that hands focus to a surface leaves it, as does clicking into any text field. Outside the mode nothing is intercepted at all. The overlay is also in the avatar menu, under **Keyboard mode**.
+Keys that navigate, or toggle chrome (digits, <kbd>d</kbd>, <kbd>b</kbd>, <kbd>x</kbd>, <kbd>s</kbd>, help), keep the mode on; anything that hands focus to a text field leaves it, whether that is a shortcut, a click, or a panel that opens with a field ready. Inside a text field nothing is intercepted at all, and a focused button keeps its own <kbd>⏎</kbd> and <kbd>Space</kbd>. The overlay is also in the avatar menu, under **Keyboard mode**.
+
+**Switching agents keeps your place.** The mode you were in when you left a cone is the mode you land back in: leave it typing and the caret is waiting in the new cone's composer, leave it in keyboard mode and the pill is still up. A scoop's transcript is read-only and has no composer at all, so it always puts you in keyboard mode — but it does not overwrite what you left behind, so cone → scoop → cone gives your caret back.
 
 **Rebinding.** The keys live in `/etc/slicc/keys.json` in the VFS, written the first time SLICC starts and never touched again — edit it and reload the tab. Each entry maps a key to a command (`"q": "terminal"`) and several keys can share one command. The file is applied _over_ the built-in keymap, so `null` removes a binding while deleting the line just restores its default — which is also how you inherit any keys a later version adds. The file lists every command it accepts. <kbd>Esc</kbd> and the digits are reserved. A bad line is skipped with a warning rather than costing you the rest of the file, and the help overlay always shows what is actually bound.
 

package/dist/node-server/_cloud_core/src/operations/list.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"list.d.ts","sourceRoot":"","sources":["../../../src/operations/list.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,gBAAgB,CAAC;AAC/C,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,iBAAiB,CAAC;AACxD,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,aAAa,CAAC;AAE7C,MAAM,WAAW,aAAa;IAC5B,SAAS,EAAE,gBAAgB,CAAC;IAC5B,QAAQ,EAAE,QAAQ,CAAC;CACpB;AAED,MAAM,WAAW,aAAa;IAC5B;;;;OAIG;IACH,QAAQ,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;CACnC;AAED;;;;;;;GAOG;AACH,wBAAsB,SAAS,CAC7B,IAAI,EAAE,aAAa,EACnB,IAAI,GAAE,aAAkB,GACvB,OAAO,CAAC,SAAS,EAAE,CAAC,CA8ItB"}
+{"version":3,"file":"list.d.ts","sourceRoot":"","sources":["../../../src/operations/list.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,gBAAgB,CAAC;AAC/C,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,iBAAiB,CAAC;AACxD,OAAO,KAAK,EAAE,SAAS,EAAkB,MAAM,aAAa,CAAC;AAE7D,MAAM,WAAW,aAAa;IAC5B,SAAS,EAAE,gBAAgB,CAAC;IAC5B,QAAQ,EAAE,QAAQ,CAAC;CACpB;AAED,MAAM,WAAW,aAAa;IAC5B;;;;OAIG;IACH,QAAQ,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;CACnC;AAwLD;;;;;;;GAOG;AACH,wBAAsB,SAAS,CAC7B,IAAI,EAAE,aAAa,EACnB,IAAI,GAAE,aAAkB,GACvB,OAAO,CAAC,SAAS,EAAE,CAAC,CA8BtB"}

package/dist/node-server/_cloud_core/src/operations/list.js

@@ -1,3 +1,146 @@
+const STALE_RESERVATION_MS = 10 * 60 * 1000;
+const DEFAULT_TTL_MS = 60 * 60 * 1000;
+/** True when entry metadata matches every key/value in the filter (or no filter). */
+function matchesMetadataFilter(entry, metadata) {
+    if (!metadata)
+        return true;
+    if (!entry.metadata)
+        return false;
+    for (const [k, v] of Object.entries(metadata)) {
+        if (entry.metadata[k] !== v)
+            return false;
+    }
+    return true;
+}
+function isStaleReservation(entry) {
+    // Reclaim if stale OR if reservedAt is missing (legacy/malformed entry
+    // from before commit e9011ba6 — could otherwise wedge cap forever).
+    if (!entry.reservedAt)
+        return true;
+    return Date.now() - new Date(entry.reservedAt).getTime() > STALE_RESERVATION_MS;
+}
+/**
+ * Handle a reserved registry entry: reclaim if stale, otherwise keep.
+ * Returns the entry to include in the reconciled list, or null if reclaimed.
+ */
+async function reconcileReserved(entry, registry) {
+    if (!isStaleReservation(entry))
+        return entry;
+    await registry.remove(entry.sandboxId);
+    console.warn('[cloud-core] reclaimed stale reservation', {
+        sandboxId: entry.sandboxId,
+        reservedAt: entry.reservedAt ?? '(missing)',
+    });
+    return null;
+}
+/** Mark a missing real sandbox dead (idempotent registry write). */
+async function markDead(entry, registry) {
+    if (entry.state !== 'dead') {
+        await registry.update(entry.sandboxId, { state: 'dead' });
+    }
+    return { ...entry, state: 'dead' };
+}
+/**
+ * Reconcile one non-reserved registry entry against live substrate state.
+ * Mutates liveById (deletes matched sandbox ids).
+ */
+async function reconcileLiveEntry(entry, liveById, registry) {
+    const liveEntry = liveById.get(entry.sandboxId);
+    if (!liveEntry) {
+        // Substrate doesn't know about it — mark dead unless it's a placeholder.
+        // The 'pending-' prefix is a sentinel for "no real sandbox yet" (paired
+        // with state:'reserved' by reserveSlot before substrate.create).
+        if (entry.sandboxId.startsWith('pending-')) {
+            return entry;
+        }
+        return markDead(entry, registry);
+    }
+    if (entry.state !== liveEntry.state) {
+        await registry.update(entry.sandboxId, { state: liveEntry.state });
+    }
+    liveById.delete(entry.sandboxId);
+    return { ...entry, state: liveEntry.state };
+}
+async function reconcileRegistryEntry(entry, liveById, registry) {
+    // Reserved entries: check for stale reservations (TTL: 10 min) and reclaim.
+    // Stale reservations are from crashed operations that never completed or rolled back.
+    if (entry.state === 'reserved') {
+        return reconcileReserved(entry, registry);
+    }
+    return reconcileLiveEntry(entry, liveById, registry);
+}
+/**
+ * Recover joinUrl from /tmp/slicc-join.json ONLY when sandbox is running.
+ * Calling substrate.connect() on a paused sandbox would RESUME it, which:
+ * (a) burns sandbox runtime silently
+ * (b) destabilizes the leader chromium mid-list
+ * Paused orphans surface with joinUrl='' — UI hides the Open button.
+ */
+async function recoverJoinFromSandbox(summary, substrate, seed) {
+    if (seed.joinUrl || summary.state !== 'running')
+        return seed;
+    try {
+        const handle = await substrate.connect(summary.sandboxId);
+        const joinData = await handle.readFile('/tmp/slicc-join.json');
+        const parsed = JSON.parse(joinData);
+        return {
+            joinUrl: parsed.joinUrl ?? '',
+            trayId: seed.trayId ?? parsed.trayId,
+            lastJoinUpdatedAt: seed.lastJoinUpdatedAt ?? parsed.updatedAt,
+        };
+    }
+    catch (err) {
+        // File not readable (sandbox is transitioning, or file doesn't exist).
+        // Leave joinUrl empty — UI will handle gracefully.
+        const msg = err instanceof Error ? err.message : String(err);
+        console.warn('[cloud-core] orphan recovery readFile failed', {
+            sandboxId: summary.sandboxId,
+            err: msg,
+        });
+        return seed;
+    }
+}
+/** Rebuild a ConeEntry for a substrate sandbox missing from the registry. */
+async function recoverOrphan(summary, substrate) {
+    const now = new Date().toISOString();
+    const recoveredJoin = await recoverJoinFromSandbox(summary, substrate, {
+        joinUrl: summary.metadata?.['joinUrl'] ?? '',
+        trayId: summary.metadata?.['trayId'],
+        lastJoinUpdatedAt: summary.metadata?.['lastJoinUpdatedAt'],
+    });
+    return {
+        sandboxId: summary.sandboxId,
+        substrate: 'e2b',
+        name: summary.metadata?.['name'] ?? summary.name,
+        createdAt: summary.metadata?.['createdAt'] ?? now,
+        joinUrl: recoveredJoin.joinUrl,
+        lastSeen: now,
+        state: summary.state,
+        trayId: recoveredJoin.trayId,
+        lastJoinUpdatedAt: recoveredJoin.lastJoinUpdatedAt,
+        metadata: summary.metadata,
+    };
+}
+/**
+ * Refresh the timeout of every running cone so active users keep their cones
+ * alive past the 1h default. Failures are non-fatal — a sandbox that
+ * disappears between substrate.list() and extendTimeout() will be discovered
+ * dead on the NEXT list call.
+ */
+async function extendRunningTimeouts(cones, substrate) {
+    await Promise.all(cones
+        .filter((c) => c.state === 'running')
+        .map(async (c) => {
+        try {
+            await substrate.extendTimeout(c.sandboxId, DEFAULT_TTL_MS);
+        }
+        catch (err) {
+            // Sandbox may have died between list and extendTimeout; ignore.
+            const msg = err instanceof Error ? err.message : String(err);
+            console.warn('[cloud-core] extendTimeout failed', { sandboxId: c.sandboxId, err: msg });
+        }
+    }));
+}
 /**
  * List cones reconciling registry against substrate.
  * - Substrate is source of truth for state (running/paused).
@@ -11,18 +154,6 @@ export async function listCones(deps, opts = {}) {
     // Pass metadata filter to substrate.list for server-side filtering
     const live = await deps.substrate.list(opts.metadata ? { metadata: opts.metadata } : undefined);
     const liveById = new Map(live.map((s) => [s.sandboxId, s]));
-    // Helper to check if an entry matches the metadata filter
-    const matchesFilter = (entry) => {
-        if (!opts.metadata)
-            return true;
-        if (!entry.metadata)
-            return false;
-        for (const [k, v] of Object.entries(opts.metadata)) {
-            if (entry.metadata[k] !== v)
-                return false;
-        }
-        return true;
-    };
     // Pass 1: walk registry; reconcile against live.
     // Reconciliation runs for EVERY registry entry regardless of metadata filter
     // — otherwise zombie entries (e.g. legacy entries without userId metadata)
@@ -31,115 +162,18 @@ export async function listCones(deps, opts = {}) {
     // per-user view.
     const reconciled = [];
     for (const entry of registryEntries) {
-        // Reserved entries: check for stale reservations (TTL: 10 min) and reclaim.
-        // Stale reservations are from crashed operations that never completed or rolled back.
-        if (entry.state === 'reserved') {
-            const STALE_MS = 10 * 60 * 1000;
-            // Reclaim if stale OR if reservedAt is missing (legacy/malformed entry
-            // from before commit e9011ba6 — could otherwise wedge cap forever).
-            const isStale = !entry.reservedAt || Date.now() - new Date(entry.reservedAt).getTime() > STALE_MS;
-            if (isStale) {
-                await deps.registry.remove(entry.sandboxId);
-                console.warn('[cloud-core] reclaimed stale reservation', {
-                    sandboxId: entry.sandboxId,
-                    reservedAt: entry.reservedAt ?? '(missing)',
-                });
-                continue;
-            }
-            // Active reservation — preserve as-is (in-flight operation holding a cap slot)
-            reconciled.push(entry);
-            continue;
-        }
-        const liveEntry = liveById.get(entry.sandboxId);
-        if (!liveEntry) {
-            // Substrate doesn't know about it — mark dead unless it's a placeholder.
-            // The 'pending-' prefix is a sentinel for "no real sandbox yet" (paired
-            // with state:'reserved' by reserveSlot before substrate.create).
-            if (entry.sandboxId.startsWith('pending-')) {
-                // Reservation placeholder — no real sandbox yet. Keep it alive.
-                reconciled.push(entry);
-            }
-            else {
-                // Real sandbox is missing — mark dead
-                if (entry.state !== 'dead') {
-                    await deps.registry.update(entry.sandboxId, { state: 'dead' });
-                }
-                reconciled.push({ ...entry, state: 'dead' });
-            }
-            continue;
-        }
-        if (entry.state !== liveEntry.state) {
-            await deps.registry.update(entry.sandboxId, { state: liveEntry.state });
-        }
-        reconciled.push({ ...entry, state: liveEntry.state });
-        liveById.delete(entry.sandboxId);
+        const next = await reconcileRegistryEntry(entry, liveById, deps.registry);
+        if (next)
+            reconciled.push(next);
     }
     // Pass 2: any substrate entries not in registry → recover.
     for (const summary of liveById.values()) {
-        const now = new Date().toISOString();
-        // Try to read the real joinUrl from the sandbox. Orphans created before this
-        // fix won't have it in metadata, but we can read /tmp/slicc-join.json directly.
-        let joinUrl = summary.metadata?.['joinUrl'] ?? '';
-        let trayId = summary.metadata?.['trayId'];
-        let lastJoinUpdatedAt = summary.metadata?.['lastJoinUpdatedAt'];
-        // Recover joinUrl from /tmp/slicc-join.json ONLY when sandbox is running.
-        // Calling substrate.connect() on a paused sandbox would RESUME it, which:
-        // (a) burns sandbox runtime silently
-        // (b) destabilizes the leader chromium mid-list
-        // Paused orphans surface with joinUrl='' — UI hides the Open button.
-        // User explicitly resumes via /api/cloud/resume which writes a fresh joinUrl.
-        if (!joinUrl && summary.state === 'running') {
-            try {
-                const handle = await deps.substrate.connect(summary.sandboxId);
-                const joinData = await handle.readFile('/tmp/slicc-join.json');
-                const parsed = JSON.parse(joinData);
-                joinUrl = parsed.joinUrl ?? '';
-                trayId = trayId ?? parsed.trayId;
-                lastJoinUpdatedAt = lastJoinUpdatedAt ?? parsed.updatedAt;
-            }
-            catch (err) {
-                // File not readable (sandbox is transitioning, or file doesn't exist).
-                // Leave joinUrl empty — UI will handle gracefully.
-                const msg = err instanceof Error ? err.message : String(err);
-                console.warn('[cloud-core] orphan recovery readFile failed', {
-                    sandboxId: summary.sandboxId,
-                    err: msg,
-                });
-            }
-        }
-        const recovered = {
-            sandboxId: summary.sandboxId,
-            substrate: 'e2b',
-            name: summary.metadata?.['name'] ?? summary.name,
-            createdAt: summary.metadata?.['createdAt'] ?? now,
-            joinUrl,
-            lastSeen: now,
-            state: summary.state,
-            trayId,
-            lastJoinUpdatedAt,
-            metadata: summary.metadata,
-        };
+        const recovered = await recoverOrphan(summary, deps.substrate);
         await deps.registry.append(recovered);
         reconciled.push(recovered);
     }
-    // Refresh the timeout of every running cone so active users keep their cones
-    // alive past the 1h default. Failures are non-fatal — a sandbox that
-    // disappears between substrate.list() and extendTimeout() will be discovered
-    // dead on the NEXT list call.
-    const DEFAULT_TTL_MS = 60 * 60 * 1000;
-    await Promise.all(reconciled
-        .filter((c) => c.state === 'running')
-        .map(async (c) => {
-        try {
-            await deps.substrate.extendTimeout(c.sandboxId, DEFAULT_TTL_MS);
-        }
-        catch (err) {
-            // Sandbox may have died between list and extendTimeout; ignore.
-            const msg = err instanceof Error ? err.message : String(err);
-            console.warn('[cloud-core] extendTimeout failed', { sandboxId: c.sandboxId, err: msg });
-        }
-    }));
+    await extendRunningTimeouts(reconciled, deps.substrate);
     // Apply the metadata filter to the RETURN value only — reconciliation
     // above ran on all entries to keep zombies from accumulating.
-    return reconciled.filter(matchesFilter);
+    return reconciled.filter((e) => matchesMetadataFilter(e, opts.metadata));
 }

package/dist/node-server/electron-federated-cdp.d.ts

@@ -1,4 +1,4 @@
-import { type FollowerToLeaderMessage } from './_shared/index.js';
+import { type CDPPayload, type FollowerToLeaderMessage } from './_shared/index.js';
 /** A CDP target as returned by `/json/list`. */
 export interface FederatedCdpInspectableTarget {
     id: string;
@@ -12,7 +12,8 @@ export interface FederatedCdpRequest {
     requestId: string;
     localTargetId: string;
     method: string;
-    params?: Record<string, unknown>;
+    /** Per-method CDP params; shape is known only to the caller that issued the method. */
+    params?: CDPPayload;
     sessionId?: string;
 }
 /**
@@ -30,7 +31,7 @@ export declare function buildTargetsAdvertise(runtimeId: string, targets: Federa
  * oversize result is split into `chunkData` frames the leader reassembles.
  */
 export declare function buildCdpResponses(requestId: string, outcome: {
-    result?: Record<string, unknown>;
+    result?: CDPPayload;
     error?: string;
 }): Array<Extract<FollowerToLeaderMessage, {
     type: 'cdp.response';
@@ -38,7 +39,8 @@ export declare function buildCdpResponses(requestId: string, outcome: {
 /** Translate a raw CDP event frame into a `cdp.event` tray-sync message. */
 export declare function buildCdpEvent(frame: {
     method: string;
-    params?: Record<string, unknown>;
+    /** Per-method CDP event params; shape depends on `method`. */
+    params?: CDPPayload;
     sessionId?: string;
 }): Extract<FollowerToLeaderMessage, {
     type: 'cdp.event';