@skrr-ai/cli 0.1.33 → 0.1.34

package/dist/base-command.js

@@ -203,6 +203,11 @@ class BaseCommand extends core_1.Command {
             (0, data_provider_1.setHttpAdapter)((0, node_adapter_1.createNodeAdapter)());
             return;
         }
+        // A replacement guest keeps its workspace but receives a fresh Linux
+        // machine-id. Retire the prior instance's machine-bound CLI envelopes
+        // before migration/prefetch reads them; the current daemon handoff below
+        // supplies fresh authority without a user login.
+        await (0, auth_core_init_1.prepareDedicatedRuntimeAuthGeneration)();
         // One-shot migration: legacy token/refreshToken in cli-config.json
         // → keychain (macOS) or cli-auth.json (elsewhere). Idempotent.
         try {

package/dist/commands/learning/delete.js

@@ -14,7 +14,8 @@ class LearningDelete extends base_command_1.BaseCommand {
         const { flags } = await this.parse(LearningDelete);
         if (!flags.yes &&
             !(await this.confirm('Delete all adaptive-learning state, episodes, and outcomes? [y/N] '))) {
-            return;
+            this.log('Cancelled.');
+            this.exit(1);
         }
         let result;
         try {

package/dist/commands/learning/export.d.ts

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

package/dist/commands/learning/export.js

@@ -1,12 +1,25 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+const promises_1 = require("node:fs/promises");
+const core_1 = require("@oclif/core");
 const base_command_1 = require("../../base-command");
 const api_fetch_1 = require("../../lib/api-fetch");
 class LearningExport extends base_command_1.BaseCommand {
     static description = 'Export your adaptive-learning consent, state, episodes, and outcomes as JSON';
+    static examples = [
+        '<%= config.bin %> learning export --output learning-data.json',
+        '<%= config.bin %> learning export --output - | jq .consent',
+    ];
+    static flags = {
+        output: core_1.Flags.string({
+            char: 'o',
+            description: 'Required destination path; use "-" only for deliberate stdout output',
+            required: true,
+        }),
+    };
     async run() {
         this.requireAuth();
-        await this.parse(LearningExport);
+        const { flags } = await this.parse(LearningExport);
         let result;
         try {
             result = await (0, api_fetch_1.apiFetch)('/api/user/adaptive-learning/export', {
@@ -16,7 +29,28 @@ class LearningExport extends base_command_1.BaseCommand {
         catch (err) {
             this.handleApiError(err);
         }
-        this.log(JSON.stringify(result, null, 2));
+        const serialized = `${JSON.stringify(result, null, 2)}\n`;
+        if (flags.output === '-') {
+            this.log(serialized.trimEnd());
+            return;
+        }
+        try {
+            await (0, promises_1.writeFile)(flags.output, serialized, {
+                encoding: 'utf8',
+                flag: 'wx',
+                mode: 0o600,
+            });
+        }
+        catch (err) {
+            this.failWithCliError({
+                message: `Could not write ${flags.output}: ${err.message}`,
+                code: 'ADAPTIVE_LEARNING_EXPORT_WRITE_FAILED',
+                exit: 1,
+                retryable: false,
+                details: { path: flags.output },
+            });
+        }
+        this.log(`Wrote adaptive-learning export to ${flags.output}.`);
     }
 }
 exports.default = LearningExport;

package/dist/commands/learning/reset.js

@@ -12,8 +12,10 @@ class LearningReset extends base_command_1.BaseCommand {
     async run() {
         this.requireAuth();
         const { flags } = await this.parse(LearningReset);
-        if (!flags.yes && !(await this.confirm('Reset all learned serving state? [y/N] ')))
-            return;
+        if (!flags.yes && !(await this.confirm('Reset all learned serving state? [y/N] '))) {
+            this.log('Cancelled.');
+            this.exit(1);
+        }
         let result;
         try {
             result = await (0, api_fetch_1.apiFetch)('/api/user/adaptive-learning/reset', {

package/dist/lib/auth-core-init.d.ts

@@ -1,4 +1,26 @@
 import { type AuthBundle } from './auth-storage';
+type DedicatedGenerationPreparationOptions = {
+    machineUuid?: string;
+    configDir?: string;
+    clearStoredAuth?: () => void;
+    clearCredentialEnvelope?: () => Promise<void>;
+    clearDeviceIdentity?: () => Promise<void>;
+};
+/**
+ * A Dedicated Runtime's workspace survives replacement but `/etc/machine-id`
+ * intentionally does not. Linux's fallback KEK is derived from that id, so a
+ * CLI credential persisted by the prior instance is unreadable on the next
+ * one. The guest never needs that stale authority: its root-owned loopback
+ * handoff descriptor mints a fresh CLI credential from the current daemon.
+ *
+ * Clear only the workload CLI's machine-bound auth artifacts once per runtime
+ * generation, before auth-core tries to decrypt them. A cross-process lock is
+ * required because terminals and agent tools can launch several `skrr`
+ * processes as soon as the guest becomes ready; without it they can clear a
+ * sibling's just-enrolled credential. The marker contains identity, not a
+ * secret, and stays in the persistent workspace beside the auth files.
+ */
+export declare function prepareDedicatedRuntimeAuthGeneration(options?: DedicatedGenerationPreparationOptions): Promise<boolean>;
 export declare function ensureAuthCoreConfigured(): void;
 export declare class CliCredentialInitializationError extends Error {
     readonly code = "CREDENTIAL_INITIALIZATION_UNAVAILABLE";
@@ -42,3 +64,4 @@ export declare function waitForCliCredentialEnvelope(): Promise<void>;
 /** @internal Test seam — reset the module-level one-shot initialization. */
 export declare function __resetPrefetchCliAuthForTest(): void;
 export declare function shouldUseAccessTokenForEnrollment(bundle: Pick<AuthBundle, 'token' | 'expiresAt'> | null | undefined, nowMs?: number, minTtlMs?: number): boolean;
+export {};

package/dist/lib/auth-core-init.js

@@ -4,6 +4,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.CliCredentialInitializationError = void 0;
+exports.prepareDedicatedRuntimeAuthGeneration = prepareDedicatedRuntimeAuthGeneration;
 exports.ensureAuthCoreConfigured = ensureAuthCoreConfigured;
 exports.prefetchCliAuth = prefetchCliAuth;
 exports.waitForCliCredentialEnvelope = waitForCliCredentialEnvelope;
@@ -33,8 +34,10 @@ exports.shouldUseAccessTokenForEnrollment = shouldUseAccessTokenForEnrollment;
  *   - Fire-and-forget enrollment when an access token is already
  *     present — short-circuits silently on a fresh install before login.
  */
+const node_fs_1 = __importDefault(require("node:fs"));
 const node_os_1 = __importDefault(require("node:os"));
 const node_path_1 = __importDefault(require("node:path"));
+const proper_lockfile_1 = __importDefault(require("proper-lockfile"));
 const auth_core_1 = require("@skrr-ai/auth-core");
 const cred_envelope_1 = require("./cred-envelope");
 const device_identity_1 = require("./device-identity");
@@ -64,6 +67,64 @@ const cliLogger = {
  * so cross-binary file paths align byte-for-byte.
  */
 const DEFAULT_PROFILE = 'default';
+const DEDICATED_AUTH_GENERATION_MARKER = 'dedicated-runtime-auth-generation';
+/**
+ * A Dedicated Runtime's workspace survives replacement but `/etc/machine-id`
+ * intentionally does not. Linux's fallback KEK is derived from that id, so a
+ * CLI credential persisted by the prior instance is unreadable on the next
+ * one. The guest never needs that stale authority: its root-owned loopback
+ * handoff descriptor mints a fresh CLI credential from the current daemon.
+ *
+ * Clear only the workload CLI's machine-bound auth artifacts once per runtime
+ * generation, before auth-core tries to decrypt them. A cross-process lock is
+ * required because terminals and agent tools can launch several `skrr`
+ * processes as soon as the guest becomes ready; without it they can clear a
+ * sibling's just-enrolled credential. The marker contains identity, not a
+ * secret, and stays in the persistent workspace beside the auth files.
+ */
+async function prepareDedicatedRuntimeAuthGeneration(options = {}) {
+    const machineUuid = String(options.machineUuid ?? process.env.SKRR_MACHINE_UUID ?? '').trim();
+    if (!machineUuid.startsWith('dedicated-runtime:'))
+        return false;
+    const configDir = options.configDir ?? node_path_1.default.join(node_os_1.default.homedir(), '.skrr');
+    node_fs_1.default.mkdirSync(configDir, { recursive: true, mode: 0o700 });
+    const markerPath = node_path_1.default.join(configDir, DEDICATED_AUTH_GENERATION_MARKER);
+    const release = await proper_lockfile_1.default.lock(configDir, {
+        lockfilePath: `${markerPath}.lock`,
+        realpath: false,
+        retries: { retries: 20, minTimeout: 25, maxTimeout: 250 },
+    });
+    try {
+        let recorded = '';
+        try {
+            recorded = node_fs_1.default.readFileSync(markerPath, 'utf8').trim();
+        }
+        catch (error) {
+            if (error.code !== 'ENOENT')
+                throw error;
+        }
+        if (recorded === machineUuid)
+            return false;
+        (options.clearStoredAuth ?? auth_storage_1.clearAllBackends)();
+        await (options.clearDeviceIdentity ??
+            (() => (0, device_identity_1.resetDeviceIdentity)({
+                profile: DEFAULT_PROFILE,
+                clearOnDisk: true,
+            })))();
+        await (options.clearCredentialEnvelope ??
+            (() => (0, cred_envelope_1.resetCredEnvelope)({
+                profile: DEFAULT_PROFILE,
+                clearOnDisk: true,
+            })))();
+        const temporary = `${markerPath}.tmp.${process.pid}.${Date.now()}`;
+        node_fs_1.default.writeFileSync(temporary, `${machineUuid}\n`, { mode: 0o600 });
+        node_fs_1.default.renameSync(temporary, markerPath);
+        return true;
+    }
+    finally {
+        await release();
+    }
+}
 /**
  * Soft cap so a stuck KEK probe (corrupt keychain, hung native binding)
  * does not wedge commands on a fresh/plaintext install. Persisted encrypted

package/dist/lib/dedicated-machines.js

@@ -893,7 +893,11 @@ function formatDedicatedRuntimeApiError(err) {
     }
     try {
         const parsed = JSON.parse(err.body);
-        const sentence = parsed.message || parsed.error || parsed.code;
+        // This formatter is reached only by `machines dedicated *`. Older API
+        // replicas and product-neutral action errors may still carry the Hosted
+        // Machine noun even though the caller named a Dedicated Runtime. Do not
+        // repeat that contradictory product name while a mixed deployment rolls.
+        const sentence = (parsed.message || parsed.error || parsed.code)?.replace(/(?:skrr )?Hosted Machine/g, 'Dedicated Runtime');
         return sentence ? `${sentence}${describeRefusalReasons(err)}` : null;
     }
     catch {