@axhub/genie 0.2.11 → 0.2.12

package/server/routes/runs.js

@@ -0,0 +1,641 @@
+import express from 'express';
+
+import { executeAgentPrompt } from '../acp-runtime/index.js';
+import { resolveAgentElicitation, resolveAgentPermission } from '../acp-runtime/index.js';
+import { mergeAgentCommandOverrides } from '../acp-runtime/command-overrides.js';
+import { abortAgentSession } from '../session-core/abortSession.js';
+import { runRegistry as defaultRunRegistry } from '../session-core/runRegistry.js';
+import { SessionEventMirrorWriter } from '../session-core/runtimeWriter.js';
+import {
+  CONVERSATION_EVENT_KINDS,
+  createConversationEvent,
+} from '../../shared/conversationEvents.js';
+
+const AGENT_COMMAND_TYPES_BY_PROVIDER = new Map([
+  ['claude', 'claude-command'],
+  ['codex', 'codex-command'],
+  ['gemini', 'gemini-command'],
+  ['opencode', 'opencode-command'],
+]);
+
+const TERMINAL_STATUSES = new Set(['succeeded', 'failed', 'canceled']);
+const DEFAULT_RUN_INACTIVITY_TIMEOUT_MS = 600_000;
+
+class NullRunWriter {
+  constructor() {
+    this.sessionId = null;
+  }
+
+  send() {}
+
+  setSessionId(sessionId) {
+    this.sessionId = sessionId;
+  }
+
+  getSessionId() {
+    return this.sessionId;
+  }
+}
+
+function sendRunNotFound(res, runId) {
+  return res.status(404).json({
+    success: false,
+    error: 'Run not found or expired',
+    runId,
+  });
+}
+
+function parseAfterSeq(value) {
+  const parsed = Number(value);
+  return Number.isFinite(parsed) && parsed > 0 ? Math.floor(parsed) : 0;
+}
+
+function normalizeProvider(provider) {
+  const normalized = String(provider || 'claude').trim().toLowerCase();
+  return AGENT_COMMAND_TYPES_BY_PROVIDER.has(normalized) ? normalized : 'claude';
+}
+
+function normalizeNullableString(value) {
+  return typeof value === 'string' && value.trim() ? value.trim() : null;
+}
+
+function normalizePositiveInteger(value, fallback) {
+  const parsed = Number(value);
+  return Number.isFinite(parsed) && parsed > 0 ? Math.floor(parsed) : fallback;
+}
+
+function createRunInactivityTimeoutError({ timeoutMs, provider, sessionId, clientRequestId, run }) {
+  const error = new Error(`Run stalled without activity for ${timeoutMs}ms`);
+  error.code = 'RUN_INACTIVITY_TIMEOUT';
+  error.details = {
+    timeoutMs,
+    provider,
+    sessionId: run?.sessionId || sessionId || null,
+    clientRequestId: clientRequestId || null,
+    lastEventSeq: run?.lastEventSeq || 0,
+    lastActivityAt: run?.updatedAt || null,
+  };
+  return error;
+}
+
+function createRunCanceledError({ provider, sessionId, clientRequestId, run }) {
+  const error = new Error('Run was canceled');
+  error.code = 'RUN_CANCELED';
+  error.details = {
+    provider,
+    sessionId: run?.sessionId || sessionId || null,
+    clientRequestId: clientRequestId || null,
+    lastEventSeq: run?.lastEventSeq || 0,
+    lastActivityAt: run?.updatedAt || null,
+  };
+  return error;
+}
+
+function withRunActivityWatchdog(promise, {
+  runRegistry,
+  runId,
+  provider,
+  sessionId = null,
+  clientRequestId = null,
+  timeoutMs,
+}) {
+  if (!Number.isFinite(timeoutMs) || timeoutMs <= 0) {
+    return promise;
+  }
+
+  let timeoutId = null;
+  let unsubscribe = null;
+  let settled = false;
+  const clearTimer = () => {
+    if (timeoutId) {
+      clearTimeout(timeoutId);
+      timeoutId = null;
+    }
+  };
+  const timeoutPromise = new Promise((_, reject) => {
+    const schedule = () => {
+      clearTimer();
+      if (settled) {
+        return;
+      }
+      const latestRun = runRegistry.getRun(runId);
+      if (latestRun?.status === 'canceled') {
+        reject(createRunCanceledError({
+          provider,
+          sessionId,
+          clientRequestId,
+          run: latestRun,
+        }));
+        return;
+      }
+      if (latestRun?.status === 'awaiting_approval' || latestRun?.status === 'awaiting_input') {
+        return;
+      }
+      timeoutId = setTimeout(() => {
+        reject(createRunInactivityTimeoutError({
+          timeoutMs,
+          provider,
+          sessionId,
+          clientRequestId,
+          run: runRegistry.getRun(runId),
+        }));
+      }, timeoutMs);
+    };
+    unsubscribe = runRegistry.subscribeRunEvents(runId, () => {
+      queueMicrotask(schedule);
+    });
+    schedule();
+  });
+
+  return Promise.race([promise, timeoutPromise]).finally(() => {
+    settled = true;
+    clearTimer();
+    unsubscribe?.();
+  });
+}
+
+function shouldEmitTerminalRunState(currentStatus, nextStatus) {
+  const current = String(currentStatus || '').trim().toLowerCase();
+  const next = String(nextStatus || '').trim().toLowerCase();
+  if (!TERMINAL_STATUSES.has(current)) {
+    return true;
+  }
+  return current === next;
+}
+
+function sendBadRequest(res, message) {
+  return res.status(400).json({
+    success: false,
+    error: message,
+  });
+}
+
+function emitRunState({ runRegistry, writer = null, runId, provider, sessionId = null, clientRequestId = null, status, event = {} }) {
+  const updatedRun = runRegistry.updateRun(runId, {
+    status,
+    sessionId,
+    clientRequestId,
+  }) || runRegistry.getRun(runId);
+  const runEvent = runRegistry.appendRunEvent(runId, {
+    type: 'run-state',
+    provider,
+    sessionId: updatedRun?.sessionId || sessionId,
+    clientRequestId,
+    event: {
+      status,
+      ...event,
+    },
+  });
+
+  writer?.send?.({
+    type: 'run-state',
+    provider,
+    sessionId: updatedRun?.sessionId || sessionId,
+    clientRequestId,
+    runId,
+    runEventSeq: runEvent?.seq || updatedRun?.lastEventSeq || null,
+    run: updatedRun,
+    event: {
+      status,
+      ...event,
+    },
+  });
+
+  return {
+    run: updatedRun,
+    event: runEvent,
+  };
+}
+
+function appendSubmittedPromptRunEvent({
+  writer,
+  provider,
+  sessionId = null,
+  clientRequestId = null,
+  command = '',
+  options = {},
+}) {
+  const promptText = String(command || '');
+  if (!promptText.trim()) {
+    return;
+  }
+
+  const contentBlocks = [
+    ...(Array.isArray(options.images)
+      ? options.images.map((image, index) => ({
+          type: 'image',
+          data: image?.data || image?.image || '',
+          mimeType: image?.mimeType || 'application/octet-stream',
+          name: image?.name || image?.filename || `image-${index + 1}`,
+        }))
+      : []),
+    ...(Array.isArray(options.resourceLinks) ? options.resourceLinks : []),
+  ];
+
+  writer?.send?.({
+    type: 'conversation-event',
+    provider,
+    sessionId,
+    clientRequestId,
+    event: createConversationEvent({
+      kind: CONVERSATION_EVENT_KINDS.USER_MESSAGE,
+      provider,
+      sessionId,
+      payload: {
+        text: promptText,
+        contentBlocks,
+      },
+      extensions: clientRequestId ? { clientRequestId } : {},
+      rawRef: {
+        runtime: 'acp',
+        sourceType: 'run-submitted-prompt',
+      },
+    }),
+  });
+}
+
+function writeSseFrame(res, eventName, payload = {}) {
+  res.write(`event: ${eventName}\n`);
+  res.write(`data: ${JSON.stringify(payload)}\n\n`);
+}
+
+function eventNameForRunEvent(runEvent) {
+  if (runEvent?.type === 'run-state') return 'run-state';
+  return 'conversation-event';
+}
+
+export function createRunsRouter({
+  runRegistry = defaultRunRegistry,
+  executeRun = async ({ agentKey, command, options, writer }) => executeAgentPrompt({
+    agentKey,
+    command,
+    options,
+    writer,
+  }),
+  cancelRun = async ({ provider, sessionId }) => abortAgentSession(provider, sessionId),
+  resolvePermission = resolveAgentPermission,
+  resolveElicitation = resolveAgentElicitation,
+  env = process.env,
+  runInactivityTimeoutMs = normalizePositiveInteger(
+    env?.AXHUB_GENIE_RUN_INACTIVITY_TIMEOUT_MS || env?.AXHUB_GENIE_RUN_TIMEOUT_MS || env?.ACP_PROMPT_TIMEOUT_MS || env?.AXHUB_GENIE_ACP_PROMPT_TIMEOUT_MS,
+    DEFAULT_RUN_INACTIVITY_TIMEOUT_MS,
+  ),
+  runTimeoutMs,
+} = {}) {
+  const effectiveRunInactivityTimeoutMs = normalizePositiveInteger(runInactivityTimeoutMs ?? runTimeoutMs, DEFAULT_RUN_INACTIVITY_TIMEOUT_MS);
+  const router = express.Router();
+
+  router.post('/runs', (req, res) => {
+    const provider = normalizeProvider(req.body?.provider || req.body?.agentKey);
+    const commandType = AGENT_COMMAND_TYPES_BY_PROVIDER.get(provider);
+    const command = typeof req.body?.command === 'string'
+      ? req.body.command
+      : typeof req.body?.message === 'string'
+        ? req.body.message
+        : '';
+
+    if (!command.trim()) {
+      return sendBadRequest(res, 'command must be a non-empty string');
+    }
+
+    const clientRequestId = normalizeNullableString(req.body?.clientRequestId || req.body?.options?.clientRequestId);
+    const sessionId = normalizeNullableString(req.body?.sessionId || req.body?.options?.sessionId);
+    const run = runRegistry.createRun({
+      provider,
+      sessionId,
+      clientRequestId,
+    });
+    const baseWriter = new NullRunWriter();
+    const writer = new SessionEventMirrorWriter(baseWriter, provider, {
+      runRegistry,
+      runId: run.runId,
+      clientRequestId,
+    });
+    const requestOptions = req.body?.options && typeof req.body.options === 'object'
+      ? req.body.options
+      : {};
+    const agentCommandOverrides = mergeAgentCommandOverrides(
+      env?.AXHUB_ACP_COMMAND_OVERRIDES,
+      requestOptions.agentCommandOverrides,
+    );
+    const options = {
+      ...requestOptions,
+      ...(Object.keys(agentCommandOverrides).length > 0 ? { agentCommandOverrides } : {}),
+      ...(sessionId ? { sessionId } : {}),
+      ...(clientRequestId ? { clientRequestId } : {}),
+    };
+
+    emitRunState({
+      runRegistry,
+      writer: baseWriter,
+      runId: run.runId,
+      provider,
+      sessionId,
+      clientRequestId,
+      status: 'queued',
+      event: { reason: 'accepted', commandType },
+    });
+
+    appendSubmittedPromptRunEvent({
+      writer,
+      provider,
+      sessionId,
+      clientRequestId,
+      command,
+      options,
+    });
+
+    setImmediate(async () => {
+      try {
+        emitRunState({
+          runRegistry,
+          writer: baseWriter,
+          runId: run.runId,
+          provider,
+          sessionId: writer.getSessionId?.() || sessionId,
+          clientRequestId,
+          status: 'running',
+          event: { reason: 'execution_started' },
+        });
+        const result = await withRunActivityWatchdog(executeRun({
+          agentKey: provider,
+          command,
+          options,
+          writer,
+          run,
+        }), {
+          runRegistry,
+          runId: run.runId,
+          provider,
+          sessionId: writer.getSessionId?.() || sessionId,
+          clientRequestId,
+          timeoutMs: effectiveRunInactivityTimeoutMs,
+        });
+        if (shouldEmitTerminalRunState(runRegistry.getRun(run.runId)?.status, 'succeeded')) {
+          emitRunState({
+            runRegistry,
+            writer: baseWriter,
+            runId: run.runId,
+            provider,
+            sessionId: result?.sessionId || writer.getSessionId?.() || sessionId,
+            clientRequestId,
+            status: 'succeeded',
+            event: {
+              sessionId: result?.sessionId || writer.getSessionId?.() || sessionId,
+              stopReason: result?.stopReason || null,
+            },
+          });
+        }
+      } catch (error) {
+        const failedSessionId = writer.getSessionId?.() || sessionId;
+        const errorPayload = {
+          message: error?.message || 'Run failed',
+          ...(error?.code ? { code: error.code } : {}),
+          ...(error?.details ? { details: error.details } : {}),
+        };
+        if (error?.code !== 'RUN_CANCELED') {
+          writer.send({
+            type: 'conversation-event',
+            provider,
+            sessionId: failedSessionId,
+            clientRequestId,
+            event: createConversationEvent({
+              kind: CONVERSATION_EVENT_KINDS.ERROR,
+              provider,
+              sessionId: failedSessionId,
+              payload: errorPayload,
+              extensions: clientRequestId ? { clientRequestId } : {},
+              rawRef: {
+                type: 'run-error',
+                runId: run.runId,
+              },
+            }),
+          });
+        }
+        if (shouldEmitTerminalRunState(runRegistry.getRun(run.runId)?.status, 'failed')) {
+          emitRunState({
+            runRegistry,
+            writer: baseWriter,
+            runId: run.runId,
+            provider,
+            sessionId: failedSessionId,
+            clientRequestId,
+            status: 'failed',
+            event: {
+              error: error?.message || 'Run failed',
+              ...(error?.code ? { code: error.code } : {}),
+              ...(error?.details ? { details: error.details } : {}),
+            },
+          });
+        }
+      }
+    });
+
+    return res.status(202).json({
+      success: true,
+      runId: run.runId,
+      status: run.status,
+      run,
+    });
+  });
+
+  router.get('/runs/:runId', (req, res) => {
+    const run = runRegistry.getRun(req.params.runId);
+    if (!run) {
+      return sendRunNotFound(res, req.params.runId);
+    }
+
+    return res.json({
+      success: true,
+      run,
+    });
+  });
+
+  router.get('/runs/:runId/events', (req, res) => {
+    const run = runRegistry.getRun(req.params.runId);
+    if (!run) {
+      return sendRunNotFound(res, req.params.runId);
+    }
+
+    return res.json({
+      success: true,
+      run,
+      events: runRegistry.listRunEvents(run.runId, {
+        after: parseAfterSeq(req.query.after),
+      }),
+    });
+  });
+
+  router.get('/runs/:runId/stream', (req, res) => {
+    const run = runRegistry.getRun(req.params.runId);
+    if (!run) {
+      return sendRunNotFound(res, req.params.runId);
+    }
+
+    res.status(200);
+    res.setHeader('Content-Type', 'text/event-stream; charset=utf-8');
+    res.setHeader('Cache-Control', 'no-cache, no-transform');
+    res.setHeader('Connection', 'keep-alive');
+    res.flushHeaders?.();
+
+    res.write(': connected\n\n');
+
+    const sendRunEvent = (runEvent) => {
+      writeSseFrame(res, eventNameForRunEvent(runEvent), runEvent);
+      const status = runEvent?.type === 'run-state'
+        ? String(runEvent.event?.status || '').trim().toLowerCase()
+        : '';
+      if (TERMINAL_STATUSES.has(status)) {
+        writeSseFrame(res, 'end', {
+          runId: run.runId,
+          status,
+          seq: runEvent.seq,
+          provider: runEvent.provider || run.provider,
+          sessionId: runEvent.sessionId || run.sessionId,
+          clientRequestId: runEvent.clientRequestId || run.clientRequestId,
+        });
+        cleanup();
+        res.end();
+      }
+    };
+
+    const cleanup = () => {
+      clearInterval(keepAliveTimer);
+      unsubscribe();
+    };
+
+    const replayEvents = runRegistry.listRunEvents(run.runId, {
+      after: parseAfterSeq(req.query.after),
+    });
+
+    const unsubscribe = runRegistry.subscribeRunEvents(run.runId, sendRunEvent);
+    const keepAliveTimer = setInterval(() => {
+      if (!res.writableEnded) {
+        res.write(': keepalive\n\n');
+      }
+    }, 25_000);
+    keepAliveTimer.unref?.();
+
+    req.on('close', cleanup);
+    replayEvents.forEach(sendRunEvent);
+
+    const latestRun = runRegistry.getRun(run.runId);
+    if (latestRun && TERMINAL_STATUSES.has(latestRun.status) && replayEvents.length === 0) {
+      writeSseFrame(res, 'end', {
+        runId: run.runId,
+        status: latestRun.status,
+        seq: latestRun.lastEventSeq,
+        provider: latestRun.provider,
+        sessionId: latestRun.sessionId,
+        clientRequestId: latestRun.clientRequestId,
+      });
+      cleanup();
+      res.end();
+    }
+  });
+
+  router.post('/runs/:runId/cancel', async (req, res) => {
+    const run = runRegistry.getRun(req.params.runId);
+    if (!run) {
+      return sendRunNotFound(res, req.params.runId);
+    }
+
+    const sessionId = normalizeNullableString(req.body?.sessionId) || run.sessionId;
+    let canceled = false;
+    if (sessionId) {
+      canceled = await cancelRun({
+        runId: run.runId,
+        provider: run.provider,
+        sessionId,
+      });
+    }
+
+    const { run: updatedRun } = emitRunState({
+      runRegistry,
+      runId: run.runId,
+      provider: run.provider,
+      sessionId,
+      clientRequestId: run.clientRequestId,
+      status: 'canceled',
+      event: {
+        reason: canceled ? 'cancel_requested' : 'cancel_recorded',
+        canceled,
+      },
+    });
+
+    return res.json({
+      success: true,
+      canceled,
+      run: updatedRun,
+    });
+  });
+
+  router.post('/runs/:runId/permission', (req, res) => {
+    const run = runRegistry.getRun(req.params.runId);
+    if (!run) {
+      return sendRunNotFound(res, req.params.runId);
+    }
+
+    const requestId = normalizeNullableString(req.body?.requestId);
+    if (!requestId) {
+      return sendBadRequest(res, 'requestId is required');
+    }
+
+    const resolved = resolvePermission(requestId, {
+      allow: Boolean(req.body?.allow),
+      optionId: req.body?.optionId,
+      outcome: req.body?.outcome,
+      cancelled: req.body?.outcome?.outcome === 'cancelled' || Boolean(req.body?.cancelled),
+      updatedInput: req.body?.updatedInput,
+      message: req.body?.message,
+      rememberEntry: req.body?.rememberEntry,
+    });
+
+    return res.json({
+      success: true,
+      resolved,
+      run,
+    });
+  });
+
+  router.post('/runs/:runId/elicitation', (req, res) => {
+    const run = runRegistry.getRun(req.params.runId);
+    if (!run) {
+      return sendRunNotFound(res, req.params.runId);
+    }
+
+    const requestId = normalizeNullableString(req.body?.requestId);
+    if (!requestId) {
+      return sendBadRequest(res, 'requestId is required');
+    }
+
+    const action = normalizeNullableString(req.body?.action) || 'cancel';
+    const resolved = resolveElicitation(requestId, {
+      action,
+      content: req.body?.content && typeof req.body.content === 'object' && !Array.isArray(req.body.content)
+        ? req.body.content
+        : {},
+    });
+
+    return res.json({
+      success: true,
+      resolved,
+      run,
+    });
+  });
+
+  router.get('/sessions/:provider/:sessionId/runs', (req, res) => {
+    return res.json({
+      success: true,
+      runs: runRegistry.listSessionRuns({
+        provider: req.params.provider,
+        sessionId: req.params.sessionId,
+        status: req.query.status,
+      }),
+    });
+  });
+
+  return router;
+}
+
+export default createRunsRouter();