notioncode 0.1.0 → 0.1.2

package/agent-runtime-server/server/agent-session-service.js

@@ -0,0 +1,816 @@
+import crypto from 'crypto';
+import { access, readFile } from 'fs/promises';
+import { existsSync } from 'fs';
+import { homedir } from 'os';
+import { join } from 'path';
+
+import { queryClaudeSDK, abortClaudeSDKSession, isClaudeSDKSessionActive } from './claude-sdk.js';
+import { queryCodex, abortCodexSession, isCodexSessionActive } from './openai-codex.js';
+import { spawnCursor, abortCursorSession, isCursorSessionActive } from './cursor-cli.js';
+import { spawnGemini, abortGeminiSession, isGeminiSessionActive } from './gemini-cli.js';
+
+const DEFAULT_APP_DATA_DIR = '.antigravity_tools';
+const GUI_CONFIG_FILE = 'gui_config.json';
+const SESSION_RETENTION_MS = 2 * 60 * 60 * 1000;
+const SESSION_PROVIDER_IDS = new Set(['claude', 'codex', 'cursor', 'gemini']);
+const LOGICAL_PROVIDER_IDS = new Set(['openai', 'anthropic', 'gemini', 'cursor', 'claude', 'codex']);
+const WORKER_ROLE_FALLBACK_ORDER = ['docs_product', 'active_work', 'code_surface', 'risk_debt', 'prototype'];
+
+const localSessions = new Map();
+
+function logAgentSession(message) {
+  console.log(`[AGENT-SESSIONS] ${message}`);
+}
+
+function quote(value) {
+  return JSON.stringify(value);
+}
+
+function readOptionalString(value) {
+  return typeof value === 'string' && value.trim().length > 0 ? value.trim() : undefined;
+}
+
+function getGuiConfigPath(env = process.env) {
+  const dataDir = readOptionalString(env.ABV_DATA_DIR) ?? join(homedir(), DEFAULT_APP_DATA_DIR);
+  return join(dataDir, GUI_CONFIG_FILE);
+}
+
+async function readGuiConfig(env = process.env) {
+  const configPath = getGuiConfigPath(env);
+  try {
+    await access(configPath);
+  } catch {
+    return { configPath, raw: null };
+  }
+
+  try {
+    const content = await readFile(configPath, 'utf8');
+    return { configPath, raw: JSON.parse(content) };
+  } catch (error) {
+    logAgentSession(`gui-config parse-failed path=${quote(configPath)} message=${quote(error instanceof Error ? error.message : String(error))}`);
+    return { configPath, raw: null };
+  }
+}
+
+function getRawNotionAutomationConfig(raw) {
+  if (!raw || typeof raw !== 'object') {
+    return null;
+  }
+
+  return raw.notion_automation ?? raw.notionAutomation ?? null;
+}
+
+function getRawAgentProviders(raw) {
+  return raw?.agent_providers ?? raw?.agentProviders ?? [];
+}
+
+function normalizeProviderChoice(value) {
+  const normalized = readOptionalString(value)?.toLowerCase();
+  return normalized && LOGICAL_PROVIDER_IDS.has(normalized) ? normalized : undefined;
+}
+
+function normalizeSessionProvider(value) {
+  const normalized = readOptionalString(value)?.toLowerCase();
+  return normalized && SESSION_PROVIDER_IDS.has(normalized) ? normalized : undefined;
+}
+
+function providerLabel(provider) {
+  switch (provider) {
+    case 'openai':
+      return 'OpenAI';
+    case 'anthropic':
+      return 'Anthropic';
+    case 'gemini':
+      return 'Gemini';
+    case 'cursor':
+      return 'Cursor';
+    case 'claude':
+      return 'Claude';
+    case 'codex':
+      return 'Codex';
+    default:
+      return provider;
+  }
+}
+
+function resolveSessionProvider(provider, runner) {
+  const sessionProvider = normalizeSessionProvider(provider);
+  if (sessionProvider) {
+    return sessionProvider;
+  }
+
+  const normalizedRunner = normalizeSessionProvider(runner);
+  if (normalizedRunner) {
+    return normalizedRunner;
+  }
+
+  switch (provider) {
+    case 'anthropic':
+      return 'claude';
+    case 'openai':
+      if (runner === 'cursor') {
+        return 'cursor';
+      }
+      return 'codex';
+    case 'gemini':
+      return 'gemini';
+    default:
+      return undefined;
+  }
+}
+
+function normalizeConfiguredProvider(candidate, index, source) {
+  if (!candidate || typeof candidate !== 'object') {
+    return null;
+  }
+
+  const logicalProvider = normalizeProviderChoice(candidate.provider);
+  const apiKey = readOptionalString(candidate.api_key ?? candidate.apiKey);
+  const sessionProvider = resolveSessionProvider(logicalProvider, readOptionalString(candidate.runner));
+  if (!apiKey || !sessionProvider) {
+    return null;
+  }
+
+  return {
+    id: logicalProvider ?? sessionProvider,
+    label: providerLabel(logicalProvider ?? sessionProvider),
+    sessionProvider,
+    source,
+    configured: true,
+    available: true,
+    priority: index,
+    apiKey,
+    baseUrl: readOptionalString(candidate.base_url ?? candidate.baseUrl),
+    runner: readOptionalString(candidate.runner),
+  };
+}
+
+function buildEnvFallbackProviders(env = process.env) {
+  const providers = [];
+
+  if (readOptionalString(env.OPENAI_API_KEY)) {
+    providers.push({
+      id: 'openai',
+      label: 'OpenAI',
+      sessionProvider: 'codex',
+      source: 'env',
+      configured: true,
+      available: true,
+      priority: providers.length,
+      apiKey: readOptionalString(env.OPENAI_API_KEY),
+      baseUrl: readOptionalString(env.OPENAI_BASE_URL),
+      runner: 'codex',
+    });
+  }
+
+  if (readOptionalString(env.ANTHROPIC_API_KEY)) {
+    providers.push({
+      id: 'anthropic',
+      label: 'Anthropic',
+      sessionProvider: 'claude',
+      source: 'env',
+      configured: true,
+      available: true,
+      priority: providers.length,
+      apiKey: readOptionalString(env.ANTHROPIC_API_KEY),
+      baseUrl: readOptionalString(env.ANTHROPIC_BASE_URL),
+      runner: 'claude',
+    });
+  }
+
+  if (readOptionalString(env.GEMINI_API_KEY)) {
+    providers.push({
+      id: 'gemini',
+      label: 'Gemini',
+      sessionProvider: 'gemini',
+      source: 'env',
+      configured: true,
+      available: true,
+      priority: providers.length,
+      apiKey: readOptionalString(env.GEMINI_API_KEY),
+      baseUrl: readOptionalString(env.GEMINI_BASE_URL),
+      runner: 'gemini',
+    });
+  }
+
+  return providers;
+}
+
+function parseWorkerRoleDefaults(rawConfig) {
+  const rawDefaults =
+    rawConfig?.worker_role_provider_defaults ??
+    rawConfig?.workerRoleProviderDefaults ??
+    rawConfig?.worker_role_defaults ??
+    rawConfig?.workerRoleDefaults ??
+    {};
+
+  if (!rawDefaults || typeof rawDefaults !== 'object') {
+    return {};
+  }
+
+  const normalized = {};
+  for (const [role, value] of Object.entries(rawDefaults)) {
+    const provider = normalizeProviderChoice(value);
+    if (provider) {
+      normalized[role] = provider;
+    }
+  }
+
+  return normalized;
+}
+
+function buildRoutingDefaults(rawNotionAutomation) {
+  const workspaceDefaultProvider =
+    normalizeProviderChoice(rawNotionAutomation?.workspace_default_provider) ??
+    normalizeProviderChoice(rawNotionAutomation?.workspaceDefaultProvider) ??
+    normalizeProviderChoice(rawNotionAutomation?.agent_provider_override) ??
+    normalizeProviderChoice(rawNotionAutomation?.agentProviderOverride);
+
+  return {
+    workspaceDefaultProvider,
+    workerRoleDefaults: parseWorkerRoleDefaults(rawNotionAutomation),
+  };
+}
+
+export async function listAvailableProviders(env = process.env) {
+  const { configPath, raw } = await readGuiConfig(env);
+  const notionAutomation = getRawNotionAutomationConfig(raw);
+  const defaults = buildRoutingDefaults(notionAutomation);
+
+  const configured = getRawAgentProviders(notionAutomation)
+    .map((candidate, index) => normalizeConfiguredProvider(candidate, index, 'gui_config'))
+    .filter(Boolean);
+
+  const providers = configured.length > 0 ? configured : buildEnvFallbackProviders(env);
+  const deduped = new Map();
+
+  for (const provider of providers) {
+    if (!deduped.has(provider.id)) {
+      deduped.set(provider.id, provider);
+    }
+  }
+
+  return {
+    source: configured.length > 0 ? 'gui_config' : 'env',
+    sourceDetail: configured.length > 0 ? configPath : 'environment',
+    providers: [...deduped.values()].map((provider, index) => ({
+      ...provider,
+      priority: index,
+      isWorkspaceDefault: provider.id === defaults.workspaceDefaultProvider,
+    })),
+    defaults,
+  };
+}
+
+export class ProviderSelectionError extends Error {
+  constructor(code, message, details = {}) {
+    super(message);
+    this.name = 'ProviderSelectionError';
+    this.code = code;
+    this.details = details;
+  }
+}
+
+function resolveWorkerRoleCandidate(workerRole, defaults) {
+  if (!workerRole) {
+    return undefined;
+  }
+
+  const exact = defaults.workerRoleDefaults?.[workerRole];
+  if (exact) {
+    return exact;
+  }
+
+  const normalized = workerRole.toLowerCase();
+  if (defaults.workerRoleDefaults?.[normalized]) {
+    return defaults.workerRoleDefaults[normalized];
+  }
+
+  return undefined;
+}
+
+function selectProvider(options, providerState) {
+  const {
+    preferredProvider,
+    workflowDefaultProvider,
+    workerRole,
+    allowFallback = 'auto',
+  } = options;
+
+  const availableProviders = providerState.providers.filter((provider) => provider.available);
+  const availableIds = new Set(availableProviders.map((provider) => provider.id));
+  const explicitPreferred = normalizeProviderChoice(preferredProvider);
+
+  if (explicitPreferred) {
+    const selected = availableProviders.find((provider) => provider.id === explicitPreferred);
+    if (selected) {
+      return {
+        provider: selected,
+        selectionSource: 'explicit',
+        fellBack: false,
+      };
+    }
+
+    if (allowFallback === 'auto') {
+      return {
+        provider: availableProviders[0] ?? null,
+        selectionSource: 'explicit-fallback',
+        fellBack: true,
+        fallbackFrom: explicitPreferred,
+      };
+    }
+
+    throw new ProviderSelectionError('preferred_provider_unavailable', `Preferred provider "${explicitPreferred}" is not available.`, {
+      preferredProvider: explicitPreferred,
+      availableProviders,
+      canConnectAnotherProvider: true,
+    });
+  }
+
+  const orderedCandidates = [
+    resolveWorkerRoleCandidate(workerRole, providerState.defaults),
+    normalizeProviderChoice(workflowDefaultProvider),
+    providerState.defaults.workspaceDefaultProvider,
+  ].filter(Boolean);
+
+  for (const candidate of orderedCandidates) {
+    if (!availableIds.has(candidate)) {
+      continue;
+    }
+
+    return {
+      provider: availableProviders.find((provider) => provider.id === candidate),
+      selectionSource: candidate === providerState.defaults.workspaceDefaultProvider ? 'workspace-default' : 'policy-default',
+      fellBack: false,
+    };
+  }
+
+  if (availableProviders.length === 0) {
+    throw new ProviderSelectionError('no_available_providers', 'No configured providers are available.', {
+      availableProviders: [],
+      canConnectAnotherProvider: true,
+    });
+  }
+
+  return {
+    provider: availableProviders[0],
+    selectionSource: 'first-available',
+    fellBack: false,
+  };
+}
+
+function createEvent(session, type, fields = {}) {
+  const sequence = session.nextSequence++;
+  return {
+    id: crypto.randomUUID(),
+    sequence,
+    sessionId: session.id,
+    provider: session.provider,
+    sessionProvider: session.sessionProvider,
+    providerSessionId: session.providerSessionId ?? null,
+    turn: session.turn,
+    timestamp: new Date().toISOString(),
+    type,
+    ...fields,
+  };
+}
+
+function emitEvent(session, type, fields = {}) {
+  const lastEvent = session.events[session.events.length - 1];
+  if (
+    type === 'status' &&
+    lastEvent?.type === 'status' &&
+    lastEvent?.turn === session.turn &&
+    lastEvent?.text === fields.text
+  ) {
+    return lastEvent;
+  }
+
+  const event = createEvent(session, type, fields);
+  session.events.push(event);
+  session.updatedAt = event.timestamp;
+
+  if (session.events.length > 2000) {
+    session.events.splice(0, session.events.length - 2000);
+  }
+
+  for (const subscriber of session.subscribers) {
+    subscriber(event);
+  }
+
+  return event;
+}
+
+function ensureSession(sessionId) {
+  const session = localSessions.get(sessionId);
+  if (!session) {
+    throw new ProviderSelectionError('session_not_found', `Unknown agent session "${sessionId}".`);
+  }
+
+  return session;
+}
+
+function extractTextContent(payload) {
+  if (!payload || typeof payload !== 'object') {
+    return '';
+  }
+
+  if (typeof payload.content === 'string') {
+    return payload.content;
+  }
+
+  if (typeof payload.message === 'string') {
+    return payload.message;
+  }
+
+  if (payload.message && typeof payload.message === 'object' && typeof payload.message.content === 'string') {
+    return payload.message.content;
+  }
+
+  if (typeof payload.text === 'string') {
+    return payload.text;
+  }
+
+  if (typeof payload.resultText === 'string') {
+    return payload.resultText;
+  }
+
+  return '';
+}
+
+function ingestPayload(session, payload) {
+  const data =
+    typeof payload === 'string'
+      ? (() => {
+          try {
+            return JSON.parse(payload);
+          } catch {
+            return { kind: 'status', text: payload };
+          }
+        })()
+      : payload;
+
+  if (!data || typeof data !== 'object') {
+    return;
+  }
+
+  const kind = typeof data.kind === 'string' ? data.kind : typeof data.type === 'string' ? data.type : 'status';
+
+  if (kind === 'session_created') {
+    session.providerSessionId = readOptionalString(data.newSessionId) ?? readOptionalString(data.sessionId) ?? session.providerSessionId;
+    emitEvent(session, 'status', {
+      text: 'provider_session_created',
+      raw: data,
+    });
+    return;
+  }
+
+  if (kind === 'text' || kind === 'stream_delta' || kind === 'thinking') {
+    const content = extractTextContent(data);
+    if (content) {
+      if (kind !== 'thinking') {
+        session.assistantText += content;
+      }
+
+      emitEvent(session, 'text_delta', {
+        content,
+        channel: kind === 'thinking' ? 'thinking' : 'assistant',
+        raw: data,
+      });
+    }
+    return;
+  }
+
+  if (kind === 'tool_use') {
+    emitEvent(session, 'tool_call', {
+      toolName: data.toolName ?? data.tool ?? 'tool',
+      toolInput: data.toolInput ?? data.arguments ?? null,
+      toolId: data.toolId ?? null,
+      raw: data,
+    });
+    return;
+  }
+
+  if (kind === 'tool_result') {
+    emitEvent(session, 'tool_result', {
+      toolId: data.toolId ?? null,
+      content: extractTextContent(data),
+      isError: Boolean(data.isError),
+      raw: data,
+    });
+    return;
+  }
+
+  if (kind === 'permission_request' || kind === 'permission_cancelled' || kind === 'interactive_prompt' || kind === 'task_notification') {
+    emitEvent(session, 'warning', {
+      text: extractTextContent(data) || kind,
+      raw: data,
+    });
+    return;
+  }
+
+  if (kind === 'error') {
+    session.turnTerminal = true;
+    session.status = 'failed';
+    emitEvent(session, 'error', {
+      content: extractTextContent(data) || 'Unknown runner error',
+      raw: data,
+    });
+    return;
+  }
+
+  if (kind === 'complete' || kind === 'stream_end') {
+    if (kind === 'complete') {
+      session.turnTerminal = true;
+      session.status = data.aborted ? 'aborted' : 'completed';
+      const resultText = extractTextContent(data) || session.assistantText.trim();
+      emitEvent(session, 'complete', {
+        aborted: Boolean(data.aborted),
+        exitCode: data.exitCode ?? null,
+        resultText,
+        raw: data,
+      });
+    }
+    return;
+  }
+
+  emitEvent(session, 'status', {
+    text: extractTextContent(data) || kind,
+    raw: data,
+  });
+}
+
+class AgentSessionWriter {
+  constructor(session) {
+    this.session = session;
+    this.userId = session.userId ?? null;
+    this.isSSEStreamWriter = true;
+  }
+
+  send(data) {
+    ingestPayload(this.session, data);
+  }
+
+  end() {
+    // Providers already emit terminal events. Nothing to do here.
+  }
+
+  setSessionId(sessionId) {
+    this.session.providerSessionId = sessionId;
+  }
+
+  getSessionId() {
+    return this.session.providerSessionId ?? this.session.id;
+  }
+}
+
+function buildProviderOptions(session, overrides = {}) {
+  return {
+    sessionId: session.providerSessionId ?? undefined,
+    cwd: session.cwd,
+    projectPath: session.cwd,
+    sessionSummary: session.metadata?.summary,
+    model: overrides.model ?? session.model,
+    apiKey: session.apiKey,
+    baseUrl: session.baseUrl,
+    permissionMode: overrides.permissionMode ?? 'bypassPermissions',
+    skipPermissions: true,
+    toolsSettings: {
+      skipPermissions: true,
+      allowedTools: [],
+      disallowedTools: [],
+    },
+  };
+}
+
+async function invokeProvider(session, prompt, overrides = {}) {
+  const writer = new AgentSessionWriter(session);
+  const options = buildProviderOptions(session, overrides);
+
+  switch (session.sessionProvider) {
+    case 'claude':
+      return await queryClaudeSDK(prompt, options, writer);
+    case 'codex':
+      return await queryCodex(prompt, options, writer);
+    case 'cursor':
+      return await spawnCursor(prompt, options, writer);
+    case 'gemini':
+      return await spawnGemini(prompt, options, writer);
+    default:
+      throw new Error(`Unsupported session provider "${session.sessionProvider}".`);
+  }
+}
+
+async function runTurn(session, prompt, reason, overrides = {}) {
+  if (session.status === 'running') {
+    throw new ProviderSelectionError('session_busy', `Agent session "${session.id}" is already running.`);
+  }
+
+  session.turn += 1;
+  session.turnTerminal = false;
+  session.status = 'running';
+  session.currentPrompt = prompt;
+  session.assistantText = '';
+
+  emitEvent(session, 'status', {
+    text: reason,
+    canAbort: true,
+    raw: {
+      kind: 'status',
+      reason,
+    },
+  });
+
+  try {
+    await invokeProvider(session, prompt, overrides);
+    if (!session.turnTerminal) {
+      session.status = 'completed';
+      emitEvent(session, 'complete', {
+        aborted: false,
+        exitCode: 0,
+        resultText: session.assistantText.trim(),
+      });
+    }
+  } catch (error) {
+    if (!session.turnTerminal) {
+      session.status = 'failed';
+      session.turnTerminal = true;
+      emitEvent(session, 'error', {
+        content: error instanceof Error ? error.message : String(error),
+      });
+    }
+  }
+}
+
+export async function startLocalAgentSession(input, context = {}) {
+  const providerState = await listAvailableProviders();
+  const selection = selectProvider(input, providerState);
+  const provider = selection.provider;
+  if (!provider) {
+    throw new ProviderSelectionError('no_available_providers', 'No configured providers are available.', {
+      availableProviders: providerState.providers,
+      canConnectAnotherProvider: true,
+    });
+  }
+
+  const session = {
+    id: crypto.randomUUID(),
+    provider: provider.id,
+    sessionProvider: provider.sessionProvider,
+    cwd: input.cwd,
+    apiKey: provider.apiKey,
+    baseUrl: provider.baseUrl,
+    workerRole: input.workerRole ?? null,
+    allowFallback: input.allowFallback ?? 'auto',
+    status: 'queued',
+    createdAt: new Date().toISOString(),
+    updatedAt: new Date().toISOString(),
+    providerSessionId: null,
+    metadata: input.metadata ?? {},
+    model: readOptionalString(input.model),
+    subscribers: new Set(),
+    events: [],
+    nextSequence: 1,
+    turn: 0,
+    turnTerminal: false,
+    currentPrompt: null,
+    assistantText: '',
+    userId: context.userId ?? null,
+    routing: {
+      selectionSource: selection.selectionSource,
+      fellBack: Boolean(selection.fellBack),
+      fallbackFrom: selection.fallbackFrom ?? null,
+      availableProviders: providerState.providers,
+      defaults: providerState.defaults,
+    },
+  };
+
+  localSessions.set(session.id, session);
+
+  emitEvent(session, 'session_started', {
+    text: 'session_started',
+    raw: {
+      workerRole: session.workerRole,
+      selectionSource: selection.selectionSource,
+      fellBack: Boolean(selection.fellBack),
+      fallbackFrom: selection.fallbackFrom ?? null,
+      availableProviders: providerState.providers,
+    },
+  });
+
+  void runTurn(session, input.prompt, 'initial_prompt', {
+    model: input.model,
+  });
+
+  return {
+    sessionId: session.id,
+    provider: session.provider,
+    sessionProvider: session.sessionProvider,
+    status: session.status,
+    createdAt: session.createdAt,
+    routing: session.routing,
+  };
+}
+
+export function getLocalAgentSession(sessionId) {
+  const session = ensureSession(sessionId);
+  return {
+    sessionId: session.id,
+    provider: session.provider,
+    sessionProvider: session.sessionProvider,
+    status: session.status,
+    createdAt: session.createdAt,
+    updatedAt: session.updatedAt,
+    providerSessionId: session.providerSessionId,
+    canAbort: session.status === 'running',
+    currentPrompt: session.currentPrompt,
+    metadata: session.metadata,
+    routing: session.routing,
+  };
+}
+
+export function getLocalAgentSessionEvents(sessionId, afterSequence = 0) {
+  const session = ensureSession(sessionId);
+  return session.events.filter((event) => event.sequence > afterSequence);
+}
+
+export function subscribeToLocalAgentSession(sessionId, handler) {
+  const session = ensureSession(sessionId);
+  session.subscribers.add(handler);
+  return () => {
+    session.subscribers.delete(handler);
+  };
+}
+
+export async function sendLocalAgentSessionMessage(sessionId, input) {
+  const session = ensureSession(sessionId);
+  void runTurn(session, input.prompt, 'followup_prompt', {
+    model: input.model,
+  });
+  return getLocalAgentSession(sessionId);
+}
+
+export async function abortLocalAgentSession(sessionId) {
+  const session = ensureSession(sessionId);
+
+  session.status = 'aborted';
+  session.turnTerminal = true;
+
+  if (session.providerSessionId) {
+    if (session.sessionProvider === 'claude') {
+      await abortClaudeSDKSession(session.providerSessionId);
+    } else if (session.sessionProvider === 'codex') {
+      abortCodexSession(session.providerSessionId);
+    } else if (session.sessionProvider === 'cursor') {
+      abortCursorSession(session.providerSessionId);
+    } else if (session.sessionProvider === 'gemini') {
+      abortGeminiSession(session.providerSessionId);
+    }
+  }
+
+  emitEvent(session, 'complete', {
+    aborted: true,
+    exitCode: null,
+    resultText: session.assistantText.trim(),
+  });
+
+  return { ok: true };
+}
+
+export function isLocalAgentSessionActive(sessionId) {
+  const session = ensureSession(sessionId);
+  const providerSessionId = session.providerSessionId;
+
+  if (!providerSessionId) {
+    return session.status === 'running';
+  }
+
+  if (session.sessionProvider === 'claude') {
+    return isClaudeSDKSessionActive(providerSessionId);
+  }
+  if (session.sessionProvider === 'codex') {
+    return isCodexSessionActive(providerSessionId);
+  }
+  if (session.sessionProvider === 'cursor') {
+    return isCursorSessionActive(providerSessionId);
+  }
+  if (session.sessionProvider === 'gemini') {
+    return isGeminiSessionActive(providerSessionId);
+  }
+
+  return false;
+}
+
+setInterval(() => {
+  const cutoff = Date.now() - SESSION_RETENTION_MS;
+  for (const [sessionId, session] of localSessions.entries()) {
+    if (session.status === 'running') {
+      continue;
+    }
+
+    const updatedAt = new Date(session.updatedAt).getTime();
+    if (updatedAt < cutoff && session.subscribers.size === 0) {
+      localSessions.delete(sessionId);
+    }
+  }
+}, 5 * 60 * 1000);