@krtclcdy/tersio 1.0.4 → 2.0.1

package/extensions/caveman-session/index.js

@@ -1,31 +1,30 @@
-import { readFileSync } from "node:fs";
-import { fileURLToPath } from "node:url";
-import { dirname, join } from "node:path";
-import { COMBO_LEVELS, getSharedComboState, isOmpSubagentPrompt, setSharedComboMode } from "../shared/session-state.js";
-import { readCavemanDefault } from "../shared/plugin-settings.js";
+import { readFileSync } from 'node:fs';
+import { fileURLToPath } from 'node:url';
+import { dirname, join } from 'node:path';
+import { asPromptArray, getSharedComboState, isComboPresetActive, isOmpSubagentPrompt, lastCustomValue, normalizeInputCommand, normalizeMode, paintStatusBar, reconcileSharedComboEntries, sessionEntries, setSharedComboMode } from '../shared/session-state.js';
+import { readCavemanDefault } from '../shared/plugin-settings.js';
 const CAVERN_DIR = dirname(fileURLToPath(import.meta.url));
-const RULE_PATH = join(CAVERN_DIR, "rule.md");
+const RULE_PATH = join(CAVERN_DIR, 'rule.md');
 const FALLBACK_FULL_RULE = `Respond terse like smart caveman. All technical substance stay. Only fluff die.
 
 Rules:
 - Drop articles (a/an/the), filler (just/really/basically), pleasantries, hedging.
 - Fragments OK. Short synonyms. Technical terms exact. Code unchanged.
 - Pattern: [thing] [action] [reason]. [next step].
-- Not: "Sure! I'd be happy to help you with that."
-- Yes: "Bug in auth middleware. Fix:"
+- Not: 'Sure! I'd be happy to help you with that.'
+- Yes: 'Bug in auth middleware. Fix:'
 
 Auto-clarity: drop caveman for security warnings, irreversible actions, or when user seems confused. Resume after.`;
 // ponytail: synchronous read each full-mode injection; ceiling = small file, cold session start. Upgrade path: cache file contents + mtime, invalidate on change.
 function readFullRule() {
     try {
-        return readFileSync(RULE_PATH, "utf8");
+        return readFileSync(RULE_PATH, 'utf8');
     }
     catch {
         return FALLBACK_FULL_RULE;
     }
 }
-const DEFAULT_MODE = "off";
-const MODES = new Set(["off", "lite", "full", "ultra", "wenyan"]);
+const DEFAULT_MODE = 'off';
 const INSTRUCTIONS = {
     lite: `Caveman lite active for this session.
 Respond concise. Drop pleasantries, filler, and hedging. Keep complete technical substance. Code, commands, paths, errors, commits, and PR text stay normal/exact.`,
@@ -35,26 +34,12 @@ Maximum terse prose. Fragments preferred. No pleasantries, no tour, no recap unl
     wenyan: `Caveman wenyan active for this session.
 Use ultra-terse classical-Chinese-style prose only where it preserves clarity for the user. Keep technical terms, code, commands, commits, PR text, paths, and errors exact. If clarity would suffer, use caveman full instead.`,
 };
-function normalizeMode(value) {
-    const mode = String(value || "").trim().toLowerCase();
-    return MODES.has(mode) ? mode : null;
-}
 function resolveMode(entries, fallback = DEFAULT_MODE) {
-    if (!Array.isArray(entries))
-        return fallback;
-    for (let i = entries.length - 1; i >= 0; i -= 1) {
-        const entry = entries[i];
-        if (entry?.type !== "custom" || entry?.customType !== "caveman-mode")
-            continue;
-        const mode = normalizeMode(entry?.data?.mode);
-        if (mode)
-            return mode;
-    }
-    return fallback;
+    return lastCustomValue(entries, 'caveman-mode', (data) => normalizeMode('caveman', data?.mode)) ?? fallback;
 }
 function isOffCommand(text) {
-    const t = String(text || "").trim().toLowerCase().replace(/[.!?\s]+$/, "");
-    return t === "stop caveman" || t === "normal mode" || t === "caveman off";
+    const t = normalizeInputCommand(text);
+    return t === 'stop caveman' || t === 'normal mode' || t === 'caveman off';
 }
 export default function cavemanSessionExtension(pi) {
     let currentMode = DEFAULT_MODE;
@@ -67,87 +52,88 @@ export default function cavemanSessionExtension(pi) {
         if (!c?.ui?.setStatus)
             return;
         // Combo owns the bar when any preset is active; keep ours empty to avoid duplication.
-        if (getSharedComboState().level in COMBO_LEVELS && getSharedComboState().level !== "off") {
-            c.ui.setStatus("caveman", undefined);
+        if (isComboPresetActive() || currentMode === 'off') {
+            c.ui.setStatus('caveman', undefined);
             return;
         }
-        if (currentMode === "off") {
-            c.ui.setStatus("caveman", undefined);
-            return;
-        }
-        const theme = c.ui.theme;
-        const indicator = isActive && theme?.fg ? theme.fg("accent", "🪨") : "🪨";
-        const label = `caveman: ${currentMode.toUpperCase()}`;
-        c.ui.setStatus("caveman", theme?.fg ? `${indicator} ${theme.fg("muted", label)}` : `${indicator} ${label}`);
+        paintStatusBar(c.ui, 'caveman', '🪨', `caveman: ${currentMode.toUpperCase()}`, isActive);
     }
     function setMode(mode, ctx) {
-        const normalized = normalizeMode(mode);
+        const normalized = normalizeMode('caveman', mode);
         if (!normalized)
             return false;
         currentMode = normalized;
-        pi.appendEntry?.("caveman-mode", { mode: normalized });
-        setSharedComboMode("caveman", normalized);
+        pi.appendEntry?.('caveman-mode', { mode: normalized });
+        setSharedComboMode('caveman', normalized);
         syncStatus(ctx);
-        ctx?.ui?.notify?.(`Caveman mode ${normalized === "off" ? "off" : `set to ${normalized}`}.`, "info");
+        const msg = normalized === 'off' ? 'Caveman mode off.' : `Caveman mode set to ${normalized}.`;
+        ctx?.ui?.notify?.(msg, 'info');
         return true;
     }
-    pi.setLabel?.("Caveman session toggle");
-    pi.registerCommand?.("caveman", {
-        description: "Toggle terse caveman replies for this session",
+    pi.setLabel?.('Caveman session toggle');
+    pi.registerCommand?.('caveman', {
+        description: 'Toggle terse caveman replies for this session',
         handler: async (args, ctx) => {
-            const arg = String(args || "").trim().toLowerCase();
-            if (!arg || arg === "on") {
-                setMode("full", ctx);
+            const arg = String(args || '').trim().toLowerCase();
+            if (!arg || arg === 'on') {
+                setMode('full', ctx);
                 return;
             }
-            if (arg === "status") {
-                ctx?.ui?.notify?.(`Caveman: ${currentMode}`, "info");
+            if (arg === 'status') {
+                ctx?.ui?.notify?.(`Caveman: ${currentMode}`, 'info');
                 return;
             }
             if (!setMode(arg, ctx)) {
-                ctx?.ui?.notify?.("Usage: /caveman [lite|full|ultra|wenyan|off|status]", "warning");
+                ctx?.ui?.notify?.('Usage: /caveman [lite|full|ultra|wenyan|off|status]', 'warning');
             }
         },
     });
-    pi.on("input", async (event) => {
-        if (event?.source === "extension")
+    pi.on('input', async (event) => {
+        if (event?.source === 'extension')
             return;
-        if (currentMode !== "off" && isOffCommand(event?.text))
-            setMode("off");
+        if (currentMode !== 'off' && isOffCommand(event?.text))
+            setMode('off');
     });
     function restoreMode(ctx) {
-        const entries = ctx?.sessionManager?.getBranch?.() || ctx?.sessionManager?.getEntries?.() || [];
+        const entries = sessionEntries(ctx);
+        // Publish the persisted combo state (incl. combo-level) before painting:
+        // bar suppression reads the in-process bridge, which is empty in a fresh
+        // host until the combo extension reconciles — and its reconcile is
+        // UI-gated. Deriving it here makes suppression independent of load order.
+        reconcileSharedComboEntries(entries);
         // Persisted session state wins; a fresh session falls back to the
         // installer/user-configured default (off unless configured).
-        const persisted = resolveMode(entries, "");
+        const persisted = resolveMode(entries, '');
         currentMode = persisted || readCavemanDefault();
         syncStatus(ctx);
     }
-    pi.on("session_start", async (_event, ctx) => {
+    pi.on('session_start', async (_event, ctx) => {
         restoreMode(ctx);
-        ctx?.ui?.notify?.(`Caveman loaded: ${currentMode}`, "info");
+        ctx?.ui?.notify?.(`Caveman loaded: ${currentMode}`, 'info');
     });
-    pi.on("session_branch", async (_event, ctx) => {
+    pi.on('session_branch', async (_event, ctx) => {
         restoreMode(ctx);
     });
-    pi.on("session_tree", async (_event, ctx) => {
+    pi.on('session_tree', async (_event, ctx) => {
         restoreMode(ctx);
     });
-    pi.on("agent_start", async (_event, ctx) => {
+    pi.on('agent_start', async (_event, ctx) => {
         isActive = true;
         syncStatus(ctx);
     });
-    pi.on("agent_end", async (_event, ctx) => {
+    pi.on('agent_end', async (_event, ctx) => {
         isActive = false;
         syncStatus(ctx);
     });
-    pi.on("before_agent_start", async (event) => {
+    pi.on('before_agent_start', async (event) => {
         const mode = isOmpSubagentPrompt(event.systemPrompt) ? getSharedComboState().caveman : currentMode;
-        if (!mode || mode === "off")
+        if (!mode || mode === 'off')
             return;
         const def = INSTRUCTIONS[mode];
-        const instruction = typeof def === "function" ? def() : def;
-        const base = Array.isArray(event.systemPrompt) ? event.systemPrompt : [event.systemPrompt];
+        if (!def)
+            return;
+        const instruction = typeof def === 'function' ? def() : def;
+        const base = asPromptArray(event.systemPrompt);
         return { systemPrompt: [...base, instruction] };
     });
 }

package/extensions/combo-toggle/index.js

@@ -1,42 +1,34 @@
 // /combo session toggle — set all three (caveman, rtk, ponytail) at once.
 // Modes: off | medium | balanced | max
-import os from "node:os";
-import path from "node:path";
-import { createRequire } from "node:module";
-import { COMBO_LEVELS, getSharedComboState, isOmpSubagentPrompt, normalizeComboLevel, reconcileSharedComboEntries, setSharedComboLevel, setSharedComboListener, } from "../shared/session-state.js";
-import { readComboDefault } from "../shared/plugin-settings.js";
+import os from 'node:os';
+import path from 'node:path';
+import { createRequire } from 'node:module';
+import { asPromptArray, COMBO_LEVELS, getSharedComboState, isComboPresetActive, isOmpSubagentPrompt, normalizeComboLevel, reconcileSharedComboEntries, sessionEntries, setSharedComboLevel, setSharedComboListener, systemPromptIncludes, } from '../shared/session-state.js';
+import { readComboDefault } from '../shared/plugin-settings.js';
 const require = createRequire(import.meta.url);
+const PONYTAIL_FALLBACK_INTENSITY = {
+    lite: 'Prefer the simplest correct solution.',
+    review: 'Review only for avoidable complexity; recommend the smallest correct replacement.',
+};
 function ponytailFallback(mode) {
-    const intensity = mode === "lite"
-        ? "Prefer the simplest correct solution."
-        : mode === "review"
-            ? "Review only for avoidable complexity; recommend the smallest correct replacement."
-            : "Use the minimum correct solution. Delete or reuse before adding.";
+    const intensity = PONYTAIL_FALLBACK_INTENSITY[mode] ?? 'Use the minimum correct solution. Delete or reuse before adding.';
     return `🦥 PONYTAIL MODE ACTIVE — level: ${mode}\n${intensity} Understand the path first and fix root causes, not symptoms. Prefer the standard library and YAGNI. Avoid speculative abstractions and dependencies. Preserve correctness. Verify changed behavior.`;
 }
-function entriesFrom(ctx) {
-    return ctx?.sessionManager?.getBranch?.() || ctx?.sessionManager?.getEntries?.() || [];
-}
 function levelSummary(state) {
     return `caveman=${state.caveman} rtk=${state.rtk} ponytail=${state.ponytail}`;
 }
-function hasPonytailInstructions(systemPrompt) {
-    const prompts = Array.isArray(systemPrompt) ? systemPrompt : [systemPrompt];
-    return prompts.some((prompt) => typeof prompt === "string" && prompt.includes("PONYTAIL MODE ACTIVE"));
-}
 function loadPonytailInstructions(mode) {
     try {
-        const installed = path.join(os.homedir(), ".omp", "plugins", "node_modules", "@dietrichgebert", "ponytail", "hooks", "ponytail-instructions.js");
+        const installed = path.join(os.homedir(), '.omp', 'plugins', 'node_modules', '@dietrichgebert', 'ponytail', 'hooks', 'ponytail-instructions.js');
         const { getPonytailInstructions } = require(installed);
-        if (typeof getPonytailInstructions === "function")
+        if (typeof getPonytailInstructions === 'function')
             return getPonytailInstructions(mode);
     }
     catch { }
     return ponytailFallback(mode);
 }
 export default function comboToggleExtension(pi) {
-    pi.setLabel?.("Combo session toggle (all 3 add-ons)");
-    let currentState = getSharedComboState();
+    pi.setLabel?.('Combo session toggle (all 3 add-ons)');
     let lastCtx = undefined;
     function syncStatus(ctx) {
         if (ctx)
@@ -46,117 +38,112 @@ export default function comboToggleExtension(pi) {
             return;
         // Single unified bar replaces the three per-extension bars while a preset is
         // active. In custom/off, the individual bars come back and combo stays clear.
-        if (currentState.level !== "medium" && currentState.level !== "balanced" && currentState.level !== "max") {
-            c.ui.setStatus("combo", undefined);
+        if (!isComboPresetActive()) {
+            c.ui.setStatus('combo', undefined);
             return;
         }
+        // Read the live bridge, not cached extension state: sibling extensions
+        // reconcile it from persisted entries before this one runs.
+        const state = getSharedComboState();
         const theme = c.ui.theme;
-        const c0 = currentState.caveman.toUpperCase();
-        const r = currentState.rtk.toUpperCase();
-        const p = currentState.ponytail.toUpperCase();
-        const lvl = currentState.level.toUpperCase();
+        const c0 = state.caveman.toUpperCase();
+        const r = state.rtk.toUpperCase();
+        const p = state.ponytail.toUpperCase();
+        const lvl = state.level.toUpperCase();
         const label = `combo ${lvl}: 🪨caveman=${c0} ⚡rtk=${r} 🦥ponytail=${p}`;
-        c.ui.setStatus("combo", theme?.fg ? `${theme.fg("accent", "🧩")} ${theme.fg("muted", label)}` : `🧩 ${label}`);
+        c.ui.setStatus('combo', theme?.fg ? `${theme.fg('accent', '🧩')} ${theme.fg('muted', label)}` : `🧩 ${label}`);
         // Clobber any sibling bars another extension may have painted in a race
         // during session_start — our bar is canonical for the duration of the preset.
-        c.ui.setStatus("caveman", undefined);
-        c.ui.setStatus("rtk", undefined);
-        c.ui.setStatus("ponytail", undefined);
+        c.ui.setStatus('caveman', undefined);
+        c.ui.setStatus('rtk', undefined);
+        c.ui.setStatus('ponytail', undefined);
     }
     // ponytail: same persistence as /combo — siblings (incl. upstream ponytail)
     // restore from these entries, so the fallback must write them too or the
     // preset evaporates on resume and ponytail never activates.
     function persistPreset(level) {
         const modes = COMBO_LEVELS[level];
-        pi.appendEntry?.("caveman-mode", { mode: modes.caveman });
-        pi.appendEntry?.("rtk-mode", { enabled: modes.rtk === "on" });
-        pi.appendEntry?.("ponytail-mode", { mode: modes.ponytail });
-        pi.appendEntry?.("combo-level", { level });
+        pi.appendEntry?.('caveman-mode', { mode: modes.caveman });
+        pi.appendEntry?.('rtk-mode', { enabled: modes.rtk === 'on' });
+        pi.appendEntry?.('ponytail-mode', { mode: modes.ponytail });
+        pi.appendEntry?.('combo-level', { level });
     }
     function useState(state, ctx) {
-        currentState = state;
         syncStatus(ctx);
         return state;
     }
     function reconcile(ctx) {
         if (!ctx?.hasUI)
-            return currentState;
-        return useState(reconcileSharedComboEntries(entriesFrom(ctx)), ctx);
+            return getSharedComboState();
+        return useState(reconcileSharedComboEntries(sessionEntries(ctx)), ctx);
     }
     function listen(ctx) {
         if (ctx?.hasUI)
             setSharedComboListener((state) => useState(state));
     }
-    pi.registerCommand?.("combo", {
-        description: "Toggle all 3 OMP add-ons at once. Usage: /combo <off|medium|balanced|max|status>",
+    function track(ctx) {
+        listen(ctx);
+        if (ctx?.hasUI)
+            reconcile(ctx);
+    }
+    pi.registerCommand?.('combo', {
+        description: 'Toggle all 3 OMP add-ons at once. Usage: /combo <off|medium|balanced|max|status>',
         handler: async (args, ctx) => {
             listen(ctx);
-            const arg = String(args || "").trim().toLowerCase();
-            if (!arg || arg === "status") {
+            const arg = String(args || '').trim().toLowerCase();
+            if (!arg || arg === 'status') {
                 const state = reconcile(ctx);
-                ctx?.ui?.notify?.(`Combo: ${state.level === "custom" ? "INACTIVE" : state.level.toUpperCase()} (${levelSummary(state)})`, "info");
+                ctx?.ui?.notify?.(`Combo: ${state.level === 'custom' ? 'INACTIVE' : state.level.toUpperCase()} (${levelSummary(state)})`, 'info');
                 return;
             }
-            if (arg === "help") {
-                ctx?.ui?.notify?.("/combo off      — disables all 3 (caveman, rtk, ponytail)\n" +
-                    "/combo medium   — light: caveman=lite, rtk=on, ponytail=lite\n" +
-                    "/combo balanced — middle: caveman=full, rtk=on, ponytail=full\n" +
-                    "/combo max      — aggressive: caveman=ultra, rtk=on, ponytail=ultra", "info");
+            if (arg === 'help') {
+                ctx?.ui?.notify?.('/combo off      — disables all 3 (caveman, rtk, ponytail)\n' +
+                    '/combo medium   — light: caveman=lite, rtk=on, ponytail=lite\n' +
+                    '/combo balanced — middle: caveman=full, rtk=on, ponytail=full\n' +
+                    '/combo max      — aggressive: caveman=ultra, rtk=on, ponytail=ultra', 'info');
                 return;
             }
             const level = normalizeComboLevel(arg);
             if (!level) {
-                ctx?.ui?.notify?.(`Unknown combo level: ${arg}. Use: off | medium | balanced | max`, "warning");
+                ctx?.ui?.notify?.(`Unknown combo level: ${arg}. Use: off | medium | balanced | max`, 'warning');
                 return;
             }
             persistPreset(level);
             useState(setSharedComboLevel(level), ctx);
-            ctx?.ui?.notify?.(`Combo ${level} applied: ${levelSummary(currentState)}`, "info");
+            ctx?.ui?.notify?.(`Combo ${level} applied: ${levelSummary(getSharedComboState())}`, 'info');
             if (ctx?.reload)
                 await ctx.reload();
         },
     });
-    pi.on("session_start", async (_event, ctx) => {
-        listen(ctx);
-        if (ctx?.hasUI)
-            reconcile(ctx);
-        else
+    pi.on('session_start', async (_event, ctx) => {
+        track(ctx);
+        if (!ctx?.hasUI)
             syncStatus(ctx);
         // Installer/user-configured default applies only to a fresh session with
         // no persisted state — real session state always wins.
-        if (getSharedComboState().level === "off" && !(ctx?.sessionManager?.getBranch?.() || ctx?.sessionManager?.getEntries?.() || []).length) {
+        if (getSharedComboState().level === 'off' && !sessionEntries(ctx).length) {
             const fallback = readComboDefault();
-            if (fallback !== "off") {
+            if (fallback !== 'off') {
                 persistPreset(fallback);
                 useState(setSharedComboLevel(fallback), ctx);
-                ctx?.ui?.notify?.(`Combo default applied: ${fallback}`, "info");
+                ctx?.ui?.notify?.(`Combo default applied: ${fallback}`, 'info');
             }
         }
     });
-    pi.on("session_branch", async (_event, ctx) => {
-        listen(ctx);
-        if (ctx?.hasUI)
-            reconcile(ctx);
-    });
-    pi.on("session_tree", async (_event, ctx) => {
-        listen(ctx);
-        if (ctx?.hasUI)
-            reconcile(ctx);
-    });
-    pi.on("agent_start", async (_event, ctx) => {
-        listen(ctx);
-        if (ctx?.hasUI)
-            reconcile(ctx);
-    });
-    pi.on("before_agent_start", async (event, ctx) => {
+    for (const event of ['session_branch', 'session_tree', 'agent_start']) {
+        pi.on(event, async (_event, ctx) => {
+            track(ctx);
+        });
+    }
+    pi.on('before_agent_start', async (event, ctx) => {
         if (ctx?.hasUI)
             reconcile(ctx);
         if (!isOmpSubagentPrompt(event.systemPrompt))
             return;
         const mode = getSharedComboState().ponytail;
-        if (mode === "off" || hasPonytailInstructions(event.systemPrompt))
+        if (mode === 'off' || systemPromptIncludes(event.systemPrompt, 'PONYTAIL MODE ACTIVE'))
             return;
-        const base = Array.isArray(event.systemPrompt) ? event.systemPrompt : [event.systemPrompt];
+        const base = asPromptArray(event.systemPrompt);
         return { systemPrompt: [...base, loadPonytailInstructions(mode)] };
     });
     // Slash commands only; natural-language input caused accidental toggles and has no reload context.

package/extensions/lib/utils.js

@@ -1,30 +1,49 @@
 // Shared helpers for the installer and the AI add-ons updater.
 // Node built-ins only — this module must stay dependency-free.
-import { createHash } from "node:crypto";
-import { createWriteStream } from "node:fs";
-import fs from "node:fs/promises";
-import https from "node:https";
-import path from "node:path";
+import { createHash } from 'node:crypto';
+import { createWriteStream } from 'node:fs';
+import fs from 'node:fs/promises';
+import https from 'node:https';
+import path from 'node:path';
 // Promise.withResolvers is Node 22+; the package supports Node 18+.
 // ponytail: swap for the built-in when engines bumps to >=22.
-function withResolvers() {
+export function withResolvers() {
     let resolve;
     let reject;
     const promise = new Promise((res, rej) => { resolve = res; reject = rej; });
     return { promise, resolve, reject };
 }
+export const RTK_RELEASE_API = 'https://api.github.com/repos/rtk-ai/rtk/releases/latest';
+export const CAVEMAN_REMOTE_RULE = 'https://raw.githubusercontent.com/JuliusBrussee/caveman/main/src/rules/caveman-activate.md';
+const RTK_PLATFORM_SPECS = {
+    'win32/x64': { triple: 'x86_64-pc-windows-msvc', ext: '.zip', binary: 'rtk.exe' },
+    'linux/x64': { triple: 'x86_64-unknown-linux-musl', ext: '.tar.gz', binary: 'rtk' },
+    'linux/arm64': { triple: 'aarch64-unknown-linux-gnu', ext: '.tar.gz', binary: 'rtk' },
+    'darwin/x64': { triple: 'x86_64-apple-darwin', ext: '.tar.gz', binary: 'rtk' },
+    'darwin/arm64': { triple: 'aarch64-apple-darwin', ext: '.tar.gz', binary: 'rtk' },
+};
+export function rtkPlatformSpec(platform = process.platform, arch = process.arch) {
+    return RTK_PLATFORM_SPECS[`${platform}/${arch}`] || null;
+}
+// Single source for the 3xx+location redirect rule shared by httpsGet/httpsDownload.
+function redirectNext(res, url) {
+    if (res.statusCode !== undefined && res.statusCode >= 300 && res.statusCode < 400 && res.headers.location) {
+        return new URL(res.headers.location, url).href;
+    }
+    return null;
+}
 export function httpsGet(url, opts = {}) {
     const { promise, resolve, reject } = withResolvers();
     const maxRedirects = opts.maxRedirects ?? 5;
-    const req = https.get(url, { headers: { "User-Agent": "tersio", Accept: "application/json,*/*" } }, (res) => {
-        if (res.statusCode !== undefined && res.statusCode >= 300 && res.statusCode < 400 && res.headers.location) {
+    const req = https.get(url, { headers: { 'User-Agent': 'tersio', Accept: 'application/json,*/*' } }, (res) => {
+        const next = redirectNext(res, url);
+        if (next) {
             if (maxRedirects <= 0) {
                 res.resume();
                 reject(new Error(`Too many redirects fetching ${url}`));
                 return;
             }
             res.resume();
-            const next = new URL(res.headers.location, url).href;
             resolve(httpsGet(next, { maxRedirects: maxRedirects - 1 }));
             return;
         }
@@ -33,28 +52,28 @@ export function httpsGet(url, opts = {}) {
             reject(new Error(`HTTP ${res.statusCode} for ${url}`));
             return;
         }
-        let body = "";
+        let body = '';
         // ponytail: streamed accumulation — fine for tens of KB; stream-pipe if assets ever exceed a few MB.
-        res.setEncoding("utf8");
-        res.on("data", (chunk) => { body += chunk; });
-        res.on("end", () => resolve(body));
+        res.setEncoding('utf8');
+        res.on('data', (chunk) => { body += chunk; });
+        res.on('end', () => resolve(body));
     });
-    req.on("error", reject);
+    req.on('error', reject);
     req.setTimeout(30000, () => req.destroy(new Error(`Timeout fetching ${url}`)));
     return promise;
 }
 export function httpsDownload(url, dest, opts = {}) {
     const { promise, resolve, reject } = withResolvers();
     const maxRedirects = opts.maxRedirects ?? 5;
-    const req = https.get(url, { headers: { "User-Agent": "tersio", Accept: "*/*" } }, (res) => {
-        if (res.statusCode !== undefined && res.statusCode >= 300 && res.statusCode < 400 && res.headers.location) {
+    const req = https.get(url, { headers: { 'User-Agent': 'tersio', Accept: '*/*' } }, (res) => {
+        const next = redirectNext(res, url);
+        if (next) {
             if (maxRedirects <= 0) {
                 res.resume();
                 reject(new Error(`Too many redirects downloading ${url}`));
                 return;
             }
             res.resume();
-            const next = new URL(res.headers.location, url).href;
             resolve(httpsDownload(next, dest, { maxRedirects: maxRedirects - 1 }));
             return;
         }
@@ -65,19 +84,26 @@ export function httpsDownload(url, dest, opts = {}) {
         }
         const file = createWriteStream(dest);
         res.pipe(file);
-        file.on("finish", () => file.close(() => resolve()));
-        file.on("error", reject);
+        file.on('finish', () => file.close(() => resolve()));
+        file.on('error', (err) => {
+            req.destroy();
+            res.resume();
+            reject(err);
+        });
     });
-    req.on("error", reject);
+    req.on('error', reject);
     req.setTimeout(120000, () => req.destroy(new Error(`Timeout downloading ${url}`)));
     return promise;
 }
+export async function fetchJson(url) {
+    return JSON.parse(await httpsGet(url));
+}
 export function sha256Hex(text) {
-    return createHash("sha256").update(text, "utf8").digest("hex");
+    return createHash('sha256').update(text, 'utf8').digest('hex');
 }
 export async function sha256File(filePath) {
     const buf = await fs.readFile(filePath);
-    return createHash("sha256").update(buf).digest("hex");
+    return createHash('sha256').update(buf).digest('hex');
 }
 export function parseChecksum(checksumsText, assetName) {
     const target = path.basename(assetName);
@@ -88,14 +114,41 @@ export function parseChecksum(checksumsText, assetName) {
     }
     return null;
 }
+export async function findFile(dir, name) {
+    try {
+        const ents = await fs.readdir(dir, { withFileTypes: true });
+        for (const e of ents) {
+            const full = path.join(dir, e.name);
+            if (e.isDirectory()) {
+                const found = await findFile(full, name);
+                if (found)
+                    return found;
+            }
+            else if (e.isFile()) {
+                if (e.name === name)
+                    return full;
+                // Match rtk-* asset names (e.g. rtk-x86_64-unknown-linux-musl).
+                if (name === 'rtk' || name === 'rtk.exe') {
+                    const base = e.name.toLowerCase();
+                    if (!/\.(txt|md|json|sha256|sig|asc|pem|crt|license)$/i.test(base)) {
+                        if (base === 'rtk' || base === 'rtk.exe' || /^rtk[-_.]/.test(base))
+                            return full;
+                    }
+                }
+            }
+        }
+    }
+    catch { /* ignore */ }
+    return null;
+}
 export async function readTextIfExists(p) {
     try {
-        return await fs.readFile(p, "utf8");
+        return await fs.readFile(p, 'utf8');
     }
     catch {
         return null;
     }
 }
 export function normalizeRtkVersion(value) {
-    return String(value || "").replace(/^rtk\s+/i, "").replace(/^v/i, "").trim();
+    return String(value || '').replace(/^rtk\s+/i, '').replace(/^v/i, '').trim();
 }