plugin-updater 1.3.0 → 1.3.2

package/dist/commands.js

@@ -4,7 +4,7 @@
 // so the command shells into this same bundle's index.js by its absolute path.
 import { fileURLToPath } from "url";
 import { dirname, join } from "path";
-import { runConfigCli, deployCommands } from "../core/dist/index.js";
+import { runConfigCli, deployCommands } from "../lib/core.js";
 const PLUGIN = "plugin-updater";
 // the deployed entry that carries the maybeRunCli guard (dist/index.js, sibling).
 const SELF = join(dirname(fileURLToPath(import.meta.url)), "index.js");

package/dist/git.js

@@ -4,7 +4,10 @@ import os from "os";
 import { execSync } from "child_process";
 import { getReposDir } from "./env.js";
 import { writeLog } from "./log.js";
-const BUILD_OUTPUT_DIRS = ["dist", path.join("core", "dist")];
+// dirs copied back from the temp build into the repo clone. core-loader/dist holds
+// the loaders' TUI (tui.js), run as a separate process — without it `oc`/`cc` find
+// no TUI and fall through to plain opencode/claude.
+const BUILD_OUTPUT_DIRS = ["dist", path.join("core", "dist"), path.join("core-loader", "dist")];
 export function executeGit(command, cwd) {
     writeLog(`Executing git: ${command} in ${cwd}`);
     try {

package/dist/log.js

@@ -5,8 +5,9 @@
 import fs from "fs";
 import path from "path";
 import { getAppConfigDir, getAppName } from "./env.js";
-// @ts-ignore — generated bundle, no .d.ts
-import { makeWriteLog } from "../core/dist/index.js";
+// @ts-ignore — generated bundle (core, esbuild-bundled to lib/ so it ships in the
+// npm tarball; the submodule's own core/dist is gitignored and never published)
+import { makeWriteLog } from "../lib/core.js";
 let pluginConfig = null;
 export function getPluginConfig() {
     if (pluginConfig !== null)

package/lib/core.js

@@ -0,0 +1,297 @@
+// core/src/env.ts
+import { existsSync } from "fs";
+import { join } from "path";
+import { homedir } from "os";
+function getApp() {
+  const override = process.env.CORE_APP;
+  if (override === "claude" || override === "opencode") return override;
+  return process.argv.join(" ").includes("claude") ? "claude" : "opencode";
+}
+function isClaude() {
+  return getApp() === "claude";
+}
+function resolveDir(app) {
+  const home = homedir();
+  if (app === "claude") {
+    const override2 = process.env.HUB_CLAUDE_DIR;
+    if (override2 && override2.trim()) return override2.trim();
+    const direct = join(home, ".claude");
+    return existsSync(direct) ? direct : join(home, ".config", "claude");
+  }
+  const override = process.env.HUB_OPENCODE_DIR;
+  if (override && override.trim()) return override.trim();
+  const xdg = join(home, ".config", "opencode");
+  return existsSync(xdg) ? xdg : join(home, ".opencode");
+}
+function getAppConfigDir() {
+  return resolveDir(getApp());
+}
+function existingConfigDirs() {
+  return existingApps().map((a) => a.configDir);
+}
+function existingApps() {
+  const out = [];
+  for (const app of ["claude", "opencode"]) {
+    const dir = resolveDir(app);
+    if (existsSync(dir) && !out.some((o) => o.configDir === dir)) {
+      out.push({ app, configDir: dir, commandDir: app === "claude" ? "commands" : "command" });
+    }
+  }
+  return out;
+}
+
+// core/src/files.ts
+import { existsSync as existsSync2, readFileSync, writeFileSync, mkdirSync, renameSync } from "fs";
+import { dirname } from "path";
+import { randomBytes } from "crypto";
+function ensureDir(dir) {
+  if (!existsSync2(dir)) mkdirSync(dir, { recursive: true });
+}
+function atomicWrite(file, content) {
+  ensureDir(dirname(file));
+  const tmp = file + "." + randomBytes(6).toString("hex") + ".tmp";
+  writeFileSync(tmp, content, "utf8");
+  renameSync(tmp, file);
+}
+function readJson(file, fallback = null) {
+  if (!existsSync2(file)) return fallback;
+  try {
+    return JSON.parse(readFileSync(file, "utf8").replace(/^\s*\/\/[^\n]*/gm, ""));
+  } catch {
+    return fallback;
+  }
+}
+function writeJson(file, value) {
+  atomicWrite(file, JSON.stringify(value, null, 2) + "\n");
+}
+
+// core/src/config.ts
+import { join as join2 } from "path";
+import { existsSync as existsSync3 } from "fs";
+var CACHE = {};
+function configPath(name, configDir = getAppConfigDir()) {
+  const preferred = join2(configDir, "config", `${name}.json`);
+  const fallback = join2(configDir, `${name}.json`);
+  if (existsSync3(preferred)) return preferred;
+  if (existsSync3(fallback)) return fallback;
+  return preferred;
+}
+function loadConfig(name, configDir = getAppConfigDir()) {
+  const key = configDir + "::" + name;
+  if (CACHE[key]) return CACHE[key];
+  const data = readJson(configPath(name, configDir), {});
+  CACHE[key] = data && typeof data === "object" && !Array.isArray(data) ? data : {};
+  return CACHE[key];
+}
+function getConfigValue(name, key, configDir = getAppConfigDir()) {
+  let node = loadConfig(name, configDir);
+  for (const part of key.split(".")) {
+    if (node && typeof node === "object") node = node[part];
+    else return void 0;
+  }
+  return node;
+}
+function coerce(value) {
+  if (value === "true") return true;
+  if (value === "false") return false;
+  if (value === "null") return null;
+  if (value !== "" && !isNaN(Number(value))) return Number(value);
+  if (/^[[{]/.test(value.trim())) {
+    try {
+      return JSON.parse(value);
+    } catch {
+    }
+  }
+  return value;
+}
+function setConfigValue(name, key, value, configDir = getAppConfigDir()) {
+  const root = { ...loadConfig(name, configDir) };
+  const parts = key.split(".");
+  let node = root;
+  for (let i = 0; i < parts.length - 1; i++) {
+    const next = node[parts[i]];
+    node[parts[i]] = next && typeof next === "object" && !Array.isArray(next) ? { ...next } : {};
+    node = node[parts[i]];
+  }
+  node[parts[parts.length - 1]] = value;
+  const target = join2(configDir, "config", `${name}.json`);
+  writeJson(target, root);
+  CACHE[configDir + "::" + name] = root;
+}
+function listConfig(name, configDir = getAppConfigDir()) {
+  return loadConfig(name, configDir);
+}
+
+// core/src/log.ts
+import { join as join3 } from "path";
+import { appendFileSync } from "fs";
+var START_TIME = (/* @__PURE__ */ new Date()).toISOString().replace(/:/g, "-").split(".")[0];
+function globalSetting(key, fallback, configDir = getAppConfigDir()) {
+  const v = loadConfig("core", configDir)[key];
+  return v === void 0 ? fallback : v;
+}
+function envTruthy(v) {
+  return !!v && v !== "0" && v.toLowerCase() !== "false";
+}
+function consoleEnabled(configDir) {
+  if (process.env.CORE_LOG_CONSOLE !== void 0) return envTruthy(process.env.CORE_LOG_CONSOLE);
+  return globalSetting("logConsole", false, configDir) === true;
+}
+function colorEnabled(configDir) {
+  if (process.env.NO_COLOR !== void 0) return false;
+  return globalSetting("logColor", true, configDir) !== false;
+}
+var RESET = "\x1B[0m";
+var RED = 31;
+var PALETTE = [36, 32, 33, 35, 34, 96, 92, 93, 95, 94];
+function prefixColor(name) {
+  let h = 0;
+  for (let i = 0; i < name.length; i++) h = h * 31 + name.charCodeAt(i) >>> 0;
+  return PALETTE[h % PALETTE.length];
+}
+function paint(code, s) {
+  return `\x1B[${code}m${s}${RESET}`;
+}
+function isLoggingEnabled(name, configDir = getAppConfigDir()) {
+  return loadConfig(name, configDir).logging !== false;
+}
+function makeWriteLog(name, configDir = getAppConfigDir()) {
+  return function writeLog(message, isError = false) {
+    try {
+      if (isError || consoleEnabled(configDir)) {
+        if (colorEnabled(configDir)) {
+          const tag = paint(prefixColor(name), `[${name}]`);
+          console.error(`${tag} ${isError ? paint(RED, message) : message}`);
+        } else {
+          console.error(`[${name}] ${message}`);
+        }
+      }
+      if (!isLoggingEnabled(name, configDir)) return;
+      const date = /* @__PURE__ */ new Date();
+      const dir = join3(configDir, "logs", date.toISOString().split("T")[0]);
+      ensureDir(dir);
+      const prefix = isError ? "[ERROR]" : "[INFO]";
+      appendFileSync(join3(dir, `${name}-${START_TIME}.log`), `[${date.toISOString()}] ${prefix} ${message}
+`);
+    } catch {
+    }
+  };
+}
+function createLogger(name, configDir = getAppConfigDir()) {
+  return {
+    getConfig: () => loadConfig(name, configDir),
+    isLoggingEnabled: () => isLoggingEnabled(name, configDir),
+    writeLog: makeWriteLog(name, configDir)
+  };
+}
+
+// core/src/hook.ts
+function isHookInvocation(firstArg) {
+  return firstArg !== void 0 && typeof firstArg !== "string";
+}
+
+// core/src/command.ts
+import { join as join4 } from "path";
+function render(def, bundlePath2) {
+  const fm = ["---", `description: ${def.description}`];
+  if (def.argumentHint) fm.push(`argument-hint: ${def.argumentHint}`);
+  fm.push("---", "");
+  const lines = [fm.join("\n")];
+  if (def.shell) lines.push("!`" + def.shell.replace(/\{\{BUNDLE\}\}/g, bundlePath2) + "`", "");
+  lines.push(def.body || "");
+  return lines.join("\n").replace(/\n{3,}/g, "\n\n").trimEnd() + "\n";
+}
+function bundlePath(configDir, pluginName) {
+  return join4(configDir, "plugin", `${pluginName}.js`);
+}
+function deployCommands(pluginName, defs) {
+  const written = [];
+  for (const { configDir, commandDir } of existingApps()) {
+    const dir = join4(configDir, commandDir);
+    for (const def of defs) {
+      const file = join4(dir, `${def.name}.md`);
+      atomicWrite(file, render(def, bundlePath(configDir, pluginName)));
+      written.push(file);
+    }
+  }
+  return written;
+}
+function configCommand(pluginName, commandName = `${pluginName}-config`) {
+  return {
+    name: commandName,
+    description: `View and change ${pluginName} configuration`,
+    argumentHint: "list | get <key> | set <key> <value>",
+    shell: `node "{{BUNDLE}}" config $ARGUMENTS`,
+    body: `Above is the result of the ${pluginName} config command. Report it to the user; if they asked to change a setting, confirm the new value.`
+  };
+}
+
+// core/src/configcli.ts
+function runConfigCli(pluginName, argv) {
+  const [action, key, ...rest] = argv;
+  if (!action || action === "list") {
+    const cfg = listConfig(pluginName);
+    const keys = Object.keys(cfg);
+    if (!keys.length) {
+      console.log(`${pluginName}: no config set (using defaults).`);
+      return;
+    }
+    for (const k of keys) console.log(`${k} = ${JSON.stringify(cfg[k])}`);
+    return;
+  }
+  if (action === "get") {
+    if (!key) {
+      console.log("usage: get <key>");
+      return;
+    }
+    console.log(`${key} = ${JSON.stringify(getConfigValue(pluginName, key))}`);
+    return;
+  }
+  if (action === "set") {
+    if (!key || rest.length === 0) {
+      console.log("usage: set <key> <value>");
+      return;
+    }
+    const value = coerce(rest.join(" "));
+    setConfigValue(pluginName, key, value);
+    console.log(`set ${key} = ${JSON.stringify(value)}`);
+    return;
+  }
+  console.log(`${pluginName} config \u2014 usage: list | get <key> | set <key> <value>`);
+}
+function maybeRunConfigCli(pluginName) {
+  const argv = process.argv.slice(2);
+  if (argv[0] !== "config") return false;
+  try {
+    runConfigCli(pluginName, argv.slice(1));
+  } catch (e) {
+    console.error(String(e.message ?? e));
+  }
+  return true;
+}
+export {
+  atomicWrite,
+  coerce,
+  configCommand,
+  configPath,
+  createLogger,
+  deployCommands,
+  ensureDir,
+  existingApps,
+  existingConfigDirs,
+  getApp,
+  getAppConfigDir,
+  getConfigValue,
+  globalSetting,
+  isClaude,
+  isHookInvocation,
+  isLoggingEnabled,
+  listConfig,
+  loadConfig,
+  makeWriteLog,
+  maybeRunConfigCli,
+  readJson,
+  runConfigCli,
+  setConfigValue,
+  writeJson
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "plugin-updater",
-  "version": "1.3.0",
+  "version": "1.3.2",
   "description": "Plugin lifecycle manager for OpenCode and Claude Code launchers",
   "type": "module",
   "main": "dist/index.js",
@@ -22,7 +22,7 @@
   ],
   "files": [
     "dist/",
-    "core/dist/",
+    "lib/",
     "README.md",
     "LICENSE"
   ],
@@ -30,7 +30,7 @@
     "node": ">=20.0.0"
   },
   "scripts": {
-    "build": "npx esbuild core/src/index.ts --bundle --platform=node --format=esm --outfile=core/dist/index.js && tsc",
+    "build": "npx esbuild core/src/index.ts --bundle --platform=node --format=esm --outfile=lib/core.js && tsc",
     "test": "npm run build && vitest run",
     "prepublishOnly": "npm run build"
   },

package/core/LICENSE

@@ -1,21 +0,0 @@
-MIT License
-
-Copyright (c) 2025 intisy
-
-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/core/README.md

@@ -1,84 +0,0 @@
-# core
-
-The shared foundation every plugin in the ecosystem builds on. Consumed as a git
-submodule and bundled into each plugin (like `core-auth` / `core-loader`), so there
-is no runtime install. It supersedes `core-log` (whose config + logging API lives
-here now) and adds app detection, the opencode/claude hook guard, file helpers, and
-a **cross-app command + config-command framework**.
-
-## Under-the-Hood Architecture
-
-```mermaid
-flowchart TD
-    PLUGIN["any plugin (utility / provider / loader)"] -->|imports + bundles| CORE["core (this repo, submodule)"]
-    CORE --> ENV["env: getApp / getAppConfigDir / existingApps"]
-    CORE --> CFG["config: load / get / set / list (config/<name>.json)"]
-    CORE --> LOG["log: createLogger / makeWriteLog"]
-    CORE --> FILES["files: atomicWrite / readJson / writeJson"]
-    CORE --> HOOK["hook: isHookInvocation guard"]
-    CORE --> CMD["command: deployCommands / configCommand"]
-    CMD -->|writes *.md| OCDIR["~/.config/opencode/command/"]
-    CMD -->|writes *.md| CCDIR["~/.claude/commands/"]
-    OCDIR -->|/<plugin>-config runs| CLI["node <bundle> config …  (maybeRunConfigCli)"]
-    CCDIR -->|/<plugin>-config runs| CLI
-    CLI --> CFG
-```
-
-## Structure
-- `src/` — `env`, `config`, `log`, `files`, `hook`, `command`, `configcli`, `index` (barrel)
-- `dist/` — single bundled `index.js` (generated; not committed). The config CLI ships inside it.
-
-## Installation (for a plugin author)
-Add as a submodule and bundle it (esbuild `bundle: true`), importing from `../core/dist/index.js`:
-```bash
-git submodule add https://github.com/intisy-ai/core core
-```
-`core` is **not published to npm** — it's a bundled submodule. (Loaders/providers that already carry `core-loader`/`core-auth` can nest `core` inside those, or add it as a second submodule.)
-
-## API
-```ts
-import {
-  getApp, isClaude, getAppConfigDir, existingApps,        // env
-  loadConfig, getConfigValue, setConfigValue, listConfig, // config
-  createLogger, makeWriteLog,                             // log
-  atomicWrite, readJson, writeJson, ensureDir,            // files
-  isHookInvocation,                                       // hook guard
-  deployCommands, configCommand, maybeRunConfigCli,       // commands
-} from "../core/dist/index.js";
-```
-
-### Commands (work in both opencode and Claude Code)
-Both apps read markdown slash-commands from a directory (`<cfg>/command/` for opencode,
-`<cfg>/commands/` for claude). `deployCommands(pluginName, defs)` writes each command to
-**both**, so one definition works everywhere. A command may run a shell line whose output
-is injected, and `{{BUNDLE}}` resolves to the plugin's deployed file:
-
-```ts
-import { deployCommands, configCommand } from "../core/dist/index.js";
-deployCommands("wakatime-sync", [
-  configCommand("wakatime-sync"),                         // /wakatime-sync-config (100% config)
-  { name: "wakatime", description: "Today's tracked time", shell: 'node "{{BUNDLE}}" today' },
-]);
-```
-
-### 100% configurable via commands
-`configCommand(name)` generates a `/<name>-config` command with `list | get <key> | set <key> <value>`.
-It shells into the plugin's own bundle, which must call `maybeRunConfigCli` at the top of its entry:
-
-```ts
-import { maybeRunConfigCli } from "../core/dist/index.js";
-if (maybeRunConfigCli("wakatime-sync")) { /* ran as `node bundle config …`; stop here */ }
-else { /* normal plugin activation */ }
-```
-Every key in `config/<name>.json` is then reachable (`set` coerces `true`/`false`/numbers/JSON).
-
-## Configuration
-`core` itself has no config. It reads each consuming plugin's `config/<name>.json`
-(preferred) or `<name>.json` (fallback) under the app's config dir.
-
-## Logging
-Via `createLogger(name)` / `makeWriteLog(name)` → `<configDir>/logs/YYYY-MM-DD/<name>-HH-MM-SS.log`,
-toggle with `"logging": false` in the plugin's config.
-
-## License
-MIT