@skrr-ai/cli 0.1.60 → 0.1.62

package/dist/lib/store-acquisition.js

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.describeAcquisitionRequestLines = describeAcquisitionRequestLines;
+const data_provider_1 = require("@skrr-ai/data-provider");
+/**
+ * A purchase an agent asked to make, as the lines a terminal shows (OSK-12240).
+ *
+ * The same server copy the web approval card renders: every field comes from
+ * `GET /api/store/acquisition-requests/:id`, which the fulfillment path built
+ * from the listing it resolved. Nothing the requesting agent wrote reaches
+ * these lines. The words themselves come from `@skrr-ai/data-provider`, so the
+ * terminal and the card cannot describe one request two ways.
+ */
+function describeAcquisitionRequestLines(request) {
+    const name = request.listingName || request.entityId;
+    const version = request.versionLabel ? ` v${request.versionLabel}` : '';
+    const kind = request.entityType === 'skill' ? 'skill' : 'agent';
+    const status = (0, data_provider_1.describeStoreAcquisitionStatus)(request.status);
+    const lines = [
+        `${name}${version} (a paid ${kind})`,
+        `  Status:       ${status.label}${status.detail ? ` — ${status.detail}` : ''}`,
+        `  Price:        ${(0, data_provider_1.formatStoreAcquisitionPrice)(request.price)} ${request.currency}`,
+        `  Refunds:      ${(0, data_provider_1.describeStoreAcquisitionRefundTerms)(request.refundTerms)}`,
+        `  Buyer terms:  ${request.buyerTerms
+            ? `${request.buyerTerms.termsVersion} — ${request.buyerTerms.artifactUri}`
+            : 'not configured, so this purchase cannot be approved'}`,
+        `  Offer:        ${request.offerVersionId}`,
+        `  Capabilities: ${(0, data_provider_1.describeStoreAcquisitionCapabilities)(request.capabilities, request.capabilityCount)}`,
+    ];
+    if (request.requestedByAgentId) {
+        lines.push(`  Asked by:     agent ${request.requestedByAgentId}`);
+    }
+    if (request.entityType === 'skill' && request.targetId) {
+        lines.push(`  Installs on:  agent ${request.targetId}`);
+    }
+    if (request.expiresAt) {
+        lines.push(`  Expires:      ${request.expiresAt}`);
+    }
+    return lines;
+}

package/dist/lib/store-advisories.d.ts

@@ -0,0 +1,50 @@
+import type { StoreReleaseAdvisory, StoreReleaseAdvisoryCloseAction, StoreReleaseAdvisoryRemedy } from '@skrr-ai/data-provider';
+/**
+ * `/api/store/.../advisories` — a Store curator's recall of one published
+ * release (OSK-12253).
+ *
+ * Only the `store_curation` surface (the TRUST role) may use any of these; the
+ * server refuses everyone else, a workspace owner or admin included. Issuing
+ * takes one curator. Ending an advisory takes two different ones: `close`
+ * records the first curator's request to lift or retract it, and `confirm` —
+ * which the server refuses for that same curator — ends it.
+ *
+ * Every route is written out at its own call site rather than composed from a
+ * builder, like the rest of the Store CLI: the parity checker reads the
+ * LITERAL at the call site.
+ */
+export type StoreReleaseAdvisoryResult = {
+    advisory: StoreReleaseAdvisory;
+    replayed: boolean;
+};
+/** `GET /agents/:id/releases/:releaseId/advisories` */
+export declare function listStoreReleaseAdvisories(agentId: string, releaseId: string, status?: string): Promise<{
+    advisories: StoreReleaseAdvisory[];
+}>;
+/** `POST /agents/:id/releases/:releaseId/advisories` — issue one. */
+export declare function issueStoreReleaseAdvisory(agentId: string, releaseId: string, body: {
+    remedy: StoreReleaseAdvisoryRemedy;
+    summary: string;
+    evidenceRefs?: string[];
+}): Promise<StoreReleaseAdvisoryResult>;
+/** `GET /advisories/:advisoryId` */
+export declare function getStoreReleaseAdvisory(advisoryId: string): Promise<{
+    advisory: StoreReleaseAdvisory;
+}>;
+/** `POST /advisories/:advisoryId/close-request` — the first of two curators. */
+export declare function requestStoreReleaseAdvisoryClose(advisoryId: string, body: {
+    action: StoreReleaseAdvisoryCloseAction;
+    note: string;
+}): Promise<StoreReleaseAdvisoryResult>;
+/** `POST /advisories/:advisoryId/close-request/confirm` — the second curator. */
+export declare function confirmStoreReleaseAdvisoryClose(advisoryId: string, body: {
+    note: string;
+}): Promise<StoreReleaseAdvisoryResult>;
+/** `DELETE /advisories/:advisoryId/close-request` — keep the recall in force. */
+export declare function cancelStoreReleaseAdvisoryClose(advisoryId: string): Promise<StoreReleaseAdvisoryResult>;
+/**
+ * An advisory as a few lines a curator can read: what it does, whether it is
+ * still in force, and — when an ending is waiting — who asked, so the second
+ * curator can see it is not them.
+ */
+export declare function describeStoreReleaseAdvisoryLines(advisory: StoreReleaseAdvisory): string[];

package/dist/lib/store-advisories.js

@@ -0,0 +1,62 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.listStoreReleaseAdvisories = listStoreReleaseAdvisories;
+exports.issueStoreReleaseAdvisory = issueStoreReleaseAdvisory;
+exports.getStoreReleaseAdvisory = getStoreReleaseAdvisory;
+exports.requestStoreReleaseAdvisoryClose = requestStoreReleaseAdvisoryClose;
+exports.confirmStoreReleaseAdvisoryClose = confirmStoreReleaseAdvisoryClose;
+exports.cancelStoreReleaseAdvisoryClose = cancelStoreReleaseAdvisoryClose;
+exports.describeStoreReleaseAdvisoryLines = describeStoreReleaseAdvisoryLines;
+const data_provider_1 = require("@skrr-ai/data-provider");
+const api_fetch_1 = require("./api-fetch");
+const triggers_1 = require("./triggers");
+/** `GET /agents/:id/releases/:releaseId/advisories` */
+async function listStoreReleaseAdvisories(agentId, releaseId, status) {
+    return (0, api_fetch_1.apiFetch)((0, triggers_1.withQuery)(`/api/store/agents/${encodeURIComponent(agentId)}/releases/${encodeURIComponent(releaseId)}/advisories`, { status }));
+}
+/** `POST /agents/:id/releases/:releaseId/advisories` — issue one. */
+async function issueStoreReleaseAdvisory(agentId, releaseId, body) {
+    return (0, api_fetch_1.apiFetch)(`/api/store/agents/${encodeURIComponent(agentId)}/releases/${encodeURIComponent(releaseId)}/advisories`, { method: 'POST', body });
+}
+/** `GET /advisories/:advisoryId` */
+async function getStoreReleaseAdvisory(advisoryId) {
+    return (0, api_fetch_1.apiFetch)(`/api/store/advisories/${encodeURIComponent(advisoryId)}`);
+}
+/** `POST /advisories/:advisoryId/close-request` — the first of two curators. */
+async function requestStoreReleaseAdvisoryClose(advisoryId, body) {
+    return (0, api_fetch_1.apiFetch)(`/api/store/advisories/${encodeURIComponent(advisoryId)}/close-request`, { method: 'POST', body });
+}
+/** `POST /advisories/:advisoryId/close-request/confirm` — the second curator. */
+async function confirmStoreReleaseAdvisoryClose(advisoryId, body) {
+    return (0, api_fetch_1.apiFetch)(`/api/store/advisories/${encodeURIComponent(advisoryId)}/close-request/confirm`, { method: 'POST', body });
+}
+/** `DELETE /advisories/:advisoryId/close-request` — keep the recall in force. */
+async function cancelStoreReleaseAdvisoryClose(advisoryId) {
+    return (0, api_fetch_1.apiFetch)(`/api/store/advisories/${encodeURIComponent(advisoryId)}/close-request`, { method: 'DELETE' });
+}
+/**
+ * An advisory as a few lines a curator can read: what it does, whether it is
+ * still in force, and — when an ending is waiting — who asked, so the second
+ * curator can see it is not them.
+ */
+function describeStoreReleaseAdvisoryLines(advisory) {
+    const remedy = (0, data_provider_1.describeStoreReleaseAdvisoryRemedy)(advisory.remedy);
+    const status = (0, data_provider_1.describeStoreReleaseAdvisoryStatus)(advisory.status);
+    const release = advisory.versionLabel
+        ? `v${advisory.versionLabel} (${advisory.releaseId})`
+        : advisory.releaseId;
+    const lines = [
+        `${advisory.advisoryId}  ${remedy.label} · ${status.label}`,
+        `  release   ${release} of ${advisory.agentId}`,
+        `  summary   ${advisory.summary}`,
+        `  effect    ${remedy.detail}`,
+        `  issued    ${advisory.issuedAt ?? '-'} by ${advisory.issuedBy}`,
+    ];
+    if (advisory.closeRequest) {
+        lines.push(`  waiting   ${advisory.closeRequest.action} requested by ${advisory.closeRequest.requestedBy} — a different curator must confirm`);
+    }
+    if (advisory.closure) {
+        lines.push(`  ended     ${advisory.closure.action} by ${advisory.closure.requestedBy}, confirmed by ${advisory.closure.confirmedBy} at ${advisory.closure.confirmedAt ?? '-'}`);
+    }
+    return lines;
+}

package/dist/lib/task-closure.js

@@ -100,7 +100,7 @@ function closureReport(closure) {
     lines.push('');
     lines.push(reviewRequired
         ? 'Only an accepted independent Review — or the Task owner closing directly — settles this. The rest is recorded on resolution.closure.'
-        : 'Closing anyway is allowed — all of this is recorded on resolution.closure.');
+        : 'If this Task is closed anyway, all of the above is recorded on resolution.closure — closing over it settles nothing.');
     return lines;
 }
 /**

package/dist/lib/web-url.d.ts

@@ -17,6 +17,14 @@
  */
 export type WebUrlRef = {
     kind: 'billing';
+} | {
+    kind: 'machine';
+    machineId: string;
+} | {
+    kind: 'harness';
+    harnessId: string;
+} | {
+    kind: 'managedExecution';
 } | {
     kind: 'task';
     taskId: string;
@@ -75,6 +83,9 @@ export type WebUrlRef = {
     kind: 'wikiPage';
     spaceId: string;
     pageId: string;
+} | {
+    kind: 'spaceTemplate';
+    templateId: string;
 };
 /**
  * Site-relative canonical path for an entity, or `null` when the required id is

package/dist/lib/web-url.js

@@ -53,6 +53,16 @@ function webPath(ref) {
     switch (ref.kind) {
         case 'billing':
             return '/d/settings/balance';
+        case 'machine': {
+            const machineId = encodeId(ref.machineId);
+            return machineId ? `/machines/${machineId}` : null;
+        }
+        case 'harness': {
+            const harnessId = encodeId(ref.harnessId);
+            return harnessId ? `/harnesses/${harnessId}` : null;
+        }
+        case 'managedExecution':
+            return '/managed-execution';
         case 'task': {
             const taskId = encodeId(ref.taskId);
             if (!taskId)
@@ -112,6 +122,10 @@ function webPath(ref) {
             const pageId = encodeId(ref.pageId);
             return spaceId && pageId ? `/spaces/${spaceId}/wiki?page=${pageId}` : null;
         }
+        case 'spaceTemplate': {
+            const templateId = encodeId(ref.templateId);
+            return templateId ? `/store/services/${templateId}` : null;
+        }
         case 'workflow': {
             const spaceId = encodeId(ref.spaceId);
             if (!spaceId)