@addai/node 0.28.0 → 0.29.1

package/dist/command-runner.js

@@ -724,12 +724,17 @@ async function runDesktopCommand(cmd) {
                 break;
             }
             case 'desktop_start': {
-                // Someone pressed start, so this one fails loudly rather than
-                // deferring quietly the way autostart does. They are owed an answer
-                // they can act on: which limit, and where to change it.
+                // A full machine used to be a hard failure here, which left an entity
+                // with nothing to do but ask again and hope. It waits instead: the
+                // request keeps its place and the reconciler starts it when a slot
+                // frees. Said out loud, because a desktop that is "not starting yet"
+                // and one that is broken look identical from the outside.
                 const room = await (0, manager_1.desktopStartAllowed)(await (0, manager_1.listDesktops)(), row.id);
-                if (!room.allowed)
-                    throw new Error(room.reason);
+                if (!room.allowed) {
+                    await (0, manager_1.setStatus)(row.id, { status: 'queued', status_message: room.reason });
+                    onLog(`${room.reason}\nWaiting for a free slot — this desktop keeps its place in the queue.\n`);
+                    break;
+                }
                 await (0, manager_1.setStatus)(row.id, { status: 'starting' });
                 await provider.start(row);
                 await (0, manager_1.setStatus)(row.id, { status: 'running', status_message: null });

package/dist/desktop/manager.d.ts

@@ -35,6 +35,10 @@ export declare function maxConcurrentDesktops(): number;
  *  tracked in a counter. A counter would drift the moment somebody stopped a
  *  container by hand, and drift upward means refusing to start anything. */
 export declare function runningDesktopCount(rows: DesktopRow[]): Promise<number>;
+/** Oldest waiter first, everything else after. Without this the order is
+ *  whatever the listing happened to return, which is how a desktop ends up
+ *  waiting behind one that asked after it. */
+export declare function queueOrder<T extends Pick<DesktopRow, 'status' | 'queued_at'>>(rows: T[]): T[];
 /** Whether one more may start. Returns the reason when it may not, so the
  *  caller can say something better than "failed". */
 export declare function desktopStartAllowed(rows: DesktopRow[], excludeId?: string): Promise<{

package/dist/desktop/manager.js

@@ -43,6 +43,7 @@ exports.clampMaxDesktops = clampMaxDesktops;
 exports.setMaxConcurrentDesktops = setMaxConcurrentDesktops;
 exports.maxConcurrentDesktops = maxConcurrentDesktops;
 exports.runningDesktopCount = runningDesktopCount;
+exports.queueOrder = queueOrder;
 exports.desktopStartAllowed = desktopStartAllowed;
 exports.startDesktopManager = startDesktopManager;
 exports.stopDesktopManager = stopDesktopManager;
@@ -68,6 +69,11 @@ function reconcileAction(row, actual) {
         || row.status === 'deleting' || row.status === 'pending'
         || row.status === 'failed')
         return 'none';
+    // Waiting for a slot. The tick retries it every pass; whether there is room
+    // yet is decided there, because it depends on every OTHER desktop, not this
+    // one. Somebody starting it by hand in the meantime just resolves the wait.
+    if (row.status === 'queued')
+        return actual?.running ? 'mark_running' : 'start';
     if (actual === null) {
         // The row says this exists and it does not. Someone pruned it by hand.
         return row.status === 'running' || row.status === 'stopped' ? 'mark_failed' : 'none';
@@ -176,6 +182,23 @@ async function runningDesktopCount(rows) {
     }
     return count;
 }
+/** When a desktop asked for its slot, as a sortable number. A waiter whose
+ *  stamp is missing or unreadable goes to the BACK, not the front: Date.parse
+ *  returns NaN for those, every NaN comparison is false, and a comparator that
+ *  returns NaN is treated as 0 — so the unstamped row would quietly keep
+ *  whatever position the listing gave it and cut in front of real waiters. */
+function waitingSince(row) {
+    if (row.status !== 'queued')
+        return Number.POSITIVE_INFINITY;
+    const at = Date.parse(row.queued_at ?? '');
+    return Number.isFinite(at) ? at : Number.POSITIVE_INFINITY;
+}
+/** Oldest waiter first, everything else after. Without this the order is
+ *  whatever the listing happened to return, which is how a desktop ends up
+ *  waiting behind one that asked after it. */
+function queueOrder(rows) {
+    return [...rows].sort((a, b) => waitingSince(a) - waitingSince(b));
+}
 /** Whether one more may start. Returns the reason when it may not, so the
  *  caller can say something better than "failed". */
 async function desktopStartAllowed(rows, excludeId) {
@@ -199,7 +222,7 @@ async function tick() {
         if (!provider)
             return; // no engine: nothing to reconcile
         const rows = await listDesktops();
-        for (const row of rows) {
+        for (const row of queueOrder(rows)) {
             const actual = await provider.inspect(row);
             const action = reconcileAction(row, actual);
             if (action === 'none')
@@ -212,7 +235,13 @@ async function tick() {
                     // failing — nothing is wrong with the desktop, there is just no room.
                     const room = await desktopStartAllowed(rows, row.id);
                     if (!room.allowed) {
-                        await setStatus(row.id, { status: 'stopped', status_message: room.reason });
+                        // Stay in the queue rather than dropping out of it. A desktop that
+                        // fell back to 'stopped' here would need asking for all over again,
+                        // which is exactly what waiting is supposed to save you.
+                        // queued_at is stamped by the status RPC, which keeps the
+                        // original on a re-queue — a desktop must not lose its place in
+                        // the line every time the reconciler looks at it.
+                        await setStatus(row.id, { status: 'queued', status_message: room.reason });
                         continue;
                     }
                     await provider.start(row);

package/dist/desktop/spec.d.ts

@@ -13,8 +13,11 @@ export interface DesktopRow {
     enabled_skills: string[];
     enabled_packages: string[];
     autostart: boolean;
-    status: 'pending' | 'creating' | 'starting' | 'running' | 'stopped' | 'failed' | 'deleting';
+    status: 'pending' | 'creating' | 'starting' | 'running' | 'stopped' | 'failed' | 'deleting' | 'queued';
     status_message: string | null;
+    /** Set while this desktop is waiting for a slot on a full machine. The node
+     *  serves its queue oldest-first, so this is the place in the line. */
+    queued_at?: string | null;
     vnc_port: number | null;
     vnc_password: string | null;
 }

package/dist/tui/run.js

@@ -91,6 +91,9 @@ function createConsole(build, hooks = {}) {
     function onKeypress(_s, key) {
         void app.handleKey(key);
     }
+    function onStdinError() {
+        teardown();
+    }
     function attachInput() {
         if (inputAttached)
             return;
@@ -99,12 +102,20 @@ function createConsole(build, hooks = {}) {
             process.stdin.setRawMode(true);
         process.stdin.resume();
         process.stdin.on('keypress', onKeypress);
+        // A terminal can be taken away mid-read: an ssh session drops, a window
+        // closes. The read then fails with EIO, and an 'error' with no listener is
+        // a thrown exception in node — the process dies without ever running
+        // teardown, so raw mode is never turned off and the shell that inherits
+        // the terminal reports its own "error on TTY read" afterwards. Treat it as
+        // what it is: the terminal is gone, so put it back and leave quietly.
+        process.stdin.on('error', onStdinError);
         inputAttached = true;
     }
     function detachInput() {
         if (!inputAttached)
             return;
         process.stdin.off('keypress', onKeypress);
+        process.stdin.off('error', onStdinError);
         if (process.stdin.isTTY)
             process.stdin.setRawMode(false);
         process.stdin.pause();
@@ -142,6 +153,16 @@ function createConsole(build, hooks = {}) {
             draw();
         }
     };
+    // Backgrounding a TUI is not an error, but reading the terminal from a
+    // background process group earns SIGTTIN, and the default action is to STOP
+    // the process — which is what "zsh: suspended (tty input)" is. Stopped mid-
+    // draw it still holds the terminal in raw mode, so the session it was
+    // sharing degrades too. Stop reading and leave instead; the daemon is a
+    // separate process and keeps running either way.
+    process.on('SIGTTIN', teardown);
+    process.on('SIGTTOU', teardown);
+    // The terminal went away without the read failing first.
+    process.on('SIGHUP', teardown);
     app.replace(build(app, suspend));
     return {
         host: app,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@addai/node",
-  "version": "0.28.0",
+  "version": "0.29.1",
   "description": "Daemon that pairs a machine with your +Ai account and runs Claude / Codex / Kimi / Gemini agents on its behalf. Reachable via Supabase from Vault, Entity Studio, or any other +Ai surface.",
   "license": "MIT",
   "keywords": [