@skrr-ai/cli 0.1.78 → 0.1.79

package/dist/lib/dedicated-lease-command.js

@@ -129,6 +129,7 @@ class DedicatedLeaseCommand extends base_command_1.BaseCommand {
                 ...(flags.cwd ? { cwd: flags.cwd } : {}),
                 ...(initialCommand ? { initialCommand } : {}),
                 persistent,
+                resumeExistingSupported: capabilities.includes('persistent_terminal_resume_v1'),
                 ...(sessionName ? { sessionName } : {}),
                 leaseId,
                 input: process.stdin,

package/dist/lib/dedicated-terminal.d.ts

@@ -27,6 +27,7 @@ export interface TerminalOutputFrame {
     encoding?: 'utf8' | 'base64';
     exitCode?: number | null;
     signal?: string | null;
+    code?: string;
 }
 export interface TerminalStartAck {
     sessionId?: string;
@@ -66,6 +67,8 @@ export interface DedicatedTerminalOptions {
      * capability before asking.
      */
     persistent?: boolean;
+    /** Capability-gated recovery can attach only an existing named shell. */
+    resumeExistingSupported?: boolean;
     /**
      * The session suffix (`skrr-term-<name>`). The same name re-attaches the
      * same session; omitted under `persistent`, the machine names the session

package/dist/lib/dedicated-terminal.js

@@ -67,6 +67,9 @@ function describeTerminalStartRefusal(ack) {
     if (code === 'DEDICATED_RUNTIME_GENERATION_STALE') {
         return 'The machine was replaced since its daemon registered. Wait a minute and try again.';
     }
+    if (code === 'persistent-session-missing') {
+        return 'The original terminal no longer exists. Start a new terminal explicitly; no replacement shell was opened.';
+    }
     if (code === 'not_found' || code === 'offline') {
         return 'The machine’s daemon is not connected. Wait for it to come online and try again.';
     }
@@ -94,6 +97,9 @@ function runDedicatedTerminal(options) {
         let sessionReady = false;
         let reattaching = false;
         let persistentName = options.sessionName;
+        let retryTimer;
+        let recoveryTimer;
+        let connected = false;
         const socket = connect((0, agentic_stream_1.toWebSocketOrigin)(options.baseURL), {
             path: '/ws/agentic',
             auth: {
@@ -170,6 +176,10 @@ function runDedicatedTerminal(options) {
         const onSigterm = () => finish(143, true);
         const onSighup = () => finish(129, true);
         const onStartTimeout = () => {
+            if (reattaching) {
+                scheduleRetry();
+                return;
+            }
             fail(new DedicatedTerminalError('The machine did not answer the terminal start in time. Its daemon may be busy or offline.', 'TERMINAL_START_TIMEOUT'));
         };
         let startTimer = setTimeout(onStartTimeout, exports.TERMINAL_START_TIMEOUT_MS);
@@ -190,6 +200,8 @@ function runDedicatedTerminal(options) {
                 return;
             finished = true;
             clearTimeout(startTimer);
+            clearTimeout(retryTimer);
+            clearTimeout(recoveryTimer);
             pending?.close();
             restoreTty();
             detachReconnectFailed();
@@ -203,6 +215,8 @@ function runDedicatedTerminal(options) {
                 return;
             finished = true;
             clearTimeout(startTimer);
+            clearTimeout(retryTimer);
+            clearTimeout(recoveryTimer);
             pending?.close();
             restoreTty();
             detachReconnectFailed();
@@ -212,15 +226,19 @@ function runDedicatedTerminal(options) {
         socket.on('connect_error', (err) => {
             // A failed retry while reattaching is not fatal — the attempt countdown
             // keeps running and `reconnect_failed` ends it if they all miss.
-            if (persistent && reattaching)
+            if (persistent && reattaching && !err.data?.code)
                 return;
             fail(new DedicatedTerminalError(`Could not connect to skrr: ${err.message}`, err.data?.code || 'TERMINAL_CONNECT_FAILED'));
         });
-        socket.on('connect', () => {
-            if (finished)
+        function sendStart() {
+            if (finished || !connected)
                 return;
+            // Clear the previous relay entry too; never replay bytes sent before loss.
+            if (sessionId)
+                socket.emit(events.stop, { sessionId });
             sessionId = (0, node_crypto_1.randomUUID)();
             clearTimeout(startTimer);
+            clearTimeout(retryTimer);
             startTimer = setTimeout(onStartTimeout, exports.TERMINAL_START_TIMEOUT_MS);
             startTimer.unref();
             socket.emit(events.start, {
@@ -228,13 +246,44 @@ function runDedicatedTerminal(options) {
                 sessionId,
                 ...(options.cwd ? { cwd: options.cwd } : {}),
                 ...(persistent ? { persistent: true } : {}),
-                // The RESOLVED name, not just the requested one: a `--new` session the
-                // machine named itself comes back in the ack, and a re-attach must
-                // name it — `tmux -A` without `-s` would open a fresh session instead.
+                ...(reattaching ? { resumeExisting: true } : {}),
                 ...(persistentName ? { sessionName: persistentName } : {}),
                 ...(options.leaseId ? { leaseId: options.leaseId } : {}),
                 ...size(),
             });
+        }
+        function scheduleRetry() {
+            clearTimeout(startTimer);
+            clearTimeout(retryTimer);
+            if (finished || !reattaching)
+                return;
+            retryTimer = setTimeout(sendStart, 2_000);
+            retryTimer.unref();
+        }
+        function recover() {
+            if (finished || reattaching)
+                return;
+            started = false;
+            pending?.close(); // The sign-in command is never typed a second time.
+            clearTimeout(startTimer);
+            if (!persistent || !persistentName || !options.resumeExistingSupported) {
+                errorOutput.write(`\r\n[terminal attachment lost; rerun the same command to reattach${persistentName ? ` to '${persistentName}'` : ''}]\r\n`);
+                finish(1, false);
+                return;
+            }
+            reattaching = true;
+            errorOutput.write(`\r\n[lost the terminal attachment — reattaching to session '${persistentName}'…]\r\n`);
+            recoveryTimer = setTimeout(() => {
+                errorOutput.write(`\r\n[could not reattach within 60 seconds; rerun the same command for session '${persistentName}']\r\n`);
+                finish(1, false);
+            }, 60_000);
+            recoveryTimer.unref();
+            if (connected)
+                sendStart();
+        }
+        socket.on('connect', () => {
+            connected = true;
+            sendStart();
         });
         socket.on(events.startAck, (ack) => {
             if (!ack || ack.sessionId !== sessionId || started || finished)
@@ -242,6 +291,12 @@ function runDedicatedTerminal(options) {
             if (ack.daemonId && ack.daemonId !== options.daemonId)
                 return;
             if (!ack.ok) {
+                // Only daemon availability refusals are retryable. Authorization,
+                // generation fencing and a missing original shell end recovery.
+                if (reattaching && (ack.code === 'offline' || ack.code === 'not_found')) {
+                    scheduleRetry();
+                    return;
+                }
                 fail(new DedicatedTerminalError(describeTerminalStartRefusal(ack), ack.code || 'TERMINAL_START_REFUSED'));
                 return;
             }
@@ -249,6 +304,8 @@ function runDedicatedTerminal(options) {
             started = true;
             reattaching = false;
             clearTimeout(startTimer);
+            clearTimeout(retryTimer);
+            clearTimeout(recoveryTimer);
             if (typeof ack.persistentName === 'string' && ack.persistentName) {
                 persistentName = ack.persistentName;
             }
@@ -278,8 +335,13 @@ function runDedicatedTerminal(options) {
                 return;
             if (frame.daemonId && frame.daemonId !== options.daemonId)
                 return;
+            if (frame.code === 'daemon-disconnected' ||
+                (frame.type === 'error' && (frame.code === 'not-found' || frame.code === 'closed'))) {
+                recover();
+                return;
+            }
             if (frame.type === 'exit') {
-                finish(typeof frame.exitCode === 'number' ? frame.exitCode : 0, false);
+                finish(typeof frame.exitCode === 'number' ? frame.exitCode : 1, false);
                 return;
             }
             if (frame.type === 'error' || frame.type === 'info') {
@@ -318,17 +380,11 @@ function runDedicatedTerminal(options) {
             }
         }
         socket.on('disconnect', () => {
+            connected = false;
             if (finished)
                 return;
             if (persistent) {
-                // The tmux session outlives the link — the tmux client's death only
-                // detaches. socket.io retries and the next start re-attaches by name.
-                started = false;
-                if (!reattaching) {
-                    reattaching = true;
-                    const named = persistentName ? ` '${persistentName}'` : '';
-                    errorOutput.write(`\r\n[lost the connection to skrr — reattaching to session${named}…]\r\n`);
-                }
+                recover();
                 return;
             }
             if (!started) {