memorix 1.2.9 → 1.2.10

package/CHANGELOG.md

@@ -2,6 +2,15 @@
 
 All notable changes to this project will be documented in this file.
 
+## [1.2.10] - 2026-07-28
+
+### Added
+- **Official MCP Registry publication path** -- Ships the checked `server.json` manifest and a GitHub OIDC publication step that runs after npm succeeds. This release is the first package version eligible for official Registry registration.
+
+### Fixed
+- **Codex plugin ownership** -- `memorix setup --agent codex --global` now uses Codex's personal marketplace plugin path and never creates project-local `.codex` configuration as a fallback. Custom user MCP configuration stays untouched; legacy Memorix files are migrated only after Codex confirms the plugin is enabled.
+- **Glama-compatible Docker build** -- Docker now installs every workspace dependency set before compiling. CI builds and starts the HTTP control-plane image, so a future container regression is caught on the pull request instead of by an external registry scan.
+
 ## [1.2.9] - 2026-07-28
 
 ### Fixed

package/README.md

@@ -218,7 +218,7 @@ memorix setup --agent claude --global   # or codex, copilot, cursor, pi, gemini-
 
 Legacy `memorix.yml`, `.env`, and `~/.memorix/config.json` are still read for compatibility, but new setup flows use TOML.
 
-If you want repo-local guidance or hooks for a specific repository, run the same setup command from inside that repo without `--global`.
+If you want repo-local guidance or hooks for a specific repository, run the same setup command from inside that repo without `--global`. Codex is the exception: its supported path is the user-level plugin install, so Memorix leaves project `.codex` configuration alone.
 
 <h2 id="quick-start"><picture><source media="(prefers-color-scheme: dark)" srcset="assets/tags/light/section-quick-start.svg"><img src="assets/tags/section-quick-start.svg" alt="Quick Start" height="32" /></picture></h2>
 
@@ -246,7 +246,7 @@ memorix setup --agent omp --global
 What it installs depends on the target agent, but the goal is the same: make Memorix available wherever you open that agent without asking you to wire every repo by hand.
 
 - Claude Code: installs the Memorix plugin package, adds `CLAUDE.md` guidance, and enables hook capture when you do not pass `--noHooks`.
-- Codex: installs the Memorix plugin package with stdio MCP, skills, and lifecycle hooks, then adds `AGENTS.md` guidance. When Codex asks, review the plugin hook definition once with `/hooks`; `--noHooks` skips automatic capture.
+- Codex: installs one user-level Memorix plugin with bundled stdio MCP, skills, and lifecycle hooks. It does not write project-local `.codex` config or change your model, approval, or sandbox settings. When Codex asks, review the plugin hook definition once with `/hooks`; `--noHooks` skips automatic capture.
 - GitHub Copilot CLI: installs the Copilot plugin package and official Memorix skills.
 - Pi: installs the user-level Pi package and official skills.
 - Cursor: writes Cursor MCP/rules/config entries in the chosen scope.

package/dist/cli/index.js

@@ -3212,7 +3212,7 @@ ${import_picocolors.default.gray(m3)}  ${s2}
 
 // src/cli/version.ts
 function getCliVersion() {
-  return true ? "1.2.9" : pkg.version;
+  return true ? "1.2.10" : pkg.version;
 }
 var init_version = __esm({
   "src/cli/version.ts"() {
@@ -35531,6 +35531,8 @@ __export(setup_exports, {
   installOpenClawBundlePackage: () => installOpenClawBundlePackage,
   installPiPackage: () => installPiPackage,
   installPluginPackage: () => installPluginPackage,
+  migrateLegacyCodexIntegration: () => migrateLegacyCodexIntegration,
+  parseCodexPluginState: () => parseCodexPluginState,
   removeLegacyCodexMemorixMcpConfig: () => removeLegacyCodexMemorixMcpConfig,
   tryInstallCodexPlugin: () => tryInstallCodexPlugin
 });
@@ -35779,6 +35781,21 @@ function mergeTomlMcpConfig(existingContent, generatedContent) {
   return `${parts.join("\n\n")}
 `;
 }
+function getTomlSection(content, section) {
+  const lines = content.split(/\r?\n/);
+  const header = `[${section}]`;
+  const start = lines.findIndex((line) => line.trim() === header);
+  if (start < 0) return null;
+  let end = lines.length;
+  for (let index = start + 1; index < lines.length; index += 1) {
+    const trimmed = lines[index].trim();
+    if (trimmed.startsWith("[") && trimmed.endsWith("]")) {
+      end = index;
+      break;
+    }
+  }
+  return lines.slice(start + 1, end).join("\n");
+}
 function isLegacyCodexMemorixNodeServer(server) {
   if (server.name !== "memorix" || server.command.trim().toLowerCase() !== "node") return false;
   const startsMemorixStdio = server.args.some((arg) => arg.trim().toLowerCase() === "serve");
@@ -35788,6 +35805,19 @@ function isLegacyCodexMemorixNodeServer(server) {
   });
   return startsMemorixStdio && sourceEntry;
 }
+function isOwnedLegacyCodexMcp(content) {
+  const section = getTomlSection(content, "mcp_servers.memorix");
+  if (section === null || getTomlSection(content, "mcp_servers.memorix.env") !== null) return false;
+  const allowedKeys = /* @__PURE__ */ new Set(["command", "args", "type", "startup_timeout_sec", "tool_timeout_sec", "enabled"]);
+  for (const rawLine of section.split(/\r?\n/)) {
+    const line = rawLine.trim();
+    if (!line || line.startsWith("#")) continue;
+    const key = line.match(/^([A-Za-z0-9_]+)\s*=/)?.[1];
+    if (!key || !allowedKeys.has(key)) return false;
+  }
+  const server = new CodexMCPAdapter().parse(content).find((entry) => entry.name === "memorix");
+  return Boolean(server && isLegacyCodexMemorixNodeServer(server));
+}
 async function removeLegacyCodexMemorixMcpConfig(configPath = path23.join(homedir24(), ".codex", "config.toml")) {
   let existingContent;
   try {
@@ -35795,15 +35825,82 @@ async function removeLegacyCodexMemorixMcpConfig(configPath = path23.join(homedi
   } catch {
     return { configPath, removed: false };
   }
-  const adapter = new CodexMCPAdapter();
-  const legacyServer = adapter.parse(existingContent).find(isLegacyCodexMemorixNodeServer);
-  if (!legacyServer) return { configPath, removed: false };
+  if (!isOwnedLegacyCodexMcp(existingContent)) return { configPath, removed: false };
   let nextContent = removeTomlSection(existingContent, "mcp_servers.memorix.env");
   nextContent = removeTomlSection(nextContent, "mcp_servers.memorix");
   await writeFile5(configPath, nextContent ? `${nextContent}
 ` : "", "utf-8");
   return { configPath, removed: true };
 }
+function collectHookCommands(value, commands) {
+  if (Array.isArray(value)) {
+    for (const item of value) collectHookCommands(item, commands);
+    return;
+  }
+  if (!value || typeof value !== "object") return;
+  for (const [key, child] of Object.entries(value)) {
+    if ((key === "command" || key === "commandWindows") && typeof child === "string") {
+      commands.push(child);
+    } else {
+      collectHookCommands(child, commands);
+    }
+  }
+}
+function isOwnedLegacyCodexHooks(content) {
+  try {
+    const parsed = JSON.parse(content);
+    if (!parsed.hooks || typeof parsed.hooks !== "object") return false;
+    const commands = [];
+    collectHookCommands(parsed.hooks, commands);
+    return commands.length > 0 && commands.every((command) => /^memorix(?:\.cmd)?\s+hook(?:\s|$)/i.test(command.trim()));
+  } catch {
+    return false;
+  }
+}
+async function removeOwnedLegacyCodexPluginFolder(homeDir) {
+  const canonicalPath = path23.join(homeDir, "plugins", "memorix");
+  const legacyPath = path23.join(homeDir, ".codex", "plugins", "memorix");
+  if (!existsSync12(legacyPath)) return "missing";
+  if (!existsSync12(canonicalPath)) return "preserved";
+  try {
+    const manifest = JSON.parse(await readFile5(path23.join(legacyPath, ".codex-plugin", "plugin.json"), "utf-8"));
+    const repository = String(manifest.repository ?? "");
+    if (manifest.name !== "memorix" || !repository.includes("github.com/AVIDS2/memorix")) return "preserved";
+    await rm(legacyPath, { recursive: true, force: true });
+    return "removed";
+  } catch {
+    return "preserved";
+  }
+}
+async function migrateLegacyCodexIntegration(options2 = {}) {
+  const homeDir = options2.homeDir ?? homedir24();
+  const projectRoot = options2.projectRoot ?? process.cwd();
+  const configPath = path23.join(homeDir, ".codex", "config.toml");
+  let mcp = "missing";
+  try {
+    const content = await readFile5(configPath, "utf-8");
+    if (getTomlSection(content, "mcp_servers.memorix") !== null) {
+      mcp = (await removeLegacyCodexMemorixMcpConfig(configPath)).removed ? "removed" : "preserved";
+    }
+  } catch {
+    mcp = "missing";
+  }
+  const hooksPath = path23.join(projectRoot, ".codex", "hooks.json");
+  let projectHooks = "missing";
+  try {
+    const content = await readFile5(hooksPath, "utf-8");
+    if (isOwnedLegacyCodexHooks(content)) {
+      await rm(hooksPath, { force: true });
+      projectHooks = "removed";
+    } else {
+      projectHooks = "preserved";
+    }
+  } catch {
+    projectHooks = "missing";
+  }
+  const pluginFolder = await removeOwnedLegacyCodexPluginFolder(homeDir);
+  return { mcp, projectHooks, pluginFolder };
+}
 function mergeYamlMcpConfig(existingContent, generatedContent) {
   let existing = {};
   try {
@@ -35926,7 +36023,7 @@ async function installPluginPackage(options2) {
     throw new Error(`Plugin package template not found: ${source}`);
   }
   if (options2.agent === "codex") {
-    const pluginPath2 = path23.join(home, ".codex", "plugins", "memorix");
+    const pluginPath2 = path23.join(home, "plugins", "memorix");
     const marketplacePath2 = path23.join(home, ".agents", "plugins", "marketplace.json");
     await copyDir(source, pluginPath2);
     await stampCodexPluginVersion(pluginPath2);
@@ -36110,19 +36207,56 @@ ${install.stdout || ""}`.toLowerCase();
     message: installDetail ? `claude: marketplace registered, but automatic plugin install did not finish: ${installDetail}` : "claude: marketplace registered. Run `claude plugin install memorix@memorix-local`."
   };
 }
+function parseCodexPluginState(content) {
+  try {
+    const start = content.indexOf("{");
+    const end = content.lastIndexOf("}");
+    if (start < 0 || end < start) return "unknown";
+    const parsed = JSON.parse(content.slice(start, end + 1));
+    if (!Array.isArray(parsed.installed)) return "unknown";
+    const plugin = parsed.installed.find((entry) => Boolean(entry) && typeof entry === "object" && entry.pluginId === "memorix@personal");
+    if (!plugin || plugin.installed !== true) return "missing";
+    return plugin.enabled === true ? "ready" : "disabled";
+  } catch {
+    return "unknown";
+  }
+}
+function getCodexPluginState() {
+  const result = spawnSync("codex", ["plugin", "list", "--json"], {
+    encoding: "utf-8",
+    stdio: "pipe",
+    shell: process.platform === "win32"
+  });
+  if (result.status !== 0) return "unknown";
+  return parseCodexPluginState(result.stdout || "");
+}
 function tryInstallCodexPlugin() {
   const result = spawnSync("codex", ["plugin", "add", "memorix@personal", "--json"], {
     encoding: "utf-8",
     stdio: "pipe",
     shell: process.platform === "win32"
   });
-  if (result.status === 0) {
-    return { ok: true, message: "codex: plugin installed from Personal marketplace" };
-  }
   const output = `${result.stderr || ""}
 ${result.stdout || ""}`.toLowerCase();
-  if (output.includes("already")) {
-    return { ok: true, message: "codex: plugin already installed from Personal marketplace" };
+  const addFinished = result.status === 0 || output.includes("already");
+  if (addFinished) {
+    const pluginState = getCodexPluginState();
+    if (pluginState === "ready") {
+      return {
+        ok: true,
+        message: result.status === 0 ? "codex: plugin installed and enabled from Personal marketplace" : "codex: plugin already installed and enabled from Personal marketplace"
+      };
+    }
+    if (pluginState === "disabled") {
+      return {
+        ok: false,
+        message: "codex: Memorix plugin is installed but disabled. Enable it in Codex Plugins before any legacy MCP or project hooks are removed."
+      };
+    }
+    return {
+      ok: false,
+      message: "codex: plugin registration finished, but Codex did not confirm an enabled Memorix plugin. Legacy MCP and project hooks were kept unchanged."
+    };
   }
   const detail = (result.stderr || result.stdout || result.error?.message || "").trim();
   return {
@@ -36268,14 +36402,14 @@ async function installAgentSetup(agent, plan, global2) {
   const hasAntigravityPlugin = plan.actions.includes("antigravity-plugin") && agent === "antigravity";
   const hasHermesPlugin = plan.actions.includes("hermes-plugin") && agent === "hermes";
   const hasOmpPackage = plan.actions.includes("omp-package") && agent === "omp";
-  const wantsMcpConfig = plan.mcp !== "none" && agent !== "pi";
+  const wantsMcpConfig = plan.mcp !== "none" && agent !== "pi" && !(agent === "codex" && !global2);
   if (PLUGIN_PACKAGE_AGENTS.has(agent) && plan.includePlugin && !global2) {
     v3.info(`${agent}: project setup leaves user-level plugins untouched. Run \`memorix setup --agent ${agent} --global\` to install its plugin, skills, and lifecycle hooks.`);
   }
   if (hasPluginPackage) {
     const result = await installPluginPackage({
       agent,
-      includeHooks: plan.actions.includes("hooks")
+      includeHooks: plan.includeHooks
     });
     v3.success(`${agent}: plugin package -> ${result.pluginPath}`);
     if (result.marketplacePath) {
@@ -36283,17 +36417,16 @@ async function installAgentSetup(agent, plan, global2) {
     }
     if (agent === "codex") {
       const install = tryInstallCodexPlugin();
-      if (install.ok) v3.success(install.message);
-      else v3.warn(install.message);
       if (install.ok) {
-        try {
-          const migration = await removeLegacyCodexMemorixMcpConfig();
-          if (migration.removed) {
-            v3.info(`codex: removed legacy source-path MCP config from ${migration.configPath}`);
-          }
-        } catch {
-          v3.warn("codex: plugin installed, but the legacy MCP config could not be checked");
-        }
+        v3.success(install.message);
+        const migration = await migrateLegacyCodexIntegration({ projectRoot: process.cwd() });
+        if (migration.mcp === "removed") v3.info("codex: removed the legacy source-path MCP block; the enabled plugin now owns MCP.");
+        if (migration.mcp === "preserved") v3.warn("codex: kept a customized legacy Memorix MCP block; remove it manually only after confirming plugin MCP works.");
+        if (migration.projectHooks === "removed") v3.info("codex: removed a legacy project-local Memorix hooks.json; plugin hooks now own lifecycle capture.");
+        if (migration.projectHooks === "preserved") v3.warn("codex: kept a project .codex/hooks.json because it contains non-Memorix commands.");
+        if (migration.pluginFolder === "removed") v3.info("codex: removed the migrated legacy plugin folder under ~/.codex/plugins.");
+      } else {
+        v3.warn(install.message);
       }
     } else if (agent === "claude" && result.marketplaceRoot) {
       const install = tryInstallClaudePlugin(result.marketplaceRoot);
@@ -36371,6 +36504,8 @@ async function installAgentSetup(agent, plan, global2) {
       const result = await installMcpConfig({ agent, projectRoot: targetRoot, global: global2, mcp });
       v3.success(`${agent}: MCP config -> ${result.configPath}`);
     }
+  } else if (agent === "codex" && !global2 && plan.mcp !== "none") {
+    v3.info("codex: project-local .codex config is intentionally untouched. Run `memorix setup --agent codex --global` to install the user-level plugin.");
   }
   if (hasPluginPackage) {
     if (plan.actions.includes("project-guidance") && (agent === "claude" || agent === "codex")) {
@@ -36463,7 +36598,7 @@ var init_setup = __esm({
     ANTIGRAVITY_PLUGIN_AGENTS = /* @__PURE__ */ new Set(["antigravity"]);
     HERMES_PLUGIN_AGENTS = /* @__PURE__ */ new Set(["hermes"]);
     OMP_PACKAGE_AGENTS = /* @__PURE__ */ new Set(["omp"]);
-    PACKAGE_OWNED_INTEGRATION_AGENTS = /* @__PURE__ */ new Set(["antigravity", "openclaw", "hermes", "omp"]);
+    PACKAGE_OWNED_INTEGRATION_AGENTS = /* @__PURE__ */ new Set(["codex", "antigravity", "openclaw", "hermes", "omp"]);
     SUPPORTED_SETUP_AGENTS = [
       "claude",
       "codex",
@@ -71498,7 +71633,7 @@ The path should point to a directory containing a .git folder.`
   };
   const server = existingServer ?? new McpServer({
     name: "memorix",
-    version: true ? "1.2.9" : "1.0.1"
+    version: true ? "1.2.10" : "1.0.1"
   });
   const originalRegisterTool = server.registerTool.bind(server);
   server.registerTool = ((name, ...args) => {
@@ -82633,7 +82768,7 @@ function asRecordArray(value) {
   return Array.isArray(value) ? value.map(asRecord2).filter((entry) => entry !== null) : [];
 }
 function codexPluginPath() {
-  return `${homedir32()}/.codex/plugins/${CODEX_PLUGIN_NAME}`;
+  return `${homedir32()}/plugins/${CODEX_PLUGIN_NAME}`;
 }
 function codexPluginMcpPath() {
   return `${codexPluginPath()}/.mcp.json`;
@@ -82652,7 +82787,10 @@ function isMemorixCodexPlugin(value) {
 }
 function parseCodexPluginList(output) {
   try {
-    const parsed = asRecord2(JSON.parse(output));
+    const start = output.indexOf("{");
+    const end = output.lastIndexOf("}");
+    if (start < 0 || end < start) return null;
+    const parsed = asRecord2(JSON.parse(output.slice(start, end + 1)));
     if (!parsed) return null;
     const entries = [...asRecordArray(parsed.installed), ...asRecordArray(parsed.available)];
     const plugin = entries.find(isMemorixCodexPlugin);
@@ -82795,7 +82933,7 @@ async function inspectCodexMarketplace() {
   }
   const source = asRecord2(entry.source);
   const sourcePath = typeof source?.path === "string" ? source.path : "";
-  const issues = source?.source === "local" && normalizeMarketplacePath(sourcePath) === ".codex/plugins/memorix" ? [] : ["codex-marketplace-entry-stale"];
+  const issues = source?.source === "local" && normalizeMarketplacePath(sourcePath) === "plugins/memorix" ? [] : ["codex-marketplace-entry-stale"];
   return {
     scope: "global",
     kind: "marketplace",
@@ -83362,9 +83500,11 @@ async function repairAgentIntegrations(options2 = {}) {
         } else {
           if (!options2.dry) {
             await installPluginPackage({ agent: "codex" });
-            if (needsInstall) {
-              const install = tryInstallCodexPlugin();
-              if (!install.ok) skipped.push("codex:plugin:global:install-pending");
+            const install = tryInstallCodexPlugin();
+            if (install.ok) {
+              await migrateLegacyCodexIntegration({ projectRoot });
+            } else {
+              skipped.push("codex:plugin:global:install-pending");
             }
           }
           changed.push("codex:plugin:global");