oc-go-usage-display 1.1.0 → 2.1.0

package/bin/lib.js

@@ -12,10 +12,87 @@ export const TUI_PLUGIN_REL = "./plugins/oc-go-usage-display.tsx";
 export const SERVER_FILE_NAME = "oc-go-usage-display.ts";
 export const TUI_FILE_NAME = "oc-go-usage-display.tsx";
 
+// Supported coding-agent hosts. Both ship the same source; the Kilo bundles are
+// separate build outputs (host-specific auth roots) with `.kilo` filenames.
+export const HOSTS = ["opencode", "kilo"];
+
+// Per-host install layout. Kilo is a fork with its own config root
+// ($KILO_CONFIG_DIR / $XDG_CONFIG_HOME/kilo), its own bundle filenames, and a
+// tui.json schema that rejects `sidebar`/`statusline` (it would skip the whole
+// file), so its TUI entry is registered without options.
+const HOST_LAYOUTS = {
+  opencode: {
+    serverFile: "oc-go-usage-display.ts",
+    tuiFile: "oc-go-usage-display.tsx",
+    serverRel: "./plugins/oc-go-usage-display.ts",
+    tuiRel: "./plugins/oc-go-usage-display.tsx",
+    serverConfigFile: "opencode.jsonc",
+    tuiOptions: true,
+  },
+  kilo: {
+    serverFile: "oc-go-usage-display.kilo.ts",
+    tuiFile: "oc-go-usage-display.kilo.tsx",
+    serverRel: "./plugins/oc-go-usage-display.kilo.ts",
+    tuiRel: "./plugins/oc-go-usage-display.kilo.tsx",
+    serverConfigFile: "kilo.json",
+    tuiOptions: false,
+  },
+};
+
+export function hostLayout(host) {
+  const layout = HOST_LAYOUTS[host];
+  if (layout === undefined) fail(`unknown target: ${host} (expected ${HOSTS.join("/")})`);
+  return layout;
+}
+
+// Plugin spec written into the host config. opencode resolves `./...` against
+// its config dir (verified); Kilo does NOT (relative specs resolve against the
+// project dir), so Kilo entries are absolute paths to the installed copy.
+export function pluginSpec(host, configDir, kind) {
+  const layout = hostLayout(host);
+  const fileName = kind === "server" ? layout.serverFile : layout.tuiFile;
+  if (host === "kilo") return path.join(configDir, "plugins", fileName);
+  return kind === "server" ? layout.serverRel : layout.tuiRel;
+}
+
 export function fail(message) {
+  if (message.startsWith("oc-go-usage-display: ")) throw new Error(message);
   throw new Error(`oc-go-usage-display: ${message}`);
 }
 
+// Format any thrown value as the single line the bin commands report, with the
+// `oc-go-usage-display: ` prefix applied exactly once. Newlines and other
+// whitespace runs collapse to single spaces so the one-line contract holds for
+// multi-line messages (e.g. a wrapped npm error). Pure and never throws.
+export function cliErrorMessage(error) {
+  let raw;
+  if (error instanceof Error) {
+    raw = error.message;
+  } else {
+    try {
+      raw = String(error);
+    } catch {
+      return "oc-go-usage-display: unknown error";
+    }
+  }
+  const message = raw.replace(/\s+/g, " ").trim();
+  if (message.length === 0) return "oc-go-usage-display: unknown error";
+  if (message.startsWith("oc-go-usage-display: ")) return message;
+  return `oc-go-usage-display: ${message}`;
+}
+
+// Top-level error boundary shared by every bin: one clean line on stderr (no
+// stack trace, no rethrow) and exit 1. The synchronous fd write keeps the
+// message from being truncated by `process.exit` when stderr is a pipe (npx).
+export function exitWithError(error) {
+  try {
+    fs.writeSync(process.stderr.fd, `${cliErrorMessage(error)}\n`);
+  } catch {
+    // No writable stderr: the exit code still carries the failure.
+  }
+  process.exit(1);
+}
+
 export function repoDirFromArgv(argv) {
   const flagValue = readFlag(argv, "--repo");
   if (flagValue !== null) return path.resolve(flagValue);
@@ -28,13 +105,155 @@ export function openCodeDirFromArgv(argv) {
   if (flagValue !== null) return path.resolve(flagValue);
   const envValue = toNonEmptyString(process.env.OPENCODE_CONFIG_DIR);
   if (envValue !== null) return path.resolve(envValue);
-  return path.join(os.homedir(), ".config", "opencode");
+  return path.join(process.env.HOME || os.homedir(), ".config", "opencode");
+}
+
+export function kiloDirFromArgv(argv) {
+  const flagValue = readFlag(argv, "--kilo-config-dir");
+  if (flagValue !== null) return path.resolve(flagValue);
+  const envValue = toNonEmptyString(process.env.KILO_CONFIG_DIR);
+  if (envValue !== null) return path.resolve(envValue);
+  return path.join(xdgHome("XDG_CONFIG_HOME", [".config"]), "kilo");
+}
+
+export function hostDirFromArgv(host, argv) {
+  return host === "kilo" ? kiloDirFromArgv(argv) : openCodeDirFromArgv(argv);
+}
+
+function xdgHome(key, fallbackSegments) {
+  const envValue = toNonEmptyString(process.env[key]);
+  if (envValue !== null) return envValue;
+  return path.join(process.env.HOME || os.homedir(), ...fallbackSegments);
+}
+
+// Data dir the host stores auth.json in (never written here, detection only).
+function hostDataDir(host) {
+  return path.join(xdgHome("XDG_DATA_HOME", [".local", "share"]), host);
+}
+
+// PATH lookup without spawning: covers brew/npm/curl/source installs that put
+// the binary on PATH. Never throws.
+function executableOnPath(name) {
+  const pathValue = toNonEmptyString(process.env.PATH);
+  if (pathValue === null) return false;
+  const names = process.platform === "win32" ? [name, `${name}.exe`, `${name}.cmd`] : [name];
+  for (const dir of pathValue.split(path.delimiter)) {
+    if (dir.length === 0) continue;
+    for (const candidate of names) {
+      try {
+        if (fs.statSync(path.join(dir, candidate)).isFile()) return true;
+      } catch {
+        // Missing entries are the normal case while scanning PATH.
+      }
+    }
+  }
+  return false;
+}
+
+// Best-effort host detection; never fails an install. A host counts as
+// installed when its binary is on PATH or its config/data dir exists, which
+// covers every install flavor (brew, npm, curl, source checkout, portable).
+export function detectHosts() {
+  try {
+    return {
+      opencode:
+        executableOnPath("opencode") ||
+        fs.existsSync(openCodeDirFromArgv([])) ||
+        fs.existsSync(hostDataDir("opencode")),
+      kilo:
+        executableOnPath("kilo") ||
+        fs.existsSync(kiloDirFromArgv([])) ||
+        fs.existsSync(hostDataDir("kilo")),
+    };
+  } catch {
+    return { opencode: false, kilo: false };
+  }
+}
+
+export function parseTargetList(value) {
+  const normalized = value.trim().toLowerCase();
+  if (normalized === "all" || normalized === "both") return [...HOSTS];
+  const targets = normalized.split(/[\s,]+/).filter((entry) => entry.length > 0);
+  if (targets.length === 0) fail("--target requires opencode, kilo, or all");
+  for (const target of targets) {
+    if (target !== "opencode" && target !== "kilo") fail(`unknown target: ${target} (expected opencode/kilo/all)`);
+  }
+  return [...new Set(targets)];
+}
+
+// Parse a numbered multiselect answer ("1,2", "all", "" for the default).
+export function parseTargetChoice(input, choices) {
+  const trimmed = input.trim().toLowerCase();
+  if (trimmed.length === 0 || trimmed === "all" || trimmed === "both") return [...choices];
+  const selected = [];
+  for (const token of trimmed.split(/[\s,]+/).filter((entry) => entry.length > 0)) {
+    const index = Number.parseInt(token, 10);
+    if (!Number.isInteger(index) || index < 1 || index > choices.length || String(index) !== token) {
+      fail(`invalid selection "${token}" (expected ${choices.map((_, i) => i + 1).join("/")} or Enter)`);
+    }
+    selected.push(choices[index - 1]);
+  }
+  return selected.length > 0 ? [...new Set(selected)] : [...choices];
+}
+
+// Targets for init/update. Explicit --target or a per-host --config-dir wins;
+// otherwise one detected host installs silently, two or more offer the
+// multiselect, and zero (or a non-interactive shell) defaults to all — a
+// missing binary must never fail the install.
+export function selectTargets(
+  argv,
+  { interactive = process.stdin.isTTY === true && process.stdout.isTTY === true } = {},
+) {
+  const targets = explicitTargets(argv);
+  if (targets !== null) return targets;
+  const detected = detectHosts();
+  const installed = HOSTS.filter((host) => detected[host]);
+  if (installed.length === 1) return installed;
+  if (installed.length > 1 && interactive) return promptTargets(installed);
+  return [...HOSTS];
+}
+
+// Removal never prompts: explicit flags pick hosts, otherwise both are visited
+// (removing from a host without an install is a no-op).
+export function resolveRemoveTargets(argv) {
+  return explicitTargets(argv) ?? [...HOSTS];
+}
+
+// Status checks only the hosts that have something installed unless the caller
+// asked for specific ones.
+export function resolveStatusTargets(argv) {
+  return explicitTargets(argv);
+}
+
+function explicitTargets(argv) {
+  const explicit = readFlag(argv, "--target");
+  if (explicit !== null) return parseTargetList(explicit);
+  const dirTargets = [];
+  if (readFlag(argv, "--config-dir") !== null) dirTargets.push("opencode");
+  if (readFlag(argv, "--kilo-config-dir") !== null) dirTargets.push("kilo");
+  return dirTargets.length > 0 ? dirTargets : null;
+}
+
+function promptTargets(installed) {
+  process.stdout.write(
+    `Detected coding agents: ${installed.map((host, index) => `${index + 1}) ${host}`).join("  ")}\n`,
+  );
+  process.stdout.write(`Install for [${installed.map((_, index) => index + 1).join(",")}] (Enter = all): `);
+  let input = "";
+  try {
+    const buffer = Buffer.alloc(256);
+    const bytes = fs.readSync(process.stdin.fd, buffer, 0, buffer.length, null);
+    input = buffer.toString("utf8", 0, bytes);
+  } catch {
+    return [...installed];
+  }
+  return parseTargetChoice(input, installed);
 }
 
 export function linkModeFromArgv(argv) {
-  if (argv.includes("--copy")) return "copy";
   if (argv.includes("--symlink")) return "symlink";
-  return "symlink";
+  if (argv.includes("--copy")) return "copy";
+  return "copy";
 }
 
 export function readFlag(argv, name) {
@@ -146,17 +365,24 @@ export function writeJsonFile(filePath, value) {
   fs.writeFileSync(filePath, `${JSON.stringify(value, null, 2)}\n`, "utf8");
 }
 
-export function linkPluginFiles(repoDir, configDir, mode) {
+export function linkPluginFiles(repoDir, configDir, mode, host = "opencode") {
+  const layout = hostLayout(host);
   const pluginsDir = path.join(configDir, "plugins");
   fs.mkdirSync(pluginsDir, { recursive: true });
+  // Bundled self-contained outputs (no `./shared` import, no shared file):
+  // `bun run build` produces dist/plugins/*, which is what gets installed.
   const pairs = [
-    [path.join(repoDir, "src", "index.ts"), path.join(pluginsDir, SERVER_FILE_NAME)],
-    [path.join(repoDir, "src", "tui.tsx"), path.join(pluginsDir, TUI_FILE_NAME)],
+    [path.join(repoDir, "dist", "plugins", layout.serverFile), path.join(pluginsDir, layout.serverFile)],
+    [path.join(repoDir, "dist", "plugins", layout.tuiFile), path.join(pluginsDir, layout.tuiFile)],
   ];
   for (const [source, target] of pairs) {
-    if (!fs.existsSync(source)) fail(`repo source missing: ${source}`);
+    if (!fs.existsSync(source)) fail(`repo bundle missing: ${source} (run bun run build)`);
     if (mode === "copy") {
       const stat = safeLstat(target);
+      if (stat?.isDirectory()) {
+        // copyFileSync would fail with a raw EISDIR; fail fast with the fix.
+        fail(`cannot replace a directory with the plugin file: ${target} (remove it, then re-run)`);
+      }
       if (stat?.isSymbolicLink() || stat?.isFile()) fs.rmSync(target, { force: true });
       fs.copyFileSync(source, target);
       continue;
@@ -192,25 +418,39 @@ export function describeLink(target) {
   return { state: "other", detail: null };
 }
 
-export function ensureServerEntry(configDir, { create = true } = {}) {
-  const filePath = path.join(configDir, "opencode.jsonc");
+export function isDanglingSymlink(target) {
+  const stat = safeLstat(target);
+  if (stat === null || !stat.isSymbolicLink()) return false;
+  try {
+    fs.statSync(target);
+    return false;
+  } catch {
+    return true;
+  }
+}
+
+export function ensureServerEntry(configDir, { create = true, host = "opencode" } = {}) {
+  const layout = hostLayout(host);
+  const spec = pluginSpec(host, configDir, "server");
+  const filePath = path.join(configDir, layout.serverConfigFile);
   const { found, value } = readJsonFile(filePath);
   if (!found) {
     if (!create) return { changed: false, present: false };
-    writeJsonFile(filePath, { plugin: [SERVER_PLUGIN_REL] });
+    writeJsonFile(filePath, { plugin: [spec] });
     return { changed: true, present: true };
   }
-  if (!isRecord(value)) fail(`opencode.jsonc is not an object: ${filePath}`);
+  if (!isRecord(value)) fail(`${layout.serverConfigFile} is not an object: ${filePath}`);
   const plugins = Array.isArray(value.plugin) ? value.plugin : [];
-  if (plugins.includes(SERVER_PLUGIN_REL)) {
+  if (plugins.includes(spec)) {
     return { changed: false, present: true };
   }
-  value.plugin = [...plugins, SERVER_PLUGIN_REL];
+  value.plugin = [...plugins, spec];
   writeJsonFile(filePath, value);
   return { changed: true, present: true };
 }
 
-export function readTuiSelection(configDir) {
+export function readTuiSelection(configDir, host = "opencode") {
+  const spec = pluginSpec(host, configDir, "tui");
   const filePath = path.join(configDir, "tui.json");
   const { found, value } = readJsonFile(filePath);
   if (!found) return { found: false, entry: false, sidebar: null, statusline: null };
@@ -218,7 +458,7 @@ export function readTuiSelection(configDir) {
   for (const entry of plugins) {
     const normalized = normalizeTuiEntry(entry);
     if (normalized === null) continue;
-    if (normalized.spec !== TUI_PLUGIN_REL) continue;
+    if (normalized.spec !== spec) continue;
     return { found: true, entry: true, sidebar: normalized.sidebar, statusline: normalized.statusline };
   }
   return { found: true, entry: false, sidebar: null, statusline: null };
@@ -235,15 +475,33 @@ export function normalizeTuiEntry(entry) {
   };
 }
 
-export function ensureTuiEntry(configDir, { sidebar = null, statusline = null, create = true } = {}) {
+export function ensureTuiEntry(
+  configDir,
+  { sidebar = null, statusline = null, create = true, host = "opencode" } = {},
+) {
+  const layout = hostLayout(host);
+  if (!layout.tuiOptions && (sidebar !== null || statusline !== null)) {
+    fail(`--sidebar/--statusline do not apply to ${host} (its tui.json rejects those options)`);
+  }
+  const spec = pluginSpec(host, configDir, "tui");
   const filePath = path.join(configDir, "tui.json");
   const { found, value } = readJsonFile(filePath);
   const sidebarNext = sidebar ?? true;
   const statuslineNext = statusline ?? true;
+  // Kilo rejects `sidebar`/`statusline` and skips the whole file, so its entry
+  // stays a plain plugin spec without options.
+  const desiredEntry = layout.tuiOptions
+    ? [spec, { sidebar: sidebarNext, statusline: statuslineNext }]
+    : spec;
   if (!found) {
-    if (!create) return { changed: false, sidebar: null, statusline: null };
-    writeJsonFile(filePath, { plugin: [[TUI_PLUGIN_REL, { sidebar: sidebarNext, statusline: statuslineNext }]] });
-    return { changed: true, sidebar: sidebarNext, statusline: statuslineNext };
+    if (!create) return { changed: false, entry: false, sidebar: null, statusline: null };
+    writeJsonFile(filePath, { plugin: [desiredEntry] });
+    return {
+      changed: true,
+      entry: true,
+      sidebar: layout.tuiOptions ? sidebarNext : null,
+      statusline: layout.tuiOptions ? statuslineNext : null,
+    };
   }
   if (!isRecord(value)) fail(`tui.json is not an object: ${filePath}`);
   const plugins = Array.isArray(value.plugin) ? value.plugin : [];
@@ -252,12 +510,16 @@ export function ensureTuiEntry(configDir, { sidebar = null, statusline = null, c
   const next = plugins.map((entry) => {
     const normalized = normalizeTuiEntry(entry);
     if (normalized === null) return entry;
-    if (normalized.spec !== TUI_PLUGIN_REL) return entry;
+    if (normalized.spec !== spec) return entry;
     seen = true;
+    if (!layout.tuiOptions) {
+      if (typeof entry === "string") return entry;
+      changed = true;
+      return spec;
+    }
     const sidebarFinal = sidebar ?? normalized.sidebar ?? true;
     const statuslineFinal = statusline ?? normalized.statusline ?? true;
     if (
-      normalized.spec === TUI_PLUGIN_REL &&
       Array.isArray(entry) &&
       isRecord(entry[1]) &&
       entry[1].sidebar === sidebarFinal &&
@@ -266,25 +528,25 @@ export function ensureTuiEntry(configDir, { sidebar = null, statusline = null, c
       return entry;
     }
     changed = true;
-    return [TUI_PLUGIN_REL, { sidebar: sidebarFinal, statusline: statuslineFinal }];
+    return [spec, { sidebar: sidebarFinal, statusline: statuslineFinal }];
   });
   if (!seen) {
-    next.push([TUI_PLUGIN_REL, { sidebar: sidebarNext, statusline: statuslineNext }]);
+    next.push(desiredEntry);
     changed = true;
   }
   if (changed) {
     value.plugin = next;
     writeJsonFile(filePath, value);
   }
-  const selection = readTuiSelection(configDir);
-  return { changed, sidebar: selection.sidebar, statusline: selection.statusline };
+  const selection = readTuiSelection(configDir, host);
+  return { changed, entry: selection.entry, sidebar: selection.sidebar, statusline: selection.statusline };
 }
 
 export function secretPresence(configDir) {
   const candidates = [
-    process.env.OPENCODE_GO_API_KEY,
-    process.env.OPENCODE_GO_AUTH_COOKIE,
-    process.env.OPENCODE_GO_WORKSPACE_ID,
+    process.env.OPENCODE_OC_GO_API_KEY,
+    process.env.OPENCODE_OC_GO_AUTH_COOKIE,
+    process.env.OPENCODE_OC_GO_WORKSPACE_ID,
   ];
   const envPresent = candidates.some((value) => toNonEmptyString(value) !== null);
   const fileConfig = path.join(configDir, "oc-go-usage-display.json");
@@ -294,10 +556,11 @@ export function secretPresence(configDir) {
   };
 }
 
-export function removePluginFiles(configDir) {
+export function removePluginFiles(configDir, host = "opencode") {
+  const layout = hostLayout(host);
   const removed = [];
   const kept = [];
-  for (const fileName of [SERVER_FILE_NAME, TUI_FILE_NAME]) {
+  for (const fileName of [layout.serverFile, layout.tuiFile]) {
     const target = path.join(configDir, "plugins", fileName);
     const stat = safeLstat(target);
     if (stat === null) continue;
@@ -311,19 +574,22 @@ export function removePluginFiles(configDir) {
   return { removed, kept };
 }
 
-export function removeServerEntry(configDir) {
-  const filePath = path.join(configDir, "opencode.jsonc");
+export function removeServerEntry(configDir, { host = "opencode" } = {}) {
+  const layout = hostLayout(host);
+  const spec = pluginSpec(host, configDir, "server");
+  const filePath = path.join(configDir, layout.serverConfigFile);
   const { found, value } = readJsonFile(filePath);
   if (!found) return { changed: false, present: false };
-  if (!isRecord(value)) fail(`opencode.jsonc is not an object: ${filePath}`);
+  if (!isRecord(value)) fail(`${layout.serverConfigFile} is not an object: ${filePath}`);
   const plugins = Array.isArray(value.plugin) ? value.plugin : [];
-  if (!plugins.includes(SERVER_PLUGIN_REL)) return { changed: false, present: false };
-  value.plugin = plugins.filter((entry) => entry !== SERVER_PLUGIN_REL);
+  if (!plugins.includes(spec)) return { changed: false, present: false };
+  value.plugin = plugins.filter((entry) => entry !== spec);
   writeJsonFile(filePath, value);
   return { changed: true, present: false };
 }
 
-export function removeTuiEntry(configDir) {
+export function removeTuiEntry(configDir, host = "opencode") {
+  const spec = pluginSpec(host, configDir, "tui");
   const filePath = path.join(configDir, "tui.json");
   const { found, value } = readJsonFile(filePath);
   if (!found) return { changed: false, present: false };
@@ -332,10 +598,102 @@ export function removeTuiEntry(configDir) {
   const next = plugins.filter((entry) => {
     const normalized = normalizeTuiEntry(entry);
     if (normalized === null) return true;
-    return normalized.spec !== TUI_PLUGIN_REL;
+    return normalized.spec !== spec;
   });
   if (next.length === plugins.length) return { changed: false, present: false };
   value.plugin = next;
   writeJsonFile(filePath, value);
   return { changed: true, present: false };
 }
+
+// Effective install report for one host (show/status share this so the two
+// commands can never disagree about what "installed" means).
+export function describeHostInstall(host, configDir) {
+  const layout = hostLayout(host);
+  const serverSpec = pluginSpec(host, configDir, "server");
+  const tuiSpec = pluginSpec(host, configDir, "tui");
+  const pluginsDir = path.join(configDir, "plugins");
+  const serverLink = describeLink(path.join(pluginsDir, layout.serverFile));
+  const tuiLink = describeLink(path.join(pluginsDir, layout.tuiFile));
+  const serverConfig = readJsonFile(path.join(configDir, layout.serverConfigFile));
+  const serverEntry =
+    serverConfig.found &&
+    isRecord(serverConfig.value) &&
+    Array.isArray(serverConfig.value.plugin) &&
+    serverConfig.value.plugin.includes(serverSpec);
+  const tui = readTuiSelection(configDir, host);
+  return {
+    configDir,
+    server: { expected: serverSpec, entry: serverEntry, ...serverLink },
+    tui: {
+      expected: tuiSpec,
+      entry: tui.entry,
+      sidebar: tui.sidebar,
+      statusline: tui.statusline,
+      ...tuiLink,
+    },
+  };
+}
+
+// Health check for one host: symlinks must point at this repo, copy installs
+// are accepted with a note, config entries must exist (toggles only where the
+// host supports them).
+export function checkHostInstall(host, configDir, repoDir) {
+  const layout = hostLayout(host);
+  const problems = [];
+  const notes = [];
+  const expectedServer = path.join(repoDir, "dist", "plugins", layout.serverFile);
+  const expectedTui = path.join(repoDir, "dist", "plugins", layout.tuiFile);
+  const serverPath = path.join(configDir, "plugins", layout.serverFile);
+  const tuiPath = path.join(configDir, "plugins", layout.tuiFile);
+
+  // Copy installs intentionally diverge, so a stale copy stays NOTE (never
+  // FAIL): users who pin a copy must not break on every repo update.
+  function copyMatchesRepo(installedPath, repoPath) {
+    let installed;
+    let source;
+    try {
+      installed = fs.readFileSync(installedPath, "utf8");
+      source = fs.readFileSync(repoPath, "utf8");
+    } catch {
+      return false;
+    }
+    return installed === source;
+  }
+
+  function checkPlugin(label, link, installedPath, expected) {
+    if (link.state === "symlink") {
+      if (isDanglingSymlink(installedPath)) {
+        problems.push(`${label} symlink target missing (dangling): ${link.detail ?? ""} (re-run install or build)`);
+      } else if (path.resolve(configDir, "plugins", link.detail ?? "") !== expected) {
+        problems.push(`${label} symlink points at ${link.detail ?? ""}, expected ${expected}`);
+      }
+    } else if (link.state === "file") {
+      if (copyMatchesRepo(installedPath, expected)) {
+        notes.push(`${label} plugin is a copy install (file, matches repo)`);
+      } else {
+        notes.push(`${label} copy install differs from repo ${expected}`);
+      }
+    } else {
+      problems.push(`${label} plugin is ${link.state}, expected symlink -> ${expected}`);
+    }
+  }
+
+  checkPlugin("server", describeLink(serverPath), serverPath, expectedServer);
+  checkPlugin("tui", describeLink(tuiPath), tuiPath, expectedTui);
+
+  const serverConfig = readJsonFile(path.join(configDir, layout.serverConfigFile));
+  const serverEntry =
+    serverConfig.found &&
+    isRecord(serverConfig.value) &&
+    Array.isArray(serverConfig.value.plugin) &&
+    serverConfig.value.plugin.includes(pluginSpec(host, configDir, "server"));
+  if (!serverEntry) problems.push(`${layout.serverConfigFile} is missing the server plugin entry`);
+
+  const tui = readTuiSelection(configDir, host);
+  if (!tui.entry) problems.push("tui.json is missing the tui plugin entry");
+  if (layout.tuiOptions && (tui.sidebar === null || tui.statusline === null)) {
+    problems.push(`tui toggles incomplete: sidebar=${tui.sidebar} statusline=${tui.statusline}`);
+  }
+  return { problems, notes };
+}

package/bin/oc-go-usage-display-init.js

@@ -1,35 +1,64 @@
 #!/usr/bin/env node
-// Install (or re-install) the plugin from this repo into ~/.config/opencode:
-// symlinks src/* -> plugins/* by default (--copy to copy instead),
-// then registers the opencode.jsonc + tui.json entries (toggles preserved).
+// Install (or re-install) the plugin into the detected coding agent(s):
+// copies dist/plugins/* (bundled, self-contained) -> plugins/* by default
+// (--symlink is dev-only: edits apply after restart but dangle if the source
+// tree moves), then registers the server + TUI config entries (toggles
+// preserved for opencode).
+//
+// Targets: --target opencode|kilo|all, or --config-dir / --kilo-config-dir.
+// Without an explicit target the hosts are detected (binary on PATH or config
+// dir present; brew/npm/curl/source installs all count): one host installs
+// silently, two or more offer a numbered multiselect, zero defaults to all —
+// detection never fails the install.
+//
+// Supported flows:
+//   npm install oc-go-usage-display@latest && npx oc-go-usage-display-init --copy
+//   (or declare "plugin": ["oc-go-usage-display@latest"] in config instead).
+//   npx -p oc-go-usage-display@latest oc-go-usage-display-init --copy  (one-shot from the package cache)
+//   bunx -p oc-go-usage-display@latest oc-go-usage-display-init --copy  (same, via Bun)
+// Copy-first needs the published latest+: 1.1.0 symlinks and ignores --copy.
+// Any source path is accepted; --repo only overrides the default repo root.
 
 import {
   ensureServerEntry,
   ensureTuiEntry,
+  exitWithError,
   fail,
+  hostDirFromArgv,
   linkModeFromArgv,
   linkPluginFiles,
-  openCodeDirFromArgv,
   parseOptionalToggle,
   repoDirFromArgv,
+  selectTargets,
 } from "./lib.js";
 
 try {
   const argv = process.argv.slice(2);
   const repoDir = repoDirFromArgv(argv);
-  const configDir = openCodeDirFromArgv(argv);
   const mode = linkModeFromArgv(argv);
   const sidebar = parseOptionalToggle(argv, "--sidebar");
   const statusline = parseOptionalToggle(argv, "--statusline");
-
-  linkPluginFiles(repoDir, configDir, mode);
-  const server = ensureServerEntry(configDir);
-  const tui = ensureTuiEntry(configDir, { sidebar, statusline });
+  const targets = selectTargets(argv);
+  if (targets.includes("kilo") && (sidebar !== null || statusline !== null)) {
+    fail("--sidebar/--statusline do not apply to kilo (its tui.json rejects those options)");
+  }
 
   console.log(`installed from ${repoDir} (${mode})`);
-  console.log(`server entry: ${server.present ? "present" : "missing"}`);
-  console.log(`tui toggles: sidebar=${tui.sidebar} statusline=${tui.statusline}`);
+  for (const host of targets) {
+    const configDir = hostDirFromArgv(host, argv);
+    linkPluginFiles(repoDir, configDir, mode, host);
+    const server = ensureServerEntry(configDir, { host });
+    const tui = ensureTuiEntry(configDir, { sidebar, statusline, host });
+
+    console.log(`${host}: ${configDir}`);
+    console.log(`${host} server entry: ${server.present ? "present" : "missing"}`);
+    if (host === "kilo") {
+      console.log(`kilo tui entry: ${tui.entry ? "present" : "missing"} (no toggles: kilo rejects sidebar/statusline)`);
+    } else {
+      console.log(`tui toggles: sidebar=${tui.sidebar} statusline=${tui.statusline}`);
+    }
+  }
+  console.log("restart the host(s) to pick up the plugin");
 } catch (error) {
-  if (error instanceof Error) fail(error.message);
-  throw error;
+  exitWithError(error);
 }