@skrr-ai/cli 0.1.94 → 0.1.96

package/dist/lib/first-party-harness-remote-update.js

@@ -0,0 +1,242 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const core_1 = require("@oclif/core");
+const auth_core_1 = require("@skrr-ai/auth-core");
+const base_command_1 = require("../base-command");
+const cli_installers_1 = require("./cli-installers");
+const daemon_target_1 = require("./daemon-target");
+const first_party_harness_1 = require("./first-party-harness");
+/**
+ * `skrr code update` — pull the engine's signed release down through the daemon.
+ *
+ * ── Why this command exists ────────────────────────────────────────────────
+ *
+ * The update verb has been API-exposed and daemon-implemented since OSK-10096 —
+ * `POST /api/daemons/:id/cli-installers/:provider/update` re-fetches the signed
+ * manifest and installs whatever the channel points at. But the only CLI that
+ * reached it was `skrr harnesses install <provider> --update`: a flag on a
+ * command a `code` user has no reason to read. On stable that left no
+ * discoverable path at all — `code install` answered "Already installed." with
+ * no next step, and the channel moving past the installed build was invisible
+ * from the surface that owns the engine (OSK-10650).
+ *
+ * So this adds a SURFACE and no mechanism. Same route `harnesses install
+ * --update` posts, same inventory pre-check, same 504 recovery — one update
+ * path, spelled where the engine's users look.
+ */
+class CodeUpdate extends base_command_1.BaseCommand {
+    static description = `Update the ${auth_core_1.FIRST_PARTY_HARNESS.displayName} engine on this machine, through the daemon`;
+    static examples = [
+        '<%= config.bin %> code update',
+        '<%= config.bin %> code update --daemon <daemon-id>',
+        '<%= config.bin %> code update --json',
+    ];
+    static flags = {
+        daemon: core_1.Flags.string({
+            description: 'Which daemon runs the update. Defaults to this machine on a Dedicated Runtime, otherwise to the only active one; required when you have several.',
+        }),
+        wait: core_1.Flags.boolean({
+            default: true,
+            allowNo: true,
+            description: 'Follow the update job until it finishes. --no-wait returns the job id.',
+        }),
+        json: core_1.Flags.boolean({ description: 'Emit the result as JSON' }),
+    };
+    async run() {
+        const { flags } = await this.parse(CodeUpdate);
+        const daemonId = this.updateTarget(await this.resolveTarget(flags.daemon));
+        // Ask the inventory before posting: a daemon older than managed updates has
+        // no handler for the request and would leave it to time out, and an engine
+        // that updates some other way has a reason the daemon already words.
+        let inventory;
+        try {
+            inventory = await (0, cli_installers_1.listCliInstallers)(daemonId, this.resolvedCredential);
+        }
+        catch (err) {
+            this.handleApiError(err);
+        }
+        const row = (inventory.providers ?? []).find((p) => (0, auth_core_1.isFirstPartyHarnessProvider)(p.provider));
+        if (!row) {
+            this.failWithCliError({
+                message: `${auth_core_1.FIRST_PARTY_HARNESS.displayName} is not installed on ${daemonId}. ` +
+                    `Install it with \`${this.config.bin} code install\`.`,
+                code: 'NOT_INSTALLED',
+                exit: 1,
+                retryable: false,
+            });
+        }
+        if (row.updatable === undefined) {
+            this.failWithCliError({
+                message: `The daemon ${daemonId} (${inventory.daemonVersion ?? 'version not reported'}) cannot update ${auth_core_1.FIRST_PARTY_HARNESS.displayName}: it predates managed updates. ` +
+                    `Update the daemon, then run this again.`,
+                code: 'DAEMON_UPDATE_UNSUPPORTED',
+                exit: 1,
+                retryable: false,
+            });
+        }
+        if (!row.updatable) {
+            this.failWithCliError({
+                message: row.updateDisabledReason?.trim() ||
+                    `${auth_core_1.FIRST_PARTY_HARNESS.displayName}: the daemon cannot update it here.`,
+                code: 'CLI_NOT_UPDATABLE',
+                exit: 1,
+                retryable: false,
+            });
+        }
+        const start = await this.start(daemonId, flags.json === true);
+        if (!start)
+            return;
+        const jobId = start.job?.id;
+        if (!start.started || !jobId) {
+            if (flags.json) {
+                this.log(JSON.stringify({ daemonId, ...start }, null, 2));
+                return;
+            }
+            this.log(start.alreadyRunning
+                ? `${auth_core_1.FIRST_PARTY_HARNESS.displayName}: an install or update is already running (job ${start.job?.id ?? 'unknown'}).`
+                : `${auth_core_1.FIRST_PARTY_HARNESS.displayName}: ${start.provider?.updateDisabledReason?.trim() || 'the daemon started no update job.'}`);
+            return;
+        }
+        if (!flags.wait) {
+            if (flags.json) {
+                this.log(JSON.stringify({ daemonId, ...start }, null, 2));
+                return;
+            }
+            this.log(`Update started on ${daemonId} — job ${jobId}.`);
+            return;
+        }
+        if (!flags.json) {
+            this.logToStderr(`Updating ${auth_core_1.FIRST_PARTY_HARNESS.displayName} ${row.version ? `${row.version} ` : ''}on ${daemonId}…`);
+        }
+        const job = await this.follow(daemonId, jobId, flags.json === true);
+        if (!job)
+            return;
+        if (flags.json) {
+            this.log(JSON.stringify({ daemonId, job }, null, 2));
+            if (job.status !== 'succeeded')
+                process.exitCode = 1;
+            return;
+        }
+        if (job.status === 'failed') {
+            this.failWithCliError({
+                message: job.error || 'The update failed and the daemon gave no reason.',
+                code: 'UPDATE_FAILED',
+                exit: 1,
+                retryable: false,
+            });
+        }
+        this.log((0, cli_installers_1.updateOutcomeLine)(job) ??
+            `${auth_core_1.FIRST_PARTY_HARNESS.displayName} updated${job.installedVersion ? ` to ${job.installedVersion}` : ''}.`);
+    }
+    /** Which daemon the update targets, by the rule every daemon-picking command shares. */
+    async resolveTarget(explicit) {
+        try {
+            return await (0, daemon_target_1.resolveDaemonTarget)({
+                explicit,
+                local: (0, daemon_target_1.localMachine)({ baseURL: this.cliConfig?.baseURL }),
+                listActiveDaemons: () => (0, daemon_target_1.listConnectedDaemons)(this.resolvedCredential),
+            });
+        }
+        catch (err) {
+            this.handleApiError(err);
+        }
+    }
+    /**
+     * The daemon id to update through, or the refusal — identical rules to
+     * `code install`: a Dedicated Runtime's own machine is image-managed, several
+     * connected daemons get named rather than guessed.
+     */
+    updateTarget(target) {
+        if (target.kind === 'daemon')
+            return target.daemonId;
+        if (target.kind === 'this-machine') {
+            this.failWithCliError({
+                message: target.explicit
+                    ? first_party_harness_1.DEDICATED_RUNTIME_ENGINE_MESSAGE
+                    : `${first_party_harness_1.DEDICATED_RUNTIME_ENGINE_MESSAGE} This command updates the machine it runs on; ` +
+                        'to update another of your machines, name it with --daemon.',
+                code: 'DEDICATED_RUNTIME_ENGINE_SHIPS_WITH_IMAGE',
+                exit: 1,
+                retryable: false,
+            });
+        }
+        if (target.kind === 'none') {
+            this.failWithCliError({
+                message: 'No daemon is connected for this account, so nothing can perform the update. ' +
+                    `Start the background service on this computer with \`${this.config.bin} daemon start\`, then run this again.`,
+                code: 'NO_DAEMON',
+                exit: 1,
+                retryable: false,
+            });
+        }
+        const { daemons } = target;
+        const choices = daemons
+            .slice(0, 10)
+            .map((d) => `  ${d.id}  ${d.name || '—'}`)
+            .join('\n');
+        this.failWithCliError({
+            message: `${daemons.length} connected daemons — say which machine should update the engine:\n${choices}\n` +
+                `Pass one with --daemon, or see each daemon id in the DAEMON ID column of \`${this.config.bin} harnesses list\`.`,
+            code: 'AMBIGUOUS_DAEMON',
+            exit: 1,
+            retryable: false,
+        });
+    }
+    /**
+     * Start the update, and survive a gateway that cut the request off — the same
+     * 504 recovery `harnesses install --update` uses: the relay can drop the
+     * answer while the daemon runs the job it started, so on a server-side
+     * failure we ask the daemon and follow the job it reports.
+     */
+    async start(daemonId, json) {
+        try {
+            return await (0, cli_installers_1.startManagedCliUpdate)(daemonId, PROVIDER, this.resolvedCredential);
+        }
+        catch (err) {
+            const status = err.status ?? 0;
+            if (status >= 500 || status === 408) {
+                const job = await (0, cli_installers_1.jobStartedDespiteTimeout)(daemonId, PROVIDER, this.resolvedCredential);
+                if (job?.id) {
+                    if (!json) {
+                        this.logToStderr(`The request to ${daemonId} did not come back (HTTP ${status}), but the daemon started job ${job.id}. Following it.`);
+                    }
+                    return { started: true, job };
+                }
+            }
+            this.handleApiError(err);
+            return undefined;
+        }
+    }
+    /** Follow a job to its end, or report why it could not be followed (and return nothing). */
+    async follow(daemonId, jobId, json) {
+        const outcome = await (0, cli_installers_1.followManagedCliInstallJob)({
+            daemonId,
+            jobId,
+            credential: this.resolvedCredential,
+            onLogLine: json ? undefined : (line) => this.logToStderr(`  ${line}`),
+        });
+        if (outcome.kind === 'missing') {
+            this.failWithCliError({
+                message: `The daemon no longer has update job ${jobId}.`,
+                code: 'JOB_MISSING',
+                exit: 1,
+                retryable: false,
+            });
+            return undefined;
+        }
+        if (outcome.kind === 'timeout') {
+            this.failWithCliError({
+                message: `Still updating after ${Math.round(cli_installers_1.INSTALL_MAX_WAIT_MS / 60000)} minutes — the daemon is ` +
+                    `still working on job ${jobId}. Check \`${this.config.bin} code doctor\` in a while.`,
+                code: 'UPDATE_PENDING',
+                exit: 1,
+                retryable: true,
+            });
+            return undefined;
+        }
+        return outcome.job;
+    }
+}
+exports.default = CodeUpdate;
+/** Same canonical provider id `code install` posts — read from the identity module. */
+const PROVIDER = auth_core_1.FIRST_PARTY_HARNESS.provider;

package/dist/lib/first-party-harness-startup-update.d.ts

@@ -0,0 +1,26 @@
+import { checkLocalCodeUpdate, updateLocalCode, type LocalCodeUpdateStatus } from './first-party-harness-update';
+export type CodeUpdateChoice = 'update' | 'once' | 'version' | 'disable';
+export declare function configureCodeStartupChecks(enabled: boolean, env?: NodeJS.ProcessEnv): {
+    enabled: boolean;
+    preferencesPath: string;
+};
+export declare function shouldCheckCodeAtStartup(input: {
+    argv: string[];
+    env?: NodeJS.ProcessEnv;
+    stdinTTY?: boolean;
+    stdoutTTY?: boolean;
+    stderrTTY?: boolean;
+}): boolean;
+export declare function ttyCodeUpdateAsker(): (result: LocalCodeUpdateStatus) => Promise<CodeUpdateChoice>;
+/** The only caller is a new interactive TUI launch, before any broker or lease. */
+export declare function maybeOfferCodeUpdate(input: {
+    argv: string[];
+    env?: NodeJS.ProcessEnv;
+    say: (line: string) => void;
+    stdinTTY?: boolean;
+    stdoutTTY?: boolean;
+    stderrTTY?: boolean;
+    ask?: (result: LocalCodeUpdateStatus) => Promise<CodeUpdateChoice>;
+    check?: typeof checkLocalCodeUpdate;
+    update?: typeof updateLocalCode;
+}): Promise<void>;

package/dist/lib/first-party-harness-startup-update.js

@@ -0,0 +1,166 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.configureCodeStartupChecks = configureCodeStartupChecks;
+exports.shouldCheckCodeAtStartup = shouldCheckCodeAtStartup;
+exports.ttyCodeUpdateAsker = ttyCodeUpdateAsker;
+exports.maybeOfferCodeUpdate = maybeOfferCodeUpdate;
+const node_fs_1 = require("node:fs");
+const node_path_1 = __importDefault(require("node:path"));
+const node_readline_1 = __importDefault(require("node:readline"));
+const auth_core_1 = require("@skrr-ai/auth-core");
+const first_party_harness_update_1 = require("./first-party-harness-update");
+function preferencesPath(env) {
+    return node_path_1.default.join((0, auth_core_1.resolveConfigRoot)(env), 'code-update-preferences.json');
+}
+function readPreferences(env) {
+    try {
+        const value = JSON.parse((0, node_fs_1.readFileSync)(preferencesPath(env), 'utf8'));
+        if (!value || typeof value !== 'object' || Array.isArray(value))
+            return {};
+        const input = value;
+        const skipped = input.skippedVersions;
+        return {
+            ...(typeof input.promptOnStartup === 'boolean'
+                ? { promptOnStartup: input.promptOnStartup }
+                : {}),
+            ...(skipped && typeof skipped === 'object' && !Array.isArray(skipped)
+                ? {
+                    skippedVersions: Object.fromEntries(Object.entries(skipped).filter((entry) => typeof entry[1] === 'string')),
+                }
+                : {}),
+        };
+    }
+    catch {
+        return {};
+    }
+}
+function saveChoice(env, result, choice) {
+    if (choice !== 'version' && choice !== 'disable')
+        return;
+    try {
+        const previous = readPreferences(env);
+        const next = choice === 'disable'
+            ? { ...previous, promptOnStartup: false }
+            : {
+                ...previous,
+                skippedVersions: {
+                    ...previous.skippedVersions,
+                    [result.channel]: result.offeredVersion,
+                },
+            };
+        const file = preferencesPath(env);
+        (0, node_fs_1.mkdirSync)(node_path_1.default.dirname(file), { recursive: true, mode: 0o700 });
+        const staging = `${file}.${process.pid}.tmp`;
+        (0, node_fs_1.writeFileSync)(staging, JSON.stringify(next), { mode: 0o600 });
+        (0, node_fs_1.renameSync)(staging, file);
+    }
+    catch {
+        /* Update preferences must never make a session unavailable. */
+    }
+}
+function configureCodeStartupChecks(enabled, env = process.env) {
+    const file = preferencesPath(env);
+    (0, node_fs_1.mkdirSync)(node_path_1.default.dirname(file), { recursive: true, mode: 0o700 });
+    const staging = `${file}.${process.pid}.tmp`;
+    (0, node_fs_1.writeFileSync)(staging, JSON.stringify({ ...readPreferences(env), promptOnStartup: enabled }), {
+        mode: 0o600,
+    });
+    (0, node_fs_1.renameSync)(staging, file);
+    return { enabled, preferencesPath: file };
+}
+const disabled = (value) => /^(0|false|off|no|disabled)$/i.test(value ?? '');
+const enabled = (value) => /^(1|true|on|yes)$/i.test(value ?? '');
+function shouldCheckCodeAtStartup(input) {
+    const env = input.env ?? process.env;
+    if (!(input.stdinTTY ?? process.stdin.isTTY) ||
+        !(input.stdoutTTY ?? process.stdout.isTTY) ||
+        !(input.stderrTTY ?? process.stderr.isTTY))
+        return false;
+    if (enabled(env.CI) ||
+        disabled(env.SKRR_CODE_UPDATE_CHECK) ||
+        disabled(env.SKRR_CODE_UPDATE_PROMPT) ||
+        enabled(env.OVERSKY_SKIP_UPDATE_CHECK) ||
+        enabled(env.OVERSKY_NO_UPDATE_NUDGE))
+        return false;
+    if ((0, first_party_harness_update_1.localCodeUpdateOwner)(env) !== 'managed' || readPreferences(env).promptOnStartup === false)
+        return false;
+    if (input.argv.some((arg) => /^(--help|-h|--version|-v|--json|--print|-p|--no-tui|--output|--format)(=|$)/.test(arg)))
+        return false;
+    if (/^(run|acp|serve|web|auth|upgrade|update|doctor|install|rollback|export|import|session|models)$/.test(input.argv[0] ?? ''))
+        return false;
+    return true;
+}
+function ttyCodeUpdateAsker() {
+    return (result) => new Promise((resolve) => {
+        const rl = node_readline_1.default.createInterface({ input: process.stdin, output: process.stderr });
+        let settled = false;
+        const finish = (choice) => {
+            if (settled)
+                return;
+            settled = true;
+            rl.close();
+            resolve(choice);
+        };
+        rl.on('close', () => finish('once'));
+        rl.question(`\n${auth_core_1.FIRST_PARTY_HARNESS.displayName} update: ${result.installedVersion ?? 'installed version not recorded'} → ${result.offeredVersion} (${result.channel})\n` +
+            '  [1] Update and start  [2] Skip this time  [3] Skip this version  [4] Disable startup checks\nChoose [2]: ', (reply) => finish(reply.trim() === '1'
+            ? 'update'
+            : reply.trim() === '3'
+                ? 'version'
+                : reply.trim() === '4'
+                    ? 'disable'
+                    : 'once'));
+    });
+}
+/** The only caller is a new interactive TUI launch, before any broker or lease. */
+async function maybeOfferCodeUpdate(input) {
+    if (!shouldCheckCodeAtStartup(input))
+        return;
+    const env = input.env ?? process.env;
+    const controller = new AbortController();
+    let timer;
+    try {
+        // Bound the whole discovery, including feed fallbacks; failed checks remain
+        // inspectable through update --check but do not hold the session open.
+        const timeout = new Promise((resolve) => {
+            timer = setTimeout(() => {
+                controller.abort();
+                resolve(null);
+            }, 1500);
+        });
+        const result = await Promise.race([
+            (input.check ?? first_party_harness_update_1.checkLocalCodeUpdate)({
+                env,
+                signal: controller.signal,
+                manifestTimeoutMs: 1500,
+            }),
+            timeout,
+        ]);
+        if (timer) {
+            clearTimeout(timer);
+            timer = undefined;
+        }
+        if (!result || result.state !== 'update-available' || !result.offeredVersion)
+            return;
+        if (readPreferences(env).skippedVersions?.[result.channel] === result.offeredVersion)
+            return;
+        const choice = await (input.ask ?? ttyCodeUpdateAsker())(result);
+        saveChoice(env, result, choice);
+        if (choice !== 'update')
+            return;
+        const updated = await (input.update ?? first_party_harness_update_1.updateLocalCode)({ env, onProgress: input.say });
+        input.say((0, first_party_harness_update_1.formatLocalCodeUpdate)(updated));
+        if (updated.state === 'failed')
+            input.say('Starting the installed engine. Inspect the update result with `skrr code doctor` or retry `skrr code update`.');
+    }
+    catch (error) {
+        input.say(`${auth_core_1.FIRST_PARTY_HARNESS.displayName} update could not complete: ${error instanceof Error ? error.message : String(error)}. Starting the installed engine.`);
+    }
+    finally {
+        if (timer)
+            clearTimeout(timer);
+    }
+}

package/dist/lib/first-party-harness-update.d.ts

@@ -0,0 +1,46 @@
+import { readFirstPartyHarnessUpdateState } from '@skrr-ai/auth-core/first-party-harness-updater';
+export type CodeUpdateOwner = 'managed' | 'external' | 'desktop' | 'image';
+export interface LocalCodeUpdateStatus {
+    component: 'code';
+    state: 'not-installed' | 'unchecked' | 'up-to-date' | 'update-available' | 'owner-managed' | 'check-failed' | 'installed' | 'failed' | 'rolled-back';
+    runningVersion: null;
+    installedVersion: string | null;
+    offeredVersion: string | null;
+    channel: string;
+    owner: CodeUpdateOwner;
+    activePath: string | null;
+    managedPath: string;
+    installedVerified: boolean;
+    command: string;
+    lastAttempt: ReturnType<typeof readFirstPartyHarnessUpdateState>;
+    message?: string;
+    code?: string;
+}
+export interface LocalCodeUpdateOptions {
+    env?: NodeJS.ProcessEnv;
+    force?: boolean;
+    version?: string;
+    allowDowngrade?: boolean;
+    onProgress?: (line: string) => void;
+    signal?: AbortSignal;
+    manifestTimeoutMs?: number;
+    /** Only an explicit install may adopt an engine currently found on PATH. */
+    install?: boolean;
+}
+export declare function localCodeUpdateOwner(env?: NodeJS.ProcessEnv): CodeUpdateOwner;
+/** Read metadata without networking or executing the engine. External versions are unknown. */
+export declare function getLocalCodeUpdateStatus(env?: NodeJS.ProcessEnv): LocalCodeUpdateStatus;
+export declare function checkLocalCodeUpdate(options?: LocalCodeUpdateOptions): Promise<LocalCodeUpdateStatus>;
+export declare function updateLocalCode(options?: LocalCodeUpdateOptions): Promise<LocalCodeUpdateStatus>;
+export declare function rollbackLocalCode(env?: NodeJS.ProcessEnv): LocalCodeUpdateStatus;
+/** Explicit --no-wait launches the same local command, with a durable private log. */
+export declare function startLocalCodeUpdate(options?: LocalCodeUpdateOptions & {
+    operation?: 'install' | 'update';
+}): Promise<{
+    component: 'code';
+    state: 'queued';
+    pid: number;
+    logPath: string;
+    command: string;
+}>;
+export declare function formatLocalCodeUpdate(result: LocalCodeUpdateStatus): string;