@skrr-ai/cli 0.1.109 → 0.1.111

package/dist/node_modules/@skrr-ai/auth-core/dist/esm/machineUuid.d.ts

@@ -56,5 +56,65 @@ export declare function getMachineUuidProfile(): string | null;
  * profile that already held credentials; see the block above.
  */
 export declare function getMachineUuid(): string;
+/**
+ * The `machineUuid` a process running as `profile` sends, WITHOUT changing which
+ * profile this process runs as.
+ *
+ * The CLI needs the answer for the profile it is about to hand a credential to,
+ * and asks the daemon binary what IT will send (`accept-handoff --print-id`).
+ * Two programs that compute one identity can only be known to agree by
+ * comparing them, and a daemon that predates per-profile identities does not
+ * agree: it sends the hardware value whatever the profile's
+ * `machine-identity.json` says, so a credential minted for what it reports
+ * registers the profile on the default machine's row (the OSK-13845 failure, now
+ * reached through version skew rather than through the rule). The comparison
+ * needs this: the expected value for the TARGET profile, which is not
+ * necessarily the one this process is running as.
+ *
+ * Decides and persists the profile's identity if nothing has yet — the same
+ * side effect `getMachineUuid()` has, for the same reason.
+ */
+export declare function getMachineUuidForProfile(profile: string | null | undefined): string;
+export type MachineIdentityReason = 
+/** The default profile, which always uses this computer's own identity. */
+'default_profile'
+/** A hosted runtime, whose identity the control plane issued. */
+ | 'hosted_runtime'
+/** A profile that held no credentials when its identity was first decided. */
+ | 'new_profile'
+/** A profile that already held credentials, so it keeps the shared identity. */
+ | 'pre_existing_profile'
+/** Recovered from the copy kept outside the profile after product state was removed. */
+ | 'restored_profile'
+/** The profile's record could not be read (the identity is still the one in use). */
+ | 'unrecorded';
+export interface MachineIdentityDescription {
+    /** The profile this process runs as; null for the default profile. */
+    profile: string | null;
+    /** The value sent to the server as `machineUuid`. */
+    machineUuid: string;
+    /** This computer's own identity. */
+    hardware: string;
+    /**
+     * A non-default profile that registers on the SAME machine row as the default
+     * profile: they share one Daemon row, one device-key pin and one machine page.
+     */
+    sharesDefaultMachine: boolean;
+    reason: MachineIdentityReason;
+    /** The files that made a profile "already hold credentials", when recorded. */
+    evidence: string[];
+    decidedAt: string | null;
+    /** One sentence for a person. Written once, here, so no surface words it differently. */
+    sentence: string;
+}
+/**
+ * Which machine this process registers as, and WHY — the question a person has
+ * when two profiles turn up on one machine page and the logs say nothing.
+ *
+ * A read, not a decision: it reports the identity `getMachineUuid()` settled on
+ * (settling it if nothing has, exactly as any caller would) and the record that
+ * explains it. It never changes what a profile registers as.
+ */
+export declare function describeMachineIdentity(): MachineIdentityDescription;
 /** @internal test seam — forget the cached value so the next call re-probes. */
 export declare function __resetMachineUuidCacheForTest(): void;

package/dist/node_modules/@skrr-ai/auth-core/dist/esm/machineUuid.js

@@ -218,7 +218,7 @@ function readPersistedChoice(file, hardware, profile, requireProfile = false) {
         return null;
     }
 }
-function persistChoice(dir, file, hardware, machineUuid, reason, profile) {
+function persistChoice(dir, file, hardware, machineUuid, reason, profile, evidence) {
     try {
         fs.mkdirSync(dir, { recursive: true, mode: 0o700 });
         const tmp = `${file}.${process.pid}.${Date.now()}.tmp`;
@@ -228,6 +228,12 @@ function persistChoice(dir, file, hardware, machineUuid, reason, profile) {
             machineUuid,
             profile,
             reason,
+            // WHICH file made a profile "already hold credentials". The reason alone
+            // says a profile shares the default's machine row; this says what put it
+            // there, which is the difference between "an older Skrr set it up" and
+            // "its first credential was written before anything chose its identity".
+            // Additive: a reader that predates it ignores the field.
+            ...(evidence && evidence.length > 0 ? { evidence: [...evidence] } : {}),
             decidedAt: new Date().toISOString(),
         };
         fs.writeFileSync(tmp, `${JSON.stringify(body)}\n`, { mode: 0o600 });
@@ -267,7 +273,7 @@ function resolveProfileMachineUuid(profile, hardware) {
             persistChoice(dir, file, hardware, chosen, 'restored_profile', profile);
     }
     if (!chosen) {
-        const preExisting = PRE_EXISTING_PROFILE_EVIDENCE.some((name) => {
+        const evidence = PRE_EXISTING_PROFILE_EVIDENCE.filter((name) => {
             try {
                 return fs.existsSync(path.join(dir, name));
             }
@@ -275,8 +281,9 @@ function resolveProfileMachineUuid(profile, hardware) {
                 return false;
             }
         });
+        const preExisting = evidence.length > 0;
         chosen = preExisting ? hardware : qualifyMachineUuid(hardware, profile);
-        persistChoice(dir, file, hardware, chosen, preExisting ? 'pre_existing_profile' : 'new_profile', profile);
+        persistChoice(dir, file, hardware, chosen, preExisting ? 'pre_existing_profile' : 'new_profile', profile, evidence);
     }
     preserveRecoveryChoice(profile, hardware, chosen);
     profileChoiceCache.set(cacheKey, chosen);
@@ -296,14 +303,129 @@ function resolveProfileMachineUuid(profile, hardware) {
  * profile that already held credentials; see the block above.
  */
 export function getMachineUuid() {
+    return getMachineUuidForProfile(activeMachineProfile);
+}
+/**
+ * The `machineUuid` a process running as `profile` sends, WITHOUT changing which
+ * profile this process runs as.
+ *
+ * The CLI needs the answer for the profile it is about to hand a credential to,
+ * and asks the daemon binary what IT will send (`accept-handoff --print-id`).
+ * Two programs that compute one identity can only be known to agree by
+ * comparing them, and a daemon that predates per-profile identities does not
+ * agree: it sends the hardware value whatever the profile's
+ * `machine-identity.json` says, so a credential minted for what it reports
+ * registers the profile on the default machine's row (the OSK-13845 failure, now
+ * reached through version skew rather than through the rule). The comparison
+ * needs this: the expected value for the TARGET profile, which is not
+ * necessarily the one this process is running as.
+ *
+ * Decides and persists the profile's identity if nothing has yet — the same
+ * side effect `getMachineUuid()` has, for the same reason.
+ */
+export function getMachineUuidForProfile(profile) {
     const hardware = getHardwareMachineUuid();
     // A hosted runtime's identity is ISSUED and fenced by the control plane.
     if (hostedRuntimeIdOverride('OVERSKY_MACHINE_UUID'))
         return hardware;
-    const profile = activeMachineProfile;
-    if (!profile || profile === DEFAULT_PROFILE_NAME)
+    const name = typeof profile === 'string' ? profile.trim() : '';
+    if (!name || name === DEFAULT_PROFILE_NAME)
         return hardware;
-    return resolveProfileMachineUuid(profile, hardware);
+    return resolveProfileMachineUuid(name, hardware);
+}
+function readRecordedChoice(profile) {
+    try {
+        const file = path.join(resolveConfigRoot(), 'profiles', profile, MACHINE_IDENTITY_FILENAME);
+        const parsed = JSON.parse(fs.readFileSync(file, 'utf-8'));
+        const reason = parsed.reason === 'new_profile' ||
+            parsed.reason === 'pre_existing_profile' ||
+            parsed.reason === 'restored_profile'
+            ? parsed.reason
+            : null;
+        return {
+            reason,
+            evidence: Array.isArray(parsed.evidence)
+                ? parsed.evidence.filter((e) => typeof e === 'string')
+                : [],
+            decidedAt: typeof parsed.decidedAt === 'string' ? parsed.decidedAt : null,
+        };
+    }
+    catch {
+        return { reason: null, evidence: [], decidedAt: null };
+    }
+}
+/**
+ * Which machine this process registers as, and WHY — the question a person has
+ * when two profiles turn up on one machine page and the logs say nothing.
+ *
+ * A read, not a decision: it reports the identity `getMachineUuid()` settled on
+ * (settling it if nothing has, exactly as any caller would) and the record that
+ * explains it. It never changes what a profile registers as.
+ */
+export function describeMachineIdentity() {
+    const hardware = getHardwareMachineUuid();
+    const machineUuid = getMachineUuid();
+    const active = activeMachineProfile;
+    const profile = active && active !== DEFAULT_PROFILE_NAME ? active : null;
+    const base = { profile, machineUuid, hardware };
+    if (hostedRuntimeIdOverride('OVERSKY_MACHINE_UUID')) {
+        return {
+            ...base,
+            sharesDefaultMachine: false,
+            reason: 'hosted_runtime',
+            evidence: [],
+            decidedAt: null,
+            sentence: 'This runtime is hosted; its machine identity was issued by the control plane.',
+        };
+    }
+    if (!profile) {
+        return {
+            ...base,
+            sharesDefaultMachine: false,
+            reason: 'default_profile',
+            evidence: [],
+            decidedAt: null,
+            sentence: "The default profile uses this computer's own machine identity.",
+        };
+    }
+    const recorded = readRecordedChoice(profile);
+    const sharesDefaultMachine = machineUuid === hardware;
+    const reason = recorded.reason ?? 'unrecorded';
+    const decided = recorded.decidedAt ? ` (decided ${recorded.decidedAt})` : '';
+    const held = recorded.evidence.length > 0 ? ` (${recorded.evidence.join(', ')})` : '';
+    let sentence;
+    if (reason === 'new_profile') {
+        sentence =
+            `Profile '${profile}' has its own machine identity: it held no credentials when that ` +
+                `identity was first chosen${decided}.`;
+    }
+    else if (reason === 'pre_existing_profile') {
+        sentence =
+            `Profile '${profile}' shares this computer's default machine identity: it already held ` +
+                `credentials${held} when its identity was first chosen${decided}, and the server ties ` +
+                'those credentials to that identity, so changing it would sign the profile out.';
+    }
+    else if (reason === 'restored_profile') {
+        sentence = sharesDefaultMachine
+            ? `Profile '${profile}' shares this computer's default machine identity, restored from the ` +
+                `copy kept outside the profile after its state was removed${decided}.`
+            : `Profile '${profile}' has its own machine identity, restored from the copy kept outside ` +
+                `the profile after its state was removed${decided}.`;
+    }
+    else {
+        sentence = sharesDefaultMachine
+            ? `Profile '${profile}' uses this computer's default machine identity; the record of why ` +
+                'could not be read.'
+            : `Profile '${profile}' has its own machine identity; the record of why could not be read.`;
+    }
+    return {
+        ...base,
+        sharesDefaultMachine,
+        reason,
+        evidence: recorded.evidence,
+        decidedAt: recorded.decidedAt,
+        sentence,
+    };
 }
 /** @internal test seam — forget the cached value so the next call re-probes. */
 export function __resetMachineUuidCacheForTest() {

package/dist/node_modules/@skrr-ai/auth-core/dist/esm/refresh.d.ts

@@ -282,6 +282,8 @@ export declare function needsReauthState(): {
      * which one they hit (OSK-12116).
      */
     message?: string;
+    /** OSK-16941 — the server's session-revocation reason, when one was latched. */
+    revocationReason?: string;
     since?: number;
 };
 export declare function clearReauthState(): void;

package/dist/node_modules/@skrr-ai/auth-core/dist/esm/refresh.js

@@ -835,8 +835,18 @@ async function doRefresh(serverUrl, currentRefreshToken, daemonId, options = {})
                     statusCode: 401,
                 },
             });
-            persistReauthState({ code, message: parsedBody.message, at: Date.now() });
-            throw new PermanentAuthFailure(code, parsedBody.message || code);
+            // OSK-16941 — keep WHY a revoked session was revoked, so the CLI and the
+            // desktop banner can tell the person instead of a bare code.
+            const revocationReason = code === 'SESSION_REVOKED' && typeof parsedBody.reason === 'string'
+                ? parsedBody.reason.slice(0, 64)
+                : undefined;
+            persistReauthState({
+                code,
+                message: parsedBody.message,
+                ...(revocationReason ? { revocationReason } : {}),
+                at: Date.now(),
+            });
+            throw new PermanentAuthFailure(code, parsedBody.message || code, revocationReason);
         }
         // Unknown-shape 401 — unknown code, missing code, or unparseable body.
         // By construction this is NOT a daemon's actual refresh-family burn
@@ -959,6 +969,9 @@ export function needsReauthState() {
             ...(typeof state.message === 'string' && state.message.length > 0
                 ? { message: state.message }
                 : {}),
+            ...(typeof state.revocationReason === 'string' && state.revocationReason.length > 0
+                ? { revocationReason: state.revocationReason }
+                : {}),
             since: state.at,
         };
     }

package/dist/node_modules/@skrr-ai/auth-core/dist/esm/refreshClassification.d.ts

@@ -21,6 +21,11 @@ export interface RefreshResponseShape {
     code?: string;
     /** Optional human-readable error message. */
     message?: string;
+    /**
+     * OSK-16941 — with `code: 'SESSION_REVOKED'`, why the session was revoked
+     * (`@skrr-ai/data-provider` `SESSION_REVOCATION_REASONS`).
+     */
+    reason?: string;
     /** When 200, the new access token. */
     token?: string;
     /** When 200, the (possibly rotated) refresh token. */

package/dist/node_modules/@skrr-ai/auth-core/dist/esm/refreshClassification.js

@@ -97,7 +97,9 @@ export function classifyRefreshResponse(status, body) {
             const fallback = body?.code === 'REFRESH_MISSING' ? 'Refresh token missing' : reason;
             return {
                 kind: 'failure',
-                failure: new PermanentAuthFailure(reason, body?.message ?? fallback),
+                failure: new PermanentAuthFailure(reason, body?.message ?? fallback, reason === 'SESSION_REVOKED' && typeof body?.reason === 'string'
+                    ? body.reason
+                    : undefined),
             };
         }
         // Unknown-shape 401 (no code, or a code we don't recognise). This is NOT a

package/dist/node_modules/@skrr-ai/auth-core/dist/esm/sessionRevocation.d.ts

@@ -0,0 +1,177 @@
+/**
+ * Why a session was signed out, and what the person should do next (OSK-16941).
+ *
+ * ## Why this file exists
+ *
+ * The server always knew why it refused a session: `requireJwtAuth` answers
+ * `401 SESSION_REVOKED` with a `reason` for an inactive account, an account-wide
+ * revocation, a password change and a per-session sign-out. Nothing passed it
+ * on. The CLI dropped the field, the web client folded every unrecognised code
+ * into "your saved credentials are no longer valid", and a refresh refused for a
+ * revoked session answered with no code at all. A person signed out with no
+ * explanation reasonably concludes their account was stolen.
+ *
+ * So the vocabulary lives here, once, beside the one function that turns a
+ * reason into words: the API writes these codes, the web login page, the desktop
+ * banner, the desktop main process (OS notification and tray) and the CLI all
+ * render them through `describeSessionRevocation`.
+ *
+ * ## Why auth-core, behind its own subpath
+ *
+ * It was declared in `@skrr-ai/data-provider`, which the Electron main process
+ * does not (and should not) depend on — so main kept printing the server's raw
+ * message in the OS notification and the tray. auth-core is already the
+ * package that LATCHES the reason (`refresh.ts` writes `revocationReason` into
+ * `needs-reauth.json`), and every desktop, daemon and CLI process already
+ * depends on it. This module imports nothing, so the
+ * `@skrr-ai/auth-core/session-revocation` subpath is safe in a browser, React
+ * Native and Node alike, the same way `first-party-harness` is.
+ * `@skrr-ai/data-provider` re-exports it unchanged: there is still exactly one
+ * declaration of the vocabulary and one copy of its words.
+ *
+ * ## Three closed lists
+ *
+ * - `SESSION_REVOCATION_REASONS` — what a refused CLIENT is told. Wire values;
+ *   the 401 body's `reason` field. The account-state members keep the spelling
+ *   `requireJwtAuth` already sent (`banned`, `pending_deletion`, ...), so a
+ *   client that already switched on them keeps working.
+ * - `SESSION_REVOCATION_CAUSES` — what HAPPENED, recorded in Security activity
+ *   when sessions are revoked. Each cause names its trigger and the reason the
+ *   signed-out client is told.
+ * - `SESSION_REVOCATION_TRIGGERS` — who or what did it.
+ *
+ * ## Unknown is a member, and it is never hidden
+ *
+ * Each list carries an explicit `unknown`. A missing, empty or unrecognised
+ * value normalizes to it, and its copy says plainly that we could not tell why.
+ * It is never folded into the nearest reassuring reading: "Everything reads
+ * healthy and the thing is unusable" (root CLAUDE.md) is exactly what an
+ * optimistic default here would produce.
+ *
+ * Copy avoids contractions in code strings so a terminal and a source file read
+ * them the same; the web reads the localized keys instead.
+ */
+/**
+ * The CLI binary the `cli` surface names when the caller passes no `bin`. A
+ * literal because this module imports nothing; `@skrr-ai/data-provider`'s
+ * `sessionRevocation.spec` asserts it equals `BRAND_NAME`, so the two cannot
+ * drift.
+ */
+export declare const SESSION_REVOCATION_DEFAULT_BIN: "skrr";
+export declare const SESSION_REVOCATION_REASONS: readonly ["password_change", "sessions_revoked", "logged_out", "session_limit", "sign_in_method_removed", "security_check", "machine_removed", "banned", "disabled", "deleted", "pending_deletion", "unknown"];
+export type SessionRevocationReason = (typeof SESSION_REVOCATION_REASONS)[number];
+export declare const SESSION_REVOCATION_UNKNOWN: "unknown";
+/**
+ * The login-page query parameter that carries a revocation reason across the
+ * sign-out redirect (`/login?reason=SESSION_REVOKED&revocation=password_change`).
+ * `reason` keeps the refusal CODE it always carried, so a login page that
+ * predates this still says something.
+ */
+export declare const SESSION_REVOCATION_QUERY_PARAM: "revocation";
+export declare function isSessionRevocationReason(value: unknown): value is SessionRevocationReason;
+/**
+ * The canonical reason for any value a server or a URL handed us. Anything not
+ * in the vocabulary is `unknown` — never a guess.
+ */
+export declare function normalizeSessionRevocationReason(value: unknown): SessionRevocationReason;
+/**
+ * Refusal codes that end a session WITHOUT revoking it, each of which a surface
+ * explains in its own sentence (expired, no longer valid). Every other code a
+ * refusal latch can carry is read as a revocation.
+ */
+export declare const NON_REVOCATION_REFUSAL_CODES: readonly ["REFRESH_EXPIRED", "TOKEN_EXPIRED", "REFRESH_INVALID", "TOKEN_INVALID"];
+export type NonRevocationRefusalCode = (typeof NON_REVOCATION_REFUSAL_CODES)[number];
+export declare function isNonRevocationRefusalCode(value: unknown): value is NonRevocationRefusalCode;
+/**
+ * The revocation reason a refusal names — from a refusal CODE (`SESSION_REVOKED`,
+ * `REFRESH_REUSED`, ...) and the revocation reason that travelled beside it —
+ * or `null` when the code is one of `NON_REVOCATION_REFUSAL_CODES`.
+ *
+ * - A revocation reason, when present, always wins.
+ * - `SESSION_REVOKED` with no reason beside it IS a revocation whose reason we
+ *   do not know, so it is `unknown`.
+ * - `REFRESH_REUSED` is the refresh-family burn, i.e. a security check.
+ * - Any other code, including none at all, is `unknown`: "we could not tell
+ *   why", never a guess.
+ *
+ * Shared by the web banner and the desktop main process so the two read one
+ * latch the same way.
+ */
+export declare function sessionRevocationForRefusal(code: string | undefined | null, revocation?: string | undefined | null): SessionRevocationReason | null;
+export declare const SESSION_REVOCATION_NEXT_STEPS: readonly ["sign_in", "sign_in_and_review", "cancel_deletion", "contact_support", "use_another_account"];
+export type SessionRevocationNextStep = (typeof SESSION_REVOCATION_NEXT_STEPS)[number];
+/** Where the copy is shown: the CLI names its command, an app names a screen. */
+export type SessionRevocationSurface = 'cli' | 'app';
+/** Translation keys the web client renders; English values mirror the copy above. */
+export interface SessionRevocationKeys {
+    title: `com_auth_revoked_${SessionRevocationReason}_title`;
+    detail: `com_auth_revoked_${SessionRevocationReason}_detail`;
+    nextStep: `com_auth_revoked_next_${SessionRevocationNextStep}`;
+}
+export interface SessionRevocationDescription {
+    /** The canonical reason; `unknown` for anything unrecognised or missing. */
+    reason: SessionRevocationReason;
+    /**
+     * The value as received when it was NOT a recognised reason (and not empty),
+     * so a surface can show the code it could not explain instead of losing it.
+     */
+    unrecognized: string | null;
+    title: string;
+    detail: string;
+    nextStep: SessionRevocationNextStep;
+    /** The next step as a sentence for the requested surface. */
+    nextStepText: string;
+    /** Whether the person should look at Security activity to explain it. */
+    reviewSecurityActivity: boolean;
+    keys: SessionRevocationKeys;
+}
+/**
+ * THE copy for a revoked session. Never throws, whatever it is given: the server
+ * can ship a reason before a client knows it, and that case must still say
+ * something true ("we could not tell why"), not nothing.
+ */
+export declare function describeSessionRevocation(value: unknown, { surface, bin, }?: {
+    surface?: SessionRevocationSurface;
+    bin?: string;
+}): SessionRevocationDescription;
+/** One line for a terminal or a notification: title, detail and next step. */
+export declare function formatSessionRevocation(value: unknown, options?: {
+    surface?: SessionRevocationSurface;
+    bin?: string;
+}): string;
+export declare const SESSION_REVOCATION_TRIGGERS: readonly ["account_owner", "administrator", "security_system", "external_provider", "account_lifecycle", "unknown"];
+export type SessionRevocationTrigger = (typeof SESSION_REVOCATION_TRIGGERS)[number];
+export declare const SESSION_REVOCATION_CAUSES: readonly ["password_change", "password_reset", "sign_out_everywhere", "sign_out_other_sessions", "session_signed_out", "two_factor_change", "email_change", "email_change_reverted", "account_recovery", "reported_not_me", "sign_in_method_removed", "machine_removed", "oauth_app_revoked", "session_limit", "suspicious_reuse", "administrator", "account_suspended", "external_provider", "account_deletion_scheduled", "account_superseded", "unverified_account_cleanup", "unknown"];
+export type SessionRevocationCause = (typeof SESSION_REVOCATION_CAUSES)[number];
+interface CauseFacts {
+    trigger: SessionRevocationTrigger;
+    /** What a client signed out by this cause is told. */
+    reason: SessionRevocationReason;
+    /** English sentence for the Security activity row. */
+    copy: string;
+}
+export declare const SESSION_REVOCATION_CAUSE_FACTS: Readonly<Record<SessionRevocationCause, CauseFacts>>;
+export declare const SESSION_REVOCATION_TRIGGER_COPY: Readonly<Record<SessionRevocationTrigger, string>>;
+export declare function normalizeSessionRevocationCause(value: unknown): SessionRevocationCause;
+export declare function normalizeSessionRevocationTrigger(value: unknown): SessionRevocationTrigger;
+export interface SessionRevocationActivityDescription {
+    cause: SessionRevocationCause;
+    trigger: SessionRevocationTrigger;
+    reason: SessionRevocationReason;
+    causeText: string;
+    triggerText: string;
+    keys: {
+        cause: `com_nav_security_activity_revocation_cause_${SessionRevocationCause}`;
+        trigger: `com_nav_security_activity_revocation_trigger_${SessionRevocationTrigger}`;
+    };
+}
+/**
+ * How Security activity explains one recorded revocation. A stored trigger wins
+ * over the cause's usual one (an administrator can change a password too); an
+ * unreadable one is `unknown`, never the cause's default.
+ */
+export declare function describeSessionRevocationActivity(record: {
+    cause?: unknown;
+    trigger?: unknown;
+}): SessionRevocationActivityDescription;
+export {};