@skrr-ai/cli 0.1.38 → 0.1.39

package/bin/dev-fallback.js

@@ -245,6 +245,14 @@ function findAlternateCli({
 function missingLocalCommandBuild({ cliRoot, argv, fileSystem = fs, verifySourceIdentity = true }) {
   const commandsDirectory = path.join(cliRoot, 'dist', 'commands');
   const sourceCommandsDirectory = path.join(cliRoot, 'src', 'commands');
+  // Staleness is a relation between a build and its SOURCE, so a CLI without
+  // source — every installed npm package, which ships `dist` and no `src` — has
+  // nothing to be stale against. Every check below is a development-checkout
+  // guard. Only the per-command one happened to notice: it looks a source file
+  // up first. The `--version` branch did not, read the missing source-digest
+  // manifest as a missing build, and made an installed 0.1.38 report whatever
+  // other `skrr` was on the PATH, or fail (OSK-9883).
+  if (!fileSystem.existsSync(sourceCommandsDirectory)) return null;
   let commandBuildManifest;
   try {
     commandBuildManifest = JSON.parse(

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

@@ -72,11 +72,15 @@ class DedicatedMachinesCreate extends dedicated_lease_command_1.DedicatedLeaseCo
         if (flags.repository !== undefined && !(0, dedicated_machines_1.isDedicatedRepositoryRef)(flags.repository)) {
             this.error(`--repository must look like owner/repo, got "${flags.repository}".`, { exit: 2 });
         }
+        // The server trims the preset, so ' standard' buys a standard machine; the
+        // preview must judge the same value, or it calls a size it is about to buy
+        // "not in the catalog" and then buys it anyway (OSK-9592).
+        const sizePreset = flags['size-preset'].trim();
         const requestId = flags['request-id'] || newRequestId();
         const body = (0, dedicated_machines_1.dedicatedRuntimeCreateInput)({
             requestId,
             displayName: flags.name,
-            sizePreset: flags['size-preset'],
+            sizePreset,
             monthlySpendingLimitCents: flags['spending-limit-cents'],
             regionClass: flags['region-class'],
             storageGb: flags['storage-gb'],
@@ -93,7 +97,7 @@ class DedicatedMachinesCreate extends dedicated_lease_command_1.DedicatedLeaseCo
             const catalog = await this.readCatalogForSummary();
             const summary = (0, dedicated_machines_1.dedicatedCreateSummary)(catalog, {
                 name: flags.name,
-                sizePreset: flags['size-preset'],
+                sizePreset,
                 storageGb: flags['storage-gb'],
                 retentionClass: flags['retention-class'],
                 spendingLimitCents: flags['spending-limit-cents'],

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

@@ -73,16 +73,16 @@ class DedicatedMachinesDestroy extends dedicated_lease_command_1.DedicatedLeaseC
         else if (flags['retain-storage'])
             retentionIntent = 'retain';
         const response = await this.callDedicated(() => (0, dedicated_machines_1.destroyDedicatedRuntime)(leaseId, { ...this.scopeFrom(flags), retentionIntent }));
-        await this.reportLeaseAction(response, flags, { kind: 'destroyed' }, 'Destroying');
-        if (!flags.json) {
-            const note = (0, dedicated_machines_1.dedicatedDestroyRetentionNote)(prior, {
-                purge: Boolean(flags['purge-storage']),
-                retain: Boolean(flags['retain-storage']),
-                bin: this.config.bin,
-            });
-            if (note)
-                this.log(note);
-        }
+        const note = (0, dedicated_machines_1.dedicatedDestroyRetentionNote)(prior, {
+            purge: Boolean(flags['purge-storage']),
+            retain: Boolean(flags['retain-storage']),
+            bin: this.config.bin,
+        });
+        // A script reading --json is exactly the caller that never sees a printed
+        // line, so the kept-and-billing fact rides in the document too (OSK-9593).
+        await this.reportLeaseAction(response, flags, { kind: 'destroyed' }, 'Destroying', note ? { storageNote: note } : {});
+        if (!flags.json && note)
+            this.log(note);
     }
 }
 exports.default = DedicatedMachinesDestroy;

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

@@ -55,6 +55,8 @@ class DedicatedMachinesExec extends base_command_1.BaseCommand {
     // What a script depends on, in the help a script author reads (OSK-8703).
     static description = [
         'Runs the command once, as the workload user, in /workspace or --cwd, through a shell with no TTY. ' +
+            'The workload user can read /workspace but writes only under user-data/ (its HOME) and repos/, so a ' +
+            'command that writes to its starting directory needs --cwd user-data or a path under one of those. ' +
             'Give it after -- as words (each one quoted for you), or as one shell string with --command; not both. ' +
             'The agent shell policy does not apply. A start whose answer is lost is followed up under the same ' +
             'request id, never run a second time.',
@@ -95,7 +97,7 @@ class DedicatedMachinesExec extends base_command_1.BaseCommand {
             description: 'Command to run as one shell string, instead of the words after --',
         }),
         cwd: core_1.Flags.string({
-            description: 'Working directory, relative to /workspace (for example repos/app)',
+            description: 'Working directory, relative to /workspace (for example repos/app or user-data). /workspace itself is not writable by the workload user.',
         }),
         timeout: core_1.Flags.string({
             description: `How long to let it run, such as 30s or 5m (default 2m, max ${dedicated_machines_1.DEDICATED_EXEC_MAX_TIMEOUT_MS / 60000}m). The process group is killed at the deadline.`,

package/dist/commands/machines/dedicated/price-book.d.ts

@@ -0,0 +1,17 @@
+import { DedicatedLeaseCommand } from '../../../lib/dedicated-lease-command';
+/**
+ * `skrr machines dedicated price-book` — the operator's answer to "under what
+ * policy, and at what margin, is each tier sold".
+ *
+ * `catalog` is the customer view: prices and the book version, never a cost or
+ * a policy. This is admin-only on the server, because costs and margins are not
+ * customer facts.
+ */
+export default class DedicatedMachinesPriceBook 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/price-book.js

@@ -0,0 +1,35 @@
+"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");
+/**
+ * `skrr machines dedicated price-book` — the operator's answer to "under what
+ * policy, and at what margin, is each tier sold".
+ *
+ * `catalog` is the customer view: prices and the book version, never a cost or
+ * a policy. This is admin-only on the server, because costs and margins are not
+ * customer facts.
+ */
+class DedicatedMachinesPriceBook extends dedicated_lease_command_1.DedicatedLeaseCommand {
+    static description = 'Show the Dedicated Runtime price book an operator audits: version, pricing policy, and each tier rate, cost and margin (admin only)';
+    static examples = [
+        '<%= config.bin %> machines dedicated price-book',
+        '<%= config.bin %> machines dedicated price-book --json',
+    ];
+    static flags = {
+        json: core_1.Flags.boolean({ description: 'Output as JSON' }),
+    };
+    async run() {
+        this.requireAuth();
+        const { flags } = await this.parse(DedicatedMachinesPriceBook);
+        const read = await this.callDedicated(() => (0, dedicated_machines_1.getDedicatedOperatorPriceBook)());
+        if (flags.json) {
+            this.log(JSON.stringify(read, null, 2));
+            return;
+        }
+        for (const line of (0, dedicated_machines_1.dedicatedOperatorPriceBookLines)(read))
+            this.log(line);
+    }
+}
+exports.default = DedicatedMachinesPriceBook;

package/dist/lib/dedicated-lease-command.d.ts

@@ -61,7 +61,9 @@ export declare abstract class DedicatedLeaseCommand extends BaseCommand {
         timeout?: string;
         interval?: number;
         workspace?: string;
-    }, goal: DedicatedWaitGoal | null, verb: string): Promise<void>;
+    }, goal: DedicatedWaitGoal | null, verb: string, 
+    /** Fields a `--json` caller needs that the server response does not carry. */
+    jsonExtra?: Record<string, unknown>): Promise<void>;
 }
 /** The same transient verdict BaseCommand gives an ordinary API call. */
 export declare function dedicatedRuntimeApiErrorRetryable(err: unknown): boolean;

package/dist/lib/dedicated-lease-command.js

@@ -145,7 +145,9 @@ class DedicatedLeaseCommand extends base_command_1.BaseCommand {
      * Print the lease an action returned, or wait for its operation to finish
      * first when `--wait` was passed.
      */
-    async reportLeaseAction(response, flags, goal, verb) {
+    async reportLeaseAction(response, flags, goal, verb, 
+    /** Fields a `--json` caller needs that the server response does not carry. */
+    jsonExtra = {}) {
         let lease = response?.lease;
         const id = (0, dedicated_machines_1.dedicatedLeaseId)(lease);
         if (flags.wait && goal && id) {
@@ -201,7 +203,7 @@ class DedicatedLeaseCommand extends base_command_1.BaseCommand {
             }
         }
         if (flags.json) {
-            this.log(JSON.stringify({ ...(response || {}), lease }, null, 2));
+            this.log(JSON.stringify({ ...(response || {}), lease, ...jsonExtra }, null, 2));
             return;
         }
         this.log(`Dedicated Runtime ${id || 'unknown'} ${(0, dedicated_machines_1.dedicatedLeaseState)(lease)}.`);

package/dist/lib/dedicated-machines.d.ts

@@ -221,6 +221,46 @@ export declare function dedicatedRuntimeCreateInput(input: {
  */
 export declare function isDedicatedRepositoryRef(value: string): boolean;
 export declare function createDedicatedRuntime(input: CreateDedicatedRuntimeInput): Promise<DedicatedRuntimeResponse>;
+/** One offered tier as the operator price book checks it. */
+export interface DedicatedPriceBookPresetCheck {
+    sizePreset: string;
+    customerRateCentsPerHour: number | null;
+    providerCostCentsPerHour: number | null;
+    grossMarginBps: number | null;
+    priced: boolean;
+    providerCostRecorded: boolean;
+    marginTargetMet: boolean;
+}
+/** `GET /api/machines/dedicated/price-book` — admin only. */
+export interface DedicatedOperatorPriceBook {
+    timestamp?: string;
+    availability: 'available' | 'disabled';
+    disabledReason: string | null;
+    configError: string | null;
+    priceBook: {
+        required: boolean;
+        approved: boolean;
+        version: string | null;
+        pricingPolicyRef: string | null;
+        targetGrossMarginBps: number | null;
+        missingReason: string | null;
+        presetChecks: DedicatedPriceBookPresetCheck[];
+    };
+    sizeAvailability: Array<{
+        id: string;
+        offered: boolean;
+        withheldReason: string | null;
+    }>;
+}
+/**
+ * The Dedicated Runtime price book as an operator reads it: which version and
+ * which pricing policy, and each tier's rate, cost and margin. The customer
+ * catalog carries none of the policy or cost facts, and the admin plane that
+ * also serves this is not deployed in production (OSK-9562).
+ */
+export declare function getDedicatedOperatorPriceBook(): Promise<DedicatedOperatorPriceBook>;
+/** Human lines for `machines dedicated price-book`. Pure, so it can be pinned. */
+export declare function dedicatedOperatorPriceBookLines(read: DedicatedOperatorPriceBook): string[];
 export declare function listDedicatedRuntimes(options?: {
     limit?: number;
     state?: string;

package/dist/lib/dedicated-machines.js

@@ -5,6 +5,8 @@ exports.describeDedicatedImageStanding = describeDedicatedImageStanding;
 exports.dedicatedRuntimeCreateInput = dedicatedRuntimeCreateInput;
 exports.isDedicatedRepositoryRef = isDedicatedRepositoryRef;
 exports.createDedicatedRuntime = createDedicatedRuntime;
+exports.getDedicatedOperatorPriceBook = getDedicatedOperatorPriceBook;
+exports.dedicatedOperatorPriceBookLines = dedicatedOperatorPriceBookLines;
 exports.listDedicatedRuntimes = listDedicatedRuntimes;
 exports.getDedicatedRuntime = getDedicatedRuntime;
 exports.performDedicatedLeaseAction = performDedicatedLeaseAction;
@@ -157,6 +159,59 @@ async function createDedicatedRuntime(input) {
     const { requestId, workspaceId, ...body } = input;
     return (0, api_fetch_1.apiFetch)(withDedicatedScope('/api/machines/dedicated', { workspaceId }), { method: 'POST', body, headers: { 'Idempotency-Key': requestId } });
 }
+/**
+ * The Dedicated Runtime price book as an operator reads it: which version and
+ * which pricing policy, and each tier's rate, cost and margin. The customer
+ * catalog carries none of the policy or cost facts, and the admin plane that
+ * also serves this is not deployed in production (OSK-9562).
+ */
+async function getDedicatedOperatorPriceBook() {
+    return (0, api_fetch_1.apiFetch)('/api/machines/dedicated/price-book');
+}
+function formatBps(bps) {
+    return bps === null ? 'unknown' : `${(bps / 100).toFixed(1)}%`;
+}
+function formatRateCents(cents) {
+    return cents === null ? 'none' : `$${(cents / 100).toFixed(2)}/hr`;
+}
+/** Human lines for `machines dedicated price-book`. Pure, so it can be pinned. */
+function dedicatedOperatorPriceBookLines(read) {
+    const book = read.priceBook;
+    const lines = [
+        `Dedicated Runtime price book — ${book.approved ? 'approved' : 'NOT approved'}${book.required ? '' : ' (not required here)'}`,
+        `  version       ${book.version ?? 'not recorded'}`,
+        `  policy        ${book.pricingPolicyRef ?? 'not recorded'}`,
+        `  target margin ${formatBps(book.targetGrossMarginBps)}`,
+    ];
+    if (!book.approved && book.missingReason)
+        lines.push(`  why           ${book.missingReason}`);
+    if (read.availability === 'disabled' && read.disabledReason) {
+        lines.push(`  product       disabled: ${read.disabledReason}`);
+    }
+    if (read.configError)
+        lines.push(`  config        unreadable: ${read.configError}`);
+    lines.push('', 'Offered tiers');
+    if (book.presetChecks.length === 0)
+        lines.push('  none');
+    for (const check of book.presetChecks) {
+        const verdict = !check.priced
+            ? 'UNPRICED'
+            : !check.providerCostRecorded
+                ? 'UNCOSTED'
+                : check.marginTargetMet
+                    ? 'meets target'
+                    : 'BELOW TARGET';
+        lines.push(`  ${check.sizePreset.padEnd(12)} rate ${formatRateCents(check.customerRateCentsPerHour)} · cost ${formatRateCents(check.providerCostCentsPerHour)} · margin ${formatBps(check.grossMarginBps)} · ${verdict}`);
+    }
+    const withheld = read.sizeAvailability.filter((entry) => !entry.offered);
+    if (withheld.length > 0) {
+        lines.push('', 'Withheld tiers');
+        for (const entry of withheld) {
+            lines.push(`  ${entry.id.padEnd(12)} ${entry.withheldReason ?? 'no reason recorded'}`);
+        }
+    }
+    return lines;
+}
 async function listDedicatedRuntimes(options = {}) {
     const query = new URLSearchParams();
     if (options.limit)
@@ -411,10 +466,25 @@ function dedicatedSpendSummary(lease) {
         parts.push(`projected ${formatUsdCents(projected)}`);
     }
     if (billing.spendingLimitExceeded) {
-        parts.push('OVER CAP — compute is stopped, files are kept');
+        parts.push(`OVER CAP — ${overCapComputeClause(lease.state)}, files are kept`);
     }
     return parts.join(' · ');
 }
+/**
+ * What the cap has done to compute, in the tense the lease is actually in.
+ *
+ * This always said "compute is stopped", including for a machine that was still
+ * `requested` — which, over its cap, never provisions and cannot have its cap
+ * raised until it settles (OSK-9836). The reconciler stops compute for exactly
+ * `stopping`, `stopped` and `archived`; anything else is only on its way there.
+ */
+function overCapComputeClause(state) {
+    if (state === 'stopped' || state === 'archived')
+        return 'compute is stopped';
+    if (state === 'stopping')
+        return 'compute is stopping';
+    return 'compute will be stopped';
+}
 /**
  * The human rendering of `machines dedicated show`, as lines.
  *