@skrr-ai/cli 0.1.8

package/dist/commands/harnesses/grants/revoke.d.ts

@@ -0,0 +1,14 @@
+import { BaseCommand } from '../../../base-command';
+export default class HarnessesGrantsRevoke extends BaseCommand {
+    static aliases: string[];
+    static description: string;
+    static examples: string[];
+    static args: {
+        harness: import("@oclif/core/lib/interfaces").Arg<string, Record<string, unknown>>;
+        grant: import("@oclif/core/lib/interfaces").Arg<string, Record<string, unknown>>;
+    };
+    static flags: {
+        json: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+    };
+    run(): Promise<void>;
+}

package/dist/commands/harnesses/grants/revoke.js

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const core_1 = require("@oclif/core");
+const base_command_1 = require("../../../base-command");
+const runtime_grants_1 = require("../../../lib/runtime-grants");
+class HarnessesGrantsRevoke extends base_command_1.BaseCommand {
+    static aliases = ['harnesses:grants:revoke'];
+    static description = 'Stop lending a harness to a workspace';
+    static examples = [
+        '<%= config.bin %> harnesses grants revoke <harness-id> <grant-id>',
+        '<%= config.bin %> harnesses grants revoke <harness-id> <grant-id> --json',
+    ];
+    static args = {
+        harness: core_1.Args.string({ ignoreStdin: true, description: 'Harness ID', required: true }),
+        grant: core_1.Args.string({ ignoreStdin: true, description: 'Grant ID', required: true }),
+    };
+    static flags = {
+        json: core_1.Flags.boolean({ description: 'Output as JSON' }),
+    };
+    async run() {
+        this.requireAuth();
+        const { args, flags } = await this.parse(HarnessesGrantsRevoke);
+        let grant;
+        try {
+            grant = await (0, runtime_grants_1.revokeHarnessGrant)(args.harness, args.grant);
+        }
+        catch (err) {
+            this.handleApiError(err);
+            return;
+        }
+        if (flags.json) {
+            this.log(JSON.stringify(grant, null, 2));
+            return;
+        }
+        // Unilateral by design: the owner does not need the borrowing workspace's
+        // agreement to stop lending their machine.
+        this.log(`Revoked grant ${grant.id} — workspace ${grant.workspaceId} can no longer use this harness.`);
+        this.log('The revoked grant is kept as a record; granting again creates a new one.');
+    }
+}
+exports.default = HarnessesGrantsRevoke;

package/dist/commands/harnesses/install-token.d.ts

@@ -0,0 +1,21 @@
+import { BaseCommand } from '../../base-command';
+/**
+ * Mint a token that installs a daemon on another machine.
+ *
+ * `skrr pair` is the interactive path and remains the one to reach for on a
+ * machine you are sitting at. This exists for the case pair cannot serve: a
+ * remote Linux host, provisioned from a script, where nobody will be present to
+ * complete a browser flow.
+ *
+ * The token is printed ONCE. It is a credential that adds a machine to your
+ * fleet, so it is not stored and cannot be re-read.
+ */
+export default class HarnessesInstallToken extends BaseCommand {
+    static description: string;
+    static examples: string[];
+    static flags: {
+        json: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+        target: import("@oclif/core/lib/interfaces").OptionFlag<string, import("@oclif/core/lib/interfaces").CustomOptions>;
+    };
+    run(): Promise<void>;
+}

package/dist/commands/harnesses/install-token.js

@@ -0,0 +1,48 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const core_1 = require("@oclif/core");
+const base_command_1 = require("../../base-command");
+const harnesses_1 = require("../../lib/harnesses");
+/**
+ * Mint a token that installs a daemon on another machine.
+ *
+ * `skrr pair` is the interactive path and remains the one to reach for on a
+ * machine you are sitting at. This exists for the case pair cannot serve: a
+ * remote Linux host, provisioned from a script, where nobody will be present to
+ * complete a browser flow.
+ *
+ * The token is printed ONCE. It is a credential that adds a machine to your
+ * fleet, so it is not stored and cannot be re-read.
+ */
+class HarnessesInstallToken extends base_command_1.BaseCommand {
+    static description = 'Mint a daemon install token for another machine (printed once)';
+    static examples = [
+        '<%= config.bin %> harnesses install-token',
+        '<%= config.bin %> harnesses install-token --target remote-linux',
+    ];
+    static flags = {
+        json: core_1.Flags.boolean({ description: 'Output as JSON' }),
+        target: core_1.Flags.string({
+            description: 'Where the daemon will be installed.',
+            options: ['foreground', 'remote-linux', 'service-install'],
+            default: 'foreground',
+        }),
+    };
+    async run() {
+        this.requireAuth();
+        const { flags } = await this.parse(HarnessesInstallToken);
+        try {
+            const response = await (0, harnesses_1.mintInstallToken)(flags.target);
+            if (flags.json) {
+                this.log(JSON.stringify(response, null, 2));
+                return;
+            }
+            this.log(JSON.stringify(response, null, 2));
+            this.log('\nThis token is shown once and adds a machine to your fleet. Treat it as a credential.');
+        }
+        catch (err) {
+            this.handleApiError(err);
+        }
+    }
+}
+exports.default = HarnessesInstallToken;

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

@@ -0,0 +1,21 @@
+import { BaseCommand } from '../../../base-command';
+/**
+ * Lifecycle actions on what a lease is holding.
+ *
+ * The action set is the server's (`MACHINE_LEASE_ACTIONS`), declared once in the
+ * lib and re-exported here rather than re-typed — a second copy of a vocabulary
+ * is how a CLI starts offering a verb the server rejects.
+ */
+export default class HarnessesLeasesAction extends BaseCommand {
+    static description: string;
+    static examples: string[];
+    static args: {
+        lease: import("@oclif/core/lib/interfaces").Arg<string, Record<string, unknown>>;
+        action: 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/harnesses/leases/action.js

@@ -0,0 +1,69 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+/**
+ * Harness leases — the hosted billing plane.
+ *
+ * A lease is an open entitlement to run on a hosted harness: it names a product
+ * (`harnesses products`), has a lifecycle, and costs money while it lives. That
+ * is why the write verbs here are spelled out rather than folded into one
+ * `--action` grab bag, and why `release` and `action destroy` are separate
+ * words for separate intents.
+ */
+const core_1 = require("@oclif/core");
+const base_command_1 = require("../../../base-command");
+const harnesses_1 = require("../../../lib/harnesses");
+/**
+ * Lifecycle actions on what a lease is holding.
+ *
+ * The action set is the server's (`MACHINE_LEASE_ACTIONS`), declared once in the
+ * lib and re-exported here rather than re-typed — a second copy of a vocabulary
+ * is how a CLI starts offering a verb the server rejects.
+ */
+class HarnessesLeasesAction extends base_command_1.BaseCommand {
+    static description = 'Run a lifecycle action on a harness lease';
+    static examples = [
+        '<%= config.bin %> harnesses leases action <lease-id> pause',
+        '<%= config.bin %> harnesses leases action <lease-id> resume',
+        '<%= config.bin %> harnesses leases action <lease-id> health-check',
+    ];
+    static args = {
+        lease: core_1.Args.string({ ignoreStdin: true, description: 'Lease ID', required: true }),
+        action: core_1.Args.string({
+            ignoreStdin: true,
+            description: `One of: ${harnesses_1.HARNESS_LEASE_ACTIONS.join(', ')}`,
+            required: true,
+            options: harnesses_1.HARNESS_LEASE_ACTIONS,
+        }),
+    };
+    static flags = {
+        json: core_1.Flags.boolean({ description: 'Output as JSON' }),
+        yes: core_1.Flags.boolean({ char: 'y', description: 'Skip the confirmation', default: false }),
+    };
+    async run() {
+        this.requireAuth();
+        const { args, flags } = await this.parse(HarnessesLeasesAction);
+        // Only the irreversible ones ask. Prompting on `pause` teaches the operator
+        // to type y without reading, which is what makes the prompt on `destroy`
+        // worth anything.
+        const irreversible = args.action === 'destroy' || args.action === 'terminate';
+        if (irreversible && !flags.yes) {
+            const confirmed = await this.confirm(`${args.action} lease ${args.lease}? This cannot be undone. [y/N] `);
+            if (!confirmed) {
+                this.log('Aborted.');
+                this.exit(1);
+            }
+        }
+        try {
+            const response = await (0, harnesses_1.performHarnessLeaseAction)(args.lease, args.action);
+            if (flags.json) {
+                this.log(JSON.stringify(response, null, 2));
+                return;
+            }
+            this.log(`${args.action}: ${response?.lease?.state ?? 'done'}`);
+        }
+        catch (err) {
+            this.handleApiError(err);
+        }
+    }
+}
+exports.default = HarnessesLeasesAction;

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

@@ -0,0 +1,21 @@
+import { BaseCommand } from '../../../base-command';
+/**
+ * Retarget who pays for a lease.
+ *
+ * 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.
+ */
+export default class HarnessesLeasesBilling extends BaseCommand {
+    static description: string;
+    static examples: string[];
+    static args: {
+        lease: import("@oclif/core/lib/interfaces").Arg<string, Record<string, unknown>>;
+    };
+    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>;
+    };
+    run(): Promise<void>;
+}

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

@@ -0,0 +1,66 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+/**
+ * Harness leases — the hosted billing plane.
+ *
+ * A lease is an open entitlement to run on a hosted harness: it names a product
+ * (`harnesses products`), has a lifecycle, and costs money while it lives. That
+ * is why the write verbs here are spelled out rather than folded into one
+ * `--action` grab bag, and why `release` and `action destroy` are separate
+ * words for separate intents.
+ */
+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.
+ *
+ * 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.
+ */
+class HarnessesLeasesBilling extends base_command_1.BaseCommand {
+    static description = 'Change who pays for a harness lease';
+    static examples = [
+        '<%= config.bin %> harnesses leases billing <lease-id> --workspace <workspace-id>',
+        '<%= config.bin %> harnesses leases billing <lease-id> --personal',
+    ];
+    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'],
+        }),
+    };
+    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);
+            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}.`);
+        }
+        catch (err) {
+            this.handleApiError(err);
+        }
+    }
+}
+exports.default = HarnessesLeasesBilling;

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

@@ -0,0 +1,9 @@
+import { BaseCommand } from '../../../base-command';
+export default class HarnessesLeasesList extends BaseCommand {
+    static description: string;
+    static examples: string[];
+    static flags: {
+        json: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+    };
+    run(): Promise<void>;
+}

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

@@ -0,0 +1,60 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+/**
+ * Harness leases — the hosted billing plane.
+ *
+ * A lease is an open entitlement to run on a hosted harness: it names a product
+ * (`harnesses products`), has a lifecycle, and costs money while it lives. That
+ * is why the write verbs here are spelled out rather than folded into one
+ * `--action` grab bag, and why `release` and `action destroy` are separate
+ * words for separate intents.
+ */
+const core_1 = require("@oclif/core");
+const base_command_1 = require("../../../base-command");
+const format_1 = require("../../../lib/format");
+const harnesses_1 = require("../../../lib/harnesses");
+class HarnessesLeasesList extends base_command_1.BaseCommand {
+    static description = 'List your open harness leases';
+    static examples = [
+        '<%= config.bin %> harnesses leases list',
+        '<%= config.bin %> harnesses leases list --json',
+    ];
+    static flags = { json: core_1.Flags.boolean({ description: 'Output as JSON' }) };
+    async run() {
+        this.requireAuth();
+        const { flags } = await this.parse(HarnessesLeasesList);
+        let response;
+        try {
+            response = await (0, harnesses_1.listHarnessLeases)();
+        }
+        catch (err) {
+            this.handleApiError(err);
+            return;
+        }
+        const leases = response?.leases ?? [];
+        if (flags.json) {
+            this.log(JSON.stringify(leases, null, 2));
+            return;
+        }
+        if (leases.length === 0) {
+            // Say what empty MEANS. "No leases" reads as a failed query; the honest
+            // reading is that nothing hosted is running, and nothing is being billed.
+            this.log('No open leases — nothing hosted is running, and nothing is accruing.');
+            return;
+        }
+        (0, format_1.renderTable)(leases.map((lease) => ({
+            id: String(lease.leaseId ?? lease.id ?? ''),
+            product: String(lease.productId ?? ''),
+            state: String(lease.state ?? ''),
+            harness: String(lease.runtimeId ?? ''),
+            expires: String(lease.expiresAt ?? ''),
+        })), [
+            { key: 'id', header: 'LEASE' },
+            { key: 'product', header: 'PRODUCT' },
+            { key: 'state', header: 'STATE' },
+            { key: 'harness', header: 'ENGINE' },
+            { key: 'expires', header: 'EXPIRES' },
+        ], (line) => this.log(line));
+    }
+}
+exports.default = HarnessesLeasesList;

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

@@ -0,0 +1,21 @@
+import { BaseCommand } from '../../../base-command';
+/**
+ * Give the lease back — stop paying for it.
+ *
+ * Distinct from `harnesses leases action <id> destroy`, and the difference is
+ * worth the two words: RELEASE hands the entitlement back and is the ordinary
+ * end of a lease's life; DESTROY is a lifecycle action on whatever the lease is
+ * holding. One is billing, the other is compute.
+ */
+export default class HarnessesLeasesRelease extends BaseCommand {
+    static description: string;
+    static examples: string[];
+    static args: {
+        lease: 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/harnesses/leases/release.js

@@ -0,0 +1,59 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+/**
+ * Harness leases — the hosted billing plane.
+ *
+ * A lease is an open entitlement to run on a hosted harness: it names a product
+ * (`harnesses products`), has a lifecycle, and costs money while it lives. That
+ * is why the write verbs here are spelled out rather than folded into one
+ * `--action` grab bag, and why `release` and `action destroy` are separate
+ * words for separate intents.
+ */
+const core_1 = require("@oclif/core");
+const base_command_1 = require("../../../base-command");
+const harnesses_1 = require("../../../lib/harnesses");
+/**
+ * Give the lease back — stop paying for it.
+ *
+ * Distinct from `harnesses leases action <id> destroy`, and the difference is
+ * worth the two words: RELEASE hands the entitlement back and is the ordinary
+ * end of a lease's life; DESTROY is a lifecycle action on whatever the lease is
+ * holding. One is billing, the other is compute.
+ */
+class HarnessesLeasesRelease extends base_command_1.BaseCommand {
+    static description = 'Release a harness lease (stop paying for it)';
+    static examples = [
+        '<%= config.bin %> harnesses leases release <lease-id>',
+        '<%= config.bin %> harnesses leases release <lease-id> --yes',
+    ];
+    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' }),
+        yes: core_1.Flags.boolean({ char: 'y', description: 'Skip the confirmation', default: false }),
+    };
+    async run() {
+        this.requireAuth();
+        const { args, flags } = await this.parse(HarnessesLeasesRelease);
+        if (!flags.yes) {
+            const confirmed = await this.confirm(`Release lease ${args.lease}? Anything running on it stops. [y/N] `);
+            if (!confirmed) {
+                this.log('Aborted.');
+                this.exit(1);
+            }
+        }
+        try {
+            const response = await (0, harnesses_1.releaseHarnessLease)(args.lease);
+            if (flags.json) {
+                this.log(JSON.stringify(response, null, 2));
+                return;
+            }
+            this.log(`Released ${args.lease}.`);
+        }
+        catch (err) {
+            this.handleApiError(err);
+        }
+    }
+}
+exports.default = HarnessesLeasesRelease;

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

@@ -0,0 +1,12 @@
+import { BaseCommand } from '../../../base-command';
+export default class HarnessesLeasesShow extends BaseCommand {
+    static description: string;
+    static examples: string[];
+    static args: {
+        lease: import("@oclif/core/lib/interfaces").Arg<string, Record<string, unknown>>;
+    };
+    static flags: {
+        json: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+    };
+    run(): Promise<void>;
+}

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

@@ -0,0 +1,84 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+/**
+ * Harness leases — the hosted billing plane.
+ *
+ * A lease is an open entitlement to run on a hosted harness: it names a product
+ * (`harnesses products`), has a lifecycle, and costs money while it lives. That
+ * is why the write verbs here are spelled out rather than folded into one
+ * `--action` grab bag, and why `release` and `action destroy` are separate
+ * words for separate intents.
+ */
+const core_1 = require("@oclif/core");
+const base_command_1 = require("../../../base-command");
+const harnesses_1 = require("../../../lib/harnesses");
+class HarnessesLeasesShow extends base_command_1.BaseCommand {
+    static description = 'Show one harness lease';
+    static examples = ['<%= config.bin %> harnesses leases show <lease-id>'];
+    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' }) };
+    async run() {
+        this.requireAuth();
+        const { args, flags } = await this.parse(HarnessesLeasesShow);
+        let lease;
+        try {
+            const response = await (0, harnesses_1.getHarnessLease)(args.lease);
+            lease = (response?.lease ?? response);
+        }
+        catch (err) {
+            this.handleApiError(err);
+        }
+        // This declared `json` and never read it, printing raw JSON either way —
+        // the same defect a722993576 fixed for `harnesses usage`, `products` and
+        // `models`, in a fourth command it did not reach. A lease costs money while
+        // it lives, so "what is this thing and is it running" should not require
+        // reading a JSON blob.
+        if (flags.json) {
+            this.log(JSON.stringify(lease, null, 2));
+            return;
+        }
+        if (!lease) {
+            this.log('Lease not found.');
+            return;
+        }
+        const line = (label, value) => {
+            if (value === undefined || value === null || value === '')
+                return;
+            this.log(`${label.padEnd(14)}${String(value)}`);
+        };
+        // Only ever a PRIMITIVE reaches `line`. Falling back to the parent object
+        // when a key is absent renders `[object Object]`, which is worse than
+        // omitting the row — it looks like data.
+        const nested = (parent, key) => {
+            const value = parent && typeof parent === 'object' ? parent[key] : undefined;
+            return value !== null && typeof value === 'object' ? undefined : value;
+        };
+        line('ID:', lease.id);
+        line('Product:', lease.machineProductLabel ?? lease.machineProduct);
+        line('State:', lease.stateReason ? `${lease.state} (${lease.stateReason})` : lease.state);
+        line('Name:', lease.displayName);
+        line('Daemon:', nested(lease.daemon, 'version'));
+        const os = nested(lease.resources, 'os');
+        const arch = nested(lease.resources, 'architecture');
+        if (os || arch)
+            line('Resources:', [os, arch].filter(Boolean).join('/'));
+        // `assignable` is the question a reader has about health, and the reasons
+        // are why — a bare status word would drop the actionable half.
+        const assignable = nested(lease.health, 'assignable');
+        if (assignable !== undefined) {
+            const reasons = lease.health?.reasons;
+            const why = Array.isArray(reasons) && reasons.length > 0 ? ` (${reasons.join(', ')})` : '';
+            line('Assignable:', `${assignable === true ? 'yes' : 'no'}${why}`);
+        }
+        line('Created:', lease.createdAt);
+        line('Updated:', lease.updatedAt);
+        // Money last, and only when the server sent it — an absent billing block
+        // and a zero are different states.
+        line('Billing:', nested(lease.billing, 'billableState'));
+        this.log('');
+        this.log('Full record: --json');
+    }
+}
+exports.default = HarnessesLeasesShow;