@axhub/genie 0.2.10 → 0.2.12

package/server/session-core/runtimeWriter.js

@@ -2,16 +2,41 @@ import {
   isConversationEvent,
   normalizeRealtimePayloadToConversationEvents
 } from '../../shared/conversationEvents.js';
-import { appendMirroredConversationEvents } from './eventStore.js';
 import { publishSessionRuntimeStateChanges } from './runtimeState.js';
 
+function shouldSendNormalizedEventsBeforeRawPayload(data) {
+  if (!data || data.type === 'conversation-event') {
+    return false;
+  }
+
+  if (data.type === 'claude-response') {
+    const dataType = data.data?.type;
+    return dataType === 'content_block_delta' || dataType === 'content_block_stop';
+  }
+
+  if (data.type === 'codex-response') {
+    const dataType = data.data?.type;
+    return dataType === 'item_delta' || dataType === 'item_done';
+  }
+
+  return false;
+}
+
+function isRuntimeReplayConversationEvent(event) {
+  const sourceType = String(event?.rawRef?.sourceType || '').trim().toLowerCase();
+  return Boolean(event?.extensions?.runtimeReplay) || sourceType === 'acp-session-loaded-replay';
+}
+
 export class SessionEventMirrorWriter {
-  constructor(writer, provider = 'claude') {
+  constructor(writer, provider = 'claude', options = {}) {
     this.writer = writer;
     this.provider = provider;
     this.sessionId = null;
     this.isWebSocketWriter = writer?.isWebSocketWriter;
     this.isSSEStreamWriter = writer?.isSSEStreamWriter;
+    this.runRegistry = options.runRegistry || null;
+    this.runId = options.runId || null;
+    this.clientRequestId = options.clientRequestId || null;
   }
 
   send(data) {
@@ -19,8 +44,6 @@ export class SessionEventMirrorWriter {
       this.sessionId = data.sessionId;
     }
 
-    this.writer.send(data);
-
     const normalizedEvents = data?.type === 'conversation-event' && isConversationEvent(data?.event)
       ? [data.event]
       : normalizeRealtimePayloadToConversationEvents({
@@ -29,21 +52,28 @@ export class SessionEventMirrorWriter {
           sessionId: data?.sessionId || this.sessionId
         }, this.provider);
 
-    normalizedEvents.forEach((event) => {
+    const sendNormalizedEvents = () => normalizedEvents.forEach((event) => {
       if (!(data?.type === 'conversation-event' && data?.event?.eventId === event.eventId)) {
-        this.writer.send({
+        this.writer.send(this.annotateConversationEventPayload({
           type: 'conversation-event',
           provider: event.provider,
           sessionId: event.sessionId,
           event
-        });
+        }, event));
       }
     });
 
+    if (data?.type === 'conversation-event' && isConversationEvent(data?.event)) {
+      this.writer.send(this.annotateConversationEventPayload(data, data.event));
+    } else if (shouldSendNormalizedEventsBeforeRawPayload(data)) {
+      sendNormalizedEvents();
+      this.writer.send(data);
+    } else {
+      this.writer.send(data);
+      sendNormalizedEvents();
+    }
+
     if (normalizedEvents.length > 0) {
-      void appendMirroredConversationEvents(normalizedEvents).catch((error) => {
-        console.warn('[WARN] Failed to persist mirrored conversation events:', error.message);
-      });
       void publishSessionRuntimeStateChanges(normalizedEvents).catch((error) => {
         console.warn('[WARN] Failed to publish runtime state changes:', error.message);
       });
@@ -63,4 +93,96 @@ export class SessionEventMirrorWriter {
     }
     return this.sessionId;
   }
+
+  setRunContext({ runId, clientRequestId, runRegistry } = {}) {
+    if (runId !== undefined) {
+      this.runId = runId;
+    }
+    if (clientRequestId !== undefined) {
+      this.clientRequestId = clientRequestId;
+    }
+    if (runRegistry !== undefined) {
+      this.runRegistry = runRegistry;
+    }
+  }
+
+  annotateConversationEventPayload(payload, event) {
+    if (!this.runRegistry || !this.runId || !isConversationEvent(event)) {
+      return payload;
+    }
+
+    const eventSessionId = event.sessionId || payload?.sessionId || this.sessionId || null;
+    if (eventSessionId) {
+      this.sessionId = eventSessionId;
+    }
+
+    if (isRuntimeReplayConversationEvent(event)) {
+      return payload;
+    }
+
+    const eventClientRequestId = event.extensions?.clientRequestId || payload?.clientRequestId || this.clientRequestId || null;
+    const runEvent = this.runRegistry.appendRunEvent(this.runId, {
+      type: 'conversation-event',
+      provider: event.provider || payload?.provider || this.provider,
+      sessionId: eventSessionId,
+      clientRequestId: eventClientRequestId,
+      event,
+    });
+
+    this.updateRunStatusFromConversationEvent(event, {
+      sessionId: eventSessionId,
+      clientRequestId: eventClientRequestId,
+    });
+
+    if (!runEvent) {
+      return payload;
+    }
+
+    return {
+      ...payload,
+      provider: payload?.provider || event.provider || this.provider,
+      sessionId: payload?.sessionId || eventSessionId,
+      clientRequestId: payload?.clientRequestId || eventClientRequestId,
+      runId: this.runId,
+      runEventSeq: runEvent.seq,
+    };
+  }
+
+  updateRunStatusFromConversationEvent(event, { sessionId = null, clientRequestId = null } = {}) {
+    if (!this.runRegistry || !this.runId || !isConversationEvent(event)) {
+      return;
+    }
+
+    const state = event.kind === 'session_state_changed'
+      ? String(event.payload?.state || '').trim().toLowerCase()
+      : '';
+    let status = null;
+
+    if (event.kind === 'approval_request' || state === 'awaiting_approval') {
+      status = 'awaiting_approval';
+    } else if (event.kind === 'elicitation_request' || state === 'awaiting_input') {
+      status = 'awaiting_input';
+    } else if (event.kind === 'error' || state === 'errored') {
+      status = 'failed';
+    } else if (state === 'completed') {
+      status = 'succeeded';
+    } else if (state === 'aborted') {
+      status = 'canceled';
+    } else if (state === 'streaming' || event.kind === 'approval_resolved' || event.kind === 'elicitation_resolved') {
+      status = 'running';
+    }
+
+    if (status) {
+      this.runRegistry.updateRun(this.runId, {
+        status,
+        sessionId,
+        clientRequestId,
+      });
+    } else if (sessionId || clientRequestId) {
+      this.runRegistry.updateRun(this.runId, {
+        sessionId,
+        clientRequestId,
+      });
+    }
+  }
 }

package/server/utils/codexImagePlayground.js

@@ -0,0 +1,479 @@
+import { promises as fs } from 'fs';
+import os from 'os';
+import path from 'path';
+import TOML from '@iarna/toml';
+
+export const CODEX_IMAGE_MODEL = 'gpt-image-2';
+const DEFAULT_OPENAI_BASE_URL = 'https://api.openai.com/v1';
+const PROJECT_IMAGE_CONFIG_FILENAMES = [
+  path.join('.codex', 'imagegen.config.local.json'),
+  path.join('.codex', 'imagegen.config.json')
+];
+
+function dedupePaths(paths) {
+  const seen = new Set();
+  const result = [];
+
+  for (const item of paths) {
+    if (typeof item !== 'string' || !item.trim()) {
+      continue;
+    }
+
+    const key = item.trim();
+    if (seen.has(key)) {
+      continue;
+    }
+
+    seen.add(key);
+    result.push(key);
+  }
+
+  return result;
+}
+
+function splitPathList(value, delimiter = path.delimiter) {
+  if (typeof value !== 'string' || !value.trim()) {
+    return [];
+  }
+
+  return value
+    .split(delimiter)
+    .map((item) => item.trim())
+    .filter(Boolean);
+}
+
+function getUnixConfigDirs(env = {}) {
+  const dirs = [];
+  const configuredDirs = splitPathList(env.XDG_CONFIG_DIRS || '', ':');
+
+  if (configuredDirs.length) {
+    dirs.push(...configuredDirs);
+  } else {
+    dirs.push('/etc/xdg');
+  }
+
+  dirs.push('/etc');
+  return dedupePaths(dirs);
+}
+
+function getWindowsConfigDirs(env = {}, homeDir = os.homedir()) {
+  return dedupePaths([
+    env.APPDATA ? path.win32.join(env.APPDATA, 'Codex') : null,
+    env.LOCALAPPDATA ? path.win32.join(env.LOCALAPPDATA, 'Codex') : null,
+    env.PROGRAMDATA ? path.win32.join(env.PROGRAMDATA, 'Codex') : 'C:\\ProgramData\\Codex',
+    path.win32.join(homeDir, 'AppData', 'Roaming', 'Codex'),
+    path.win32.join(homeDir, 'AppData', 'Local', 'Codex')
+  ]);
+}
+
+export function createCodexConfigPaths({
+  platform = process.platform,
+  homeDir = os.homedir(),
+  env = process.env
+} = {}) {
+  const useWin32 = platform === 'win32';
+  const pathApi = useWin32 ? path.win32 : path.posix;
+  const codexHome = pathApi.join(homeDir, '.codex');
+  const configuredCodexHome = typeof env.CODEX_HOME === 'string' && env.CODEX_HOME.trim()
+    ? env.CODEX_HOME.trim()
+    : null;
+  const configDirs = [];
+
+  if (useWin32) {
+    configDirs.push(...getWindowsConfigDirs(env, homeDir));
+  } else {
+    const xdgConfigHome = env.XDG_CONFIG_HOME
+      ? pathApi.join(env.XDG_CONFIG_HOME, 'codex')
+      : pathApi.join(homeDir, '.config', 'codex');
+    configDirs.push(xdgConfigHome);
+    configDirs.push(...getUnixConfigDirs(env).map((dir) => pathApi.join(dir, 'codex')));
+
+    if (platform === 'darwin') {
+      configDirs.push('/Library/Application Support/Codex');
+    }
+  }
+
+  const roots = dedupePaths([configuredCodexHome, codexHome, ...configDirs]);
+  return {
+    authPaths: roots.map((root) => pathApi.join(root, 'auth.json')),
+    configPaths: roots.map((root) => pathApi.join(root, 'config.toml'))
+  };
+}
+
+function createProjectImageConfigPaths(projectPath) {
+  if (typeof projectPath !== 'string' || !projectPath.trim()) {
+    return [];
+  }
+
+  const root = path.resolve(projectPath.trim());
+  return PROJECT_IMAGE_CONFIG_FILENAMES.map((filename) => path.join(root, filename));
+}
+
+async function readExistingTextFiles(paths) {
+  const files = [];
+
+  for (const filePath of paths) {
+    try {
+      files.push({
+        path: filePath,
+        content: await fs.readFile(filePath, 'utf8')
+      });
+    } catch (error) {
+      if (error.code !== 'ENOENT' && error.code !== 'ENOTDIR') {
+        throw error;
+      }
+    }
+  }
+
+  return files;
+}
+
+function mergePlainObjects(base, override) {
+  const next = { ...(base || {}) };
+  for (const [key, value] of Object.entries(override || {})) {
+    if (
+      value &&
+      typeof value === 'object' &&
+      !Array.isArray(value) &&
+      next[key] &&
+      typeof next[key] === 'object' &&
+      !Array.isArray(next[key])
+    ) {
+      next[key] = mergePlainObjects(next[key], value);
+    } else {
+      next[key] = value;
+    }
+  }
+  return next;
+}
+
+function parseConfigFiles(files) {
+  const warnings = [];
+  let config = {};
+
+  for (const file of files) {
+    try {
+      config = mergePlainObjects(config, TOML.parse(file.content));
+    } catch (error) {
+      warnings.push({
+        path: file.path,
+        message: `Failed to parse Codex config: ${error.message}`
+      });
+    }
+  }
+
+  return { config, warnings };
+}
+
+function normalizeBaseUrl(value) {
+  const trimmed = String(value || '').trim();
+  if (!trimmed) {
+    return DEFAULT_OPENAI_BASE_URL;
+  }
+
+  return trimmed.replace(/\/+$/, '');
+}
+
+function getActiveProvider(config) {
+  const providerId = typeof config?.model_provider === 'string'
+    ? config.model_provider.trim()
+    : '';
+  const providers = config?.model_providers && typeof config.model_providers === 'object'
+    ? config.model_providers
+    : {};
+  const provider = providerId ? providers[providerId] : null;
+
+  return {
+    providerId: providerId || null,
+    provider: provider && typeof provider === 'object' ? provider : null
+  };
+}
+
+function getApiMode(provider) {
+  const wireApi = typeof provider?.wire_api === 'string'
+    ? provider.wire_api.trim().toLowerCase()
+    : '';
+
+  return wireApi === 'responses' ? 'images' : 'images';
+}
+
+function getProjectApiMode(value) {
+  return value === 'responses' ? 'responses' : 'images';
+}
+
+function getBooleanLaunchParam(value, fallback = false) {
+  if (typeof value === 'boolean') {
+    return value ? 'true' : 'false';
+  }
+
+  if (typeof value === 'string') {
+    const normalized = value.trim().toLowerCase();
+    if (['true', '1', 'yes', 'on'].includes(normalized)) {
+      return 'true';
+    }
+    if (['false', '0', 'no', 'off'].includes(normalized)) {
+      return 'false';
+    }
+  }
+
+  return fallback ? 'true' : 'false';
+}
+
+function resolveEnvReference(value, env = process.env) {
+  if (typeof value !== 'string') {
+    return '';
+  }
+
+  const trimmed = value.trim();
+  if (!trimmed) {
+    return '';
+  }
+
+  if (trimmed.startsWith('env:')) {
+    const envName = trimmed.slice('env:'.length).trim();
+    return envName ? String(env[envName] || '').trim() : '';
+  }
+
+  const envMatch = /^\$\{([A-Za-z_][A-Za-z0-9_]*)\}$/.exec(trimmed);
+  if (envMatch) {
+    return String(env[envMatch[1]] || '').trim();
+  }
+
+  return trimmed;
+}
+
+function getProjectApiKey(config, env = process.env) {
+  if (typeof config?.apiKeyEnv === 'string' && config.apiKeyEnv.trim()) {
+    return String(env[config.apiKeyEnv.trim()] || '').trim();
+  }
+
+  return resolveEnvReference(config?.apiKey || config?.api_key || '', env);
+}
+
+function normalizeProjectConfigObject(value) {
+  if (!value || typeof value !== 'object' || Array.isArray(value)) {
+    return null;
+  }
+
+  const record = value;
+  if (record.profile && typeof record.profile === 'object' && !Array.isArray(record.profile)) {
+    return record.profile;
+  }
+
+  return record;
+}
+
+async function readProjectImageConfig(projectPath, env = process.env) {
+  const paths = createProjectImageConfigPaths(projectPath);
+  const files = await readExistingTextFiles(paths);
+  const warnings = [];
+
+  for (const file of files) {
+    try {
+      const parsed = JSON.parse(file.content);
+      const config = normalizeProjectConfigObject(parsed);
+      if (!config) {
+        warnings.push({
+          path: file.path,
+          message: 'Project image config must be a JSON object.'
+        });
+        continue;
+      }
+
+      const source = typeof config.source === 'string' ? config.source.trim().toLowerCase() : '';
+      if (source === 'codex') {
+        return {
+          config: null,
+          file: file.path,
+          paths,
+          warnings,
+          useCodexConfig: true
+        };
+      }
+
+      const apiKey = getProjectApiKey(config, env);
+      const launchParams = {
+        apiUrl: normalizeBaseUrl(config.apiUrl || config.baseUrl || config.base_url || DEFAULT_OPENAI_BASE_URL),
+        apiKey,
+        apiMode: getProjectApiMode(config.apiMode || config.api_mode),
+        model: typeof config.model === 'string' && config.model.trim()
+          ? config.model.trim()
+          : CODEX_IMAGE_MODEL,
+        codexCli: getBooleanLaunchParam(config.codexCli ?? config.codex_cli, false)
+      };
+
+      if (config.apiProxy !== undefined || config.api_proxy !== undefined) {
+        launchParams.apiProxy = getBooleanLaunchParam(config.apiProxy ?? config.api_proxy, false);
+      }
+
+      const configWarnings = [];
+      if (!apiKey) {
+        const keySource = typeof config.apiKey === 'string' ? config.apiKey.trim() : '';
+        const keyEnv = typeof config.apiKeyEnv === 'string' ? config.apiKeyEnv.trim() : '';
+        configWarnings.push({
+          path: file.path,
+          message: keySource.startsWith('env:') || keyEnv
+            ? 'Project image config references an environment variable, but no API key value was found.'
+            : 'Project image config does not include an API key.'
+        });
+      }
+
+      return {
+        config,
+        file: file.path,
+        paths,
+        launchParams,
+        warnings: [...warnings, ...configWarnings],
+        useCodexConfig: false
+      };
+    } catch (error) {
+      warnings.push({
+        path: file.path,
+        message: `Failed to parse project image config: ${error.message}`
+      });
+    }
+  }
+
+  return {
+    config: null,
+    file: null,
+    paths,
+    warnings,
+    useCodexConfig: false
+  };
+}
+
+function readApiKeyFromAuth(auth) {
+  if (!auth || typeof auth !== 'object') {
+    return '';
+  }
+
+  if (typeof auth.OPENAI_API_KEY === 'string' && auth.OPENAI_API_KEY.trim()) {
+    return auth.OPENAI_API_KEY.trim();
+  }
+
+  if (typeof auth.openaiApiKey === 'string' && auth.openaiApiKey.trim()) {
+    return auth.openaiApiKey.trim();
+  }
+
+  if (typeof auth.api_key === 'string' && auth.api_key.trim()) {
+    return auth.api_key.trim();
+  }
+
+  return '';
+}
+
+async function readFirstAuth(authPaths) {
+  const files = await readExistingTextFiles(authPaths);
+  for (const file of files) {
+    try {
+      const parsed = JSON.parse(file.content);
+      const apiKey = readApiKeyFromAuth(parsed);
+      if (apiKey) {
+        return {
+          apiKey,
+          authFile: file.path
+        };
+      }
+    } catch {
+      // Ignore malformed auth candidates and continue scanning.
+    }
+  }
+
+  return {
+    apiKey: '',
+    authFile: files[0]?.path || null
+  };
+}
+
+export async function resolveCodexImagePlaygroundConfig(options = {}) {
+  const projectConfig = await readProjectImageConfig(options.projectPath, options.env || process.env);
+  if (projectConfig.launchParams && !projectConfig.useCodexConfig) {
+    const ready = Boolean(projectConfig.launchParams.apiKey);
+
+    return {
+      ready,
+      launchParams: projectConfig.launchParams,
+      discovery: {
+        projectConfigFile: projectConfig.file,
+        projectConfigPaths: projectConfig.paths,
+        configSource: 'project'
+      },
+      warnings: projectConfig.warnings
+    };
+  }
+
+  const paths = options.configPaths && options.authPaths
+    ? {
+        configPaths: options.configPaths,
+        authPaths: options.authPaths
+      }
+    : createCodexConfigPaths(options);
+  const configFiles = await readExistingTextFiles(paths.configPaths);
+  const { config, warnings } = parseConfigFiles(configFiles);
+  const { provider } = getActiveProvider(config);
+  const { apiKey, authFile } = await readFirstAuth(paths.authPaths);
+  const apiUrl = normalizeBaseUrl(provider?.base_url || config?.base_url || DEFAULT_OPENAI_BASE_URL);
+  const ready = Boolean(apiKey);
+
+  return {
+    ready,
+    launchParams: {
+      apiUrl,
+      apiKey,
+      apiMode: getApiMode(provider),
+      model: CODEX_IMAGE_MODEL,
+      codexCli: 'true'
+    },
+    discovery: {
+      configFiles: configFiles.map((file) => file.path),
+      authFile,
+      scannedConfigPaths: paths.configPaths,
+      scannedAuthPaths: paths.authPaths,
+      projectConfigFile: projectConfig.file,
+      projectConfigPaths: projectConfig.paths,
+      configSource: 'codex'
+    },
+    warnings: ready ? [...projectConfig.warnings, ...warnings] : [
+      ...projectConfig.warnings,
+      ...warnings,
+      { message: 'No OpenAI API key found in Codex auth files.' }
+    ]
+  };
+}
+
+function normalizeRoutePath(routePath) {
+  const value = typeof routePath === 'string' ? routePath.trim() : '';
+  if (!value.startsWith('/') || value.startsWith('//')) {
+    return '/image-playground';
+  }
+
+  return value;
+}
+
+export function buildCodexImagePlaygroundLaunch({
+  routePath = '/image-playground',
+  config
+} = {}) {
+  const launchParams = config?.launchParams || {};
+  const urlSearchParams = new URLSearchParams();
+
+  for (const [key, value] of Object.entries(launchParams)) {
+    if (typeof value === 'string' && value) {
+      urlSearchParams.set(key, value);
+    }
+  }
+
+  const queryString = urlSearchParams.toString();
+  const safeRoutePath = normalizeRoutePath(routePath);
+  const url = queryString ? `${safeRoutePath}?${queryString}` : safeRoutePath;
+  const { apiKey: _apiKey, ...safeParams } = launchParams;
+
+  return {
+    ready: Boolean(config?.ready),
+    url,
+    params: safeParams,
+    discovery: config?.discovery || {},
+    warnings: config?.warnings || []
+  };
+}

package/server/utils/localTerminal.js

@@ -0,0 +1,56 @@
+import os from 'os';
+import { spawn } from 'child_process';
+
+function escapeAppleScriptString(value) {
+  return String(value).replace(/\\/g, '\\\\').replace(/"/g, '\\"');
+}
+
+export function buildLocalTerminalSpawn({ command, platform = os.platform() }) {
+  const terminalCommand = String(command || '').trim();
+
+  if (!terminalCommand) {
+    throw new Error('Command is required');
+  }
+
+  if (platform === 'darwin') {
+    return {
+      command: 'osascript',
+      args: [
+        '-e',
+        'tell application "Terminal" to activate',
+        '-e',
+        `tell application "Terminal" to do script "${escapeAppleScriptString(terminalCommand)}"`
+      ]
+    };
+  }
+
+  if (platform === 'win32') {
+    return {
+      command: 'cmd.exe',
+      args: [
+        '/c',
+        'start',
+        '',
+        'powershell.exe',
+        '-NoExit',
+        '-Command',
+        terminalCommand
+      ]
+    };
+  }
+
+  return {
+    command: 'x-terminal-emulator',
+    args: ['-e', 'bash', '-lc', terminalCommand]
+  };
+}
+
+export function openLocalTerminal({ command, platform = os.platform() }) {
+  const spawnConfig = buildLocalTerminalSpawn({ command, platform });
+  const child = spawn(spawnConfig.command, spawnConfig.args, {
+    detached: true,
+    stdio: 'ignore'
+  });
+  child.unref();
+  return spawnConfig;
+}