@cortexkit/opencode-magic-context 0.45.0 → 0.46.0

package/dist/index-sfnj6h8h.js

@@ -0,0 +1,259 @@
+import {
+  sendStatusNotification2
+} from "./index-7qw742ev.js";
+import {
+  importPluginModule,
+  log
+} from "./index-hybnrwq0.js";
+import {
+  formatConflictShort
+} from "./index-8da2zjhz.js";
+
+// src/plugin/conflict-warning-hook.ts
+import { existsSync, readFileSync } from "node:fs";
+import { homedir, platform } from "node:os";
+import { join } from "node:path";
+var CONFLICT_WARNING_MARKER = "⚠️ Magic Context is disabled due to conflicting configuration:";
+var SCHEMA_FENCE_MARKER = "⚠️ Magic Context is disabled — database is newer than this version";
+var ENABLED_MARKER = "✨ Magic Context is now enabled";
+var ANNOUNCEMENT_MARKER = "✨ Magic Context — what's new in";
+function getDesktopStatePath() {
+  const os = platform();
+  const home = homedir();
+  if (os === "darwin") {
+    return join(home, "Library", "Application Support", "ai.opencode.desktop", "opencode.global.dat");
+  }
+  if (os === "linux") {
+    const xdgConfig = process.env.XDG_CONFIG_HOME || join(home, ".config");
+    return join(xdgConfig, "ai.opencode.desktop", "opencode.global.dat");
+  }
+  if (os === "win32") {
+    const appData = process.env.APPDATA || join(home, "AppData", "Roaming");
+    return join(appData, "ai.opencode.desktop", "opencode.global.dat");
+  }
+  return null;
+}
+function readDesktopState(directory) {
+  const statePath = getDesktopStatePath();
+  if (!statePath || !existsSync(statePath)) {
+    log(`[magic-context] conflict-warning: Desktop state file not found at ${statePath}`);
+    return { sessionId: null, sidecarUrl: null };
+  }
+  try {
+    const raw = readFileSync(statePath, "utf-8");
+    const state = JSON.parse(raw);
+    let sidecarUrl = null;
+    const serverStr = state.server;
+    if (typeof serverStr === "string") {
+      try {
+        const serverState = JSON.parse(serverStr);
+        if (typeof serverState.currentSidecarUrl === "string") {
+          sidecarUrl = serverState.currentSidecarUrl;
+        }
+      } catch {}
+    }
+    let sessionId = null;
+    const layoutPage = state["layout.page"];
+    if (typeof layoutPage === "string") {
+      const parsed = JSON.parse(layoutPage);
+      const lastProjectSession = parsed.lastProjectSession;
+      if (lastProjectSession) {
+        const entry = lastProjectSession[directory];
+        sessionId = entry?.id ?? null;
+      }
+    }
+    return { sessionId, sidecarUrl };
+  } catch (error) {
+    log(`[magic-context] conflict-warning: failed to read Desktop state: ${error instanceof Error ? error.message : String(error)}`);
+    return { sessionId: null, sidecarUrl: null };
+  }
+}
+var cachedDesktopStateByDir = new Map;
+var __conflictWarningTest2 = {
+  setDesktopState(directory, state) {
+    cachedDesktopStateByDir.set(directory, state);
+  },
+  reset() {
+    cachedDesktopStateByDir.clear();
+  }
+};
+function getDesktopState(directory) {
+  let cached = cachedDesktopStateByDir.get(directory);
+  if (!cached) {
+    cached = readDesktopState(directory);
+    cachedDesktopStateByDir.set(directory, cached);
+  }
+  return cached;
+}
+async function deleteMessage(serverUrl, sessionId, messageId) {
+  const auth = getServerAuth();
+  const url = `${serverUrl}/session/${encodeURIComponent(sessionId)}/message/${encodeURIComponent(messageId)}`;
+  try {
+    const response = await fetch(url, {
+      method: "DELETE",
+      headers: auth ? { Authorization: auth } : {},
+      signal: AbortSignal.timeout(1e4)
+    });
+    if (!response.ok) {
+      log(`[magic-context] conflict-warning: DELETE failed status=${response.status} url=${url}`);
+      return false;
+    }
+    return true;
+  } catch (error) {
+    log(`[magic-context] conflict-warning: DELETE error (url=${serverUrl}): ${error instanceof Error ? error.message : String(error)}`);
+    return false;
+  }
+}
+function getServerAuth() {
+  const password = process.env.OPENCODE_SERVER_PASSWORD;
+  if (!password)
+    return;
+  const username = process.env.OPENCODE_SERVER_USERNAME ?? "opencode";
+  return `Basic ${Buffer.from(`${username}:${password}`, "utf8").toString("base64")}`;
+}
+async function getSessionMessages(client, sessionId) {
+  try {
+    const c = client;
+    if (typeof c.session?.messages === "function") {
+      const result = await c.session.messages({
+        path: { id: sessionId },
+        query: { limit: 50 }
+      });
+      return result?.data ?? [];
+    }
+  } catch (error) {
+    log(`[magic-context] conflict-warning: failed to read messages: ${error instanceof Error ? error.message : String(error)}`);
+  }
+  return [];
+}
+async function sendConflictWarning2(client, directory, conflictResult) {
+  const { sessionId } = getDesktopState(directory);
+  if (!sessionId) {
+    log("[magic-context] conflict-warning: could not find active session for Desktop warning");
+    return;
+  }
+  const warningText = formatConflictShort(conflictResult);
+  log(`[magic-context] sending conflict warning to session ${sessionId}: ${conflictResult.reasons.join(", ")}`);
+  try {
+    await sendStatusNotification2(client, sessionId, warningText, {});
+  } catch (error) {
+    log(`[magic-context] conflict-warning: failed to send: ${error instanceof Error ? error.message : String(error)}`);
+  }
+}
+async function cleanupConflictWarnings2(client, directory, serverUrl) {
+  const { sessionId } = getDesktopState(directory);
+  if (!sessionId) {
+    log("[magic-context] cleanup: no active Desktop session found");
+    return;
+  }
+  const messages = await getSessionMessages(client, sessionId);
+  if (messages.length === 0)
+    return;
+  const warningMessageIds = [];
+  for (let i = messages.length - 1;i >= 0; i--) {
+    const msg = messages[i];
+    const msgId = msg.info?.id;
+    const msgRole = msg.info?.role;
+    if (!msgId || msgRole !== "user")
+      break;
+    const parts = msg.parts ?? [];
+    const isWarning = parts.length > 0 && parts.every((p) => p.ignored === true && p.type === "text" && typeof p.text === "string" && p.text.startsWith(CONFLICT_WARNING_MARKER));
+    if (isWarning) {
+      warningMessageIds.push(msgId);
+    } else {
+      break;
+    }
+  }
+  if (warningMessageIds.length === 0) {
+    await cleanupEnabledMessages(messages, serverUrl, sessionId);
+    return;
+  }
+  if (!serverUrl) {
+    log("[magic-context] cleanup: no serverUrl provided, cannot delete messages");
+    return;
+  }
+  log(`[magic-context] cleaning up ${warningMessageIds.length} conflict warning message(s) from session ${sessionId}`);
+  for (const messageId of warningMessageIds) {
+    const ok = await deleteMessage(serverUrl, sessionId, messageId);
+    if (ok) {
+      log(`[magic-context] deleted conflict warning message ${messageId}`);
+    }
+  }
+  const enabledText = `${ENABLED_MARKER}. Enjoy! ✨`;
+  try {
+    await sendStatusNotification2(client, sessionId, enabledText, {});
+  } catch {}
+}
+async function cleanupEnabledMessages(messages, serverUrl, sessionId) {
+  if (!serverUrl)
+    return;
+  for (let i = messages.length - 1;i >= 0; i--) {
+    const msg = messages[i];
+    const msgId = msg.info?.id;
+    const msgRole = msg.info?.role;
+    if (!msgId || msgRole !== "user")
+      break;
+    const parts = msg.parts ?? [];
+    const isEnabled = parts.length > 0 && parts.every((p) => p.ignored === true && p.type === "text" && typeof p.text === "string" && p.text.startsWith(ENABLED_MARKER));
+    if (isEnabled) {
+      await deleteMessage(serverUrl, sessionId, msgId);
+    } else {
+      break;
+    }
+  }
+}
+async function sendSchemaFenceWarning2(client, directory, detail) {
+  const { sessionId } = getDesktopState(directory);
+  if (!sessionId)
+    return;
+  const text = [
+    `${SCHEMA_FENCE_MARKER}`,
+    "",
+    `The shared Magic Context database was upgraded to schema v${detail.persistedVersion} by a`,
+    `newer build (OpenCode and Pi share one database). This build only supports`,
+    `up to v${detail.supportedVersion}, so it has fail-closed to avoid corrupting the cache.`,
+    "",
+    "This usually means a pinned or stale plugin is sharing the database with a",
+    "newer instance. Update or unpin Magic Context on this harness (or update",
+    "OpenCode/Pi) to the latest version, then restart. The fastest fix is:",
+    "",
+    "  npx @cortexkit/magic-context@latest doctor --force",
+    "",
+    "Your data is safe; nothing is disabled permanently."
+  ].join(`
+`);
+  try {
+    await sendStatusNotification2(client, sessionId, text, {});
+  } catch {
+    return;
+  }
+}
+async function sendStartupAnnouncement2(client, directory, version, features, footer, markSeen) {
+  if (!version || features.length === 0)
+    return;
+  const { sessionId } = getDesktopState(directory);
+  if (!sessionId) {
+    return;
+  }
+  const { isTuiConnected } = await importPluginModule(() => import("./rpc-notifications-3hed126v.js"));
+  if (isTuiConnected(sessionId) || isTuiConnected())
+    return;
+  const bullets = features.map((line) => `  • ${line}`).join(`
+`);
+  const sections = [`${ANNOUNCEMENT_MARKER} v${version}:`, "", bullets];
+  if (footer && footer.trim().length > 0) {
+    sections.push("", footer);
+  }
+  const text = sections.join(`
+`);
+  log(`[magic-context] sending startup announcement for v${version} to session ${sessionId}`);
+  try {
+    await sendStatusNotification2(client, sessionId, text, {
+      onDelivered: () => markSeen(version)
+    });
+  } catch (error) {
+    log(`[magic-context] announcement: failed to send: ${error instanceof Error ? error.message : String(error)}`);
+  }
+}
+
+export { __conflictWarningTest2, sendConflictWarning2, cleanupConflictWarnings2, sendSchemaFenceWarning2, sendStartupAnnouncement2 };

package/dist/index-sj29b3z2.js

@@ -0,0 +1,30 @@
+import {
+  log
+} from "./index-hybnrwq0.js";
+
+// src/shared/write-transaction-timing.ts
+var SLOW_WRITE_TRANSACTION_THRESHOLD_MS = 1000;
+function logSlowWriteTransaction(site, startedAt, thresholdMs = SLOW_WRITE_TRANSACTION_THRESHOLD_MS, completedAtMs = performance.now(), steps) {
+  try {
+    const durationMs = completedAtMs - startedAt;
+    if (durationMs < thresholdMs)
+      return;
+    const detail = steps ? Object.entries(steps).map(([name, ms]) => `${name}=${ms.toFixed(1)}ms`).join(" ") : "";
+    log(`[magic-context] slow write transaction: site=${site} held=${durationMs.toFixed(1)}ms${detail ? ` ${detail}` : ""}`);
+  } catch {}
+}
+
+class WriteTransactionSteps {
+  durations = {};
+  last = performance.now();
+  mark(name) {
+    const now = performance.now();
+    this.durations[name] = now - this.last;
+    this.last = now;
+  }
+  reset() {
+    this.last = performance.now();
+  }
+}
+
+export { logSlowWriteTransaction, WriteTransactionSteps };

package/dist/{index-q7yesyk9.js → index-yasgb8ej.js}

@@ -1,6 +1,8 @@
 import {
-  toolTemplateError
-} from "./index-remp7e2g.js";
+  toolTemplateError,
+  DEFAULT_PROTECTED_TOOLS,
+  mergeProtectedTools
+} from "./index-q4yp4b52.js";
 import {
   getHarness,
   getMagicContextStorageDir
@@ -11,10 +13,14 @@ import {
 } from "./index-hybnrwq0.js";
 import {
   estimateTokens
-} from "./index-gd5qx1j9.js";
+} from "./index-5eqk6z3s.js";
 import {
-  shouldEnforcePrivateStoragePermissions
-} from "./index-e44zzy84.js";
+  shouldEnforcePrivateStoragePermissions,
+  ensureStorageDirectorySync,
+  writeStorageFileAsync,
+  writeStorageFileHandleAsync,
+  createStorageFileHandleAsync
+} from "./index-1bc61ans.js";
 import {
   modelRefLookupOrder
 } from "./index-avwt563y.js";
@@ -92,8 +98,8 @@ function buildPrimaryLanguageDirective(language) {
 }
 
 // src/features/magic-context/memory/embedding-local.ts
-import { chmodSync, mkdirSync, readdirSync, statSync } from "node:fs";
-import { open, stat, unlink, writeFile } from "node:fs/promises";
+import { readdirSync, statSync } from "node:fs";
+import { stat, unlink } from "node:fs/promises";
 import { dirname, join } from "node:path";
 import { pathToFileURL } from "node:url";
 import { workerData } from "node:worker_threads";
@@ -5615,7 +5621,7 @@ var MagicContextConfigSchema = object({
   smart_notes: object({
     retina_handoff: boolean2().default(false).describe("When true, dreamer skips smart notes whose surface conditions compiled to retina provider configs at authoring time. Default false keeps both paths active until the retina consumer is deployed.")
   }).default({ retina_handoff: false }).describe("Smart-note ownership transition controls."),
-  cache_ttl: union([string(), object({ default: string() }).catchall(string())]).default("5m").describe(`How long Magic Context assumes the provider's cached prefix stays valid. This is MC's own deferral gate — it does not change the provider's actual cache lifetime. String (e.g. "5m", "1h", "30s") or per-model object ({ default: "5m", "provider/model": "1h", "provider/*": "never" }); keys resolve most-specific first (exact provider/model, bare model ID, shorter dash-prefixes, then the provider/* wildcard). Explicit per-model entries win; otherwise GPT-5.6 and later (including gpt-6*, through any provider prefix) use a built-in 30m lifetime before the object default or 5m fallback. An unset or global "5m" opts into built-in defaults; any other global string is an explicit policy and wins. Policy is frozen per session, including across restarts; a model switch resolves against that frozen policy. /ctx-status shows the effective value and source. OpenAI documents at least 30 minutes since the latest write or reuse: https://developers.openai.com/api/docs/guides/prompt-caching (Cache lifetime and Summary of model differences). Set to "never" to mean MC never assumes expiry (for lanes kept warm externally by a cache-keep tool) — disables the idle-TTL heuristic so MC never initiates a rebuild based on elapsed time. Provider-side extended TTL is a separate request-level concern (cache_control: { ttl } in the request body).`),
+  cache_ttl: union([string(), object({ default: string() }).catchall(string())]).default("5m").describe(`How long Magic Context assumes the provider's cached prefix stays valid. This is MC's own deferral gate — it does not change the provider's actual cache lifetime. String (e.g. "5m", "1h", "30s") or per-model object ({ default: "5m", "provider/model": "1h", "provider/*": "never" }); keys resolve most-specific first (exact provider/model, bare model ID, shorter dash-prefixes, then the provider/* wildcard, then default). User and project settings, including an explicit "5m" or object default, apply on the next pass. Only built-in defaults are frozen per session, including across restarts: when unset, GPT-5.6 and later (including gpt-6*, through any provider prefix) use 30m, other models use 5m. /ctx-status shows the effective TTL and whether it comes from your config or a frozen built-in default. Editing the TTL does not itself rewrite prompt bytes; a lowered TTL rebuilds only after normal idle expiry. OpenAI documents at least 30 minutes since the latest write or reuse: https://developers.openai.com/api/docs/guides/prompt-caching (Cache lifetime and Summary of model differences). Set to "never" to mean MC never assumes expiry (for lanes kept warm externally by a cache-keep tool) — disables the idle-TTL heuristic so MC never initiates a rebuild based on elapsed time. Provider-side extended TTL is a separate request-level concern (cache_control: { ttl } in the request body).`),
   prompt_surface: PromptSurfaceConfigSchema.default({ default: "full" }).describe("Prompt-surface presets: default is full; models use bare model IDs, provider/model, or provider/* routing keys. Guidance and tool-description overrides are user-level only. OpenCode 1.x, Pi, and OMP register tool descriptions once per process (they follow the default preset). OpenCode 2 rewrites the five ctx_* descriptions per request from the draft model."),
   output_reserve: union([
     number2().min(0),
@@ -5653,8 +5659,8 @@ var MagicContextConfigSchema = object({
     mmap_size_mb: number2().min(0).max(8192).default(0).describe("Memory-mapped I/O size in MiB (PRAGMA mmap_size). 0 disables mmap (SQLite default). Raising it can cut read overhead on large DBs at the cost of address space. (min 0, max 8192, default 0)")
   }).default({ cache_size_mb: 64, mmap_size_mb: 0 }).describe("SQLite connection tuning for Magic Context's own context.db. These are per-connection PRAGMAs applied at open; they do not change the schema or what is stored."),
   storage: object({
-    enforce_private_permissions: boolean2().default(true).describe("When true (default), Magic Context creates and re-tightens its storage directories to owner-only 0700 and storage files to owner-only 0600. Set false only for a deliberate trusted-group deployment whose operator manages directory, database, WAL/SHM, cache, and RPC file permissions externally; Magic Context then never chmods or supplies restrictive creation modes. USER-LEVEL ONLY — ignored in project config for security. On Windows, POSIX chmod modes are already meaningless, so this setting is a no-op.")
-  }).default({ enforce_private_permissions: true }).describe("Storage permission policy. The default keeps session content and memories owner-private. Disabling enforcement is for trusted shared-group storage managed externally; every group member able to read the storage can read all stored session content and memories."),
+    enforce_private_permissions: boolean2().default(true).describe("When true (default), Magic Context creates and re-tightens its TypeScript-mode storage directories to owner-only 0700 and storage files to owner-only 0600. Set false only for a deliberate trusted-group deployment whose operator manages those files externally; in TypeScript mode Magic Context then skips its own creation modes and recursive tightening. In Rust transform mode, ck-mc's store library always keeps the shared data directory owner-only 0700, regardless of this setting. USER-LEVEL ONLY — ignored in project config for security. On Windows, POSIX chmod modes are already meaningless, so this setting is a no-op.")
+  }).default({ enforce_private_permissions: true }).describe("Storage permission policy. The default keeps session content and memories owner-private. Disabling enforcement is for trusted shared-group storage managed externally; TypeScript mode follows that policy, but Rust transform mode always keeps its shared data directory owner-only because ck-mc's store library enforces it."),
   embedding: EmbeddingConfigSchema.default({
     provider: "local",
     model: DEFAULT_LOCAL_EMBEDDING_MODEL,
@@ -5678,7 +5684,8 @@ var MagicContextConfigSchema = object({
     overlay: boolean2().default(true).describe("Pi only: show the persistent todo overlay above the editor while tasks are active.")
   }).default({ enabled: false, overlay: true }).describe("Pi-only todowrite tool and overlay controls. Pi registers tools and widgets at extension boot, so changing this after /cd requires /reload or restart."),
   pi: PiConfigSchema.describe("Pi-only child-process extension controls. This setting is user-level only; project configuration cannot choose which extensions a user's subagent children load."),
-  smart_drops: boolean2().default(false).describe("Content-aware reclaim of provably-superseded tool output, layered on the existing execute-pass auto-drop. When on: superseded todowrite (keep newest 1), spent ctx_reduce (keep newest 3), and zero-value meta (bash_status, bash_kill, ctx_note read/dismiss) outputs are dropped; older edits to a file are compressed to a filePath-preserving marker while the newest edit per file stays full. Only acts on passes already busting the cache, so it never originates a cache bust. Honors the protected-tag reserve. Experimental: opt-in, default off until cache stability is proven; when off the wire is byte-identical to the positional-only reclaim. Requires a restart."),
+  smart_drops: unknown().optional().describe("Deprecated: ignored. Content-aware supersession reclaim is always on, only on passes already rebuilding the cache. Remove this key; it no longer does anything.").meta({ deprecated: true }),
+  protected_tools: record(string(), number2().int().nonnegative()).default({ ...DEFAULT_PROTECTED_TOOLS }).transform((map) => mergeProtectedTools(map)).describe("Keep each tool's newest N still-active results in every automatic drop lane (issue 621). User and project maps merge over defaults {todowrite: 1, ctx_reduce: 3}; 0 turns protection off. Names are case-insensitive and ignore leading mcp_. Holds even at 95% pressure, with no byte cap: large protected outputs can reach refusal sooner. Queued drops, from the agent or historian publication, are held until newer calls displace the result and a later cache-rebuilding pass applies them. The historian's summary is unaffected; the raw result leaves at the next fold. Frozen strips are unaffected. Changes and rotation never originate a bust; dropped results are never restored."),
   caveman_text_compression: object({
     enabled: boolean2().default(false).describe("Apply deterministic caveman-style text compression to old conversation text. Active for primary sessions when enabled; never for subagents. Compresses user/assistant text in oldest-first tiers: ultra (oldest 20%), full, lite, untouched (newest 40%)."),
     min_chars: number2().min(100).max(1e4).default(500).describe("Text parts shorter than this (characters) stay untouched. Min 100, max 10000. Default: 500.")
@@ -5713,6 +5720,7 @@ var MagicContextConfigSchema = object({
   };
 });
 var LIVE_RELOAD_CONFIG_PATHS = [
+  "cache_ttl",
   "mural.model",
   "toast_duration_ms",
   "historian.opencode.model",
@@ -8460,9 +8468,9 @@ async function acquireModelLoadLock(lockPath) {
   const waitStart = Date.now();
   while (true) {
     try {
-      const handle = await open(lockPath, "wx");
+      const handle = await createStorageFileHandleAsync(lockPath, "wx");
       try {
-        await handle.writeFile(`pid=${process.pid} started=${Date.now()}
+        await writeStorageFileHandleAsync(handle, `pid=${process.pid} started=${Date.now()}
 `);
       } catch {}
       await handle.close();
@@ -8498,7 +8506,7 @@ async function acquireModelLoadLock(lockPath) {
 function startLockHeartbeat(lockPath) {
   const HEARTBEAT_MS = Math.floor(STALE_LOCK_MS / 3);
   const timer = setInterval(() => {
-    writeFile(lockPath, `pid=${process.pid} alive=${Date.now()}
+    writeStorageFileAsync(lockPath, `pid=${process.pid} alive=${Date.now()}
 `).catch(() => {});
   }, HEARTBEAT_MS);
   timer.unref?.();
@@ -8861,16 +8869,7 @@ class LocalEmbeddingProvider {
         }
         const modelCacheDir = modelCacheDirForRuntime();
         try {
-          if (shouldEnforcePrivateStoragePermissions()) {
-            mkdirSync(modelCacheDir, { recursive: true, mode: 448 });
-            if (process.platform !== "win32") {
-              try {
-                chmodSync(modelCacheDir, 448);
-              } catch {}
-            }
-          } else {
-            mkdirSync(modelCacheDir, { recursive: true });
-          }
+          ensureStorageDirectorySync(modelCacheDir);
           env.cacheDir = modelCacheDir;
         } catch {
           log("[magic-context] could not create model cache dir, using library default");

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAiB,YAAY,EAAE,MAAM,qBAAqB,CAAC;AAyGvE,OAAO,EAAE,KAAK,EAAE,MAAM,aAAa,CAAC;AAohCpC,QAAA,MAAM,MAAM,EAAE,YAAY,GAAG;IAAE,KAAK,EAAE,OAAO,KAAK,CAAA;CAIjD,CAAC;AAEF,eAAe,MAAM,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAiB,YAAY,EAAE,MAAM,qBAAqB,CAAC;AA8GvE,OAAO,EAAE,KAAK,EAAE,MAAM,aAAa,CAAC;AA+kCpC,QAAA,MAAM,MAAM,EAAE,YAAY,GAAG;IAAE,KAAK,EAAE,OAAO,KAAK,CAAA;CAIjD,CAAC;AAEF,eAAe,MAAM,CAAC"}