@krtclcdy/tersio 2.25.2 → 2.25.3

package/{cli → dist/cli}/common.js

@@ -4,7 +4,8 @@ import { promises as fs } from 'node:fs';
 import path from 'node:path';
 import { promisify } from 'node:util';
 import { createRequire } from 'node:module';
-import { readTextIfExists } from '../extensions/lib/utils.js';
+import { fileURLToPath } from 'node:url';
+import { findPackageRoot, readTextIfExists } from '../extensions/lib/utils.js';
 import { parseCurrencyFlag, readStoredCurrency } from './currency.js';
 const IS_WINDOWS = process.platform === 'win32';
 const RTK_BINARY_NAME = IS_WINDOWS ? 'rtk.exe' : 'rtk';
@@ -15,8 +16,8 @@ const BUN_BIN_DIR = path.join(HOME, '.bun', 'bin');
 const OMP_BIN = IS_WINDOWS ? 'omp.cmd' : 'omp';
 const PACKAGE_NAME = '@krtclcdy/tersio';
 const PACKAGE_BIN = 'tersio';
-const { version: PACKAGE_VERSION } = createRequire(import.meta.url)('../package.json');
-const CAVEMAN_DEFAULTS = new Set(['off', 'lite', 'full', 'ultra', 'wenyan-lite', 'wenyan-full', 'wenyan-ultra']);
+const { version: PACKAGE_VERSION } = createRequire(import.meta.url)(path.join(findPackageRoot(path.dirname(fileURLToPath(import.meta.url))), 'package.json'));
+const CAVEMAN_DEFAULTS = new Set(['off', 'lite', 'full', 'ultra', 'megacave-lite', 'megacave-full', 'megacave-ultra']);
 const PONYTAIL_DEFAULTS = new Set(['off', 'lite', 'full', 'ultra']);
 const RTK_DEFAULTS = new Set(['on', 'off']);
 const DIAG_SCHEDULES = new Set(['manual', 'daily', 'weekly', 'monthly']);

package/{cli → dist/cli}/dashboard.js

@@ -16,8 +16,8 @@ import { BACKUP_SCHEDULES, formatCliStatus, storedProfile, writePluginSettings }
 import { normalizeComboLevel } from '../extensions/shared/session-state.js';
 import { CAVEMAN_DEFAULTS, PONYTAIL_DEFAULTS } from './common.js';
 import { PACKAGE_NAME } from './common.js';
-import { resolveRtkBinary } from '../extensions/lib/utils.js';
-const DASHBOARD_DIST = path.join(path.dirname(fileURLToPath(import.meta.url)), '..', 'dashboard', 'dist');
+import { findPackageRoot, resolveRtkBinary } from '../extensions/lib/utils.js';
+const DASHBOARD_DIST = path.join(findPackageRoot(path.dirname(fileURLToPath(import.meta.url))), 'dashboard', 'dist');
 const DASHBOARD_INDEX = path.join(DASHBOARD_DIST, 'index.html');
 const DASHBOARD_BRAND = path.join(DASHBOARD_DIST, 'brand.webp');
 function requireDashboardBundle() {
@@ -634,17 +634,34 @@ async function runDashboard(options) {
         res.writeHead(200, { 'Content-Type': 'text/html; charset=utf-8' });
         res.end(await readSegment(DASHBOARD_INDEX));
     });
-    server.listen(options.port, '127.0.0.1', () => {
-        try {
-            process.title = 'tersio dashboard';
-        }
-        catch { /* non-POSIX shells keep node */ }
-        const address = server.address();
-        const port = typeof address === 'object' && address ? address.port : options.port;
-        const url = `http://127.0.0.1:${port}`;
-        console.log(`[ok] Dashboard live → ${url} (Ctrl-C to stop)`);
-        if (options.open)
-            openBrowser(url);
+    await new Promise((resolve, reject) => {
+        let stopping = false;
+        const rejectOnce = (err) => {
+            if (!stopping)
+                reject(err);
+        };
+        const stop = () => {
+            if (stopping)
+                return;
+            stopping = true;
+            server.close(() => resolve());
+            server.closeIdleConnections();
+        };
+        process.once('SIGINT', stop);
+        process.once('SIGTERM', stop);
+        server.once('error', rejectOnce);
+        server.listen(options.port, '127.0.0.1', () => {
+            try {
+                process.title = 'tersio dashboard';
+            }
+            catch { /* non-POSIX shells keep node */ }
+            const address = server.address();
+            const port = typeof address === 'object' && address ? address.port : options.port;
+            const url = `http://127.0.0.1:${port}`;
+            console.log(`[ok] Dashboard live → ${url} (Ctrl-C to stop)`);
+            if (options.open)
+                openBrowser(url);
+        });
     });
 }
 export { runDashboard, saveDashboardCurrency, readDiagSchedule, setDiagSchedule };

package/{cli → dist/cli}/doctor-fix.js

@@ -1,15 +1,13 @@
 import { existsSync, promises as fs } from 'node:fs';
 import os from 'node:os';
 import path from 'node:path';
-import { fileURLToPath } from 'node:url';
 import { BUN_BIN_DIR, OMP_AGENT_DIR, OMP_PLUGINS_DIR, PACKAGE_NAME, PACKAGE_VERSION, RTK_BINARY_NAME, removeExtensionFromConfig, dryRun, verbose, debug, execP, readPluginsPackage, writeIfChanged, } from './common.js';
 import { execNetwork, sayTagged } from './interactive.js';
 import { wireRtkOmp, wireRtkOpencode, wireRtkPi, ensureRtkInConfig } from './rtk-wiring.js';
 import { RTK_RELEASE_API, fetchJson, findFile, httpsGet, httpsDownload, parseChecksum, readTextIfExists, rtkPlatformSpec, sha256File, } from '../extensions/lib/utils.js';
 import { runLatestUpdate } from './update.js';
-import { OPENCODE_SERVER_SHIM, TREE_FILES, sourcePath } from './manifest.js';
+import { EXT_DIR, OPENCODE_SERVER_SHIM, TREE_FILES, sourcePath } from './manifest.js';
 import { detectHosts, hostExtensionsDir } from './hosts.js';
-const EXT_DIR = path.join(path.dirname(fileURLToPath(import.meta.url)), '..', 'extensions');
 // A written tree is the install for both hosts now, so --fix restores it for whichever hosts have it, alongside the OMP package when that is present.
 async function fixExtensionTrees() {
     // The opencode entrypoint is foreign to pi/omp loaders: never copy it there, and remove strays.

package/{cli → dist/cli}/doctor.js

@@ -6,7 +6,7 @@ import { detectHosts, hostExtensionsDir, ompPackageDir } from './hosts.js';
 import { askInteractiveChoice, askInteractiveConfirm, runInteractivePhase } from './interactive.js';
 import { usageDbPath } from '../extensions/shared/usage-store.js';
 import { pricesCachePath } from '../extensions/shared/pricing.js';
-import { readTextIfExists, resolveRtkBinary } from '../extensions/lib/utils.js';
+import { readTextIfExists, resolveRtkBinary, ruleBodyProblem } from '../extensions/lib/utils.js';
 import { TREE_FILES } from './manifest.js';
 async function runDoctor(recheck = false) {
     console.log('\n=== Tersio Doctor ===');
@@ -30,7 +30,7 @@ async function runDoctor(recheck = false) {
         cavemanIndexText: readTextIfExists(cavemanIndex),
         cavemanRuleText: readTextIfExists(cavemanRule('rule.md')),
         cavemanUltraText: readTextIfExists(cavemanRule('rule-ultra.md')),
-        cavemanWenyanText: readTextIfExists(cavemanRule('rule-wenyan.md')),
+        cavemanMegacaveText: readTextIfExists(cavemanRule('rule-megacave.md')),
         rtkIndexText: readTextIfExists(rtkIndex),
         updaterIndexText: readTextIfExists(updaterIndex),
         rtkMtime: rtkBin ? fs.stat(rtkBin).catch(() => null) : Promise.resolve(null),
@@ -42,7 +42,7 @@ async function runDoctor(recheck = false) {
         const err = e;
         return err.stdout?.trim() || err.stderr?.trim() || null;
     }) : Promise.resolve(null);
-    const [[ompPkgText, configText], [cavemanIndexText, rtkIndexText, updaterIndexText, ponytailPkgText], [cavemanRuleText, cavemanUltraText, cavemanWenyanText, ruleMtime, rtkBinText, rtkMtime, rtkVersion, ponytailMtime, pricesMtime]] = await runInteractivePhase('Checking installation', () => Promise.all([
+    const [[ompPkgText, configText], [cavemanIndexText, rtkIndexText, updaterIndexText, ponytailPkgText], [cavemanRuleText, cavemanUltraText, cavemanMegacaveText, ruleMtime, rtkBinText, rtkMtime, rtkVersion, ponytailMtime, pricesMtime]] = await runInteractivePhase('Checking installation', () => Promise.all([
         Promise.all([
             probes.ompPkgText,
             probes.configText,
@@ -56,7 +56,7 @@ async function runDoctor(recheck = false) {
         Promise.all([
             probes.cavemanRuleText,
             probes.cavemanUltraText,
-            probes.cavemanWenyanText,
+            probes.cavemanMegacaveText,
             probes.ruleMtime,
             probes.rtkBinText,
             probes.rtkMtime,
@@ -133,9 +133,16 @@ async function runDoctor(recheck = false) {
     check('Prices feed', pricesMtime !== null, pricesAge || pricesCachePath());
     section('Add-ons');
     const ruleAge = ruleMtime ? `(updated ${relTime(Date.now() - ruleMtime.mtimeMs)} · ${absDate(ruleMtime.mtimeMs)})` : '';
-    const cavemanRules = [['rule.md', cavemanRuleText], ['rule-ultra.md', cavemanUltraText], ['rule-wenyan.md', cavemanWenyanText]];
+    const cavemanRules = [['rule.md', cavemanRuleText], ['rule-ultra.md', cavemanUltraText], ['rule-megacave.md', cavemanMegacaveText]];
     const missingRules = cavemanRules.filter(([, text]) => text === null).map(([name]) => name);
     check('Caveman rule', missingRules.length === 0, missingRules.length ? `missing: ${missingRules.join(', ')}` : ruleAge);
+    for (const [name, text] of cavemanRules) {
+        if (text === null)
+            continue;
+        const problem = ruleBodyProblem(text);
+        if (problem)
+            warnLine(`Caveman ${name}`, `unusable body (${problem}) — run: tersio install`);
+    }
     const rtkAge = rtkMtime ? `(updated ${relTime(Date.now() - rtkMtime.mtimeMs)} · ${absDate(rtkMtime.mtimeMs)})` : '';
     check('RTK binary', rtkBin !== null, rtkBinText === null ? 'not found in PATH' : [rtkVersion, rtkAge].filter(Boolean).join(' '));
     // rtk_run needs a host exec API, which doctor cannot assume.

package/dist/cli/headroom-install.js

@@ -0,0 +1,266 @@
+// 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());
+}