context-mode 1.0.113 → 1.0.115

package/.claude-plugin/marketplace.json

@@ -6,14 +6,14 @@
   },
   "metadata": {
     "description": "Claude Code plugins by Mert Koseoğlu",
-    "version": "1.0.113"
+    "version": "1.0.115"
   },
   "plugins": [
     {
       "name": "context-mode",
       "source": "./",
       "description": "Claude Code MCP plugin that saves 98% of your context window. Sandboxed code execution in 11 languages, FTS5 knowledge base with BM25 ranking, and intent-driven search.",
-      "version": "1.0.113",
+      "version": "1.0.115",
       "author": {
         "name": "Mert Koseoğlu"
       },

package/.claude-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "context-mode",
-  "version": "1.0.113",
+  "version": "1.0.115",
   "description": "MCP server that saves 98% of your context window with session continuity. Sandboxed code execution in 11 languages, FTS5 knowledge base with BM25 ranking, and automatic state restore across compactions.",
   "author": {
     "name": "Mert Koseoğlu",

package/.openclaw-plugin/openclaw.plugin.json

@@ -3,7 +3,7 @@
   "name": "Context Mode",
   "kind": "tool",
   "description": "OpenClaw plugin that saves 98% of your context window. Sandboxed code execution in 11 languages, FTS5 knowledge base with BM25 ranking, and intent-driven search.",
-  "version": "1.0.113",
+  "version": "1.0.115",
   "sandbox": {
     "mode": "permissive",
     "filesystem_access": "full",

package/.openclaw-plugin/package.json

@@ -1,6 +1,6 @@
 {
   "name": "context-mode",
-  "version": "1.0.113",
+  "version": "1.0.115",
   "description": "OpenClaw plugin that saves 98% of your context window. Sandboxed code execution in 11 languages, FTS5 knowledge base with BM25 ranking, and intent-driven search.",
   "author": {
     "name": "Mert Koseoğlu",

package/build/cli.js

@@ -679,9 +679,75 @@ async function upgrade() {
             };
             writeFileSync(resolve(pluginRoot, ".mcp.json"), JSON.stringify(mcpConfig, null, 2) + "\n");
             s.stop(color.green(`Updated in-place to v${newVersion}`));
+            // v1.0.114 hotfix — pre-flight: verify the in-place copy actually
+            // wrote a plugin.json carrying newVersion BEFORE we tell the
+            // registry that's the install path. If the manifest still reports
+            // the old version (rsync race, partial write, files-array drift),
+            // updating the registry would create the silent v1.0.113-class
+            // drift Mert hit. Bail out — the next /ctx-upgrade gets to retry.
+            const pluginManifest = resolve(pluginRoot, ".claude-plugin", "plugin.json");
+            let onDiskVersion = null;
+            try {
+                const pj = JSON.parse(readFileSync(pluginManifest, "utf-8"));
+                if (pj && typeof pj.version === "string")
+                    onDiskVersion = pj.version;
+            }
+            catch { /* parse error → onDiskVersion stays null */ }
+            if (onDiskVersion !== newVersion) {
+                throw new Error(`pluginRoot manifest version mismatch — disk says "${onDiskVersion ?? "<missing>"}" but newVersion is "${newVersion}". Refusing to bump registry.`);
+            }
             // Fix registry — adapter-aware
             adapter.updatePluginRegistry(pluginRoot, newVersion);
             p.log.info(color.dim("  Registry synced to " + pluginRoot));
+            // v1.0.114 hotfix — post-write assertion: re-read installed_plugins.json
+            // and verify installPath/.claude-plugin/plugin.json's version matches
+            // the registry entry. Throws on mismatch — fails loudly so a future
+            // adapter regression surfaces here, not weeks later in user reports.
+            try {
+                const ipPath = resolve(resolveClaudeConfigDir(), "plugins", "installed_plugins.json");
+                if (existsSync(ipPath)) {
+                    const ip = JSON.parse(readFileSync(ipPath, "utf-8"));
+                    const entries = ip?.plugins?.["context-mode@context-mode"];
+                    if (Array.isArray(entries)) {
+                        for (const entry of entries) {
+                            const ip2 = entry?.installPath;
+                            if (typeof ip2 !== "string" || !ip2)
+                                continue;
+                            if (!existsSync(ip2)) {
+                                throw new Error(`installPath does not exist on disk: ${ip2}`);
+                            }
+                            const pjPath = resolve(ip2, ".claude-plugin", "plugin.json");
+                            if (!existsSync(pjPath)) {
+                                throw new Error(`missing plugin.json manifest at ${pjPath}`);
+                            }
+                            const pj = JSON.parse(readFileSync(pjPath, "utf-8"));
+                            if (pj?.version !== entry.version) {
+                                throw new Error(`version mismatch — registry says "${entry.version}" but ${pjPath} says "${pj?.version}"`);
+                            }
+                        }
+                    }
+                }
+            }
+            catch (err) {
+                const message = err instanceof Error ? err.message : String(err);
+                throw new Error(`Registry consistency check failed: ${message}`);
+            }
+            // v1.0.114 hotfix — marketplace post-pull assertion: clone (if
+            // present) MUST be on newVersion. Mert's case showed marketplace
+            // stuck at v1.0.89 — the sync block above swallowed that silently.
+            // Warn (don't throw) — npm-only users have no marketplace clone.
+            try {
+                const marketplaceManifest = resolve(marketplaceDir, ".claude-plugin", "plugin.json");
+                if (existsSync(marketplaceManifest)) {
+                    const mpj = JSON.parse(readFileSync(marketplaceManifest, "utf-8"));
+                    if (mpj?.version !== newVersion) {
+                        p.log.warn(color.yellow("Marketplace clone version mismatch") +
+                            ` — ${marketplaceDir} reports "${mpj?.version}" but expected "${newVersion}"`);
+                        p.log.info(color.dim(`  Run manually: git -C "${marketplaceDir}" fetch --tags origin && git -C "${marketplaceDir}" reset --hard origin/HEAD`));
+                    }
+                }
+            }
+            catch { /* best effort */ }
             // Install production deps
             s.start("Installing production dependencies");
             npmExecFile(["install", "--production", "--no-audit", "--no-fund"], {

package/build/server.js

@@ -184,12 +184,16 @@ function getSessionDir() {
 function getProjectDir() {
     // Delegated to the shared resolver so the env-var chain rejects plugin
     // install paths (set by a prior MCP boot's start.mjs after `/ctx-upgrade`)
-    // and prefers the shell-set PWD before the chdir'd cwd. See
-    // src/util/project-dir.ts for the rationale + safety rules.
+    // and prefers the shell-set PWD before the chdir'd cwd. v1.0.115 adds
+    // the Claude Code transcript heuristic — read `cwd` from the most-recently-
+    // modified `~/.claude/projects/<encoded>/<session>.jsonl` to recover the
+    // real project dir when MCP was launched from a non-project cwd (desktop-
+    // app launch, /ctx-upgrade respawn). See src/util/project-dir.ts.
     return resolveProjectDir({
         env: process.env,
         cwd: process.cwd(),
         pwd: process.env.PWD,
+        transcriptsRoot: join(homedir(), ".claude", "projects"),
     });
 }
 /**

package/build/util/project-dir.d.ts

@@ -26,6 +26,30 @@
  * suffix pattern.
  */
 export declare function isPluginInstallPath(p: string): boolean;
+/**
+ * Read the per-session project dir from Claude Code's transcript files.
+ *
+ * Claude Code writes session transcripts under
+ * `~/.claude/projects/<encoded-cwd>/<session-id>.jsonl`. Each line is a JSON
+ * event; an early line (typically line 2) carries a `cwd` field with the
+ * literal project directory the session is running against. The encoded dir
+ * name itself is lossy (`/` and `.` both become `-`), so we read the JSONL.
+ *
+ * This is the strongest available signal when Claude Code does NOT propagate
+ * `CLAUDE_PROJECT_DIR` to the spawned MCP env (the common case when Claude
+ * Code is launched from the desktop app rather than `cd <project> && claude`).
+ *
+ * Returns `undefined` when no transcript exists, the projects dir is empty,
+ * or no transcript carries a `cwd` field — caller falls through.
+ *
+ * Multi-window safety: the most-recently-modified jsonl wins. When the user
+ * actively talks to one Claude Code window, that window's transcript is the
+ * one being written to RIGHT NOW, so its mtime is freshest. Other windows'
+ * transcripts have older mtimes and are correctly ignored.
+ */
+export declare function resolveProjectDirFromTranscript(opts: {
+    projectsRoot: string;
+}): string | undefined;
 /**
  * Pure project-dir resolver. Mirror of the env-var chain inside
  * `src/server.ts getProjectDir()`, but takes its inputs explicitly so the
@@ -34,10 +58,14 @@ export declare function isPluginInstallPath(p: string): boolean;
  * Resolution order:
  *   1. Adapter-priority env vars (CLAUDE / GEMINI / VSCODE / OPENCODE / PI /
  *      IDEA / CONTEXT_MODE) — first non-empty AND non-plugin-path wins.
- *   2. `process.env.PWD` — shell-set, NOT updated by `process.chdir()`, so
+ *   2. Claude Code transcript heuristic — read `cwd` from the most-recently-
+ *      modified `~/.claude/projects/<encoded>/<session>.jsonl`. This is the
+ *      most reliable signal when Claude Code launched MCP from a non-project
+ *      cwd (desktop-app launch, `/ctx-upgrade` respawn, etc.).
+ *   3. `process.env.PWD` — shell-set, NOT updated by `process.chdir()`, so
  *      it survives the `start.mjs` chdir into the plugin dir. Skipped if
  *      it too points at a plugin install path.
- *   3. `cwd` — last resort. Returned even if it is a plugin path; the
+ *   4. `cwd` — last resort. Returned even if it is a plugin path; the
  *      caller is responsible for rendering a graceful "no project context"
  *      message rather than panicking. Keeping the function total preserves
  *      operation of project-independent tools (sandbox execute, fetch).
@@ -46,4 +74,6 @@ export declare function resolveProjectDir(opts: {
     env: Record<string, string | undefined>;
     cwd: string;
     pwd: string | undefined;
+    /** Optional override; production code passes `~/.claude/projects`. */
+    transcriptsRoot?: string;
 }): string;

package/build/util/project-dir.js

@@ -30,6 +30,103 @@ export function isPluginInstallPath(p) {
         return false;
     return /[/\\]\.claude[/\\]plugins[/\\](cache|marketplaces)[/\\]/.test(p);
 }
+/**
+ * Read the per-session project dir from Claude Code's transcript files.
+ *
+ * Claude Code writes session transcripts under
+ * `~/.claude/projects/<encoded-cwd>/<session-id>.jsonl`. Each line is a JSON
+ * event; an early line (typically line 2) carries a `cwd` field with the
+ * literal project directory the session is running against. The encoded dir
+ * name itself is lossy (`/` and `.` both become `-`), so we read the JSONL.
+ *
+ * This is the strongest available signal when Claude Code does NOT propagate
+ * `CLAUDE_PROJECT_DIR` to the spawned MCP env (the common case when Claude
+ * Code is launched from the desktop app rather than `cd <project> && claude`).
+ *
+ * Returns `undefined` when no transcript exists, the projects dir is empty,
+ * or no transcript carries a `cwd` field — caller falls through.
+ *
+ * Multi-window safety: the most-recently-modified jsonl wins. When the user
+ * actively talks to one Claude Code window, that window's transcript is the
+ * one being written to RIGHT NOW, so its mtime is freshest. Other windows'
+ * transcripts have older mtimes and are correctly ignored.
+ */
+export function resolveProjectDirFromTranscript(opts) {
+    // Inline imports kept private to this function — keeps the module test-
+    // friendly when fs is stubbed at the call sites that don't use this path.
+    // eslint-disable-next-line @typescript-eslint/no-require-imports
+    const fs = require("node:fs");
+    const path = require("node:path");
+    if (!fs.existsSync(opts.projectsRoot))
+        return undefined;
+    let bestPath;
+    let bestMtime = 0;
+    try {
+        for (const dir of fs.readdirSync(opts.projectsRoot)) {
+            const dirPath = path.join(opts.projectsRoot, dir);
+            let stat;
+            try {
+                stat = fs.statSync(dirPath);
+            }
+            catch {
+                continue;
+            }
+            if (!stat.isDirectory())
+                continue;
+            let files;
+            try {
+                files = fs.readdirSync(dirPath);
+            }
+            catch {
+                continue;
+            }
+            for (const f of files) {
+                if (!f.endsWith(".jsonl"))
+                    continue;
+                const fp = path.join(dirPath, f);
+                try {
+                    const m = fs.statSync(fp).mtimeMs;
+                    if (m > bestMtime) {
+                        bestMtime = m;
+                        bestPath = fp;
+                    }
+                }
+                catch { /* skip */ }
+            }
+        }
+    }
+    catch {
+        return undefined;
+    }
+    if (!bestPath)
+        return undefined;
+    // Read first ~10 lines until we find a cwd field. The jsonl is
+    // append-only and can be huge (60+ MB on long sessions) — never load it
+    // into memory; stream a small head buffer.
+    try {
+        const fd = fs.openSync(bestPath, "r");
+        try {
+            const buf = Buffer.alloc(8192);
+            const bytes = fs.readSync(fd, buf, 0, buf.length, 0);
+            const text = buf.subarray(0, bytes).toString("utf-8");
+            for (const line of text.split("\n").slice(0, 10)) {
+                if (!line.trim())
+                    continue;
+                try {
+                    const obj = JSON.parse(line);
+                    if (typeof obj.cwd === "string" && obj.cwd.length > 0)
+                        return obj.cwd;
+                }
+                catch { /* skip malformed line */ }
+            }
+        }
+        finally {
+            fs.closeSync(fd);
+        }
+    }
+    catch { /* file vanished mid-read */ }
+    return undefined;
+}
 /**
  * Pure project-dir resolver. Mirror of the env-var chain inside
  * `src/server.ts getProjectDir()`, but takes its inputs explicitly so the
@@ -38,16 +135,20 @@ export function isPluginInstallPath(p) {
  * Resolution order:
  *   1. Adapter-priority env vars (CLAUDE / GEMINI / VSCODE / OPENCODE / PI /
  *      IDEA / CONTEXT_MODE) — first non-empty AND non-plugin-path wins.
- *   2. `process.env.PWD` — shell-set, NOT updated by `process.chdir()`, so
+ *   2. Claude Code transcript heuristic — read `cwd` from the most-recently-
+ *      modified `~/.claude/projects/<encoded>/<session>.jsonl`. This is the
+ *      most reliable signal when Claude Code launched MCP from a non-project
+ *      cwd (desktop-app launch, `/ctx-upgrade` respawn, etc.).
+ *   3. `process.env.PWD` — shell-set, NOT updated by `process.chdir()`, so
  *      it survives the `start.mjs` chdir into the plugin dir. Skipped if
  *      it too points at a plugin install path.
- *   3. `cwd` — last resort. Returned even if it is a plugin path; the
+ *   4. `cwd` — last resort. Returned even if it is a plugin path; the
  *      caller is responsible for rendering a graceful "no project context"
  *      message rather than panicking. Keeping the function total preserves
  *      operation of project-independent tools (sandbox execute, fetch).
  */
 export function resolveProjectDir(opts) {
-    const { env, cwd, pwd } = opts;
+    const { env, cwd, pwd, transcriptsRoot } = opts;
     const candidates = [
         env.CLAUDE_PROJECT_DIR,
         env.GEMINI_PROJECT_DIR,
@@ -61,6 +162,11 @@ export function resolveProjectDir(opts) {
         if (c && !isPluginInstallPath(c))
             return c;
     }
+    if (transcriptsRoot) {
+        const fromTranscript = resolveProjectDirFromTranscript({ projectsRoot: transcriptsRoot });
+        if (fromTranscript && !isPluginInstallPath(fromTranscript))
+            return fromTranscript;
+    }
     if (pwd && !isPluginInstallPath(pwd))
         return pwd;
     return cwd;