@krtclcdy/tersio 2.25.4 → 2.25.6

package/dist/cli/doctor-fix.js

@@ -1,63 +1,181 @@
 import { existsSync, promises as fs } from 'node:fs';
+import { spawnSync } from 'node:child_process';
 import os from 'node:os';
 import path from 'node:path';
-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 { BUN_BIN_DIR, HOME, OMP_AGENT_DIR, OMP_PLUGINS_DIR, PACKAGE_NAME, PACKAGE_VERSION, RTK_BINARY_NAME, removeExtensionFromConfig, dryRun, verbose, debug, bundledPonytailSpec, execP, ponytailOverride, readPluginsPackage, } 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 { RTK_RELEASE_API, fetchJson, findFile, httpsGet, httpsDownload, parseChecksum, readTextIfExists, resolveHostBinary, rtkPlatformSpec, sha256File, } from '../extensions/shared/utils.js';
 import { runLatestUpdate } from './update.js';
-import { EXT_DIR, OPENCODE_SERVER_SHIM, TREE_FILES, sourcePath } from './manifest.js';
+import { OPENCODE_ENTRY, TREE_FILES, isObsoleteTreeFile, syncPluginManifest, syncTreeFiles, treeFilesFor } from './manifest.js';
 import { detectHosts, hostExtensionsDir } from './hosts.js';
-// 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.
-    const forHost = (id) => TREE_FILES.filter((file) => id === 'opencode' || !file.startsWith('opencode/'));
-    const scrubOpencodeDir = async (dest) => {
-        const dir = path.join(dest, 'opencode');
-        if (!existsSync(dir))
-            return;
-        if (dryRun) {
-            sayTagged(`  [dry-run] would remove foreign ${dir}`);
+/** Pids of `opencode serve --service` processes whose service manager no longer tracks them. The orphan holds the managed port, so the next start exits 1. */
+export function serviceOrphanPids() {
+    const bin = resolveHostBinary('opencode', path.join(HOME, '.opencode', 'bin'));
+    if (!bin)
+        return [];
+    let status = '';
+    try {
+        status = spawnSync(bin, ['service', 'status'], { encoding: 'utf8' }).stdout.trim().toLowerCase();
+    }
+    catch {
+        return [];
+    }
+    if (serviceRunning(status))
+        return [];
+    let out = '';
+    try {
+        out = spawnSync('pgrep', ['-f', 'opencode serve --service'], { encoding: 'utf8' }).stdout ?? '';
+    }
+    catch {
+        return [];
+    }
+    // Only digits: the value comes from another process, and `process.kill` throws on anything else.
+    return out.split(/[\s,]+/).filter((line) => /^\d+$/.test(line.trim())).map((line) => line.trim());
+}
+/** Whether OpenCode reports its service running, and whether a serve process is alive. */
+export function serviceState() {
+    const bin = resolveHostBinary('opencode', path.join(HOME, '.opencode', 'bin'));
+    if (!bin)
+        return null;
+    let status = '';
+    try {
+        status = spawnSync(bin, ['service', 'status'], { encoding: 'utf8' }).stdout.trim().toLowerCase();
+    }
+    catch {
+        return null;
+    }
+    if (status === '')
+        return null;
+    let live = false;
+    try {
+        const out = spawnSync('pgrep', ['-f', 'opencode serve --service'], { encoding: 'utf8' }).stdout ?? '';
+        live = out.split(/[\s,]+/).some((line) => /^\d+$/.test(line.trim()));
+    }
+    catch {
+        live = false;
+    }
+    return { status, live };
+}
+/** A running service reports its URL, so the word is only one of the answers. */
+export function serviceRunning(status) {
+    return status === 'running' || status.startsWith('http://') || status.startsWith('https://');
+}
+/** Every obsolete file under `dest`, or an empty list. `treeFilesFor` is what the install writes. */
+async function obsoleteFiles(dest, id) {
+    const keep = new Set(treeFilesFor(id));
+    const out = [];
+    const walk = async (dir, rel) => {
+        let entries;
+        try {
+            entries = await fs.readdir(dir, { withFileTypes: true });
+        }
+        catch {
             return;
         }
-        await fs.rm(dir, { recursive: true, force: true });
-        sayTagged(`  [rm] foreign ${dir}`);
+        for (const entry of entries) {
+            if (entry.name === 'node_modules' || entry.name === '.git')
+                continue;
+            const child = rel ? `${rel}/${entry.name}` : entry.name;
+            const at = path.join(dir, entry.name);
+            if (entry.isDirectory()) {
+                await walk(at, child);
+                continue;
+            }
+            if (keep.has(child))
+                continue;
+            if (isObsoleteTreeFile(child, id))
+                out.push(child);
+        }
+    };
+    await walk(dest, '');
+    return out;
+}
+/** Obsolete top-level directories, empty or not: a debris name is a whole directory, so a repair must drop the directory, not only the files inside it. */
+async function obsoleteDirs(dest, id) {
+    const out = [];
+    let entries;
+    try {
+        entries = await fs.readdir(dest, { withFileTypes: true });
+    }
+    catch {
+        return out;
+    }
+    for (const entry of entries) {
+        if (!entry.isDirectory())
+            continue;
+        if (isObsoleteTreeFile(entry.name, id))
+            out.push(entry.name);
+    }
+    return out;
+}
+// A written tree is the install for both hosts, so --fix restores it for whichever hosts have it.
+async function fixExtensionTrees() {
+    // The entry imports @opencode/plugin, which pi and omp lack, so one shared filter keeps repairs out of their trees.
+    const forHost = (id) => treeFilesFor(id);
+    // Older trees nested the entry; a repair under the old filter may have left it at the root, so remove both strays.
+    const scrubOpencodeEntry = async (dest) => {
+        for (const target of [path.join(dest, OPENCODE_ENTRY), path.join(dest, 'opencode')]) {
+            if (!existsSync(target))
+                continue;
+            if (dryRun) {
+                sayTagged(`  [dry-run] would remove foreign ${target}`);
+                continue;
+            }
+            await fs.rm(target, { recursive: true, force: true });
+            sayTagged(`  [rm] foreign ${target}`);
+        }
     };
     for (const host of detectHosts()) {
         const dest = hostExtensionsDir(host.id);
-        // Repair a host whose tree is partly there: a half-written tree is exactly the case this runs for, and it reads as "not installed" to the detector.
+        // Repair a partly-present tree: a half-written one is this run's case, and it reads as "not installed".
         const present = forHost(host.id).filter((file) => existsSync(path.join(dest, file))).length;
         if (present === 0) {
             if (host.id !== 'opencode')
-                await scrubOpencodeDir(dest);
+                await scrubOpencodeEntry(dest);
             continue;
         }
         await fs.mkdir(dest, { recursive: true });
-        for (const file of forHost(host.id)) {
-            const from = path.join(EXT_DIR, ...file.split('/'));
-            const text = await readTextIfExists(from);
-            if (text === null)
-                sayTagged(`  [warn] bundled source missing: ${from}`);
-            else
-                await writeIfChanged(path.join(dest, file), text, { dryRun, verbose });
+        const missing = await syncTreeFiles(dest, forHost(host.id), { dryRun, verbose });
+        for (const from of missing)
+            sayTagged(`  [warn] bundled source missing: ${from}`);
+        // Writing the current tree repairs stale and missing at once; dropped debris needs removal, else it survives.
+        const debris = (await obsoleteFiles(dest, host.id)).sort();
+        for (const rel of debris) {
+            const at = path.join(dest, ...rel.split('/'));
+            if (dryRun) {
+                sayTagged(`  [dry-run] would remove debris ${at}`);
+                continue;
+            }
+            await fs.rm(at, { force: true });
+            sayTagged(`  [rm] debris ${at}`);
+        }
+        for (const rel of await obsoleteDirs(dest, host.id)) {
+            const at = path.join(dest, ...rel.split('/'));
+            if (dryRun) {
+                sayTagged(`  [dry-run] would remove debris dir ${at}`);
+                continue;
+            }
+            await fs.rm(at, { recursive: true, force: true });
+            sayTagged(`  [rm] debris dir ${at}`);
         }
         if (host.id !== 'opencode')
-            await scrubOpencodeDir(dest);
+            await scrubOpencodeEntry(dest);
         if (!dryRun)
             sayTagged(`  [ok] ${host.label} extension tree: ${dest}`);
     }
 }
-// The tree alone does nothing on OpenCode without its entrypoint registered in opencode.json.
-// The tersio tree ships the rtk rewrite, so the rtk plugin entry is redundant.
+// On OpenCode the tree is inert without its entry in opencode.json, and the rtk plugin entry is redundant beside it.
 async function fixOpencodeEntry() {
     const { HOME } = await import('./common.js');
     const dir = path.join(HOME, '.config', 'opencode', 'plugins', 'tersio');
     const configPath = path.join(HOME, '.config', 'opencode', 'opencode.json');
-    const nested = path.join(dir, 'opencode', 'server.ts');
-    if (!(await readTextIfExists(nested)))
-        return;
-    // The loader resolves <pluginDir>/server.ts, so mirror the entry at the tree root.
-    await writeIfChanged(path.join(dir, 'server.ts'), OPENCODE_SERVER_SHIM, { dryRun, verbose });
+    // The loader resolves <pluginDir>/server.ts: an entry at the extensions root leaves a shim to a nested copy.
+    const nested = path.join(dir, 'opencode');
+    const staleNested = (await readTextIfExists(path.join(nested, 'server.ts'))) !== null;
+    await syncTreeFiles(dir, TREE_FILES.filter((file) => !file.includes('/')), { dryRun, verbose });
+    if (staleNested && !dryRun)
+        await fs.rm(nested, { recursive: true, force: true }).catch(() => { });
     if (dryRun)
         sayTagged(`  [dry-run] would remove the redundant rtk plugin entry`);
     else
@@ -91,23 +209,38 @@ async function fixExtensions(pluginsDir) {
     const pluginExtDir = path.join(pluginsDir, 'node_modules', '@krtclcdy', 'tersio', 'extensions');
     await fs.mkdir(pluginExtDir, { recursive: true });
     // Rule bodies are never overwritten: they can be newer upstream fetches.
-    const ruleFile = (f) => /^caveman-session\/rule.*\.md$/.test(f);
-    for (const file of TREE_FILES) {
-        const dest = path.join(pluginExtDir, ...file.split('/'));
-        if (ruleFile(file) && existsSync(dest))
+    const ruleFile = (f) => /^caveman\/rule.*\.md$/.test(f);
+    const missing = await syncTreeFiles(pluginExtDir, TREE_FILES, { dryRun, verbose }, (file) => ruleFile(file) && existsSync(path.join(pluginExtDir, ...file.split('/'))));
+    for (const from of missing)
+        sayTagged(`  [warn] bundled source missing: ${from}`);
+    // omp loads this tree, so its debris is what doctor reports: the package tree, compared against every entry.
+    const debris = (await obsoleteFiles(pluginExtDir, 'opencode')).sort();
+    for (const rel of debris) {
+        const at = path.join(pluginExtDir, ...rel.split('/'));
+        if (dryRun) {
+            sayTagged(`  [dry-run] would remove debris ${at}`);
             continue;
-        const text = await readTextIfExists(sourcePath(file));
-        if (text === null)
-            sayTagged(`  [warn] bundled source missing: ${sourcePath(file)}`);
-        else
-            await writeIfChanged(dest, text, { dryRun, verbose });
+        }
+        await fs.rm(at, { force: true });
+        sayTagged(`  [rm] debris ${at}`);
     }
+    for (const rel of await obsoleteDirs(pluginExtDir, 'opencode')) {
+        const at = path.join(pluginExtDir, ...rel.split('/'));
+        if (dryRun) {
+            sayTagged(`  [dry-run] would remove debris dir ${at}`);
+            continue;
+        }
+        await fs.rm(at, { recursive: true, force: true });
+        sayTagged(`  [rm] debris dir ${at}`);
+    }
+    // A synced tree is not enough: omp loads only the entries its manifest names.
+    await syncPluginManifest(path.dirname(pluginExtDir), { dryRun, verbose });
     // Writing is not atomic, so re-read rather than assume the tree is whole.
     if (dryRun)
         return;
-    const missing = TREE_FILES.filter((file) => !existsSync(path.join(pluginExtDir, ...file.split('/'))));
-    if (missing.length > 0)
-        sayTagged(`  [fail] tree incomplete: ${missing.join(', ')}`);
+    const stillMissing = TREE_FILES.filter((file) => !existsSync(path.join(pluginExtDir, ...file.split('/'))));
+    if (stillMissing.length > 0)
+        sayTagged(`  [fail] tree incomplete: ${stillMissing.join(', ')}`);
     else
         sayTagged(`  [ok] extension tree: ${TREE_FILES.length} files`);
 }
@@ -127,7 +260,9 @@ async function fixRegistrations(agentDir, pluginsDir) {
     if ((await readTextIfExists(rtkTs)) !== null)
         await ensureRtkInConfig({ dryRun, verbose });
     const ponytailExtPath = path.join(pluginsDir, 'node_modules', '@dietrichgebert', 'ponytail', 'pi-extension', 'index.js');
-    await removeExtensionFromConfig(configPath, path.join(extDir, 'combo-toggle', 'index.ts'), 'manifest-loaded combo', { dryRun, verbose });
+    // A tree from before the fold still names `combo-toggle`; both lines name the same module.
+    await removeExtensionFromConfig(configPath, path.join(extDir, 'combo', 'index.ts'), 'manifest-loaded combo', { dryRun, verbose });
+    await removeExtensionFromConfig(configPath, path.join(extDir, 'combo-toggle', 'index.ts'), 'retired manifest-loaded combo', { dryRun, verbose });
     await removeExtensionFromConfig(configPath, ponytailExtPath, 'manifest-loaded ponytail', { dryRun, verbose });
     await removeExtensionFromConfig(configPath, path.join(extDir, 'shared', 'mode-reinforcement.ts'), 'retired mode reinforcement', { dryRun, verbose });
     const pkgPath = path.join(pluginsDir, 'package.json');
@@ -209,13 +344,22 @@ async function fixPonytail(pluginsDir) {
     await fs.mkdir(pluginsDir, { recursive: true });
     const pkgPath = path.join(pluginsDir, 'package.json');
     const pkg = await readPluginsPackage(pkgPath);
-    // Drop the legacy separate entry: ponytail is a tersio dependency now.
-    if ('@dietrichgebert/ponytail' in pkg.dependencies) {
-        delete pkg.dependencies['@dietrichgebert/ponytail'];
-        console.log('  [migrate] dropped separate @dietrichgebert/ponytail dependency (now bundled with tersio)');
-    }
     if (!(PACKAGE_NAME in pkg.dependencies))
         pkg.dependencies[PACKAGE_NAME] = `^${PACKAGE_VERSION}`;
+    // npm resolves the *published* tersio, whose range can lag this tree; the override is what reaches the loaded copy.
+    const localSpec = await bundledPonytailSpec();
+    if (localSpec !== null) {
+        if (pkg.dependencies['@dietrichgebert/ponytail'] !== localSpec)
+            pkg.dependencies['@dietrichgebert/ponytail'] = localSpec;
+        if (ponytailOverride(pkg) !== localSpec) {
+            pkg.overrides = { ...(typeof pkg.overrides === 'object' && pkg.overrides !== null ? pkg.overrides : {}), '@dietrichgebert/ponytail': localSpec };
+            const note = 'forced with overrides, so the nested copy is dropped';
+            if (dryRun)
+                sayTagged(`  [dry-run] would pin @dietrichgebert/ponytail → ${localSpec} (${note})`);
+            else
+                console.log(`  [pin] @dietrichgebert/ponytail → ${localSpec} (${note})`);
+        }
+    }
     if (dryRun) {
         console.log('  [dry-run] would run: npm install --no-audit --no-fund (in plugins dir)');
         return;
@@ -225,10 +369,46 @@ async function fixPonytail(pluginsDir) {
         throw new Error(`bundled ponytail restore failed: ${e.message}`);
     });
 }
+/** The decisive line of a failed command, so one [warn] line carries the reason. */
+function shortError(e) {
+    return ((e.stderr) || e.message || '').trim().slice(0, 200);
+}
 async function fixCli() {
     console.log('  Doctor --fix: updating CLI + add-ons');
     await runLatestUpdate();
 }
+/** OpenCode's manager can lose its daemonized serve process, so `stop` and `restart` cannot reach it: kill the orphan by pid, then start the service again. */
+async function fixOpencodeService() {
+    const orphans = serviceOrphanPids();
+    if (orphans.length === 0) {
+        sayTagged('  [skip] no orphaned OpenCode serve process; the service answers');
+        return;
+    }
+    for (const pid of orphans) {
+        if (dryRun) {
+            sayTagged(`  [dry-run] would stop the orphaned serve process (pid ${pid})`);
+            continue;
+        }
+        try {
+            process.kill(Number(pid), 'SIGTERM');
+            sayTagged(`  [ok] stopped the orphaned serve process (pid ${pid})`);
+        }
+        catch (e) {
+            sayTagged(`  [warn] pid ${pid} already gone: ${shortError(e)}`);
+        }
+    }
+    if (dryRun)
+        return;
+    await new Promise((resolve) => setTimeout(resolve, 500));
+    const bin = resolveHostBinary('opencode', path.join(HOME, '.opencode', 'bin'));
+    if (!bin) {
+        sayTagged('  [warn] opencode not found on PATH; start it with `opencode service start`');
+        return;
+    }
+    await execNetwork('Starting the OpenCode service', bin, ['service', 'start'], { timeout: 60000 }).catch((e) => {
+        throw new Error(`service start failed: ${shortError(e)}`);
+    });
+}
 async function runDoctorRepairs(targets) {
     const all = targets.includes('all');
     const want = (t) => all || targets.includes(t);
@@ -256,6 +436,8 @@ async function runDoctorRepairs(targets) {
         await attempt('ponytail', () => fixPonytail(OMP_PLUGINS_DIR));
     if (want('cli'))
         await attempt('cli', fixCli);
+    if (want('service'))
+        await attempt('opencode service', fixOpencodeService);
     return failed;
 }
 export { runDoctorRepairs };