@skrr-ai/cli 0.1.8

package/dist/commands/logout.d.ts

@@ -0,0 +1,74 @@
+import { BaseCommand } from '../base-command';
+export declare function shouldSkipLocalLogout(input: {
+    hasAnyStoredToken: boolean;
+    hasUsableLocalToken: boolean;
+    hasUnreadableEncryptedToken: boolean;
+    allDevices: boolean;
+}): boolean;
+/**
+ * `skrr logout` / `skrr logout --all-devices`
+ *
+ * Default mode (no flags): revokes the current CLI refresh session on the
+ * server (best-effort) and clears every local backend (Keychain on macOS,
+ * cli-auth.json fallback, and any legacy token fields in cli-config.json).
+ * `baseURL` and `cliId` are preserved so the next `skrr login` defaults to
+ * the same host and reuses the per-machine identity (which becomes a new
+ * refresh family — server-side revocation invalidated the prior family).
+ *
+ * `--all-devices` (L7 fleet-grade logout): in addition to the local
+ * cleanup, iterate the user's registered daemons and revoke each one
+ * server-side. This is the threat-model-correct response for a stolen-
+ * laptop scenario where the user wants every persistent daemon credential
+ * gone immediately, regardless of which machine they're calling from.
+ *
+ * Architectural note: the L7 server-side has a bulk endpoint
+ * (`POST /api/auth/sessions/revoke-all`) but it requires a user-scope JWT.
+ * CLI sessions are minted with `scope: 'cli'` (interactive single-machine
+ * use), so they cannot directly hit the bulk endpoint — that's by design,
+ * preventing a leaked CLI credential from kicking the user out of every
+ * other device. We instead iterate `DELETE /api/daemon-resources/:id`
+ * which CLI scope CAN hit (per-resource ownership check, not scope check).
+ * N round trips for N daemons; for typical fleet sizes (< 20) this is
+ * sub-second. Each per-daemon DELETE produces its own audit row keyed by
+ * `'user_initiated_per_device'`, which preserves forensic granularity.
+ *
+ * The CLI's own refresh session is NOT a Daemon resource (it's a
+ * `scope='cli'` refresh-session row with no Daemon FK), so it's invisible
+ * to `/api/daemon-resources`. We revoke it separately via
+ * `revokeCurrentRefreshToken()`.
+ *
+ * Ordering rationale for `--all-devices`:
+ *   1. `runAllDevices` is attempted first (remote sweep).
+ *   2. If it throws (network error, API unreachable), the error is captured
+ *      and a warning is emitted — but execution CONTINUES to step 3.
+ *      Rationale: a user who runs `logout --all-devices` after a security
+ *      incident must not be left with live tokens on disk just because the
+ *      API was momentarily unreachable. Local cleanup is always the safer
+ *      default; re-running --all-devices later from a connected machine is
+ *      idempotent and cleans up whatever the first attempt missed.
+ *   3. If the user explicitly declines the confirmation prompt inside
+ *      `runAllDevices`, that path calls `this.exit(1)` which invokes
+ *      `process.exit` — the try/catch is never reached, so local cleanup
+ *      is correctly skipped (user said "abort").
+ */
+export default class Logout extends BaseCommand {
+    static description: string;
+    static flags: {
+        'all-devices': import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+        yes: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+    };
+    run(): Promise<void>;
+    /**
+     * Iterate the user's daemon resources and revoke each one. Honors
+     * `--yes` to skip the confirmation prompt; without it, prompts with
+     * a count + sample of names so the user can sanity-check before the
+     * revoke fan-out.
+     *
+     * Best-effort per-daemon: a single failure does not abort the whole
+     * sweep — we report the error and continue. The user gets a partial-
+     * success summary at the end. Re-running `skrr logout --all-devices`
+     * is idempotent (already-revoked daemons surface as
+     * `alreadyRevoked: true`).
+     */
+    private runAllDevices;
+}

package/dist/commands/logout.js

@@ -0,0 +1,260 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.shouldSkipLocalLogout = shouldSkipLocalLogout;
+const core_1 = require("@oclif/core");
+const base_command_1 = require("../base-command");
+const config_1 = require("../lib/config");
+const auth_storage_1 = require("../lib/auth-storage");
+const refresh_1 = require("../lib/refresh");
+const api_fetch_1 = require("../lib/api-fetch");
+const cred_envelope_1 = require("../lib/cred-envelope");
+const device_identity_1 = require("../lib/device-identity");
+function shouldSkipLocalLogout(input) {
+    return (!input.hasAnyStoredToken &&
+        !input.hasUsableLocalToken &&
+        !input.hasUnreadableEncryptedToken &&
+        !input.allDevices);
+}
+/**
+ * `skrr logout` / `skrr logout --all-devices`
+ *
+ * Default mode (no flags): revokes the current CLI refresh session on the
+ * server (best-effort) and clears every local backend (Keychain on macOS,
+ * cli-auth.json fallback, and any legacy token fields in cli-config.json).
+ * `baseURL` and `cliId` are preserved so the next `skrr login` defaults to
+ * the same host and reuses the per-machine identity (which becomes a new
+ * refresh family — server-side revocation invalidated the prior family).
+ *
+ * `--all-devices` (L7 fleet-grade logout): in addition to the local
+ * cleanup, iterate the user's registered daemons and revoke each one
+ * server-side. This is the threat-model-correct response for a stolen-
+ * laptop scenario where the user wants every persistent daemon credential
+ * gone immediately, regardless of which machine they're calling from.
+ *
+ * Architectural note: the L7 server-side has a bulk endpoint
+ * (`POST /api/auth/sessions/revoke-all`) but it requires a user-scope JWT.
+ * CLI sessions are minted with `scope: 'cli'` (interactive single-machine
+ * use), so they cannot directly hit the bulk endpoint — that's by design,
+ * preventing a leaked CLI credential from kicking the user out of every
+ * other device. We instead iterate `DELETE /api/daemon-resources/:id`
+ * which CLI scope CAN hit (per-resource ownership check, not scope check).
+ * N round trips for N daemons; for typical fleet sizes (< 20) this is
+ * sub-second. Each per-daemon DELETE produces its own audit row keyed by
+ * `'user_initiated_per_device'`, which preserves forensic granularity.
+ *
+ * The CLI's own refresh session is NOT a Daemon resource (it's a
+ * `scope='cli'` refresh-session row with no Daemon FK), so it's invisible
+ * to `/api/daemon-resources`. We revoke it separately via
+ * `revokeCurrentRefreshToken()`.
+ *
+ * Ordering rationale for `--all-devices`:
+ *   1. `runAllDevices` is attempted first (remote sweep).
+ *   2. If it throws (network error, API unreachable), the error is captured
+ *      and a warning is emitted — but execution CONTINUES to step 3.
+ *      Rationale: a user who runs `logout --all-devices` after a security
+ *      incident must not be left with live tokens on disk just because the
+ *      API was momentarily unreachable. Local cleanup is always the safer
+ *      default; re-running --all-devices later from a connected machine is
+ *      idempotent and cleans up whatever the first attempt missed.
+ *   3. If the user explicitly declines the confirmation prompt inside
+ *      `runAllDevices`, that path calls `this.exit(1)` which invokes
+ *      `process.exit` — the try/catch is never reached, so local cleanup
+ *      is correctly skipped (user said "abort").
+ */
+class Logout extends base_command_1.BaseCommand {
+    static description = 'Sign out and clear locally-stored tokens. ' +
+        '--all-devices also revokes every registered daemon for this account.';
+    static flags = {
+        'all-devices': core_1.Flags.boolean({
+            description: 'Revoke every registered daemon for this account, in addition to ' +
+                'clearing local CLI tokens. Use after a stolen-laptop incident or ' +
+                'when rotating credentials platform-wide.',
+            default: false,
+        }),
+        yes: core_1.Flags.boolean({
+            char: 'y',
+            description: 'Skip the --all-devices confirmation prompt (CI / scripting).',
+            default: false,
+        }),
+    };
+    async run() {
+        const { flags } = await this.parse(Logout);
+        // Discard any observation made by BaseCommand's recovery-tolerant resolve;
+        // the reads below establish whether THIS logout found encrypted local state
+        // that it could not decrypt but still must erase.
+        (0, cred_envelope_1.consumeUnreadableEncryptedCredentialRead)();
+        const hasUsableLocalToken = Boolean(this.resolvedCredential?.token || (0, auth_storage_1.readFromBackend)(this.cliConfig.baseURL).bundle?.token);
+        // A server-mismatched or legacy-unbound bundle is intentionally unusable
+        // for network calls, but `skrr logout` must still remove it locally.
+        const hasAnyStoredToken = Boolean((0, auth_storage_1.readFromBackend)().bundle?.token);
+        const hasUnreadableEncryptedToken = (0, cred_envelope_1.consumeUnreadableEncryptedCredentialRead)();
+        if (shouldSkipLocalLogout({
+            hasAnyStoredToken,
+            hasUsableLocalToken,
+            hasUnreadableEncryptedToken,
+            allDevices: flags['all-devices'],
+        })) {
+            this.log('Not signed in. Nothing to do.');
+            return;
+        }
+        if (flags['all-devices'] && !hasUsableLocalToken) {
+            this.error('Not signed in on this machine. --all-devices requires an authenticated ' +
+                'CLI session to enumerate and revoke your daemons. Sign in here first, ' +
+                'or run --all-devices from a machine where you are already signed in.', { exit: 1 });
+        }
+        // Attempt the remote daemon sweep. A network failure must NOT prevent
+        // local cleanup — see ordering rationale in the class-level JSDoc.
+        // Note: if the user declines the confirmation inside runAllDevices,
+        // that path calls this.exit(1) → process.exit(), so the catch block
+        // is never reached and local cleanup is correctly skipped.
+        let allDevicesError = null;
+        if (flags['all-devices']) {
+            try {
+                await this.runAllDevices(flags.yes);
+            }
+            catch (err) {
+                allDevicesError = err instanceof Error ? err : new Error(String(err));
+                this.warn(`Failed to enumerate or revoke remote daemons: ${allDevicesError.message}. ` +
+                    `Continuing with local cleanup; re-run --all-devices later from a connected machine.`);
+            }
+        }
+        // Best-effort server-side revocation BEFORE we clear local state.
+        // The endpoint is authenticated by the refresh token itself; if we
+        // nuked local storage first the server call would have nothing to
+        // present.
+        //
+        // For --all-devices: the per-daemon iteration above already revoked
+        // every daemon-scope refresh session, but the CLI's OWN refresh
+        // session is a `scope='cli'` row without a Daemon FK and was NOT
+        // touched by the iteration. This call gets it.
+        try {
+            await (0, refresh_1.revokeCurrentRefreshToken)();
+        }
+        catch {
+            // intentionally swallowed — logout must succeed locally even
+            // when the API host is unreachable.
+        }
+        (0, auth_storage_1.clearAllBackends)();
+        // L11/L12 — also wipe shared device-identity + envelope artifacts.
+        // These files live under ~/.skrr/profiles/default/ and are shared
+        // with the daemon, so a `skrr logout` here also rotates the daemon's
+        // identity on the next start. Each call is wrapped so a single
+        // cleanup failure (permissions, transient fs error) doesn't break
+        // the local logout — the user already saw "Signed out" intent.
+        try {
+            await (0, device_identity_1.resetDeviceIdentity)({ profile: 'default', clearOnDisk: true });
+        }
+        catch {
+            /* best-effort */
+        }
+        try {
+            (0, device_identity_1.clearEnrollmentMarker)('default');
+        }
+        catch {
+            /* best-effort */
+        }
+        try {
+            await (0, cred_envelope_1.resetCredEnvelope)({ profile: 'default', clearOnDisk: true });
+        }
+        catch {
+            /* best-effort */
+        }
+        // Strip any stray token/refreshToken from cli-config.json too —
+        // `migrateAuthOutOfConfig` should have done this at init time, but
+        // call it again explicitly to cover the rare case where migration
+        // was skipped (e.g. `OVERSKY_BARE_MODE=1` short-circuit).
+        //
+        // This rebuilds the object rather than deleting keys, which is what strips
+        // the tokens — so every field worth keeping has to be named here, and one
+        // that is not named is dropped SILENTLY. `skyCodeAgentId` was in exactly
+        // that position: `skrr code` told users to set it, and the next `skrr logout`
+        // erased it with no message. It is preserved for the same reason `baseURL`
+        // and `cliId` are — this machine's settings outlive one session.
+        //
+        // It is re-resolved through the NEXT caller's own roster, so an id they
+        // cannot reach is refused by name rather than silently attributed. That is
+        // not the same as safe: if two people share one OS account and the second
+        // holds EDIT on the agent the first pinned, the config branch is deliberately
+        // ungated (naming a shared agent is a deliberate act) and their sessions
+        // would bill it. `skrr code oversky-agent --show` reports the resolved agent
+        // and where it came from, which is the intended way to notice.
+        const cfg = (0, config_1.loadConfig)();
+        (0, config_1.saveConfig)({
+            baseURL: cfg.baseURL,
+            ...(cfg.cliId ? { cliId: cfg.cliId } : {}),
+            ...(cfg.skyCodeAgentId ? { skyCodeAgentId: cfg.skyCodeAgentId } : {}),
+            ...(cfg.credentials ? { credentials: cfg.credentials } : {}),
+            migrated: { ...(cfg.migrated ?? {}), authOutOfConfig: true },
+        });
+        const finalMessage = flags['all-devices']
+            ? allDevicesError
+                ? 'Signed out locally. Remote daemons NOT revoked (see warning above).'
+                : 'Signed out from all devices.'
+            : 'Signed out.';
+        this.log(finalMessage);
+    }
+    /**
+     * Iterate the user's daemon resources and revoke each one. Honors
+     * `--yes` to skip the confirmation prompt; without it, prompts with
+     * a count + sample of names so the user can sanity-check before the
+     * revoke fan-out.
+     *
+     * Best-effort per-daemon: a single failure does not abort the whole
+     * sweep — we report the error and continue. The user gets a partial-
+     * success summary at the end. Re-running `skrr logout --all-devices`
+     * is idempotent (already-revoked daemons surface as
+     * `alreadyRevoked: true`).
+     */
+    async runAllDevices(skipConfirm) {
+        let listing;
+        try {
+            listing = await (0, api_fetch_1.apiFetch)('/api/daemon-resources?status=active&limit=500', { credential: this.resolvedCredential });
+        }
+        catch (err) {
+            this.handleApiError(err);
+        }
+        const active = listing.daemons.filter((d) => d.revokedAt == null);
+        if (active.length === 0) {
+            this.log('No active daemons to revoke.');
+            return;
+        }
+        if (!skipConfirm) {
+            const sample = active
+                .slice(0, 5)
+                .map((d) => `  • ${d.name || d.id.slice(0, 12)}${d.os ? ` (${d.os})` : ''}`)
+                .join('\n');
+            const more = active.length > 5 ? `\n  …and ${active.length - 5} more` : '';
+            const confirmed = await this.confirm(`Revoke ${active.length} daemon(s)?\n${sample}${more}\n[y/N] `);
+            if (!confirmed) {
+                this.log('Aborted.');
+                this.exit(1);
+            }
+        }
+        let succeeded = 0;
+        let alreadyRevoked = 0;
+        let failed = 0;
+        for (const d of active) {
+            try {
+                const res = await (0, api_fetch_1.apiFetch)(`/api/daemon-resources/${encodeURIComponent(d.id)}`, {
+                    method: 'DELETE',
+                    body: { reason: 'user_initiated_all_devices' },
+                    credential: this.resolvedCredential,
+                });
+                if (res.revoked)
+                    succeeded += 1;
+                else if (res.alreadyRevoked)
+                    alreadyRevoked += 1;
+            }
+            catch (err) {
+                failed += 1;
+                const msg = err instanceof api_fetch_1.ApiFetchError ? `${err.status} ${err.message}` : String(err);
+                this.warn(`Failed to revoke ${d.name || d.id.slice(0, 12)}: ${msg}`);
+            }
+        }
+        this.log(`Revoked ${succeeded} daemon(s)` +
+            (alreadyRevoked > 0 ? `; ${alreadyRevoked} already revoked` : '') +
+            (failed > 0 ? `; ${failed} failed (see warnings above)` : '') +
+            '.');
+    }
+}
+exports.default = Logout;

package/dist/commands/machines/disconnect.d.ts

@@ -0,0 +1,21 @@
+import { BaseCommand } from '../../base-command';
+/**
+ * Revoke skrr's access to a machine.
+ *
+ * NOT a delete: this removes the daemon credential, it does not touch the
+ * computer. A hosted machine is refused here on purpose — terminating one has
+ * to go through its runtime lease so provider teardown and billing settle
+ * (`MACHINE_DISCONNECT_UNSUPPORTED`).
+ */
+export default class MachinesDisconnect extends BaseCommand {
+    static description: string;
+    static examples: string[];
+    static args: {
+        machine: import("@oclif/core/lib/interfaces").Arg<string, Record<string, unknown>>;
+    };
+    static flags: {
+        json: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+        yes: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+    };
+    run(): Promise<void>;
+}

package/dist/commands/machines/disconnect.js

@@ -0,0 +1,69 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const core_1 = require("@oclif/core");
+const base_command_1 = require("../../base-command");
+const machines_1 = require("../../lib/machines");
+/**
+ * Revoke skrr's access to a machine.
+ *
+ * NOT a delete: this removes the daemon credential, it does not touch the
+ * computer. A hosted machine is refused here on purpose — terminating one has
+ * to go through its runtime lease so provider teardown and billing settle
+ * (`MACHINE_DISCONNECT_UNSUPPORTED`).
+ */
+class MachinesDisconnect extends base_command_1.BaseCommand {
+    static description = "Disconnect a machine — revokes skrr's daemon access, does not delete the computer";
+    static examples = [
+        '<%= config.bin %> machines disconnect 03548116',
+        '<%= config.bin %> machines disconnect 03548116 --yes',
+    ];
+    static args = {
+        machine: core_1.Args.string({
+            ignoreStdin: true,
+            description: 'Machine id, uuid, daemon id, name, or a unique prefix',
+            required: true,
+        }),
+    };
+    static flags = {
+        json: core_1.Flags.boolean({ description: 'Output as JSON' }),
+        yes: core_1.Flags.boolean({ description: 'Skip the confirmation prompt', char: 'y' }),
+    };
+    async run() {
+        this.requireAuth();
+        const { args, flags } = await this.parse(MachinesDisconnect);
+        let target;
+        try {
+            target = (0, machines_1.resolveMachineRef)(await (0, machines_1.listMachines)(), args.machine);
+        }
+        catch (err) {
+            this.handleApiError(err);
+        }
+        if (!target) {
+            this.error('Machine not found.', { exit: 1 });
+        }
+        // Name what is about to break before doing it. Agents pinned to a harness
+        // on this machine stop having anywhere to run, and that is not recoverable
+        // by re-running the command.
+        if (!flags.yes) {
+            const label = target.preferences?.name || target.name;
+            const count = target.harnesses?.length ?? 0;
+            this.log(`This revokes skrr's daemon access on "${label}" (${target.id}).`);
+            this.log(`${count} harness${count === 1 ? '' : 'es'} on this machine will stop being reachable. ` +
+                'The computer and its files are untouched. A live daemon re-registers on next launch.');
+            this.error('Re-run with --yes to confirm.', { exit: 1 });
+        }
+        let result;
+        try {
+            result = await (0, machines_1.disconnectMachine)(target.id);
+        }
+        catch (err) {
+            this.handleApiError(err);
+        }
+        if (flags.json) {
+            this.log(JSON.stringify(result, null, 2));
+            return;
+        }
+        this.log(`Disconnected ${target.preferences?.name || target.name} (${target.id}).`);
+    }
+}
+exports.default = MachinesDisconnect;

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

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

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

@@ -0,0 +1,92 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const core_1 = require("@oclif/core");
+const promises_1 = require("node:readline/promises");
+const node_process_1 = require("node:process");
+const base_command_1 = require("../../../base-command");
+const hosted_machines_1 = require("../../../lib/hosted-machines");
+class HostedMachinesConnect extends base_command_1.BaseCommand {
+    static description = 'Open a command REPL for a Hosted Machine';
+    static examples = [
+        '<%= config.bin %> machines hosted connect <machine-id>',
+        '<%= config.bin %> machines hosted connect <machine-id> --cwd /home/user/app',
+    ];
+    static args = {
+        id: core_1.Args.string({
+            description: 'Hosted Machine session id',
+            required: true,
+            ignoreStdin: true,
+        }),
+    };
+    static flags = {
+        cwd: core_1.Flags.string({ description: 'Working directory for shell commands' }),
+        timeout: core_1.Flags.string({ description: 'Per-command timeout such as 30s, 5m' }),
+        workspace: core_1.Flags.string({ description: 'Workspace scope' }),
+    };
+    async run() {
+        this.requireAuth();
+        const { args, flags } = await this.parse(HostedMachinesConnect);
+        if (!node_process_1.stdin.isTTY || !node_process_1.stdout.isTTY) {
+            this.error('connect requires an interactive terminal. Use `skrr machines hosted exec` for scripts.', {
+                exit: 2,
+            });
+        }
+        let timeoutMs;
+        try {
+            timeoutMs = (0, hosted_machines_1.parseDurationMs)(flags.timeout, '--timeout');
+        }
+        catch (err) {
+            this.error(err.message, { exit: 1 });
+        }
+        try {
+            const response = await (0, hosted_machines_1.getHostedMachine)(args.id, { workspaceId: flags.workspace });
+            this.log(`Connected to ${args.id} (${(0, hosted_machines_1.hostedMachineStatus)(response.session)}).`);
+            if (response.session?.previewUrl)
+                this.log(`Preview: ${response.session.previewUrl}`);
+        }
+        catch (err) {
+            const message = (0, hosted_machines_1.formatHostedMachineApiError)(err);
+            if (message)
+                this.error(message, { exit: 1 });
+            this.handleApiError(err);
+        }
+        const rl = (0, promises_1.createInterface)({ input: node_process_1.stdin, output: node_process_1.stdout });
+        try {
+            while (true) {
+                const line = await rl.question(`${args.id}> `);
+                const command = line.trim();
+                if (!command)
+                    continue;
+                if (command === 'exit' || command === 'quit')
+                    return;
+                try {
+                    const response = await (0, hosted_machines_1.execHostedMachine)(args.id, {
+                        command,
+                        language: 'shell',
+                        ...(flags.cwd ? { cwd: flags.cwd } : {}),
+                        ...(timeoutMs ? { timeoutMs } : {}),
+                    }, { workspaceId: flags.workspace });
+                    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)
+                        this.log(`[exit ${exitCode}]`);
+                }
+                catch (err) {
+                    const message = (0, hosted_machines_1.formatHostedMachineApiError)(err);
+                    this.log(message || err.message);
+                }
+            }
+        }
+        finally {
+            rl.close();
+        }
+    }
+}
+exports.default = HostedMachinesConnect;

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

@@ -0,0 +1,13 @@
+import { BaseCommand } from '../../../base-command';
+export default class HostedMachinesDestroy 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/destroy.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 HostedMachinesDestroy extends base_command_1.BaseCommand {
+    static description = 'Terminate a Hosted Machine';
+    static examples = [
+        '<%= config.bin %> machines hosted destroy <machine-id>',
+        '<%= config.bin %> machines hosted destroy <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(HostedMachinesDestroy);
+        let response;
+        try {
+            response = await (0, hosted_machines_1.destroyHostedMachine)(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 = HostedMachinesDestroy;

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

@@ -0,0 +1,30 @@
+import { BaseCommand } from '../../../base-command';
+/**
+ * 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`.
+ */
+export declare function splitExecArgv(rawArgv: readonly string[]): {
+    head: string[];
+    tail: string[] | null;
+};
+export default class HostedMachinesExec extends BaseCommand {
+    static description: string;
+    static strict: boolean;
+    static examples: string[];
+    static args: {
+        id: import("@oclif/core/lib/interfaces").Arg<string, Record<string, unknown>>;
+    };
+    static flags: {
+        command: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
+        cwd: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
+        language: import("@oclif/core/lib/interfaces").OptionFlag<string, import("@oclif/core/lib/interfaces").CustomOptions>;
+        timeout: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
+        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>;
+}