amalgm 0.0.0 → 0.0.32

package/runtime/scripts/chat-core/tooling/native-binaries.js

@@ -0,0 +1,608 @@
+'use strict';
+
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+const { spawnSync } = require('child_process');
+
+function amalgmDir() {
+  return process.env.AMALGM_DIR || path.join(os.homedir(), '.amalgm');
+}
+
+function nativeNodeModulesDirs() {
+  return [
+    process.env.AMALGM_NATIVE_NODE_MODULES,
+    path.join(amalgmDir(), 'native', 'node_modules'),
+  ].filter(Boolean);
+}
+
+function executableExists(file) {
+  try {
+    fs.accessSync(file, fs.constants.X_OK);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+function findPackageJson(packageName) {
+  const candidateDirs = [
+    ...nativeNodeModulesDirs(),
+    ...(require.resolve.paths(packageName) || []),
+  ];
+  for (const dir of candidateDirs) {
+    const candidate = path.join(dir, packageName, 'package.json');
+    if (fs.existsSync(candidate)) return candidate;
+  }
+  return null;
+}
+
+function packageRoot(packageName) {
+  const manifest = findPackageJson(packageName);
+  if (manifest) return path.dirname(manifest);
+  try {
+    return path.dirname(require.resolve(`${packageName}/package.json`));
+  } catch {
+    return null;
+  }
+}
+
+function findOnPath(command) {
+  if (!command || command.includes('/') || command.includes('\\')) return null;
+  const binaryNames = process.platform === 'win32' && !path.extname(command)
+    ? unique([
+      command,
+      ...String(process.env.PATHEXT || '.COM;.EXE;.BAT;.CMD')
+        .split(';')
+        .filter(Boolean)
+        .map((ext) => `${command}${ext.toLowerCase()}`),
+    ])
+    : [command];
+  for (const dir of String(process.env.PATH || '').split(path.delimiter).filter(Boolean)) {
+    for (const binaryName of binaryNames) {
+      const candidate = path.join(dir, binaryName);
+      if (executableExists(candidate)) return candidate;
+    }
+  }
+  return null;
+}
+
+function packageBin(packageName, binName) {
+  const root = packageRoot(packageName);
+  if (!root) return null;
+  try {
+    const manifest = JSON.parse(fs.readFileSync(path.join(root, 'package.json'), 'utf8'));
+    const bin = typeof manifest.bin === 'string'
+      ? manifest.bin
+      : manifest.bin?.[binName];
+    if (!bin) return null;
+    const candidate = path.join(root, bin);
+    return executableExists(candidate) ? candidate : null;
+  } catch {
+    return null;
+  }
+}
+
+function chmodExecutableBestEffort(file) {
+  if (!file || process.platform === 'win32') return;
+  try {
+    const stat = fs.statSync(file);
+    fs.chmodSync(file, stat.mode | 0o111);
+  } catch {
+    // chmod is best-effort.
+  }
+}
+
+function sameRealPath(a, b) {
+  try {
+    return fs.realpathSync(a) === fs.realpathSync(b);
+  } catch {
+    return false;
+  }
+}
+
+function unique(values) {
+  const seen = new Set();
+  return values.filter((value) => {
+    if (!value || seen.has(value)) return false;
+    seen.add(value);
+    return true;
+  });
+}
+
+function nearestPackageManifest() {
+  let current = __dirname;
+  for (let i = 0; i < 12; i += 1) {
+    const candidate = path.join(current, 'package.json');
+    if (fs.existsSync(candidate)) {
+      try {
+        const manifest = JSON.parse(fs.readFileSync(candidate, 'utf8'));
+        if (manifest.dependencies || manifest.optionalDependencies) return manifest;
+      } catch {
+        // Keep walking.
+      }
+    }
+    const next = path.dirname(current);
+    if (next === current) break;
+    current = next;
+  }
+  return {};
+}
+
+function dependencySpec(packageName, fallback = 'latest') {
+  const manifest = nearestPackageManifest();
+  return manifest.dependencies?.[packageName]
+    || manifest.optionalDependencies?.[packageName]
+    || fallback;
+}
+
+function linuxLibcSuffix() {
+  if (process.platform !== 'linux') return '';
+  const glibc = process.report?.getReport?.().header?.glibcVersionRuntime;
+  return glibc ? '' : '-musl';
+}
+
+function nativePackageSuffix() {
+  if (!['linux', 'darwin', 'win32'].includes(process.platform)) return null;
+  if (!['x64', 'arm64'].includes(process.arch)) return null;
+  return `${process.platform}-${process.arch}${linuxLibcSuffix()}`;
+}
+
+function claudeTargetPackage() {
+  const suffix = nativePackageSuffix();
+  if (!suffix) return null;
+  return `@anthropic-ai/claude-agent-sdk-${suffix}`;
+}
+
+function bundledClaudeBinary() {
+  const packageName = claudeTargetPackage();
+  if (!packageName) return null;
+  const root = packageRoot(packageName);
+  if (!root) return null;
+  const candidate = path.join(root, process.platform === 'win32' ? 'claude.exe' : 'claude');
+  return executableExists(candidate) ? candidate : null;
+}
+
+function resolveClaudeBinary() {
+  const candidates = [
+    process.env.CLAUDE_CODE_BINARY,
+    bundledClaudeBinary(),
+    path.join(os.homedir(), '.npm-global', 'bin', process.platform === 'win32' ? 'claude.exe' : 'claude'),
+    '/opt/homebrew/bin/claude',
+    '/usr/local/bin/claude',
+    findOnPath('claude'),
+  ].filter(Boolean);
+
+  for (const candidate of candidates) {
+    if (executableExists(candidate)) return candidate;
+  }
+  return null;
+}
+
+function codexTarget() {
+  const binaryName = process.platform === 'win32' ? 'codex.exe' : 'codex';
+  if (process.platform === 'linux' && process.arch === 'x64') {
+    return { packageName: '@openai/codex-linux-x64', triple: 'x86_64-unknown-linux-musl', binaryName };
+  }
+  if (process.platform === 'linux' && process.arch === 'arm64') {
+    return { packageName: '@openai/codex-linux-arm64', triple: 'aarch64-unknown-linux-musl', binaryName };
+  }
+  if (process.platform === 'darwin' && process.arch === 'x64') {
+    return { packageName: '@openai/codex-darwin-x64', triple: 'x86_64-apple-darwin', binaryName };
+  }
+  if (process.platform === 'darwin' && process.arch === 'arm64') {
+    return { packageName: '@openai/codex-darwin-arm64', triple: 'aarch64-apple-darwin', binaryName };
+  }
+  if (process.platform === 'win32' && process.arch === 'x64') {
+    return { packageName: '@openai/codex-win32-x64', triple: 'x86_64-pc-windows-msvc', binaryName };
+  }
+  if (process.platform === 'win32' && process.arch === 'arm64') {
+    return { packageName: '@openai/codex-win32-arm64', triple: 'aarch64-pc-windows-msvc', binaryName };
+  }
+  return null;
+}
+
+function codexInstallPackageName() {
+  return codexTarget()?.packageName || null;
+}
+
+function codexVendorRoot() {
+  const target = codexTarget();
+  if (!target) return null;
+  const platformRoot = packageRoot(target.packageName);
+  if (platformRoot) return path.join(platformRoot, 'vendor');
+  const wrapperRoot = packageRoot('@openai/codex');
+  if (wrapperRoot) {
+    const localVendorRoot = path.join(wrapperRoot, 'vendor');
+    if (fs.existsSync(localVendorRoot)) return localVendorRoot;
+  }
+  return null;
+}
+
+function bundledCodexBinary() {
+  const target = codexTarget();
+  const vendorRoot = codexVendorRoot();
+  if (target && vendorRoot) {
+    const candidate = path.join(vendorRoot, target.triple, 'codex', target.binaryName);
+    if (executableExists(candidate)) return candidate;
+  }
+  return packageBin('@openai/codex', 'codex');
+}
+
+function bundledCodexPathDirs() {
+  const target = codexTarget();
+  const vendorRoot = codexVendorRoot();
+  if (!target || !vendorRoot) return [];
+  const candidate = path.join(vendorRoot, target.triple, 'path');
+  return executableExists(path.join(candidate, process.platform === 'win32' ? 'rg.exe' : 'rg')) ? [candidate] : [];
+}
+
+function openCodePlatform() {
+  if (process.platform === 'darwin') return 'darwin';
+  if (process.platform === 'linux') return 'linux';
+  if (process.platform === 'win32') return 'windows';
+  return process.platform;
+}
+
+function supportsAvx2() {
+  if (process.arch !== 'x64') return false;
+  if (process.platform === 'linux') {
+    try {
+      return /(^|\s)avx2(\s|$)/i.test(fs.readFileSync('/proc/cpuinfo', 'utf8'));
+    } catch {
+      return false;
+    }
+  }
+  if (process.platform === 'darwin') {
+    try {
+      const { spawnSync } = require('child_process');
+      const res = spawnSync('sysctl', ['-n', 'hw.optional.avx2_0'], { encoding: 'utf8', timeout: 1500 });
+      return res.status === 0 && String(res.stdout || '').trim() === '1';
+    } catch {
+      return false;
+    }
+  }
+  return false;
+}
+
+function openCodePackageCandidates() {
+  if (!['linux', 'darwin', 'win32'].includes(process.platform)) return [];
+  if (!['x64', 'arm64', 'arm'].includes(process.arch)) return [];
+  const platform = openCodePlatform();
+  const arch = process.arch;
+  const base = `opencode-${platform}-${arch}`;
+  if (process.platform !== 'linux') return [base];
+
+  const musl = linuxLibcSuffix() === '-musl';
+  if (arch !== 'x64') return musl ? [`${base}-musl`, base] : [base, `${base}-musl`];
+
+  const preferred = supportsAvx2() ? [base, `${base}-baseline`] : [`${base}-baseline`, base];
+  const suffixes = musl ? ['-musl', ''] : ['', '-musl'];
+  return preferred.flatMap((name) => suffixes.map((suffix) => `${name}${suffix}`));
+}
+
+function openCodeInstallPackageNames() {
+  return openCodePackageCandidates();
+}
+
+function bundledOpenCodeBinary() {
+  const binaryName = process.platform === 'win32' ? 'opencode.exe' : 'opencode';
+  for (const packageName of openCodePackageCandidates()) {
+    const root = packageRoot(packageName);
+    if (!root) continue;
+    const candidate = path.join(root, 'bin', binaryName);
+    if (executableExists(candidate)) return candidate;
+  }
+  const wrapperRoot = packageRoot('opencode-ai');
+  if (wrapperRoot) {
+    const cached = path.join(wrapperRoot, 'bin', '.opencode');
+    if (executableExists(cached)) return cached;
+  }
+  return packageBin('opencode-ai', 'opencode');
+}
+
+function binaryStatus() {
+  const claudeBinary = resolveClaudeBinary();
+  const codexBinary = bundledCodexBinary() || findOnPath('codex');
+  const openCodeBinary = bundledOpenCodeBinary() || findOnPath('opencode');
+  return [
+    {
+      id: 'claude_code',
+      name: 'Claude Code',
+      ok: Boolean(claudeBinary),
+      path: claudeBinary,
+      packageName: claudeTargetPackage(),
+    },
+    {
+      id: 'codex',
+      name: 'Codex',
+      ok: Boolean(codexBinary),
+      path: codexBinary,
+      packageName: codexInstallPackageName(),
+    },
+    {
+      id: 'opencode',
+      name: 'OpenCode',
+      ok: Boolean(openCodeBinary),
+      path: openCodeBinary,
+      packageName: openCodeInstallPackageNames()[0] || null,
+    },
+  ];
+}
+
+function commandTargets() {
+  return [
+    {
+      command: 'claude',
+      name: 'Claude Code',
+      path: resolveClaudeBinary(),
+    },
+    {
+      command: 'codex',
+      name: 'Codex',
+      path: packageBin('@openai/codex', 'codex') || bundledCodexBinary(),
+    },
+    {
+      command: 'opencode',
+      name: 'OpenCode',
+      path: packageBin('opencode-ai', 'opencode') || bundledOpenCodeBinary(),
+    },
+  ];
+}
+
+function installRoot() {
+  return path.join(amalgmDir(), 'native');
+}
+
+function npmCommand() {
+  return process.platform === 'win32' ? 'npm.cmd' : 'npm';
+}
+
+function npmGlobalBinDir() {
+  try {
+    const result = spawnSync(npmCommand(), ['prefix', '-g'], {
+      encoding: 'utf8',
+      timeout: 5000,
+      stdio: ['ignore', 'pipe', 'ignore'],
+      shell: process.platform === 'win32',
+      windowsHide: true,
+    });
+    if (result.status !== 0) return null;
+    const prefix = String(result.stdout || '').trim();
+    if (!prefix) return null;
+    return process.platform === 'win32' ? prefix : path.join(prefix, 'bin');
+  } catch {
+    return null;
+  }
+}
+
+function commandShimDirs() {
+  return unique([
+    process.env.AMALGM_AGENT_BIN_DIR,
+    findOnPath('amalgm') ? path.dirname(findOnPath('amalgm')) : null,
+    npmGlobalBinDir(),
+  ]);
+}
+
+function entryStat(file) {
+  try {
+    return fs.lstatSync(file);
+  } catch {
+    return null;
+  }
+}
+
+function ensurePosixCommandShim(command, target, binDir, options = {}) {
+  fs.mkdirSync(binDir, { recursive: true });
+  chmodExecutableBestEffort(target);
+
+  const linkPath = path.join(binDir, command);
+  const existing = entryStat(linkPath);
+  if (existing) {
+    if (sameRealPath(linkPath, target)) {
+      return { ok: true, command, path: linkPath, target, status: 'exists' };
+    }
+    if (!existing.isSymbolicLink() && !options.force) {
+      return { ok: true, command, path: linkPath, target, status: 'kept-existing' };
+    }
+    try {
+      fs.unlinkSync(linkPath);
+    } catch (error) {
+      return { ok: false, command, path: linkPath, target, status: 'failed', error };
+    }
+  }
+
+  try {
+    fs.symlinkSync(target, linkPath);
+    return { ok: true, command, path: linkPath, target, status: 'created' };
+  } catch (error) {
+    return { ok: false, command, path: linkPath, target, status: 'failed', error };
+  }
+}
+
+function ensureWindowsCommandShim(command, target, binDir) {
+  fs.mkdirSync(binDir, { recursive: true });
+  const shimPath = path.join(binDir, `${command}.cmd`);
+  const usesNode = /\.m?js$/i.test(target);
+  const runner = usesNode ? process.execPath : target;
+  const args = usesNode ? `"${target}" %*` : '%*';
+  try {
+    fs.writeFileSync(shimPath, `@echo off\r\n"${runner}" ${args}\r\n`);
+    return { ok: true, command, path: shimPath, target, status: 'created' };
+  } catch (error) {
+    return { ok: false, command, path: shimPath, target, status: 'failed', error };
+  }
+}
+
+function ensureCommandShim(command, target, binDir, options = {}) {
+  if (!target || !fs.existsSync(target)) {
+    return { ok: false, command, path: null, target, status: 'missing-target' };
+  }
+  if (process.platform === 'win32') {
+    return ensureWindowsCommandShim(command, target, binDir);
+  }
+  return ensurePosixCommandShim(command, target, binDir, options);
+}
+
+function ensureAgentCommandShims(options = {}) {
+  const binDirs = commandShimDirs();
+  const targets = commandTargets();
+  const logger = options.logger || console;
+  const results = [];
+
+  if (binDirs.length === 0) {
+    return {
+      ok: false,
+      shims: targets.map((target) => ({
+        command: target.command,
+        ok: false,
+        status: 'missing-bin-dir',
+      })),
+      error: new Error('Could not find a global bin directory for agent commands'),
+    };
+  }
+
+  for (const target of targets) {
+    if (!target.path) {
+      results.push({
+        command: target.command,
+        name: target.name,
+        ok: false,
+        status: 'missing-target',
+      });
+      continue;
+    }
+
+    let last = null;
+    for (const binDir of binDirs) {
+      last = ensureCommandShim(target.command, target.path, binDir, options);
+      if (last.ok) break;
+    }
+    results.push({ ...last, name: target.name });
+  }
+
+  const created = results.filter((result) => result.ok && result.status === 'created');
+  if (created.length > 0 && !options.quiet) {
+    logger.log?.(`Agent commands are ready: ${created.map((result) => result.command).join(', ')}`);
+  }
+
+  const failures = results.filter((result) => !result.ok);
+  return {
+    ok: failures.length === 0,
+    shims: results,
+    error: failures.length > 0
+      ? new Error(`Could not expose agent commands: ${failures.map((result) => result.command).join(', ')}`)
+      : null,
+  };
+}
+
+function agentCommandShimStatus() {
+  const binDirs = commandShimDirs();
+  return commandTargets().map((target) => {
+    const commandPath = findOnPath(target.command)
+      || binDirs
+        .map((binDir) => path.join(binDir, process.platform === 'win32' ? `${target.command}.cmd` : target.command))
+        .find((candidate) => fs.existsSync(candidate))
+      || null;
+    return {
+      command: target.command,
+      name: target.name,
+      ok: Boolean(commandPath),
+      path: commandPath,
+      target: target.path,
+      status: commandPath
+        ? (target.path && sameRealPath(commandPath, target.path) ? 'linked' : 'available')
+        : (target.path ? 'missing-command' : 'missing-target'),
+    };
+  });
+}
+
+function packageInstallSpecs() {
+  return [
+    `@anthropic-ai/claude-agent-sdk@${dependencySpec('@anthropic-ai/claude-agent-sdk', 'latest')}`,
+    `@openai/codex@${dependencySpec('@openai/codex', 'latest')}`,
+    `opencode-ai@${dependencySpec('opencode-ai', 'latest')}`,
+  ];
+}
+
+function ensureNativeInstallPackageJson(root) {
+  fs.mkdirSync(root, { recursive: true });
+  const manifest = path.join(root, 'package.json');
+  if (!fs.existsSync(manifest)) {
+    fs.writeFileSync(manifest, `${JSON.stringify({ private: true }, null, 2)}\n`);
+  }
+}
+
+function ensureNativeBinaries(options = {}) {
+  const before = binaryStatus();
+  const missing = before.filter((item) => !item.ok);
+  if (missing.length === 0) {
+    return { ok: true, installed: false, before, after: before };
+  }
+
+  if (process.env.AMALGM_SKIP_NATIVE_INSTALL === '1') {
+    return {
+      ok: false,
+      installed: false,
+      before,
+      after: before,
+      error: new Error(`Missing agent binaries: ${missing.map((item) => item.name).join(', ')}`),
+    };
+  }
+
+  const root = installRoot();
+  ensureNativeInstallPackageJson(root);
+  const args = [
+    'install',
+    '--prefix',
+    root,
+    '--no-audit',
+    '--no-fund',
+    '--include=optional',
+    ...packageInstallSpecs(),
+  ];
+  const logger = options.logger || console;
+  if (!options.quiet) {
+    logger.log?.(`Installing missing agent binaries: ${missing.map((item) => item.name).join(', ')}`);
+  }
+
+  const result = spawnSync(npmCommand(), args, {
+    stdio: options.quiet ? 'pipe' : 'inherit',
+    encoding: 'utf8',
+    shell: process.platform === 'win32',
+    windowsHide: true,
+    env: {
+      ...process.env,
+      npm_config_audit: 'false',
+      npm_config_fund: 'false',
+      npm_config_optional: 'true',
+    },
+    timeout: Number(process.env.AMALGM_NATIVE_INSTALL_TIMEOUT_MS || 180000),
+  });
+
+  const after = binaryStatus();
+  if (result.status === 0 && after.every((item) => item.ok)) {
+    return { ok: true, installed: true, before, after };
+  }
+
+  const stderr = String(result.stderr || '').trim();
+  return {
+    ok: false,
+    installed: result.status === 0,
+    before,
+    after,
+    error: new Error(stderr || `npm install exited with status ${result.status ?? result.signal ?? 'unknown'}`),
+  };
+}
+
+module.exports = {
+  binaryStatus,
+  bundledCodexPathDirs,
+  bundledClaudeBinary: resolveClaudeBinary,
+  bundledCodexBinary,
+  bundledOpenCodeBinary,
+  agentCommandShimStatus,
+  ensureAgentCommandShims,
+  ensureNativeBinaries,
+  executableExists,
+};

package/runtime/scripts/chat-core/tooling/system-prompt.js

@@ -0,0 +1,20 @@
+'use strict';
+
+const { PLATFORM_CONTEXT } = require('../../chat-server/config');
+
+function trimBlock(value) {
+  return String(value || '').trim();
+}
+
+function composeSystemPrompt(contract) {
+  const parts = [];
+  const platform = trimBlock(PLATFORM_CONTEXT);
+  const custom = trimBlock(contract?.systemPrompt);
+  if (platform) parts.push(platform);
+  if (custom) parts.push(custom);
+  return parts.join('\n\n');
+}
+
+module.exports = {
+  composeSystemPrompt,
+};