@gakim-digital/dexter-bridge 0.5.0

package/src/providers/claudeAgentSdk.js

@@ -0,0 +1,508 @@
+import { spawn } from 'node:child_process';
+import { normalizeCompanionTokenUsage } from '../agentOutput.js';
+
+const MAX_CLI_OUTPUT_BYTES = 1024 * 1024;
+const OFFICIAL_AUTH_HOSTS = new Set([
+  'anthropic.com',
+  'claude.com',
+]);
+
+function text(value, maximum = 4096) {
+  return typeof value === 'string' && value.trim()
+    ? value.trim().slice(0, maximum)
+    : '';
+}
+
+function isOfficialAuthHost(hostname) {
+  const normalized = String(hostname || '').toLowerCase();
+  for (const host of OFFICIAL_AUTH_HOSTS) {
+    if (normalized === host || normalized.endsWith(`.${host}`)) return true;
+  }
+  return false;
+}
+
+export function normalizeClaudeAuthorizationUrl(value) {
+  const raw = text(value, 8192);
+  if (!raw) throw new Error('Claude login did not return an authorization URL.');
+  const parsed = new URL(raw);
+  if (parsed.protocol !== 'https:' || !isOfficialAuthHost(parsed.hostname)) {
+    throw new Error('Claude login returned an untrusted authorization URL.');
+  }
+  if (parsed.username || parsed.password) {
+    throw new Error('Claude login returned an authorization URL with embedded credentials.');
+  }
+  return parsed.toString();
+}
+
+export function extractClaudeAuthorizationUrl(value) {
+  const matches = String(value || '').match(/https:\/\/[^\s\u0007\u001b]+/g) || [];
+  for (const candidate of matches) {
+    try {
+      return normalizeClaudeAuthorizationUrl(candidate);
+    } catch {
+      // Ignore terminal noise and non-Anthropic links.
+    }
+  }
+  return null;
+}
+
+function authorizationCode(value) {
+  const normalized = text(value, 4096);
+  if (normalized.length < 4 || /[\u0000-\u001f\u007f]/.test(normalized)) {
+    throw new Error('Claude authorization code is invalid.');
+  }
+  return normalized;
+}
+
+function boundedOutput(current, chunk) {
+  return `${current}${chunk.toString('utf8')}`.slice(-MAX_CLI_OUTPUT_BYTES);
+}
+
+export function runClaudeCommand({
+  command,
+  args,
+  env,
+  cwd,
+  timeoutMs = 20_000,
+  spawnImpl = spawn,
+} = {}) {
+  return new Promise((resolve, reject) => {
+    const child = spawnImpl(command, args, {
+      cwd,
+      env,
+      stdio: ['ignore', 'pipe', 'pipe'],
+    });
+    let stdout = '';
+    let stderr = '';
+    let settled = false;
+    const timer = setTimeout(() => {
+      if (settled) return;
+      settled = true;
+      child.kill('SIGTERM');
+      reject(Object.assign(new Error(`Claude command timed out after ${timeoutMs}ms.`), {
+        code: 'CLAUDE_COMMAND_TIMEOUT',
+      }));
+    }, timeoutMs);
+    timer.unref?.();
+
+    child.stdout.on('data', (chunk) => {
+      stdout = boundedOutput(stdout, chunk);
+    });
+    child.stderr.on('data', (chunk) => {
+      stderr = boundedOutput(stderr, chunk);
+    });
+    child.once('error', (error) => {
+      if (settled) return;
+      settled = true;
+      clearTimeout(timer);
+      reject(error);
+    });
+    child.once('close', (code, signal) => {
+      if (settled) return;
+      settled = true;
+      clearTimeout(timer);
+      resolve({ code: Number(code), signal, stdout, stderr });
+    });
+  });
+}
+
+export async function startClaudeLogin({
+  command,
+  env,
+  cwd,
+  timeoutMs = 10 * 60 * 1000,
+  spawnImpl = spawn,
+} = {}) {
+  const child = spawnImpl(command, ['auth', 'login', '--claudeai'], {
+    cwd,
+    env,
+    stdio: ['pipe', 'pipe', 'pipe'],
+  });
+  let output = '';
+  let settled = false;
+  let codeSubmitted = false;
+  let resolveUrl;
+  let rejectUrl;
+  let resolveCompleted;
+  let rejectCompleted;
+
+  const urlReady = new Promise((resolve, reject) => {
+    resolveUrl = resolve;
+    rejectUrl = reject;
+  });
+  const completed = new Promise((resolve, reject) => {
+    resolveCompleted = resolve;
+    rejectCompleted = reject;
+  });
+  // The process can fail before the URL parser returns. Mark the rejection as
+  // observed now; callers still receive the original rejecting promise.
+  completed.catch(() => undefined);
+
+  function finishError(error) {
+    if (settled) return;
+    settled = true;
+    clearTimeout(timer);
+    rejectUrl(error);
+    rejectCompleted(error);
+  }
+
+  function inspect(chunk) {
+    output = boundedOutput(output, chunk);
+    const url = extractClaudeAuthorizationUrl(output);
+    if (url) resolveUrl(url);
+  }
+
+  child.stdout.on('data', inspect);
+  child.stderr.on('data', inspect);
+  child.once('error', finishError);
+  child.once('close', (code, signal) => {
+    if (settled) return;
+    settled = true;
+    clearTimeout(timer);
+    if (code === 0) {
+      resolveCompleted({ ok: true });
+      return;
+    }
+    const error = Object.assign(
+      new Error(`Claude login exited before authorization completed${signal ? ` (${signal})` : ''}.`),
+      { code: 'CLAUDE_LOGIN_FAILED' },
+    );
+    rejectUrl(error);
+    rejectCompleted(error);
+  });
+
+  const timer = setTimeout(() => {
+    const error = Object.assign(new Error('Claude sign-in timed out.'), {
+      code: 'CLAUDE_LOGIN_TIMEOUT',
+    });
+    try {
+      child.kill('SIGTERM');
+    } catch {
+      // Process already exited.
+    }
+    finishError(error);
+  }, timeoutMs);
+  timer.unref?.();
+
+  const verificationUrl = await urlReady;
+  return {
+    kind: 'authorization_code',
+    loginId: `claude_${Date.now()}_${Math.random().toString(36).slice(2, 10)}`,
+    verificationUrl,
+    userCode: null,
+    completed,
+    submitAuthorizationCode(value) {
+      if (settled) throw new Error('Claude login is no longer active.');
+      if (codeSubmitted) throw new Error('Claude authorization code was already submitted.');
+      codeSubmitted = true;
+      child.stdin.write(`${authorizationCode(value)}\n`);
+    },
+    cancel() {
+      if (settled) return;
+      try {
+        child.kill('SIGTERM');
+      } catch {
+        // Process already exited.
+      }
+    },
+  };
+}
+
+function normalizeClaudeUsage(usage = {}) {
+  const normalized = normalizeCompanionTokenUsage({
+    inputTokens: usage.input_tokens ?? usage.inputTokens,
+    outputTokens: usage.output_tokens ?? usage.outputTokens,
+    cacheReadInputTokens: usage.cache_read_input_tokens ?? usage.cacheReadInputTokens,
+    cacheCreationInputTokens:
+      usage.cache_creation_input_tokens ?? usage.cacheCreationInputTokens,
+  });
+  return normalized;
+}
+
+export function normalizeClaudeModels(rows) {
+  const models = Array.isArray(rows) ? rows : [];
+  return models
+    .filter((row) => row && typeof row.value === 'string' && row.value.trim())
+    .map((row, index) => ({
+      id: `claude-code:${row.value.trim()}`,
+      agent: 'claude-code',
+      provider: 'anthropic',
+      displayName: text(row.displayName, 255) || row.value.trim(),
+      invocationName: row.value.trim(),
+      costTier: '$$',
+      description: text(row.description, 2000) || 'Claude Code model.',
+      isDefault: row.value === 'default' || index === 0,
+    }));
+}
+
+function holdOpenInput(signal) {
+  return {
+    async *[Symbol.asyncIterator]() {
+      if (signal.aborted) return;
+      await new Promise((resolve) => {
+        signal.addEventListener('abort', resolve, { once: true });
+      });
+    },
+  };
+}
+
+export function createClaudeAgentSdkAdapter({
+  queryImpl,
+  command = process.env.DEXTER_HOSTED_CLAUDE_BIN || 'claude',
+  env = process.env,
+  cwd = '/workspace',
+  configDir = env.CLAUDE_CONFIG_DIR || `${env.HOME || '/home/dexter'}/.claude`,
+  runCommand = runClaudeCommand,
+  startLogin = startClaudeLogin,
+  trace,
+} = {}) {
+  if (typeof queryImpl !== 'function') {
+    throw new Error('Claude Agent SDK query implementation is required.');
+  }
+  const activeTurns = new Map();
+  let activeLogin = null;
+
+  function processEnv() {
+    const inherited = {};
+    const allowed = [
+      'PATH',
+      'HOME',
+      'LANG',
+      'LC_ALL',
+      'TMPDIR',
+      'HTTPS_PROXY',
+      'HTTP_PROXY',
+      'NO_PROXY',
+      'SSL_CERT_FILE',
+      'SSL_CERT_DIR',
+      'NODE_EXTRA_CA_CERTS',
+    ];
+    for (const name of allowed) {
+      if (typeof env[name] === 'string' && env[name]) inherited[name] = env[name];
+    }
+    for (const [name, value] of Object.entries(env)) {
+      if (name.startsWith('LC_') && typeof value === 'string' && value) inherited[name] = value;
+    }
+    return {
+      ...inherited,
+      CLAUDE_CONFIG_DIR: configDir,
+      CLAUDE_AGENT_SDK_CLIENT_APP: 'dexter-hosted-worker/0.2.0',
+    };
+  }
+
+  function baseOptions(abortController) {
+    return {
+      abortController,
+      cwd,
+      env: processEnv(),
+      tools: [],
+      allowedTools: [],
+      mcpServers: {},
+      strictMcpConfig: true,
+      skills: [],
+      extraArgs: { 'safe-mode': null },
+      settingSources: [],
+      permissionMode: 'dontAsk',
+      persistSession: false,
+    };
+  }
+
+  async function withControlQuery(operation) {
+    const abortController = new AbortController();
+    const control = queryImpl({
+      prompt: holdOpenInput(abortController.signal),
+      options: baseOptions(abortController),
+    });
+    try {
+      return await operation(control);
+    } finally {
+      abortController.abort();
+      control.close?.();
+    }
+  }
+
+  async function detect() {
+    try {
+      const result = await runCommand({
+        command,
+        args: ['auth', 'status', '--json'],
+        env: processEnv(),
+        cwd,
+      });
+      let status = {};
+      try {
+        status = JSON.parse(result.stdout || result.stderr || '{}');
+      } catch {
+        status = {};
+      }
+      const signedIn = Boolean(status.loggedIn);
+      let account = null;
+      if (signedIn) {
+        account = await withControlQuery((control) => control.accountInfo()).catch(() => null);
+      }
+      return {
+        ok: true,
+        installed: true,
+        signedIn,
+        agent: 'claude-code',
+        plan: account?.subscriptionType || status.subscriptionType || null,
+        account: account || status,
+        authMethod: status.authMethod || null,
+        apiProvider: account?.apiProvider || status.apiProvider || null,
+      };
+    } catch (error) {
+      return {
+        ok: false,
+        installed: false,
+        signedIn: false,
+        agent: 'claude-code',
+        error: error?.message || String(error || ''),
+      };
+    }
+  }
+
+  async function authenticate({ timeoutMs } = {}) {
+    if (activeLogin) throw new Error('Claude authentication is already active.');
+    const login = await startLogin({
+      command,
+      env: processEnv(),
+      cwd,
+      timeoutMs,
+    });
+    activeLogin = login;
+    login.completed.finally(() => {
+      if (activeLogin === login) activeLogin = null;
+    }).catch(() => undefined);
+    return login;
+  }
+
+  function submitAuthenticationCode(loginId, code) {
+    if (!activeLogin) throw new Error('Claude authentication is not active.');
+    if (loginId && activeLogin.loginId !== loginId) {
+      throw new Error('Claude authentication attempt does not match.');
+    }
+    activeLogin.submitAuthorizationCode(code);
+  }
+
+  async function cancelAuthentication(loginId) {
+    if (!activeLogin) return;
+    if (loginId && activeLogin.loginId !== loginId) return;
+    activeLogin.cancel();
+    activeLogin = null;
+  }
+
+  async function models() {
+    return withControlQuery(async (control) => {
+      const rows = await control.supportedModels();
+      return normalizeClaudeModels(rows);
+    });
+  }
+
+  async function runModelTurn({
+    runId,
+    sessionId,
+    prompt,
+    model,
+    timeoutMs = 180_000,
+  } = {}) {
+    const turnKey = sessionId || runId;
+    if (!turnKey) throw new Error('Claude model turn requires a session id.');
+    if (activeTurns.has(turnKey)) throw new Error('Claude model turn is already active.');
+
+    const abortController = new AbortController();
+    const control = queryImpl({
+      prompt,
+      options: {
+        ...baseOptions(abortController),
+        ...(model ? { model } : {}),
+        maxTurns: 1,
+      },
+    });
+    const active = { abortController, control, cancelled: false };
+    activeTurns.set(turnKey, active);
+    const timeout = setTimeout(() => {
+      active.cancelled = true;
+      abortController.abort();
+      control.close?.();
+    }, timeoutMs);
+    timeout.unref?.();
+
+    try {
+      let result = null;
+      for await (const message of control) {
+        if (message?.type === 'result') result = message;
+      }
+      if (active.cancelled || abortController.signal.aborted) {
+        throw Object.assign(new Error('Claude model turn was cancelled.'), {
+          code: 'RUN_CANCELLED',
+        });
+      }
+      if (!result) throw new Error('Claude Agent SDK ended without a result.');
+      if (result.subtype !== 'success' || result.is_error) {
+        throw Object.assign(
+          new Error(result.errors?.join(' ') || `Claude Agent SDK returned ${result.subtype}.`),
+          { code: 'CLAUDE_AGENT_RESULT_ERROR' },
+        );
+      }
+      return {
+        text: result.result || '',
+        sessionId: result.session_id || null,
+        tokenUsage: normalizeClaudeUsage(result.usage),
+        usageAvailable: true,
+        usageSource: 'claude-agent-sdk',
+        usageAccuracy: 'reported',
+      };
+    } catch (error) {
+      if (active.cancelled || abortController.signal.aborted || error?.name === 'AbortError') {
+        throw Object.assign(new Error('Claude model turn was cancelled.'), {
+          code: 'RUN_CANCELLED',
+        });
+      }
+      throw error;
+    } finally {
+      clearTimeout(timeout);
+      if (activeTurns.get(turnKey) === active) activeTurns.delete(turnKey);
+      control.close?.();
+      trace?.info?.('claude_agent_turn_closed', { sessionId: turnKey });
+    }
+  }
+
+  async function cancel(sessionId) {
+    const active = activeTurns.get(sessionId);
+    if (!active) return;
+    active.cancelled = true;
+    active.abortController.abort();
+    active.control.close?.();
+  }
+
+  async function logout() {
+    await cancelAuthentication();
+    await runCommand({
+      command,
+      args: ['auth', 'logout'],
+      env: processEnv(),
+      cwd,
+    });
+  }
+
+  function close() {
+    cancelAuthentication().catch(() => undefined);
+    for (const [sessionId] of activeTurns) {
+      cancel(sessionId).catch(() => undefined);
+    }
+  }
+
+  return {
+    id: 'claude-code',
+    label: 'Claude Code',
+    detect,
+    authenticate,
+    submitAuthenticationCode,
+    cancelAuthentication,
+    models,
+    runModelTurn,
+    cancel,
+    logout,
+    close,
+  };
+}