codex-overleaf-link 2.4.1 → 2.5.1

package/native-host/src/codexHome.js

@@ -2,6 +2,9 @@
 
 const fs = require('node:fs');
 const path = require('node:path');
+const { createHash } = require('node:crypto');
+const { filterTomlRootKeys } = require('./tomlStatements');
+const { copyInheritedAuth, removeMissingInheritedAuth } = require('./codexInheritedAuth');
 const {
   getHomeDir,
   getNativeHostPlatform
@@ -86,9 +89,11 @@ function preparePluginCodexHome(env = process.env, options = {}) {
   const linked = [];
   const skippedLinks = [];
   for (const fileName of COPIED_USER_CODEX_FILES) {
+    if (fileName === 'config.toml' && options.skipCopiedUserConfig === true) continue;
     const source = path.join(userHome, fileName);
     const target = path.join(pluginHome, fileName);
     if (!isRegularFile(source)) {
+      if (fileName === 'auth.json') removeMissingInheritedAuth(source, target);
       continue;
     }
     fs.mkdirSync(path.dirname(target), { recursive: true });
@@ -166,90 +171,36 @@ function ensureDefaultCodexOverleafSkills({ env = process.env } = {}) {
 }
 
 function copyUserCodexFile(source, target, fileName, options = {}) {
+  if (fileName === 'auth.json') {
+    copyInheritedAuth(source, target);
+    return;
+  }
   if (fileName !== 'config.toml') {
     fs.copyFileSync(source, target);
     return;
   }
-  let content = stripPersonalizationFromCodexConfig(fs.readFileSync(source, 'utf8'));
+  const content = sanitizeCopiedCodexConfig(fs.readFileSync(source, 'utf8'), options);
+  fs.writeFileSync(target, content, 'utf8');
+}
+
+function sanitizeCopiedCodexConfig(content, options = {}) {
+  content = stripPersonalizationFromCodexConfig(content);
   if (options.loadCodexLocalSkills === false) {
     content = sanitizeCodexConfigForLocalSkillIsolation(content);
   }
-  fs.writeFileSync(target, content, 'utf8');
+  return content;
 }
 
-// Removes the top-level `personality` key (Codex's built-in "personality"
-// feature) so the plugin Codex home never inherits the user's global
-// personalization. Only the top-level key is removed — a `personality` key
-// inside a [section] is a different key and is preserved. Handles single-line
-// values and both multi-line string forms (""" basic and ''' literal). All
-// other lines pass through unchanged, aside from line endings being normalized to LF.
+// Remove the complete top-level personality assignment. Statement boundaries
+// keep keys/table headers inside multiline strings from becoming filter input.
+// Key paths are decoded before filtering, including quoted/dotted spellings.
+// Table-scoped fields remain distinct. Unselected source text is preserved.
 function stripPersonalizationFromCodexConfig(content) {
-  const lines = String(content || '').split(/\r?\n/);
-  const output = [];
-  let beforeFirstSection = true;
-  let closingDelimiter = '';
-
-  for (const line of lines) {
-    if (closingDelimiter) {
-      if (line.includes(closingDelimiter)) {
-        closingDelimiter = '';
-      }
-      // Drop every line of the multi-line value, including the one that closes it.
-      continue;
-    }
-    if (parseTomlSectionName(line)) {
-      beforeFirstSection = false;
-      output.push(line);
-      continue;
-    }
-    if (beforeFirstSection) {
-      const match = line.match(/^\s*personality\s*=\s*(.*)$/);
-      if (match) {
-        const value = match[1];
-        const opener = value.startsWith('"""') ? '"""'
-          : value.startsWith("'''") ? "'''"
-            : '';
-        if (opener && value.indexOf(opener, opener.length) === -1) {
-          closingDelimiter = opener;
-        }
-        continue;
-      }
-    }
-    output.push(line);
-  }
-
-  return output.join('\n');
+  return filterTomlRootKeys(content, ['personality']);
 }
 
 function sanitizeCodexConfigForLocalSkillIsolation(content) {
-  const output = [];
-  let skippedSection = false;
-
-  for (const line of String(content || '').split(/\r?\n/)) {
-    const sectionName = parseTomlSectionName(line);
-    if (sectionName) {
-      skippedSection = isLocalSkillConfigSection(sectionName);
-      if (!skippedSection) {
-        output.push(line);
-      }
-      continue;
-    }
-    if (skippedSection || /^\s*notify\s*=/.test(line)) {
-      continue;
-    }
-    output.push(line);
-  }
-
-  return `${output.join('\n').replace(/\n{3,}/g, '\n\n').trim()}\n`;
-}
-
-function parseTomlSectionName(line) {
-  const match = String(line || '').match(/^\s*\[{1,2}\s*([^\]]+?)\s*\]{1,2}\s*(?:#.*)?$/);
-  return match ? match[1].trim() : '';
-}
-
-function isLocalSkillConfigSection(sectionName) {
-  return LOCAL_SKILL_CONFIG_SECTIONS.some(prefix => sectionName === prefix || sectionName.startsWith(`${prefix}.`));
+  return filterTomlRootKeys(content, ['notify', ...LOCAL_SKILL_CONFIG_SECTIONS]);
 }
 
 function removePluginHomeEntry(pluginHome, entryName, skippedLinks) {
@@ -265,6 +216,24 @@ function removePluginHomeEntry(pluginHome, entryName, skippedLinks) {
 }
 
 function buildCodexHomeEnv(env = process.env, options = {}) {
+  const userHome = getUserCodexHome(env, options);
+  let canonicalHome = getPluginCodexHome(env, options);
+  // Per-skill writes belong to the plugin even when an older installation
+  // explicitly shared its Codex home with the user's normal Codex session.
+  if (samePath(userHome, canonicalHome) && (options.forceIsolatedSkillSettings === true
+    || Array.isArray(options.enabledCodexLocalSkillIds))) {
+    canonicalHome += '-overleaf-runtime';
+    if (samePath(userHome, canonicalHome)) throw new Error('The isolated skill home must not alias the user Codex home.');
+  }
+  if (options.isolateRuntimeHome === true && !samePath(userHome, canonicalHome)) {
+    const { prepareScopedPluginCodexHome } = require('./codexHomeScope');
+    const prepared = prepareScopedPluginCodexHome(env, options, {
+      userHome, canonicalHome, prepare: preparePluginCodexHome, ensureSkills: ensureDefaultCodexOverleafSkills,
+      prepareConfig: sanitizeCopiedCodexConfig
+    });
+    return { ...env, CODEX_HOME: prepared.pluginHome, CODEX_SQLITE_HOME: env.CODEX_SQLITE_HOME || canonicalHome,
+      CODEX_OVERLEAF_CODEX_HOME: canonicalHome, CODEX_OVERLEAF_USER_CODEX_HOME: userHome };
+  }
   const prepared = preparePluginCodexHome(env, options);
   return {
     ...env,
@@ -322,9 +291,14 @@ function composePluginSkillsDirectory({
       continue;
     }
     for (const entry of fs.readdirSync(source.root, { withFileTypes: true })) {
-      if (!entry.isDirectory() || !isSafeSkillEntryName(entry.name)) {
+      if (!(entry.isDirectory() || (source.name === 'codex-local' && entry.isSymbolicLink()
+        && isDirectory(path.join(source.root, entry.name)))) || !isSafeSkillEntryName(entry.name)) {
         continue;
       }
+      if (source.name === 'codex-overleaf') {
+        if (Array.isArray(options.enabledCodexOverleafSkillIds) && !options.enabledCodexOverleafSkillIds.includes(entry.name)) continue;
+        if (Array.isArray(options.disableCodexOverleafSkillIds) && options.disableCodexOverleafSkillIds.includes(entry.name)) continue;
+      }
       const sourcePath = path.join(source.root, entry.name);
       const targetPath = path.join(targetRoot, entry.name);
       if (!isSafePluginHomePath(targetPath, pluginHome)) {
@@ -332,6 +306,7 @@ function composePluginSkillsDirectory({
         continue;
       }
       if (source.replaceExisting) {
+        preserveLocalSkillAlias(targetPath, targetRoot, options);
         fs.rmSync(targetPath, { recursive: true, force: true });
       }
       const linkResult = ensureSymlink(sourcePath, targetPath, options);
@@ -377,6 +352,21 @@ function composePluginSkillsDirectory({
   return { linked, skippedLinks };
 }
 
+function preserveLocalSkillAlias(targetPath, targetRoot, options) {
+  let target;
+  try {
+    if (!fs.lstatSync(targetPath).isSymbolicLink()) return;
+    target = fs.realpathSync(targetPath);
+  } catch (error) {
+    if (error.code === 'ENOENT') return;
+    throw error;
+  }
+  const suffix = createHash('sha256').update(target).digest('hex').slice(0, 16);
+  const alias = path.join(targetRoot, `${path.basename(targetPath)}.codex-local-${suffix}`);
+  const result = ensureSymlink(target, alias, options);
+  if (!result.ok) throw new Error('The local skill alias could not be preserved.');
+}
+
 function clearPluginCodexHistory(optionsOrEnv = {}, maybeEnv = null) {
   const { options, env } = normalizeClearHistoryArgs(optionsOrEnv, maybeEnv);
   const pluginHome = getPluginCodexHome(env);
@@ -595,7 +585,10 @@ function chmodIfPossible(target, mode) {
 }
 
 function samePath(left, right) {
-  return path.resolve(left) === path.resolve(right);
+  const resolvedLeft = path.resolve(left), resolvedRight = path.resolve(right);
+  if (resolvedLeft === resolvedRight) return true;
+  try { return fs.realpathSync(resolvedLeft) === fs.realpathSync(resolvedRight); }
+  catch { return false; }
 }
 
 function isInsideDirectory(target, parent) {

package/native-host/src/codexHomeScope.js

@@ -0,0 +1,124 @@
+'use strict';
+
+const crypto = require('node:crypto');
+const fs = require('node:fs');
+const path = require('node:path');
+const { rebaseCodexConfigPaths } = require('./codexConfigPaths');
+const { AUTH_SOURCE_MARKER, copyInheritedAuth, removeMissingInheritedAuth } = require('./codexInheritedAuth');
+const { getCodexOverleafSkillsRoot } = require('./localSkills');
+
+const HISTORY_DIRS = ['sessions', 'archived_sessions', 'history'];
+const SCOPE_MARKER = '.codex-overleaf-scope.json';
+
+function prepareScopedPluginCodexHome(env, options, home) {
+  const { userHome, canonicalHome, prepare, ensureSkills, prepareConfig } = home;
+  fs.mkdirSync(canonicalHome, { recursive: true, mode: 0o700 });
+  try { fs.chmodSync(canonicalHome, 0o700); } catch { /* Match the existing best-effort home permissions. */ }
+  synchronizeAuth(path.join(userHome, 'auth.json'), path.join(canonicalHome, 'auth.json'));
+  ensureSkills({ env });
+  const overleafRoot = getCodexOverleafSkillsRoot({ env });
+  const capturedConfig = readOptionalFile(path.join(userHome, 'config.toml'));
+  const descriptor = {
+    version: 1,
+    userHome,
+    local: options.loadCodexLocalSkills !== false,
+    overleaf: options.loadCodexOverleafSkills !== false,
+    installer: options.installCodexOverleafSkillsTarget === true,
+    enabled: normalizedIds(options.enabledCodexOverleafSkillIds),
+    enabledLocal: normalizedIds(options.enabledCodexLocalSkillIds),
+    disabled: normalizedIds(options.disableCodexOverleafSkillIds),
+    config: digest(capturedConfig),
+    localSkills: options.loadCodexLocalSkills !== false ? directoryIdentity(path.join(userHome, 'skills')) : [],
+    // Installer targets stay stable while installed skill contents grow.
+    pluginSkills: options.installCodexOverleafSkillsTarget === true
+      ? overleafRoot
+      : options.loadCodexOverleafSkills !== false ? directoryIdentity(overleafRoot) : [],
+    projectSkills: options.projectLocalSkills || null
+  };
+  const key = digest(JSON.stringify(descriptor));
+  const scopesRoot = path.join(canonicalHome, 'runtime-homes');
+  fs.mkdirSync(scopesRoot, { recursive: true, mode: 0o700 });
+  const scopeHome = path.join(scopesRoot, key);
+  for (const name of HISTORY_DIRS) fs.mkdirSync(path.join(canonicalHome, name), { recursive: true });
+
+  if (!isReady(scopeHome, key)) {
+    const staging = fs.mkdtempSync(path.join(scopesRoot, '.prepare-'));
+    try {
+      prepare({ ...env, CODEX_OVERLEAF_CODEX_HOME: staging, CODEX_OVERLEAF_USER_CODEX_HOME: userHome }, {
+        ...options,
+        skipCopiedUserConfig: true,
+        enabledCodexOverleafSkillIds: descriptor.enabled || undefined,
+        enabledCodexLocalSkillIds: descriptor.enabledLocal || undefined,
+        disableCodexOverleafSkillIds: descriptor.disabled || undefined
+      });
+      // Published scopes inherit from the canonical home, including provenance.
+      // The staging prepare's direct user copy must never escape publication.
+      fs.rmSync(path.join(staging, 'auth.json'), { force: true });
+      fs.rmSync(path.join(staging, AUTH_SOURCE_MARKER), { force: true });
+      synchronizeAuth(path.join(canonicalHome, 'auth.json'), path.join(staging, 'auth.json'));
+      const configFile = path.join(staging, 'config.toml');
+      const config = prepareConfig(capturedConfig.toString('utf8'), options);
+      fs.writeFileSync(configFile, rebaseCodexConfigPaths(config, canonicalHome), { mode: 0o600 });
+      for (const name of HISTORY_DIRS) {
+        fs.symlinkSync(path.join(canonicalHome, name), path.join(staging, name), options.platform === 'win32' || process.platform === 'win32' ? 'junction' : 'dir');
+      }
+      fs.writeFileSync(path.join(staging, SCOPE_MARKER), JSON.stringify({ version: 1, key }), { mode: 0o600 });
+      try { fs.renameSync(staging, scopeHome); }
+      catch (error) {
+        // Another process may have atomically published this complete scope.
+        // Never remove a final directory or return an incomplete environment.
+        if (!isReady(scopeHome, key)) throw error;
+      }
+    } finally {
+      fs.rmSync(staging, { recursive: true, force: true });
+    }
+  }
+
+  synchronizeAuth(path.join(userHome, 'auth.json'), path.join(canonicalHome, 'auth.json'));
+  synchronizeAuth(path.join(canonicalHome, 'auth.json'), path.join(scopeHome, 'auth.json'));
+  // Refresh discovery caches without rewriting a live scope's configuration or
+  // replacing the skill paths a process has already discovered.
+  for (const name of ['installation_id', 'models_cache.json', 'version.json']) {
+    const source = path.join(userHome, name);
+    if (isFile(source)) fs.copyFileSync(source, path.join(scopeHome, name));
+  }
+  return { userHome, pluginHome: scopeHome, canonicalHome };
+}
+
+function synchronizeAuth(source, target) {
+  if (isFile(source)) copyInheritedAuth(source, target);
+  else removeMissingInheritedAuth(source, target);
+}
+
+function normalizedIds(value) {
+  return Array.isArray(value) ? Array.from(new Set(value.map(id => String(id || '').trim()).filter(Boolean))).sort() : null;
+}
+
+function directoryIdentity(root) {
+  let entries;
+  try { entries = fs.readdirSync(root, { withFileTypes: true }); }
+  catch (error) { if (error.code === 'ENOENT') return []; throw error; }
+  return entries.filter(entry => entry.isDirectory() || (entry.isSymbolicLink()
+    && isDirectory(path.join(root, entry.name)))).map(entry => {
+    const location = path.join(root, entry.name);
+    return [entry.name, fs.realpathSync(location)];
+  }).sort((a, b) => a[0].localeCompare(b[0]));
+}
+
+function isReady(directory, key) {
+  try {
+    const marker = JSON.parse(fs.readFileSync(path.join(directory, SCOPE_MARKER), 'utf8'));
+    if (marker.version === 1 && marker.key === key && !fs.lstatSync(directory).isSymbolicLink()) return true;
+    throw new Error('The plugin Codex scope has invalid ownership metadata.');
+  } catch (error) {
+    if (error.code === 'ENOENT' && !fs.existsSync(directory)) return false;
+    throw error;
+  }
+}
+
+function isFile(file) { try { return fs.statSync(file).isFile(); } catch { return false; } }
+function isDirectory(file) { try { return fs.statSync(file).isDirectory(); } catch { return false; } }
+function readOptionalFile(file) { try { return fs.readFileSync(file); } catch (error) { if (error.code === 'ENOENT') return Buffer.alloc(0); throw error; } }
+function digest(value) { return crypto.createHash('sha256').update(value).digest('hex'); }
+
+module.exports = { prepareScopedPluginCodexHome };

package/native-host/src/codexInheritedAuth.js

@@ -0,0 +1,90 @@
+'use strict';
+
+const crypto = require('node:crypto');
+const fs = require('node:fs');
+const path = require('node:path');
+
+const MARKER = '.codex-overleaf-auth-source.json';
+
+function fingerprint(contents) {
+  return crypto.createHash('sha256').update(contents).digest('hex');
+}
+
+function copyInheritedAuth(source, target) {
+  const contents = fs.readFileSync(source);
+  const authTemporary = `${target}.${process.pid}.${crypto.randomBytes(6).toString('hex')}.tmp`;
+  try {
+    fs.writeFileSync(authTemporary, contents, { mode: 0o600 });
+    fs.renameSync(authTemporary, target);
+  } finally {
+    fs.rmSync(authTemporary, { force: true });
+  }
+  const marker = path.join(path.dirname(target), MARKER);
+  const temporary = `${marker}.${process.pid}.${crypto.randomBytes(6).toString('hex')}.tmp`;
+  try {
+    fs.writeFileSync(temporary, JSON.stringify({ version: 1, source: path.resolve(source), digest: fingerprint(contents) }), { mode: 0o600 });
+    fs.renameSync(temporary, marker);
+  } finally {
+    fs.rmSync(temporary, { force: true });
+  }
+}
+
+// Source absence alone cannot identify independent or old, unattributed auth.
+// Delete only the unchanged bytes that this home preparation actually copied.
+function removeMissingInheritedAuth(source, target) {
+  const marker = path.join(path.dirname(target), MARKER);
+  const ownedMarker = `${marker}.claimed-${process.pid}-${crypto.randomBytes(8).toString('hex')}`;
+  try { fs.renameSync(marker, ownedMarker); }
+  catch (error) { if (error.code === 'ENOENT') return; throw error; }
+  let provenance;
+  try { provenance = JSON.parse(fs.readFileSync(ownedMarker, 'utf8')); }
+  catch (error) { restoreExclusive(ownedMarker, marker); throw error; }
+  if (provenance?.version !== 1 || provenance.source !== path.resolve(source)) {
+    restoreExclusive(ownedMarker, marker); return;
+  }
+  // Independent auth that already differs requires no file move at all.
+  let contents;
+  try { contents = fs.readFileSync(target); }
+  catch (error) {
+    if (error.code === 'ENOENT') { fs.rmSync(ownedMarker, { force: true }); return; }
+    restoreExclusive(ownedMarker, marker); throw error;
+  }
+  if (fingerprint(contents) !== provenance.digest) {
+    fs.rmSync(ownedMarker, { force: true }); return;
+  }
+  const detached = `${target}.preserved-${process.pid}-${crypto.randomBytes(8).toString('hex')}`;
+  try { fs.renameSync(target, detached); }
+  catch (error) {
+    restoreExclusive(ownedMarker, marker);
+    if (error.code === 'ENOENT') return;
+    throw error;
+  }
+  let inherited;
+  try {
+    inherited = fs.lstatSync(detached).isFile() && fingerprint(fs.readFileSync(detached)) === provenance.digest;
+  } catch (error) {
+    restoreExclusive(detached, target); restoreExclusive(ownedMarker, marker); throw error;
+  }
+  if (inherited) {
+    // A concurrent login may already have published a new auth and marker.
+    // Only these atomically claimed files belong to this cleanup operation.
+    fs.rmSync(detached, { force: true });
+  } else {
+    restoreExclusive(detached, target);
+  }
+  fs.rmSync(ownedMarker, { force: true });
+}
+
+function restoreExclusive(detached, target) {
+  try {
+    fs.linkSync(detached, target);
+    fs.rmSync(detached, { force: true });
+  } catch (error) {
+    if (error.code === 'EEXIST' && fs.existsSync(target)) return;
+    // A nonmatching credential remains in the private preserved file. Starting
+    // without restoring it would silently change the selected authentication.
+    throw error;
+  }
+}
+
+module.exports = { AUTH_SOURCE_MARKER: MARKER, copyInheritedAuth, removeMissingInheritedAuth };