@skrr-ai/cli 0.1.8

package/dist/commands/machines/hosted/exec.js

@@ -0,0 +1,130 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.splitExecArgv = splitExecArgv;
+const core_1 = require("@oclif/core");
+const base_command_1 = require("../../../base-command");
+const shell_quote_1 = require("../../../lib/shell-quote");
+const hosted_machines_1 = require("../../../lib/hosted-machines");
+/**
+ * Split a raw argv at the first `--`.
+ *
+ * `head` is ours (the machine id and our flags); `tail` is the remote
+ * command's argv, verbatim — including any further `--`, which is a normal
+ * argument to whatever runs remotely. `tail` is `null` when no separator was
+ * typed, so the caller can keep accepting `exec <id> pwd`.
+ */
+function splitExecArgv(rawArgv) {
+    const separator = rawArgv.indexOf('--');
+    if (separator === -1)
+        return { head: [...rawArgv], tail: null };
+    return { head: rawArgv.slice(0, separator), tail: rawArgv.slice(separator + 1) };
+}
+class HostedMachinesExec extends base_command_1.BaseCommand {
+    static description = 'Run a command inside a Hosted Machine';
+    static strict = false;
+    static examples = [
+        '<%= config.bin %> machines hosted exec <machine-id> -- pwd',
+        '<%= config.bin %> machines hosted exec <machine-id> --cwd /home/user -- ls -la',
+        '<%= config.bin %> machines hosted exec <machine-id> --command "npm test" --json',
+    ];
+    // Declared so `exec --help` renders the positional ID and an ARGUMENTS
+    // section like every sibling command (OSK-4869). The command still needs
+    // `strict = false` to accept the variadic argv after `--`, and argv keeps
+    // carrying the id at [0]; the declaration is for help and validation only.
+    static args = {
+        id: core_1.Args.string({
+            description: 'Hosted Machine session id',
+            required: true,
+            ignoreStdin: true,
+        }),
+    };
+    static flags = {
+        command: core_1.Flags.string({ description: 'Command to run instead of trailing argv' }),
+        cwd: core_1.Flags.string({ description: 'Working directory for shell commands' }),
+        language: core_1.Flags.string({
+            description: 'Execution language',
+            options: ['shell', 'python', 'node'],
+            default: 'shell',
+        }),
+        timeout: core_1.Flags.string({ description: 'Execution timeout such as 30s, 5m' }),
+        workspace: core_1.Flags.string({ description: 'Workspace scope' }),
+        json: core_1.Flags.boolean({ description: 'Output as JSON' }),
+    };
+    async run() {
+        this.requireAuth();
+        // Everything after the FIRST `--` is the remote command's argv, taken from
+        // the raw argv rather than from the parser: oclif consumes the separator
+        // and sorts what it hands back by each token's position in the original
+        // line, so a second `--` — `git log -- path`, `grep -- -foo` — was lost
+        // before this command ever saw it (OSK-4848). Flags are parsed from the
+        // head only, which is also what the separator means: nothing after it is
+        // ours to interpret.
+        const { head, tail } = splitExecArgv(this.argv);
+        const { argv, flags } = await this.parse(HostedMachinesExec, head);
+        const raw = argv;
+        const id = raw[0];
+        const commandArgs = tail ?? raw.slice(1);
+        // Quoted per-argument, not joined raw: `--` carries ARGV, and the machine
+        // executes the string we send through a shell. Joining with spaces threw
+        // away the quoting the local shell had already consumed, so an argument
+        // containing a space or `;` was re-split remotely into several — running a
+        // command the caller never wrote, with no error (OSK-4789). `--command` is
+        // the shell-string path and is unchanged.
+        const command = flags.command || (0, shell_quote_1.shellQuoteArgv)(commandArgs);
+        if (!id) {
+            this.error('Machine id is required.', { exit: 2 });
+        }
+        if (!command.trim()) {
+            this.error('Command is required. Use --command or pass it after --.', { exit: 2 });
+        }
+        let timeoutMs;
+        try {
+            timeoutMs = (0, hosted_machines_1.parseDurationMs)(flags.timeout, '--timeout');
+        }
+        catch (err) {
+            this.error(err.message, { exit: 1 });
+        }
+        const body = {
+            command,
+            language: flags.language,
+            ...(flags.cwd ? { cwd: flags.cwd } : {}),
+            ...(timeoutMs ? { timeoutMs } : {}),
+        };
+        let response;
+        try {
+            response = await (0, hosted_machines_1.execHostedMachine)(id, body, { workspaceId: flags.workspace });
+        }
+        catch (err) {
+            const message = (0, hosted_machines_1.formatHostedMachineApiError)(err);
+            if (message)
+                this.error(message, { exit: 1 });
+            this.handleApiError(err);
+        }
+        if (flags.json) {
+            this.log(JSON.stringify((0, hosted_machines_1.curateHostedMachineExecResult)(response), null, 2));
+        }
+        else {
+            // A paused machine is parked on purpose and meters at the paused rate, and
+            // `resolveExecutionTarget` wakes it for any command. That is convenient and
+            // stays — but it silently moves a workspace back onto the active rate, so
+            // say it. stderr, not stdout: this is about the invocation, and a caller
+            // piping stdout is reading the command's output (OSK-4790).
+            if (response.resumedFromPaused) {
+                process.stderr.write(`Note: this command resumed a paused machine — it is billing at the active rate again. ` +
+                    `Run \`${this.config.bin} machines hosted pause ${id}\` to park it.\n`);
+            }
+            if (response.stdout)
+                process.stdout.write(response.stdout);
+            if (response.stderr)
+                process.stderr.write(response.stderr);
+        }
+        const exitCode = Number.isInteger(response.exitCode)
+            ? response.exitCode
+            : response.success
+                ? 0
+                : 1;
+        if (exitCode !== 0)
+            this.exit(exitCode);
+    }
+}
+exports.default = HostedMachinesExec;

package/dist/commands/machines/hosted/index.d.ts

@@ -0,0 +1,6 @@
+import { Command } from '@oclif/core';
+export default class Machines extends Command {
+    static description: string;
+    static examples: string[];
+    run(): Promise<void>;
+}

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

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const core_1 = require("@oclif/core");
+class Machines extends core_1.Command {
+    static description = 'Manage skrr Hosted Machine workspaces';
+    static examples = [
+        '<%= config.bin %> machines hosted start --name scratch --wait',
+        '<%= config.bin %> machines hosted list',
+        '<%= config.bin %> machines hosted exec <machine-id> -- pwd',
+        '<%= config.bin %> machines hosted pull <machine-id> /home/user/app ./app-copy',
+        '<%= config.bin %> machines hosted connect <machine-id>',
+    ];
+    async run() {
+        this.log('skrr Hosted Machine commands:');
+        this.log('  skrr machines hosted start      start a hosted machine');
+        this.log('  skrr machines hosted list       list Hosted Machine sessions');
+        this.log('  skrr machines hosted status     show machine status');
+        this.log('  skrr machines hosted exec       run a command in a machine');
+        this.log('  skrr machines hosted pull       copy files out of a machine');
+        this.log('  skrr machines hosted connect    open a command REPL');
+        this.log('  skrr machines hosted pause      pause a machine');
+        this.log('  skrr machines hosted resume     resume a machine');
+        this.log('  skrr machines hosted destroy    terminate a machine');
+    }
+}
+exports.default = Machines;

package/dist/commands/machines/hosted/list.d.ts

@@ -0,0 +1,25 @@
+import { BaseCommand } from '../../../base-command';
+export default class HostedMachinesList extends BaseCommand {
+    static description: string;
+    static examples: string[];
+    static flags: {
+        json: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+        details: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+        workspace: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
+        limit: import("@oclif/core/lib/interfaces").OptionFlag<number, import("@oclif/core/lib/interfaces").CustomOptions>;
+    };
+    run(): Promise<void>;
+    /**
+     * OSK-2045 — this command lists Hosted Machine *sessions* and nothing else,
+     * but `agents attach-machine` used to send users here for the local-daemon
+     * machine `_id`. An empty list is exactly the moment a user is most likely to
+     * be looking for `machines hosted engines`, so point at it from here rather than
+     * leaving `No Hosted Machines.` as the whole answer.
+     *
+     * The engine count is a courtesy probe: it makes the pointer concrete ("4
+     * local daemon engines are registered") instead of speculative. It is
+     * advisory only, so a failure degrades to the generic pointer rather than
+     * turning a successful list into an error.
+     */
+    private logLocalEngineHint;
+}

package/dist/commands/machines/hosted/list.js

@@ -0,0 +1,98 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const core_1 = require("@oclif/core");
+const base_command_1 = require("../../../base-command");
+const api_fetch_1 = require("../../../lib/api-fetch");
+const format_1 = require("../../../lib/format");
+const hosted_machines_1 = require("../../../lib/hosted-machines");
+class HostedMachinesList extends base_command_1.BaseCommand {
+    static description = 'List skrr Hosted Machine sessions';
+    static examples = [
+        '<%= config.bin %> machines hosted list',
+        '<%= config.bin %> machines hosted list --workspace <workspace-id>',
+        '<%= config.bin %> machines hosted list --json',
+    ];
+    static flags = {
+        json: core_1.Flags.boolean({ description: 'Output as JSON' }),
+        details: core_1.Flags.boolean({
+            description: 'Include complete session histories in JSON (may be large)',
+        }),
+        workspace: core_1.Flags.string({ description: 'Workspace scope' }),
+        limit: core_1.Flags.integer({ description: 'Max sessions to return', default: 50 }),
+    };
+    async run() {
+        this.requireAuth();
+        const { flags } = await this.parse(HostedMachinesList);
+        let response;
+        try {
+            response = await (0, hosted_machines_1.listHostedMachines)({ workspaceId: flags.workspace, limit: flags.limit });
+        }
+        catch (err) {
+            const message = (0, hosted_machines_1.formatHostedMachineApiError)(err);
+            if (message)
+                this.error(message, { exit: 1 });
+            this.handleApiError(err);
+        }
+        if (flags.json) {
+            this.log(JSON.stringify(flags.details ? response : (0, hosted_machines_1.curateHostedMachineList)(response), null, 2));
+            return;
+        }
+        const sessions = response.data ?? [];
+        if (sessions.length === 0) {
+            this.log('No Hosted Machines.');
+            await this.logLocalEngineHint();
+            return;
+        }
+        const rows = sessions.map((session) => ({
+            id: (0, hosted_machines_1.hostedMachineId)(session),
+            status: (0, hosted_machines_1.hostedMachineStatus)(session),
+            name: (0, hosted_machines_1.hostedMachineDisplayName)(session),
+            agent: session.agentId ? String(session.agentId) : '-',
+            lease: session.machineLeaseId ? String(session.machineLeaseId) : '-',
+            repos: (0, hosted_machines_1.hostedMachineRepoSummary)(session),
+            preview: session.previewUrl ? String(session.previewUrl) : '-',
+        }));
+        (0, format_1.renderTable)(rows, [
+            { key: 'id', header: 'ID' },
+            { key: 'status', header: 'STATUS' },
+            { key: 'name', header: 'NAME', maxWidth: 28 },
+            { key: 'agent', header: 'AGENT', maxWidth: 22 },
+            { key: 'lease', header: 'LEASE', maxWidth: 22 },
+            { key: 'repos', header: 'REPOS', maxWidth: 36 },
+            { key: 'preview', header: 'PREVIEW', maxWidth: 48 },
+        ], (line) => this.log(line));
+    }
+    /**
+     * OSK-2045 — this command lists Hosted Machine *sessions* and nothing else,
+     * but `agents attach-machine` used to send users here for the local-daemon
+     * machine `_id`. An empty list is exactly the moment a user is most likely to
+     * be looking for `machines hosted engines`, so point at it from here rather than
+     * leaving `No Hosted Machines.` as the whole answer.
+     *
+     * The engine count is a courtesy probe: it makes the pointer concrete ("4
+     * local daemon engines are registered") instead of speculative. It is
+     * advisory only, so a failure degrades to the generic pointer rather than
+     * turning a successful list into an error.
+     */
+    async logLocalEngineHint() {
+        let localHarnesses = 0;
+        try {
+            const res = await (0, api_fetch_1.apiFetch)('/api/harnesses', {
+                credential: this.resolvedCredential,
+            });
+            localHarnesses = (res.harnesses ?? []).filter((harness) => harness.harnessLocation === 'local').length;
+        }
+        catch {
+            // Advisory only: fall back to the generic pointer rather than failing a
+            // command that already produced its answer.
+            localHarnesses = 0;
+        }
+        if (localHarnesses > 0) {
+            this.log(`${localHarnesses} local daemon harness${localHarnesses === 1 ? ' is' : 'es are'} registered — ` +
+                'run `skrr harnesses list` to list them (that is the harness id `agents attach-harness` wants).');
+            return;
+        }
+        this.log('Local daemon harnesses are listed separately: `skrr harnesses list`.');
+    }
+}
+exports.default = HostedMachinesList;

package/dist/commands/machines/hosted/pause.d.ts

@@ -0,0 +1,13 @@
+import { BaseCommand } from '../../../base-command';
+export default class HostedMachinesPause extends BaseCommand {
+    static description: string;
+    static examples: string[];
+    static args: {
+        id: import("@oclif/core/lib/interfaces").Arg<string, Record<string, unknown>>;
+    };
+    static flags: {
+        workspace: 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/hosted/pause.js

@@ -0,0 +1,43 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const core_1 = require("@oclif/core");
+const base_command_1 = require("../../../base-command");
+const hosted_machines_1 = require("../../../lib/hosted-machines");
+class HostedMachinesPause extends base_command_1.BaseCommand {
+    static description = 'Pause a Hosted Machine';
+    static examples = [
+        '<%= config.bin %> machines hosted pause <machine-id>',
+        '<%= config.bin %> machines hosted pause <machine-id> --json',
+    ];
+    static args = {
+        id: core_1.Args.string({
+            description: 'Hosted Machine session id',
+            required: true,
+            ignoreStdin: true,
+        }),
+    };
+    static flags = {
+        workspace: core_1.Flags.string({ description: 'Workspace scope' }),
+        json: core_1.Flags.boolean({ description: 'Output as JSON' }),
+    };
+    async run() {
+        this.requireAuth();
+        const { args, flags } = await this.parse(HostedMachinesPause);
+        let response;
+        try {
+            response = await (0, hosted_machines_1.pauseHostedMachine)(args.id, { workspaceId: flags.workspace });
+        }
+        catch (err) {
+            const message = (0, hosted_machines_1.formatHostedMachineApiError)(err);
+            if (message)
+                this.error(message, { exit: 1 });
+            this.handleApiError(err);
+        }
+        if (flags.json) {
+            this.log(JSON.stringify(response, null, 2));
+            return;
+        }
+        this.log(`Hosted Machine ${(0, hosted_machines_1.hostedMachineId)(response.session)} ${(0, hosted_machines_1.hostedMachineStatus)(response.session)}.`);
+    }
+}
+exports.default = HostedMachinesPause;

package/dist/commands/machines/hosted/pull.d.ts

@@ -0,0 +1,19 @@
+import { BaseCommand } from '../../../base-command';
+export default class HostedMachinesPull extends BaseCommand {
+    static description: string;
+    static examples: string[];
+    static args: {
+        id: import("@oclif/core/lib/interfaces").Arg<string, Record<string, unknown>>;
+        remotePath: import("@oclif/core/lib/interfaces").Arg<string, Record<string, unknown>>;
+        localPath: import("@oclif/core/lib/interfaces").Arg<string | undefined, Record<string, unknown>>;
+    };
+    static flags: {
+        workspace: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
+        archive: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+        overwrite: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+        timeout: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
+        'max-bytes': import("@oclif/core/lib/interfaces").OptionFlag<number, import("@oclif/core/lib/interfaces").CustomOptions>;
+        json: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+    };
+    run(): Promise<void>;
+}

package/dist/commands/machines/hosted/pull.js

@@ -0,0 +1,271 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const core_1 = require("@oclif/core");
+const node_child_process_1 = require("node:child_process");
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_os_1 = __importDefault(require("node:os"));
+const node_path_1 = __importDefault(require("node:path"));
+const base_command_1 = require("../../../base-command");
+const hosted_machines_1 = require("../../../lib/hosted-machines");
+const DEFAULT_MAX_BYTES = 50 * 1024 * 1024;
+class HostedMachinesPull extends base_command_1.BaseCommand {
+    static description = 'Pull a file or directory out of a Hosted Machine';
+    static examples = [
+        '<%= config.bin %> machines hosted pull <machine-id> /home/user/app/package.json',
+        '<%= config.bin %> machines hosted pull <machine-id> /home/user/app ./app-copy',
+        '<%= config.bin %> machines hosted pull <machine-id> /home/user/app app.tgz --archive',
+        '<%= config.bin %> machines hosted pull <machine-id> /home/user/app ./app-copy --overwrite --json',
+    ];
+    static args = {
+        id: core_1.Args.string({
+            description: 'Hosted Machine session id',
+            required: true,
+            ignoreStdin: true,
+        }),
+        remotePath: core_1.Args.string({
+            description: 'File or directory path inside the machine',
+            required: true,
+            ignoreStdin: true,
+        }),
+        localPath: core_1.Args.string({
+            description: 'Local destination path. Defaults to the remote basename.',
+            required: false,
+            ignoreStdin: true,
+        }),
+    };
+    static flags = {
+        workspace: core_1.Flags.string({ description: 'Workspace scope' }),
+        archive: core_1.Flags.boolean({
+            description: 'Write the machine tar.gz archive instead of extracting it',
+        }),
+        overwrite: core_1.Flags.boolean({ description: 'Replace an existing local destination' }),
+        timeout: core_1.Flags.string({ description: 'Machine command timeout such as 30s, 5m' }),
+        'max-bytes': core_1.Flags.integer({
+            description: 'Maximum archive bytes to accept from the machine',
+            default: DEFAULT_MAX_BYTES,
+        }),
+        json: core_1.Flags.boolean({ description: 'Output as JSON' }),
+    };
+    async run() {
+        this.requireAuth();
+        const { args, flags } = await this.parse(HostedMachinesPull);
+        let timeoutMs;
+        try {
+            timeoutMs = (0, hosted_machines_1.parseDurationMs)(flags.timeout, '--timeout');
+        }
+        catch (err) {
+            this.failWithCliError({
+                message: err.message,
+                code: 'INVALID_RUNTIME_PULL_TIMEOUT',
+                exit: 1,
+                retryable: false,
+            });
+        }
+        let maxBytes;
+        try {
+            maxBytes = normalizeMaxBytes(flags['max-bytes']);
+        }
+        catch (err) {
+            this.failWithCliError({
+                message: err.message,
+                code: 'INVALID_RUNTIME_PULL_MAX_BYTES',
+                exit: 1,
+                retryable: false,
+            });
+        }
+        let response;
+        try {
+            response = await (0, hosted_machines_1.execHostedMachine)(args.id, {
+                command: buildPullScript(args.remotePath, maxBytes),
+                language: 'node',
+                ...(timeoutMs ? { timeoutMs } : {}),
+            }, { workspaceId: flags.workspace });
+        }
+        catch (err) {
+            const message = (0, hosted_machines_1.formatHostedMachineApiError)(err);
+            if (message) {
+                this.failWithCliError({
+                    message,
+                    code: 'RUNTIME_PULL_API_ERROR',
+                    exit: 1,
+                    retryable: false,
+                });
+            }
+            this.handleApiError(err);
+        }
+        if (!response.success || (Number.isInteger(response.exitCode) && response.exitCode !== 0)) {
+            this.failWithCliError({
+                message: response.stderr?.trim() ||
+                    `Machine pull command failed with exit ${response.exitCode ?? 1}.`,
+                code: 'RUNTIME_PULL_FAILED',
+                exit: 1,
+                retryable: false,
+                details: {
+                    exitCode: response.exitCode,
+                    stderr: response.stderr,
+                },
+            });
+        }
+        let parsed;
+        try {
+            parsed = parsePullOutput(response.stdout || '', maxBytes);
+        }
+        catch (err) {
+            this.failWithCliError({
+                message: err.message,
+                code: 'RUNTIME_PULL_OUTPUT_INVALID',
+                exit: 1,
+                retryable: false,
+            });
+        }
+        const localPath = node_path_1.default.resolve(args.localPath || (flags.archive ? `${parsed.metadata.name}.tar.gz` : parsed.metadata.name));
+        try {
+            if (flags.archive) {
+                writeFile(localPath, parsed.archive, flags.overwrite);
+            }
+            else {
+                extractArchive(parsed.archive, parsed.metadata.name, localPath, flags.overwrite);
+            }
+        }
+        catch (err) {
+            this.failWithCliError({
+                message: err.message,
+                code: 'RUNTIME_PULL_WRITE_FAILED',
+                exit: 1,
+                retryable: false,
+            });
+        }
+        const result = {
+            object: 'sky.runtime_pull',
+            ok: true,
+            machine: args.id,
+            remotePath: args.remotePath,
+            localPath,
+            archive: Boolean(flags.archive),
+            type: parsed.metadata.type,
+            bytes: parsed.archive.length,
+        };
+        if (flags.json) {
+            this.log(JSON.stringify(result, null, 2));
+            return;
+        }
+        this.log(`Pulled ${args.remotePath} from ${args.id} to ${localPath}.`);
+    }
+}
+exports.default = HostedMachinesPull;
+function normalizeMaxBytes(value) {
+    if (!Number.isInteger(value) || value <= 0) {
+        throw new Error('--max-bytes must be a positive integer.');
+    }
+    return value;
+}
+function buildPullScript(remotePath, maxBytes) {
+    return `
+const fs = require('fs');
+const path = require('path');
+const { spawnSync } = require('child_process');
+
+const target = ${JSON.stringify(remotePath)};
+const maxBytes = ${JSON.stringify(maxBytes)};
+
+let stat;
+try {
+  stat = fs.statSync(target);
+} catch (err) {
+  console.error('Remote path not found: ' + target);
+  process.exit(66);
+}
+
+const parent = path.dirname(target);
+const name = path.basename(target);
+if (!name || name === '.' || name === '..') {
+  console.error('Remote path must name a concrete file or directory.');
+  process.exit(64);
+}
+
+const tar = spawnSync('tar', ['-C', parent, '-czf', '-', name], {
+  encoding: 'buffer',
+  maxBuffer: maxBytes + 1024 * 1024,
+});
+if (tar.error) {
+  console.error(tar.error.message);
+  process.exit(70);
+}
+if (tar.status !== 0) {
+  process.stderr.write(tar.stderr || Buffer.from('tar failed'));
+  process.exit(tar.status || 1);
+}
+if (tar.stdout.length > maxBytes) {
+  console.error('Archive exceeds --max-bytes: ' + tar.stdout.length + ' > ' + maxBytes);
+  process.exit(74);
+}
+
+process.stdout.write(JSON.stringify({
+  name,
+  type: stat.isDirectory() ? 'directory' : stat.isFile() ? 'file' : 'other',
+  archiveBytes: tar.stdout.length,
+}) + '\\n');
+process.stdout.write(tar.stdout.toString('base64'));
+`;
+}
+function parsePullOutput(stdout, maxBytes) {
+    const newline = stdout.indexOf('\n');
+    if (newline <= 0) {
+        throw new Error('Machine pull output did not include metadata.');
+    }
+    const metadata = JSON.parse(stdout.slice(0, newline));
+    if (!metadata.name ||
+        metadata.name.includes('/') ||
+        metadata.name === '.' ||
+        metadata.name === '..') {
+        throw new Error('Machine pull metadata contained an invalid name.');
+    }
+    const archive = Buffer.from(stdout.slice(newline + 1).trim(), 'base64');
+    if (archive.length === 0) {
+        throw new Error('Machine pull archive was empty.');
+    }
+    if (archive.length > maxBytes) {
+        throw new Error(`Machine pull archive exceeds --max-bytes: ${archive.length} > ${maxBytes}.`);
+    }
+    return { metadata, archive };
+}
+function writeFile(destination, data, overwrite) {
+    if (node_fs_1.default.existsSync(destination) && !overwrite) {
+        throw new Error(`Local destination already exists: ${destination}. Pass --overwrite to replace it.`);
+    }
+    node_fs_1.default.mkdirSync(node_path_1.default.dirname(destination), { recursive: true });
+    node_fs_1.default.writeFileSync(destination, data, { flag: overwrite ? 'w' : 'wx' });
+}
+function extractArchive(archive, name, destination, overwrite) {
+    if (node_fs_1.default.existsSync(destination) && !overwrite) {
+        throw new Error(`Local destination already exists: ${destination}. Pass --overwrite to replace it.`);
+    }
+    const tmp = node_fs_1.default.mkdtempSync(node_path_1.default.join(node_os_1.default.tmpdir(), 'sky-machine-pull-'));
+    try {
+        const archivePath = node_path_1.default.join(tmp, 'archive.tgz');
+        const extractDir = node_path_1.default.join(tmp, 'extract');
+        node_fs_1.default.mkdirSync(extractDir);
+        node_fs_1.default.writeFileSync(archivePath, archive);
+        const result = (0, node_child_process_1.spawnSync)('tar', ['-xzf', archivePath, '-C', extractDir], {
+            encoding: 'utf8',
+        });
+        if (result.status !== 0) {
+            throw new Error(result.stderr?.trim() || 'Failed to extract machine archive.');
+        }
+        const extracted = node_path_1.default.join(extractDir, name);
+        if (!node_fs_1.default.existsSync(extracted)) {
+            throw new Error('Machine archive did not contain the expected top-level path.');
+        }
+        node_fs_1.default.mkdirSync(node_path_1.default.dirname(destination), { recursive: true });
+        if (node_fs_1.default.existsSync(destination)) {
+            node_fs_1.default.rmSync(destination, { recursive: true, force: true });
+        }
+        node_fs_1.default.cpSync(extracted, destination, { recursive: true, errorOnExist: false, force: true });
+    }
+    finally {
+        node_fs_1.default.rmSync(tmp, { recursive: true, force: true });
+    }
+}

package/dist/commands/machines/hosted/resume.d.ts

@@ -0,0 +1,16 @@
+import { BaseCommand } from '../../../base-command';
+export default class HostedMachinesResume extends BaseCommand {
+    static description: string;
+    static examples: string[];
+    static args: {
+        id: import("@oclif/core/lib/interfaces").Arg<string, Record<string, unknown>>;
+    };
+    static flags: {
+        workspace: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
+        wait: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+        interval: import("@oclif/core/lib/interfaces").OptionFlag<number, import("@oclif/core/lib/interfaces").CustomOptions>;
+        timeout: import("@oclif/core/lib/interfaces").OptionFlag<string, import("@oclif/core/lib/interfaces").CustomOptions>;
+        json: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+    };
+    run(): Promise<void>;
+}