@gemus/mcp-proxy 0.1.9 → 0.1.10

package/src/setup/configFile.mjs

@@ -0,0 +1,155 @@
+import { randomUUID } from 'node:crypto'
+import { open, readFile, rename, rm, lstat, access, mkdir } from 'node:fs/promises'
+import { constants } from 'node:fs'
+import { homedir as systemHomeDirectory } from 'node:os'
+import path from 'node:path'
+
+export class CodexConfigChangedError extends Error {
+  constructor(currentSource) {
+    super('Codex config changed while setup was running; re-plan from the latest config.')
+    this.code = 'CODEX_CONFIG_CHANGED'
+    this.currentSource = currentSource
+  }
+}
+
+function configPathFromEnvironment(env, homeDirectory) {
+  const configuredHome = typeof env.CODEX_HOME === 'string' && env.CODEX_HOME.trim() !== ''
+    ? env.CODEX_HOME
+    : undefined
+  const codexHome = configuredHome ?? path.join(homeDirectory(), '.codex')
+  if (!path.isAbsolute(codexHome)) throw new Error('CODEX_HOME must be an absolute path')
+  return path.join(codexHome, 'config.toml')
+}
+
+async function readSource(configPath, fileOps) {
+  try {
+    return await fileOps.readFile(configPath, 'utf8')
+  } catch (error) {
+    if (error?.code === 'ENOENT') return ''
+    throw error
+  }
+}
+
+async function validateConfigBoundary(configPath, fileOps) {
+  const root = path.parse(configPath).root
+  const parts = path.relative(root, configPath).split(path.sep).filter(Boolean)
+  let current = root
+  for (let index = 0; index < parts.length; index += 1) {
+    current = path.join(current, parts[index])
+    try {
+      const stat = await fileOps.lstat(current)
+      if (stat.isSymbolicLink()) throw new Error('refusing to replace a symlink Codex config path')
+      if (index < parts.length - 1 && !stat.isDirectory()) {
+        throw new Error('Codex config home path is not a directory')
+      }
+    } catch (error) {
+      if (error?.code === 'ENOENT') return
+      throw error
+    }
+  }
+}
+
+export async function preflightCodexConfig({
+  env = process.env,
+  fileOps: overrides,
+  homeDirectory = systemHomeDirectory,
+} = {}) {
+  const fileOps = { readFile, lstat, access, ...overrides }
+  const configPath = configPathFromEnvironment(env, homeDirectory)
+  await validateConfigBoundary(configPath, fileOps)
+  let ancestor = path.dirname(configPath)
+  while (true) {
+    try { await fileOps.lstat(ancestor); break } catch (error) {
+      if (error?.code !== 'ENOENT') throw error
+      const parent = path.dirname(ancestor)
+      if (parent === ancestor) throw error
+      ancestor = parent
+    }
+  }
+  await fileOps.access(ancestor, constants.W_OK)
+  return { configPath, source: await readSource(configPath, fileOps) }
+}
+
+async function openExclusive(prefix, fileOps) {
+  for (let attempt = 0; attempt < 32; attempt += 1) {
+    const candidate = `${prefix}${randomUUID()}`
+    try {
+      return { path: candidate, handle: await fileOps.open(candidate, 'wx', 0o600) }
+    } catch (error) {
+      if (error?.code !== 'EEXIST') throw error
+    }
+  }
+  throw new Error('could not reserve a unique Codex config transaction file')
+}
+
+async function createConfigHomeSafely(configPath, fileOps) {
+  await validateConfigBoundary(configPath, fileOps)
+  const root = path.parse(configPath).root
+  const directories = path.relative(root, path.dirname(configPath)).split(path.sep).filter(Boolean)
+  let current = root
+  for (const segment of directories) {
+    current = path.join(current, segment)
+    try {
+      const stat = await fileOps.lstat(current)
+      if (stat.isSymbolicLink()) throw new Error('refusing to replace a symlink Codex config path')
+      if (!stat.isDirectory()) throw new Error('Codex config home path is not a directory')
+    } catch (error) {
+      if (error?.code !== 'ENOENT') throw error
+      await fileOps.mkdir(current, { mode: 0o700 })
+      const created = await fileOps.lstat(current)
+      if (created.isSymbolicLink()) throw new Error('refusing to replace a symlink Codex config path')
+      if (!created.isDirectory()) throw new Error('Codex config home path is not a directory')
+    }
+  }
+  await validateConfigBoundary(configPath, fileOps)
+}
+
+export async function commitCodexConfig({
+  expectedSource,
+  nextText,
+  env = process.env,
+  fileOps: overrides,
+  homeDirectory = systemHomeDirectory,
+} = {}) {
+  if (typeof expectedSource !== 'string' || typeof nextText !== 'string') {
+    throw new TypeError('expectedSource and nextText must be strings')
+  }
+  const fileOps = { open, readFile, rename, rm, lstat, mkdir, ...overrides }
+  const configPath = configPathFromEnvironment(env, homeDirectory)
+  await createConfigHomeSafely(configPath, fileOps)
+  const currentSource = await readSource(configPath, fileOps)
+  if (currentSource !== expectedSource) throw new CodexConfigChangedError(currentSource)
+  if (currentSource === nextText) return { changed: false, backupPath: undefined }
+
+  let backupPath
+  let tempPath
+  try {
+    if (currentSource !== '') {
+      const backup = await openExclusive(`${configPath}.gemus-backup-`, fileOps)
+      backupPath = backup.path
+      try {
+        await backup.handle.writeFile(currentSource, 'utf8')
+      } finally {
+        await backup.handle.close()
+      }
+    }
+
+    const temp = await openExclusive(`${path.join(path.dirname(configPath), `.${path.basename(configPath)}.gemus-tmp-`)}`, fileOps)
+    tempPath = temp.path
+    try {
+      await temp.handle.writeFile(nextText, 'utf8')
+    } finally {
+      await temp.handle.close()
+    }
+    await validateConfigBoundary(configPath, fileOps)
+    const finalSource = await readSource(configPath, fileOps)
+    if (finalSource !== expectedSource) throw new CodexConfigChangedError(finalSource)
+    await fileOps.rename(tempPath, configPath)
+    tempPath = undefined
+  } catch (error) {
+    if (tempPath) await fileOps.rm(tempPath, { force: true })
+    throw error
+  }
+
+  return { changed: true, backupPath }
+}

package/src/setup/environment.mjs

@@ -0,0 +1,79 @@
+import { spawn } from 'node:child_process'
+
+const WINDOWS_SCRIPT = [
+  "$ErrorActionPreference = 'Stop'",
+  'try {',
+  "  if ($env:GEMUS_URL) { [Environment]::SetEnvironmentVariable('GEMUS_URL', $env:GEMUS_URL, 'User') }",
+  "  [Environment]::SetEnvironmentVariable('GEMUS_KEY', $env:GEMUS_KEY, 'User')",
+  "$signature = @'",
+  'using System;',
+  'using System.Runtime.InteropServices;',
+  'public static class GemusEnvironmentBroadcast {',
+  '  [DllImport("user32.dll", CharSet = CharSet.Auto, SetLastError = true)]',
+  '  public static extern IntPtr SendMessageTimeout(IntPtr hWnd, uint msg, UIntPtr wParam, string lParam, uint flags, uint timeout, out UIntPtr result);',
+  '}',
+  "'@",
+  'Add-Type -TypeDefinition $signature',
+  '$result = [UIntPtr]::Zero',
+  '[GemusEnvironmentBroadcast]::SendMessageTimeout([IntPtr]0xffff, 0x001A, [UIntPtr]::Zero, "Environment", 2, 5000, [ref]$result) | Out-Null # WM_SETTINGCHANGE',
+  '} finally {',
+  '  Remove-Item Env:GEMUS_KEY -ErrorAction SilentlyContinue',
+  '  Remove-Item Env:GEMUS_URL -ErrorAction SilentlyContinue',
+  '}',
+].join('\n')
+
+const MACOS_SCRIPT = [
+  'set -e',
+  "trap 'unset GEMUS_KEY GEMUS_URL' EXIT",
+  'if [ -n "${GEMUS_URL:-}" ]; then /bin/launchctl setenv GEMUS_URL "$GEMUS_URL"; fi',
+  '/bin/launchctl setenv GEMUS_KEY "$GEMUS_KEY"',
+].join('\n')
+
+function childEnvironment(key, url, parentEnv) {
+  const environment = Object.fromEntries(Object.entries(parentEnv).filter(([name]) => (
+    name.toUpperCase() !== 'GEMUS_KEY' && name.toUpperCase() !== 'GEMUS_URL'
+  )))
+  environment.GEMUS_KEY = key
+  if (url !== undefined) environment.GEMUS_URL = url
+  return environment
+}
+
+function runChild(command, args, { env }) {
+  return new Promise((resolve, reject) => {
+    const child = spawn(command, args, { env, stdio: 'ignore' })
+    child.once('error', reject)
+    child.once('exit', (code) => {
+      if (code === 0) resolve()
+      else reject(new Error('environment installer exited unsuccessfully'))
+    })
+  })
+}
+
+export async function installGemusEnvironment({
+  key,
+  url,
+  runner = runChild,
+  platform = process.platform,
+  stdout = process.stdout,
+  parentEnv = process.env,
+} = {}) {
+  if (platform !== 'win32' && platform !== 'darwin') {
+    throw new Error('Gemus Companion setup supports only Windows and macOS.')
+  }
+
+  const env = childEnvironment(key, url, parentEnv)
+  try {
+    if (platform === 'win32') {
+      await runner('powershell.exe', ['-NoProfile', '-NonInteractive', '-Command', WINDOWS_SCRIPT], { env })
+      return
+    }
+    await runner('/bin/sh', ['-c', MACOS_SCRIPT], { env })
+    stdout?.write(
+      'Gemus environment values last only for the current macOS login session. '
+      + 'After logout, reboot, or a new login, rerun setup. '
+      + 'Fully quit and restart Codex Desktop to use Gemus Companion.\n',
+    )
+  } catch {
+    throw new Error('Could not install the Gemus Companion environment.')
+  }
+}

package/src/setup/secret.mjs

@@ -0,0 +1,91 @@
+function present(value) {
+  return value !== undefined && value !== ''
+}
+
+function validateKey(key) {
+  if (typeof key !== 'string' || key.length === 0 || /\s/.test(key)) {
+    throw new Error('invalid GEMUS_KEY')
+  }
+  return key
+}
+
+function validateUrl(url) {
+  if (typeof url !== 'string' || url.length === 0 || /\s/.test(url)) {
+    throw new Error('invalid GEMUS_URL')
+  }
+  let parsed
+  try {
+    parsed = new URL(url)
+  } catch {
+    throw new Error('invalid GEMUS_URL')
+  }
+  if (parsed.protocol !== 'https:' && parsed.protocol !== 'http:') {
+    throw new Error('invalid GEMUS_URL')
+  }
+  return url
+}
+
+function hiddenKey({ stdin, stdout }) {
+  stdout?.write('Enter Gemus API key: ')
+  return new Promise((resolve, reject) => {
+    let key = ''
+    const finish = (callback, value) => {
+      stdin.off('data', onData)
+      stdin.off('end', onEnd)
+      stdin.off('error', onError)
+      callback(value)
+    }
+    const onData = (chunk) => {
+      for (const character of String(chunk)) {
+        if (character === '\u0003') {
+          finish(reject, new Error('Gemus setup cancelled.'))
+          return
+        }
+        if (character === '\r' || character === '\n') {
+          if (key) finish(resolve, key)
+          else finish(reject, new Error('No Gemus API key was provided.'))
+          return
+        }
+        if (character === '\b' || character === '\u007f') {
+          key = key.slice(0, -1)
+          continue
+        }
+        key += character
+      }
+    }
+    const onEnd = () => finish(reject, new Error('No Gemus API key was provided.'))
+    const onError = () => finish(reject, new Error('Could not read the Gemus API key.'))
+
+    stdin.on('data', onData)
+    stdin.once('end', onEnd)
+    stdin.once('error', onError)
+  })
+}
+
+async function promptForKey({ stdin, stdout }) {
+  if (!stdin?.isTTY || typeof stdin.setRawMode !== 'function') {
+    throw new Error('GEMUS_KEY is required; set GEMUS_KEY before running setup.')
+  }
+  let rawModeEnabled = false
+  try {
+    stdin.setRawMode(true)
+    rawModeEnabled = true
+    return validateKey(await hiddenKey({ stdin, stdout }))
+  } finally {
+    if (rawModeEnabled) stdin.setRawMode(false)
+  }
+}
+
+export async function acquireGemusSecret({
+  env = process.env,
+  legacyKey,
+  legacyUrl,
+  stdin = process.stdin,
+  stdout = process.stdout,
+} = {}) {
+  const configuredUrl = present(env.GEMUS_URL) ? env.GEMUS_URL : legacyUrl
+  const url = configuredUrl === undefined ? undefined : validateUrl(configuredUrl)
+  const configuredKey = present(env.GEMUS_KEY) ? env.GEMUS_KEY : legacyKey
+  const key = configuredKey === undefined ? await promptForKey({ stdin, stdout }) : validateKey(configuredKey)
+  return { key, url }
+}