orizu 0.5.49 → 0.5.50

package/dist/self-update-command.js

@@ -0,0 +1,390 @@
+// `orizu update` of an npm-global install (ORI-2424). self-update.ts loads
+// this only once it has found such an install, so no other command, and not
+// the daily background cache refresh, loads Effect. Effect owns the children
+// this starts: each runs in the command's fiber, and a stop interrupts that
+// fiber, which passes the signal on to the running child and waits for it
+// within the stop cap.
+import { spawn } from 'child_process';
+import { stderr as errorOutput, stdout as output } from 'process';
+import { Cause, Effect, Exit, Fiber, Schema } from 'effect';
+import { sanitizeTerminalText } from './json-response.js';
+import { cliInvocation, compareSemver, MANUAL_INSTALL_COMMAND, npmInvocation, resolveLatest, resolveUpdateRegistry, tryWriteCache, } from './self-update.js';
+const CHILD_TIMEOUT_MS = 60_000;
+const STDERR_TAIL_CHARS = 4_000;
+const STOP_SIGNALS = ['SIGINT', 'SIGTERM', 'SIGHUP', 'SIGQUIT'];
+// The CLI's stop cap (ORI-2402) is 15 s. A stopped child gets 10 s to exit,
+// then is killed; reading which version is installed gets the last 5 s.
+const STOP_CHILD_WAIT_MS = 10_000;
+const STOP_VERSION_CHECK_MS = 5_000;
+const PIPE_GRACE_MS = 200;
+// What the skills refresh child reports (`orizu skills update --json`).
+const SkillUpdate = Schema.Struct({
+    path: Schema.String,
+    action: Schema.String,
+    backup: Schema.optionalKey(Schema.String),
+    warning: Schema.optionalKey(Schema.String),
+    error: Schema.optionalKey(Schema.String),
+});
+const SkillsReport = Schema.Struct({ updates: Schema.Array(SkillUpdate) });
+function testMs(name, fallback) {
+    const override = process.env[name];
+    if (override === undefined)
+        return fallback;
+    const parsed = Number(override);
+    return Number.isSafeInteger(parsed) && parsed > 0 ? parsed : fallback;
+}
+const verifyTimeoutMs = () => testMs('ORIZU_UPDATE_TEST_VERIFY_TIMEOUT_MS', CHILD_TIMEOUT_MS);
+// Stops reading a child's output, so a process it started that still holds
+// the pipes can't keep this command waiting.
+function releasePipes(child) {
+    child.stdout?.destroy();
+    child.stderr?.destroy();
+}
+/**
+ * Passes the stop's signal on to a running child, waits for it to exit until
+ * the stop's deadline, then kills it. Runs when the command's fiber is
+ * interrupted while it waits for the child. It waits for the child itself
+ * ('exit'), not its output pipes ('close'): a process the child started can
+ * hold those open long after the child is gone.
+ */
+function stopChild(child, stop) {
+    return Effect.callback(resume => {
+        if (child.exitCode !== null || child.signalCode !== null) {
+            releasePipes(child);
+            resume(Effect.void);
+            return;
+        }
+        const kill = setTimeout(() => child.kill('SIGKILL'), Math.max(0, stop.deadline - Date.now()));
+        child.once('exit', () => {
+            clearTimeout(kill);
+            releasePipes(child);
+            resume(Effect.void);
+        });
+        child.kill(stop.signal ?? 'SIGTERM');
+    });
+}
+function runStreaming(command, args, io, stop, options = {}) {
+    return Effect.callback(resume => {
+        let stderr = '';
+        let stdout = '';
+        let settled = false;
+        let timedOut = false;
+        let timer;
+        const finish = (status) => {
+            if (settled)
+                return;
+            settled = true;
+            if (timer)
+                clearTimeout(timer);
+            resume(Effect.succeed({ status, stderr: stderr.slice(-STDERR_TAIL_CHARS), stdout, timedOut }));
+        };
+        const child = spawn(command, args, {
+            env: { ...process.env, ORIZU_NO_UPDATE_CHECK: '1' },
+            stdio: ['ignore', 'pipe', 'pipe'],
+        });
+        if (options.timeoutMs !== undefined) {
+            timer = setTimeout(() => {
+                timedOut = true;
+                child.kill('SIGKILL');
+            }, options.timeoutMs);
+        }
+        child.stdout?.on('data', chunk => {
+            const text = sanitizeTerminalText(chunk);
+            if (options.captureStdout) {
+                stdout = `${stdout}${text}`;
+                return;
+            }
+            if (io.json)
+                errorOutput.write(text);
+            else
+                output.write(text);
+        });
+        child.stderr?.on('data', chunk => {
+            const text = sanitizeTerminalText(chunk);
+            stderr = `${stderr}${text}`.slice(-STDERR_TAIL_CHARS);
+            errorOutput.write(text);
+        });
+        child.once('error', error => {
+            stderr = `${stderr}${sanitizeTerminalText(error.message)}`;
+            finish(1);
+        });
+        child.once('close', code => finish(code ?? 1));
+        return Effect.suspend(() => {
+            if (timer)
+                clearTimeout(timer);
+            return stopChild(child, stop);
+        });
+    });
+}
+// Runs a child to completion and keeps all it said; used for version checks.
+function runCaptured(command, args, timeoutMs, stop) {
+    return Effect.callback(resume => {
+        let stdout = '';
+        let stderr = '';
+        let error = null;
+        let timedOut = false;
+        const child = spawn(command, args, {
+            env: { ...process.env, ORIZU_NO_UPDATE_CHECK: '1' },
+            stdio: ['ignore', 'pipe', 'pipe'],
+        });
+        const timer = setTimeout(() => {
+            timedOut = true;
+            child.kill('SIGKILL');
+        }, timeoutMs);
+        child.stdout?.setEncoding('utf8');
+        child.stderr?.setEncoding('utf8');
+        child.stdout?.on('data', (chunk) => { stdout += chunk; });
+        child.stderr?.on('data', (chunk) => { stderr += chunk; });
+        let settled = false;
+        let grace;
+        const settle = (status, signal) => {
+            if (settled)
+                return;
+            settled = true;
+            clearTimeout(timer);
+            if (grace)
+                clearTimeout(grace);
+            releasePipes(child);
+            resume(Effect.succeed({ status, signal, stdout, stderr, error, timedOut }));
+        };
+        child.once('error', failure => {
+            error = failure;
+            if (child.pid === undefined)
+                settle(null, null);
+        });
+        child.once('close', (status, signal) => settle(status, signal));
+        // Once the process is gone, its output gets a moment to arrive; a process
+        // it started that holds the pipes doesn't extend the timeout.
+        child.once('exit', (status, signal) => { grace = setTimeout(() => settle(status, signal), PIPE_GRACE_MS); });
+        return Effect.suspend(() => {
+            clearTimeout(timer);
+            if (grace)
+                clearTimeout(grace);
+            return stop ? stopChild(child, stop) : Effect.sync(() => { child.kill('SIGKILL'); releasePipes(child); });
+        });
+    });
+}
+/**
+ * Refresh managed skills through the given CLI binary and classify the outcome
+ * from the child's --json report, never from its human text: an install with
+ * no skill targets reports 'none', the one state a caller of `update --json`
+ * most needs to see (ADR-001 coupling). The report's backups, warnings and
+ * failures are passed on, in human and JSON output alike.
+ */
+function refreshManagedSkills(command, args, io, stop) {
+    return Effect.gen(function* () {
+        const child = yield* runStreaming(command, [...args, 'skills', 'update', '--json'], io, stop, { timeoutMs: CHILD_TIMEOUT_MS, captureStdout: true });
+        const report = Schema.decodeUnknownOption(Schema.fromJsonString(SkillsReport))(child.stdout || '');
+        const updates = report._tag === 'Some' ? report.value.updates : null;
+        if (updates !== null && !io.json)
+            printSkillUpdates(io, updates, child.status === 0);
+        if (child.status !== 0)
+            return { status: child.status, timedOut: child.timedOut, skills: 'none', updates };
+        if (updates === null)
+            return { status: 1, timedOut: false, skills: 'none', updates };
+        if (updates.length === 0)
+            return { status: 0, timedOut: false, skills: 'none', updates };
+        const refreshed = updates.some(update => update.action !== 'already-current');
+        return { status: 0, timedOut: false, skills: refreshed ? 'refreshed' : 'already-current', updates };
+    });
+}
+// The same lines `orizu skills update` prints for each install.
+function printSkillUpdates(io, updates, succeeded) {
+    if (updates.length === 0 && succeeded)
+        io.printLine('No Orizu skill installs found. Run `orizu install-skill` first.');
+    for (const update of updates) {
+        const path = sanitizeTerminalText(update.path);
+        const backup = update.backup ? `; moved your earlier folder to ${sanitizeTerminalText(update.backup)}` : '';
+        if (update.action === 'already-current')
+            io.printLine(`Current ${path}`);
+        else if (update.action === 'relinked')
+            io.printLine(`Relinked ${path}`);
+        else if (update.action === 'rewrote')
+            io.printLine(`Rewrote ${path} from the installed CLI skill${backup}`);
+        else if (update.action === 'failed')
+            io.printLine(`Failed ${path}: ${sanitizeTerminalText(update.error ?? 'unknown error')}`);
+        else
+            io.printLine(`Updated ${path}${backup}`);
+        if (update.warning)
+            io.printLine(`Warning: ${sanitizeTerminalText(update.warning)}`);
+    }
+}
+function withSkillUpdates(result, skills) {
+    return skills.updates === null ? result : { ...result, skillUpdates: skills.updates };
+}
+function emit(io, result) {
+    if (io.json)
+        io.printLine(JSON.stringify(result));
+}
+function fail(io, code, detail, result) {
+    io.printError(`${code}: ${detail}`);
+    emit(io, result);
+    return 1;
+}
+function selfUpdate(io, install, progress, stop) {
+    return Effect.gen(function* () {
+        progress.install = install;
+        const checked = yield* Effect.promise(async () => {
+            try {
+                const registry = resolveUpdateRegistry();
+                const latest = await resolveLatest(registry);
+                tryWriteCache(latest);
+                return { ok: true, registry, latest };
+            }
+            catch (error) {
+                return { ok: false, error };
+            }
+        });
+        if (!checked.ok) {
+            const { error } = checked;
+            return fail(io, 'update_check_failed', sanitizeTerminalText(error instanceof Error ? error.message : error), {
+                installed: io.installed, latest: null, action: 'check-failed', prefix: install.prefix, skills: 'not-run',
+            });
+        }
+        const { latest, registry } = checked;
+        progress.latest = latest;
+        if (compareSemver(io.installed, latest) >= 0) {
+            if (!io.json)
+                io.printLine(`orizu ${io.installed} is already the latest.`);
+            if (io.dryRun) {
+                emit(io, { installed: io.installed, latest, action: 'already-latest', prefix: install.prefix, skills: 'not-run' });
+                return 0;
+            }
+            progress.step = 'refreshing-skills';
+            const skills = yield* refreshManagedSkills(install.binPath, [], io, stop);
+            progress.step = null;
+            if (skills.status !== 0) {
+                const detail = skills.timedOut
+                    ? 'orizu is already the latest, but its managed skills refresh timed out.'
+                    : 'orizu is already the latest, but its managed skills could not be refreshed.';
+                return fail(io, 'update_skills_refresh_failed', detail, withSkillUpdates({
+                    installed: io.installed, latest, action: 'already-latest', prefix: install.prefix, skills: 'refresh-failed',
+                }, skills));
+            }
+            emit(io, withSkillUpdates({ installed: io.installed, latest, action: 'already-latest', prefix: install.prefix, skills: skills.skills }, skills));
+            return 0;
+        }
+        if (io.dryRun) {
+            if (!io.json)
+                io.printLine(`Would update orizu ${io.installed} → ${latest} in ${install.prefix}.`);
+            emit(io, { installed: io.installed, latest, action: 'would-update', prefix: install.prefix, skills: 'would-refresh' });
+            return 0;
+        }
+        const npmCommand = npmInvocation();
+        const registryArgs = process.env.ORIZU_UPDATE_REGISTRY !== undefined
+            ? ['--registry', registry]
+            : [];
+        progress.step = 'installing';
+        const npm = yield* runStreaming(npmCommand.command, [...npmCommand.args,
+            'install', '-g', `orizu@${latest}`, '--prefix', install.prefix, '--no-audit', '--no-fund',
+            ...registryArgs,
+        ], io, stop);
+        progress.step = null;
+        if (npm.status !== 0) {
+            const tail = npm.stderr.trim() ? ` npm stderr tail: ${npm.stderr.trim()}` : '';
+            return fail(io, 'update_install_failed', `${tail} Run \`${MANUAL_INSTALL_COMMAND}\`.`, {
+                installed: io.installed, latest, action: 'install-failed', prefix: install.prefix, skills: 'not-run',
+            });
+        }
+        const verifyCommand = cliInvocation(install, ['--version']);
+        const verificationTimeoutMs = verifyTimeoutMs();
+        progress.step = 'verifying';
+        const verified = yield* runCaptured(verifyCommand.command, verifyCommand.args, verificationTimeoutMs, stop);
+        progress.step = null;
+        const observed = sanitizeTerminalText(verified.stdout).trim();
+        if (verified.timedOut) {
+            return fail(io, 'update_verify_mismatch', `verification timed out after ${verificationTimeoutMs} ms.`, {
+                installed: io.installed, latest, action: 'verify-mismatch', prefix: install.prefix, skills: 'not-run',
+            });
+        }
+        if (verified.status !== 0 || observed !== `orizu ${latest}`) {
+            const launchError = verified.error ? ` launch error: ${sanitizeTerminalText(verified.error.message)}.` : '';
+            const exit = verified.status === null ? `signal ${verified.signal ?? 'unknown'}` : `exit ${verified.status}`;
+            const errorTail = sanitizeTerminalText(verified.stderr).trim().split('\n').slice(-3).join(' ');
+            const detail = `expected orizu ${latest}, observed ${observed || '<no version>'} (${exit}).${launchError}${errorTail ? ` ${errorTail}` : ''}`;
+            return fail(io, 'update_verify_mismatch', `${detail} Run \`${MANUAL_INSTALL_COMMAND}\` to reinstall.`, {
+                installed: io.installed, latest, action: 'verify-mismatch', prefix: install.prefix, skills: 'not-run',
+            });
+        }
+        progress.installedNow = latest;
+        if (!io.json)
+            io.printLine(`orizu ${latest} installed.`);
+        const skillsCommand = cliInvocation(install, []);
+        progress.step = 'refreshing-skills';
+        const skills = yield* refreshManagedSkills(skillsCommand.command, skillsCommand.args, io, stop);
+        progress.step = null;
+        if (skills.status !== 0) {
+            const detail = skills.timedOut
+                ? 'the CLI was updated, but its managed skills refresh timed out.'
+                : 'the CLI was updated, but its managed skills could not be refreshed.';
+            return fail(io, 'update_skills_refresh_failed', detail, withSkillUpdates({
+                installed: io.installed, latest, action: 'updated', prefix: install.prefix, skills: 'refresh-failed',
+            }, skills));
+        }
+        emit(io, withSkillUpdates({ installed: io.installed, latest, action: 'updated', prefix: install.prefix, skills: skills.skills }, skills));
+        return 0;
+    });
+}
+// After a stop: which orizu the global install runs now, read once in the stop cap's last 5 s.
+async function installedVersionAfterStop(install) {
+    const command = cliInvocation(install, ['--version']);
+    const checked = await Effect.runPromise(runCaptured(command.command, command.args, STOP_VERSION_CHECK_MS, null));
+    const match = /^orizu (\S+)$/u.exec(sanitizeTerminalText(checked.stdout).trim());
+    return checked.status === 0 && match ? match[1] : null;
+}
+async function reportStop(io, progress) {
+    const { step, install, latest } = progress;
+    if (!step || !install || !latest)
+        return;
+    if (step === 'refreshing-skills') {
+        io.printError(`update_stopped: stopped while refreshing the managed skills. orizu ${progress.installedNow} is installed now. Run \`orizu skills update\` to finish the refresh.`);
+        emit(io, { installed: io.installed, latest, action: 'stopped', prefix: install.prefix, skills: 'refresh-stopped' });
+        return;
+    }
+    const now = await installedVersionAfterStop(install);
+    const doing = step === 'installing' ? `npm was installing orizu ${latest}` : `checking the new orizu ${latest}`;
+    const state = now ? `orizu ${now} is installed now.` : 'Could not tell which orizu is installed now.';
+    io.printError(`update_stopped: stopped while ${doing}. ${state} Run \`${MANUAL_INSTALL_COMMAND}\` to finish the update.`);
+    emit(io, { installed: io.installed, latest, action: 'stopped', prefix: install.prefix, skills: 'not-run' });
+}
+/**
+ * Runs the update with stop handlers installed for exactly its duration. A
+ * stop interrupts it: the running child gets the same signal and the stop cap
+ * to exit, the command says what is installed now, then ends by that signal.
+ */
+export async function runSelfUpdate(io, install) {
+    const progress = { step: null, install: null, latest: null, installedNow: io.installed };
+    const stop = { signal: null, deadline: 0 };
+    // eslint-disable-next-line prefer-const -- assigned after the handlers that read it
+    let fiber;
+    const handlers = STOP_SIGNALS.map(signal => ({
+        signal,
+        handle: () => {
+            if (stop.signal)
+                return;
+            stop.signal = signal;
+            stop.deadline = Date.now() + testMs('ORIZU_UPDATE_TEST_STOP_WAIT_MS', STOP_CHILD_WAIT_MS);
+            void Effect.runPromise(Fiber.interrupt(fiber));
+        },
+    }));
+    const removeHandlers = () => { for (const entry of handlers)
+        process.off(entry.signal, entry.handle); };
+    for (const entry of handlers)
+        process.on(entry.signal, entry.handle);
+    fiber = Effect.runFork(selfUpdate(io, install, progress, stop));
+    try {
+        const exit = await Effect.runPromise(Effect.exit(Fiber.join(fiber)));
+        if (stop.signal) {
+            await reportStop(io, progress);
+            removeHandlers();
+            process.kill(process.pid, stop.signal);
+            return await new Promise(() => { });
+        }
+        if (Exit.isSuccess(exit))
+            return exit.value;
+        throw Cause.squash(exit.cause);
+    }
+    finally {
+        removeHandlers();
+    }
+}

package/dist/self-update.d.ts

@@ -1,25 +1,16 @@
 import { spawn } from 'child_process';
+export declare const MANUAL_INSTALL_COMMAND = "npm i -g orizu@latest";
 interface UpdateCache {
     checkedAt: string;
     latest: string | null;
 }
-interface GlobalInstall {
+export interface GlobalInstall {
     binPath: string;
     prefix: string;
 }
-export interface SelfUpdateIo {
-    dryRun: boolean;
-    installed: string;
-    json: boolean;
-    refreshCache: boolean;
-    printLine(message?: string): void;
-    printError(message: string): void;
-}
-interface UpdateCommandIo {
-    getCliVersion(): string;
-    json: boolean;
-    printLine(message?: string): void;
-    printError(message: string): void;
+export interface Invocation {
+    command: string;
+    args: string[];
 }
 export interface PassiveUpdateState {
     cache: UpdateCache | null;
@@ -33,10 +24,32 @@ export interface PassiveUpdateIo {
 export declare const defaultPassiveUpdateIo: PassiveUpdateIo;
 export declare function compareSemver(left: string, right: string): number;
 export declare function detectNpmGlobalInstall(entry?: string): GlobalInstall | null;
-export declare function selfUpdateCommand(io: SelfUpdateIo): Promise<number>;
-export declare function runUpdateCommand(rawArgs: string[], io: UpdateCommandIo): Promise<number>;
+export declare function tryWriteCache(latest: string | null): void;
+export declare function resolveUpdateRegistry(): string;
+export declare function resolveLatest(registry?: string): Promise<string>;
+export declare function npmInvocation(): Invocation;
+export declare function cliInvocation(install: GlobalInstall, args: string[]): Invocation;
 export declare function preparePassiveUpdate(rawArgs: string[], command: string | undefined, installed: string): PassiveUpdateState | null;
 export declare function withPassiveUpdateNotice(rawArgs: string[], getInstalledVersion: () => string, printError: (message: string) => void, run: (args: string[]) => Promise<unknown>, io?: PassiveUpdateIo): void;
 export declare function finishPassiveUpdate(state: PassiveUpdateState | null, printError: (message: string) => void, io?: PassiveUpdateIo): void;
+export interface SelfUpdateIo {
+    dryRun: boolean;
+    installed: string;
+    json: boolean;
+    printLine(message?: string): void;
+    printError(message: string): void;
+}
+interface UpdateCommandIo {
+    getCliVersion(): string;
+    json: boolean;
+    printLine(message?: string): void;
+    printError(message: string): void;
+}
+/**
+ * `orizu update`. Checking the arguments, the daily background cache refresh
+ * and refusing an install npm doesn't own stay plain code; only an update of
+ * an npm-global install loads the Effect workflow (ORI-2424).
+ */
+export declare function runUpdateCommand(rawArgs: string[], io: UpdateCommandIo): Promise<number>;
 export {};
 //# sourceMappingURL=self-update.d.ts.map

package/dist/self-update.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"self-update.d.ts","sourceRoot":"","sources":["../src/self-update.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAa,MAAM,eAAe,CAAA;AA8BhD,UAAU,WAAW;IAAG,SAAS,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,MAAM,GAAG,IAAI,CAAA;CAAE;AAClE,UAAU,aAAa;IAAG,OAAO,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,MAAM,CAAA;CAAE;AAK3D,MAAM,WAAW,YAAY;IAC3B,MAAM,EAAE,OAAO,CAAC;IAAC,SAAS,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,OAAO,CAAC;IAAC,YAAY,EAAE,OAAO,CAAA;IACxE,SAAS,CAAC,OAAO,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IAAC,UAAU,CAAC,OAAO,EAAE,MAAM,GAAG,IAAI,CAAA;CACrE;AAED,UAAU,eAAe;IACvB,aAAa,IAAI,MAAM,CAAA;IACvB,IAAI,EAAE,OAAO,CAAA;IACb,SAAS,CAAC,OAAO,CAAC,EAAE,MAAM,GAAG,IAAI,CAAA;IACjC,UAAU,CAAC,OAAO,EAAE,MAAM,GAAG,IAAI,CAAA;CAClC;AAED,MAAM,WAAW,kBAAkB;IAAG,KAAK,EAAE,WAAW,GAAG,IAAI,CAAC;IAAC,OAAO,EAAE,aAAa,CAAC;IAAC,SAAS,EAAE,MAAM,CAAA;CAAE;AAC5G,MAAM,WAAW,eAAe;IAAG,IAAI,CAAC,IAAI,EAAE,MAAM,GAAG,IAAI,CAAC;IAAC,KAAK,EAAE,OAAO,KAAK,CAAA;CAAE;AAClF,eAAO,MAAM,sBAAsB,EAAE,eAA+C,CAAA;AAcpF,wBAAgB,aAAa,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,MAAM,CAsBjE;AAED,wBAAgB,sBAAsB,CAAC,KAAK,SAAkB,GAAG,aAAa,GAAG,IAAI,CAuBpF;AA6ND,wBAAsB,iBAAiB,CAAC,EAAE,EAAE,YAAY,GAAG,OAAO,CAAC,MAAM,CAAC,CA2GzE;AAED,wBAAsB,gBAAgB,CAAC,OAAO,EAAE,MAAM,EAAE,EAAE,EAAE,EAAE,eAAe,GAAG,OAAO,CAAC,MAAM,CAAC,CAuB9F;AAOD,wBAAgB,oBAAoB,CAClC,OAAO,EAAE,MAAM,EAAE,EACjB,OAAO,EAAE,MAAM,GAAG,SAAS,EAC3B,SAAS,EAAE,MAAM,GAChB,kBAAkB,GAAG,IAAI,CAa3B;AAED,wBAAgB,uBAAuB,CACrC,OAAO,EAAE,MAAM,EAAE,EACjB,mBAAmB,EAAE,MAAM,MAAM,EACjC,UAAU,EAAE,CAAC,OAAO,EAAE,MAAM,KAAK,IAAI,EACrC,GAAG,EAAE,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,OAAO,CAAC,OAAO,CAAC,EACzC,EAAE,GAAE,eAAwC,GAC3C,IAAI,CAyBN;AAED,wBAAgB,mBAAmB,CACjC,KAAK,EAAE,kBAAkB,GAAG,IAAI,EAChC,UAAU,EAAE,CAAC,OAAO,EAAE,MAAM,KAAK,IAAI,EACrC,EAAE,GAAE,eAAwC,GAC3C,IAAI,CAoBN"}
+{"version":3,"file":"self-update.d.ts","sourceRoot":"","sources":["../src/self-update.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAE,MAAM,eAAe,CAAA;AAuBrC,eAAO,MAAM,sBAAsB,0BAA0B,CAAA;AAI7D,UAAU,WAAW;IAAG,SAAS,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,MAAM,GAAG,IAAI,CAAA;CAAE;AAClE,MAAM,WAAW,aAAa;IAAG,OAAO,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,MAAM,CAAA;CAAE;AAClE,MAAM,WAAW,UAAU;IAAG,OAAO,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,EAAE,CAAA;CAAE;AAE/D,MAAM,WAAW,kBAAkB;IAAG,KAAK,EAAE,WAAW,GAAG,IAAI,CAAC;IAAC,OAAO,EAAE,aAAa,CAAC;IAAC,SAAS,EAAE,MAAM,CAAA;CAAE;AAC5G,MAAM,WAAW,eAAe;IAAG,IAAI,CAAC,IAAI,EAAE,MAAM,GAAG,IAAI,CAAC;IAAC,KAAK,EAAE,OAAO,KAAK,CAAA;CAAE;AAClF,eAAO,MAAM,sBAAsB,EAAE,eAA+C,CAAA;AAcpF,wBAAgB,aAAa,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,MAAM,CAsBjE;AAED,wBAAgB,sBAAsB,CAAC,KAAK,SAAkB,GAAG,aAAa,GAAG,IAAI,CAuBpF;AA2BD,wBAAgB,aAAa,CAAC,MAAM,EAAE,MAAM,GAAG,IAAI,GAAG,IAAI,CAMzD;AA+CD,wBAAgB,qBAAqB,IAAI,MAAM,CAY9C;AAED,wBAAsB,aAAa,CAAC,QAAQ,SAA0B,GAAG,OAAO,CAAC,MAAM,CAAC,CAUvF;AAED,wBAAgB,aAAa,IAAI,UAAU,CAI1C;AAED,wBAAgB,aAAa,CAAC,OAAO,EAAE,aAAa,EAAE,IAAI,EAAE,MAAM,EAAE,GAAG,UAAU,CAEhF;AAOD,wBAAgB,oBAAoB,CAClC,OAAO,EAAE,MAAM,EAAE,EACjB,OAAO,EAAE,MAAM,GAAG,SAAS,EAC3B,SAAS,EAAE,MAAM,GAChB,kBAAkB,GAAG,IAAI,CAa3B;AAED,wBAAgB,uBAAuB,CACrC,OAAO,EAAE,MAAM,EAAE,EACjB,mBAAmB,EAAE,MAAM,MAAM,EACjC,UAAU,EAAE,CAAC,OAAO,EAAE,MAAM,KAAK,IAAI,EACrC,GAAG,EAAE,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,OAAO,CAAC,OAAO,CAAC,EACzC,EAAE,GAAE,eAAwC,GAC3C,IAAI,CAyBN;AAED,wBAAgB,mBAAmB,CACjC,KAAK,EAAE,kBAAkB,GAAG,IAAI,EAChC,UAAU,EAAE,CAAC,OAAO,EAAE,MAAM,KAAK,IAAI,EACrC,EAAE,GAAE,eAAwC,GAC3C,IAAI,CAoBN;AAED,MAAM,WAAW,YAAY;IAC3B,MAAM,EAAE,OAAO,CAAC;IAAC,SAAS,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,OAAO,CAAA;IACjD,SAAS,CAAC,OAAO,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IAAC,UAAU,CAAC,OAAO,EAAE,MAAM,GAAG,IAAI,CAAA;CACrE;AAED,UAAU,eAAe;IACvB,aAAa,IAAI,MAAM,CAAA;IACvB,IAAI,EAAE,OAAO,CAAA;IACb,SAAS,CAAC,OAAO,CAAC,EAAE,MAAM,GAAG,IAAI,CAAA;IACjC,UAAU,CAAC,OAAO,EAAE,MAAM,GAAG,IAAI,CAAA;CAClC;AAED;;;;GAIG;AACH,wBAAsB,gBAAgB,CAAC,OAAO,EAAE,MAAM,EAAE,EAAE,EAAE,EAAE,eAAe,GAAG,OAAO,CAAC,MAAM,CAAC,CAyC9F"}