@axhub/genie 0.1.8 → 0.1.9

package/server/utils/agentCallback.js

@@ -0,0 +1,273 @@
+import crypto from 'crypto';
+import fetch from 'node-fetch';
+
+export const DEFAULT_AGENT_CALLBACK_EVENTS = ['completed', 'errored', 'aborted'];
+const VALID_AGENT_CALLBACK_EVENTS = new Set(DEFAULT_AGENT_CALLBACK_EVENTS);
+const CALLBACK_ATTEMPT_TIMEOUT_MS = 5000;
+const CALLBACK_RETRY_DELAYS_MS = [0, 1000, 5000];
+
+export function normalizeAgentCallbackConfig(rawCallback) {
+  if (rawCallback == null) {
+    return null;
+  }
+
+  if (!rawCallback || typeof rawCallback !== 'object' || Array.isArray(rawCallback)) {
+    throw new Error('callback must be an object');
+  }
+
+  const rawUrl = typeof rawCallback.url === 'string' ? rawCallback.url.trim() : '';
+  if (!rawUrl) {
+    throw new Error('callback.url is required when callback is provided');
+  }
+
+  let parsedUrl;
+  try {
+    parsedUrl = new URL(rawUrl);
+  } catch {
+    throw new Error('callback.url must be a valid URL');
+  }
+
+  if (!['http:', 'https:'].includes(parsedUrl.protocol)) {
+    throw new Error('callback.url must use http or https');
+  }
+
+  if (rawCallback.secret !== undefined && typeof rawCallback.secret !== 'string') {
+    throw new Error('callback.secret must be a string when provided');
+  }
+
+  const eventsInput = rawCallback.events === undefined
+    ? DEFAULT_AGENT_CALLBACK_EVENTS
+    : rawCallback.events;
+
+  if (!Array.isArray(eventsInput)) {
+    throw new Error('callback.events must be an array when provided');
+  }
+
+  const normalizedEvents = [];
+  for (const event of eventsInput) {
+    if (typeof event !== 'string') {
+      throw new Error('callback.events must only contain strings');
+    }
+
+    const normalizedEvent = event.trim().toLowerCase();
+    if (!VALID_AGENT_CALLBACK_EVENTS.has(normalizedEvent)) {
+      throw new Error('callback.events can only include completed, errored, or aborted');
+    }
+
+    if (!normalizedEvents.includes(normalizedEvent)) {
+      normalizedEvents.push(normalizedEvent);
+    }
+  }
+
+  return {
+    url: parsedUrl.toString(),
+    events: normalizedEvents,
+    secret: rawCallback.secret ? rawCallback.secret : null
+  };
+}
+
+export function shouldDeliverAgentCallback(callbackConfig, event) {
+  return !!(callbackConfig && callbackConfig.events.includes(event));
+}
+
+export function createAgentCallbackEventId() {
+  if (typeof crypto.randomUUID === 'function') {
+    return `agentcb_${crypto.randomUUID()}`;
+  }
+
+  return `agentcb_${Date.now()}_${Math.random().toString(36).slice(2, 10)}`;
+}
+
+export function createEmptyTokenSummary() {
+  return {
+    inputTokens: 0,
+    outputTokens: 0,
+    cacheReadTokens: 0,
+    cacheCreationTokens: 0,
+    totalTokens: 0
+  };
+}
+
+function normalizeResult(result = {}) {
+  return {
+    sessionPath: result.sessionPath ?? null,
+    sessionUrl: result.sessionUrl ?? null,
+    messages: Array.isArray(result.messages) ? result.messages : [],
+    tokens: result.tokens && typeof result.tokens === 'object'
+      ? {
+          inputTokens: Number(result.tokens.inputTokens) || 0,
+          outputTokens: Number(result.tokens.outputTokens) || 0,
+          cacheReadTokens: Number(result.tokens.cacheReadTokens) || 0,
+          cacheCreationTokens: Number(result.tokens.cacheCreationTokens) || 0,
+          totalTokens: Number(result.tokens.totalTokens) || 0
+        }
+      : createEmptyTokenSummary(),
+    branch: result.branch ?? null,
+    pullRequest: result.pullRequest ?? null
+  };
+}
+
+export function buildAgentCallbackPayload({
+  event,
+  eventId,
+  sessionId = null,
+  provider,
+  projectPath = null,
+  isResumed = false,
+  startedAt,
+  finishedAt,
+  result,
+  error = null
+}) {
+  const success = event === 'completed';
+
+  return {
+    event,
+    eventId,
+    sessionId,
+    provider,
+    status: event,
+    success,
+    projectPath,
+    isResumed,
+    startedAt,
+    finishedAt,
+    result: normalizeResult(result),
+    error: error ? { message: error.message || String(error) } : null
+  };
+}
+
+export function signAgentCallbackBody(secret, rawBody) {
+  const digest = crypto.createHmac('sha256', secret).update(rawBody).digest('hex');
+  return `sha256=${digest}`;
+}
+
+function getCallbackTargetHost(url) {
+  try {
+    return new URL(url).host;
+  } catch {
+    return url;
+  }
+}
+
+function sleep(ms) {
+  return new Promise((resolve) => {
+    setTimeout(resolve, ms);
+  });
+}
+
+export async function deliverAgentCallbackAttempt({
+  callback,
+  payload,
+  eventId,
+  attempt,
+  logger = console
+}) {
+  const rawBody = JSON.stringify(payload);
+  const headers = {
+    'Content-Type': 'application/json',
+    'User-Agent': 'Axhub-Genie-Callback/1.0',
+    'X-Agent-Event': payload.event,
+    'X-Agent-Event-Id': eventId,
+    'X-Agent-Delivery-Attempt': String(attempt),
+  };
+
+  if (callback.secret) {
+    headers['X-Agent-Signature'] = signAgentCallbackBody(callback.secret, rawBody);
+  }
+
+  const controller = new AbortController();
+  const timeoutId = setTimeout(() => controller.abort(), CALLBACK_ATTEMPT_TIMEOUT_MS);
+  const host = getCallbackTargetHost(callback.url);
+
+  try {
+    const response = await fetch(callback.url, {
+      method: 'POST',
+      headers,
+      body: rawBody,
+      signal: controller.signal
+    });
+
+    const retryable = response.status >= 500;
+    logger.info?.(
+      `[AgentCallback] attempt=${attempt} eventId=${eventId} sessionId=${payload.sessionId || 'unknown'} host=${host} status=${response.status}`
+    );
+
+    return {
+      ok: response.ok,
+      status: response.status,
+      retryable
+    };
+  } catch (error) {
+    const isAbortTimeout = error?.name === 'AbortError';
+    logger.warn?.(
+      `[AgentCallback] attempt=${attempt} eventId=${eventId} sessionId=${payload.sessionId || 'unknown'} host=${host} error=${isAbortTimeout ? 'timeout' : (error.message || error)}`
+    );
+
+    return {
+      ok: false,
+      status: null,
+      retryable: true,
+      error
+    };
+  } finally {
+    clearTimeout(timeoutId);
+  }
+}
+
+export async function deliverAgentCallbackWithRetry({
+  callback,
+  payload,
+  logger = console
+}) {
+  const eventId = payload.eventId;
+  let finalResult = null;
+
+  for (let index = 0; index < CALLBACK_RETRY_DELAYS_MS.length; index += 1) {
+    const attempt = index + 1;
+    const delayMs = CALLBACK_RETRY_DELAYS_MS[index];
+
+    if (delayMs > 0) {
+      await sleep(delayMs);
+    }
+
+    const result = await deliverAgentCallbackAttempt({
+      callback,
+      payload,
+      eventId,
+      attempt,
+      logger
+    });
+    finalResult = result;
+
+    if (result.ok) {
+      return result;
+    }
+
+    if (!result.retryable || attempt >= CALLBACK_RETRY_DELAYS_MS.length) {
+      break;
+    }
+  }
+
+  logger.warn?.(
+    `[AgentCallback] delivery_failed eventId=${eventId} sessionId=${payload.sessionId || 'unknown'} host=${getCallbackTargetHost(callback.url)} status=${finalResult?.status ?? 'n/a'}`
+  );
+
+  return finalResult;
+}
+
+export function scheduleAgentCallbackDelivery({
+  callback,
+  payload,
+  logger = console
+}) {
+  return Promise.resolve().then(() => deliverAgentCallbackWithRetry({
+    callback,
+    payload,
+    logger
+  })).catch((error) => {
+    logger.warn?.(
+      `[AgentCallback] unexpected_delivery_error eventId=${payload?.eventId || 'unknown'} error=${error.message || error}`
+    );
+  });
+}

package/server/utils/codexPath.js

@@ -0,0 +1,47 @@
+import path from 'path';
+import { fileURLToPath } from 'url';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
+export function getBundledCodexPath() {
+  const { platform, arch } = process;
+  let targetTriple = null;
+
+  if (platform === 'darwin') {
+    if (arch === 'arm64') targetTriple = 'aarch64-apple-darwin';
+    if (arch === 'x64') targetTriple = 'x86_64-apple-darwin';
+  } else if (platform === 'linux' || platform === 'android') {
+    if (arch === 'arm64') targetTriple = 'aarch64-unknown-linux-musl';
+    if (arch === 'x64') targetTriple = 'x86_64-unknown-linux-musl';
+  } else if (platform === 'win32') {
+    if (arch === 'arm64') targetTriple = 'aarch64-pc-windows-msvc';
+    if (arch === 'x64') targetTriple = 'x86_64-pc-windows-msvc';
+  }
+
+  if (!targetTriple) {
+    throw new Error(`Unsupported Codex platform: ${platform} (${arch})`);
+  }
+
+  const binaryName = platform === 'win32' ? 'codex.exe' : 'codex';
+  return path.join(
+    __dirname,
+    '..',
+    '..',
+    'node_modules',
+    '@openai',
+    'codex-sdk',
+    'vendor',
+    targetTriple,
+    'codex',
+    binaryName
+  );
+}
+
+export function getCodexPathOverride() {
+  if (process.platform === 'win32') {
+    return path.join(__dirname, '..', 'bin', 'codex-sdk-wrapper.cmd');
+  }
+
+  return path.join(__dirname, '..', 'bin', 'codex-sdk-wrapper.js');
+}