@skrr-ai/cli 0.1.60 → 0.1.62

package/dist/commands/store/update.js

@@ -3,12 +3,15 @@ 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 http_error_1 = require("../../lib/http-error");
 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',
+        '<%= config.bin %> store update agent_abc123 --accept-capabilities',
+        '<%= config.bin %> store update agent_abc123 --decline',
     ];
     static args = {
         agentId: core_1.Args.string({
@@ -25,10 +28,33 @@ class StoreUpdate extends base_command_1.BaseCommand {
             description: 'merge (default) keeps your edits and refuses on a conflict; replace takes the publisher version',
             options: ['merge', 'replace'],
         }),
+        'accept-capabilities': core_1.Flags.boolean({
+            description: 'Consent to the new powers a pending "capability_widened" update grants your copy',
+        }),
+        decline: core_1.Flags.boolean({
+            description: 'Decline the waiting update and clear the reminder; your copy stays as it is',
+        }),
     };
     async run() {
         this.requireAuth();
         const { args, flags } = await this.parse(StoreUpdate);
+        // A status read first: what this command would move, and whether anything
+        // already waits on it. It doubles as the friendly refusal for a listing
+        // that was never installed.
+        let status;
+        try {
+            status = await data_provider_1.dataService.getAgentPurchaseStatus(args.agentId);
+        }
+        catch (err) {
+            this.handleApiError(err);
+        }
+        if (!status?.purchased) {
+            this.error(`${args.agentId} is not installed from the Store. Install it first: skrr store install ${args.agentId}`, { exit: 1 });
+        }
+        if (status.pendingUpdate && !flags.decline) {
+            this.log(`A ${status.pendingUpdate.versionLabel ?? 'new'} release is waiting for review ` +
+                `(${status.pendingUpdate.reason}).`);
+        }
         let response;
         try {
             response = await data_provider_1.dataService.updateInstalledStoreAgent({
@@ -36,13 +62,41 @@ class StoreUpdate extends base_command_1.BaseCommand {
                 ...(flags.installed ? { installedAgentId: flags.installed } : {}),
                 ...(flags.release ? { targetReleaseId: flags.release } : {}),
                 ...(flags.strategy ? { strategy: flags.strategy } : {}),
+                ...(flags['accept-capabilities'] ? { acceptCapabilities: true } : {}),
+                ...(flags.decline ? { decline: true } : {}),
             });
         }
         catch (err) {
+            // Read the refusal the way every transport carries it: the node adapter
+            // hands back the body as TEXT, so reading `err.body` as an object never
+            // saw a code at all and both answers below fell through to a bare error.
+            const body = (0, http_error_1.httpBodyOf)(err);
+            // Not an update: a new major is a separate purchase. Say which version
+            // keeps its free updates, and offer no command — none sells a second
+            // major of a listing yet, and `store install` refuses one you own.
+            if (body?.code === 'MAJOR_UPDATE_REQUIRES_PURCHASE') {
+                this.log(body.error ?? 'A new major version is a separate purchase.');
+                this.log(body.installedVersionLabel
+                    ? `You own ${body.installedVersionLabel}, and it keeps getting free updates within its major.`
+                    : 'The version you own keeps getting free updates within its major.');
+                this.error('Update not applied.', { exit: 1 });
+            }
+            // 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.
+            // A widened capability set is a consent question (OSK-12257): name what
+            // the release adds, and the two answers — grant it, or decline the update.
+            if (body?.code === 'UPDATE_CAPABILITY_WIDENED') {
+                this.log(body.error ?? 'This update grants your copy new powers.');
+                for (const row of body.capabilities ?? []) {
+                    this.log(`  ${row.field}: ${row.added.join(', ')}`);
+                }
+                this.log('');
+                this.log(`Accept:  skrr store update ${args.agentId} --accept-capabilities`);
+                this.log(`Decline: skrr store update ${args.agentId} --decline`);
+                this.error('Update not applied.', { exit: 1 });
+            }
             // 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) {
@@ -58,6 +112,10 @@ class StoreUpdate extends base_command_1.BaseCommand {
             this.log(JSON.stringify(response, null, 2));
             return;
         }
+        if (response?.declined) {
+            this.log('Update declined. Your copy stays on the version it runs.');
+            return;
+        }
         const merge = response
             ?.merge;
         this.log(`Updated to ${response?.targetVersionLabel ?? response?.targetReleaseId ?? ''}.`);

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

@@ -2,17 +2,23 @@ import { BaseCommand } from '../../base-command';
 /**
  * What is waiting on you across everything you installed.
  *
+ * Reads `GET /api/store/installs` — the one read model the web Installed page
+ * shows too (OSK-12287). It used to loop `purchased` × `purchase-status`, so
+ * every row was a second request and a stopped copy arrived as "unreadable".
+ * Now the server answers every install with its own waiting state.
+ *
  * 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
+ *            both changed the same field, the release widened capabilities, or
+ *            the version your copy came from is unknown
  *   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.
+ * Plus two row states that are not updates at all: `stopped` (a quarantined,
+ * revoked or uninstalled copy — its reason, not silence) and `advisory`
+ * (an active security advisory on a release you run).
  */
 export default class StoreUpdates extends BaseCommand {
     static description: string;

package/dist/commands/store/updates.js

@@ -7,17 +7,23 @@ const format_1 = require("../../lib/format");
 /**
  * What is waiting on you across everything you installed.
  *
+ * Reads `GET /api/store/installs` — the one read model the web Installed page
+ * shows too (OSK-12287). It used to loop `purchased` × `purchase-status`, so
+ * every row was a second request and a stopped copy arrived as "unreadable".
+ * Now the server answers every install with its own waiting state.
+ *
  * 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
+ *            both changed the same field, the release widened capabilities, or
+ *            the version your copy came from is unknown
  *   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.
+ * Plus two row states that are not updates at all: `stopped` (a quarantined,
+ * revoked or uninstalled copy — its reason, not silence) and `advisory`
+ * (an active security advisory on a release you run).
  */
 class StoreUpdates extends base_command_1.BaseCommand {
     static description = 'Show what is waiting across the agents you installed';
@@ -31,63 +37,74 @@ class StoreUpdates extends base_command_1.BaseCommand {
     async run() {
         this.requireAuth();
         const { flags } = await this.parse(StoreUpdates);
-        let purchased;
+        let installs;
         try {
-            purchased = await data_provider_1.dataService.getPurchasedAgents();
+            installs = await data_provider_1.dataService.getStoreInstalls();
         }
         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) {
+        for (const install of installs?.installs ?? []) {
+            const have = install.installedVersionLabel ?? '-';
+            const update = install.update;
+            if (update?.state === 'review') {
+                const pending = install.pendingUpdate;
                 rows.push({
-                    agent: agentId,
+                    agent: install.agentId,
                     state: 'review',
+                    channel: install.updatePolicy ?? 'manual',
                     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',
+                    waiting: update.versionLabel ?? '-',
+                    detail: pending?.reason === 'conflict'
+                        ? `you both changed ${(pending.conflicts ?? []).join(', ') || 'a field'}`
+                        : pending?.reason === 'capability_widened'
+                            ? `adds capabilities: ${(pending.capabilities ?? [])
+                                .map((row) => `${row.field} (${row.added.join(', ')})`)
+                                .join('; ') || 'new powers'}`
+                            : 'the version your copy came from is unknown',
                 });
             }
-            if (status.availableMajor) {
+            if (update?.state === 'buy') {
                 rows.push({
-                    agent: agentId,
+                    agent: install.agentId,
                     state: 'buy',
+                    channel: install.updatePolicy ?? 'manual',
                     have,
-                    waiting: status.availableMajor.versionLabel ?? '-',
+                    waiting: update.versionLabel ?? '-',
                     detail: 'a new major is a separate purchase',
                 });
             }
-            if (!status.pendingUpdate && status.updateAvailable && status.updateKind === 'minor') {
+            if (update?.state === 'ready') {
                 rows.push({
-                    agent: agentId,
+                    agent: install.agentId,
                     state: 'ready',
+                    channel: install.updatePolicy ?? 'manual',
                     have,
-                    waiting: status.latestVersionLabel ?? '-',
+                    waiting: update.versionLabel ?? '-',
                     detail: 'applies cleanly',
                 });
             }
+            if (install.stopReason) {
+                rows.push({
+                    agent: install.agentId,
+                    state: 'stopped',
+                    channel: install.updatePolicy ?? 'manual',
+                    have,
+                    waiting: '-',
+                    detail: install.stopReason,
+                });
+            }
+            if (install.advisory) {
+                rows.push({
+                    agent: install.agentId,
+                    state: 'advisory',
+                    channel: install.updatePolicy ?? 'manual',
+                    have,
+                    waiting: '-',
+                    detail: install.advisory.summary ?? 'security advisory on this release',
+                });
+            }
         }
         if (flags.json) {
             this.log(JSON.stringify({ object: 'list', data: rows }, null, 2));
@@ -107,7 +124,11 @@ class StoreUpdates extends base_command_1.BaseCommand {
         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>');
+        this.log('widened → skrr store update <agent> --accept-capabilities   (or --decline to keep yours)');
+        // No command: `store install` refuses a listing you already own, and
+        // `store update` refuses a new major (§11 D2/D13). Naming either here sent
+        // a buyer to a refusal.
+        this.log('buy    → a separate purchase; not yet on sale to owners of an earlier major');
     }
 }
 exports.default = StoreUpdates;

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

@@ -0,0 +1,18 @@
+import { BaseCommand } from '../../base-command';
+/**
+ * Watch a store listing (OSK-12309): the one relation that delivers —
+ * every public release that lands pings the watcher. Star and Follow are
+ * separate intent signals; neither sends anything.
+ */
+export default class StoreWatch extends BaseCommand {
+    static description: string;
+    static examples: string[];
+    static args: {
+        agentId: import("@oclif/core/lib/interfaces").Arg<string, Record<string, unknown>>;
+    };
+    static flags: {
+        undo: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+        json: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+    };
+    run(): Promise<void>;
+}

package/dist/commands/store/watch.js

@@ -0,0 +1,44 @@
+"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");
+/**
+ * Watch a store listing (OSK-12309): the one relation that delivers —
+ * every public release that lands pings the watcher. Star and Follow are
+ * separate intent signals; neither sends anything.
+ */
+class StoreWatch extends base_command_1.BaseCommand {
+    static description = 'Get a notification when a store agent publishes a release — or stop watching with --undo';
+    static examples = [
+        '<%= config.bin %> store watch agent_abc123',
+        '<%= config.bin %> store watch agent_abc123 --undo',
+    ];
+    static args = {
+        agentId: core_1.Args.string({ description: 'The store agent id', required: true, ignoreStdin: true }),
+    };
+    static flags = {
+        undo: core_1.Flags.boolean({ description: 'Stop watching this listing' }),
+        json: core_1.Flags.boolean({ description: 'Output as JSON' }),
+    };
+    async run() {
+        this.requireAuth();
+        const { args, flags } = await this.parse(StoreWatch);
+        try {
+            const result = flags.undo
+                ? await data_provider_1.dataService.unwatchStoreListing(args.agentId)
+                : await data_provider_1.dataService.watchStoreListing(args.agentId);
+            if (flags.json) {
+                this.log(JSON.stringify(result, null, 2));
+                return;
+            }
+            this.log(flags.undo
+                ? 'Not watching this listing.'
+                : 'Watching — a release publishes, you hear about it.');
+        }
+        catch (err) {
+            this.handleApiError(err);
+        }
+    }
+}
+exports.default = StoreWatch;

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

@@ -1,3 +1,4 @@
+import type { StoreSubscriptionObligations } from '@skrr-ai/data-provider';
 import { BaseCommand } from '../../base-command';
 /**
  * Has this service actually delivered?
@@ -22,3 +23,14 @@ export default class SubscriptionsHealth extends BaseCommand {
     };
     run(): Promise<void>;
 }
+/**
+ * What the service owes, as bought. Four answers that must never print alike:
+ * the list itself; a service that declared nothing; a subscription whose
+ * Commitment does not exist yet, so nothing holds the service to what was
+ * bought (NOT "declared nothing" — the release may declare plenty); and a
+ * contract that could not be read. `undefined` is an older server that does not
+ * report it, so nothing is said.
+ *
+ * Exported for tests.
+ */
+export declare function obligationLines(obligations: StoreSubscriptionObligations | undefined): string[];

package/dist/commands/subscriptions/health.js

@@ -1,5 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.obligationLines = obligationLines;
 const core_1 = require("@oclif/core");
 const data_provider_1 = require("@skrr-ai/data-provider");
 const base_command_1 = require("../../base-command");
@@ -54,6 +55,11 @@ class SubscriptionsHealth extends base_command_1.BaseCommand {
         this.log('');
         this.log(`delivered              ${response.delivered} / ${response.tasks}`);
         this.log(`waiting on you         ${response.awaitingConfirmation}`);
+        // A delivery somebody assessed as not delivered (the subscriber, or the
+        // service's own agent reporting it could not deliver or verify) — never
+        // folded into "owed", which means nobody has done it yet. An older server
+        // does not send it.
+        this.log(`judged not delivered   ${response.unmet ?? 0}`);
         this.log(`still owed             ${response.owed}`);
         this.log(`blocked                ${response.blocked}`);
         if (response.noContract > 0) {
@@ -61,6 +67,39 @@ class SubscriptionsHealth extends base_command_1.BaseCommand {
             // about what you are paying for.
             this.log(`no stated contract     ${response.noContract}`);
         }
+        for (const line of obligationLines(response.obligations))
+            this.log(line);
     }
 }
 exports.default = SubscriptionsHealth;
+/**
+ * What the service owes, as bought. Four answers that must never print alike:
+ * the list itself; a service that declared nothing; a subscription whose
+ * Commitment does not exist yet, so nothing holds the service to what was
+ * bought (NOT "declared nothing" — the release may declare plenty); and a
+ * contract that could not be read. `undefined` is an older server that does not
+ * report it, so nothing is said.
+ *
+ * Exported for tests.
+ */
+function obligationLines(obligations) {
+    if (!obligations)
+        return [];
+    if (obligations.state === 'unreadable') {
+        return ['', 'What it owes you: could not be read right now.'];
+    }
+    if (obligations.state === 'not_recorded') {
+        return [
+            '',
+            'What it owes you: not recorded on your subscription yet. It has not started work, so nothing holds the service to the obligations you bought.',
+        ];
+    }
+    if (obligations.rows.length === 0) {
+        return ['', 'What it owes you: this service declared no delivery obligations.'];
+    }
+    return [
+        '',
+        'What it owes you, on each delivery:',
+        ...obligations.rows.map((row) => `  - ${row.text}`),
+    ];
+}

package/dist/commands/subscriptions/list.js

@@ -37,8 +37,9 @@ class SubscriptionsList extends base_command_1.BaseCommand {
             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,
+            // rather than something you have to ask for with --json. It is who is
+            // actually CHARGED (the server's resolver), not the declared mode.
+            pays: s.computePayer?.label ?? 'unknown',
             expires: s.expiresAt ? String(s.expiresAt).slice(0, 10) : 'no end date',
         })), [
             { key: 'entitlementId', header: 'ENTITLEMENT' },

package/dist/commands/subscriptions/status.js

@@ -43,8 +43,14 @@ class SubscriptionsStatus extends base_command_1.BaseCommand {
         }
         this.log(`Live. Entitlement ${response.entitlementId} (v${response.version})`);
         this.log(`Your instance: ${response.instanceAgentId ?? '-'}`);
-        this.log(`Compute paid by: ${response.billingMode}`);
+        this.log(`Compute paid by: ${(0, data_provider_1.describeStoreComputePayer)(response.computePayer)}`);
         this.log(`Expires: ${response.expiresAt ? String(response.expiresAt) : 'no end date'}`);
+        // The same line the web card shows: whose turn it is when a period could
+        // not be charged. Only a balance that could not pay is told to top up.
+        this.log(`Billing: ${(0, data_provider_1.describeStoreServiceBilling)(response).text}`);
+        if (response.billingIssueCode) {
+            this.log(`Last charge failed with: ${response.billingIssueCode}`);
+        }
         if (response.commitmentId) {
             this.log(`Obligation: ${response.commitmentId}`);
         }

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

@@ -7,9 +7,16 @@ export default class SubscriptionsSubscribe extends BaseCommand {
     };
     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>;
+        grant: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
+        trial: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+        yes: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
     };
     run(): Promise<void>;
+    /**
+     * The card-free trial path (OSK-12281). The trial's own terms — days, the
+     * platform compute budget — come from the quote's `trial` block the server
+     * computed for this caller, so what is printed is what the write will do.
+     */
+    private startTrial;
 }