wtt-connect 0.1.0

package/src/adapter-registry.js

@@ -0,0 +1,58 @@
+import { createAdapter, normalizeAdapterName } from './adapters/index.js';
+
+export class AdapterRegistry {
+  constructor(config, deps = {}) {
+    this.config = config;
+    this.adapters = new Map();
+    const names = config.adapters?.length ? config.adapters : [config.adapter || 'codex'];
+    for (const name of names) {
+      const normalized = normalizeAdapterName(name);
+      const adapterConfig = { ...config, adapter: normalized };
+      this.adapters.set(normalized, createAdapter(adapterConfig, deps));
+    }
+    this.defaultName = normalizeAdapterName(config.adapter || names[0] || 'codex');
+  }
+
+  default() {
+    return this.get(this.defaultName);
+  }
+
+  get(name) {
+    const adapter = this.adapters.get(normalizeAdapterName(name)) || this.adapters.get(this.defaultName);
+    if (!adapter) throw new Error(`adapter not configured: ${name}`);
+    return adapter;
+  }
+
+  select(input = {}) {
+    const explicit = String(input.adapter || input.exec_mode || input.execMode || '').trim().toLowerCase();
+    if (explicit && this.adapters.has(normalizeAdapterName(explicit))) return this.get(normalizeAdapterName(explicit));
+    const type = String(input.task_type || input.taskType || '').trim().toLowerCase();
+    if (type && this.config.adapterPolicy?.[type]) return this.get(this.config.adapterPolicy[type]);
+    const text = `${input.title || ''}\n${input.description || ''}\n${input.content || ''}`.toLowerCase();
+    for (const alias of adapterMentionAliases()) {
+      if (text.includes(`@${alias}`) && this.adapters.has(normalizeAdapterName(alias))) return this.get(alias);
+    }
+    return this.default();
+  }
+
+  list() {
+    return [...this.adapters.keys()];
+  }
+}
+
+function adapterMentionAliases() {
+  return [
+    'codex',
+    'claude', 'claude-code',
+    'cursor', 'cursor-agent',
+    'gemini',
+    'qoder',
+    'opencode', 'crush',
+    'iflow',
+    'kimi',
+    'pi',
+    'acp',
+    'devin',
+    'openclaw',
+  ];
+}

package/src/adapters/acp.js

@@ -0,0 +1,196 @@
+import { spawn } from 'node:child_process';
+import readline from 'node:readline';
+import { log } from '../logger.js';
+
+export class AcpAdapter {
+  constructor(config, deps = {}) {
+    this.config = config;
+    this.store = deps.store;
+    this.name = config.adapter === 'devin' ? 'devin' : 'acp';
+  }
+
+  async run(prompt, context = {}) {
+    const sessionKey = context.sessionKey || 'default';
+    const stored = this.store?.getSession(sessionKey) || {};
+    const bin = this.config.acpCommand || this.config.acpBin || 'acp-agent';
+    const args = this.config.acpArgs || [];
+    const resumeSessionId = stored.acpSessionId || (this.name === 'devin' ? stored.devinSessionId : '');
+    log('info', `${this.name} launch`, { sessionKey, resume: Boolean(resumeSessionId), command: bin });
+    const result = await runAcpTurn({
+      bin,
+      args,
+      cwd: this.config.workDir,
+      prompt,
+      resumeSessionId,
+      timeoutMs: this.config.taskTimeoutSeconds * 1000,
+      mode: this.config.mode,
+      displayName: this.config.acpDisplayName || (this.name === 'devin' ? 'Devin' : 'ACP Agent'),
+      context,
+    });
+    if (result.sessionId) {
+      const patch = { acpSessionId: result.sessionId, adapter: this.name };
+      if (this.name === 'devin') patch.devinSessionId = result.sessionId;
+      this.store?.patchSession(sessionKey, patch);
+    }
+    return result.text.trim();
+  }
+}
+
+function runAcpTurn({ bin, args, cwd, prompt, resumeSessionId, timeoutMs, mode, displayName, context }) {
+  return new Promise((resolve, reject) => {
+    const child = spawn(bin, args, { cwd, stdio: ['pipe', 'pipe', 'pipe'], env: { ...process.env } });
+    const rpc = new JsonRpc(child);
+    let stderr = '';
+    let sessionId = '';
+    const chunks = [];
+    const timer = setTimeout(() => {
+      child.kill('SIGTERM');
+      reject(new Error(`${bin} timed out after ${timeoutMs}ms`));
+    }, timeoutMs);
+
+    child.stderr.on('data', (d) => { stderr += d.toString(); });
+    child.on('error', (err) => { clearTimeout(timer); reject(err); });
+    child.on('close', (code) => {
+      clearTimeout(timer);
+      if (code !== 0 && !rpc.resolved) reject(new Error(`${bin} exited ${code}: ${stderr.trim()}`));
+    });
+
+    rpc.onNotification = (method, params) => {
+      if (method !== 'session/update') return;
+      const text = extractAcpUpdateText(params);
+      if (text) chunks.push(text);
+      if (context.onProgress) context.onProgress({ method, params }).catch(() => {});
+    };
+    rpc.onRequest = async (method, id) => {
+      // Keep the MVP fail-closed for permission prompts; concrete permission
+      // brokering can be layered in the same way Codex modes are brokered.
+      if (method === 'session/request_permission') {
+        await rpc.respond(id, { outcome: { outcome: 'cancelled' } });
+        return;
+      }
+      await rpc.respondError(id, -32601, `method not implemented: ${method}`);
+    };
+
+    (async () => {
+      try {
+        const init = await rpc.call('initialize', {
+          protocolVersion: 1,
+          clientCapabilities: {
+            fs: { readTextFile: false, writeTextFile: false },
+            terminal: false,
+          },
+          clientInfo: { name: 'wtt-connect', version: '0.1.0' },
+        });
+        const canLoad = Boolean(init?.agentCapabilities?.loadSession || init?.agentCapabilities?.sessionCapabilities?.load);
+        let session;
+        if (resumeSessionId && canLoad) {
+          try {
+            session = await rpc.call('session/load', { sessionId: resumeSessionId, cwd, mcpServers: [] });
+          } catch {
+            session = null;
+          }
+        }
+        if (!session) session = await rpc.call('session/new', { cwd, mcpServers: [] });
+        sessionId = session?.sessionId;
+        if (!sessionId) throw new Error('acp: empty sessionId');
+        await maybeSetMode(rpc, session, sessionId, mode);
+        const fullPrompt = appendAttachmentRefs(prompt, context);
+        await rpc.call('session/prompt', {
+          sessionId,
+          prompt: [{ type: 'text', text: fullPrompt }],
+        });
+        rpc.resolved = true;
+        child.kill('SIGTERM');
+        clearTimeout(timer);
+        resolve({ text: chunks.join('').trim(), sessionId });
+      } catch (err) {
+        child.kill('SIGTERM');
+        clearTimeout(timer);
+        reject(err);
+      }
+    })();
+  });
+}
+
+class JsonRpc {
+  constructor(child) {
+    this.child = child;
+    this.nextId = 1;
+    this.pending = new Map();
+    this.onNotification = () => {};
+    this.onRequest = async () => {};
+    this.resolved = false;
+    const rl = readline.createInterface({ input: child.stdout });
+    rl.on('line', (line) => this.handleLine(line));
+  }
+
+  call(method, params) {
+    const id = this.nextId++;
+    this.write({ jsonrpc: '2.0', id, method, params });
+    return new Promise((resolve, reject) => this.pending.set(String(id), { resolve, reject }));
+  }
+
+  respond(id, result) {
+    this.write({ jsonrpc: '2.0', id, result });
+  }
+
+  respondError(id, code, message) {
+    this.write({ jsonrpc: '2.0', id, error: { code, message } });
+  }
+
+  write(payload) {
+    this.child.stdin.write(`${JSON.stringify(payload)}\n`);
+  }
+
+  handleLine(line) {
+    if (!line.trim()) return;
+    let msg;
+    try { msg = JSON.parse(line); } catch { return; }
+    if (Object.hasOwn(msg, 'id') && (Object.hasOwn(msg, 'result') || Object.hasOwn(msg, 'error'))) {
+      const pending = this.pending.get(String(msg.id));
+      if (!pending) return;
+      this.pending.delete(String(msg.id));
+      if (msg.error) pending.reject(new Error(msg.error.message || JSON.stringify(msg.error)));
+      else pending.resolve(msg.result);
+      return;
+    }
+    if (msg.method && Object.hasOwn(msg, 'id')) {
+      this.onRequest(msg.method, msg.id, msg.params).catch(() => {});
+      return;
+    }
+    if (msg.method) this.onNotification(msg.method, msg.params);
+  }
+}
+
+async function maybeSetMode(rpc, session, sessionId, mode) {
+  const normalized = String(mode || '').trim().toLowerCase().replace(/_/g, '-');
+  if (!normalized || normalized === 'default' || normalized === 'full-auto') return;
+  const modes = session?.modes?.availableModes || session?.modes?.modes || [];
+  const ids = Array.isArray(modes) ? modes.map((m) => m.id || m.modeId || m.name).filter(Boolean) : [];
+  if (ids.length && !ids.includes(normalized)) return;
+  try { await rpc.call('session/set_mode', { sessionId, modeId: normalized }); } catch {}
+}
+
+function extractAcpUpdateText(params) {
+  const update = params?.update || params?.sessionUpdate || params;
+  if (!update) return '';
+  const kind = update.sessionUpdate || update.type || update.kind;
+  if (kind === 'agent_message_chunk' || kind === 'reasoning_chunk') return update.content || update.text || update.delta || '';
+  if (kind === 'agent_message') return valueToText(update.content || update.message || update.text);
+  return '';
+}
+
+function valueToText(value) {
+  if (!value) return '';
+  if (typeof value === 'string') return value;
+  if (Array.isArray(value)) return value.map(valueToText).join('');
+  if (typeof value === 'object') return value.text || value.content || '';
+  return '';
+}
+
+function appendAttachmentRefs(prompt, context = {}) {
+  const refs = [];
+  if (context.images?.length) refs.push(`Attached images: ${context.images.join(', ')}`);
+  if (context.files?.length) refs.push(`Attached files: ${context.files.join(', ')}`);
+  return refs.length ? `${prompt}\n\n${refs.join('\n')}` : prompt;
+}

package/src/adapters/claude-code.js

@@ -0,0 +1,161 @@
+import { spawn } from 'node:child_process';
+import readline from 'node:readline';
+import { log } from '../logger.js';
+
+export class ClaudeCodeAdapter {
+  constructor(config) {
+    this.config = config;
+    this.name = 'claude-code';
+  }
+
+  async run(prompt, context = {}) {
+    if (context.images?.length && this.config.codexBin) {
+      log('info', 'claude-code image fallback via codex', { sessionKey: context.sessionKey || 'default', images: context.images.length });
+      return runCodexVision(this.config.codexBin, prompt, context.images, this.config.workDir, this.config.taskTimeoutSeconds * 1000, this.config);
+    }
+    // Claude Code 2.x requires --verbose when stream-json is used with --print/-p.
+    const args = ['-p', prompt, '--output-format', 'stream-json', '--verbose'];
+    if (this.config.mode === 'yolo') args.push('--dangerously-skip-permissions', '--permission-mode', 'bypassPermissions');
+    if (this.config.model) args.push('--model', this.config.model);
+    log('info', 'claude-code launch', { sessionKey: context.sessionKey || 'default' });
+    return runClaude(this.config.claudeBin, args, this.config.workDir, this.config.taskTimeoutSeconds * 1000);
+  }
+}
+
+function runClaude(bin, args, cwd, timeoutMs) {
+  return new Promise((resolve, reject) => {
+    const child = spawn(bin, args, { cwd, stdio: ['ignore', 'pipe', 'pipe'], env: { ...process.env } });
+    let stderr = '';
+    let finalResult = '';
+    let streamError = '';
+    const rawLines = [];
+    const assistantTexts = [];
+    const timer = setTimeout(() => { child.kill('SIGTERM'); reject(new Error(`${bin} timed out`)); }, timeoutMs);
+    child.stderr.on('data', (d) => { stderr += d.toString(); });
+    child.on('error', (err) => { clearTimeout(timer); reject(err); });
+    const rl = readline.createInterface({ input: child.stdout });
+    rl.on('line', (line) => {
+      try {
+        rawLines.push(line);
+        if (rawLines.length > 20) rawLines.shift();
+        const ev = JSON.parse(line);
+        const evError = extractEventError(ev);
+        if (evError) streamError = evError;
+        if (typeof ev.result === 'string' && ev.result.trim()) {
+          finalResult = ev.result.trim();
+          return;
+        }
+        const t = extractAssistantText(ev);
+        if (t) assistantTexts.push(t);
+      } catch {}
+    });
+    child.on('close', (code) => {
+      clearTimeout(timer);
+      if (code !== 0) reject(new Error(`${bin} exited ${code}: ${errorDetail({ stderr, streamError, finalResult, rawLines })}`));
+      else resolve((finalResult || dedupeAdjacent(assistantTexts).join('\n')).trim());
+    });
+  });
+}
+
+async function runCodexVision(bin, prompt, images, cwd, timeoutMs, config = {}) {
+  const args = ['exec', '--skip-git-repo-check', '--json', '--cd', cwd];
+  if (config.mode === 'yolo') args.push('--dangerously-bypass-approvals-and-sandbox');
+  for (const img of images || []) args.push('--image', img);
+  args.push('-');
+  return new Promise((resolve, reject) => {
+    const child = spawn(bin, args, { cwd, stdio: ['pipe', 'pipe', 'pipe'], env: { ...process.env } });
+    let stderr = '';
+    const messages = [];
+    const timer = setTimeout(() => {
+      child.kill('SIGTERM');
+      reject(new Error(`${bin} vision fallback timed out after ${timeoutMs}ms`));
+    }, timeoutMs);
+    child.stderr.on('data', (d) => { stderr += d.toString(); });
+    child.on('error', (err) => { clearTimeout(timer); reject(err); });
+    const rl = readline.createInterface({ input: child.stdout });
+    rl.on('line', (line) => {
+      if (!line.trim()) return;
+      try {
+        const event = JSON.parse(line);
+        const text = extractCodexText(event);
+        if (text) messages.push(text);
+      } catch {}
+    });
+    child.on('close', (code) => {
+      clearTimeout(timer);
+      if (code !== 0) reject(new Error(`${bin} vision fallback exited ${code}: ${truncate(stderr.trim(), 1200)}`));
+      else {
+        const finalMessages = dedupeAdjacent(messages);
+        resolve((finalMessages[finalMessages.length - 1] || '').trim());
+      }
+    });
+    child.stdin.end(prompt);
+  });
+}
+
+function extractCodexText(event) {
+  if (event.type !== 'item.completed' || !event.item) return '';
+  const item = event.item;
+  if (!['agent_message', 'message'].includes(item.type)) return '';
+  if (typeof item.text === 'string') return item.text;
+  if (typeof item.content === 'string') return item.content;
+  if (typeof item.output_text === 'string') return item.output_text;
+  if (Array.isArray(item.content)) return item.content.map((p) => p?.text || p?.content || '').filter(Boolean).join('\n');
+  return '';
+}
+
+function extractEventError(ev) {
+  if (!ev) return '';
+  if (typeof ev.error === 'string') return ev.error;
+  if (ev.error?.message) return ev.error.message;
+  if (ev.is_error && typeof ev.result === 'string') return ev.result;
+  const text = extractAssistantText(ev);
+  if (text && /^api error:|^error:/i.test(text.trim())) return text.trim();
+  return '';
+}
+
+function errorDetail({ stderr, streamError, finalResult, rawLines }) {
+  const detail = [stderr, streamError, finalResult].map((x) => String(x || '').trim()).find(Boolean)
+    || summarizeRawLines(rawLines)
+    || 'no stderr/stdout detail';
+  return truncate(detail, 1200);
+}
+
+function summarizeRawLines(rawLines = []) {
+  const lines = rawLines.map((line) => {
+    try {
+      const ev = JSON.parse(line);
+      return extractEventError(ev) || extractAssistantText(ev) || ev.type || '';
+    } catch {
+      return line;
+    }
+  }).map((x) => String(x || '').trim()).filter(Boolean);
+  return dedupeAdjacent(lines).join('\n');
+}
+
+function extractAssistantText(ev) {
+  if (!ev || ev.type !== 'assistant') return '';
+  const parts = ev.message?.content;
+  if (Array.isArray(parts)) {
+    return parts
+      .filter((x) => x?.type === 'text')
+      .map((x) => x.text || '')
+      .filter(Boolean)
+      .join('');
+  }
+  if (typeof ev.content === 'string') return ev.content;
+  return '';
+}
+
+function dedupeAdjacent(texts) {
+  const out = [];
+  for (const text of texts.map((x) => String(x || '').trim()).filter(Boolean)) {
+    if (out[out.length - 1] !== text) out.push(text);
+  }
+  return out;
+}
+
+function truncate(text, max) {
+  const s = String(text || '');
+  return s.length > max ? `${s.slice(0, max)}...` : s;
+}

package/src/adapters/codex.js

@@ -0,0 +1,88 @@
+import { spawn } from 'node:child_process';
+import readline from 'node:readline';
+import { log } from '../logger.js';
+
+export class CodexAdapter {
+  constructor(config, deps = {}) {
+    this.config = config;
+    this.permissions = deps.permissions;
+    this.store = deps.store;
+    this.name = 'codex';
+    this.threadBySession = new Map();
+  }
+
+  async run(prompt, context = {}) {
+    const sessionKey = context.sessionKey || 'default';
+    const stored = this.store?.getSession(sessionKey) || {};
+    const threadId = this.threadBySession.get(sessionKey) || stored.codexThreadId;
+    const args = this.buildArgs(threadId, context);
+    log('info', 'codex launch', { sessionKey, resume: Boolean(threadId), mode: this.config.mode });
+    const result = await runJsonCli(this.config.codexBin, args, prompt, this.config.workDir, (event) => {
+      const eventThreadId = event.thread_id || event.session_id || event.conversation_id;
+      if ((event.type === 'thread.started' || event.type === 'session.started') && eventThreadId) {
+        this.threadBySession.set(sessionKey, eventThreadId);
+        this.store?.patchSession(sessionKey, { codexThreadId: eventThreadId, adapter: this.name });
+      }
+      if (this.config.publishProgress && context.onProgress) context.onProgress(event).catch(() => {});
+    }, this.config.taskTimeoutSeconds * 1000);
+    if (result.threadId) {
+      this.threadBySession.set(sessionKey, result.threadId);
+      this.store?.patchSession(sessionKey, { codexThreadId: result.threadId, adapter: this.name });
+    }
+    return result.text.trim();
+  }
+
+  buildArgs(threadId, context = {}) {
+    const options = ['--skip-git-repo-check', '--json'];
+    options.push(...(this.permissions?.codexArgs() || []));
+    if (this.config.model) options.push('--model', this.config.model);
+    for (const img of context.images || []) options.push('--image', img);
+    if (this.config.reasoningEffort) options.push('-c', `model_reasoning_effort=${JSON.stringify(this.config.reasoningEffort)}`);
+    if (threadId) return ['exec', 'resume', ...options, threadId, '-'];
+    return ['exec', ...options, '--cd', this.config.workDir, '-'];
+  }
+}
+
+async function runJsonCli(bin, args, stdinText, cwd, onEvent, timeoutMs) {
+  return new Promise((resolve, reject) => {
+    const child = spawn(bin, args, { cwd, stdio: ['pipe', 'pipe', 'pipe'], env: { ...process.env } });
+    let stderr = '';
+    let threadId = '';
+    const messages = [];
+    const timer = setTimeout(() => {
+      child.kill('SIGTERM');
+      reject(new Error(`${bin} timed out after ${timeoutMs}ms`));
+    }, timeoutMs);
+    child.stderr.on('data', (d) => { stderr += d.toString(); });
+    child.on('error', (err) => { clearTimeout(timer); reject(err); });
+    const rl = readline.createInterface({ input: child.stdout });
+    rl.on('line', (line) => {
+      if (!line.trim()) return;
+      let event;
+      try { event = JSON.parse(line); } catch { return; }
+      if ((event.type === 'thread.started' || event.type === 'session.started') && (event.thread_id || event.session_id || event.conversation_id)) threadId = event.thread_id || event.session_id || event.conversation_id;
+      const text = extractText(event);
+      if (text) messages.push(text);
+      onEvent?.(event);
+    });
+    child.on('close', (code) => {
+      clearTimeout(timer);
+      if (code !== 0) reject(new Error(`${bin} exited ${code}: ${stderr.trim()}`));
+      else resolve({ text: messages.join('\n').trim(), threadId });
+    });
+    child.stdin.end(stdinText);
+  });
+}
+
+function extractText(event) {
+  if (event.type !== 'item.completed' || !event.item) return '';
+  const item = event.item;
+  if (!['agent_message', 'message'].includes(item.type)) return '';
+  if (typeof item.text === 'string') return item.text;
+  if (typeof item.content === 'string') return item.content;
+  if (typeof item.output_text === 'string') return item.output_text;
+  if (Array.isArray(item.content)) {
+    return item.content.map((p) => p?.text || p?.content || '').filter(Boolean).join('\n');
+  }
+  return '';
+}