@skrr-ai/cli 0.1.25 → 0.1.27

package/dist/base-command.js

@@ -38,6 +38,7 @@ const refresh_1 = require("./lib/refresh");
 const auth_storage_1 = require("./lib/auth-storage");
 const update_check_1 = require("./lib/update-check");
 const web_url_1 = require("./lib/web-url");
+const edge_error_page_1 = require("./lib/edge-error-page");
 const delegated_cli_1 = require("./lib/delegated-cli");
 const tasks_1 = require("./lib/tasks");
 function assigneePayloadNeedsResolution(payload) {
@@ -284,11 +285,10 @@ class BaseCommand extends core_1.Command {
                     const accessToken = autoResult.outcome.accessToken;
                     this.resolvedCredential = {
                         token: accessToken,
-                        // Best-effort source label. `writeToBackend` routes to
-                        // Keychain on darwin, file elsewhere; we don't re-probe
-                        // here, but a follow-up `skrr whoami` reads the actual
-                        // backend so the label there is authoritative.
-                        source: 'keychain',
+                        // The backend the broker actually wrote to. Hard-coding
+                        // 'keychain' labelled a Linux credential (always the file)
+                        // "macOS Keychain" in the same process that minted it.
+                        source: autoResult.outcome.storedIn === 'keychain' ? 'keychain' : 'file',
                         kind: (0, auth_core_1.classifyTokenKind)(accessToken),
                     };
                 }
@@ -888,6 +888,30 @@ class BaseCommand extends core_1.Command {
                     retryable: true,
                 });
             }
+            else if ((e.status === 403 || e.status === 504) &&
+                !body &&
+                (0, edge_error_page_1.describeEdgeErrorPage)({ status: e.status, body: e.body, method: e.method })) {
+                // An HTML page in place of the API's JSON: the edge answered, not the
+                // API (OSK-8700, OSK-8705). A WAF 403 is a content match that the same
+                // request will hit again, not "transient" and not a permission; an edge
+                // 504 is a request the API may still be carrying out, not proof of an
+                // outage. 502/503 pages keep the outage branch below, which is what
+                // they usually are and which records the incident.
+                const edge = (0, edge_error_page_1.describeEdgeErrorPage)({
+                    status: e.status,
+                    body: e.body,
+                    method: e.method,
+                    host: this.cliConfig?.baseURL,
+                });
+                this.failWithCliError({
+                    message: say(edge.message),
+                    code: edge.code,
+                    status: e.status,
+                    exit: e.status === 403 ? 3 : 5,
+                    retryable: edge.retryable,
+                    ...(edge.requestId ? { details: { edgeRequestId: edge.requestId } } : {}),
+                });
+            }
             else if (e.status === 403) {
                 // A 403 WITH a body is the API deciding; it says why, and we relay it.
                 //

package/dist/commands/code/install.js

@@ -4,6 +4,7 @@ const core_1 = require("@oclif/core");
 const base_command_1 = require("../../base-command");
 const api_fetch_1 = require("../../lib/api-fetch");
 const daemon_ref_1 = require("../../lib/daemon-ref");
+const sky_code_1 = require("../../lib/sky-code");
 /**
  * `skrr code install` — install the engine from the terminal.
  *
@@ -47,6 +48,18 @@ class CodeInstall extends base_command_1.BaseCommand {
     };
     async run() {
         const { flags } = await this.parse(CodeInstall);
+        // Refused locally, before choosing a daemon. The daemon and the API refuse
+        // too, but with several active daemons this command would first ask which
+        // one — and "pick a machine" is the wrong question to put to someone whose
+        // answer is "none of them can do this here".
+        if ((0, sky_code_1.isDedicatedRuntimeWorkload)()) {
+            this.failWithCliError({
+                message: sky_code_1.DEDICATED_RUNTIME_ENGINE_MESSAGE,
+                code: 'DEDICATED_RUNTIME_ENGINE_SHIPS_WITH_IMAGE',
+                exit: 1,
+                retryable: false,
+            });
+        }
         const daemonId = await this.resolveDaemon(flags.daemon);
         let started;
         try {

package/dist/commands/harnesses/leases/billing.d.ts

@@ -1,10 +1,14 @@
 import { BaseCommand } from '../../../base-command';
 /**
- * Retarget who pays for a lease.
+ * Change a lease's monthly spending cap.
  *
- * This moves money, so the command refuses to guess: it sends exactly the axis
- * you named and nothing else. `--workspace` bills a workspace you belong to;
- * `--personal` moves it back to you.
+ * `PATCH /api/machines/leases/:id/billing` accepts `spendingLimitCents` and
+ * NOTHING else — its own comment says lifecycle billing state, usage and cost
+ * fields stay server-owned. This command used to be "change who pays", sending
+ * `{ workspaceId }`: no API moves a lease's payer, so every call was answered
+ * `INVALID_RUNTIME_SPENDING_LIMIT` for a field it never sent, while the parity
+ * check stayed green because it tests that the URL is reachable, not that the
+ * body means anything to it.
  */
 export default class HarnessesLeasesBilling extends BaseCommand {
     static description: string;
@@ -14,8 +18,7 @@ export default class HarnessesLeasesBilling extends BaseCommand {
     };
     static flags: {
         json: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
-        workspace: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
-        personal: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+        'spending-limit-cents': import("@oclif/core/lib/interfaces").OptionFlag<number, import("@oclif/core/lib/interfaces").CustomOptions>;
     };
     run(): Promise<void>;
 }

package/dist/commands/harnesses/leases/billing.js

@@ -13,50 +13,45 @@ const core_1 = require("@oclif/core");
 const base_command_1 = require("../../../base-command");
 const harnesses_1 = require("../../../lib/harnesses");
 /**
- * Retarget who pays for a lease.
+ * Change a lease's monthly spending cap.
  *
- * This moves money, so the command refuses to guess: it sends exactly the axis
- * you named and nothing else. `--workspace` bills a workspace you belong to;
- * `--personal` moves it back to you.
+ * `PATCH /api/machines/leases/:id/billing` accepts `spendingLimitCents` and
+ * NOTHING else — its own comment says lifecycle billing state, usage and cost
+ * fields stay server-owned. This command used to be "change who pays", sending
+ * `{ workspaceId }`: no API moves a lease's payer, so every call was answered
+ * `INVALID_RUNTIME_SPENDING_LIMIT` for a field it never sent, while the parity
+ * check stayed green because it tests that the URL is reachable, not that the
+ * body means anything to it.
  */
 class HarnessesLeasesBilling extends base_command_1.BaseCommand {
-    static description = 'Change who pays for a harness lease';
+    static description = 'Change the monthly spending cap of a hosted lease (Hosted Machine or Dedicated Runtime)';
     static examples = [
-        '<%= config.bin %> harnesses leases billing <lease-id> --workspace <workspace-id>',
-        '<%= config.bin %> harnesses leases billing <lease-id> --personal',
+        '<%= config.bin %> harnesses leases billing <lease-id> --spending-limit-cents 30000',
+        '<%= config.bin %> harnesses leases billing <lease-id> --spending-limit-cents 5000 --json',
     ];
     static args = {
         lease: core_1.Args.string({ ignoreStdin: true, description: 'Lease ID', required: true }),
     };
     static flags = {
         json: core_1.Flags.boolean({ description: 'Output as JSON' }),
-        workspace: core_1.Flags.string({
-            description: 'Bill this workspace instead',
-            exclusive: ['personal'],
-        }),
-        personal: core_1.Flags.boolean({
-            description: 'Bill you personally instead of a workspace',
-            exclusive: ['workspace'],
+        'spending-limit-cents': core_1.Flags.integer({
+            description: 'New monthly cap in cents. Refused below what the month has already spent or is projected to. Who pays for a lease is set at create and cannot be changed.',
+            required: true,
+            min: 1,
         }),
     };
     async run() {
         this.requireAuth();
         const { args, flags } = await this.parse(HarnessesLeasesBilling);
-        if (!flags.workspace && !flags.personal) {
-            this.error('Name the new payer: --workspace <id> or --personal.', { exit: 1 });
-            return;
-        }
-        // `null` is the explicit "no workspace pays this" signal, not an omission.
-        const body = { workspaceId: flags.personal ? null : flags.workspace };
         try {
-            const response = await (0, harnesses_1.setHarnessLeaseBilling)(args.lease, body);
+            const response = await (0, harnesses_1.setHarnessLeaseBilling)(args.lease, {
+                spendingLimitCents: flags['spending-limit-cents'],
+            });
             if (flags.json) {
                 this.log(JSON.stringify(response, null, 2));
                 return;
             }
-            this.log(flags.personal
-                ? `${args.lease} now bills you personally.`
-                : `${args.lease} now bills workspace ${flags.workspace}.`);
+            this.log(`${args.lease} monthly spending cap set to $${(flags['spending-limit-cents'] / 100).toFixed(2)}.`);
         }
         catch (err) {
             this.handleApiError(err);

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

@@ -0,0 +1,28 @@
+import { DedicatedLeaseCommand } from '../../../lib/dedicated-lease-command';
+/**
+ * `skrr machines dedicated attach` — run an agent on this machine.
+ *
+ * The only way to put an agent's turns on a Dedicated Runtime is to pin it to a
+ * harness row the machine's daemon registered, and the lease payload names no
+ * daemon, so the caller had to cross-reference `harnesses list` by metadata the
+ * table does not print. The admission error even told users to "attach it",
+ * naming a command that did not exist.
+ *
+ * This resolves the row from the lease and hands off to `agents attach-harness`,
+ * so execution-order semantics, agent resolution and task-pin migration stay in
+ * the one command that owns them.
+ */
+export default class DedicatedMachinesAttach extends DedicatedLeaseCommand {
+    static description: string;
+    static examples: string[];
+    static args: {
+        lease: import("@oclif/core/lib/interfaces").Arg<string, Record<string, unknown>>;
+    };
+    static flags: {
+        agent: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
+        engine: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
+        'rebind-tasks': import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+        json: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+    };
+    run(): Promise<void>;
+}

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

@@ -0,0 +1,76 @@
+"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 dedicated_lease_command_1 = require("../../../lib/dedicated-lease-command");
+const dedicated_machines_1 = require("../../../lib/dedicated-machines");
+const harnesses_1 = require("../../../lib/harnesses");
+const attach_harness_1 = __importDefault(require("../../agents/attach-harness"));
+/**
+ * `skrr machines dedicated attach` — run an agent on this machine.
+ *
+ * The only way to put an agent's turns on a Dedicated Runtime is to pin it to a
+ * harness row the machine's daemon registered, and the lease payload names no
+ * daemon, so the caller had to cross-reference `harnesses list` by metadata the
+ * table does not print. The admission error even told users to "attach it",
+ * naming a command that did not exist.
+ *
+ * This resolves the row from the lease and hands off to `agents attach-harness`,
+ * so execution-order semantics, agent resolution and task-pin migration stay in
+ * the one command that owns them.
+ */
+class DedicatedMachinesAttach extends dedicated_lease_command_1.DedicatedLeaseCommand {
+    static description = 'Pin an agent to a Dedicated Runtime so its turns and tasks run on that machine, under the engine you choose';
+    static examples = [
+        '<%= config.bin %> machines dedicated attach <lease-id> --agent <agent-id>',
+        '<%= config.bin %> machines dedicated attach <lease-id> --agent <agent-id> --engine claude --rebind-tasks',
+        '<%= config.bin %> machines dedicated attach <lease-id> --agent <agent-id> --engine codex --json',
+    ];
+    static args = {
+        lease: core_1.Args.string({
+            description: dedicated_lease_command_1.DEDICATED_LEASE_ARG_DESCRIPTION,
+            required: true,
+            ignoreStdin: true,
+        }),
+    };
+    static flags = {
+        agent: core_1.Flags.string({
+            description: 'Agent to attach. Inside an agent session it defaults to that agent (OVERSKY_SESSION_AGENT_ID).',
+        }),
+        engine: core_1.Flags.string({
+            description: 'Which engine row to attach when the machine registered several (claude, codex, sky-code, oversky). Required only when it is ambiguous.',
+        }),
+        'rebind-tasks': core_1.Flags.boolean({
+            description: 'Publish the updated agent release and move dormant assigned task pins to it. Running and finished tasks are never changed.',
+        }),
+        json: core_1.Flags.boolean({ description: 'Output the attachment result as JSON' }),
+    };
+    async run() {
+        this.requireAuth();
+        const { args, flags } = await this.parse(DedicatedMachinesAttach);
+        const leaseId = await this.resolveLeaseArg(args.lease);
+        const response = await this.callDedicated(() => (0, dedicated_machines_1.getDedicatedRuntime)(leaseId, this.scopeFrom(flags)));
+        const lease = response?.lease;
+        if (!lease)
+            this.error('Dedicated Runtime lease not found.', { exit: 1 });
+        const listed = await this.callDedicated(() => (0, harnesses_1.listHarnesses)());
+        const selection = (0, dedicated_machines_1.selectDedicatedAttachHarness)(lease, listed?.harnesses ?? [], flags.engine);
+        if ('error' in selection) {
+            this.error(selection.error, { exit: 1 });
+        }
+        const { harness } = selection;
+        if (!flags.json) {
+            process.stderr.write(`Attaching ${harness.provider} on ${leaseId} (harness ${harness._id}, ${harness.status || 'status unknown'}).\n` +
+                'Everything the agent runs there acts as you: it shares the machine’s sign-ins and your skrr login.\n');
+        }
+        await attach_harness_1.default.run([
+            harness._id,
+            ...(flags.agent ? ['--agent', flags.agent] : []),
+            ...(flags['rebind-tasks'] ? ['--rebind-tasks'] : []),
+            ...(flags.json ? ['--json'] : []),
+        ], this.config);
+    }
+}
+exports.default = DedicatedMachinesAttach;

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

@@ -0,0 +1,17 @@
+import { DedicatedLeaseCommand } from '../../../lib/dedicated-lease-command';
+/**
+ * `skrr machines dedicated catalog` — what `create` will accept, and what it costs.
+ *
+ * `--size-preset`, `--storage-gb`, `--retention-class` and `--backup-profile`
+ * carry no client-side values on purpose: presets are gated by server flags and
+ * the storage bounds are configuration. That made `create --help` point at
+ * `harnesses products`, whose table shows none of them without `--json`.
+ */
+export default class DedicatedMachinesCatalog extends DedicatedLeaseCommand {
+    static description: string;
+    static examples: string[];
+    static flags: {
+        json: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+    };
+    run(): Promise<void>;
+}

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

@@ -0,0 +1,75 @@
+"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 dedicated_machines_1 = require("../../../lib/dedicated-machines");
+const harnesses_1 = require("../../../lib/harnesses");
+/**
+ * `skrr machines dedicated catalog` — what `create` will accept, and what it costs.
+ *
+ * `--size-preset`, `--storage-gb`, `--retention-class` and `--backup-profile`
+ * carry no client-side values on purpose: presets are gated by server flags and
+ * the storage bounds are configuration. That made `create --help` point at
+ * `harnesses products`, whose table shows none of them without `--json`.
+ */
+class DedicatedMachinesCatalog extends dedicated_lease_command_1.DedicatedLeaseCommand {
+    static description = 'Show the Dedicated Runtime sizes, storage bounds, retention classes, backup profiles and prices that create accepts';
+    static examples = [
+        '<%= config.bin %> machines dedicated catalog',
+        '<%= config.bin %> machines dedicated catalog --json',
+    ];
+    static flags = {
+        json: core_1.Flags.boolean({ description: 'Output as JSON' }),
+    };
+    async run() {
+        this.requireAuth();
+        const { flags } = await this.parse(DedicatedMachinesCatalog);
+        const payload = await this.callDedicated(() => (0, harnesses_1.listHarnessProducts)());
+        const catalog = (0, dedicated_machines_1.dedicatedCatalogFromProducts)(payload);
+        if (!catalog) {
+            this.error('This server does not offer Dedicated Runtime.', { exit: 1 });
+        }
+        if (flags.json) {
+            this.log(JSON.stringify({ catalog }, null, 2));
+            return;
+        }
+        this.log(`Dedicated Runtime — ${catalog.availability}`);
+        if (catalog.disabledReason)
+            this.log(`  ${catalog.disabledReason}`);
+        if (catalog.headline)
+            this.log(`  ${catalog.headline}`);
+        this.log('\nSizes (--size-preset)');
+        if (catalog.sizes.length === 0)
+            this.log('  none offered right now');
+        for (const size of catalog.sizes) {
+            const spec = [
+                size.vcpus ? `${size.vcpus} vCPU` : '',
+                size.memoryGiB ? `${size.memoryGiB} GiB RAM` : '',
+                size.accelerator || '',
+            ]
+                .filter(Boolean)
+                .join(' · ');
+            this.log(`  ${String(size.id).padEnd(14)}${spec}`);
+        }
+        if (catalog.storage) {
+            const { minGb, defaultGb, maxGb } = catalog.storage;
+            this.log(`\nWorkspace (--storage-gb)\n  ${minGb}–${maxGb} GiB, default ${defaultGb}; grow later, never shrink`);
+        }
+        if (catalog.retentionClasses.length) {
+            this.log(`\nRetention (--retention-class)\n  ${catalog.retentionClasses.join(', ')}`);
+        }
+        if (catalog.backupProfiles.length) {
+            this.log(`\nBackup (--backup-profile)\n  ${catalog.backupProfiles.join(', ')}`);
+        }
+        if (catalog.regionClasses.length) {
+            this.log(`\nRegion (--region-class)\n  ${catalog.regionClasses.join(', ')}`);
+        }
+        this.log('\nPrices');
+        if (catalog.priceLines.length === 0)
+            this.log('  not published by this server');
+        for (const line of catalog.priceLines) {
+            this.log(`  ${line.display || `${(0, dedicated_machines_1.formatUsdCents)(line.amountCents)} ${line.label || ''}`}`);
+        }
+    }
+}
+exports.default = DedicatedMachinesCatalog;

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

@@ -0,0 +1,22 @@
+import { BaseCommand } from '../../../base-command';
+/**
+ * `skrr machines dedicated cp` — copy ONE file to or from a Dedicated Runtime.
+ *
+ * On the machine, paths resolve against /workspace and must be inside `repos/`
+ * or `user-data/`; the rest of the workspace belongs to the runtime. Files are
+ * limited to 64 MiB. See lib/dedicated-copy.ts for how neither end is ever left
+ * half-written.
+ */
+export default class DedicatedMachinesCp extends BaseCommand {
+    static description: string;
+    static examples: string[];
+    static args: {
+        source: import("@oclif/core/lib/interfaces").Arg<string, Record<string, unknown>>;
+        destination: 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/dedicated/cp.js

@@ -0,0 +1,76 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const core_1 = require("@oclif/core");
+const base_command_1 = require("../../../base-command");
+const dedicated_machines_1 = require("../../../lib/dedicated-machines");
+const dedicated_copy_1 = require("../../../lib/dedicated-copy");
+/**
+ * `skrr machines dedicated cp` — copy ONE file to or from a Dedicated Runtime.
+ *
+ * On the machine, paths resolve against /workspace and must be inside `repos/`
+ * or `user-data/`; the rest of the workspace belongs to the runtime. Files are
+ * limited to 64 MiB. See lib/dedicated-copy.ts for how neither end is ever left
+ * half-written.
+ */
+class DedicatedMachinesCp extends base_command_1.BaseCommand {
+    static description = 'Copy a file to or from a Dedicated Runtime machine';
+    static examples = [
+        '<%= config.bin %> machines dedicated cp ./dist/app.tar.gz rtl_abc123:repos/app/app.tar.gz',
+        '<%= 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
+    // will read a missing positional from stdin, so `skrr machines dedicated cp`
+    // typed with one argument hangs on a pipe instead of saying what it needs.
+    static args = {
+        source: core_1.Args.string({
+            description: 'Local path, or <lease-id>:<path> on the machine',
+            required: true,
+            ignoreStdin: true,
+        }),
+        destination: core_1.Args.string({
+            description: 'Local path, or <lease-id>:<path> on the machine',
+            required: true,
+            ignoreStdin: true,
+        }),
+    };
+    static flags = {
+        workspace: core_1.Flags.string({ description: 'Workspace scope' }),
+        json: core_1.Flags.boolean({ description: 'Output the result as JSON' }),
+    };
+    async run() {
+        this.requireAuth();
+        const { args, flags } = await this.parse(DedicatedMachinesCp);
+        let plan;
+        try {
+            plan = (0, dedicated_machines_1.parseDedicatedCopyEndpoints)(args.source, args.destination);
+        }
+        catch (err) {
+            this.error(err.message, { exit: 2 });
+        }
+        const scope = { workspaceId: flags.workspace };
+        let result;
+        try {
+            result =
+                plan.direction === 'upload'
+                    ? await (0, dedicated_copy_1.uploadToDedicatedRuntime)(plan.localPath, plan.leaseId, plan.remotePath, scope)
+                    : await (0, dedicated_copy_1.downloadFromDedicatedRuntime)(plan.leaseId, plan.remotePath, plan.localPath, scope);
+        }
+        catch (err) {
+            const message = (0, dedicated_machines_1.formatDedicatedRuntimeApiError)(err);
+            if (message)
+                this.error(message, { exit: 1, code: (0, dedicated_machines_1.dedicatedRuntimeApiErrorCode)(err) });
+            // A local failure (missing file, too large, changed mid-copy) is ours to
+            // explain; an API failure without a readable body goes to the shared path.
+            if (err instanceof Error && typeof err.status !== 'number') {
+                this.error(err.message, { exit: 1 });
+            }
+            this.handleApiError(err);
+        }
+        if (flags.json) {
+            this.log(JSON.stringify({ direction: plan.direction, ...result }, null, 2));
+            return;
+        }
+        this.log(`${plan.direction === 'upload' ? 'Uploaded' : 'Downloaded'} ${result.bytes} bytes → ${result.destination}`);
+    }
+}
+exports.default = DedicatedMachinesCp;

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

@@ -1,8 +1,11 @@
-import { BaseCommand } from '../../../base-command';
-export default class DedicatedMachinesCreate extends BaseCommand {
+import { DedicatedLeaseCommand } from '../../../lib/dedicated-lease-command';
+export default class DedicatedMachinesCreate extends DedicatedLeaseCommand {
     static description: string;
     static examples: string[];
     static flags: {
+        wait: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+        timeout: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
+        interval: import("@oclif/core/lib/interfaces").OptionFlag<number | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
         name: import("@oclif/core/lib/interfaces").OptionFlag<string, import("@oclif/core/lib/interfaces").CustomOptions>;
         'size-preset': import("@oclif/core/lib/interfaces").OptionFlag<string, import("@oclif/core/lib/interfaces").CustomOptions>;
         'region-class': import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
@@ -10,6 +13,7 @@ export default class DedicatedMachinesCreate extends BaseCommand {
         'retention-class': import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
         'backup-profile': import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
         'spending-limit-cents': import("@oclif/core/lib/interfaces").OptionFlag<number, import("@oclif/core/lib/interfaces").CustomOptions>;
+        repository: 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>;
         'request-id': import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
         json: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;

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

@@ -2,18 +2,18 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 const core_1 = require("@oclif/core");
 const node_crypto_1 = require("node:crypto");
-const base_command_1 = require("../../../base-command");
+const dedicated_lease_command_1 = require("../../../lib/dedicated-lease-command");
 const dedicated_machines_1 = require("../../../lib/dedicated-machines");
-class DedicatedMachinesCreate extends base_command_1.BaseCommand {
-    static description = 'Request a Dedicated Runtime lease';
+class DedicatedMachinesCreate extends dedicated_lease_command_1.DedicatedLeaseCommand {
+    static description = 'Request a Dedicated Runtime lease. See `machines dedicated catalog` for sizes, storage bounds and prices.';
     static examples = [
         '<%= config.bin %> machines dedicated create --name dev-box --size-preset standard --spending-limit-cents 20000',
-        '<%= config.bin %> machines dedicated create --name dev-box --size-preset standard --spending-limit-cents 20000 --json',
+        '<%= config.bin %> machines dedicated create --name dev-box --size-preset standard --spending-limit-cents 20000 --repository acme/app --wait --json',
     ];
     static flags = {
         name: core_1.Flags.string({ description: 'Display name for the dedicated machine', required: true }),
         'size-preset': core_1.Flags.string({
-            description: 'Instance size preset (from harnesses products)',
+            description: 'Instance size preset (see `machines dedicated catalog`)',
             required: true,
         }),
         // None of these four carry a client-side default, deliberately.
@@ -33,26 +33,34 @@ class DedicatedMachinesCreate extends base_command_1.BaseCommand {
             description: 'Workspace storage size in GB. Defaults to the product catalog size.',
         }),
         'retention-class': core_1.Flags.string({
-            description: 'Retention class for stopped instances. Defaults to the product catalog value.',
+            description: 'What destroy does with the workspace: none (delete), standard or extended (archive it). Defaults to the product catalog value.',
         }),
         'backup-profile': core_1.Flags.string({
             description: 'crash-consistent (AWS Backup) or application-consistent (guest fsfreeze while the daemon is reachable; scheduled DLM when that plan is enabled). Defaults to the product catalog value.',
         }),
         'spending-limit-cents': core_1.Flags.integer({
-            description: 'Monthly spending limit in cents. Required before start.',
+            description: 'Monthly spending limit in cents. Required; change it later with `machines dedicated spending-limit`.',
             required: true,
         }),
+        repository: core_1.Flags.string({
+            description: 'Default GitHub repository (owner/repo) for git credentials on the machine. Requires the GitHub App installed for it; a clone of another repository the App covers still works.',
+        }),
         workspace: core_1.Flags.string({ description: 'Workspace scope' }),
         'request-id': core_1.Flags.string({
             description: 'Idempotency key. Reuse it to safely retry the same create request.',
         }),
         json: core_1.Flags.boolean({ description: 'Output as JSON' }),
+        ...dedicated_lease_command_1.dedicatedWaitFlags,
     };
     async run() {
         this.requireAuth();
         const { flags } = await this.parse(DedicatedMachinesCreate);
+        if (flags.repository !== undefined && !(0, dedicated_machines_1.isDedicatedRepositoryRef)(flags.repository)) {
+            this.error(`--repository must look like owner/repo, got "${flags.repository}".`, { exit: 2 });
+        }
+        const requestId = flags['request-id'] || newRequestId();
         const body = (0, dedicated_machines_1.dedicatedRuntimeCreateInput)({
-            requestId: flags['request-id'] || newRequestId(),
+            requestId,
             displayName: flags.name,
             sizePreset: flags['size-preset'],
             monthlySpendingLimitCents: flags['spending-limit-cents'],
@@ -60,27 +68,28 @@ class DedicatedMachinesCreate extends base_command_1.BaseCommand {
             storageGb: flags['storage-gb'],
             retentionClass: flags['retention-class'],
             backupProfile: flags['backup-profile'],
+            repositoryRef: flags.repository,
             workspaceId: flags.workspace,
         });
-        let response;
-        try {
-            response = await (0, dedicated_machines_1.createDedicatedRuntime)(body);
-        }
-        catch (err) {
-            const message = (0, dedicated_machines_1.formatDedicatedRuntimeApiError)(err);
-            if (message)
-                this.error(message, { exit: 1 });
-            this.handleApiError(err);
-        }
+        const response = await this.callDedicated(() => (0, dedicated_machines_1.createDedicatedRuntime)(body));
         const lease = response?.lease;
+        const id = (0, dedicated_machines_1.dedicatedLeaseId)(lease);
+        if (flags.wait) {
+            // The request id is what makes a retry safe, and a --wait that times out
+            // is exactly when someone retries — so say it before watching.
+            if (!flags.json && !flags['request-id']) {
+                process.stderr.write(`Request id ${requestId} (reuse it with --request-id to retry safely)\n`);
+            }
+            await this.reportLeaseAction(response, flags, { kind: 'running' }, 'Provisioning');
+            return;
+        }
         if (flags.json) {
             this.log(JSON.stringify(response, null, 2));
             return;
         }
-        const id = (0, dedicated_machines_1.dedicatedLeaseId)(lease);
         this.log(`Dedicated Runtime ${(0, dedicated_machines_1.dedicatedLeaseDisplayName)(lease)} (${id || 'unknown'}) ${(0, dedicated_machines_1.dedicatedLeaseState)(lease)}.`);
         if (id) {
-            this.log(`Poll: ${this.config.bin} machines dedicated show ${id}`);
+            this.log(`Poll: ${this.config.bin} machines dedicated show ${id}  (or pass --wait)`);
         }
     }
 }

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

@@ -0,0 +1,19 @@
+import { DedicatedLeaseCommand } from '../../../lib/dedicated-lease-command';
+/**
+ * `skrr machines dedicated current` — which Dedicated Runtime am I running on?
+ *
+ * An agent working on the machine is the caller most likely to need its own
+ * lease — to snapshot before something risky, read the spend against the cap,
+ * or stop the machine when the work is done — and nothing in its environment
+ * names it. Every lease command also accepts `self`; this prints the answer so a
+ * script can hold it.
+ */
+export default class DedicatedMachinesCurrent extends DedicatedLeaseCommand {
+    static description: string;
+    static examples: string[];
+    static flags: {
+        id: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+        json: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+    };
+    run(): Promise<void>;
+}