@krtclcdy/tersio 2.25.5 → 2.25.6

package/dist/cli/doctor-fix.js

@@ -1,20 +1,119 @@
 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, } 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/shared/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 { OPENCODE_ENTRY, TREE_FILES, syncTreeFiles, treeFilesFor } 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.
+/** 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;
+        }
+        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 OpenCode entry is foreign to the pi and omp loaders: it imports @opencode/plugin, which
-    // those hosts do not carry. One shared filter, so a repair cannot drop it into the wrong tree.
+    // 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);
-    // A tree from before the entry moved to the extensions root held a nested copy, and a repair
-    // written against the old filter may have left the entry at the root. Remove both strays.
+    // 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))
@@ -29,7 +128,7 @@ async function fixExtensionTrees() {
     };
     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')
@@ -40,21 +139,38 @@ async function fixExtensionTrees() {
         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 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');
-    // The loader resolves <pluginDir>/server.ts, and the entry is that file. A tree from before the
-    // entry moved to the extensions root held a root shim that re-exported a nested copy, so the
-    // real entry is written in place and the stale nested tree is dropped.
+    // 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 });
@@ -97,6 +213,28 @@ async function fixExtensions(pluginsDir) {
     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;
+        }
+        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;
@@ -206,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;
@@ -222,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);
@@ -253,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 };