opencode-mempalace 0.1.5 → 0.1.7

package/dist/auto-update.d.ts

@@ -0,0 +1,11 @@
+export interface UpdateResult {
+    currentVersion: string | null;
+    latestVersion: string | null;
+    updated: boolean;
+    error?: string;
+}
+/**
+ * Check npm registry for a newer version and install it if available.
+ * @param runInstall - Callback to run `bun install` in a given directory. Returns true on success.
+ */
+export declare function checkAndUpdate(runInstall: (cwd: string) => Promise<boolean>): Promise<UpdateResult>;

package/dist/index.js

@@ -12334,12 +12334,182 @@ function tool(input) {
   return input;
 }
 tool.schema = exports_external;
+// src/auto-update.ts
+import * as fs from "fs";
+import * as path from "path";
+import * as os from "os";
+import * as crypto from "crypto";
+var PACKAGE_NAME = "opencode-mempalace";
+var NPM_REGISTRY_URL = `https://registry.npmjs.org/-/package/${PACKAGE_NAME}/dist-tags`;
+var NPM_FETCH_TIMEOUT = 5000;
+function getOpenCodeCacheDir() {
+  if (process.platform === "win32") {
+    const appdata = process.env.APPDATA ?? path.join(os.homedir(), "AppData", "Roaming");
+    return path.join(appdata, "opencode");
+  }
+  return path.join(process.env.XDG_CACHE_HOME ?? path.join(os.homedir(), ".cache"), "opencode");
+}
+function getOpenCodeConfigDir() {
+  if (process.platform === "win32") {
+    const appdata = process.env.APPDATA ?? path.join(os.homedir(), "AppData", "Roaming");
+    return path.join(appdata, "opencode");
+  }
+  return path.join(process.env.XDG_CONFIG_HOME ?? path.join(os.homedir(), ".config"), "opencode");
+}
+var CACHE_DIR = path.join(getOpenCodeCacheDir(), "packages");
+var CONFIG_DIR = getOpenCodeConfigDir();
+function getCachedVersion() {
+  const locations = [
+    path.join(CACHE_DIR, "node_modules", PACKAGE_NAME, "package.json"),
+    path.join(CACHE_DIR, `${PACKAGE_NAME}@latest`, "node_modules", PACKAGE_NAME, "package.json"),
+    path.join(CONFIG_DIR, "node_modules", PACKAGE_NAME, "package.json")
+  ];
+  for (const pkgPath of locations) {
+    try {
+      if (fs.existsSync(pkgPath)) {
+        const pkg = JSON.parse(fs.readFileSync(pkgPath, "utf-8"));
+        if (pkg.version)
+          return pkg.version;
+      }
+    } catch {}
+  }
+  return null;
+}
+async function getLatestVersion() {
+  const controller = new AbortController;
+  const timeoutId = setTimeout(() => controller.abort(), NPM_FETCH_TIMEOUT);
+  try {
+    const response = await fetch(NPM_REGISTRY_URL, {
+      signal: controller.signal,
+      headers: { Accept: "application/json" }
+    });
+    if (!response.ok)
+      return null;
+    const data = await response.json();
+    return data.latest ?? null;
+  } catch {
+    return null;
+  } finally {
+    clearTimeout(timeoutId);
+  }
+}
+function stripTrailingCommas(json2) {
+  return json2.replace(/,(\s*[}\]])/g, "$1");
+}
+function invalidatePackage() {
+  const pkgDirs = [
+    path.join(CONFIG_DIR, "node_modules", PACKAGE_NAME),
+    path.join(CACHE_DIR, "node_modules", PACKAGE_NAME),
+    path.join(CACHE_DIR, `${PACKAGE_NAME}@latest`, "node_modules", PACKAGE_NAME)
+  ];
+  let removed = false;
+  for (const dir of pkgDirs) {
+    try {
+      if (fs.existsSync(dir)) {
+        fs.rmSync(dir, { recursive: true, force: true });
+        removed = true;
+      }
+    } catch {}
+  }
+  for (const baseDir of [CACHE_DIR, path.join(CACHE_DIR, `${PACKAGE_NAME}@latest`)]) {
+    const textLock = path.join(baseDir, "bun.lock");
+    const binaryLock = path.join(baseDir, "bun.lockb");
+    if (fs.existsSync(textLock)) {
+      try {
+        const content = fs.readFileSync(textLock, "utf-8");
+        const lock = JSON.parse(stripTrailingCommas(content));
+        if (lock.packages?.[PACKAGE_NAME]) {
+          delete lock.packages[PACKAGE_NAME];
+          fs.writeFileSync(textLock, JSON.stringify(lock, null, 2));
+          removed = true;
+        }
+      } catch {}
+    } else if (fs.existsSync(binaryLock)) {
+      try {
+        fs.unlinkSync(binaryLock);
+        removed = true;
+      } catch {}
+    }
+  }
+  return removed;
+}
+function syncCachePackageJson(pkgJsonPath) {
+  try {
+    if (!fs.existsSync(pkgJsonPath)) {
+      fs.mkdirSync(path.dirname(pkgJsonPath), { recursive: true });
+      fs.writeFileSync(pkgJsonPath, JSON.stringify({ dependencies: { [PACKAGE_NAME]: "latest" } }, null, 2));
+      return true;
+    }
+    const content = fs.readFileSync(pkgJsonPath, "utf-8");
+    const pkg = JSON.parse(content);
+    if (!pkg.dependencies)
+      pkg.dependencies = {};
+    if (pkg.dependencies[PACKAGE_NAME] === "latest")
+      return true;
+    pkg.dependencies[PACKAGE_NAME] = "latest";
+    const tmpPath = `${pkgJsonPath}.${crypto.randomUUID()}`;
+    fs.writeFileSync(tmpPath, JSON.stringify(pkg, null, 2));
+    fs.renameSync(tmpPath, pkgJsonPath);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function resolveActiveWorkspace() {
+  const configInstall = path.join(CONFIG_DIR, "node_modules", PACKAGE_NAME, "package.json");
+  const cacheInstall = path.join(CACHE_DIR, "node_modules", PACKAGE_NAME, "package.json");
+  if (fs.existsSync(configInstall))
+    return CONFIG_DIR;
+  if (fs.existsSync(cacheInstall))
+    return CACHE_DIR;
+  if (fs.existsSync(path.join(CACHE_DIR, "package.json")))
+    return CACHE_DIR;
+  return CONFIG_DIR;
+}
+async function checkAndUpdate(runInstall) {
+  const currentVersion = getCachedVersion();
+  const latestVersion = await getLatestVersion();
+  if (!currentVersion || !latestVersion) {
+    return { currentVersion, latestVersion, updated: false };
+  }
+  if (currentVersion === latestVersion) {
+    return { currentVersion, latestVersion, updated: false };
+  }
+  try {
+    syncCachePackageJson(path.join(CACHE_DIR, "package.json"));
+    const atLatestDir = path.join(CACHE_DIR, `${PACKAGE_NAME}@latest`);
+    if (fs.existsSync(atLatestDir)) {
+      syncCachePackageJson(path.join(atLatestDir, "package.json"));
+    }
+    invalidatePackage();
+    const activeWorkspace = resolveActiveWorkspace();
+    const success2 = await runInstall(activeWorkspace);
+    if (success2) {
+      if (activeWorkspace !== CACHE_DIR) {
+        await runInstall(CACHE_DIR).catch(() => {});
+      }
+      if (activeWorkspace !== atLatestDir && fs.existsSync(path.join(atLatestDir, "package.json"))) {
+        await runInstall(atLatestDir).catch(() => {});
+      }
+    }
+    return {
+      currentVersion,
+      latestVersion,
+      updated: success2,
+      error: success2 ? undefined : "bun install failed"
+    };
+  } catch (err) {
+    return {
+      currentVersion,
+      latestVersion,
+      updated: false,
+      error: err instanceof Error ? err.message : String(err)
+    };
+  }
+}
+
 // src/index.ts
-var DEFAULT_MCP_COMMAND = [
-  "bun",
-  "run",
-  "/home/dat/mempalace-js/src/mcp-server.ts"
-];
+var DEFAULT_MCP_COMMAND = ["npx", "-y", "-p", "@nguyentamdat/mempalace", "mempalace-mcp"];
 var PALACE_PROTOCOL = `IMPORTANT \u2014 MemPalace Memory Protocol:
 1. ON WAKE-UP: Call mempalace_status to load palace overview + AAAK spec.
 2. BEFORE RESPONDING about any person, project, or past event: call mempalace_kg_query or mempalace_search FIRST. Never guess \u2014 verify.
@@ -12356,12 +12526,31 @@ On session start, load mempalace context by calling these tools directly (do NOT
 
 Call both in parallel. If either fails (ChromaDB not running), skip silently and continue.
 Use the results to inform your responses \u2014 do not announce or summarize them unless the user asks.
-Proceed with the user's request immediately.`;
-var mempalacePlugin = async (_input, options) => {
+Proceed with the user's request immediately.
+<!-- MEMPALACE -->`;
+var mempalacePlugin = async (input, options) => {
   const opts = options ?? {};
   const mcpCommand = opts.mcpCommand ?? DEFAULT_MCP_COMMAND;
   const sessionsSeen = new Set;
   const diaryWritten = new Set;
+  let updateResult = null;
+  if (!opts.disableAutoUpdate) {
+    checkAndUpdate(async (cwd) => {
+      try {
+        const result = await input.$`bun install`.cwd(cwd).quiet().nothrow();
+        return result.exitCode === 0;
+      } catch {
+        return false;
+      }
+    }).then((result) => {
+      updateResult = result;
+      if (result.updated) {
+        console.log(`[opencode-mempalace] Auto-updated: ${result.currentVersion} \u2192 ${result.latestVersion}. Restart to apply.`);
+      } else if (result.error) {
+        console.log(`[opencode-mempalace] Update available: ${result.currentVersion} \u2192 ${result.latestVersion} (install failed: ${result.error})`);
+      }
+    }).catch(() => {});
+  }
   return {
     config: opts.disableMcp ? undefined : async (config2) => {
       if (!config2.mcp)
@@ -12374,23 +12563,28 @@ var mempalacePlugin = async (_input, options) => {
         };
       }
     },
-    "experimental.chat.system.transform": opts.disableProtocol ? undefined : async (_input2, output) => {
-      output.system.push(PALACE_PROTOCOL);
+    "experimental.chat.system.transform": async (_input, output) => {
+      if (!opts.disableProtocol) {
+        output.system.push(PALACE_PROTOCOL);
+      }
+      if (updateResult?.updated) {
+        output.system.push(`[opencode-mempalace] Updated ${updateResult.currentVersion} \u2192 ${updateResult.latestVersion}. Restart OpenCode to apply.`);
+      }
     },
-    "tool.execute.after": async (input, _output) => {
-      if (input.tool === "mcp_mempalace_mempalace_diary_write") {
-        diaryWritten.add(input.sessionID);
+    "tool.execute.after": async (input2, _output) => {
+      if (input2.tool === "mcp_mempalace_mempalace_diary_write") {
+        diaryWritten.add(input2.sessionID);
       }
     },
-    "experimental.session.compacting": async (input, output) => {
-      if (!diaryWritten.has(input.sessionID)) {
+    "experimental.session.compacting": async (input2, output) => {
+      if (!diaryWritten.has(input2.sessionID)) {
         output.context.push("\u26A0\uFE0F MEMPALACE: No diary entry written yet for this session. Call mcp_mempalace_mempalace_diary_write with a session summary BEFORE important context is lost to compaction.");
       }
     },
-    "chat.message": opts.disableAutoLoad ? undefined : async (input, output) => {
-      if (sessionsSeen.has(input.sessionID))
+    "chat.message": opts.disableAutoLoad ? undefined : async (input2, output) => {
+      if (sessionsSeen.has(input2.sessionID))
         return;
-      sessionsSeen.add(input.sessionID);
+      sessionsSeen.add(input2.sessionID);
       const firstTextPart = output.parts.find((p) => p.type === "text");
       if (firstTextPart && "text" in firstTextPart) {
         firstTextPart.text = `${SESSION_START_INSTRUCTION}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "opencode-mempalace",
-  "version": "0.1.5",
+  "version": "0.1.7",
   "description": "OpenCode plugin for MemPalace memory system — auto-registers MCP server, injects memory protocol into system prompt, and loads context on session start",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",