@skrr-ai/cli 0.1.18 → 0.1.20

package/dist/commands/store/releases.d.ts

@@ -0,0 +1,19 @@
+import { BaseCommand } from '../../base-command';
+/**
+ * What versions of a published agent exist.
+ *
+ * Operator-relevant rather than store chrome: pinning an install to a specific
+ * release, or reading what changed before taking an update, both need this and
+ * neither is a browsing activity.
+ */
+export default class StoreReleases extends BaseCommand {
+    static description: string;
+    static examples: string[];
+    static args: {
+        agentId: 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/store/releases.js

@@ -0,0 +1,60 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const core_1 = require("@oclif/core");
+const data_provider_1 = require("@skrr-ai/data-provider");
+const base_command_1 = require("../../base-command");
+const format_1 = require("../../lib/format");
+/**
+ * What versions of a published agent exist.
+ *
+ * Operator-relevant rather than store chrome: pinning an install to a specific
+ * release, or reading what changed before taking an update, both need this and
+ * neither is a browsing activity.
+ */
+class StoreReleases extends base_command_1.BaseCommand {
+    static description = 'List the published releases of a store agent';
+    static examples = [
+        '<%= config.bin %> store releases agent_abc123',
+        '<%= config.bin %> store releases agent_abc123 --json',
+    ];
+    static args = {
+        agentId: core_1.Args.string({ description: 'The store agent', required: true }),
+    };
+    static flags = {
+        json: core_1.Flags.boolean({ description: 'Output as JSON' }),
+    };
+    async run() {
+        this.requireAuth();
+        const { args, flags } = await this.parse(StoreReleases);
+        let response;
+        try {
+            response = await data_provider_1.dataService.getStoreAgentReleases(args.agentId);
+        }
+        catch (err) {
+            this.handleApiError(err);
+        }
+        if (flags.json) {
+            this.log(JSON.stringify(response, null, 2));
+            return;
+        }
+        const items = response?.data ?? [];
+        if (items.length === 0) {
+            this.log('No published releases.');
+            return;
+        }
+        (0, format_1.renderTable)(items.map((r) => ({
+            id: String(r.id ?? '-'),
+            version: String(r.versionLabel ?? '-'),
+            price: r.price ? String(r.price) : 'free',
+            published: r.publishedAt ? String(r.publishedAt).slice(0, 10) : '-',
+            changelog: String(r.changelog ?? ''),
+        })), [
+            { key: 'id', header: 'RELEASE ID' },
+            { key: 'version', header: 'VERSION' },
+            { key: 'price', header: 'PRICE' },
+            { key: 'published', header: 'PUBLISHED' },
+            { key: 'changelog', header: 'CHANGELOG', maxWidth: 44 },
+        ], (line) => this.log(line));
+    }
+}
+exports.default = StoreReleases;

package/dist/commands/store/update.d.ts

@@ -0,0 +1,15 @@
+import { BaseCommand } from '../../base-command';
+export default class StoreUpdate extends BaseCommand {
+    static description: string;
+    static examples: string[];
+    static args: {
+        agentId: import("@oclif/core/lib/interfaces").Arg<string, Record<string, unknown>>;
+    };
+    static flags: {
+        json: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+        release: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
+        installed: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
+        strategy: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
+    };
+    run(): Promise<void>;
+}

package/dist/commands/store/update.js

@@ -0,0 +1,69 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const core_1 = require("@oclif/core");
+const data_provider_1 = require("@skrr-ai/data-provider");
+const base_command_1 = require("../../base-command");
+class StoreUpdate extends base_command_1.BaseCommand {
+    static description = 'Update an installed agent to a published release, keeping the edits you made to your copy';
+    static examples = [
+        '<%= config.bin %> store update agent_abc123',
+        '<%= config.bin %> store update agent_abc123 --release ar_def456',
+        '<%= config.bin %> store update agent_abc123 --strategy replace',
+    ];
+    static args = {
+        agentId: core_1.Args.string({ description: 'The store agent you installed', required: true }),
+    };
+    static flags = {
+        json: core_1.Flags.boolean({ description: 'Output as JSON' }),
+        release: core_1.Flags.string({ description: 'Target release id (defaults to the latest)' }),
+        installed: core_1.Flags.string({ description: 'Your installed copy (defaults to the purchase)' }),
+        strategy: core_1.Flags.string({
+            description: 'merge (default) keeps your edits and refuses on a conflict; replace takes the publisher version',
+            options: ['merge', 'replace'],
+        }),
+    };
+    async run() {
+        this.requireAuth();
+        const { args, flags } = await this.parse(StoreUpdate);
+        let response;
+        try {
+            response = await data_provider_1.dataService.updateInstalledStoreAgent({
+                agentId: args.agentId,
+                ...(flags.installed ? { installedAgentId: flags.installed } : {}),
+                ...(flags.release ? { targetReleaseId: flags.release } : {}),
+                ...(flags.strategy ? { strategy: flags.strategy } : {}),
+            });
+        }
+        catch (err) {
+            // A conflict is not a failure of the update; it is the update asking a
+            // question. Print the fields, and the one command that answers it.
+            const conflict = err;
+            const body = conflict?.body;
+            if (body?.code === 'UPDATE_CONFLICT' || body?.code === 'UPDATE_NO_BASE') {
+                this.log(body.error ?? 'This update needs a decision.');
+                if (body.conflicts?.length) {
+                    this.log(`Both of you changed: ${body.conflicts.join(', ')}`);
+                }
+                this.log('');
+                this.log(`Take the publisher version:  skrr store update ${args.agentId} --strategy replace`);
+                this.error('Update not applied.', { exit: 1 });
+            }
+            this.handleApiError(err);
+        }
+        if (flags.json) {
+            this.log(JSON.stringify(response, null, 2));
+            return;
+        }
+        const merge = response
+            ?.merge;
+        this.log(`Updated to ${response?.targetVersionLabel ?? response?.targetReleaseId ?? ''}.`);
+        if (merge?.kept?.length) {
+            // The promise that makes an automatic update worth having, made visible.
+            this.log(`Kept your changes to: ${merge.kept.join(', ')}`);
+        }
+        if (merge?.taken?.length) {
+            this.log(`Applied: ${merge.taken.join(', ')}`);
+        }
+    }
+}
+exports.default = StoreUpdate;

package/dist/commands/store/updates.d.ts

@@ -0,0 +1,24 @@
+import { BaseCommand } from '../../base-command';
+/**
+ * What is waiting on you across everything you installed.
+ *
+ * Three states, kept apart because they ask for three different things:
+ *
+ *   ready    a same-major release that will apply cleanly
+ *   review   one that could not be applied on its own — you and the publisher
+ *            both changed the same field, or the version your copy came from is
+ *            unknown so your edits cannot be told apart from theirs
+ *   buy      a new major, which under the channel decision is a fresh purchase
+ *            rather than an update
+ *
+ * Collapsing them into "update available" is what makes a person ignore the
+ * whole column: two of the three cannot be resolved by pressing update.
+ */
+export default class StoreUpdates extends BaseCommand {
+    static description: string;
+    static examples: string[];
+    static flags: {
+        json: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+    };
+    run(): Promise<void>;
+}

package/dist/commands/store/updates.js

@@ -0,0 +1,113 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const core_1 = require("@oclif/core");
+const data_provider_1 = require("@skrr-ai/data-provider");
+const base_command_1 = require("../../base-command");
+const format_1 = require("../../lib/format");
+/**
+ * What is waiting on you across everything you installed.
+ *
+ * Three states, kept apart because they ask for three different things:
+ *
+ *   ready    a same-major release that will apply cleanly
+ *   review   one that could not be applied on its own — you and the publisher
+ *            both changed the same field, or the version your copy came from is
+ *            unknown so your edits cannot be told apart from theirs
+ *   buy      a new major, which under the channel decision is a fresh purchase
+ *            rather than an update
+ *
+ * Collapsing them into "update available" is what makes a person ignore the
+ * whole column: two of the three cannot be resolved by pressing update.
+ */
+class StoreUpdates extends base_command_1.BaseCommand {
+    static description = 'Show what is waiting across the agents you installed';
+    static examples = [
+        '<%= config.bin %> store updates',
+        '<%= config.bin %> store updates --json',
+    ];
+    static flags = {
+        json: core_1.Flags.boolean({ description: 'Output as JSON' }),
+    };
+    async run() {
+        this.requireAuth();
+        const { flags } = await this.parse(StoreUpdates);
+        let purchased;
+        try {
+            purchased = await data_provider_1.dataService.getPurchasedAgents();
+        }
+        catch (err) {
+            this.handleApiError(err);
+        }
+        const items = purchased?.data ?? [];
+        const rows = [];
+        for (const item of items) {
+            const agentId = String(item.sourceAgentId ?? item.id ?? '');
+            if (!agentId) {
+                continue;
+            }
+            let status;
+            try {
+                status = await data_provider_1.dataService.getAgentPurchaseStatus(agentId);
+            }
+            catch {
+                // One unreadable listing must not hide the rest. A row we could not
+                // read is reported as such rather than silently dropped.
+                rows.push({ agent: agentId, state: 'unreadable', have: '-', waiting: '-', detail: '' });
+                continue;
+            }
+            if (!status?.purchased) {
+                continue;
+            }
+            const have = status.installedVersionLabel ?? '-';
+            if (status.pendingUpdate) {
+                rows.push({
+                    agent: agentId,
+                    state: 'review',
+                    have,
+                    waiting: status.pendingUpdate.versionLabel ?? '-',
+                    detail: status.pendingUpdate.reason === 'conflict'
+                        ? `you both changed ${(status.pendingUpdate.conflicts ?? []).join(', ') || 'a field'}`
+                        : 'the version your copy came from is unknown',
+                });
+            }
+            if (status.availableMajor) {
+                rows.push({
+                    agent: agentId,
+                    state: 'buy',
+                    have,
+                    waiting: status.availableMajor.versionLabel ?? '-',
+                    detail: 'a new major is a separate purchase',
+                });
+            }
+            if (!status.pendingUpdate && status.updateAvailable && status.updateKind === 'minor') {
+                rows.push({
+                    agent: agentId,
+                    state: 'ready',
+                    have,
+                    waiting: status.latestVersionLabel ?? '-',
+                    detail: 'applies cleanly',
+                });
+            }
+        }
+        if (flags.json) {
+            this.log(JSON.stringify({ object: 'list', data: rows }, null, 2));
+            return;
+        }
+        if (rows.length === 0) {
+            this.log('Nothing waiting.');
+            return;
+        }
+        (0, format_1.renderTable)(rows, [
+            { key: 'agent', header: 'AGENT' },
+            { key: 'state', header: 'STATE' },
+            { key: 'have', header: 'YOU HAVE' },
+            { key: 'waiting', header: 'WAITING' },
+            { key: 'detail', header: 'WHY', maxWidth: 46 },
+        ], (line) => this.log(line));
+        this.log('');
+        this.log('ready  → skrr store update <agent>');
+        this.log('review → skrr store update <agent> --strategy replace   (takes the publisher version)');
+        this.log('buy    → skrr store install <agent>');
+    }
+}
+exports.default = StoreUpdates;

package/dist/commands/subscriptions/cancel.d.ts

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

package/dist/commands/subscriptions/cancel.js

@@ -0,0 +1,47 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const core_1 = require("@oclif/core");
+const data_provider_1 = require("@skrr-ai/data-provider");
+const base_command_1 = require("../../base-command");
+class SubscriptionsCancel extends base_command_1.BaseCommand {
+    static description = 'End a service subscription. Stops future work; keeps everything already delivered';
+    static examples = [
+        '<%= config.bin %> subscriptions cancel agent_abc123',
+        '<%= config.bin %> subscriptions cancel agent_abc123 --reason "no longer needed"',
+        '<%= config.bin %> subscriptions cancel agent_abc123 --expected-version 3',
+    ];
+    static args = {
+        agentId: core_1.Args.string({ description: 'The service to unsubscribe from', required: true }),
+    };
+    static flags = {
+        json: core_1.Flags.boolean({ description: 'Output as JSON' }),
+        reason: core_1.Flags.string({ description: 'Why it is being cancelled (recorded on the lease)' }),
+        'expected-version': core_1.Flags.integer({
+            description: 'Fence — refuse if the lease has changed since you read it. Pass it when a program read the subscription first.',
+        }),
+    };
+    async run() {
+        this.requireAuth();
+        const { args, flags } = await this.parse(SubscriptionsCancel);
+        let response;
+        try {
+            response = await data_provider_1.dataService.unsubscribeFromStoreAgent(args.agentId, {
+                ...(flags.reason ? { reason: flags.reason } : {}),
+                ...(flags['expected-version'] !== undefined
+                    ? { expectedVersion: flags['expected-version'] }
+                    : {}),
+            });
+        }
+        catch (err) {
+            this.handleApiError(err);
+        }
+        if (flags.json) {
+            this.log(JSON.stringify(response, null, 2));
+            return;
+        }
+        this.log(`Ended subscription ${response?.entitlementId} (${response?.status}).`);
+        // Said plainly, because it is the thing people fear about cancelling.
+        this.log(response?.retained ?? '');
+    }
+}
+exports.default = SubscriptionsCancel;

package/dist/commands/subscriptions/health.d.ts

@@ -0,0 +1,24 @@
+import { BaseCommand } from '../../base-command';
+/**
+ * Has this service actually delivered?
+ *
+ * The question every recurring charge has to answer, and the reason a
+ * subscription is modelled as a Commitment rather than a billing schedule.
+ *
+ * `unverified` — the work is done and nobody has looked — is counted as
+ * DELIVERED and reported separately as "waiting on you". It is not a failure:
+ * counting it as one would let a subscriber who stops confirming make a working
+ * service read as broken. It is surfaced anyway, because it is the subscriber's
+ * own evidence in a refund conversation.
+ */
+export default class SubscriptionsHealth extends BaseCommand {
+    static description: string;
+    static examples: string[];
+    static args: {
+        agentId: 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/subscriptions/health.js

@@ -0,0 +1,62 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const core_1 = require("@oclif/core");
+const data_provider_1 = require("@skrr-ai/data-provider");
+const base_command_1 = require("../../base-command");
+/**
+ * Has this service actually delivered?
+ *
+ * The question every recurring charge has to answer, and the reason a
+ * subscription is modelled as a Commitment rather than a billing schedule.
+ *
+ * `unverified` — the work is done and nobody has looked — is counted as
+ * DELIVERED and reported separately as "waiting on you". It is not a failure:
+ * counting it as one would let a subscriber who stops confirming make a working
+ * service read as broken. It is surfaced anyway, because it is the subscriber's
+ * own evidence in a refund conversation.
+ */
+class SubscriptionsHealth extends base_command_1.BaseCommand {
+    static description = 'Show what a service has actually delivered, and what awaits you';
+    static examples = [
+        '<%= config.bin %> subscriptions health agent_abc123',
+        '<%= config.bin %> subscriptions health agent_abc123 --json',
+    ];
+    static args = {
+        agentId: core_1.Args.string({ description: 'The service to check', required: true }),
+    };
+    static flags = {
+        json: core_1.Flags.boolean({ description: 'Output as JSON' }),
+    };
+    async run() {
+        this.requireAuth();
+        const { args, flags } = await this.parse(SubscriptionsHealth);
+        let response;
+        try {
+            response = await data_provider_1.dataService.getStoreAgentSubscriptionHealth(args.agentId);
+        }
+        catch (err) {
+            this.handleApiError(err);
+        }
+        if (flags.json) {
+            this.log(JSON.stringify(response, null, 2));
+            return;
+        }
+        this.log(response?.summary ?? '');
+        if (!response?.read) {
+            // "We could not look" and "nothing arrived" lead somewhere different, so
+            // they are never printed the same way.
+            return;
+        }
+        this.log('');
+        this.log(`delivered              ${response.delivered} / ${response.tasks}`);
+        this.log(`waiting on you         ${response.awaitingConfirmation}`);
+        this.log(`still owed             ${response.owed}`);
+        this.log(`blocked                ${response.blocked}`);
+        if (response.noContract > 0) {
+            // "Declared nothing" and "contract met" are different things to know
+            // about what you are paying for.
+            this.log(`no stated contract     ${response.noContract}`);
+        }
+    }
+}
+exports.default = SubscriptionsHealth;

package/dist/commands/subscriptions/list.d.ts

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

package/dist/commands/subscriptions/list.js

@@ -0,0 +1,52 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const core_1 = require("@oclif/core");
+const data_provider_1 = require("@skrr-ai/data-provider");
+const base_command_1 = require("../../base-command");
+const format_1 = require("../../lib/format");
+class SubscriptionsList extends base_command_1.BaseCommand {
+    static description = 'List the service subscriptions you hold';
+    static examples = [
+        '<%= config.bin %> subscriptions list',
+        '<%= config.bin %> subscriptions list --json',
+    ];
+    static flags = {
+        json: core_1.Flags.boolean({ description: 'Output as JSON' }),
+    };
+    async run() {
+        this.requireAuth();
+        const { flags } = await this.parse(SubscriptionsList);
+        let response;
+        try {
+            response = await data_provider_1.dataService.getStoreSubscriptions();
+        }
+        catch (err) {
+            this.handleApiError(err);
+        }
+        if (flags.json) {
+            this.log(JSON.stringify(response, null, 2));
+            return;
+        }
+        const items = response?.data ?? [];
+        if (items.length === 0) {
+            this.log('No active subscriptions.');
+            return;
+        }
+        (0, format_1.renderTable)(items.map((s) => ({
+            entitlementId: s.entitlementId,
+            service: s.sourceAgentId,
+            instance: s.instanceAgentId ?? '-',
+            // Who pays for the work is part of what you bought, so it is a column
+            // rather than something you have to ask for with --json.
+            pays: s.billingMode,
+            expires: s.expiresAt ? String(s.expiresAt).slice(0, 10) : 'no end date',
+        })), [
+            { key: 'entitlementId', header: 'ENTITLEMENT' },
+            { key: 'service', header: 'SERVICE' },
+            { key: 'instance', header: 'YOUR INSTANCE' },
+            { key: 'pays', header: 'COMPUTE PAID BY' },
+            { key: 'expires', header: 'EXPIRES' },
+        ], (line) => this.log(line));
+    }
+}
+exports.default = SubscriptionsList;

package/dist/commands/subscriptions/status.d.ts

@@ -0,0 +1,12 @@
+import { BaseCommand } from '../../base-command';
+export default class SubscriptionsStatus extends BaseCommand {
+    static description: string;
+    static examples: string[];
+    static args: {
+        agentId: 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/subscriptions/status.js

@@ -0,0 +1,49 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const core_1 = require("@oclif/core");
+const data_provider_1 = require("@skrr-ai/data-provider");
+const base_command_1 = require("../../base-command");
+class SubscriptionsStatus extends base_command_1.BaseCommand {
+    static description = 'Show whether a service subscription is live, and until when';
+    static examples = [
+        '<%= config.bin %> subscriptions status agent_abc123',
+        '<%= config.bin %> subscriptions status agent_abc123 --json',
+    ];
+    static args = {
+        agentId: core_1.Args.string({ description: 'The service to check', required: true }),
+    };
+    static flags = {
+        json: core_1.Flags.boolean({ description: 'Output as JSON' }),
+    };
+    async run() {
+        this.requireAuth();
+        const { args, flags } = await this.parse(SubscriptionsStatus);
+        let response;
+        try {
+            response = await data_provider_1.dataService.getStoreAgentSubscriptionStatus(args.agentId);
+        }
+        catch (err) {
+            this.handleApiError(err);
+        }
+        if (flags.json) {
+            this.log(JSON.stringify(response, null, 2));
+            return;
+        }
+        if (!response?.subscribed) {
+            // The two reasons want different next actions, so they are printed
+            // differently rather than collapsed into "not subscribed".
+            this.log(response?.reason === 'expired'
+                ? 'Not live — the subscription expired. Renewing resumes it.'
+                : 'Not subscribed.');
+            return;
+        }
+        this.log(`Live. Entitlement ${response.entitlementId} (v${response.version})`);
+        this.log(`Your instance: ${response.instanceAgentId ?? '-'}`);
+        this.log(`Compute paid by: ${response.billingMode}`);
+        this.log(`Expires: ${response.expiresAt ? String(response.expiresAt) : 'no end date'}`);
+        if (response.commitmentId) {
+            this.log(`Obligation: ${response.commitmentId}`);
+        }
+    }
+}
+exports.default = SubscriptionsStatus;

package/dist/commands/subscriptions/subscribe.d.ts

@@ -0,0 +1,15 @@
+import { BaseCommand } from '../../base-command';
+export default class SubscriptionsSubscribe extends BaseCommand {
+    static description: string;
+    static examples: string[];
+    static args: {
+        agentId: import("@oclif/core/lib/interfaces").Arg<string, Record<string, unknown>>;
+    };
+    static flags: {
+        json: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+        'billing-mode': import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
+        'expires-at': import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
+        space: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
+    };
+    run(): Promise<void>;
+}

package/dist/commands/subscriptions/subscribe.js

@@ -0,0 +1,59 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const core_1 = require("@oclif/core");
+const data_provider_1 = require("@skrr-ai/data-provider");
+const base_command_1 = require("../../base-command");
+class SubscriptionsSubscribe extends base_command_1.BaseCommand {
+    static description = 'Subscribe to a published service — installs your own managed instance and opens the obligation it is delivered through';
+    static examples = [
+        '<%= config.bin %> subscriptions subscribe agent_abc123',
+        '<%= config.bin %> subscriptions subscribe agent_abc123 --billing-mode per-user',
+        '<%= config.bin %> subscriptions subscribe agent_abc123 --space space_xyz --json',
+    ];
+    static args = {
+        agentId: core_1.Args.string({ description: 'The published service to subscribe to', required: true }),
+    };
+    static flags = {
+        json: core_1.Flags.boolean({ description: 'Output as JSON' }),
+        'billing-mode': core_1.Flags.string({
+            description: 'Who pays for the inference this service consumes',
+            options: ['owner', 'per-user', 'shared'],
+        }),
+        'expires-at': core_1.Flags.string({ description: 'Paid-through date (ISO 8601)' }),
+        space: core_1.Flags.string({ description: 'Space the service should work in' }),
+    };
+    async run() {
+        this.requireAuth();
+        const { args, flags } = await this.parse(SubscriptionsSubscribe);
+        let response;
+        try {
+            response = await data_provider_1.dataService.subscribeToStoreAgent(args.agentId, {
+                ...(flags['billing-mode']
+                    ? { billingMode: flags['billing-mode'] }
+                    : {}),
+                ...(flags['expires-at'] ? { expiresAt: flags['expires-at'] } : {}),
+                ...(flags.space ? { spaceId: flags.space } : {}),
+            });
+        }
+        catch (err) {
+            this.handleApiError(err);
+        }
+        if (flags.json) {
+            this.log(JSON.stringify(response, null, 2));
+            return;
+        }
+        this.log(`Subscribed. Entitlement ${response?.entitlementId}`);
+        this.log(`Your instance: ${response?.instanceAgentId ?? '-'}`);
+        this.log(`Compute paid by: ${response?.billingMode}`);
+        if (response?.commitmentId) {
+            // The commitment is the thing you can hold the service to — surface it,
+            // because "is it working" is answered there and nowhere else.
+            this.log(`Obligation: ${response.commitmentId}`);
+        }
+        if (response?.degraded === 'commitment_pending') {
+            this.log('');
+            this.log('Note: the subscription is live but its obligation has not been created yet. It is resumable and refundable; retry to finish opening it.');
+        }
+    }
+}
+exports.default = SubscriptionsSubscribe;