[Init] Initial commit - NetMesh terminal manager

infrastructure/ai/sdkAgentAdapter.ts

@@ -0,0 +1,540 @@
+/**
+ * SDK Agent Adapter
+ *
+ * Bridges managed external agents through IPC. The main process runs the
+ * official SDK drivers and forwards stream events to the renderer.
+ */
+
+import type {
+  AgentActivity,
+  AgentUsage,
+  AIPermissionMode,
+  AIToolIntegrationMode,
+  ExternalAgentConfig,
+} from './types';
+import { getExternalAgentSdkBackend, getManualAgentCommand } from './managedAgents';
+import { encodeSdkSessionIdentity } from './harness/sdkSessionIdentity';
+import { mapSdkStreamEventToAgentEvents } from './harness/agentEventAdapter';
+import { globalTraceStore } from './harness/traceStore';
+import { decryptField } from '../persistence/secureFieldAdapter';
+
+export interface DefaultTargetSessionHint {
+  sessionId: string;
+  hostname: string;
+  label: string;
+  os?: string;
+  username?: string;
+  protocol?: string;
+  shellType?: string;
+  deviceType?: string;
+  connected: boolean;
+  source: 'scope-target' | 'only-connected-in-scope';
+}
+
+export interface SdkAgentCallbacks {
+  onSessionId?: (sessionId: string) => void;
+  onTextDelta: (text: string) => void;
+  onThinkingDelta: (text: string) => void;
+  onThinkingDone: () => void;
+  onToolCall: (toolName: string, args: Record<string, unknown>, toolCallId?: string) => void;
+  onToolResult: (toolCallId: string, result: string, toolName?: string) => void;
+  onFileChange?: (activity: Extract<AgentActivity, { type: 'file_change' }>) => void;
+  onWebSearch?: (activity: Extract<AgentActivity, { type: 'web_search' }>) => void;
+  onPlanUpdate?: (activity: Extract<AgentActivity, { type: 'plan_update' }>) => void;
+  onWarning?: (activity: Extract<AgentActivity, { type: 'warning' }>) => void;
+  onUsage?: (usage: AgentUsage) => void;
+  onStatus?: (message: string) => void;
+  onHook?: (hookEvent: string, payload: Record<string, unknown>) => void;
+  onElicitationCreate?: (elicitationId: string, request: Record<string, unknown>) => void;
+  onElicitationComplete?: (notification: Record<string, unknown>) => void;
+  onError: (error: string) => void;
+  onDone: () => void;
+}
+
+interface SdkAgentBridge {
+  aiSdkAgentStream(
+    requestId: string,
+    chatSessionId: string,
+    sdkBackend: string,
+    prompt: string,
+    cwd?: string,
+    providerId?: string,
+    model?: string,
+    existingSessionId?: string,
+    historyMessages?: Array<{ role: 'user' | 'assistant'; content: string }>,
+    images?: FileAttachment[],
+    toolIntegrationMode?: AIToolIntegrationMode,
+    defaultTargetSession?: DefaultTargetSessionHint,
+    userSkillsContext?: string,
+    agentEnv?: Record<string, string>,
+    agentCommand?: string,
+    codexRuntime?: 'sdk' | 'app-server',
+    permissionMode?: AIPermissionMode,
+    codebuddyOptions?: ExternalAgentConfig['codebuddyOptions'],
+  ): Promise<{ ok: boolean; error?: unknown }>;
+  aiSdkAgentSteer?(
+    requestId: string,
+    chatSessionId: string,
+    prompt: string,
+    images: FileAttachment[] | undefined,
+    clientUserMessageId: string,
+  ): Promise<SdkAgentSteerResult>;
+  aiSdkAgentCancel(requestId: string, chatSessionId?: string): Promise<{ ok: boolean }>;
+  onAiSdkAgentEvent(requestId: string, cb: (event: StreamEvent) => void): () => void;
+  onAiSdkAgentDone(requestId: string, cb: () => void): () => void;
+  onAiSdkAgentError(requestId: string, cb: (error: unknown) => void): () => void;
+}
+
+export type SdkAgentSteerResult =
+  | { status: 'accepted' }
+  | {
+      status: 'not-steerable' | 'busy' | 'inactive' | 'unsupported' | 'cancelled' | 'failed';
+      message?: string;
+      turnKind?: 'review' | 'compact';
+    };
+
+interface StreamEvent {
+  type: string;
+  [key: string]: unknown;
+}
+
+export interface FileAttachment {
+  base64Data: string;
+  mediaType: string;
+  filename?: string;
+  filePath?: string;
+}
+
+export async function steerSdkAgentTurn(
+  bridge: unknown,
+  requestId: string,
+  chatSessionId: string,
+  prompt: string,
+  images: FileAttachment[] | undefined,
+  clientUserMessageId: string,
+): Promise<SdkAgentSteerResult> {
+  const sdkBridge = bridge as SdkAgentBridge | null;
+  if (!sdkBridge?.aiSdkAgentSteer) return { status: 'unsupported' };
+  try {
+    return await sdkBridge.aiSdkAgentSteer(
+      requestId,
+      chatSessionId,
+      prompt,
+      images,
+      clientUserMessageId,
+    );
+  } catch (error) {
+    return {
+      status: 'failed',
+      message: error instanceof Error ? error.message : String(error),
+    };
+  }
+}
+
+async function buildAgentEnvWithStoredApiKey(
+  sdkBackend: string,
+  config: ExternalAgentConfig,
+): Promise<Record<string, string> | undefined> {
+  const env = { ...(config.env ?? {}) };
+  if (sdkBackend === 'cursor') {
+    const authMode = config.cursorAuthMode === 'cli-login' ? 'cli-login' : 'api-key';
+    env.NETCATTY_CURSOR_AUTH_MODE = authMode;
+    const cliBin = String(config.command || '').trim();
+    if (authMode === 'cli-login') {
+      if (cliBin && cliBin !== 'cursor') {
+        env.NETCATTY_CURSOR_CLI_BIN = cliBin;
+      }
+      return Object.keys(env).length > 0 ? env : undefined;
+    }
+    if (config.apiKey) {
+      const decrypted = await decryptField(config.apiKey).catch(() => config.apiKey);
+      const apiKey = String(decrypted || '').trim();
+      if (apiKey) {
+        env.CURSOR_API_KEY = apiKey;
+      }
+    }
+  }
+  return Object.keys(env).length > 0 ? env : undefined;
+}
+
+function safeJsonStringify(value: unknown): string | null {
+  const seen = new WeakSet<object>();
+  try {
+    return JSON.stringify(value, (_key, nestedValue: unknown) => {
+      if (typeof nestedValue !== 'object' || nestedValue === null) {
+        return nestedValue;
+      }
+      if (seen.has(nestedValue)) {
+        return '[Circular]';
+      }
+      seen.add(nestedValue);
+      return nestedValue;
+    });
+  } catch {
+    return null;
+  }
+}
+
+function formatSdkAgentErrorValue(error: unknown, seen = new WeakSet<object>()): string {
+  if (error == null) return '';
+  if (typeof error === 'string') return error;
+  if (typeof error === 'number' || typeof error === 'boolean') return String(error);
+  if (error instanceof Error) return error.message || error.name || '';
+  if (typeof error !== 'object') return String(error);
+  if (seen.has(error)) return '[Circular error]';
+  seen.add(error);
+
+  const record = error as Record<string, unknown>;
+  const data = record.data as Record<string, unknown> | undefined;
+  const nestedError = record.error as Record<string, unknown> | undefined;
+  const candidates: unknown[] = [
+    data?.message,
+    data?.error,
+    record.errorText,
+    record.message,
+    record.error,
+    record.cause,
+    nestedError?.message,
+    record.data,
+  ];
+
+  for (const candidate of candidates) {
+    const message = formatSdkAgentErrorValue(candidate, seen).trim();
+    if (message && message !== '{}') {
+      return message;
+    }
+  }
+
+  return safeJsonStringify(error) || String(error);
+}
+
+export function formatSdkAgentErrorForDisplay(error: unknown): string {
+  return formatSdkAgentErrorValue(error).trim() || 'Unknown error';
+}
+
+export async function runSdkAgentTurn(
+  bridge: Record<string, (...args: unknown[]) => unknown>,
+  requestId: string,
+  chatSessionId: string,
+  config: ExternalAgentConfig,
+  prompt: string,
+  callbacks: SdkAgentCallbacks,
+  signal?: AbortSignal,
+  providerId?: string,
+  model?: string,
+  existingSessionId?: string,
+  historyMessages?: Array<{ role: 'user' | 'assistant'; content: string }>,
+  images?: FileAttachment[],
+  toolIntegrationMode?: AIToolIntegrationMode,
+  defaultTargetSession?: DefaultTargetSessionHint,
+  userSkillsContext?: string,
+  permissionMode?: AIPermissionMode,
+  harnessOptions?: {
+    traceSink?: (event: import('./harness/types').AgentEvent) => void;
+    skipHarnessTrace?: boolean;
+  },
+): Promise<void> {
+  const sdkBridge = bridge as unknown as SdkAgentBridge;
+  const sdkBackend = getExternalAgentSdkBackend(config);
+
+  if (!sdkBackend) {
+    callbacks.onError('Agent has no SDK backend configured');
+    return;
+  }
+
+  const cleanupFns: (() => void)[] = [];
+  let settled = false;
+  let resolveDone: () => void = () => {};
+  const donePromise = new Promise<void>((resolve) => {
+    resolveDone = resolve;
+  });
+  const settle = (fn?: () => void) => {
+    if (settled) return false;
+    settled = true;
+    fn?.();
+    resolveDone();
+    return true;
+  };
+
+  const baseAgentEnv = await buildAgentEnvWithStoredApiKey(sdkBackend, config);
+  // Grok dual runtime: prefer Settings grokRuntime; env override still works in main.
+  const agentEnv = sdkBackend === 'grok'
+    ? {
+        ...baseAgentEnv,
+        NETCATTY_GROK_RUNTIME: config.grokRuntime === 'streaming-json' ? 'streaming-json' : 'acp',
+      }
+    : baseAgentEnv;
+  const agentCommand = getManualAgentCommand(config);
+
+  // Set up event listeners before starting stream
+  if (!harnessOptions?.skipHarnessTrace) {
+    globalTraceStore.append({
+      id: `turn-start-${requestId}`,
+      type: 'turn_start',
+      sessionId: chatSessionId,
+      chatSessionId,
+      backend: 'external-sdk',
+      timestamp: Date.now(),
+      backendLabel: sdkBackend,
+    });
+  }
+
+  const appendHarnessEvent = (event: import('./harness/types').AgentEvent) => {
+    if (harnessOptions?.traceSink) {
+      harnessOptions.traceSink(event);
+      return;
+    }
+    if (!harnessOptions?.skipHarnessTrace) {
+      globalTraceStore.append(event);
+    }
+  };
+
+  const unsubEvent = sdkBridge.onAiSdkAgentEvent(requestId, (event: StreamEvent) => {
+    for (const agentEvent of mapSdkStreamEventToAgentEvents(event, {
+      sessionId: chatSessionId,
+      chatSessionId,
+      turnId: requestId,
+    })) {
+      appendHarnessEvent(agentEvent);
+    }
+    const streamFailed = handleStreamEvent(event, callbacks);
+    if (streamFailed) {
+      settle();
+    }
+  });
+  cleanupFns.push(unsubEvent);
+
+  const unsubDone = sdkBridge.onAiSdkAgentDone(requestId, () => {
+    settle(() => {
+      callbacks.onDone();
+    });
+  });
+  cleanupFns.push(unsubDone);
+
+  const unsubError = sdkBridge.onAiSdkAgentError(requestId, (error: unknown) => {
+    settle(() => {
+      callbacks.onError(formatSdkAgentErrorForDisplay(error));
+    });
+  });
+  cleanupFns.push(unsubError);
+
+  // Handle abort
+  if (signal) {
+    if (signal.aborted) {
+      cleanup(cleanupFns);
+      return;
+    }
+    const onAbort = () => {
+      if (!settle()) {
+        return;
+      }
+      sdkBridge.aiSdkAgentCancel(requestId, chatSessionId).catch(() => {});
+    };
+    signal.addEventListener('abort', onAbort, { once: true });
+    cleanupFns.push(() => signal.removeEventListener('abort', onAbort));
+  }
+
+  // Start the SDK stream in the main process
+  void sdkBridge.aiSdkAgentStream(
+    requestId,
+    chatSessionId,
+    sdkBackend,
+    prompt,
+    undefined, // cwd
+    providerId,
+    model,
+    existingSessionId,
+    historyMessages,
+    images?.length ? images : undefined,
+    toolIntegrationMode,
+    defaultTargetSession,
+    userSkillsContext,
+    agentEnv,
+    agentCommand,
+    sdkBackend === 'codex' ? (config.codexRuntime ?? 'sdk') : undefined,
+    permissionMode,
+    sdkBackend === 'codebuddy' ? config.codebuddyOptions : undefined,
+  ).then((result) => {
+    if (result?.ok === false) {
+      settle(() => {
+        callbacks.onError(
+          result.error == null
+            ? 'Failed to start SDK agent stream'
+            : formatSdkAgentErrorForDisplay(result.error),
+        );
+      });
+    }
+  }).catch((err: unknown) => {
+    settle(() => {
+      callbacks.onError(formatSdkAgentErrorForDisplay(err));
+    });
+  }).finally(() => {
+    if (settled) {
+      cleanup(cleanupFns);
+    }
+  });
+
+  // Wait for done or error
+  await donePromise;
+  cleanup(cleanupFns);
+}
+
+function cleanup(fns: (() => void)[]) {
+  for (const fn of fns) {
+    try { fn(); } catch { /* */ }
+  }
+}
+
+/**
+ * Handle a single stream event from the AI SDK stream.
+ * Events come from `streamText().stream` in the main process.
+ */
+function handleStreamEvent(event: StreamEvent, callbacks: SdkAgentCallbacks): boolean {
+  switch (event.type) {
+    case 'text-delta': {
+      const text = (event.textDelta as string) || (event.delta as string) || '';
+      if (text) callbacks.onTextDelta(text);
+      return false;
+    }
+    case 'reasoning-start': {
+      // Reasoning block started — nothing to render yet
+      return false;
+    }
+    case 'reasoning-delta': {
+      const text = (event.delta as string) || '';
+      if (text) callbacks.onThinkingDelta(text);
+      return false;
+    }
+    case 'reasoning-end': {
+      callbacks.onThinkingDone();
+      return false;
+    }
+    case 'tool-call': {
+      const toolName = (event.toolName as string) || 'unknown';
+      // The Electron bridge emits tool args as `args` (see sdk/emit.cjs
+      // toolCall), while direct AI SDK paths use `input`. Read both so
+      // either source works.
+      const input =
+        (event.input as Record<string, unknown>) ||
+        (event.args as Record<string, unknown>) ||
+        {};
+      const toolCallId = (event.toolCallId as string) || undefined;
+      callbacks.onToolCall(toolName, input, toolCallId);
+      return false;
+    }
+    case 'tool-result': {
+      const toolCallId = (event.toolCallId as string) || '';
+      const toolName = (event.toolName as string) || undefined;
+      const output = event.output ?? event.result;
+      const result = typeof output === 'string'
+        ? output
+        : JSON.stringify(output);
+      callbacks.onToolResult(toolCallId, result, toolName);
+      return false;
+    }
+    case 'file-change': {
+      callbacks.onFileChange?.({
+        id: (event.itemId as string) || '',
+        type: 'file_change',
+        status: event.status === 'failed' ? 'failed' : 'completed',
+        changes: Array.isArray(event.changes)
+          ? event.changes as Extract<AgentActivity, { type: 'file_change' }>['changes']
+          : [],
+      });
+      return false;
+    }
+    case 'web-search': {
+      callbacks.onWebSearch?.({
+        id: (event.itemId as string) || '',
+        type: 'web_search',
+        status: event.status === 'completed' ? 'completed' : 'running',
+        query: (event.query as string) || '',
+      });
+      return false;
+    }
+    case 'plan-update': {
+      callbacks.onPlanUpdate?.({
+        id: (event.itemId as string) || '',
+        type: 'plan_update',
+        status: event.status === 'completed' ? 'completed' : 'running',
+        items: Array.isArray(event.items)
+          ? event.items as Extract<AgentActivity, { type: 'plan_update' }>['items']
+          : [],
+      });
+      return false;
+    }
+    case 'warning': {
+      const message = (event.message as string) || '';
+      if (message) {
+        callbacks.onWarning?.({
+          id: (event.itemId as string) || '',
+          type: 'warning',
+          status: 'completed',
+          message,
+        });
+      }
+      return false;
+    }
+    case 'usage': {
+      const inputTokens = Number(event.inputTokens) || 0;
+      const outputTokens = Number(event.outputTokens) || 0;
+      callbacks.onUsage?.({
+        inputTokens,
+        cachedInputTokens: Number(event.cachedInputTokens) || 0,
+        outputTokens,
+        reasoningTokens: Number(event.reasoningTokens) || 0,
+        totalTokens: Number(event.totalTokens) || inputTokens + outputTokens,
+        estimated: false,
+      });
+      return false;
+    }
+    case 'status': {
+      const msg = (event.message as string) || '';
+      if (msg) callbacks.onStatus?.(msg);
+      return false;
+    }
+    case 'session-id': {
+      const sessionId = (event.sessionId as string) || '';
+      if (sessionId) {
+        const runtimeRaw = String(event.runtime || 'sdk');
+        callbacks.onSessionId?.(encodeSdkSessionIdentity(
+          sessionId,
+          event.sdkBackend as string | undefined,
+          event.binPath as string | undefined,
+          // Preserve Codex + Grok dual-runtime tokens (do not collapse Grok to "sdk").
+          runtimeRaw,
+          event.authMode as string | undefined,
+          event.cliMode as string | undefined,
+        ));
+      }
+      return false;
+    }
+    case 'hook': {
+      const hookEvent = (event.hookEvent as string) || '';
+      if (hookEvent) {
+        callbacks.onHook?.(hookEvent, event as Record<string, unknown>);
+      }
+      return false;
+    }
+    case 'elicitation-create': {
+      const elicitationId = (event.elicitationId as string) || '';
+      const request = (event.request as Record<string, unknown>) || {};
+      if (elicitationId) {
+        callbacks.onElicitationCreate?.(elicitationId, request);
+      }
+      return false;
+    }
+    case 'elicitation-complete': {
+      const notification = (event.notification as Record<string, unknown>) || {};
+      callbacks.onElicitationComplete?.(notification);
+      return false;
+    }
+    case 'error': {
+      callbacks.onError(formatSdkAgentErrorForDisplay(event.error));
+      return true;
+    }
+    // step-start, step-finish, etc. — ignore silently
+    default:
+      return false;
+  }
+}