memoryrouter-codex 1.6.1 → 1.8.0

package/runtime/project.cjs

@@ -1,50 +1,198 @@
 'use strict';
 
+// Project identity for Codex hooks and the local MCP fallback.
+//
+// Since 1.7.0 MemoryRouter is one vault per user: every Codex session, every
+// Claude Code session, every repository, and every MemoryRouter surface (the
+// hosted MCP, ChatGPT, Claude) read and write the same core vault. The hooks
+// therefore send NO session_id (the API treats session_id as a hard vault
+// partition, so any session_id would wall memories off again).
+//
+// The repository identity below is still computed, byte-for-byte the same as
+// Claude Code (memoryrouter-claude lib/project.js): the same overrides, the
+// same git remote normalization, the same `ccp_` SHA-256 prefix. It is only
+// metadata now: it is stamped on Codex captures and used locally to label
+// which recalled memories came from the current repository.
+//
+// History: 1.1.0 to 1.6.1 sent `mrcodex:<proj>:<codex session uuid>` (one pile
+// per Codex session, so a new session recalled nothing), and memoryrouter-claude
+// up to 2.6.1 used the per-repo `ccp_` id as a partition (one pile per repo).
+// Both kinds of pile were merged into each user's core vault server-side when
+// 1.7.0 shipped, so nothing saved earlier is lost.
+//
+// Only the opaque hash leaves the machine; local paths and remotes stay local.
+// Keep this file self-contained: it is copied into the Codex runtime
+// directory and must not require anything outside runtime/.
+
+const fs = require('fs');
 const path = require('path');
 const crypto = require('crypto');
 const { execFileSync } = require('child_process');
 
-function git(cwd, args) {
+const PROJECT_CONFIG = '.memoryrouter.json';
+
+function runGit(args, cwd) {
   try {
-    return execFileSync('git', ['-C', cwd, ...args], {
+    return execFileSync('git', args, {
+      cwd,
       encoding: 'utf8',
-      stdio: ['ignore', 'pipe', 'ignore'],
       timeout: 2000,
+      stdio: ['ignore', 'pipe', 'ignore'],
     }).trim();
-  } catch { return ''; }
+  } catch {
+    return '';
+  }
 }
 
+// Back-compat helper used by older tests and callers: git -C <cwd> <args>.
+function git(cwd, args) {
+  return runGit(args, cwd);
+}
+
+function realpathSafe(value) {
+  const resolved = path.resolve(value || process.cwd());
+  try {
+    return fs.realpathSync.native(resolved);
+  } catch {
+    return resolved;
+  }
+}
+
+// Identical to memoryrouter-claude normalizeRemote(). Do not "improve" one
+// side without the other: any difference splits the shared project memory.
 function normalizeRemote(remote) {
   let value = String(remote || '').trim();
-  value = value.replace(/^([^@/]+)@([^:]+):/, 'ssh://$2/');
+  if (!value) return '';
+
+  // SCP-like git syntax: git@github.com:Org/Repo.git
+  const scp = value.match(/^(?:[^@/]+@)?([^:/]+):(.+)$/);
+  if (scp && !/^[a-z][a-z0-9+.-]*:\/\//i.test(value)) {
+    value = `ssh://${scp[1]}/${scp[2]}`;
+  }
+
   try {
     const url = new URL(value);
+    const host = url.hostname.toLowerCase();
+    const port = url.port && !((url.protocol === 'https:' && url.port === '443') || (url.protocol === 'ssh:' && url.port === '22'))
+      ? `:${url.port}`
+      : '';
+    const pathname = decodeURIComponent(url.pathname).replace(/^\/+|\/+$/g, '').replace(/\.git$/i, '');
+    return host && pathname ? `${host}${port}/${pathname}`.toLowerCase() : '';
+  } catch {
+    return value
+      .replace(/^[^@/]+@/, '')
+      .replace(/^[a-z][a-z0-9+.-]*:\/\//i, '')
+      .replace(/[?#].*$/, '')
+      .replace(/^\/+|\/+$/g, '')
+      .replace(/\.git$/i, '')
+      .toLowerCase();
+  }
+}
+
+function readProjectConfig(root) {
+  try {
+    const parsed = JSON.parse(fs.readFileSync(path.join(root, PROJECT_CONFIG), 'utf8'));
+    return parsed && typeof parsed === 'object' && !Array.isArray(parsed) ? parsed : {};
+  } catch {
+    return {};
+  }
+}
+
+function hashIdentity(canonical) {
+  return crypto.createHash('sha256').update(canonical).digest('hex');
+}
+
+// Pre-1.7 Codex-only handle. Kept so envelopes written by older releases are
+// still recognised as belonging to this repository.
+function legacyHandle(root, rawRemote, commonDirRaw) {
+  let remote = String(rawRemote || '').trim();
+  remote = remote.replace(/^([^@/]+)@([^:]+):/, 'ssh://$2/');
+  try {
+    const url = new URL(remote);
     url.username = '';
     url.password = '';
-    value = `${url.protocol}//${url.host}${url.pathname}`;
+    remote = `${url.protocol}//${url.host}${url.pathname}`;
   } catch { /* local/file-like remote */ }
-  return value.replace(/\\/g, '/').replace(/\.git\/?$/i, '').replace(/\/+$/, '').toLowerCase();
-}
-
-function resolveProject(cwd = process.cwd()) {
-  const absoluteCwd = path.resolve(cwd);
-  const root = git(absoluteCwd, ['rev-parse', '--show-toplevel']) || absoluteCwd;
-  const remote = normalizeRemote(git(root, ['remote', 'get-url', 'origin']));
-  const commonDir = git(root, ['rev-parse', '--git-common-dir']);
+  remote = remote.replace(/\\/g, '/').replace(/\.git\/?$/i, '').replace(/\/+$/, '').toLowerCase();
   const canonical = remote
     ? `remote:${remote}`
-    : commonDir
-      ? `git:${path.resolve(root, commonDir)}`
+    : commonDirRaw
+      ? `git:${path.resolve(root, commonDirRaw)}`
       : `path:${root}`;
-  const digest = crypto.createHash('sha256')
-    .update(`memoryrouter-codex-project-v1\0${canonical}`)
-    .digest('hex');
+  const digest = crypto.createHash('sha256').update(`memoryrouter-codex-project-v1\0${canonical}`).digest('hex');
+  return `proj_${digest.slice(0, 20)}`;
+}
+
+function resolveProject(cwd = process.cwd(), options = {}) {
+  const env = options.env || process.env;
+  const config = options.config || {};
+  const requestedRoot = realpathSafe(cwd || process.cwd());
+  const gitRootRaw = runGit(['rev-parse', '--show-toplevel'], requestedRoot);
+  const root = realpathSafe(gitRootRaw || requestedRoot);
+  const projectConfig = readProjectConfig(root);
+  const ignored = fs.existsSync(path.join(root, '.memoryrouterignore')) || projectConfig.enabled === false;
+
+  const explicit = env.MEMORYROUTER_PROJECT_ID
+    || projectConfig.projectId
+    || projectConfig.project
+    || config.projectId
+    || config.project;
+
+  const originUrl = runGit(['config', '--get', 'remote.origin.url'], root);
+  const anyRemoteUrl = originUrl || runGit(['config', '--get-regexp', '^remote\\..*\\.url$'], root).split(/\s+/).pop();
+  const remote = normalizeRemote(anyRemoteUrl);
+
+  const commonDirRaw = gitRootRaw
+    ? runGit(['rev-parse', '--path-format=absolute', '--git-common-dir'], root)
+    : '';
+  const commonDir = commonDirRaw ? realpathSafe(commonDirRaw) : '';
+
+  let source;
+  let canonical;
+  if (explicit && String(explicit).trim()) {
+    source = 'explicit';
+    canonical = `explicit:${String(explicit).trim().toLowerCase()}`;
+  } else if (remote) {
+    source = 'git-remote';
+    canonical = `git:${remote}`;
+  } else if (commonDir) {
+    source = 'git-common-dir';
+    canonical = `git-local:${commonDir}`;
+  } else {
+    source = 'directory';
+    canonical = `dir:${root}`;
+  }
+
+  const id = `ccp_${hashIdentity(canonical).slice(0, 24)}`;
+
   return {
-    handle: `proj_${digest.slice(0, 20)}`,
+    handle: id,
+    id,
     root,
-    source: remote ? 'git-remote' : commonDir ? 'git-common-dir' : 'path',
-    portable: Boolean(remote),
+    source,
+    portable: source === 'git-remote' || source === 'explicit',
+    label: path.basename(root) || 'workspace',
+    ignored,
+    legacyHandle: legacyHandle(gitRootRaw || path.resolve(cwd || process.cwd()), originUrl, gitRootRaw ? runGit(['rev-parse', '--git-common-dir'], root) : ''),
   };
 }
 
-module.exports = { git, normalizeRemote, resolveProject };
+// The MemoryRouter session_id (vault partition) the hooks use. Always
+// undefined since 1.7.0: one vault per user, no per-session or per-repo walls.
+// Kept as a function so callers and tests have one place that states the rule.
+function sessionIdFor() {
+  return undefined;
+}
+
+module.exports = {
+  PROJECT_CONFIG,
+  git,
+  runGit,
+  realpathSafe,
+  normalizeRemote,
+  readProjectConfig,
+  hashIdentity,
+  legacyHandle,
+  resolveProject,
+  sessionIdFor,
+};

package/runtime/vault-binding.cjs

@@ -0,0 +1,51 @@
+'use strict';
+// One user = one vault. The vault a user selects when connecting MemoryRouter
+// over OAuth (the MCP login used by Claude Code, Codex, ChatGPT, Claude) must
+// be the same vault the automatic hooks write to with the Memory Key. The auth
+// server compares the two: GET /v1/vault-binding with the Memory Key as Bearer.
+// Kept self-contained (copied into the Codex runtime directory).
+// The response never contains a key, only opaque vault refs and names.
+
+const AUTH_BASE = 'https://auth.memoryrouter.ai';
+
+function authBase(env = process.env) {
+  return String(env.MEMORYROUTER_AUTH_BASE || AUTH_BASE).replace(/\/+$/, '');
+}
+
+async function checkVaultBinding(key, options = {}) {
+  const env = options.env || process.env;
+  const controller = new AbortController();
+  const timer = setTimeout(() => controller.abort(), options.timeoutMs || 6000);
+  try {
+    const res = await fetch(`${authBase(env)}/v1/vault-binding`, {
+      headers: { Authorization: `Bearer ${key}`, Accept: 'application/json' },
+      signal: controller.signal,
+    });
+    let data = null;
+    try { data = await res.json(); } catch { /* not json */ }
+    if (!res.ok || !data || typeof data.status !== 'string') {
+      return { status: 'unknown', httpStatus: res.status, message: `vault check unavailable (HTTP ${res.status})` };
+    }
+    return data;
+  } catch (err) {
+    return { status: 'unknown', message: `vault check unavailable (${err && err.name === 'AbortError' ? 'timeout' : (err && err.message) || 'network error'})` };
+  } finally {
+    clearTimeout(timer);
+  }
+}
+
+function vaultLabel(binding) {
+  const vault = binding && binding.vault;
+  if (!vault) return 'this vault';
+  return vault.name ? `"${vault.name}" (${vault.ref})` : vault.ref;
+}
+
+class VaultMismatchError extends Error {
+  constructor(binding) {
+    super(`${binding.message || 'This Memory Key is not the vault you selected in OAuth.'}\n  Nothing was installed. Run init again with the Memory Key of the vault you selected (app.memoryrouter.ai), or reconnect MemoryRouter and select ${vaultLabel(binding)}.`);
+    this.name = 'VaultMismatchError';
+    this.binding = binding;
+  }
+}
+
+module.exports = { AUTH_BASE, authBase, checkVaultBinding, vaultLabel, VaultMismatchError };