@ephemushroom/opencode-claude-mem 0.7.0 → 0.7.2

package/dist/cli.js

@@ -1,12 +1,82 @@
 // @bun
-// src/worker-client.ts
-import { existsSync, readFileSync } from "fs";
+// src/capture-status.ts
+import { createHash, randomUUID } from "crypto";
+import { join, resolve } from "path";
+import {
+  mkdirSync,
+  readFileSync,
+  readdirSync,
+  realpathSync,
+  renameSync,
+  rmSync,
+  statSync,
+  writeFileSync
+} from "fs";
 import { homedir } from "os";
-import { join } from "path";
+function cacheDirectory(env = process.env, home = homedir()) {
+  return join(env["XDG_CACHE_HOME"]?.trim() || join(home, ".cache"), "opencode-claude-mem");
+}
+function statusKey(directory) {
+  let resolved = resolve(directory);
+  try {
+    resolved = realpathSync(directory);
+  } catch {}
+  return createHash("sha256").update(resolved).digest("hex").slice(0, 16);
+}
+function isAlive(pid) {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (error) {
+    return error.code === "EPERM";
+  }
+}
+function parseStatus(file) {
+  try {
+    const parsed = JSON.parse(readFileSync(file, "utf8"));
+    if (typeof parsed !== "object" || parsed === null) {
+      return null;
+    }
+    const { state, message, pid } = parsed;
+    return (state === "ok" || state === "problem") && typeof message === "string" && typeof pid === "number" && Number.isInteger(pid) && pid > 0 ? { state, message, pid } : null;
+  } catch {
+    return null;
+  }
+}
+function readCaptureStatus(directory, dir = cacheDirectory()) {
+  const folder = join(dir, "status");
+  const prefix = `${statusKey(directory)}.`;
+  let names = [];
+  try {
+    names = readdirSync(folder).filter((name) => name.startsWith(prefix) && name.endsWith(".json"));
+  } catch {
+    return null;
+  }
+  let best = null;
+  for (const name of names) {
+    const file = join(folder, name);
+    const parsed = parseStatus(file);
+    if (!parsed || !isAlive(parsed.pid)) {
+      rmSync(file, { force: true });
+    } else {
+      const own = parsed.pid === process.pid;
+      const at = statSync(file, { throwIfNoEntry: false })?.mtimeMs ?? 0;
+      if (!best || own && !best.own || own === best.own && at > best.at) {
+        best = { status: { state: parsed.state, message: parsed.message }, own, at };
+      }
+    }
+  }
+  return best?.status ?? null;
+}
+
+// src/worker-client.ts
+import { existsSync, readFileSync as readFileSync2 } from "fs";
+import { join as join2, resolve as resolve2, win32 } from "path";
+import { createHash as createHash2 } from "crypto";
+import { homedir as homedir2 } from "os";
 var DEFAULT_WORKER_HOST = "127.0.0.1";
-var DEFAULT_WORKER_PORT = 37777;
-var SETTINGS_FILE = join(homedir(), ".claude-mem", "settings.json");
-var LOOPBACK_HOSTS = new Set(["127.0.0.1", "localhost", "::1", "[::1]"]);
+var WORKER_PORT_BASE = 37700;
+var TOKEN_HEADER = "x-claude-mem-token";
 var PROJECT_COUNTS_SQL = `SELECT
   (SELECT COUNT(*) FROM observations
     WHERE project = ?1 COLLATE NOCASE OR merged_into_project = ?1 COLLATE NOCASE) AS observations,
@@ -36,25 +106,62 @@ function parseSettings(rawSettings) {
     return {};
   }
   try {
-    const parsed = JSON.parse(rawSettings);
-    return isRecord(parsed) ? parsed : {};
+    const parsed = JSON.parse(rawSettings.replace(/^\uFEFF/, ""));
+    if (!isRecord(parsed)) {
+      return {};
+    }
+    const nested = parsed["env"];
+    const source = isRecord(nested) && Object.keys(nested).some((key) => key.startsWith("CLAUDE_MEM_")) ? nested : parsed;
+    return Object.fromEntries(Object.entries(source).map(([key, value]) => [
+      key,
+      typeof value === "number" || typeof value === "boolean" ? String(value) : value
+    ]));
   } catch {
     return {};
   }
 }
-function parseWorkerEndpoint(env, rawSettings) {
+function dataDirectory(env, home) {
+  const dir = readString(env["CLAUDE_MEM_DATA_DIR"]) ?? join2(home, ".claude-mem");
+  return dir.replace(/^~(?=$|[\\/])/, home);
+}
+function defaultWorkerPort(dataDir, platform = process.platform, uid = typeof process.getuid === "function" ? process.getuid() : null) {
+  if (uid !== null) {
+    return WORKER_PORT_BASE + (uid % 100 + 100) % 100;
+  }
+  const normalized = platform === "win32" ? win32.resolve(dataDir).toLowerCase() : resolve2(dataDir);
+  const digest = createHash2("sha256").update(normalized, "utf8").digest();
+  return WORKER_PORT_BASE + digest.readUInt32BE(0) % 100;
+}
+function parseWorkerEndpoint(env, rawSettings, fallbackPort = defaultWorkerPort(dataDirectory(env, homedir2()))) {
   const settings = parseSettings(rawSettings);
-  const host = readString(env["CLAUDE_MEM_WORKER_HOST"]) ?? readString(settings["CLAUDE_MEM_WORKER_HOST"]) ?? DEFAULT_WORKER_HOST;
-  const port = readPort(env["CLAUDE_MEM_WORKER_PORT"]) ?? readPort(settings["CLAUDE_MEM_WORKER_PORT"]) ?? DEFAULT_WORKER_PORT;
+  const configured = readString(env["CLAUDE_MEM_WORKER_HOST"]) ?? readString(settings["CLAUDE_MEM_WORKER_HOST"]) ?? DEFAULT_WORKER_HOST;
+  const host = configured === "localhost" ? DEFAULT_WORKER_HOST : configured;
+  const port = readPort(env["CLAUDE_MEM_WORKER_PORT"]) ?? readPort(settings["CLAUDE_MEM_WORKER_PORT"]) ?? fallbackPort;
   return { host, port };
 }
+function isLoopbackHost(host) {
+  const name = host.toLowerCase().replace(/^\[|\]$/g, "");
+  return name === "localhost" || name.endsWith(".localhost") || name === "::1" || /^127(?:\.\d{1,3}){1,3}$/.test(name);
+}
+function workerUrl(endpoint) {
+  const host = endpoint.host.includes(":") && !endpoint.host.startsWith("[") ? `[${endpoint.host}]` : endpoint.host;
+  return `http://${host}:${endpoint.port}`;
+}
+function tokenHeaders(baseUrl, rawSettings) {
+  const token = readString(parseSettings(rawSettings)["CLAUDE_MEM_LOCAL_API_TOKEN"]);
+  try {
+    return token && isLoopbackHost(new URL(baseUrl).hostname) ? { [TOKEN_HEADER]: token } : {};
+  } catch {
+    return {};
+  }
+}
 function resolveDatabasePath(env, rawSettings, home) {
-  if (!LOOPBACK_HOSTS.has(parseWorkerEndpoint(env, rawSettings).host)) {
+  if (!isLoopbackHost(parseWorkerEndpoint(env, rawSettings).host)) {
     return null;
   }
   const settings = parseSettings(rawSettings);
-  const dir = readString(env["CLAUDE_MEM_DATA_DIR"]) ?? readString(settings["CLAUDE_MEM_DATA_DIR"]) ?? join(home, ".claude-mem");
-  return join(dir.replace(/^~(?=$|[\\/])/, home), "claude-mem.db");
+  const dir = readString(env["CLAUDE_MEM_DATA_DIR"]) ?? readString(settings["CLAUDE_MEM_DATA_DIR"]) ?? join2(home, ".claude-mem");
+  return join2(dir.replace(/^~(?=$|[\\/])/, home), "claude-mem.db");
 }
 function readCount(value) {
   return typeof value === "number" && Number.isInteger(value) && value >= 0 ? value : null;
@@ -88,27 +195,45 @@ function readEpoch(item) {
 }
 function readSettingsRaw() {
   try {
-    return readFileSync(SETTINGS_FILE, "utf8");
+    return readFileSync2(join2(dataDirectory(process.env, homedir2()), "settings.json"), "utf8");
   } catch {
     return null;
   }
 }
+function readWorkerSetting(key) {
+  return readString(process.env[key]) ?? readString(parseSettings(readSettingsRaw())[key]);
+}
+function getWorkerEndpoint() {
+  return parseWorkerEndpoint(process.env, readSettingsRaw());
+}
 function getWorkerBaseUrl() {
-  const endpoint = parseWorkerEndpoint(process.env, readSettingsRaw());
-  return `http://${endpoint.host}:${endpoint.port}`;
+  return workerUrl(getWorkerEndpoint());
+}
+function workerHeaders(baseUrl = getWorkerBaseUrl()) {
+  return tokenHeaders(baseUrl, readSettingsRaw());
 }
 
 class WorkerClient {
   static BASE_URL = getWorkerBaseUrl();
-  static DATABASE_PATH = resolveDatabasePath(process.env, readSettingsRaw(), homedir());
+  static SUPPORTED = !readWorkerSetting("CLAUDE_MEM_WORKER_URL");
+  static DATABASE_PATH = resolveDatabasePath(process.env, readSettingsRaw(), homedir2());
+  static get(path) {
+    if (!this.SUPPORTED) {
+      return Promise.reject(new Error("CLAUDE_MEM_WORKER_URL is not supported"));
+    }
+    return fetch(`${this.BASE_URL}${path}`, {
+      headers: workerHeaders(this.BASE_URL),
+      redirect: "error"
+    });
+  }
   static getProjectCounts(project) {
-    return this.DATABASE_PATH ? readProjectCounts(this.DATABASE_PATH, project) : Promise.resolve(null);
+    return this.DATABASE_PATH && this.SUPPORTED ? readProjectCounts(this.DATABASE_PATH, project) : Promise.resolve(null);
   }
   static async getStats() {
     try {
       const [statsRes, processingRes] = await Promise.all([
-        fetch(`${this.BASE_URL}/api/stats`),
-        fetch(`${this.BASE_URL}/api/processing-status`)
+        this.get(`/api/stats`),
+        this.get(`/api/processing-status`)
       ]);
       if (!statsRes.ok) {
         return null;
@@ -123,7 +248,7 @@ class WorkerClient {
   static async getRecentSummaries(project, limit) {
     try {
       const params = new URLSearchParams({ project, limit: String(limit) });
-      const response = await fetch(`${this.BASE_URL}/api/summaries?${params.toString()}`);
+      const response = await this.get(`/api/summaries?${params.toString()}`);
       if (!response.ok) {
         return [];
       }
@@ -145,7 +270,7 @@ class WorkerClient {
   static async getRecentObservations(project, limit) {
     try {
       const params = new URLSearchParams({ project, limit: String(limit) });
-      const response = await fetch(`${this.BASE_URL}/api/observations?${params.toString()}`);
+      const response = await this.get(`/api/observations?${params.toString()}`);
       if (!response.ok) {
         return [];
       }
@@ -168,7 +293,7 @@ class WorkerClient {
   static async getDetail(kind, id) {
     try {
       const path = kind === "observation" ? "observation" : "session";
-      const response = await fetch(`${this.BASE_URL}/api/${path}/${id}`);
+      const response = await this.get(`/api/${path}/${id}`);
       if (!response.ok) {
         return null;
       }
@@ -252,6 +377,9 @@ function summaryLine(view) {
   if (!view.healthy) {
     return { label: "(offline)", tone: "err" };
   }
+  if (view.capture?.state === "problem") {
+    return { label: "(capture off)", tone: "err" };
+  }
   if (view.isProcessing || (view.queueDepth ?? 0) > 0) {
     return { label: `(queue ${view.queueDepth ?? 0})`, tone: "warn" };
   }
@@ -272,18 +400,50 @@ function bulletRow(icon, iconColor, value, theme, labelColor = theme.text) {
     label(labelColor, decodeEntities(value))
   ]);
 }
+function leftClick(action) {
+  let pressed = false;
+  return {
+    onMouseDown(event) {
+      pressed = event.button === 0;
+    },
+    onMouseDrag() {
+      pressed = false;
+    },
+    onMouseOut() {
+      pressed = false;
+    },
+    onMouseUp(event) {
+      const clicked = pressed && event.button === 0;
+      pressed = false;
+      if (clicked) {
+        event.stopPropagation();
+        action();
+      }
+    }
+  };
+}
 function recentRow(icon, iconColor, title, age, theme, onSelect) {
-  return box({ flexDirection: "column", ...onSelect ? { onMouseDown: onSelect } : {} }, [
+  return box({ flexDirection: "column", ...onSelect ? leftClick(onSelect) : {} }, [
     bulletRow(icon, iconColor, title, theme),
     ...age ? [box({ paddingLeft: 2 }, [label(theme.textMuted, age)])] : []
   ]);
 }
 function expandedRows(view, theme, onSelect) {
+  const notice = view.capture?.message ? [
+    box({ flexDirection: "row", gap: 1 }, [
+      text({ fg: theme.warning, flexShrink: 0 }, "!"),
+      text({
+        fg: view.capture.state === "problem" ? theme.error : theme.warning,
+        wrapMode: "word"
+      }, view.capture.message)
+    ])
+  ] : [];
   if (!view.healthy) {
-    return [bulletRow("\u2022", theme.error, "worker offline", theme)];
+    return [bulletRow("\u2022", theme.error, "worker offline", theme), ...notice];
   }
   const counts = `obs ${formatCount(view.observations)} \xB7 sum ${formatCount(view.summaries)} \xB7 ses ${formatCount(view.sessions)}`;
   const rows = [
+    ...notice,
     bulletRow("\u2022", theme.success, view.scope === "all" ? `all \xB7 ${counts}` : counts, theme)
   ];
   if (view.scope === "project") {
@@ -312,7 +472,7 @@ function expandedRows(view, theme, onSelect) {
 }
 function buildMemNodes(view, theme, collapsed, onToggle, onSelect) {
   const summary = summaryLine(view);
-  const header = box({ flexDirection: "row", gap: 1, onMouseDown: onToggle }, [
+  const header = box({ flexDirection: "row", gap: 1, ...leftClick(onToggle) }, [
     text({ fg: theme.text, flexShrink: 0 }, collapsed ? "\u25B6" : "\u25BC"),
     text({ fg: theme.info, attributes: 1, flexShrink: 0 }, "Memory"),
     collapsed ? text({ fg: toneColor(summary.tone, theme) }, summary.label) : label(theme.textMuted, view.project)
@@ -330,14 +490,16 @@ function viewKey(view) {
 function readCount2(value) {
   return typeof value === "number" && Number.isFinite(value) ? value : null;
 }
-async function readMemView(project, collapsed) {
+async function readMemView(project, collapsed, directory = "") {
   const [stats, counts] = await Promise.all([
     WorkerClient.getStats(),
     WorkerClient.getProjectCounts(project)
   ]);
+  const capture = directory ? readCaptureStatus(directory) : null;
   if (!stats) {
     return {
       healthy: false,
+      capture,
       project,
       scope: "all",
       totalObservations: null,
@@ -358,6 +520,7 @@ async function readMemView(project, collapsed) {
   const totalObservations = readCount2(stats.database?.observations);
   return {
     healthy: true,
+    capture,
     project,
     scope: counts ? "project" : "all",
     totalObservations,
@@ -446,6 +609,7 @@ var REFRESH_EVENTS = ["session.created", "session.execution.succeeded"];
 function emptyView(project) {
   return {
     healthy: false,
+    capture: null,
     project,
     scope: "all",
     totalObservations: null,
@@ -466,7 +630,8 @@ var cli_default = define({
     if (!solid) {
       return;
     }
-    const project = String(ctx.location?.directory ?? process.cwd()).split(/[\\/]/).filter(Boolean).findLast(Boolean) ?? "unknown-project";
+    const directory = String(ctx.location?.directory ?? process.cwd());
+    const project = directory.split(/[\\/]/).filter(Boolean).findLast(Boolean) ?? "unknown-project";
     const [state, setState] = ctx.storage.memory("claude-mem.sidebar", {
       initial: { collapsed: true, view: emptyView(project) }
     });
@@ -487,7 +652,7 @@ var cli_default = define({
         do {
           refreshPending = false;
           const { collapsed } = state;
-          const next = await readMemView(project, collapsed);
+          const next = await readMemView(project, collapsed, directory);
           if (disposed) {
             return;
           }
@@ -531,7 +696,9 @@ var cli_default = define({
           });
           return;
         }
-        return ctx.ui.dialog.alert(detail);
+        return new Promise((closed) => {
+          ctx.ui.dialog.show(() => renderDetail(ctx, solid, detail), closed);
+        });
       }).catch(() => {}).finally(() => {
         opening = false;
       });
@@ -596,6 +763,47 @@ function themeFromResolved(resolved) {
     borderSubtle: resolved.border.base
   };
 }
+function renderDetail(ctx, solid, detail) {
+  ctx.ui.dialog.set({ size: "xlarge", centered: true });
+  const panel = solid.createElement("box");
+  solid.setProp(panel, "flexDirection", "column");
+  solid.setProp(panel, "padding", 1);
+  solid.setProp(panel, "gap", 1);
+  const header = solid.createElement("box");
+  solid.setProp(header, "flexDirection", "row");
+  solid.setProp(header, "gap", 2);
+  const title = solid.createElement("text");
+  solid.setProp(title, "fg", ctx.theme.text.base);
+  solid.setProp(title, "attributes", 1);
+  solid.setProp(title, "flexGrow", 1);
+  solid.setProp(title, "wrapMode", "none");
+  solid.setProp(title, "truncate", true);
+  solid.insert(title, detail.title);
+  solid.insert(header, title);
+  const close = solid.createElement("text");
+  solid.setProp(close, "fg", ctx.theme.text.muted);
+  solid.setProp(close, "flexShrink", 0);
+  solid.setProp(close, "onMouseUp", (event) => {
+    if (event.button === 0) {
+      ctx.ui.dialog.clear();
+    }
+  });
+  solid.insert(close, "esc close");
+  solid.insert(header, close);
+  solid.insert(panel, header);
+  const body = solid.createElement("scrollbox");
+  solid.setProp(body, "scrollX", false);
+  const sizeBody = (height) => solid.setProp(body, "maxHeight", Math.max(1, Math.floor(height * 0.75) - 4));
+  sizeBody(ctx.renderer.height);
+  solid.onResize((_width, height) => sizeBody(height));
+  const message = solid.createElement("text");
+  solid.setProp(message, "fg", ctx.theme.text.base);
+  solid.setProp(message, "wrapMode", "word");
+  solid.insert(message, detail.message);
+  solid.insert(body, message);
+  solid.insert(panel, body);
+  return panel;
+}
 function materializeNode(node, solid) {
   const element = solid.createElement(node.kind);
   for (const [name, value] of Object.entries(node.props)) {

package/dist/official-sync.d.ts

@@ -0,0 +1,29 @@
+export interface OfficialFiles {
+    readonly version: string;
+    /** The official OpenCode plugin: default export `{ id, server, setup }`. */
+    readonly plugin: string;
+    readonly mcpServer: string;
+}
+export type SyncResult = {
+    readonly ok: true;
+    readonly files: OfficialFiles;
+} | {
+    readonly ok: false;
+    readonly reason: string;
+};
+export interface SyncOptions {
+    /** Directory holding one sub-directory per version. */
+    readonly root?: string;
+    readonly registry?: string;
+}
+export declare function officialRoot(): string;
+/** `CLAUDE_MEM_NPM_REGISTRY`, then npm's own registry setting, then the public registry. */
+export declare function npmRegistry(env?: Record<string, string | undefined>): string;
+/**
+ * Reads the named regular files out of a gzipped tar. npm tarballs are ustar; a path longer
+ * than the name field uses the prefix field, and anything else (pax records, directories)
+ * is skipped by its size. No `tar` binary is needed, which Windows may not have on PATH.
+ */
+export declare function extractTarFiles(archive: Uint8Array, members: readonly string[]): Map<string, Uint8Array>;
+/** The official files for `version`, downloading them once when they are not on disk. */
+export declare function syncOfficial(version: string, options?: SyncOptions): Promise<SyncResult>;

package/dist/server.d.ts

@@ -0,0 +1,70 @@
+/**
+ * OpenCode V2 server plugin: one package entry that brings claude-mem to OpenCode.
+ *
+ * Capture and context injection stay upstream code: this plugin downloads the official
+ * claude-mem OpenCode plugin at the running Worker's version and runs its `setup` with
+ * this plugin's context. On top of that it registers the memory tools the official plugin
+ * leaves to claude-mem's MCP server, starts the Worker when it is not running, and reports
+ * what happened to the sidebar. Loaded from `opencode.json`:
+ *
+ * ```json
+ * { "plugins": ["@ephemushroom/opencode-claude-mem"] }
+ * ```
+ *
+ * `{ "package": "...", "options": { "mcp": true } }` registers claude-mem's MCP server
+ * (all of its tools, in a separate process) instead of this plugin's own tools.
+ */
+import { type CaptureStatusWriter } from './capture-status';
+import type { Plugin } from '@opencode/plugin';
+type Cleanup = () => Promise<void> | void;
+/** What a capture pass needs from the host; `Plugin.Context` satisfies it. */
+export interface CaptureContext {
+    readonly mcp: Pick<Plugin.Context['mcp'], 'transform'>;
+    /** The host's plugins for this checkout; its result is read defensively. */
+    readonly plugin: {
+        readonly list: () => Promise<unknown>;
+    };
+}
+/**
+ * What the host says about a plugin with the official id: loaded and running, loaded and
+ * failed, not among its plugins, or `unknown` while its list is still empty.
+ */
+export type OfficialPluginState = 'active' | 'failed' | 'absent' | 'unknown';
+export declare function officialPluginState(ctx: CaptureContext): Promise<OfficialPluginState>;
+/** One `setup` call: the host runs it once per checkout it serves. */
+export interface CaptureSession {
+    readonly ctx: CaptureContext;
+    readonly directory: string;
+    readonly status: CaptureStatusWriter;
+    readonly useMcp: boolean;
+    readonly keep: (cleanup: Cleanup) => void;
+    readonly disposed: () => boolean;
+    /** Something records this checkout's sessions: the copy loaded here, or a standalone one the host confirmed. */
+    capturing: boolean;
+    mcpRegistered: boolean;
+}
+/**
+ * True when the official plugin exists as a standalone file, the way
+ * `npx claude-mem install --ide opencode` leaves it in the config directory, or a project
+ * keeps it under `.opencode` in the checkout or a directory above it. OpenCode normally
+ * loads that file by itself, and a second copy here would record every prompt and tool
+ * call twice. The file alone proves nothing: whether it runs is the host's to say
+ * (`officialPluginState`).
+ */
+export declare function standalonePluginInstalled(env: Record<string, string | undefined>, home: string, directory: string): boolean;
+/** claude-mem's MCP server is a Node script; without Node the host binary runs it as Bun. */
+export declare function mcpServerCommand(script: string, node: string | null, host: string): {
+    command: string[];
+    environment?: Record<string, string>;
+};
+/**
+ * One pass over what is still missing: a running Worker, the official files at exactly its
+ * version, capture, and the MCP server when asked for. Resolves true when nothing is left
+ * to do. Each step is recorded only after it succeeded, so a later pass never repeats it:
+ * a second `setup` of the official plugin would record everything twice. Only the first
+ * pass starts the Worker; later ones look at what is there, so a Worker that crashes on
+ * start is not launched again every minute.
+ */
+export declare function attemptCapture(session: CaptureSession, first: boolean): Promise<boolean>;
+declare const plugin: Plugin.Plugin;
+export default plugin;