@skrr-ai/cli 0.1.77 → 0.1.79

package/dist/commands/machines/dedicated/cp.js

@@ -26,6 +26,8 @@ class DedicatedMachinesCp extends base_command_1.BaseCommand {
             'machine is created.',
         'As with cp and scp, a destination that ends in / or is an existing directory receives the file ' +
             'under its source name.',
+        'Files marked executable keep owner execute permission on the copy. Other permissions use ' +
+            'destination defaults; source special permission bits are not copied.',
         'Neither side is left half-written: the file is staged beside its destination and renamed into ' +
             'place at the end. A file that changes while it is copied is refused, not spliced. Ctrl-C removes ' +
             'the partial copy and exits 130 (143 for SIGTERM, 129 when the terminal closes). Progress is ' +

package/dist/lib/dedicated-copy.js

@@ -220,7 +220,7 @@ async function uploadFile(localPath, leaseId, remotePath, scope, io) {
                 dataBase64: buffer.subarray(0, bytesRead).toString('base64'),
                 // A file that GREW is caught here: the machine refuses to commit
                 // when what it staged is not the size declared at the start.
-                ...(final ? { final: true, totalSize: info.size } : {}),
+                ...(final ? { final: true, totalSize: info.size, executable: (info.mode & 0o111) !== 0 } : {}),
             }, scope), signal);
             offset += bytesRead;
             onProgress?.(offset, info.size);
@@ -276,6 +276,7 @@ async function downloadFromDedicatedRuntime(leaseId, remotePath, localPath, scop
     let offset = 0;
     let size = -1;
     let mtimeMs = -1;
+    let executable;
     try {
         for (;;) {
             throwIfCancelled(signal);
@@ -285,11 +286,17 @@ async function downloadFromDedicatedRuntime(leaseId, remotePath, localPath, scop
             if (size === -1) {
                 size = chunk.size;
                 mtimeMs = chunk.mtimeMs;
+                executable = chunk.executable;
             }
-            else if (chunk.size !== size || chunk.mtimeMs !== mtimeMs) {
+            else if (chunk.size !== size || chunk.mtimeMs !== mtimeMs ||
+                (typeof chunk.executable === 'boolean' && typeof executable === 'boolean' &&
+                    chunk.executable !== executable)) {
                 // Chunks from two versions of a file splice into one that never existed.
                 throw changedWhileCopying(remotePath, 'on the machine');
             }
+            // Older API replicas omit this additive metadata during a rollout.
+            if (typeof chunk.executable === 'boolean')
+                executable = chunk.executable;
             const bytes = Buffer.from(chunk.dataBase64, 'base64');
             if (bytes.byteLength !== chunk.bytesRead) {
                 throw new DedicatedCopyError('DEDICATED_RUNTIME_FILE_TRANSFER_FAILED', 'A chunk arrived damaged; nothing was written to the destination.');
@@ -304,6 +311,11 @@ async function downloadFromDedicatedRuntime(leaseId, remotePath, localPath, scop
                 throw changedWhileCopying(remotePath, 'on the machine');
             }
         }
+        // Set only the owner execute bit on the pinned staging inode. Other
+        // permissions keep destination defaults; source special bits never travel.
+        if (executable === true) {
+            await handle.chmod(((await handle.stat()).mode & 0o777) | 0o100);
+        }
         await handle.close();
         closed = true;
         await (0, promises_1.rename)(temporary, target);

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-machines.d.ts

@@ -466,6 +466,7 @@ export interface DedicatedFileChunk {
     path: string;
     size: number;
     mtimeMs: number;
+    executable?: boolean;
     offset: number;
     bytesRead: number;
     dataBase64: string;
@@ -491,6 +492,7 @@ export declare function writeDedicatedRuntimeFileChunk(leaseId: string, input: {
     final?: boolean;
     abort?: boolean;
     totalSize?: number;
+    executable?: boolean;
 }, scope?: DedicatedRuntimeScope): Promise<DedicatedFileWriteResult>;
 export type DedicatedCopyPlan = {
     direction: 'upload';

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

@@ -112,6 +112,7 @@ export interface SshStartAck {
         type: string;
         key: string;
     }[];
+    receiverAckV1?: boolean;
 }
 export interface SshProxyOptions {
     baseURL: string;

package/dist/lib/dedicated-ssh.js

@@ -343,6 +343,7 @@ function runSshProxy(options) {
                 channelId,
                 keyType: identity.keyType,
                 keyBlob: identity.keyBlob,
+                receiverAckV1: true,
             });
         });
         socket.on('dedicated:ssh:start:ack', (ack) => {
@@ -366,11 +367,23 @@ function runSshProxy(options) {
             input.resume();
             input.on('data', onInput);
         });
-        socket.on('dedicated:ssh:data', (frame) => {
+        socket.on('dedicated:ssh:data', (frame, receipt) => {
             if (!frame || frame.channelId !== channelId || finished)
                 return;
             if (typeof frame.data === 'string' && frame.data.length > 0) {
-                output.write(Buffer.from(frame.data, 'base64'));
+                const bytes = Buffer.from(frame.data, 'base64');
+                if (typeof receipt === 'function') {
+                    // A frame can precede start-ack (sshd's banner). The owned channel
+                    // already advertised support; confirm only when stdout flushed.
+                    output.write(bytes, (error) => {
+                        receipt({ channelId, ok: !error && !finished });
+                        if (error)
+                            finish(1, 'Could not write SSH output.');
+                    });
+                }
+                else {
+                    output.write(bytes);
+                }
             }
         });
         socket.on('dedicated:ssh:closed', (frame) => {

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) {