@skrr-ai/cli 0.1.56 → 0.1.57

package/dist/lib/config.d.ts

@@ -190,6 +190,10 @@ export declare function isEnvAuthOverride(): boolean;
  * resolver and every existing install read it.
  */
 export declare function configRoot(env?: NodeJS.ProcessEnv): string;
+/** The root this machine uses when nothing relocates it (`~/.skrr`). */
+export declare function defaultConfigRoot(): string;
+/** Is this process on the primary root, however it was reached? */
+export declare function isDefaultConfigRoot(env?: NodeJS.ProcessEnv): boolean;
 /**
  * The machine cliId THIS config root mints when it has none stored
  * (OSK-12179). The primary root keeps the historical (host, user) id; any other

package/dist/lib/config.js

@@ -39,6 +39,8 @@ exports.describeDeployment = describeDeployment;
 exports.canonicalizeKnownBaseURL = canonicalizeKnownBaseURL;
 exports.isEnvAuthOverride = isEnvAuthOverride;
 exports.configRoot = configRoot;
+exports.defaultConfigRoot = defaultConfigRoot;
+exports.isDefaultConfigRoot = isDefaultConfigRoot;
 exports.machineCliId = machineCliId;
 exports.priorConfigDir = priorConfigDir;
 exports.loadConfig = loadConfig;
@@ -276,8 +278,8 @@ function defaultConfigRoot() {
     return (0, auth_core_1.resolveConfigRoot)({});
 }
 /** Is this process on the primary root, however it was reached? */
-function isDefaultConfigRoot() {
-    return path.resolve(configRoot()) === path.resolve(defaultConfigRoot());
+function isDefaultConfigRoot(env = process.env) {
+    return path.resolve(configRoot(env)) === path.resolve(defaultConfigRoot());
 }
 /**
  * The machine cliId THIS config root mints when it has none stored

package/dist/lib/daemonBroker.d.ts

@@ -342,6 +342,24 @@ export declare function maybeRetireStoredCliAuthFile(opts: {
     descriptorPath?: string;
     descriptorServerUrl?: string;
 }): Promise<void>;
+/**
+ * Should this process broker BEFORE it reads the stored credential?
+ * (OSK-12194)
+ *
+ * True only on a brokered Dedicated guest: the guest hand-off descriptor is
+ * live and offers the access-token mode and NOT the durable mint (its secret
+ * can only redeem, so any `cli-auth.json` here predates broker mode), and that
+ * file carries a refresh family for the descriptor's own server — the same
+ * provenance guard the retirement applies.
+ *
+ * Without this, the retirement could never run: it runs after a successful
+ * redeem, the auto-broker runs only when the resolver found no token, and the
+ * resolver adopts a file that carries one — so a LIVE pre-broker family was
+ * used and kept forever, which is exactly the case the cleanup exists for.
+ * A laptop has no guest descriptor and is untouched: there `cli-auth.json` is
+ * a legitimate login.
+ */
+export declare function shouldBrokerBeforeStoredCredential(descriptorPath?: string): boolean;
 /**
  * Convenience wrapper: run the broker call and, on a durable-mint success,
  * persist the returned bundle through the canonical Sky CLI auth backend

package/dist/lib/daemonBroker.js

@@ -86,6 +86,7 @@ exports.redeemBrokeredHandoffToken = redeemBrokeredHandoffToken;
 exports.__resetBrokeredHandoffForTest = __resetBrokeredHandoffForTest;
 exports.findBrokeredHandoffDescriptor = findBrokeredHandoffDescriptor;
 exports.maybeRetireStoredCliAuthFile = maybeRetireStoredCliAuthFile;
+exports.shouldBrokerBeforeStoredCredential = shouldBrokerBeforeStoredCredential;
 exports.attemptDaemonBrokerLoginAndPersist = attemptDaemonBrokerLoginAndPersist;
 exports.maybeAutoBroker = maybeAutoBroker;
 const fs = __importStar(require("node:fs"));
@@ -837,32 +838,69 @@ function findBrokeredHandoffDescriptor(profile = 'default') {
 async function maybeRetireStoredCliAuthFile(opts) {
     if (opts.descriptorPath !== exports.DEDICATED_RUNTIME_CLI_HANDOFF_DESCRIPTOR)
         return;
-    let stored;
-    try {
-        stored = (0, auth_storage_1.readFromFile)();
-    }
-    catch {
-        return;
-    }
-    if (!stored?.refreshToken)
-        return;
-    const storedOrigin = stored.serverOrigin ? (0, auth_storage_1.normalizeServerOrigin)(stored.serverOrigin) : null;
-    const descriptorOrigin = opts.descriptorServerUrl
-        ? (0, auth_storage_1.normalizeServerOrigin)(opts.descriptorServerUrl)
-        : null;
-    if (!storedOrigin || !descriptorOrigin || storedOrigin !== descriptorOrigin)
+    const stale = retirableCliAuthFamily(opts.descriptorServerUrl);
+    if (!stale)
         return;
     // The revoke is authenticated by the refresh token itself — presenting it
     // is the proof of ownership. `revokeDaemonRefreshSession` swallows its own
     // network/HTTP failures (best-effort by contract); the delete still runs.
     try {
-        await (0, auth_core_1.revokeDaemonRefreshSession)(descriptorOrigin, stored.refreshToken);
+        await (0, auth_core_1.revokeDaemonRefreshSession)(stale.origin, stale.refreshToken);
     }
     catch {
         /* best-effort — delete proceeds regardless */
     }
     (0, auth_storage_1.deleteFileBackend)();
 }
+/**
+ * Guards 2 and 3 of the retirement above: the stored file's refresh family,
+ * when its origin matches the descriptor's. Read through
+ * `readRefreshFamilyFromFile`, which accepts a file whose access token is
+ * empty — the realistic pre-broker shape once that token lapsed, and the one
+ * `readFromFile` reports as no credential at all (OSK-12194).
+ */
+function retirableCliAuthFamily(descriptorServerUrl) {
+    let stored;
+    try {
+        stored = (0, auth_storage_1.readRefreshFamilyFromFile)();
+    }
+    catch {
+        return null;
+    }
+    if (!stored?.refreshToken)
+        return null;
+    const storedOrigin = stored.serverOrigin ? (0, auth_storage_1.normalizeServerOrigin)(stored.serverOrigin) : null;
+    const descriptorOrigin = descriptorServerUrl ? (0, auth_storage_1.normalizeServerOrigin)(descriptorServerUrl) : null;
+    if (!storedOrigin || !descriptorOrigin || storedOrigin !== descriptorOrigin)
+        return null;
+    return { origin: descriptorOrigin, refreshToken: stored.refreshToken };
+}
+/**
+ * Should this process broker BEFORE it reads the stored credential?
+ * (OSK-12194)
+ *
+ * True only on a brokered Dedicated guest: the guest hand-off descriptor is
+ * live and offers the access-token mode and NOT the durable mint (its secret
+ * can only redeem, so any `cli-auth.json` here predates broker mode), and that
+ * file carries a refresh family for the descriptor's own server — the same
+ * provenance guard the retirement applies.
+ *
+ * Without this, the retirement could never run: it runs after a successful
+ * redeem, the auto-broker runs only when the resolver found no token, and the
+ * resolver adopts a file that carries one — so a LIVE pre-broker family was
+ * used and kept forever, which is exactly the case the cleanup exists for.
+ * A laptop has no guest descriptor and is untouched: there `cli-auth.json` is
+ * a legitimate login.
+ */
+function shouldBrokerBeforeStoredCredential(descriptorPath = exports.DEDICATED_RUNTIME_CLI_HANDOFF_DESCRIPTOR) {
+    const bootstrap = readBootstrap(descriptorPath);
+    if (!bootstrap)
+        return false;
+    const modes = (0, cli_handoff_wire_1.advertisedHandoffModes)(bootstrap);
+    if (!modes.includes('access_token') || modes.includes('refresh_family'))
+        return false;
+    return retirableCliAuthFamily(bootstrap.serverUrl) !== null;
+}
 /** Bound the confirm so a slow server cannot stall a login that already worked. */
 const CONFIRM_TIMEOUT_MS = 10_000;
 /**

package/dist/lib/daemonHandoff.d.ts

@@ -40,7 +40,7 @@ export interface DaemonHandoffOutcome {
      * The two absent cases are separated because they need different work — one
      * needs a binary fetched, the other only needs the service registered.
      */
-    reason?: 'opted-out' | 'brokered' | 'no-binary' | 'legacy-binary' | 'unsupported-daemon' | 'no-service';
+    reason?: 'opted-out' | 'brokered' | 'no-binary' | 'legacy-binary' | 'unsupported-daemon' | 'no-service' | 'foreign-root' | 'mint-refused';
 }
 export declare function handOffToLocalDaemon(env?: NodeJS.ProcessEnv, opts?: {
     loginFlow?: string;

package/dist/lib/daemonHandoff.js

@@ -196,6 +196,24 @@ async function handOffToLocalDaemon(env = process.env, opts = {}) {
             detail: 'the local daemon brokered this login, so it already has a working credential',
         };
     }
+    // A relocated config root (`SKRR_CONFIG_DIR`) is a second sign-in on this
+    // machine, not the machine's sign-in. The installed daemon service carries no
+    // config-root override, so it reads the DEFAULT root — its credential, its
+    // deployment, its account belong there. Offering this root's login to it would
+    // re-point the machine at whatever this root signed in as, and when the server
+    // refused the offer the CLI used to report a healthy, signed-in daemon as
+    // "not signed in" and send the user to re-login it (OSK-12189).
+    //
+    // Decided on the root alone, before anything is spawned or minted: nothing
+    // about this machine's daemon should change because a second root signed in.
+    if (!(0, config_1.isDefaultConfigRoot)(env)) {
+        return {
+            status: 'skipped',
+            reason: 'foreign-root',
+            detail: `this login is in the config root ${(0, config_1.configRoot)(env)}; the local daemon ` +
+                `belongs to ${(0, config_1.defaultConfigRoot)()} and keeps its own sign-in`,
+        };
+    }
     const binary = (0, exec_runtime_binary_1.findRuntimeBinary)();
     if (!binary) {
         return { status: 'skipped', reason: 'no-binary', detail: 'no local daemon installed' };
@@ -264,7 +282,9 @@ async function handOffToLocalDaemon(env = process.env, opts = {}) {
         }));
     }
     catch (err) {
-        return { status: 'failed', detail: err.message };
+        // Refused BEFORE the daemon was touched: it still holds exactly the
+        // credential it had, so this is "not handed this login", never "signed out".
+        return { status: 'failed', reason: 'mint-refused', detail: err.message };
     }
     const payload = JSON.stringify({
         refreshToken: bundle.refreshToken,

package/dist/lib/internal-id.d.ts

@@ -0,0 +1,28 @@
+/**
+ * The internal Mongo `_id` handed back where a command wants the `id`.
+ *
+ * `--json` prints every row's `_id` FIRST, so it is the value a person or a
+ * script copies. Spaces and Tasks are addressed by `id` (a UUID) everywhere in
+ * the API, and no resolver accepts both forms, so `spaces show <_id>`,
+ * `tasks show <_id>` and `tasks create --space <_id>` answered with not-found
+ * or a raw HTTP 404 — true, and no help: nothing said which field to use
+ * (OSK-12205).
+ *
+ * Only the refusal lives here. Finding the `id` that goes with an `_id` needs
+ * a listing, so the caller does that (it holds the API) and passes the answer
+ * in when it has one.
+ */
+/** A 24-hex Mongo ObjectId, the shape of `_id`. */
+export declare function looksLikeInternalObjectId(value: string): boolean;
+/**
+ * The sentence for an `_id` passed where the `id` belongs.
+ *
+ * `canonicalId` is the row's `id` when the caller could find it — then the
+ * remedy is the exact value to use. Without it the remedy names the field.
+ */
+export declare function describeInternalIdMisuse(opts: {
+    value: string;
+    noun: 'space' | 'task';
+    canonicalId?: string | null;
+    bin: string;
+}): string;

package/dist/lib/internal-id.js

@@ -0,0 +1,41 @@
+"use strict";
+/**
+ * The internal Mongo `_id` handed back where a command wants the `id`.
+ *
+ * `--json` prints every row's `_id` FIRST, so it is the value a person or a
+ * script copies. Spaces and Tasks are addressed by `id` (a UUID) everywhere in
+ * the API, and no resolver accepts both forms, so `spaces show <_id>`,
+ * `tasks show <_id>` and `tasks create --space <_id>` answered with not-found
+ * or a raw HTTP 404 — true, and no help: nothing said which field to use
+ * (OSK-12205).
+ *
+ * Only the refusal lives here. Finding the `id` that goes with an `_id` needs
+ * a listing, so the caller does that (it holds the API) and passes the answer
+ * in when it has one.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.looksLikeInternalObjectId = looksLikeInternalObjectId;
+exports.describeInternalIdMisuse = describeInternalIdMisuse;
+const OBJECT_ID_RE = /^[0-9a-fA-F]{24}$/;
+/** A 24-hex Mongo ObjectId, the shape of `_id`. */
+function looksLikeInternalObjectId(value) {
+    return OBJECT_ID_RE.test(value.trim());
+}
+/**
+ * The sentence for an `_id` passed where the `id` belongs.
+ *
+ * `canonicalId` is the row's `id` when the caller could find it — then the
+ * remedy is the exact value to use. Without it the remedy names the field.
+ */
+function describeInternalIdMisuse(opts) {
+    const { value, noun, canonicalId, bin } = opts;
+    const head = `"${value.trim()}" is the internal _id of a ${noun}; commands take its \`id\``;
+    if (canonicalId) {
+        return `${head}. Use \`id\` ${canonicalId}.`;
+    }
+    const alternatives = noun === 'task'
+        ? 'the `id` field (a UUID) or the `identifier` (OSK-123) from the same --json output'
+        : 'the `id` field (a UUID) or the `identifier` (OSK-S-12) from the same --json output';
+    return (`${head}.\n` +
+        `  → use ${alternatives}; \`${bin} ${noun === 'task' ? 'tasks' : 'spaces'} list --json\` prints both.`);
+}

package/dist/lib/workflow-state-hint.d.ts

@@ -0,0 +1,10 @@
+/**
+ * The remedy for `tasks move --status <unknown>` (OSK-12205).
+ *
+ * Workflow states are Space-local, so the CLI cannot declare them as flag
+ * options and cannot list them ahead of the refusal. The server now names the
+ * accepted states in its message (and in `details.validStates`); this adds the
+ * command that lists them with their types, and quotes the states itself when
+ * a server sent them only in `details`.
+ */
+export declare function describeUnknownWorkflowState(body: Record<string, unknown> | undefined, bin: string): string | null;

package/dist/lib/workflow-state-hint.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.describeUnknownWorkflowState = describeUnknownWorkflowState;
+/**
+ * The remedy for `tasks move --status <unknown>` (OSK-12205).
+ *
+ * Workflow states are Space-local, so the CLI cannot declare them as flag
+ * options and cannot list them ahead of the refusal. The server now names the
+ * accepted states in its message (and in `details.validStates`); this adds the
+ * command that lists them with their types, and quotes the states itself when
+ * a server sent them only in `details`.
+ */
+function describeUnknownWorkflowState(body, bin) {
+    if (!body || body.code !== 'WORKFLOW_STATE_UNKNOWN')
+        return null;
+    const details = (body.details ?? {});
+    const valid = Array.isArray(details.validStates)
+        ? details.validStates.filter((v) => typeof v === 'string')
+        : [];
+    let message = typeof body.error === 'string' && body.error ? body.error : 'Unknown workflow state';
+    if (valid.length > 0 && !message.includes(valid[0])) {
+        message += `. This Space accepts: ${valid.join(', ')}.`;
+    }
+    return (`${message}\n` +
+        `  → \`${bin} spaces states list <space-id>\` lists this Space's states with their types; ` +
+        '`--status` takes a state id or its display name.');
+}