@skrr-ai/cli 0.1.80 → 0.1.81

package/dist/commands/tokens/create.js

@@ -0,0 +1,136 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const core_1 = require("@oclif/core");
+const data_provider_1 = require("@skrr-ai/data-provider");
+const base_command_1 = require("../../base-command");
+const access_tokens_1 = require("../../lib/access-tokens");
+const api_fetch_1 = require("../../lib/api-fetch");
+const prompt_1 = require("../../lib/prompt");
+/**
+ * `skrr tokens create` — mint a personal access token (`osk_pat_*`, OSK-13208)
+ * for CI. The secret is printed EXACTLY ONCE.
+ *
+ * Creating one needs a sign-in session (a token cannot mint a token) and, for
+ * an account with two-factor authentication, a fresh authenticator code from
+ * that session. `--otp` / `--backup-code` supply it up front; at a terminal the
+ * command asks for it when the server does.
+ */
+class TokensCreate extends base_command_1.BaseCommand {
+    static description = 'Create a personal access token for CI (use it as SKRR_TOKEN). The secret is shown once and never again.';
+    static examples = [
+        '<%= config.bin %> tokens create github-actions',
+        '<%= config.bin %> tokens create deploy --scope write --expires-in-days 30',
+        '<%= config.bin %> tokens create ci --scope write --otp 123456 --json',
+    ];
+    static args = {
+        name: core_1.Args.string({
+            description: 'Label for the token, e.g. the CI secret it will live in (also --name)',
+            ignoreStdin: true,
+        }),
+    };
+    static flags = {
+        name: core_1.Flags.string({ description: 'Label for the token (1-64 chars)' }),
+        scope: core_1.Flags.string({
+            description: 'read: GET requests only. write: everything the CLI can do as you, except sign-in, credential, account-deletion, admin and payment actions',
+            options: ['read', 'write'],
+            default: 'read',
+        }),
+        'expires-in-days': core_1.Flags.integer({
+            description: 'Days until the token expires (1-365)',
+            min: 1,
+            max: 365,
+            default: 90,
+        }),
+        otp: core_1.Flags.string({
+            description: 'Current code from your authenticator app, if your account uses two-factor',
+            exclusive: ['backup-code'],
+        }),
+        'backup-code': core_1.Flags.string({
+            description: 'One of your unused backup codes (it is spent)',
+            exclusive: ['otp'],
+        }),
+        json: core_1.Flags.boolean({ description: 'Output as JSON (includes the secret)' }),
+    };
+    async run() {
+        this.requireAuth();
+        const { args, flags } = await this.parse(TokensCreate);
+        const name = flags.name || args.name;
+        if (!name) {
+            this.error('A name is required — pass it positionally or with --name.', { exit: 1 });
+        }
+        const input = {
+            name,
+            scopes: [flags.scope],
+            expiresInDays: flags['expires-in-days'],
+        };
+        let code = null;
+        if (flags.otp)
+            code = { token: flags.otp.trim() };
+        else if (flags['backup-code'])
+            code = { backupCode: flags['backup-code'].trim() };
+        if (code)
+            await this.verify(code);
+        let created;
+        try {
+            created = await (0, access_tokens_1.createAccessToken)(input);
+        }
+        catch (err) {
+            const challenge = stepUpChallenge(err);
+            if (!challenge)
+                return this.handleApiError(err);
+            if (code || challenge.reason !== 'no_recent_step_up') {
+                return this.refuseStepUp(challenge);
+            }
+            if (!process.stdin.isTTY) {
+                return this.refuseStepUp(challenge);
+            }
+            const entered = (await (0, prompt_1.prompt)('Code from your authenticator app: ')).trim();
+            code = { token: entered };
+            await this.verify(code);
+            try {
+                created = await (0, access_tokens_1.createAccessToken)(input);
+            }
+            catch (retryErr) {
+                return this.handleApiError(retryErr);
+            }
+        }
+        if (flags.json) {
+            this.log(JSON.stringify(created, null, 2));
+            return;
+        }
+        const t = created.accessToken;
+        this.log('');
+        this.log(`  ${created.token}`);
+        this.log('');
+        this.log('This is the only time the token will be displayed. Store it as a CI secret now.');
+        this.log(`Use it as:  SKRR_TOKEN=<token> ${this.config.bin} <command>`);
+        this.log('');
+        this.log(`  id       ${t.id}`);
+        this.log(`  name     ${t.name}`);
+        this.log(`  scopes   ${t.scopes.join(', ')}`);
+        this.log(`  expires  ${t.expiresAt ?? '(unknown)'}`);
+    }
+    async verify(code) {
+        try {
+            await data_provider_1.dataService.verifyStepUp({ purpose: data_provider_1.ACCESS_TOKEN_CREATE_STEP_UP_PURPOSE, ...code });
+        }
+        catch (err) {
+            this.handleApiError(err);
+        }
+    }
+    refuseStepUp(challenge) {
+        const bin = this.config.bin;
+        const messages = {
+            credential_not_session_bound: `Creating an access token needs a sign-in session, and this credential is not one (an access token cannot create another). Run \`${bin} login\` and try again. Nothing changed.`,
+            two_factor_not_enabled: 'Creating an access token needs two-factor authentication on this account. Turn it on in the web app, then try again. Nothing changed.',
+            no_recent_step_up: 'Creating an access token needs a fresh code from your authenticator app. Run this command again with --otp <code> (or --backup-code <code>). Nothing changed.',
+        };
+        this.error(messages[challenge.reason], { code: 'STEP_UP_REQUIRED', exit: 2 });
+    }
+}
+exports.default = TokensCreate;
+function stepUpChallenge(err) {
+    if (!(err instanceof api_fetch_1.ApiFetchError) || err.status !== 403)
+        return null;
+    return (0, data_provider_1.stepUpChallengeFromError)(err);
+}

package/dist/commands/tokens/list.d.ts

@@ -0,0 +1,11 @@
+import { BaseCommand } from '../../base-command';
+/** `skrr tokens list` — your personal access tokens (never their secrets). */
+export default class TokensList extends BaseCommand {
+    static description: string;
+    static examples: string[];
+    static flags: {
+        all: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+        json: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+    };
+    run(): Promise<void>;
+}

package/dist/commands/tokens/list.js

@@ -0,0 +1,53 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const core_1 = require("@oclif/core");
+const base_command_1 = require("../../base-command");
+const access_tokens_1 = require("../../lib/access-tokens");
+/** `skrr tokens list` — your personal access tokens (never their secrets). */
+class TokensList extends base_command_1.BaseCommand {
+    static description = 'List your personal access tokens (secrets are never shown again)';
+    static examples = [
+        '<%= config.bin %> tokens list',
+        '<%= config.bin %> tokens list --all',
+        '<%= config.bin %> tokens list --json',
+    ];
+    static flags = {
+        all: core_1.Flags.boolean({ description: 'Include revoked and expired tokens' }),
+        json: core_1.Flags.boolean({ description: 'Output as JSON' }),
+    };
+    async run() {
+        this.requireAuth();
+        const { flags } = await this.parse(TokensList);
+        let tokens;
+        try {
+            tokens = await (0, access_tokens_1.listAccessTokens)();
+        }
+        catch (err) {
+            this.handleApiError(err);
+            return;
+        }
+        const shown = flags.all ? tokens : tokens.filter((t) => t.state === 'active');
+        if (flags.json) {
+            this.log(JSON.stringify({ accessTokens: shown }, null, 2));
+            return;
+        }
+        if (shown.length === 0) {
+            this.log(flags.all || tokens.length === 0
+                ? `No access tokens. Create one with \`${this.config.bin} tokens create <name>\`.`
+                : `No active access tokens (${tokens.length} revoked or expired; --all shows them).`);
+            return;
+        }
+        for (const t of shown) {
+            this.log([
+                t.id,
+                t.name,
+                `…${t.lastFour}`,
+                t.scopes.join('+'),
+                (0, access_tokens_1.describeAccessTokenState)(t),
+                `expires ${t.expiresAt ?? '?'}`,
+                `last used ${t.lastUsedAt ?? 'never'}`,
+            ].join('  '));
+        }
+    }
+}
+exports.default = TokensList;

package/dist/commands/tokens/revoke.d.ts

@@ -0,0 +1,14 @@
+import { BaseCommand } from '../../base-command';
+/** `skrr tokens revoke <id>` — irreversible; a revoked token is replaced, never re-enabled. */
+export default class TokensRevoke extends BaseCommand {
+    static description: string;
+    static examples: string[];
+    static args: {
+        id: import("@oclif/core/lib/interfaces").Arg<string, Record<string, unknown>>;
+    };
+    static flags: {
+        compromised: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+        json: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+    };
+    run(): Promise<void>;
+}

package/dist/commands/tokens/revoke.js

@@ -0,0 +1,42 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const core_1 = require("@oclif/core");
+const base_command_1 = require("../../base-command");
+const access_tokens_1 = require("../../lib/access-tokens");
+/** `skrr tokens revoke <id>` — irreversible; a revoked token is replaced, never re-enabled. */
+class TokensRevoke extends base_command_1.BaseCommand {
+    static description = 'Revoke a personal access token. Anything still presenting it is refused on its next request.';
+    static examples = [
+        '<%= config.bin %> tokens revoke <token-id>',
+        '<%= config.bin %> tokens revoke <token-id> --compromised',
+    ];
+    static args = {
+        id: core_1.Args.string({
+            description: 'Token id (from `tokens list`)',
+            required: true,
+            ignoreStdin: true,
+        }),
+    };
+    static flags = {
+        compromised: core_1.Flags.boolean({ description: 'Record that the token leaked' }),
+        json: core_1.Flags.boolean({ description: 'Output as JSON' }),
+    };
+    async run() {
+        this.requireAuth();
+        const { args, flags } = await this.parse(TokensRevoke);
+        try {
+            const res = await (0, access_tokens_1.revokeAccessToken)(args.id, { compromised: flags.compromised });
+            if (flags.json) {
+                this.log(JSON.stringify(res, null, 2));
+                return;
+            }
+            this.log(res.alreadyRevoked
+                ? `${args.id} was already revoked.`
+                : `Revoked ${args.id}. Anything still presenting it will now be refused.`);
+        }
+        catch (err) {
+            this.handleApiError(err);
+        }
+    }
+}
+exports.default = TokensRevoke;

package/dist/lib/access-tokens.d.ts

@@ -0,0 +1,59 @@
+/**
+ * access-tokens.ts — request client for `/api/user/access-tokens`, the
+ * personal access tokens (`osk_pat_*`, OSK-13208) behind `skrr tokens`.
+ *
+ * A personal access token is how CI runs `skrr` AS a person: set it as
+ * `SKRR_TOKEN` and every command authenticates with it, never refreshing,
+ * until it expires or is revoked. It is not `skrr create-token` (an `osk_ci_`
+ * DAEMON bootstrap token), not `skrr token mint` (a rotating refresh bundle),
+ * and not `skrr api-keys` (Space-scoped Managed-Agents keys).
+ *
+ * Path literals are inline on purpose: `domain-api-parity` resolves a command
+ * to an endpoint by reading these strings.
+ */
+/** A token as the API returns it. The secret is never part of this shape. */
+export interface AccessToken {
+    id: string;
+    name: string;
+    lastFour: string;
+    scopes: string[];
+    /** Derived server-side: natural expiry is not stored as a revocation. */
+    state: 'active' | 'expired' | 'revoked';
+    createdAt: string | null;
+    expiresAt: string | null;
+    lastUsedAt: string | null;
+    revokedAt: string | null;
+    revokedReason: string | null;
+    createdFromIp: string | null;
+    createdFromUserAgent: string | null;
+}
+/** The create response. `token` is shown exactly once and never again. */
+export interface AccessTokenCreated {
+    token: string;
+    accessToken: AccessToken;
+}
+export interface CreateAccessTokenInput {
+    name: string;
+    scopes?: string[];
+    expiresInDays?: number;
+}
+/**
+ * The words for each stored revocation reason. Every member of the schema's
+ * `revokedReason` enum appears here, so the list shows WHY a token died —
+ * "revoked" alone cannot tell a deliberate revoke from a sign-out sweep.
+ */
+export declare const ACCESS_TOKEN_REVOKED_REASON_LABELS: Record<string, string>;
+export declare function createAccessToken(input: CreateAccessTokenInput): Promise<AccessTokenCreated>;
+/** Every token the caller owns, newest first, including revoked and expired rows. */
+export declare function listAccessTokens(): Promise<AccessToken[]>;
+export interface RevokeAccessTokenResult {
+    revoked: boolean;
+    alreadyRevoked: boolean;
+    accessToken?: AccessToken;
+}
+/** Revoke one token. Irreversible: a revoked token is replaced, never re-enabled. */
+export declare function revokeAccessToken(id: string, opts?: {
+    compromised?: boolean;
+}): Promise<RevokeAccessTokenResult>;
+/** One-line status for a listed token. */
+export declare function describeAccessTokenState(token: AccessToken): string;

package/dist/lib/access-tokens.js

@@ -0,0 +1,50 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ACCESS_TOKEN_REVOKED_REASON_LABELS = void 0;
+exports.createAccessToken = createAccessToken;
+exports.listAccessTokens = listAccessTokens;
+exports.revokeAccessToken = revokeAccessToken;
+exports.describeAccessTokenState = describeAccessTokenState;
+const api_fetch_1 = require("./api-fetch");
+/**
+ * The words for each stored revocation reason. Every member of the schema's
+ * `revokedReason` enum appears here, so the list shows WHY a token died —
+ * "revoked" alone cannot tell a deliberate revoke from a sign-out sweep.
+ */
+exports.ACCESS_TOKEN_REVOKED_REASON_LABELS = {
+    user: 'revoked by you',
+    sign_out_everywhere: 'revoked by sign-out everywhere / password or 2FA change',
+    admin: 'revoked by an administrator',
+    compromised: 'revoked as compromised',
+};
+async function createAccessToken(input) {
+    return (0, api_fetch_1.apiFetch)('/api/user/access-tokens', {
+        method: 'POST',
+        body: {
+            name: input.name,
+            ...(input.scopes ? { scopes: input.scopes } : {}),
+            ...(input.expiresInDays !== undefined ? { expiresInDays: input.expiresInDays } : {}),
+        },
+    });
+}
+/** Every token the caller owns, newest first, including revoked and expired rows. */
+async function listAccessTokens() {
+    const res = await (0, api_fetch_1.apiFetch)('/api/user/access-tokens');
+    return Array.isArray(res?.accessTokens) ? res.accessTokens : [];
+}
+/** Revoke one token. Irreversible: a revoked token is replaced, never re-enabled. */
+async function revokeAccessToken(id, opts = {}) {
+    return (0, api_fetch_1.apiFetch)(`/api/user/access-tokens/${encodeURIComponent(id)}`, {
+        method: 'DELETE',
+        ...(opts.compromised ? { body: { reason: 'compromised' } } : {}),
+    });
+}
+/** One-line status for a listed token. */
+function describeAccessTokenState(token) {
+    if (token.state === 'revoked') {
+        return exports.ACCESS_TOKEN_REVOKED_REASON_LABELS[token.revokedReason ?? ''] ?? 'revoked';
+    }
+    if (token.state === 'expired')
+        return 'expired';
+    return 'active';
+}

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

@@ -36,6 +36,12 @@ export declare function plainCredentialEnvelopeWarning(args: readonly unknown[])
  * own when a local daemon can hand a credential over.
  */
 export declare const CREDENTIAL_KEY_CHANGED_NOTICE: string;
+/**
+ * The one line an unreadable device key prints when no credential-key change
+ * explains it. The CLI never enrolls or requires a device key (OSK-12063), so
+ * this degrades a proof, not access — say exactly that.
+ */
+export declare const DEVICE_KEY_RECOVERY_REQUIRED_NOTICE: string;
 export declare function createCredentialEnvelopeWarningPresenter(): (args: readonly unknown[]) => string | null;
 type DedicatedGenerationPreparationOptions = {
     machineUuid?: string;

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

@@ -3,7 +3,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.CliCredentialInitializationError = exports.CREDENTIAL_KEY_CHANGED_NOTICE = void 0;
+exports.CliCredentialInitializationError = exports.DEVICE_KEY_RECOVERY_REQUIRED_NOTICE = exports.CREDENTIAL_KEY_CHANGED_NOTICE = void 0;
 exports.plainCredentialEnvelopeWarning = plainCredentialEnvelopeWarning;
 exports.createCredentialEnvelopeWarningPresenter = createCredentialEnvelopeWarningPresenter;
 exports.prepareDedicatedRuntimeAuthGeneration = prepareDedicatedRuntimeAuthGeneration;
@@ -108,6 +108,20 @@ exports.CREDENTIAL_KEY_CHANGED_NOTICE = "note: this machine's credential key cha
  */
 /** auth-core's device-identity warning for a private key it could not open. */
 const DEVICE_KEY_DECRYPT_FAILED = '[deviceIdentity] private_key_decrypt_failed';
+/**
+ * auth-core's device-identity warning for a stored key it will NOT replace on
+ * ordinary boot (`b5e683280b`): minting a new key here would make the next
+ * refresh sign with a key the server never pinned. Only an explicit login with
+ * `recoverUnreadable` replaces it.
+ */
+const DEVICE_KEY_RECOVERY_REQUIRED = '[deviceIdentity] recovery_required';
+/**
+ * The one line an unreadable device key prints when no credential-key change
+ * explains it. The CLI never enrolls or requires a device key (OSK-12063), so
+ * this degrades a proof, not access — say exactly that.
+ */
+exports.DEVICE_KEY_RECOVERY_REQUIRED_NOTICE = "warning: this machine's stored device key could not be read, so skrr sends requests " +
+    'without a device proof until the local daemon signs in again. (DEBUG=1 shows the underlying error.)';
 function createCredentialEnvelopeWarningPresenter() {
     let keyChanged = false;
     return (args) => {
@@ -133,12 +147,20 @@ function createCredentialEnvelopeWarningPresenter() {
         if (keyChanged && event === 'cred_envelope.read.decrypt_failed')
             return '';
         // The device private key is one of those values: auth-core's device
-        // identity loads it next, cannot open it, and mints a new keypair. It
-        // logs that through its own `[deviceIdentity]` prefix, which reached the
-        // terminal as a raw `[auth-core warn]` line right under the notice. The
-        // notice covers it; without a key change it is a real fault and prints.
-        if (keyChanged && message === DEVICE_KEY_DECRYPT_FAILED)
+        // identity loads it next and cannot open it. Since `b5e683280b` it does
+        // NOT mint a replacement on ordinary boot — it parks in
+        // `recovery_required` until an explicit login recovers it. Both warnings
+        // come through the `[deviceIdentity]` prefix and reached the terminal as
+        // raw `[auth-core warn]` lines right under the notice, which already says
+        // the old key is gone and what replaces it.
+        if (keyChanged &&
+            (message === DEVICE_KEY_DECRYPT_FAILED || message === DEVICE_KEY_RECOVERY_REQUIRED)) {
             return '';
+        }
+        // Without a key change an unreadable device key is a real fault: one
+        // plain line instead of an object dump.
+        if (message === DEVICE_KEY_RECOVERY_REQUIRED)
+            return exports.DEVICE_KEY_RECOVERY_REQUIRED_NOTICE;
         return plainCredentialEnvelopeWarning(args);
     };
 }

package/dist/lib/credential-resolver.d.ts

@@ -5,7 +5,7 @@
  * CLI-appropriate backends. The resolver walks the published chain:
  *
  *   1. flag         — --token <jwt> (debugging; BaseCommand parses)
- *   2. env-token    — OVERSKY_TOKEN (CI / static; kind='ci' detected)
+ *   2. env-token    — OVERSKY_TOKEN, then SKRR_TOKEN (CI / static; kind 'ci' or 'pat' detected)
  *   3. auth-helper  — OVERSKY_AUTH_HELPER script output
  *   4. fd-handoff   — N/A for CLI (skipped; no parent fd)
  *   5. keychain     — ai.skrr.cli.<profile>

package/dist/lib/credential-resolver.js

@@ -12,7 +12,7 @@ exports.formatCredentialSource = formatCredentialSource;
  * CLI-appropriate backends. The resolver walks the published chain:
  *
  *   1. flag         — --token <jwt> (debugging; BaseCommand parses)
- *   2. env-token    — OVERSKY_TOKEN (CI / static; kind='ci' detected)
+ *   2. env-token    — OVERSKY_TOKEN, then SKRR_TOKEN (CI / static; kind 'ci' or 'pat' detected)
  *   3. auth-helper  — OVERSKY_AUTH_HELPER script output
  *   4. fd-handoff   — N/A for CLI (skipped; no parent fd)
  *   5. keychain     — ai.skrr.cli.<profile>
@@ -78,6 +78,9 @@ async function resolveCredential(opts = {}) {
         flagToken: opts.flagToken,
         bareMode,
         storeMode,
+        // SKRR_TOKEN is the name the CI recipe uses (OSK-13208); OVERSKY_TOKEN still
+        // wins when both are set, as in the config overlay (config.ts).
+        envTokenNames: ['OVERSKY_TOKEN', 'SKRR_TOKEN'],
         // CLI never has an interactive slot — users run `skrr login` explicitly.
         isHeadless: () => true,
         // Stored credentials are only usable against the origin that issued
@@ -160,7 +163,10 @@ function formatCredentialSource(source) {
         case 'flag':
             return 'CLI --token flag';
         case 'env-token':
-            return 'OVERSKY_TOKEN';
+            // Name the variable that actually supplied it (OVERSKY_TOKEN wins).
+            return !process.env.OVERSKY_TOKEN?.trim() && process.env.SKRR_TOKEN?.trim()
+                ? 'SKRR_TOKEN'
+                : 'OVERSKY_TOKEN';
         case 'auth-helper':
             return 'OVERSKY_AUTH_HELPER';
         case 'fd-handoff':

package/dist/lib/daemonBroker.d.ts

@@ -1,5 +1,5 @@
 /**
- * daemonBroker.ts — Sky CLI client for the local `oversky` daemon's
+ * daemonBroker.ts — skrr CLI client for the local `skrrd` daemon's
  * cli-handoff endpoint.
  *
  * When the daemon is already authenticated for the user on this machine,
@@ -199,7 +199,7 @@ export interface DaemonBrokerOptions {
     /** Stable per-machine cliId the CLI wants the new refresh row bound to. */
     cliId: string;
     /**
-     * The Sky CLI's currently-configured baseURL (e.g. `https://oversky.ai`).
+     * The skrr CLI's currently-configured baseURL (e.g. `https://skrr.ai`).
      * Two roles:
      *   1. Pre-flight check vs `bootstrap.serverUrl` — when they don't
      *      match, we refuse to call the daemon so we never mint a token
@@ -461,6 +461,17 @@ export interface MaybeAutoBrokerOptions {
      * everywhere else. Production callers omit it and behave exactly as before.
      */
     bootstrapPathOverride?: string;
+    /**
+     * The profile whose daemon may be borrowed. Defaults to the active profile.
+     *
+     * A silent hand-off must never cross profiles (OSK-13257). The `default`
+     * candidate list falls through to any running daemon, and every daemon is
+     * signed in as whoever started it — so `--profile buyer`, with its own
+     * session refused, used to run as the machine owner after one stderr line.
+     * A named profile now borrows only a daemon started under that same
+     * profile, and otherwise reports NOT_SIGNED_IN for the profile it was given.
+     */
+    profile?: string;
 }
 export interface MaybeAutoBrokerResult {
     /**

package/dist/lib/daemonBroker.js

@@ -1,6 +1,6 @@
 "use strict";
 /**
- * daemonBroker.ts — Sky CLI client for the local `oversky` daemon's
+ * daemonBroker.ts — skrr CLI client for the local `skrrd` daemon's
  * cli-handoff endpoint.
  *
  * When the daemon is already authenticated for the user on this machine,
@@ -101,6 +101,7 @@ const auth_storage_1 = require("./auth-storage");
 const config_1 = require("./config");
 const cli_identity_1 = require("./cli-identity");
 const daemonRestartWait_1 = require("./daemonRestartWait");
+const keychain_1 = require("./keychain");
 const REQUEST_TIMEOUT_MS = 20_000;
 /**
  * Normalize a base URL for equality comparison. Mirrors the daemon-side
@@ -247,9 +248,9 @@ exports.HOSTED_MACHINE_CLI_HANDOFF_DESCRIPTOR = '/run/skrr-hosted-machine/cli-ha
 /** Where the cli-handoff broker looks, in order. */
 function resolveCliHandoffCandidatePaths(profile = 'default') {
     const candidates = resolveBootstrapCandidatePaths(profile);
-    // Any profile: a guest runs one daemon, and the auto-broker resolves the
-    // default profile regardless of `--profile`, so a narrower condition here would
-    // only describe behaviour production never reaches.
+    // Any profile: a guest runs one daemon holding the one account the guest
+    // serves, so every profile on it is that account. On a laptop a named profile
+    // reaches only its own island file above (OSK-13257).
     if (process.platform === 'linux') {
         candidates.push(exports.DEDICATED_RUNTIME_CLI_HANDOFF_DESCRIPTOR, exports.HOSTED_MACHINE_CLI_HANDOFF_DESCRIPTOR);
     }
@@ -1252,6 +1253,7 @@ async function maybeAutoBroker(opts) {
         // family mint remains the fallback for v1 descriptors and the redeem
         // path for explicit `skrr login`.
         preferHandoffMode: 'access_token',
+        profile: opts.profile ?? (0, keychain_1.getActiveProfile)(),
         ...(opts.bootstrapPathOverride ? { bootstrapPathOverride: opts.bootstrapPathOverride } : {}),
     });
     return {

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

@@ -104,6 +104,10 @@ export declare function installSshConfigBlock(home?: string): {
     changed: boolean;
 };
 export interface SshStartAck {
+    failed?: boolean;
+    closing?: boolean;
+    closed?: boolean;
+    retryable?: boolean;
     channelId?: string;
     ok?: boolean;
     error?: string;
@@ -113,6 +117,9 @@ export interface SshStartAck {
         key: string;
     }[];
     receiverAckV1?: boolean;
+    resumeV2?: boolean;
+    epoch?: string;
+    generation?: number;
 }
 export interface SshProxyOptions {
     baseURL: string;
@@ -123,6 +130,8 @@ export interface SshProxyOptions {
     /** Diagnostics; never stdout — ssh reads stdout as protocol bytes. */
     errorOutput: NodeJS.WritableStream;
     ttlSeconds?: number;
+    getToken?: () => Promise<string>;
+    recoveryMs?: number;
     /** Injected for tests. */
     connect?: (url: string, opts: Parameters<typeof io>[1]) => Socket;
     /** Injected for tests. */