amalgm 0.0.0 → 0.0.1

package/runtime/scripts/amalgm-mcp/workspace/rest.js

@@ -0,0 +1,389 @@
+/**
+ * /workspace/* REST routes for the Next.js API to call.
+ * Not part of the MCP tool surface — used by the internal UI.
+ */
+
+const fs = require('fs');
+const path = require('path');
+const { execFile } = require('child_process');
+const { promisify } = require('util');
+const { DEFAULT_CWD } = require('../config');
+
+const execFileAsync = promisify(execFile);
+const MAX_BUFFER = 10 * 1024 * 1024;
+const WORKTREE_SUFFIX_RE = /-amalgm-wt-[a-z0-9]+$/;
+
+function isValidWorkspacePath(workspacePath) {
+  return typeof workspacePath === 'string' && workspacePath.length > 0 && path.isAbsolute(workspacePath);
+}
+
+async function runGit(args, cwd) {
+  try {
+    const { stdout, stderr } = await execFileAsync('git', args, {
+      cwd,
+      maxBuffer: MAX_BUFFER,
+    });
+    return { stdout, stderr, exitCode: 0 };
+  } catch (error) {
+    return {
+      stdout: error?.stdout ?? '',
+      stderr: error?.stderr ?? error?.message ?? '',
+      exitCode: typeof error?.code === 'number' ? error.code : 1,
+    };
+  }
+}
+
+async function isGitRepo(workspacePath) {
+  try {
+    await fs.promises.access(workspacePath);
+  } catch {
+    return false;
+  }
+
+  const result = await runGit(['rev-parse', '--git-dir'], workspacePath);
+  return result.exitCode === 0;
+}
+
+async function readBranch(projectPath) {
+  try {
+    const { stdout } = await execFileAsync('git', ['-C', projectPath, 'rev-parse', '--abbrev-ref', 'HEAD']);
+    const branch = stdout.trim();
+    return branch || null;
+  } catch {
+    return null;
+  }
+}
+
+function parseWorktreeList(output) {
+  const worktrees = [];
+  let current = {};
+
+  for (const line of output.trim().split('\n')) {
+    if (line.startsWith('worktree ')) {
+      if (current.path) worktrees.push(current);
+      current = { path: line.slice('worktree '.length).trim(), isMain: false };
+      continue;
+    }
+    if (line.startsWith('HEAD ')) {
+      current.head = line.slice('HEAD '.length).trim();
+      continue;
+    }
+    if (line.startsWith('branch ')) {
+      current.branch = line.slice('branch '.length).trim().replace(/^refs\/heads\//, '');
+      continue;
+    }
+    if (line === 'bare') {
+      current = {};
+      continue;
+    }
+    if (line === '') {
+      if (current.path) worktrees.push(current);
+      current = {};
+    }
+  }
+
+  if (current.path) worktrees.push(current);
+  if (worktrees.length > 0) worktrees[0].isMain = true;
+  return worktrees;
+}
+
+function getLocalWorktreePath(workspacePath, shortId) {
+  const repoBase = path.basename(workspacePath).replace(WORKTREE_SUFFIX_RE, '');
+  return path.join(path.dirname(workspacePath), `${repoBase}-amalgm-wt-${shortId}`);
+}
+
+async function handleProjects(sendJson) {
+  try {
+    const rootDir = DEFAULT_CWD;
+    const dirents = await fs.promises.readdir(rootDir, { withFileTypes: true }).catch(() => []);
+    const projects = [];
+
+    for (const dirent of dirents) {
+      if (!dirent.isDirectory() || dirent.name.startsWith('.')) continue;
+
+      const projectPath = path.join(rootDir, dirent.name);
+      const branch = await readBranch(projectPath);
+
+      projects.push({
+        name: dirent.name,
+        path: projectPath,
+        branch,
+      });
+    }
+
+    projects.sort((a, b) => a.name.localeCompare(b.name));
+    sendJson(200, { projects });
+  } catch (error) {
+    sendJson(500, {
+      error: error instanceof Error ? error.message : 'Failed to list projects',
+    });
+  }
+}
+
+async function handleClone(body, sendJson) {
+  const cloneUrl = body?.clone_url;
+  const repoName = body?.repo_name;
+  const githubToken = typeof body?.githubToken === 'string' ? body.githubToken : '';
+
+  if (!cloneUrl || !repoName) {
+    sendJson(400, { error: 'clone_url and repo_name are required' });
+    return;
+  }
+
+  if (repoName.includes('/') || repoName.includes('..') || repoName.includes('\0')) {
+    sendJson(400, { error: 'Invalid repo name' });
+    return;
+  }
+
+  const targetPath = path.join(DEFAULT_CWD, repoName);
+
+  try {
+    await fs.promises.access(targetPath);
+    if (await isGitRepo(targetPath)) {
+      sendJson(200, { success: true, path: targetPath, alreadyExists: true });
+      return;
+    }
+    sendJson(409, {
+      error: `Directory already exists and is not a Git repository: ${targetPath}`,
+    });
+    return;
+  } catch {
+    // Does not exist yet.
+  }
+
+  const cloneArgs = [];
+  if (githubToken && cloneUrl.includes('github.com')) {
+    const auth = Buffer.from(`x-access-token:${githubToken}`).toString('base64');
+    cloneArgs.push('-c', `http.https://github.com/.extraheader=AUTHORIZATION: basic ${auth}`);
+  }
+  cloneArgs.push('clone', cloneUrl, targetPath);
+
+  const cloneResult = await runGit(cloneArgs, DEFAULT_CWD);
+  if (cloneResult.exitCode !== 0) {
+    sendJson(500, {
+      error: cloneResult.stderr.trim() || cloneResult.stdout.trim() || 'Clone failed',
+    });
+    return;
+  }
+
+  sendJson(200, { success: true, path: targetPath, alreadyExists: false });
+}
+
+async function handleBranches(query, sendJson) {
+  const workspacePath = query?.path;
+  if (!isValidWorkspacePath(workspacePath)) {
+    sendJson(400, { error: 'Invalid path' });
+    return;
+  }
+
+  if (!(await isGitRepo(workspacePath))) {
+    sendJson(200, { branches: [], current: '', hasRemote: false, isGit: false });
+    return;
+  }
+
+  const remoteResult = await runGit(['remote'], workspacePath);
+  const hasRemote = remoteResult.stdout.trim().length > 0;
+  if (hasRemote) {
+    await runGit(['fetch', '--prune'], workspacePath);
+  }
+
+  const currentBranch = (await runGit(['rev-parse', '--abbrev-ref', 'HEAD'], workspacePath)).stdout.trim();
+  const localBranches = (await runGit(['branch', '--format=%(refname:short)'], workspacePath)).stdout
+    .split('\n')
+    .map((line) => line.trim())
+    .filter(Boolean);
+  const remoteBranches = (await runGit(['branch', '-r', '--format=%(refname:short)'], workspacePath)).stdout
+    .split('\n')
+    .map((line) => line.trim())
+    .filter(Boolean);
+
+  const branches = [];
+  const seen = new Set();
+
+  for (const name of localBranches) {
+    if (seen.has(name)) continue;
+    seen.add(name);
+    branches.push({ name, current: name === currentBranch, remote: false });
+  }
+
+  for (const raw of remoteBranches) {
+    if (!raw || raw.includes(' -> ')) continue;
+    const name = raw.replace(/^[^/]+\//, '');
+    if (!name || seen.has(name)) continue;
+    seen.add(name);
+    branches.push({ name, current: name === currentBranch, remote: true });
+  }
+
+  branches.sort((a, b) => {
+    if (a.current && !b.current) return -1;
+    if (!a.current && b.current) return 1;
+    if (!a.remote && b.remote) return -1;
+    if (a.remote && !b.remote) return 1;
+    return a.name.localeCompare(b.name);
+  });
+
+  sendJson(200, { branches, current: currentBranch, hasRemote, isGit: true });
+}
+
+async function handleCheckout(body, sendJson) {
+  const workspacePath = body?.path;
+  const branch = body?.branch;
+
+  if (!isValidWorkspacePath(workspacePath)) {
+    sendJson(400, { error: 'Invalid path' });
+    return;
+  }
+  if (typeof branch !== 'string' || !branch.trim()) {
+    sendJson(400, { error: 'Invalid branch' });
+    return;
+  }
+  if (!(await isGitRepo(workspacePath))) {
+    sendJson(400, { error: 'Not a git repository' });
+    return;
+  }
+
+  const checkoutResult = await runGit(['checkout', branch], workspacePath);
+  const currentBranch = (await runGit(['rev-parse', '--abbrev-ref', 'HEAD'], workspacePath)).stdout.trim() || branch;
+
+  if (checkoutResult.exitCode !== 0) {
+    sendJson(400, {
+      error: checkoutResult.stderr || checkoutResult.stdout || 'Checkout failed',
+      branch: currentBranch,
+    });
+    return;
+  }
+
+  sendJson(200, { success: true, branch: currentBranch });
+}
+
+async function handleDiff(query, sendJson) {
+  const workspacePath = query?.path;
+  if (!isValidWorkspacePath(workspacePath)) {
+    sendJson(400, { error: 'Invalid path' });
+    return;
+  }
+  if (!(await isGitRepo(workspacePath))) {
+    sendJson(200, { isGit: false, files: [], diff: '', additions: 0, deletions: 0 });
+    return;
+  }
+
+  const runDiff = async (...args) => {
+    const withHead = await runGit(['diff', ...args, 'HEAD'], workspacePath);
+    if (withHead.exitCode === 0) return withHead.stdout;
+    return (await runGit(['diff', ...args], workspacePath)).stdout;
+  };
+
+  const stat = (await runDiff('--shortstat')).trim();
+  const diff = (await runDiff()).trim();
+  const changedFiles = (await runDiff('--name-status')).trim();
+  const untracked = (await runGit(['ls-files', '--others', '--exclude-standard'], workspacePath)).stdout.trim();
+
+  let additions = 0;
+  let deletions = 0;
+  const addMatch = stat.match(/(\d+) insertion/);
+  const delMatch = stat.match(/(\d+) deletion/);
+  if (addMatch) additions = parseInt(addMatch[1], 10);
+  if (delMatch) deletions = parseInt(delMatch[1], 10);
+
+  const files = [];
+  for (const line of changedFiles.split('\n').filter(Boolean)) {
+    const [status, ...pathParts] = line.split('\t');
+    if (status && pathParts.length > 0) files.push({ path: pathParts.join('\t'), status: status.trim() });
+  }
+  for (const line of untracked.split('\n').filter(Boolean)) {
+    files.push({ path: line.trim(), status: '?' });
+  }
+
+  sendJson(200, { isGit: true, files, diff, additions, deletions });
+}
+
+async function handleWorktreeList(query, sendJson) {
+  const workspacePath = query?.path;
+  if (!isValidWorkspacePath(workspacePath)) {
+    sendJson(400, { error: 'Invalid path' });
+    return;
+  }
+  if (!(await isGitRepo(workspacePath))) {
+    sendJson(200, { worktrees: [], isGit: false });
+    return;
+  }
+
+  const result = await runGit(['worktree', 'list', '--porcelain'], workspacePath);
+  sendJson(200, { worktrees: parseWorktreeList(result.stdout), isGit: true });
+}
+
+async function handleWorktreeCreate(body, sendJson) {
+  const workspacePath = body?.path;
+  if (!isValidWorkspacePath(workspacePath)) {
+    sendJson(400, { error: 'Invalid path' });
+    return;
+  }
+  if (!(await isGitRepo(workspacePath))) {
+    sendJson(400, { error: 'Not a git repository' });
+    return;
+  }
+
+  const shortId = Math.random().toString(36).slice(2, 8);
+  const currentBranch = (await runGit(['rev-parse', '--abbrev-ref', 'HEAD'], workspacePath)).stdout.trim() || 'HEAD';
+  const worktreePath = getLocalWorktreePath(workspacePath, shortId);
+  const branch = `amalgm-${shortId}-${currentBranch}`;
+  const createResult = await runGit(['worktree', 'add', worktreePath, '-b', branch, 'HEAD'], workspacePath);
+
+  if (createResult.exitCode !== 0) {
+    sendJson(500, {
+      error: `Failed to create worktree: ${createResult.stderr || createResult.stdout}`,
+    });
+    return;
+  }
+
+  sendJson(200, { success: true, worktreePath, branch });
+}
+
+async function handleWorktreeDelete(body, sendJson) {
+  const workspacePath = body?.path;
+  const worktreePath = body?.worktreePath;
+  if (!isValidWorkspacePath(workspacePath)) {
+    sendJson(400, { error: 'Invalid path' });
+    return;
+  }
+  if (!isValidWorkspacePath(worktreePath)) {
+    sendJson(400, { error: 'Invalid worktree path' });
+    return;
+  }
+  if (workspacePath === worktreePath) {
+    sendJson(400, { error: 'Cannot remove the main worktree' });
+    return;
+  }
+  if (!(await isGitRepo(workspacePath))) {
+    sendJson(400, { error: 'Not a git repository' });
+    return;
+  }
+
+  const branch = (await runGit(['-C', worktreePath, 'rev-parse', '--abbrev-ref', 'HEAD'], workspacePath)).stdout.trim();
+  const removeResult = await runGit(['worktree', 'remove', worktreePath, '--force'], workspacePath);
+
+  if (removeResult.exitCode !== 0) {
+    sendJson(500, {
+      error: `Failed to remove worktree: ${removeResult.stderr || removeResult.stdout}`,
+    });
+    return;
+  }
+
+  if (branch.startsWith('amalgm-')) {
+    await runGit(['branch', '-D', branch], workspacePath);
+  }
+  await runGit(['worktree', 'prune'], workspacePath);
+
+  sendJson(200, { success: true });
+}
+
+module.exports = {
+  handleProjects,
+  handleClone,
+  handleBranches,
+  handleCheckout,
+  handleDiff,
+  handleWorktreeList,
+  handleWorktreeCreate,
+  handleWorktreeDelete,
+};

package/runtime/scripts/chat-core/adapters/claude.js

@@ -0,0 +1,163 @@
+'use strict';
+
+const path = require('path');
+const { done, errorEvent, reasoningStarted, usageFinal } = require('../events');
+const { promptText } = require('../input');
+const { runtimeEnv } = require('../auth');
+const { normalizeClaudeMessage, usageRecordsFromClaudeResult, usageFromClaude } = require('../normalizers/claude');
+const { recordNativeEvent } = require('../recorder');
+const { toClaudeMcpServers } = require('../tooling/mcp-bundle');
+const { bundledClaudeBinary } = require('../tooling/native-binaries');
+const { composeSystemPrompt } = require('../tooling/system-prompt');
+
+function redactSecrets(text) {
+  return String(text || '')
+    .replace(/\b(npm_[A-Za-z0-9]{20,})\b/g, '[REDACTED_NPM_TOKEN]')
+    .replace(/\b(sk-[A-Za-z0-9_-]{20,})\b/g, '[REDACTED_API_KEY]')
+    .replace(/\b(sk-ant-[A-Za-z0-9_-]{20,})\b/g, '[REDACTED_ANTHROPIC_KEY]')
+    .replace(/\b(Bearer\s+)[A-Za-z0-9._~+/=-]{20,}/gi, '$1[REDACTED_TOKEN]');
+}
+
+class ClaudeAdapter {
+  async create(contract) {
+    return {
+      sessionId: contract.sessionId,
+      providerSessionId: contract.providerSessionId || null,
+      currentCliModel: contract.cliModel,
+      currentQuery: null,
+      closed: false,
+    };
+  }
+
+  options(contract, extra = {}) {
+    const systemPrompt = composeSystemPrompt(contract);
+    const pathToClaudeCodeExecutable = process.env.CLAUDE_CODE_BINARY || bundledClaudeBinary();
+    return {
+      cwd: contract.cwd,
+      env: runtimeEnv(contract),
+      model: contract.cliModel,
+      ...(pathToClaudeCodeExecutable ? { pathToClaudeCodeExecutable } : {}),
+      ...(systemPrompt ? { systemPrompt: { type: 'preset', preset: 'claude_code', append: systemPrompt } } : {}),
+      mcpServers: toClaudeMcpServers(contract),
+      permissionMode: 'bypassPermissions',
+      allowDangerouslySkipPermissions: true,
+      ...(process.env.CHAT_CORE_DEBUG_CLAUDE === '1'
+        ? { debug: true, debugFile: path.join(contract.auth.runtimeHome || process.cwd(), 'claude-debug.log') }
+        : {}),
+      settingSources: [],
+      strictMcpConfig: false,
+      ...extra,
+    };
+  }
+
+  async resume(session, contract) {
+    session.currentCliModel = contract.cliModel;
+    session.closed = false;
+    return session;
+  }
+
+  async stop(session) {
+    session.currentQuery?.close?.();
+    session.currentQuery = null;
+    session.closed = true;
+  }
+
+  async destroy(session) {
+    session.currentQuery?.close?.();
+    session.currentQuery = null;
+    session.closed = true;
+  }
+
+  async *prompt(session, input, contract) {
+    const contextLimit = Number(contract.contextWindow || 0) || undefined;
+    const state = {
+      providerSessionId: session.providerSessionId,
+      contextLimit,
+      claudeTools: new Map(),
+      claudeCompletedTools: new Set(),
+      claudeUsageSnapshotFingerprints: new Set(),
+    };
+    const stderrChunks = [];
+    const captureStderr = (chunk) => {
+      const text = redactSecrets(String(chunk || ''));
+      if (!text) return;
+      stderrChunks.push(text);
+      while (stderrChunks.length > 20) stderrChunks.shift();
+      if (process.env.CHAT_CORE_DEBUG_CLAUDE === '1' && text.trim()) {
+        console.warn('[Claude]', text.trim().slice(0, 2000));
+      }
+    };
+    try {
+      const sdk = await import('@anthropic-ai/claude-agent-sdk');
+      const query = sdk.query({
+        prompt: promptText(input, contract),
+        options: {
+          ...this.options(contract, { stderr: captureStderr }),
+          ...(session.providerSessionId ? { resume: session.providerSessionId } : {}),
+        },
+      });
+      session.currentQuery = query;
+      session.closed = false;
+      yield reasoningStarted({ providerSessionId: state.providerSessionId });
+      for await (const message of query) {
+        recordNativeEvent('claude.sdk.message', message, {
+          providerSessionId: state.providerSessionId,
+          sessionId: contract.sessionId,
+          assistantMessageId: contract.assistantMessageId,
+        });
+        if (message.session_id) {
+          session.providerSessionId = message.session_id;
+          state.providerSessionId = message.session_id;
+        }
+        const normalized = normalizeClaudeMessage(message, state);
+        if (normalized.length > 0) {
+          for (const e of normalized) yield e;
+          continue;
+        }
+        if (message.type === 'result') {
+          const usageRecords = usageRecordsFromClaudeResult(message, contextLimit);
+          if (usageRecords.length === 0) {
+            usageRecords.push(usageFromClaude(message.usage, contextLimit));
+          }
+          for (const [index, usageRecord] of usageRecords.entries()) {
+            yield usageFinal({
+              ...usageRecord,
+              costUsd: usageRecords.length === 1 ? message.total_cost_usd ?? null : null,
+            }, {
+              providerSessionId: state.providerSessionId,
+              raw: {
+                source: 'claude.sdk.message',
+                method: 'claude/result',
+                payload: {
+                  ...message,
+                  usageRecordIndex: index,
+                  usageRecordCount: usageRecords.length,
+                },
+              },
+            });
+          }
+          if (message.is_error) {
+            yield errorEvent(message.errors?.join('\n') || message.stop_reason || 'Claude turn failed', {
+              providerSessionId: state.providerSessionId,
+              raw: { source: 'claude.sdk.message', method: 'claude/result', payload: message },
+            });
+          }
+          yield done({
+            providerSessionId: state.providerSessionId,
+            stopReason: message.stop_reason || 'end_turn',
+            raw: { source: 'claude.sdk.message', method: 'claude/result', payload: message },
+          });
+        }
+      }
+    } catch (err) {
+      const stderrTail = stderrChunks.join('').trim().slice(-3000);
+      const message = stderrTail ? `${err.message}\n${stderrTail}` : err.message;
+      yield errorEvent(message, { providerSessionId: session.providerSessionId });
+      yield done({ providerSessionId: session.providerSessionId, stopReason: session.closed ? 'cancelled' : 'error' });
+    } finally {
+      session.currentQuery = null;
+    }
+  }
+}
+
+module.exports = { ClaudeAdapter };