@skrr-ai/cli 0.1.87 → 0.1.88

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

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 const core_1 = require("@oclif/core");
 const base_command_1 = require("../../../base-command");
+const computer_files_1 = require("../../../lib/computer-files");
 const dedicated_machines_1 = require("../../../lib/dedicated-machines");
 const dedicated_copy_1 = require("../../../lib/dedicated-copy");
 const LIMIT_MIB = dedicated_machines_1.DEDICATED_FILE_MAX_BYTES / (1024 * 1024);
@@ -26,6 +27,12 @@ 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.',
+        'Copying to the machine never replaces a file unasked. A destination that does not exist is created, ' +
+            'and the copy commits only if the name is still free. A destination that exists is refused before ' +
+            'anything is sent, unless --overwrite is given (it replaces the version found when the copy starts, ' +
+            'and says which) or --if-tag <tag> (it replaces exactly the version `stat` showed you). Either way, a ' +
+            'destination that changes during the copy is not replaced. Every request of one copy is bound to the ' +
+            'machine as it was when the copy started: a machine replaced meanwhile refuses the rest.',
         '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 ' +
@@ -36,6 +43,8 @@ class DedicatedMachinesCp extends base_command_1.BaseCommand {
     static examples = [
         '<%= config.bin %> machines dedicated cp ./dist/app.tar.gz rtl_abc123:repos/app/app.tar.gz',
         '<%= config.bin %> machines dedicated cp ./notes.md rtl_abc123:user-data/',
+        '<%= config.bin %> machines dedicated cp ./build.zip rtl_abc123:repos/app/build.zip --overwrite',
+        '<%= config.bin %> machines dedicated cp ./build.zip rtl_abc123:repos/app/build.zip --if-tag 12345:3182:1761234567890000000',
         '<%= config.bin %> machines dedicated cp rtl_abc123:repos/app/coverage/report.html ./report.html',
     ];
     // `ignoreStdin: true` on both, per the CLI's own hygiene rule: without it oclif
@@ -55,6 +64,12 @@ class DedicatedMachinesCp extends base_command_1.BaseCommand {
     };
     static flags = {
         workspace: core_1.Flags.string({ description: 'Workspace scope' }),
+        overwrite: core_1.Flags.boolean({
+            description: 'Copying to the machine: replace an existing destination (the version found when the copy starts)',
+        }),
+        'if-tag': core_1.Flags.string({
+            description: 'Copying to the machine: replace the destination only if it still has this tag — the <inode>:<size>:<mtimeNs> `stat` prints',
+        }),
         json: core_1.Flags.boolean({ description: 'Output the result as JSON' }),
     };
     async run() {
@@ -68,6 +83,23 @@ class DedicatedMachinesCp extends base_command_1.BaseCommand {
             this.error(err.message, { exit: 2 });
         }
         const scope = { workspaceId: flags.workspace };
+        if (plan.direction === 'download' && (flags.overwrite || flags['if-tag'] !== undefined)) {
+            this.error('--overwrite and --if-tag apply when copying to the machine.', { exit: 2 });
+        }
+        let ifTag;
+        if (flags['if-tag'] !== undefined) {
+            try {
+                ifTag = (0, computer_files_1.parseComputerFileTag)(flags['if-tag']);
+            }
+            catch (err) {
+                this.error(err.message.replace(/--tag/g, '--if-tag'), { exit: 2 });
+            }
+            if (ifTag.contents !== undefined) {
+                this.error('--if-tag names a file version; a folder contents tag cannot be replaced.', {
+                    exit: 2,
+                });
+            }
+        }
         // Progress is drawn on stderr, for a person at a terminal: never into a
         // --json document, and never into a CI log as a stream of carriage returns.
         const progress = !flags.json && process.stderr.isTTY && !(0, dedicated_copy_1.isContinuousIntegration)()
@@ -84,13 +116,24 @@ class DedicatedMachinesCp extends base_command_1.BaseCommand {
         let result;
         try {
             const { signal } = interrupt;
+            // Once, before the first file call: every request of this copy presents
+            // this generation, so a machine replaced mid-copy refuses the rest.
+            const generation = await (0, computer_files_1.resolveDedicatedFileGeneration)(plan.leaseId, scope);
             result =
                 plan.direction === 'upload'
                     ? await (0, dedicated_copy_1.uploadToDedicatedRuntime)(plan.localPath, plan.leaseId, plan.remotePath, scope, {
+                        generation,
                         signal,
                         onProgress,
+                        overwrite: flags.overwrite === true,
+                        ...(ifTag ? { ifTag } : {}),
+                        // Said before a byte is sent, so the person knows what is being replaced.
+                        onReplace: (destination, tag) => {
+                            progress?.clear();
+                            process.stderr.write(`Replacing ${destination} (tag ${(0, computer_files_1.computerFileTagString)(tag)})\n`);
+                        },
                     })
-                    : await (0, dedicated_copy_1.downloadFromDedicatedRuntime)(plan.leaseId, plan.remotePath, plan.localPath, scope, { signal, onProgress });
+                    : await (0, dedicated_copy_1.downloadFromDedicatedRuntime)(plan.leaseId, plan.remotePath, plan.localPath, scope, { generation, signal, onProgress });
         }
         catch (thrown) {
             progress?.clear();
@@ -107,6 +150,28 @@ class DedicatedMachinesCp extends base_command_1.BaseCommand {
             if (err instanceof dedicated_copy_1.DedicatedCopyError) {
                 this.error(err.message, { exit: 1, code: err.code });
             }
+            if (err instanceof computer_files_1.DedicatedFileGenerationUnavailableError) {
+                this.error(err.message, { exit: 1, code: err.code });
+            }
+            // The machine was replaced mid-copy, or its image cannot fence the copy:
+            // the computer vocabulary says what to do about either.
+            const computerCode = (0, computer_files_1.computerFileRefusalInfo)(err)?.code;
+            if (computerCode === 'stale_generation' || computerCode === 'capability_missing') {
+                const failure = (0, computer_files_1.describeComputerFileFailure)(err, {
+                    bin: this.config.bin,
+                    leaseId: plan.leaseId,
+                });
+                if (failure) {
+                    const notReplaced = plan.direction === 'upload'
+                        ? ` ${plan.leaseId}:${plan.remotePath} was not changed.`
+                        : ` Nothing was written to ${plan.localPath}.`;
+                    this.failWithCliError({
+                        ...failure,
+                        message: `${failure.message}${notReplaced}`,
+                        exit: 1,
+                    });
+                }
+            }
             // Keep the API status, request id and explicit retry decision together.
             if ((0, base_command_1.apiRefusal)(err).body?.retryable === true)
                 this.handleApiError(err);
@@ -129,7 +194,14 @@ class DedicatedMachinesCp extends base_command_1.BaseCommand {
             this.log(JSON.stringify({ direction: plan.direction, ...result }, null, 2));
             return;
         }
-        this.log(`${plan.direction === 'upload' ? 'Uploaded' : 'Downloaded'} ${result.bytes} bytes → ${result.destination}`);
+        if (plan.direction === 'upload' && result.alreadyCommitted) {
+            this.log(`Already copied: ${result.destination} (an earlier attempt committed it)`);
+            return;
+        }
+        const replaced = result.replacedTag
+            ? ` (replaced the version tagged ${result.replacedTag})`
+            : '';
+        this.log(`${plan.direction === 'upload' ? 'Uploaded' : 'Downloaded'} ${result.bytes} bytes → ${result.destination}${replaced}`);
     }
 }
 exports.default = DedicatedMachinesCp;

package/dist/commands/machines/dedicated/git-status.d.ts

@@ -0,0 +1,15 @@
+import { DedicatedLeaseCommand } from '../../../lib/dedicated-lease-command';
+/** `skrr machines dedicated git-status` — git marks of one folder's entries. */
+export default class DedicatedMachinesGitStatus extends DedicatedLeaseCommand {
+    static summary: string;
+    static description: string;
+    static examples: string[];
+    static args: {
+        lease: import("@oclif/core/lib/interfaces").Arg<string, Record<string, unknown>>;
+        path: import("@oclif/core/lib/interfaces").Arg<string, Record<string, unknown>>;
+    };
+    static flags: {
+        json: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+    };
+    run(): Promise<void>;
+}

package/dist/commands/machines/dedicated/git-status.js

@@ -0,0 +1,56 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const core_1 = require("@oclif/core");
+const dedicated_lease_command_1 = require("../../../lib/dedicated-lease-command");
+const computer_files_1 = require("../../../lib/computer-files");
+/** `skrr machines dedicated git-status` — git marks of one folder's entries. */
+class DedicatedMachinesGitStatus extends dedicated_lease_command_1.DedicatedLeaseCommand {
+    static summary = 'Show git marks for a folder on a Dedicated Runtime machine';
+    static description = 'Prints the git mark (modified, added, untracked, ignored, conflicted) of each entry of one ' +
+        'folder, as the computer’s Files window decorates them. A folder outside a repository is ' +
+        'said so; a status that does not finish in time offers no marks rather than a partial set. ' +
+        'Available on dedicated machines, not on a personal machine.';
+    static examples = [
+        '<%= config.bin %> machines dedicated git-status rtl_abc123 repos/app',
+        '<%= config.bin %> machines dedicated git-status rtl_abc123 repos/app --json',
+    ];
+    static args = {
+        lease: core_1.Args.string({
+            description: dedicated_lease_command_1.DEDICATED_LEASE_ARG_DESCRIPTION,
+            required: true,
+            ignoreStdin: true,
+        }),
+        path: core_1.Args.string({
+            description: 'Folder on the machine, relative to /workspace',
+            required: true,
+            ignoreStdin: true,
+        }),
+    };
+    static flags = {
+        json: core_1.Flags.boolean({ description: 'Output the result as JSON' }),
+    };
+    async run() {
+        this.requireAuth();
+        const { args, flags } = await this.parse(DedicatedMachinesGitStatus);
+        const leaseId = await this.resolveLeaseArg(args.lease);
+        let result;
+        try {
+            const scope = this.scopeFrom(flags);
+            const generation = await (0, computer_files_1.resolveDedicatedFileGeneration)(leaseId, scope);
+            result = await (0, computer_files_1.gitStatusComputerFiles)(leaseId, { path: args.path, generation }, scope);
+        }
+        catch (err) {
+            const failure = (0, computer_files_1.describeComputerFileFailure)(err, { bin: this.config.bin, leaseId });
+            if (failure)
+                this.failWithCliError({ ...failure, exit: 1 });
+            this.handleApiError(err);
+        }
+        if (flags.json) {
+            this.log(JSON.stringify(result, null, 2));
+            return;
+        }
+        for (const line of (0, computer_files_1.computerFileGitStatusLines)(result))
+            this.log(line);
+    }
+}
+exports.default = DedicatedMachinesGitStatus;

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

@@ -19,6 +19,13 @@ class DedicatedMachines extends core_1.Command {
         '<%= config.bin %> machines dedicated sign-in <lease-id> github',
         '<%= config.bin %> machines dedicated exec <lease-id> -- git -C repos/app status',
         '<%= config.bin %> machines dedicated cp ./notes.md <lease-id>:user-data/notes.md',
+        '<%= config.bin %> machines dedicated ls <lease-id> repos/app',
+        '<%= config.bin %> machines dedicated stat <lease-id> repos/app/package.json',
+        '<%= config.bin %> machines dedicated mkdir <lease-id> repos/app/dist',
+        '<%= config.bin %> machines dedicated mv <lease-id> repos/a repos/b',
+        '<%= config.bin %> machines dedicated rm <lease-id> repos/app/dist --recursive',
+        '<%= config.bin %> machines dedicated archive <lease-id> repos/app',
+        '<%= config.bin %> machines dedicated computer <lease-id>',
         '<%= config.bin %> machines dedicated stop <lease-id> --wait',
         '<%= config.bin %> machines dedicated start <lease-id> --wait',
         '<%= config.bin %> machines dedicated restart <lease-id>',
@@ -44,6 +51,13 @@ class DedicatedMachines extends core_1.Command {
             ['sign-in', 'sign in to GitHub CLI, Claude Code or Codex there'],
             ['exec', 'run one command; output and exit code'],
             ['cp', 'copy a file to or from the machine'],
+            ['ls', 'list a directory on the machine'],
+            ['stat', 'one path: type, size, mtime, mode and its tag'],
+            ['mkdir', 'create a directory, parents included'],
+            ['mv', 'rename or move a path'],
+            ['rm', 'delete a file or folder (--recursive)'],
+            ['archive', 'download a folder as a tar file'],
+            ['computer', 'open the machine’s computer in the browser or skrr Desktop'],
             ['start', 'start a stopped runtime'],
             ['stop', 'stop compute and keep the disk'],
             ['restart', 'restart the instance; files stay'],
@@ -56,7 +70,7 @@ class DedicatedMachines extends core_1.Command {
             ['service', 'declare workloads the machine keeps running'],
             ['destroy', 'stop compute; keep or purge the workspace disk'],
         ];
-        this.log('skrr Dedicated Runtime commands:');
+        this.log('Skrr Dedicated Runtime commands:');
         for (const [name, summary] of rows) {
             this.log(`  skrr machines dedicated ${name.padEnd(15)} ${summary}`);
         }

package/dist/commands/machines/dedicated/ls.d.ts

@@ -0,0 +1,27 @@
+import { DedicatedLeaseCommand } from '../../../lib/dedicated-lease-command';
+/**
+ * `skrr machines dedicated ls` — list one directory on the machine.
+ *
+ * Paths are relative to /workspace and, on a guest, confined to `repos/` and
+ * `user-data/` — the tenant roots; the workspace root itself is the runtime's
+ * and a listing of it is refused `path_withheld`. Entries are sorted by the
+ * machine by name bytes; a symlink shows its stored target and is never
+ * followed; an entry the machine withholds (deny set, blockedPaths, a
+ * sensitive pattern, an OS permission) is shown as withheld, not hidden.
+ */
+export default class DedicatedMachinesLs extends DedicatedLeaseCommand {
+    static summary: string;
+    static description: string;
+    static examples: string[];
+    static args: {
+        lease: import("@oclif/core/lib/interfaces").Arg<string, Record<string, unknown>>;
+        path: import("@oclif/core/lib/interfaces").Arg<string, Record<string, unknown>>;
+    };
+    static flags: {
+        limit: import("@oclif/core/lib/interfaces").OptionFlag<number | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
+        cursor: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
+        all: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+        json: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+    };
+    run(): Promise<void>;
+}

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

@@ -0,0 +1,100 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const core_1 = require("@oclif/core");
+const dedicated_lease_command_1 = require("../../../lib/dedicated-lease-command");
+const format_1 = require("../../../lib/format");
+const computer_files_1 = require("../../../lib/computer-files");
+/**
+ * `skrr machines dedicated ls` — list one directory on the machine.
+ *
+ * Paths are relative to /workspace and, on a guest, confined to `repos/` and
+ * `user-data/` — the tenant roots; the workspace root itself is the runtime's
+ * and a listing of it is refused `path_withheld`. Entries are sorted by the
+ * machine by name bytes; a symlink shows its stored target and is never
+ * followed; an entry the machine withholds (deny set, blockedPaths, a
+ * sensitive pattern, an OS permission) is shown as withheld, not hidden.
+ */
+class DedicatedMachinesLs extends dedicated_lease_command_1.DedicatedLeaseCommand {
+    static summary = 'List a directory on a Dedicated Runtime machine';
+    static description = 'Lists one directory on the machine, one page of up to 500 entries. ' +
+        'Paths are relative to /workspace and must be inside repos/ or user-data/. ' +
+        'A path the machine withholds is answered as a refusal, and an entry it ' +
+        'withholds is shown marked rather than hidden.';
+    static examples = [
+        '<%= config.bin %> machines dedicated ls rtl_abc123 repos/app',
+        '<%= config.bin %> machines dedicated ls rtl_abc123 repos/app --limit 1000 --all',
+        '<%= config.bin %> machines dedicated ls rtl_abc123 repos/app --json',
+    ];
+    static args = {
+        lease: core_1.Args.string({
+            description: dedicated_lease_command_1.DEDICATED_LEASE_ARG_DESCRIPTION,
+            required: true,
+            ignoreStdin: true,
+        }),
+        path: core_1.Args.string({
+            description: 'Directory on the machine, relative to /workspace (inside repos/ or user-data/)',
+            required: true,
+            ignoreStdin: true,
+        }),
+    };
+    static flags = {
+        limit: core_1.Flags.integer({ description: 'Entries per page (at most 2000)' }),
+        cursor: core_1.Flags.string({ description: 'Continue the listing from a nextCursor' }),
+        all: core_1.Flags.boolean({ description: 'Follow the cursor until the directory is listed whole' }),
+        json: core_1.Flags.boolean({ description: 'Output the result as JSON' }),
+    };
+    async run() {
+        this.requireAuth();
+        const { args, flags } = await this.parse(DedicatedMachinesLs);
+        const leaseId = await this.resolveLeaseArg(args.lease);
+        const scope = this.scopeFrom(flags);
+        const entries = [];
+        let listedPath = args.path;
+        let nextCursor;
+        try {
+            // Once: every page of this listing is read from the same machine.
+            const generation = await (0, computer_files_1.resolveDedicatedFileGeneration)(leaseId, scope);
+            let cursor = flags.cursor;
+            do {
+                const page = await (0, computer_files_1.listComputerFiles)(leaseId, {
+                    path: args.path,
+                    generation,
+                    ...(cursor ? { cursor } : {}),
+                    ...(flags.limit !== undefined ? { limit: flags.limit } : {}),
+                }, scope);
+                listedPath = page.path;
+                entries.push(...page.entries);
+                cursor = page.nextCursor;
+                nextCursor = page.nextCursor;
+            } while (flags.all && cursor);
+        }
+        catch (err) {
+            const failure = (0, computer_files_1.describeComputerFileFailure)(err, { bin: this.config.bin, leaseId });
+            if (failure)
+                this.failWithCliError({ ...failure, exit: 1 });
+            this.handleApiError(err);
+        }
+        if (flags.json) {
+            this.log(JSON.stringify({ path: listedPath, entries, ...(nextCursor ? { nextCursor } : {}) }, null, 2));
+            return;
+        }
+        this.log(`${listedPath} — ${entries.length} entr${entries.length === 1 ? 'y' : 'ies'}`);
+        (0, format_1.renderTable)(entries.map((entry) => ({
+            type: (0, format_1.formatCell)(entry.withheld ? 'withheld' : entry.type),
+            mode: (0, format_1.formatCell)(entry.withheld ? '-' : (0, computer_files_1.computerFileModeString)(entry.type, entry.mode)),
+            size: (0, format_1.formatCell)(entry.withheld ? '-' : (0, computer_files_1.formatComputerFileSize)(entry.size)),
+            modified: (0, format_1.formatCell)(entry.withheld ? '-' : (0, format_1.localStamp)(entry.mtimeMs)),
+            name: (0, format_1.formatCell)((0, computer_files_1.computerFileEntryName)(entry)),
+        })), [
+            { key: 'type', header: 'TYPE' },
+            { key: 'mode', header: 'MODE' },
+            { key: 'size', header: 'SIZE' },
+            { key: 'modified', header: 'MODIFIED' },
+            { key: 'name', header: 'NAME', verbatim: true },
+        ], (line) => this.log(line));
+        if (nextCursor) {
+            this.log(`More entries: --cursor ${nextCursor} (or --all to list the whole directory).`);
+        }
+    }
+}
+exports.default = DedicatedMachinesLs;

package/dist/commands/machines/dedicated/mkdir.d.ts

@@ -0,0 +1,18 @@
+import { DedicatedLeaseCommand } from '../../../lib/dedicated-lease-command';
+/**
+ * `skrr machines dedicated mkdir` — create a directory on the machine, missing
+ * parents included (`mkdir -p` semantics; the machine makes the chain).
+ */
+export default class DedicatedMachinesMkdir extends DedicatedLeaseCommand {
+    static summary: string;
+    static description: string;
+    static examples: string[];
+    static args: {
+        lease: import("@oclif/core/lib/interfaces").Arg<string, Record<string, unknown>>;
+        path: import("@oclif/core/lib/interfaces").Arg<string, Record<string, unknown>>;
+    };
+    static flags: {
+        json: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+    };
+    run(): Promise<void>;
+}

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

@@ -0,0 +1,57 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const core_1 = require("@oclif/core");
+const dedicated_lease_command_1 = require("../../../lib/dedicated-lease-command");
+const computer_files_1 = require("../../../lib/computer-files");
+/**
+ * `skrr machines dedicated mkdir` — create a directory on the machine, missing
+ * parents included (`mkdir -p` semantics; the machine makes the chain).
+ */
+class DedicatedMachinesMkdir extends dedicated_lease_command_1.DedicatedLeaseCommand {
+    static summary = 'Create a directory on a Dedicated Runtime machine';
+    static description = 'Creates the directory and any missing parents, as the workload user, inside ' +
+        'repos/ or user-data/. The tenant roots themselves and a path that already ' +
+        'exists are refused.';
+    static examples = [
+        '<%= config.bin %> machines dedicated mkdir rtl_abc123 repos/app/dist',
+        '<%= config.bin %> machines dedicated mkdir rtl_abc123 user-data/notes --json',
+    ];
+    static args = {
+        lease: core_1.Args.string({
+            description: dedicated_lease_command_1.DEDICATED_LEASE_ARG_DESCRIPTION,
+            required: true,
+            ignoreStdin: true,
+        }),
+        path: core_1.Args.string({
+            description: 'Directory to create, relative to /workspace (inside repos/ or user-data/)',
+            required: true,
+            ignoreStdin: true,
+        }),
+    };
+    static flags = {
+        json: core_1.Flags.boolean({ description: 'Output the result as JSON' }),
+    };
+    async run() {
+        this.requireAuth();
+        const { args, flags } = await this.parse(DedicatedMachinesMkdir);
+        const leaseId = await this.resolveLeaseArg(args.lease);
+        let result;
+        try {
+            const scope = this.scopeFrom(flags);
+            const generation = await (0, computer_files_1.resolveDedicatedFileGeneration)(leaseId, scope);
+            result = await (0, computer_files_1.mkdirComputerFile)(leaseId, { path: args.path, generation }, scope);
+        }
+        catch (err) {
+            const failure = (0, computer_files_1.describeComputerFileFailure)(err, { bin: this.config.bin, leaseId });
+            if (failure)
+                this.failWithCliError({ ...failure, exit: 1 });
+            this.handleApiError(err);
+        }
+        if (flags.json) {
+            this.log(JSON.stringify(result, null, 2));
+            return;
+        }
+        this.log(`Created ${result.path}`);
+    }
+}
+exports.default = DedicatedMachinesMkdir;

package/dist/commands/machines/dedicated/mv.d.ts

@@ -0,0 +1,24 @@
+import { DedicatedLeaseCommand } from '../../../lib/dedicated-lease-command';
+/**
+ * `skrr machines dedicated mv` — rename or move one path on the machine.
+ *
+ * `--tag` is the optimistic-concurrency fence (design §6.3): the tag `stat`
+ * prints for the source. When the source changed since that read the move is
+ * refused `file_changed` and the refusal carries the current tag — it is never
+ * silently applied over the version you did not see.
+ */
+export default class DedicatedMachinesMv extends DedicatedLeaseCommand {
+    static summary: string;
+    static description: string;
+    static examples: string[];
+    static args: {
+        lease: import("@oclif/core/lib/interfaces").Arg<string, Record<string, unknown>>;
+        from: import("@oclif/core/lib/interfaces").Arg<string, Record<string, unknown>>;
+        to: import("@oclif/core/lib/interfaces").Arg<string, Record<string, unknown>>;
+    };
+    static flags: {
+        tag: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
+        json: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+    };
+    run(): Promise<void>;
+}

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

@@ -0,0 +1,83 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const core_1 = require("@oclif/core");
+const dedicated_lease_command_1 = require("../../../lib/dedicated-lease-command");
+const computer_files_1 = require("../../../lib/computer-files");
+/**
+ * `skrr machines dedicated mv` — rename or move one path on the machine.
+ *
+ * `--tag` is the optimistic-concurrency fence (design §6.3): the tag `stat`
+ * prints for the source. When the source changed since that read the move is
+ * refused `file_changed` and the refusal carries the current tag — it is never
+ * silently applied over the version you did not see.
+ */
+class DedicatedMachinesMv extends dedicated_lease_command_1.DedicatedLeaseCommand {
+    static summary = 'Rename or move a path on a Dedicated Runtime machine';
+    static description = 'Moves or renames one path inside repos/ or user-data/. --tag takes the tag ' +
+        '`stat` prints for the source and refuses the move if the path changed ' +
+        'since; without it the move is unconditional.';
+    static examples = [
+        '<%= config.bin %> machines dedicated mv rtl_abc123 repos/app/old repos/app/new',
+        '<%= config.bin %> machines dedicated mv rtl_abc123 user-data/draft.md user-data/sent/draft.md',
+        '<%= config.bin %> machines dedicated mv rtl_abc123 repos/a repos/b --tag 12345:3182:1761234567890000000',
+    ];
+    static args = {
+        lease: core_1.Args.string({
+            description: dedicated_lease_command_1.DEDICATED_LEASE_ARG_DESCRIPTION,
+            required: true,
+            ignoreStdin: true,
+        }),
+        from: core_1.Args.string({
+            description: 'Existing path on the machine, relative to /workspace',
+            required: true,
+            ignoreStdin: true,
+        }),
+        to: core_1.Args.string({
+            description: 'Where it goes, relative to /workspace',
+            required: true,
+            ignoreStdin: true,
+        }),
+    };
+    static flags = {
+        tag: core_1.Flags.string({
+            description: 'Refuse unless the source still has this tag — the <inode>:<size>:<mtimeNs> `stat` prints',
+        }),
+        json: core_1.Flags.boolean({ description: 'Output the result as JSON' }),
+    };
+    async run() {
+        this.requireAuth();
+        const { args, flags } = await this.parse(DedicatedMachinesMv);
+        const leaseId = await this.resolveLeaseArg(args.lease);
+        let tag;
+        if (flags.tag !== undefined) {
+            try {
+                tag = (0, computer_files_1.parseComputerFileTag)(flags.tag);
+            }
+            catch (err) {
+                this.error(err.message, { exit: 2 });
+            }
+        }
+        let result;
+        try {
+            const scope = this.scopeFrom(flags);
+            const generation = await (0, computer_files_1.resolveDedicatedFileGeneration)(leaseId, scope);
+            result = await (0, computer_files_1.moveComputerFile)(leaseId, { from: args.from, to: args.to, generation, ...(tag ? { tag } : {}) }, scope);
+        }
+        catch (err) {
+            const failure = (0, computer_files_1.describeComputerFileFailure)(err, {
+                bin: this.config.bin,
+                leaseId,
+                takesTag: true,
+            });
+            if (failure)
+                this.failWithCliError({ ...failure, exit: 1 });
+            this.handleApiError(err);
+        }
+        if (flags.json) {
+            this.log(JSON.stringify(result, null, 2));
+            return;
+        }
+        this.log(`Moved ${args.from} → ${result.path}`);
+    }
+}
+exports.default = DedicatedMachinesMv;

package/dist/commands/machines/dedicated/rm.d.ts

@@ -0,0 +1,26 @@
+import { DedicatedLeaseCommand } from '../../../lib/dedicated-lease-command';
+/**
+ * `skrr machines dedicated rm` — delete one path on the machine.
+ *
+ * As `rm` does: a directory needs --recursive and is refused `not_empty`
+ * without it. `--tag` is the optimistic-concurrency fence — the tag `stat`
+ * prints; a file that changed since that read is refused `file_changed`, so a
+ * scripted delete never removes a version it never saw. For `--recursive` the
+ * tag must be the folder's CONTENTS tag (`stat --contents`): anything changed
+ * inside the folder since is refused. `--recursive` without `--tag` is unfenced.
+ */
+export default class DedicatedMachinesRm extends DedicatedLeaseCommand {
+    static summary: string;
+    static description: string;
+    static examples: string[];
+    static args: {
+        lease: import("@oclif/core/lib/interfaces").Arg<string, Record<string, unknown>>;
+        path: import("@oclif/core/lib/interfaces").Arg<string, Record<string, unknown>>;
+    };
+    static flags: {
+        recursive: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+        tag: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
+        json: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+    };
+    run(): Promise<void>;
+}