@bububuger/spanory 0.1.20 → 0.1.22

package/dist/index.js

@@ -4542,6 +4542,14 @@ ${notifyLine}
 function escapeTomlBasicString(value) {
   return String(value).replaceAll("\\", "\\\\").replaceAll('"', '\\"');
 }
+function isSpanoryCodexNotifyConfigured(configText) {
+  return /notify\s*=\s*\[[^\]]*spanory-codex-notify\.sh[^\]]*\]/m.test(String(configText ?? ""));
+}
+function stripSpanoryCodexNotifyConfig(configText) {
+  const next = String(configText ?? "").replace(/^notify\s*=\s*\[[^\]]*spanory-codex-notify\.sh[^\]]*\]\s*$/gm, "").replace(/\n{3,}/g, "\n\n").trim();
+  return next ? `${next}
+` : "";
+}
 function codexNotifyScriptContent({ spanoryBin, codexHome, exportDir, logFile }) {
   return `#!/usr/bin/env bash
 set -euo pipefail
@@ -4629,6 +4637,183 @@ async function applyCodexSetup({ homeRoot, spanoryBin, dryRun }) {
     configBackup
   };
 }
+async function applyCodexWatchSetup({ homeRoot, dryRun }) {
+  const codexHome = path8.join(homeRoot, ".codex");
+  const scriptPath = path8.join(codexHome, "bin", "spanory-codex-notify.sh");
+  const configPath = path8.join(codexHome, "config.toml");
+  let currentConfig = "";
+  try {
+    currentConfig = await readFile8(configPath, "utf-8");
+  } catch (error) {
+    if (error?.code !== "ENOENT")
+      throw error;
+  }
+  const nextConfig = stripSpanoryCodexNotifyConfig(currentConfig);
+  const configChanged = currentConfig !== nextConfig;
+  let scriptPresent = false;
+  try {
+    await stat4(scriptPath);
+    scriptPresent = true;
+  } catch {
+  }
+  const changed = configChanged || scriptPresent;
+  let configBackup = null;
+  if (changed && !dryRun) {
+    if (configChanged) {
+      await mkdir4(path8.dirname(configPath), { recursive: true });
+      configBackup = await backupIfExists(configPath);
+      await writeFile4(configPath, nextConfig, "utf-8");
+    }
+    if (scriptPresent) {
+      await rm(scriptPath, { force: true });
+    }
+  }
+  return {
+    runtime: "codex",
+    ok: true,
+    changed,
+    dryRun,
+    mode: "watch",
+    configPath,
+    scriptPath,
+    configBackup,
+    notifyConfigured: isSpanoryCodexNotifyConfigured(nextConfig),
+    scriptPresent: false
+  };
+}
+function removeClaudeHooks(settings) {
+  if (!settings.hooks || typeof settings.hooks !== "object")
+    return;
+  for (const eventName of Object.keys(settings.hooks)) {
+    const groups = settings.hooks[eventName];
+    if (!Array.isArray(groups))
+      continue;
+    for (const group of groups) {
+      if (!group || !Array.isArray(group.hooks))
+        continue;
+      group.hooks = group.hooks.filter((hook) => !(hook && typeof hook === "object" && isSpanoryHookCommand(hook.command)));
+    }
+    settings.hooks[eventName] = groups.filter((group) => !group || !Array.isArray(group.hooks) || group.hooks.length > 0);
+    if (settings.hooks[eventName].length === 0)
+      delete settings.hooks[eventName];
+  }
+  if (Object.keys(settings.hooks).length === 0)
+    delete settings.hooks;
+}
+async function teardownClaudeSetup({ homeRoot, dryRun }) {
+  const settingsPath = path8.join(homeRoot, ".claude", "settings.json");
+  let settings = {};
+  try {
+    settings = JSON.parse(await readFile8(settingsPath, "utf-8"));
+  } catch (error) {
+    if (error?.code !== "ENOENT")
+      throw new Error(`failed to parse Claude settings: ${error.message ?? String(error)}`);
+    return { runtime: "claude-code", ok: true, changed: false, dryRun, settingsPath, backup: null };
+  }
+  const before = JSON.stringify(settings);
+  removeClaudeHooks(settings);
+  const after = JSON.stringify(settings);
+  const changed = before !== after;
+  let backup = null;
+  if (changed && !dryRun) {
+    backup = await backupIfExists(settingsPath);
+    await writeFile4(settingsPath, JSON.stringify(settings, null, 2), "utf-8");
+  }
+  return { runtime: "claude-code", ok: true, changed, dryRun, settingsPath, backup };
+}
+async function teardownCodexSetup({ homeRoot, dryRun }) {
+  const codexHome = path8.join(homeRoot, ".codex");
+  const configPath = path8.join(codexHome, "config.toml");
+  const scriptPath = path8.join(codexHome, "bin", "spanory-codex-notify.sh");
+  let currentConfig = "";
+  try {
+    currentConfig = await readFile8(configPath, "utf-8");
+  } catch (error) {
+    if (error?.code !== "ENOENT")
+      throw error;
+  }
+  const nextConfig = stripSpanoryCodexNotifyConfig(currentConfig);
+  const configChanged = currentConfig !== nextConfig;
+  let scriptPresent = false;
+  try {
+    await stat4(scriptPath);
+    scriptPresent = true;
+  } catch {
+  }
+  const changed = configChanged || scriptPresent;
+  let configBackup = null;
+  if (changed && !dryRun) {
+    if (configChanged) {
+      configBackup = await backupIfExists(configPath);
+      await writeFile4(configPath, nextConfig, "utf-8");
+    }
+    if (scriptPresent)
+      await rm(scriptPath, { force: true });
+  }
+  return { runtime: "codex", ok: true, changed, dryRun, configPath, scriptPath, configBackup, scriptRemoved: scriptPresent };
+}
+async function teardownOpenclawSetup({ homeRoot, openclawRuntimeHome, dryRun }) {
+  if (!commandExists("openclaw")) {
+    return { runtime: "openclaw", ok: true, skipped: true, detail: "openclaw command not found in PATH" };
+  }
+  const runtimeHome = openclawRuntimeHomeForSetup(homeRoot, openclawRuntimeHome);
+  if (dryRun)
+    return { runtime: "openclaw", ok: true, changed: true, dryRun };
+  const result = runSystemCommand("openclaw", ["plugins", "uninstall", OPENCLAW_SPANORY_PLUGIN_ID], {
+    env: { ...process.env, ...runtimeHome ? { OPENCLAW_STATE_DIR: resolveRuntimeHome3("openclaw", runtimeHome) } : {} }
+  });
+  if (result.code !== 0)
+    throw new Error(result.stderr || result.error || "openclaw plugins uninstall failed");
+  return { runtime: "openclaw", ok: true, changed: true, dryRun };
+}
+async function teardownOpencodeSetup({ homeRoot, opencodeRuntimeHome, dryRun }) {
+  const runtimeHome = opencodeRuntimeHomeForSetup(homeRoot, opencodeRuntimeHome);
+  const loaderFile = opencodePluginLoaderPath(runtimeHome);
+  let present = false;
+  try {
+    await stat4(loaderFile);
+    present = true;
+  } catch {
+  }
+  if (present && !dryRun)
+    await rm(loaderFile, { force: true });
+  return { runtime: "opencode", ok: true, changed: present, dryRun, loaderFile };
+}
+async function runSetupTeardown(options) {
+  const homeRoot = setupHomeRoot(options.home);
+  const selected = parseSetupRuntimes(options.runtimes);
+  const dryRun = Boolean(options.dryRun);
+  const results = [];
+  if (selected.includes("claude-code")) {
+    try {
+      results.push(await teardownClaudeSetup({ homeRoot, dryRun }));
+    } catch (error) {
+      results.push({ runtime: "claude-code", ok: false, error: String(error?.message ?? error) });
+    }
+  }
+  if (selected.includes("codex")) {
+    try {
+      results.push(await teardownCodexSetup({ homeRoot, dryRun }));
+    } catch (error) {
+      results.push({ runtime: "codex", ok: false, error: String(error?.message ?? error) });
+    }
+  }
+  if (selected.includes("openclaw")) {
+    try {
+      results.push(await teardownOpenclawSetup({ homeRoot, openclawRuntimeHome: options.openclawRuntimeHome, dryRun }));
+    } catch (error) {
+      results.push({ runtime: "openclaw", ok: false, error: String(error?.message ?? error) });
+    }
+  }
+  if (selected.includes("opencode")) {
+    try {
+      results.push(await teardownOpencodeSetup({ homeRoot, opencodeRuntimeHome: options.opencodeRuntimeHome, dryRun }));
+    } catch (error) {
+      results.push({ runtime: "opencode", ok: false, error: String(error?.message ?? error) });
+    }
+  }
+  return { ok: results.every((r) => r.ok), results };
+}
 function commandExists(command) {
   const result = runSystemCommand("which", [command], { env: process.env });
   return result.code === 0;
@@ -4671,7 +4856,102 @@ function openclawRuntimeHomeForSetup(homeRoot, explicitRuntimeHome) {
 function opencodeRuntimeHomeForSetup(homeRoot, explicitRuntimeHome) {
   return explicitRuntimeHome || path8.join(homeRoot, ".config", "opencode");
 }
-function installOpenclawPlugin(runtimeHome) {
+function resolveOpenclawConfigPath(runtimeHome) {
+  return path8.join(runtimeHome, "openclaw.json");
+}
+function canonicalPath(input) {
+  const resolved = path8.resolve(String(input ?? ""));
+  try {
+    return realpathSync(resolved);
+  } catch {
+    return resolved;
+  }
+}
+function readOpenclawPluginNameFromDir(dirPath) {
+  const pkgPath = path8.join(dirPath, "package.json");
+  if (!existsSync(pkgPath))
+    return null;
+  try {
+    const parsed = JSON.parse(readFileSync(pkgPath, "utf-8"));
+    const name = String(parsed?.name ?? "").trim();
+    return name || null;
+  } catch {
+    return null;
+  }
+}
+function isSpanoryOpenclawPluginPath(candidatePath) {
+  const text = String(candidatePath ?? "").trim();
+  if (!text)
+    return false;
+  const normalized = text.replaceAll("\\", "/").toLowerCase();
+  if (normalized.includes("spanory") && normalized.includes("openclaw-plugin")) {
+    return true;
+  }
+  const canonical = canonicalPath(text);
+  const pluginName = readOpenclawPluginNameFromDir(canonical);
+  return pluginName === "@bububuger/spanory-openclaw-plugin" || pluginName === "@alipay/spanory-openclaw-plugin";
+}
+async function normalizeOpenclawPluginLoadPaths(runtimeHome, pluginDir, dryRun) {
+  const configPath = resolveOpenclawConfigPath(runtimeHome);
+  let configRaw = "";
+  try {
+    configRaw = await readFile8(configPath, "utf-8");
+  } catch (error) {
+    if (error?.code === "ENOENT")
+      return { changed: false, configPath, backup: null };
+    throw error;
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(configRaw);
+  } catch (error) {
+    throw new Error(`failed to parse openclaw config ${configPath}: ${error?.message ?? String(error)}`);
+  }
+  if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+    parsed = {};
+  }
+  if (!parsed.plugins || typeof parsed.plugins !== "object" || Array.isArray(parsed.plugins)) {
+    parsed.plugins = {};
+  }
+  if (!parsed.plugins.load || typeof parsed.plugins.load !== "object" || Array.isArray(parsed.plugins.load)) {
+    parsed.plugins.load = {};
+  }
+  const target = path8.resolve(pluginDir);
+  const targetCanonical = canonicalPath(target);
+  const currentPaths = Array.isArray(parsed.plugins.load.paths) ? parsed.plugins.load.paths : [];
+  const nonSpanoryPaths = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const item of currentPaths) {
+    if (typeof item !== "string")
+      continue;
+    const text = item.trim();
+    if (!text)
+      continue;
+    if (isSpanoryOpenclawPluginPath(text))
+      continue;
+    const key = canonicalPath(text);
+    if (seen.has(key))
+      continue;
+    seen.add(key);
+    nonSpanoryPaths.push(text);
+  }
+  if (!seen.has(targetCanonical)) {
+    nonSpanoryPaths.push(target);
+  }
+  parsed.plugins.load.paths = nonSpanoryPaths;
+  const nextRaw = `${JSON.stringify(parsed, null, 2)}
+`;
+  if (nextRaw === configRaw) {
+    return { changed: false, configPath, backup: null };
+  }
+  let backup = null;
+  if (!dryRun) {
+    backup = await backupIfExists(configPath);
+    await writeFile4(configPath, nextRaw, "utf-8");
+  }
+  return { changed: true, configPath, backup };
+}
+async function installOpenclawPlugin(runtimeHome, dryRun) {
   const pluginDir = path8.resolve(resolveOpenclawPluginDir());
   const installResult = runSystemCommand("openclaw", ["plugins", "install", "-l", pluginDir], {
     env: {
@@ -4691,9 +4971,12 @@ function installOpenclawPlugin(runtimeHome) {
   if (enableResult.code !== 0) {
     throw new Error(enableResult.stderr || enableResult.error || "openclaw plugins enable failed");
   }
+  const pathNormalizeResult = await normalizeOpenclawPluginLoadPaths(runtimeHome, pluginDir, dryRun);
   return {
+    pluginDir,
     installStdout: installResult.stdout.trim(),
-    enableStdout: enableResult.stdout.trim()
+    enableStdout: enableResult.stdout.trim(),
+    pathNormalizeResult
   };
 }
 async function installOpencodePlugin(runtimeHome, pluginDirOverride) {
@@ -4749,7 +5032,7 @@ async function runSetupDetect(options) {
   let codexNotifyConfigured = false;
   try {
     const config = await readFile8(codexConfigPath, "utf-8");
-    codexNotifyConfigured = /notify\s*=\s*\[[^\]]*spanory-codex-notify\.sh[^\]]*\]/m.test(config);
+    codexNotifyConfigured = isSpanoryCodexNotifyConfigured(config);
   } catch {
   }
   let codexScriptPresent = true;
@@ -4761,10 +5044,11 @@ async function runSetupDetect(options) {
   report2.runtimes.push({
     runtime: "codex",
     available: commandExists("codex"),
-    configured: codexNotifyConfigured && codexScriptPresent,
+    configured: !codexNotifyConfigured,
     details: {
       configPath: codexConfigPath,
       scriptPath: codexScriptPath,
+      mode: "watch",
       notifyConfigured: codexNotifyConfigured,
       scriptPresent: codexScriptPresent
     }
@@ -4822,7 +5106,7 @@ async function runSetupDoctor(options) {
     let notifyConfigured = false;
     try {
       const config = await readFile8(configPath, "utf-8");
-      notifyConfigured = /notify\s*=\s*\[[^\]]*spanory-codex-notify\.sh[^\]]*\]/m.test(config);
+      notifyConfigured = isSpanoryCodexNotifyConfigured(config);
     } catch {
     }
     let scriptPresent = false;
@@ -4832,15 +5116,15 @@ async function runSetupDoctor(options) {
     } catch {
     }
     checks.push({
-      id: "codex_notify_configured",
+      id: "codex_watch_mode",
       runtime: "codex",
-      ok: notifyConfigured,
+      ok: !notifyConfigured,
       detail: configPath
     });
     checks.push({
-      id: "codex_notify_script",
+      id: "codex_notify_script_absent",
       runtime: "codex",
-      ok: scriptPresent,
+      ok: !scriptPresent,
       detail: scriptPath
     });
   }
@@ -4883,7 +5167,7 @@ async function runSetupApply(options) {
   const selected = parseSetupRuntimes(options.runtimes);
   const spanoryBin = options.spanoryBin ?? "spanory";
   const dryRun = Boolean(options.dryRun);
-  const codexMode = options.codexMode ?? "notify";
+  const codexMode = options.codexMode ?? process.env.SPANORY_CODEX_MODE ?? "watch";
   const results = [];
   if (selected.includes("claude-code")) {
     try {
@@ -4898,14 +5182,7 @@ async function runSetupApply(options) {
     }
   }
   if (selected.includes("codex")) {
-    if (codexMode !== "notify") {
-      results.push({
-        runtime: "codex",
-        ok: true,
-        skipped: true,
-        detail: `codex mode "${codexMode}" skips notify setup`
-      });
-    } else {
+    if (codexMode === "notify") {
       try {
         const result = await applyCodexSetup({ homeRoot, spanoryBin, dryRun });
         results.push(result);
@@ -4916,6 +5193,24 @@ async function runSetupApply(options) {
           error: String(error?.message ?? error)
         });
       }
+    } else if (codexMode === "watch") {
+      try {
+        const result = await applyCodexWatchSetup({ homeRoot, dryRun });
+        results.push(result);
+      } catch (error) {
+        results.push({
+          runtime: "codex",
+          ok: false,
+          error: String(error?.message ?? error)
+        });
+      }
+    } else {
+      results.push({
+        runtime: "codex",
+        ok: true,
+        skipped: true,
+        detail: `codex mode "${codexMode}" has no setup action`
+      });
     }
   }
   if (selected.includes("openclaw")) {
@@ -4930,7 +5225,7 @@ async function runSetupApply(options) {
       const runtimeHome = openclawRuntimeHomeForSetup(homeRoot, options.openclawRuntimeHome);
       try {
         if (!dryRun)
-          installOpenclawPlugin(runtimeHome);
+          await installOpenclawPlugin(runtimeHome, dryRun);
         const doctor = await runOpenclawPluginDoctor(runtimeHome);
         results.push({
           runtime: "openclaw",
@@ -5286,7 +5581,7 @@ setup.command("detect").description("Detect local runtime availability and setup
   const report2 = await runSetupDetect(options);
   console.log(JSON.stringify(report2, null, 2));
 });
-setup.command("apply").description("Apply idempotent local setup for selected runtimes").option("--runtimes <csv>", `Comma-separated runtimes (default: ${DEFAULT_SETUP_RUNTIMES.join(",")})`, DEFAULT_SETUP_RUNTIMES.join(",")).option("--home <path>", "Home directory root override (default: $HOME)").option("--spanory-bin <path>", "Spanory binary/command to write into runtime configs", "spanory").option("--codex-mode <mode>", "Codex setup mode: notify | proxy (default: notify)", "notify").option("--openclaw-runtime-home <path>", "Override OpenClaw runtime home (default: ~/.openclaw)").option("--opencode-runtime-home <path>", "Override OpenCode runtime home (default: ~/.config/opencode)").option("--dry-run", "Only print planned changes without writing files", false).action(async (options) => {
+setup.command("apply").description("Apply idempotent local setup for selected runtimes").option("--runtimes <csv>", `Comma-separated runtimes (default: ${DEFAULT_SETUP_RUNTIMES.join(",")})`, DEFAULT_SETUP_RUNTIMES.join(",")).option("--home <path>", "Home directory root override (default: $HOME)").option("--spanory-bin <path>", "Spanory binary/command to write into runtime configs", "spanory").option("--openclaw-runtime-home <path>", "Override OpenClaw runtime home (default: ~/.openclaw)").option("--opencode-runtime-home <path>", "Override OpenCode runtime home (default: ~/.config/opencode)").option("--dry-run", "Only print planned changes without writing files", false).action(async (options) => {
   const report2 = await runSetupApply(options);
   console.log(JSON.stringify(report2, null, 2));
   if (!report2.ok)
@@ -5298,6 +5593,12 @@ setup.command("doctor").description("Run setup diagnostics for selected runtimes
   if (!report2.ok)
     process.exitCode = 2;
 });
+setup.command("teardown").description("Remove all Spanory integration from local runtimes").option("--runtimes <csv>", `Comma-separated runtimes (default: ${DEFAULT_SETUP_RUNTIMES.join(",")})`, DEFAULT_SETUP_RUNTIMES.join(",")).option("--home <path>", "Home directory root override (default: $HOME)").option("--openclaw-runtime-home <path>", "Override OpenClaw runtime home (default: ~/.openclaw)").option("--opencode-runtime-home <path>", "Override OpenCode runtime home (default: ~/.config/opencode)").option("--dry-run", "Only print planned changes without writing files", false).action(async (options) => {
+  const report2 = await runSetupTeardown(options);
+  console.log(JSON.stringify(report2, null, 2));
+  if (!report2.ok)
+    process.exitCode = 2;
+});
 program.command("upgrade").description("Upgrade spanory CLI from npm registry").option("--dry-run", "Print upgrade command without executing", false).option("--manager <name>", "Package manager override: npm|tnpm").option("--scope <scope>", "Install scope override: global|local").action(async (options) => {
   const manager = options.manager === "tnpm" ? "tnpm" : detectUpgradePackageManager();
   const scope = options.scope === "local" ? "local" : options.scope === "global" ? "global" : detectUpgradeScope();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bububuger/spanory",
-  "version": "0.1.20",
+  "version": "0.1.22",
   "description": "Spanory CLI for cross-runtime agent observability",
   "license": "MIT",
   "type": "module",