@skrr-ai/cli 0.1.77 → 0.1.78

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