oc-go-usage-display 1.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 oc-go-usage-display contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,90 @@
+# oc-go-usage-display
+
+OpenCode Go subscription usage plugin (dual target):
+
+- **server** (`src/index.ts`): `go_usage` tool (manual query: `Go 5h … | 7d … | 30d …`).
+- **tui** (`src/tui.tsx`): `Go Usage` sidebar block (muted `5h`/`7d`/`30d` rows) + `session_prompt_right` statusline.
+
+![Go Usage sidebar and statusline showing 5h, 7d, and 30d subscription usage](docs/screenshot.png)
+
+## Install (npm)
+
+```sh
+npm install oc-go-usage-display
+npx oc-go-usage-display-init
+```
+
+Or one-shot without installing:
+
+```sh
+npx -y oc-go-usage-display@1.0.0 oc-go-usage-display-init
+```
+
+This links `src/*` into `~/.config/opencode/plugins/*` and registers the
+`opencode.jsonc` + `tui.json` entries. Restart opencode afterwards.
+No secrets are touched. Requires Node >= 22.
+
+## Install (manual plugin entries)
+
+If you prefer to wire the plugin by hand (e.g. npm / OpenDock managed
+plugins), add the package to your config and restart opencode:
+
+```jsonc
+// opencode.jsonc — server target (go_usage tool)
+{
+  "plugin": ["oc-go-usage-display"]
+}
+```
+
+```jsonc
+// tui.json — TUI target (Go Usage sidebar + statusline)
+{
+  "plugin": [["oc-go-usage-display", { "sidebar": true, "statusline": true }]]
+}
+```
+
+The `oc-plugin: ["server", "tui"]` manifest auto-discovers both targets
+from the published package (`dist/`). Set `OPENCODE_GO_API_KEY` (Bearer for
+`GET https://opencode.ai/zen/go/v1/usage`) or sign in via the `opencode-go`
+provider so `auth.json` supplies the key.
+
+## Install (local repo, easy update)
+
+```sh
+./install.sh
+```
+
+This symlinks `src/*` into `~/.config/opencode/plugins/*` and registers the
+`opencode.jsonc` + `tui.json` entries. Edits in this repo apply after an
+opencode restart. No secrets are touched.
+
+## Commands
+
+```sh
+node ./bin/oc-go-usage-display-init.js     # (re-)install
+node ./bin/oc-go-usage-display-show.js     # show effective config (secrets redacted)
+node ./bin/oc-go-usage-display-status.js   # health check (exit 0/1)
+node ./bin/oc-go-usage-display-update.js   # re-link (+ git pull when a remote exists)
+```
+
+After installing the package, the commands are also available as
+`oc-go-usage-display-init|show|status|update`.
+
+## Display toggles
+
+Both surfaces default on and are independent:
+
+```json
+["./plugins/oc-go-usage-display.tsx", { "sidebar": true, "statusline": true }]
+```
+
+`OPENCODE_GO_SIDEBAR` / `OPENCODE_GO_STATUSLINE` env vars override when the
+toggles are absent. Restart opencode after changing them.
+
+## Build
+
+```sh
+npm install
+npm run build   # tsc -> dist/
+npm run check   # typecheck only
+```

package/bin/lib.js

@@ -0,0 +1,312 @@
+// Shared helpers for the oc-go-usage-display bin commands.
+// Dependency-free (node:fs/os/path only). Secrets are never printed;
+// only their presence is reported.
+
+import * as fs from "node:fs";
+import * as os from "node:os";
+import * as path from "node:path";
+import { fileURLToPath } from "node:url";
+
+export const SERVER_PLUGIN_REL = "./plugins/oc-go-usage-display.ts";
+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";
+// Legacy (pre-rename) paths, removed/migrated on install.
+export const LEGACY_SERVER_PLUGIN_REL = "./plugins/opencode-go-usage.ts";
+export const LEGACY_TUI_PLUGIN_REL = "./plugins/opencode-go-usage.tsx";
+export const LEGACY_SERVER_FILE_NAME = "opencode-go-usage.ts";
+export const LEGACY_TUI_FILE_NAME = "opencode-go-usage.tsx";
+
+export function fail(message) {
+  throw new Error(`oc-go-usage-display: ${message}`);
+}
+
+export function repoDirFromArgv(argv) {
+  const flagValue = readFlag(argv, "--repo");
+  if (flagValue !== null) return path.resolve(flagValue);
+  const here = path.dirname(fileURLToPath(import.meta.url));
+  return path.resolve(here, "..");
+}
+
+export function openCodeDirFromArgv(argv) {
+  const flagValue = readFlag(argv, "--config-dir");
+  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");
+}
+
+export function linkModeFromArgv(argv) {
+  if (argv.includes("--copy")) return "copy";
+  if (argv.includes("--symlink")) return "symlink";
+  return "symlink";
+}
+
+export function readFlag(argv, name) {
+  const prefix = `${name}=`;
+  for (const arg of argv) {
+    if (arg.startsWith(prefix)) return arg.slice(prefix.length);
+  }
+  const index = argv.indexOf(name);
+  if (index !== -1 && index + 1 < argv.length && !argv[index + 1].startsWith("--")) {
+    return argv[index + 1];
+  }
+  return null;
+}
+
+export function parseOptionalToggle(argv, name) {
+  const raw = readFlag(argv, name);
+  if (raw === null) return null;
+  const normalized = raw.trim().toLowerCase();
+  if (normalized === "1" || normalized === "true") return true;
+  if (normalized === "0" || normalized === "false") return false;
+  fail(`invalid value for ${name}: expected 0/1/true/false, got ${JSON.stringify(raw)}`);
+}
+
+function toNonEmptyString(value) {
+  if (typeof value !== "string") return null;
+  const trimmed = value.trim();
+  return trimmed.length > 0 ? trimmed : null;
+}
+
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+function stripJsonComments(text) {
+  let out = "";
+  let inString = false;
+  let escaped = false;
+  let lineComment = false;
+  let blockComment = false;
+  for (let i = 0; i < text.length; i++) {
+    const ch = text[i];
+    const next = text[i + 1];
+    if (lineComment) {
+      if (ch === "\n") {
+        lineComment = false;
+        out += ch;
+      }
+      continue;
+    }
+    if (blockComment) {
+      if (ch === "*" && next === "/") {
+        blockComment = false;
+        i++;
+      }
+      continue;
+    }
+    if (inString) {
+      out += ch;
+      if (escaped) escaped = false;
+      else if (ch === "\\") escaped = true;
+      else if (ch === '"') inString = false;
+      continue;
+    }
+    if (ch === '"') {
+      inString = true;
+      out += ch;
+      continue;
+    }
+    if (ch === "/" && next === "/") {
+      lineComment = true;
+      i++;
+      continue;
+    }
+    if (ch === "/" && next === "*") {
+      blockComment = true;
+      i++;
+      continue;
+    }
+    out += ch;
+  }
+  return out;
+}
+
+export function parseJsonTolerant(text, filePath) {
+  try {
+    return JSON.parse(text);
+  } catch {
+    // Fall through to comment-stripped parse (JSONC).
+  }
+  try {
+    return JSON.parse(stripJsonComments(text));
+  } catch {
+    fail(`cannot parse ${filePath} as JSON/JSONC`);
+  }
+}
+
+export function readJsonFile(filePath) {
+  let raw;
+  try {
+    raw = fs.readFileSync(filePath, "utf8");
+  } catch {
+    return { found: false, value: null };
+  }
+  return { found: true, value: parseJsonTolerant(raw, filePath) };
+}
+
+export function writeJsonFile(filePath, value) {
+  fs.mkdirSync(path.dirname(filePath), { recursive: true });
+  fs.writeFileSync(filePath, `${JSON.stringify(value, null, 2)}\n`, "utf8");
+}
+
+export function linkPluginFiles(repoDir, configDir, mode) {
+  const pluginsDir = path.join(configDir, "plugins");
+  fs.mkdirSync(pluginsDir, { recursive: true });
+  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)],
+  ];
+  for (const [source, target] of pairs) {
+    if (!fs.existsSync(source)) fail(`repo source missing: ${source}`);
+    if (mode === "copy") {
+      const stat = safeLstat(target);
+      if (stat?.isSymbolicLink() || stat?.isFile()) fs.rmSync(target, { force: true });
+      fs.copyFileSync(source, target);
+      continue;
+    }
+    const existing = safeReadlink(target);
+    if (existing !== null && path.resolve(path.dirname(target), existing) === source) continue;
+    fs.rmSync(target, { force: true });
+    fs.symlinkSync(source, target);
+  }
+  // Remove legacy (pre-rename) plugin files left by older installs.
+  for (const legacy of [LEGACY_SERVER_FILE_NAME, LEGACY_TUI_FILE_NAME]) {
+    if (legacy === SERVER_FILE_NAME || legacy === TUI_FILE_NAME) continue;
+    fs.rmSync(path.join(pluginsDir, legacy), { force: true });
+  }
+}
+
+function safeLstat(target) {
+  try {
+    return fs.lstatSync(target);
+  } catch {
+    return null;
+  }
+}
+
+function safeReadlink(target) {
+  try {
+    return fs.readlinkSync(target);
+  } catch {
+    return null;
+  }
+}
+
+export function describeLink(target) {
+  const stat = safeLstat(target);
+  if (stat === null) return { state: "missing", detail: null };
+  if (stat.isSymbolicLink()) return { state: "symlink", detail: safeReadlink(target) };
+  if (stat.isFile()) return { state: "file", detail: null };
+  return { state: "other", detail: null };
+}
+
+export function ensureServerEntry(configDir, { create = true } = {}) {
+  const filePath = path.join(configDir, "opencode.jsonc");
+  const { found, value } = readJsonFile(filePath);
+  if (!found) {
+    if (!create) return { changed: false, present: false };
+    writeJsonFile(filePath, { plugin: [SERVER_PLUGIN_REL] });
+    return { changed: true, present: true };
+  }
+  if (!isRecord(value)) fail(`opencode.jsonc is not an object: ${filePath}`);
+  const plugins = Array.isArray(value.plugin) ? value.plugin : [];
+  const withoutLegacy = plugins.filter((entry) => entry !== LEGACY_SERVER_PLUGIN_REL);
+  const changed = withoutLegacy.length !== plugins.length;
+  if (withoutLegacy.includes(SERVER_PLUGIN_REL)) {
+    if (changed) {
+      value.plugin = withoutLegacy;
+      writeJsonFile(filePath, value);
+    }
+    return { changed, present: true };
+  }
+  value.plugin = [...withoutLegacy, SERVER_PLUGIN_REL];
+  writeJsonFile(filePath, value);
+  return { changed: true, present: true };
+}
+
+export function readTuiSelection(configDir) {
+  const filePath = path.join(configDir, "tui.json");
+  const { found, value } = readJsonFile(filePath);
+  if (!found) return { found: false, entry: false, sidebar: null, statusline: null };
+  const plugins = isRecord(value) && Array.isArray(value.plugin) ? value.plugin : [];
+  for (const entry of plugins) {
+    const normalized = normalizeTuiEntry(entry);
+    if (normalized === null) continue;
+    if (normalized.spec !== TUI_PLUGIN_REL && normalized.spec !== LEGACY_TUI_PLUGIN_REL) continue;
+    return { found: true, entry: true, sidebar: normalized.sidebar, statusline: normalized.statusline };
+  }
+  return { found: true, entry: false, sidebar: null, statusline: null };
+}
+
+function normalizeTuiEntry(entry) {
+  if (typeof entry === "string") return { spec: entry, sidebar: null, statusline: null };
+  if (!Array.isArray(entry) || typeof entry[0] !== "string") return null;
+  const options = entry.length > 1 && isRecord(entry[1]) ? entry[1] : {};
+  return {
+    spec: entry[0],
+    sidebar: typeof options.sidebar === "boolean" ? options.sidebar : null,
+    statusline: typeof options.statusline === "boolean" ? options.statusline : null,
+  };
+}
+
+export function ensureTuiEntry(configDir, { sidebar = null, statusline = null, create = true } = {}) {
+  const filePath = path.join(configDir, "tui.json");
+  const { found, value } = readJsonFile(filePath);
+  const sidebarNext = sidebar ?? true;
+  const statuslineNext = statusline ?? true;
+  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 (!isRecord(value)) fail(`tui.json is not an object: ${filePath}`);
+  const plugins = Array.isArray(value.plugin) ? value.plugin : [];
+  let changed = false;
+  let seen = false;
+  const next = plugins.map((entry) => {
+    const normalized = normalizeTuiEntry(entry);
+    if (normalized === null) return entry;
+    if (normalized.spec !== TUI_PLUGIN_REL && normalized.spec !== LEGACY_TUI_PLUGIN_REL) return entry;
+    seen = true;
+    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 &&
+      entry[1].statusline === statuslineFinal
+    ) {
+      return entry;
+    }
+    changed = true;
+    return [TUI_PLUGIN_REL, { sidebar: sidebarFinal, statusline: statuslineFinal }];
+  });
+  if (!seen) {
+    next.push([TUI_PLUGIN_REL, { sidebar: sidebarNext, statusline: statuslineNext }]);
+    changed = true;
+  }
+  if (changed) {
+    value.plugin = next;
+    writeJsonFile(filePath, value);
+  }
+  const selection = readTuiSelection(configDir);
+  return { changed, 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,
+  ];
+  const envPresent = candidates.some((value) => toNonEmptyString(value) !== null);
+  const fileConfig = path.join(configDir, "oc-go-usage-display.json");
+  const legacyFileConfig = path.join(configDir, "opencode-go-usage.json");
+  return {
+    envPresent,
+    filePresent: fs.existsSync(fileConfig) || fs.existsSync(legacyFileConfig),
+  };
+}

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

@@ -0,0 +1,35 @@
+#!/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).
+
+import {
+  ensureServerEntry,
+  ensureTuiEntry,
+  fail,
+  linkModeFromArgv,
+  linkPluginFiles,
+  openCodeDirFromArgv,
+  parseOptionalToggle,
+  repoDirFromArgv,
+} 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 });
+
+  console.log(`installed from ${repoDir} (${mode})`);
+  console.log(`server entry: ${server.present ? "present" : "missing"}`);
+  console.log(`tui toggles: sidebar=${tui.sidebar} statusline=${tui.statusline}`);
+} catch (error) {
+  if (error instanceof Error) fail(error.message);
+  throw error;
+}

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

@@ -0,0 +1,65 @@
+#!/usr/bin/env node
+// Show the effective installation: link targets, config entries, toggles.
+// Secrets are never printed; only presence (env/file) is reported.
+
+import * as path from "node:path";
+import {
+  SERVER_FILE_NAME,
+  TUI_FILE_NAME,
+  TUI_PLUGIN_REL,
+  SERVER_PLUGIN_REL,
+  describeLink,
+  fail,
+  openCodeDirFromArgv,
+  readJsonFile,
+  readTuiSelection,
+  repoDirFromArgv,
+  secretPresence,
+} from "./lib.js";
+
+try {
+  const argv = process.argv.slice(2);
+  const repoDir = repoDirFromArgv(argv);
+  const configDir = openCodeDirFromArgv(argv);
+  const asJson = argv.includes("--json");
+
+  const serverLink = describeLink(path.join(configDir, "plugins", SERVER_FILE_NAME));
+  const tuiLink = describeLink(path.join(configDir, "plugins", TUI_FILE_NAME));
+  const tui = readTuiSelection(configDir);
+  const opencodeJson = readJsonFile(path.join(configDir, "opencode.jsonc"));
+  const serverEntry =
+    opencodeJson.found &&
+    typeof opencodeJson.value === "object" &&
+    opencodeJson.value !== null &&
+    Array.isArray(opencodeJson.value.plugin) &&
+    opencodeJson.value.plugin.includes(SERVER_PLUGIN_REL);
+  const secrets = secretPresence(configDir);
+
+  const report = {
+    repoDir,
+    configDir,
+    server: { expected: SERVER_PLUGIN_REL, entry: serverEntry, ...serverLink },
+    tui: {
+      expected: TUI_PLUGIN_REL,
+      entry: tui.entry,
+      sidebar: tui.sidebar,
+      statusline: tui.statusline,
+      ...tuiLink,
+    },
+    secrets: { envPresent: secrets.envPresent, filePresent: secrets.filePresent },
+  };
+
+  if (asJson) {
+    console.log(JSON.stringify(report, null, 2));
+  } else {
+    console.log(`repo: ${repoDir}`);
+    console.log(`config: ${configDir}`);
+    console.log(`server: ${serverLink.state}${serverLink.detail ? ` -> ${serverLink.detail}` : ""} (entry: ${serverEntry ? "present" : "missing"})`);
+    console.log(`tui: ${tuiLink.state}${tuiLink.detail ? ` -> ${tuiLink.detail}` : ""} (entry: ${tui.entry ? "present" : "missing"})`);
+    console.log(`toggles: sidebar=${tui.sidebar} statusline=${tui.statusline}`);
+    console.log(`secrets: env=${secrets.envPresent ? "set" : "unset"} file=${secrets.filePresent ? "present" : "absent"} (values never shown)`);
+  }
+} catch (error) {
+  if (error instanceof Error) fail(error.message);
+  throw error;
+}

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

@@ -0,0 +1,64 @@
+#!/usr/bin/env node
+// Check the installation. Exit 0 when healthy, 1 with reasons otherwise.
+// Verifies: symlinks point at this repo, config entries exist, toggles set.
+
+import * as path from "node:path";
+import {
+  SERVER_FILE_NAME,
+  TUI_FILE_NAME,
+  describeLink,
+  fail,
+  openCodeDirFromArgv,
+  readJsonFile,
+  SERVER_PLUGIN_REL,
+  readTuiSelection,
+  repoDirFromArgv,
+} from "./lib.js";
+
+try {
+  const argv = process.argv.slice(2);
+  const repoDir = repoDirFromArgv(argv);
+  const configDir = openCodeDirFromArgv(argv);
+  const problems = [];
+
+  const expectedServer = path.join(repoDir, "src", "index.ts");
+  const expectedTui = path.join(repoDir, "src", "tui.tsx");
+  const serverLink = describeLink(path.join(configDir, "plugins", SERVER_FILE_NAME));
+  const tuiLink = describeLink(path.join(configDir, "plugins", TUI_FILE_NAME));
+
+  if (serverLink.state !== "symlink") {
+    problems.push(`server plugin is ${serverLink.state}, expected symlink -> ${expectedServer}`);
+  } else if (path.resolve(configDir, "plugins", serverLink.detail) !== expectedServer) {
+    problems.push(`server symlink points at ${serverLink.detail}, expected ${expectedServer}`);
+  }
+  if (tuiLink.state !== "symlink") {
+    problems.push(`tui plugin is ${tuiLink.state}, expected symlink -> ${expectedTui}`);
+  } else if (path.resolve(configDir, "plugins", tuiLink.detail ?? "") !== expectedTui) {
+    problems.push(`tui symlink points at ${tuiLink.detail}, expected ${expectedTui}`);
+  }
+
+  const opencodeJson = readJsonFile(path.join(configDir, "opencode.jsonc"));
+  const serverEntry =
+    opencodeJson.found &&
+    typeof opencodeJson.value === "object" &&
+    opencodeJson.value !== null &&
+    Array.isArray(opencodeJson.value.plugin) &&
+    opencodeJson.value.plugin.includes(SERVER_PLUGIN_REL);
+  if (!serverEntry) problems.push("opencode.jsonc is missing the server plugin entry");
+
+  const tui = readTuiSelection(configDir);
+  if (!tui.entry) problems.push("tui.json is missing the tui plugin entry");
+  if (tui.sidebar === null || tui.statusline === null) {
+    problems.push(`tui toggles incomplete: sidebar=${tui.sidebar} statusline=${tui.statusline}`);
+  }
+
+  if (problems.length > 0) {
+    for (const problem of problems) console.error(`FAIL: ${problem}`);
+    process.exitCode = 1;
+  } else {
+    console.log(`OK: installed from ${repoDir} (sidebar=${tui.sidebar} statusline=${tui.statusline})`);
+  }
+} catch (error) {
+  if (error instanceof Error) fail(error.message);
+  throw error;
+}

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

@@ -0,0 +1,66 @@
+#!/usr/bin/env node
+// Update the installation: re-link plugin files, re-register config entries,
+// then fast-forward the repo (only when it has a remote; otherwise re-link is
+// the update). Restart opencode afterwards to pick up changes.
+
+import { execFileSync } from "node:child_process";
+import * as fs from "node:fs";
+import * as path from "node:path";
+import {
+  ensureServerEntry,
+  ensureTuiEntry,
+  fail,
+  linkModeFromArgv,
+  linkPluginFiles,
+  openCodeDirFromArgv,
+  parseOptionalToggle,
+  repoDirFromArgv,
+} from "./lib.js";
+
+function hasRemote(repoDir) {
+  try {
+    const out = execFileSync("git", ["-C", repoDir, "remote"], { encoding: "utf8" });
+    return out.trim().length > 0;
+  } catch {
+    return false;
+  }
+}
+
+function isClean(repoDir) {
+  try {
+    const out = execFileSync("git", ["-C", repoDir, "status", "--porcelain"], { encoding: "utf8" });
+    return out.trim().length === 0;
+  } catch {
+    return false;
+  }
+}
+
+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");
+
+  if (!fs.existsSync(path.join(repoDir, ".git"))) fail(`not a git repo: ${repoDir}`);
+
+  if (hasRemote(repoDir)) {
+    if (!isClean(repoDir)) fail(`repo has local changes; commit or stash before updating: ${repoDir}`);
+    execFileSync("git", ["-C", repoDir, "pull", "--ff-only"], { stdio: "inherit" });
+  } else {
+    console.log("no remote configured; re-linking local files (no fetch)");
+  }
+
+  linkPluginFiles(repoDir, configDir, mode);
+  const server = ensureServerEntry(configDir);
+  const tui = ensureTuiEntry(configDir, { sidebar, statusline });
+
+  console.log(`updated from ${repoDir} (${mode})`);
+  console.log(`server entry: ${server.present ? "present" : "missing"}`);
+  console.log(`tui toggles: sidebar=${tui.sidebar} statusline=${tui.statusline}`);
+  console.log("restart opencode to pick up plugin changes");
+} catch (error) {
+  if (error instanceof Error) fail(error.message);
+  throw error;
+}

package/dist/index.d.ts

@@ -0,0 +1,11 @@
+declare const _default: () => Promise<{
+    tool: {
+        go_usage: {
+            description: string;
+            args: {};
+            execute(args: Record<string, never>, context: import("@opencode-ai/plugin").ToolContext): Promise<import("@opencode-ai/plugin").ToolResult>;
+        };
+    };
+}>;
+export default _default;
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":";;;;;;;;;AAwiBA,wBAiBoB"}