@krtclcdy/tersio 2.25.3 → 2.25.5

package/dist/cli/headroom-install.js

@@ -1,266 +0,0 @@
-// The Headroom bundle: Tersio installs, updates, and removes the add-on so the user never runs a Python tool by hand.
-// A Tersio-owned venv at ~/.tersio/headroom stays inside our home, so uninstall is one directory removal.
-import { existsSync } from 'node:fs';
-import { promises as fs } from 'node:fs';
-import path from 'node:path';
-import { execP } from './common.js';
-import { sayTagged } from './interactive.js';
-import { findFile, headroomBundleDir, headroomBundledBinary, httpsDownload, httpsGet, parseChecksum, sha256File, } from '../extensions/lib/utils.js';
-import { HEADROOM_TESTED_VERSION, parseHeadroomVersion } from '../extensions/shared/headroom.js';
-/** The extra that carries the proxy. No `[ml]`: torch plus model weights are opt-in, later. */
-const HEADROOM_SPEC = 'headroom-ai[proxy]';
-/** uv resolves and, when needed, downloads a managed CPython for this request. */
-const PYTHON_REQUEST = '>=3.10';
-const UV_RELEASE_BASE = 'https://github.com/astral-sh/uv/releases/latest/download';
-const IS_WINDOWS = process.platform === 'win32';
-/** CI and tests set this so an install never reaches the network. Not a user-facing option. */
-function bundleDisabled() {
-    return process.env.TERSIO_SKIP_HEADROOM_BUNDLE === '1';
-}
-function skippedResult() {
-    sayTagged('  [skip] Headroom bundle skipped (TERSIO_SKIP_HEADROOM_BUNDLE=1)');
-    return { ok: true, bin: null, version: null, detail: 'skipped', skipped: true };
-}
-// --- layout ----------------------------------------------------------------------------
-export function headroomVenvDir() {
-    return path.join(headroomBundleDir(), 'venv');
-}
-function headroomVenvPython() {
-    return IS_WINDOWS
-        ? path.join(headroomVenvDir(), 'Scripts', 'python.exe')
-        : path.join(headroomVenvDir(), 'bin', 'python');
-}
-/** The bundled entrypoint. `resolveHeadroomBinary` prefers it, so Tersio updates what Tersio installed. */
-export const headroomBundledBin = headroomBundledBinary;
-function uvManagedDir() {
-    return path.join(headroomBundleDir(), 'bin');
-}
-function uvManagedFile() {
-    return path.join(uvManagedDir(), IS_WINDOWS ? 'uv.exe' : 'uv');
-}
-/** Written only when Tersio downloaded uv itself, so uninstall knows what it may delete. */
-function uvOwnedMarker() {
-    return path.join(headroomBundleDir(), 'uv-managed');
-}
-export function headroomBundleInstalled() {
-    return existsSync(headroomBundledBin());
-}
-const UV_PLATFORM_SPECS = {
-    'win32/x64': { triple: 'x86_64-pc-windows-msvc', ext: '.zip' },
-    'linux/x64': { triple: 'x86_64-unknown-linux-gnu', ext: '.tar.gz' },
-    'linux/arm64': { triple: 'aarch64-unknown-linux-gnu', ext: '.tar.gz' },
-    'darwin/x64': { triple: 'x86_64-apple-darwin', ext: '.tar.gz' },
-    'darwin/arm64': { triple: 'aarch64-apple-darwin', ext: '.tar.gz' },
-};
-export function uvPlatformSpec(platform = process.platform, arch = process.arch) {
-    return UV_PLATFORM_SPECS[`${platform}/${arch}`] ?? null;
-}
-async function onPath(name) {
-    try {
-        if (IS_WINDOWS) {
-            const found = await execP('where', [name], { timeout: 5000 });
-            return found.stdout.split(/\r?\n/).map((l) => l.trim()).find(Boolean) ?? null;
-        }
-        const found = await execP('sh', ['-c', `command -v ${name}`], { timeout: 5000 });
-        return found.stdout.trim() || null;
-    }
-    catch {
-        return null;
-    }
-}
-/** A usable uv: the Tersio copy first (so tests and CI are deterministic), then PATH. */
-export async function resolveUv() {
-    if (existsSync(uvManagedFile()))
-        return uvManagedFile();
-    return onPath('uv');
-}
-async function extractArchive(archivePath, extractDir) {
-    await fs.mkdir(extractDir, { recursive: true });
-    let attempts;
-    if (archivePath.endsWith('.zip')) {
-        attempts = IS_WINDOWS
-            ? [['powershell', ['Expand-Archive', '-Path', archivePath, '-DestinationPath', extractDir, '-Force']]]
-            : [['unzip', ['-o', archivePath, '-d', extractDir]]];
-    }
-    else {
-        attempts = [['tar', ['xzf', archivePath, '-C', extractDir]]];
-    }
-    for (const [cmd, args] of attempts) {
-        try {
-            await execP(cmd, args, { timeout: 60000 });
-            return true;
-        }
-        catch { /* try the next extractor */ }
-    }
-    return false;
-}
-/** Downloads uv into the Tersio home, checksum-verified, when the machine has none. */
-async function installUv(options) {
-    const spec = uvPlatformSpec();
-    if (!spec) {
-        sayTagged(`  [fail] No uv build for ${process.platform}/${process.arch}.`);
-        return null;
-    }
-    if (options.dryRun) {
-        sayTagged(`  [dry-run] would download uv-${spec.triple}${spec.ext} into ${uvManagedDir()}`);
-        return uvManagedFile();
-    }
-    const asset = `uv-${spec.triple}${spec.ext}`;
-    // The parent must exist before mkdtemp runs inside it.
-    await fs.mkdir(headroomBundleDir(), { recursive: true });
-    const tmpDir = await fs.mkdtemp(path.join(headroomBundleDir(), 'tmp-'));
-    try {
-        const archivePath = path.join(tmpDir, asset);
-        sayTagged(`  [get] ${asset}`);
-        await httpsDownload(`${UV_RELEASE_BASE}/${asset}`, archivePath, { maxRedirects: 5 });
-        // Fails closed: an unverified executable would run with the user's privileges.
-        const checksums = await httpsGet(`${UV_RELEASE_BASE}/${asset}.sha256`).catch(() => null);
-        const expected = checksums ? parseChecksum(checksums, asset) : null;
-        if (!expected) {
-            sayTagged(`  [fail] No checksum published for ${asset} — refusing to install uv.`);
-            return null;
-        }
-        if (await sha256File(archivePath) !== expected) {
-            sayTagged(`  [fail] Checksum mismatch for ${asset} — refusing to install uv.`);
-            return null;
-        }
-        const extractDir = path.join(tmpDir, 'extracted');
-        if (!await extractArchive(archivePath, extractDir)) {
-            sayTagged(`  [fail] Could not extract ${asset}`);
-            return null;
-        }
-        const found = await findFile(extractDir, IS_WINDOWS ? 'uv.exe' : 'uv');
-        if (!found) {
-            sayTagged(`  [fail] Could not find uv in ${asset}`);
-            return null;
-        }
-        await fs.mkdir(uvManagedDir(), { recursive: true });
-        await fs.copyFile(found, uvManagedFile());
-        await fs.chmod(uvManagedFile(), 0o755).catch(() => { });
-        await fs.writeFile(uvOwnedMarker(), `${new Date().toISOString()}\n`, 'utf8');
-        return uvManagedFile();
-    }
-    catch (e) {
-        sayTagged(`  [fail] Could not install uv: ${e.message}`);
-        return null;
-    }
-    finally {
-        await fs.rm(tmpDir, { recursive: true, force: true }).catch(() => { });
-    }
-}
-async function ensureUv(options) {
-    const existing = await resolveUv();
-    if (existing)
-        return existing;
-    if (!options.quiet)
-        sayTagged('  [info] No uv found — Tersio installs its own copy under ~/.tersio/headroom');
-    return installUv(options);
-}
-// --- install / update ------------------------------------------------------------------
-async function runUv(uv, args, options) {
-    if (options.dryRun) {
-        sayTagged(`  [dry-run] would run: uv ${args.join(' ')}`);
-        return true;
-    }
-    if (options.verbose || !options.quiet)
-        sayTagged(`  [run] uv ${args.join(' ')}`);
-    try {
-        const execOptions = { timeout: options.timeout ?? 600000 };
-        const result = await execP(uv, args, execOptions);
-        if (options.verbose && result.stdout.trim())
-            sayTagged(`  ${result.stdout.trim().slice(-400)}`);
-        return true;
-    }
-    catch (e) {
-        const err = e;
-        sayTagged(`  [fail] uv ${args[0]}: ${(err.stderr || err.message || '').trim().slice(0, 300)}`);
-        return false;
-    }
-}
-/** Builds the venv if it is missing, then installs or upgrades the package inside it. */
-async function provision(options, upgrade) {
-    const uv = await ensureUv(options);
-    if (!uv)
-        return { ok: false, bin: null, version: null, detail: 'uv unavailable' };
-    if (!existsSync(headroomVenvPython())) {
-        // uv fetches a managed CPython when the machine has no interpreter in range.
-        if (!await runUv(uv, ['venv', headroomVenvDir(), '--python', PYTHON_REQUEST], { ...options, timeout: 900000 })) {
-            return { ok: false, bin: null, version: null, detail: 'venv creation failed' };
-        }
-    }
-    const installArgs = ['pip', 'install', '--python', headroomVenvPython()];
-    if (upgrade)
-        installArgs.push('--upgrade');
-    installArgs.push(HEADROOM_SPEC);
-    if (!await runUv(uv, installArgs, options)) {
-        return { ok: false, bin: null, version: null, detail: `could not install ${HEADROOM_SPEC}` };
-    }
-    if (options.dryRun)
-        return { ok: true, bin: headroomBundledBin(), version: null, detail: 'dry run' };
-    const version = await bundledVersion();
-    if (!existsSync(headroomBundledBin())) {
-        return { ok: false, bin: null, version, detail: 'the package installed, but no headroom entrypoint appeared' };
-    }
-    return { ok: true, bin: headroomBundledBin(), version, detail: upgrade ? 'updated' : 'installed' };
-}
-async function bundledVersion() {
-    try {
-        const result = await execP(headroomBundledBin(), ['--version'], { timeout: 30000 });
-        return parseHeadroomVersion(result.stdout || result.stderr);
-    }
-    catch (e) {
-        const err = e;
-        return parseHeadroomVersion(err.stdout || err.stderr);
-    }
-}
-/** Install the bundled Headroom. Idempotent: an existing venv is reused. */
-export async function installHeadroom(options = {}) {
-    if (bundleDisabled())
-        return skippedResult();
-    if (headroomBundleInstalled() && !options.dryRun) {
-        const version = await bundledVersion();
-        return { ok: true, bin: headroomBundledBin(), version, detail: 'already installed' };
-    }
-    return provision(options, false);
-}
-/** Refresh the bundled Headroom to the newest release. */
-export async function updateHeadroom(options = {}) {
-    if (bundleDisabled())
-        return skippedResult();
-    if (!headroomBundleInstalled() && !options.dryRun && !existsSync(headroomVenvPython())) {
-        return installHeadroom(options);
-    }
-    const result = await provision(options, true);
-    if (result.ok && result.version) {
-        const beyond = parseHeadroomVersion(result.version);
-        if (beyond && beyond !== HEADROOM_TESTED_VERSION && beyond > HEADROOM_TESTED_VERSION) {
-            sayTagged(`  [warn] Headroom ${beyond} is newer than the tested ${HEADROOM_TESTED_VERSION}`);
-        }
-    }
-    return result;
-}
-// --- remove ----------------------------------------------------------------------------
-/** Removes the venv and anything else the bundle created, including a uv copy Tersio downloaded. */
-export async function removeHeadroomBundle(options = {}) {
-    const root = headroomBundleDir();
-    if (!existsSync(root))
-        return true;
-    // Removal still happens under the skip flag: an uninstall must not leave the bundle behind.
-    if (options.dryRun) {
-        sayTagged(`  [dry-run] would remove ${root}`);
-        return true;
-    }
-    try {
-        await fs.rm(root, { recursive: true, force: true });
-        sayTagged(`  [rm] ${root}`);
-        return true;
-    }
-    catch (e) {
-        sayTagged(`  [fail] could not remove ${root}: ${e.message}`);
-        return false;
-    }
-}
-/** True when the bundle holds a uv copy Tersio downloaded (as opposed to one the user had). */
-export function headroomOwnsUv() {
-    return existsSync(uvOwnedMarker());
-}