@xuda.io/ai_module 1.1.5589 → 1.1.5590

package/index.mjs

@@ -4,6 +4,7 @@ import { z } from 'zod';
 import fs from 'fs';
 import path from 'node:path';
 import { pathToFileURL } from 'node:url';
+import { spawn } from 'node:child_process';
 
 import sharp from 'sharp';
 
@@ -24,11 +25,133 @@ import process from 'process';
 import { File } from 'node:buffer'; // Node 20+
 const { rm, readFile, unlink, writeFile } = fs.promises;
 
-global._conf = (
-  await import(path.join(process.env.XUDA_HOME, process.env.XUDA_CONFIG), {
-    with: { type: 'json' },
-  })
-).default;
+const run_process = function (command, args, input, options = {}) {
+  return new Promise((resolve, reject) => {
+    const { onStdout, onStderr, ...spawn_options } = options;
+    const child = spawn(command, args, {
+      stdio: ['pipe', 'pipe', 'pipe'],
+      ...spawn_options,
+    });
+
+    let stdout = '';
+    let stderr = '';
+
+    child.stdout.on('data', (chunk) => {
+      const text = chunk.toString();
+      stdout += text;
+      if (onStdout) {
+        onStdout(text);
+      }
+    });
+
+    child.stderr.on('data', (chunk) => {
+      const text = chunk.toString();
+      stderr += text;
+      if (onStderr) {
+        onStderr(text);
+      }
+    });
+
+    child.on('error', reject);
+    child.on('close', (exit_code) => {
+      resolve({ exit_code, stdout, stderr });
+    });
+
+    if (input) {
+      child.stdin.write(input);
+    }
+    child.stdin.end();
+  });
+};
+
+const normalize_boolean = function (value) {
+  if (typeof value === 'string') {
+    return ['true', '1', 'yes', 'on'].includes(value.toLowerCase());
+  }
+
+  return Boolean(value);
+};
+
+const is_valid_codex_remote_host = function (ip) {
+  return typeof ip === 'string' && /^[a-zA-Z0-9.:%@_-]+$/.test(ip) && !ip.startsWith('-') && !ip.includes('..');
+};
+
+const get_codex_remote_host = function (ip) {
+  return ip.includes('@') ? ip : `root@${ip}`;
+};
+
+const get_codex_local_attachment_path = function (attachment) {
+  if (!attachment || typeof attachment !== 'object') return null;
+
+  return attachment.local_path || attachment.local_file_path || (attachment.is_local ? attachment.path || attachment.file_path || attachment.filename : null);
+};
+
+const get_codex_remote_attachment_path = function (attachment) {
+  if (!attachment) return null;
+  if (typeof attachment === 'string') return attachment;
+  if (typeof attachment !== 'object') return null;
+
+  return attachment.remote_path || (attachment.is_remote ? attachment.path || attachment.file_path || attachment.filename : null);
+};
+
+const is_codex_image_attachment = function (attachment_path) {
+  return typeof attachment_path === 'string' && /\.(png|jpe?g|webp|gif)$/i.test(attachment_path);
+};
+
+const parse_codex_jsonl = function (stdout) {
+  const events = [];
+  for (const line of stdout.split(/\r?\n/)) {
+    if (!line.trim()) continue;
+    try {
+      events.push(JSON.parse(line));
+    } catch (err) {
+      return null;
+    }
+  }
+  return events;
+};
+
+const create_codex_jsonl_stream_parser = function (onEvent) {
+  let buffer = '';
+
+  return function (chunk) {
+    buffer += chunk;
+    const lines = buffer.split(/\r?\n/);
+    buffer = lines.pop() || '';
+
+    for (const line of lines) {
+      if (!line.trim()) continue;
+      try {
+        onEvent(JSON.parse(line));
+      } catch (err) {
+        onEvent({
+          type: 'raw',
+          text: line,
+        });
+      }
+    }
+  };
+};
+
+const get_openai_codex_cli_command = function () {
+  return _conf.openai_codex_command || 'codex';
+};
+
+const get_openai_codex_exec_args = function () {
+  const args = ['exec', '--json'];
+  const bypass_approvals_and_sandbox = typeof _conf.openai_codex_bypass_approvals_and_sandbox === 'undefined' ? true : _conf.openai_codex_bypass_approvals_and_sandbox;
+  const sandbox = _conf.openai_codex_sandbox;
+
+  if (bypass_approvals_and_sandbox) {
+    args.push('--dangerously-bypass-approvals-and-sandbox');
+  } else if (sandbox) {
+    args.push('--sandbox', sandbox);
+  }
+
+  return args;
+};
+
+global._conf = JSON.parse(fs.readFileSync(path.join(process.env.XUDA_HOME, process.env.XUDA_CONFIG), 'utf8'));
 
 const _defaultAppConfig = {
   credential: admin.credential.cert(_conf.firebase_serviceAccount),
@@ -1082,6 +1205,259 @@ const check_studio_doc_tool = tool({
   },
 });
 
+export const execute_codex_request = async function (req_or_ip, prompt_arg, attachments_arg = []) {
+  let emitToDashboard = function () {};
+  let streamText = function () {};
+  let stream_enabled = false;
+
+  try {
+    const is_req_call = req_or_ip && typeof req_or_ip === 'object' && !Array.isArray(req_or_ip);
+    const ip = is_req_call ? req_or_ip.ip : req_or_ip;
+    const prompt = is_req_call ? req_or_ip.prompt : prompt_arg;
+    let attachments = is_req_call ? req_or_ip.attachments || [] : attachments_arg;
+    const uid = is_req_call ? req_or_ip.uid : undefined;
+    const conversation_id = is_req_call ? req_or_ip.conversation_id || req_or_ip.conversation_doc?._id : undefined;
+    const job_id = is_req_call ? prompt_arg || req_or_ip.job_id : undefined;
+    stream_enabled = is_req_call ? req_or_ip.stream !== false && req_or_ip.stream !== 'false' : false;
+    const prompt_conversation_item_id = is_req_call ? await _common.xuda_get_uuid('chat_conversation_item') : undefined;
+    const response_conversation_item_id = is_req_call ? await _common.xuda_get_uuid('chat_conversation_item') : undefined;
+
+    let stream_delta_seq = 0;
+    let stream_delta_text = '';
+    let response_started = false;
+
+    emitToDashboard = (type, content, params) => {
+      if (!stream_enabled || !uid) return;
+
+      const is_stream_delta = type === 'stream_delta';
+      const is_stream_end = type === 'stream_end';
+      const seq = is_stream_delta ? ++stream_delta_seq : undefined;
+      if (is_stream_delta) {
+        stream_delta_text += content || '';
+      }
+
+      ws_dashboard_msa.emit_message_to_dashboard({
+        service: type,
+        to: uid,
+        data: {
+          conversation_id,
+          job_id,
+          delta: content,
+          ...(seq ? { seq } : {}),
+          ...(is_stream_end
+            ? {
+                stream_id: response_conversation_item_id,
+                final_seq: stream_delta_seq,
+                text: stream_delta_text,
+              }
+            : {}),
+          prompt_conversation_item_id,
+          response_conversation_item_id,
+          params,
+        },
+      });
+    };
+
+    const ensureResponseStarted = function () {
+      if (!response_started) {
+        response_started = true;
+        emitToDashboard('response_start');
+      }
+    };
+
+    streamText = function (text, chunk_size = 280) {
+      if (!stream_enabled || !text) return;
+      ensureResponseStarted();
+      for (let i = 0; i < text.length; i += chunk_size) {
+        emitToDashboard('stream_delta', text.slice(i, i + chunk_size));
+      }
+    };
+
+    if (!is_valid_codex_remote_host(ip)) {
+      return { code: -1, data: 'invalid remote ip' };
+    }
+
+    if (typeof prompt !== 'string' || !prompt.trim()) {
+      return { code: -2, data: 'prompt is mandatory field' };
+    }
+
+    if (!Array.isArray(attachments)) {
+      attachments = attachments ? [attachments] : [];
+    }
+
+    const reasoning = [];
+    let streamed_agent_messages = new Set();
+    const pushReasoning = function (type, text, metadata = {}) {
+      if (!text) return;
+      reasoning.push({
+        type,
+        text,
+        ...metadata,
+      });
+    };
+
+    const handleCodexEvent = function (event) {
+      if (!event || typeof event !== 'object') return;
+
+      switch (event.type) {
+        case 'thread.started':
+          emitToDashboard('stream_phase', 'Starting Codex thread', { update: true, thread_id: event.thread_id });
+          break;
+        case 'turn.started':
+          emitToDashboard('stream_phase', 'Reasoning through Codex request', { update: true });
+          break;
+        case 'item.started': {
+          const item = event.item || {};
+          if (item.type === 'command_execution') {
+            const command = item.command || '';
+            pushReasoning('command_started', command, { item_id: item.id });
+            emitToDashboard('stream_phase', 'Running remote command', { update: true, command });
+          }
+          break;
+        }
+        case 'item.completed': {
+          const item = event.item || {};
+          if (item.type === 'agent_message') {
+            const text = item.text || '';
+            pushReasoning('agent_message', text, { item_id: item.id });
+            emitToDashboard('stream_phase', text.trim(), { update: true, reasoning: true });
+            if (!streamed_agent_messages.has(item.id)) {
+              streamed_agent_messages.add(item.id);
+              streamText(`${text.trim()}\n\n`);
+            }
+          }
+
+          if (item.type === 'command_execution') {
+            const command = item.command || '';
+            const output = (item.aggregated_output || '').trim();
+            pushReasoning('command_completed', command, {
+              item_id: item.id,
+              exit_code: item.exit_code,
+              status: item.status,
+              output: output.length > 4000 ? `${output.slice(0, 4000)}...` : output,
+            });
+            emitToDashboard('stream_phase', item.exit_code === 0 ? 'Remote command completed' : 'Remote command failed', { update: true, command, exit_code: item.exit_code });
+          }
+          break;
+        }
+        case 'error':
+          pushReasoning('error', event.message);
+          emitToDashboard('stream_phase', event.message, { update: true, error: true });
+          break;
+        case 'turn.completed':
+          emitToDashboard('stream_phase', 'Codex request completed', { update: true, usage: event.usage });
+          break;
+        case 'turn.failed':
+          pushReasoning('error', event.error?.message || 'Codex request failed');
+          emitToDashboard('stream_phase', 'Codex request failed', { update: true, error: true });
+          break;
+        default:
+          break;
+      }
+    };
+
+    const image_paths = [];
+    const local_attachments = [];
+    const remote_attachments = [];
+
+    for (const attachment of attachments) {
+      const attachment_path = get_codex_remote_attachment_path(attachment);
+      const local_attachment_path = get_codex_local_attachment_path(attachment);
+
+      if (local_attachment_path && is_codex_image_attachment(local_attachment_path)) {
+        image_paths.push(local_attachment_path);
+      }
+
+      if (local_attachment_path) {
+        local_attachments.push(local_attachment_path);
+      }
+
+      if (attachment_path) {
+        remote_attachments.push(attachment_path);
+      }
+    }
+
+    emitToDashboard('stream_start');
+    emitToDashboard('stream_phase', 'Starting Codex request');
+
+    let codex_prompt = `You are OpenAI Codex running on the local Xuda server.
+
+The target remote machine is ${get_codex_remote_host(ip)}.
+Execute shell commands on the remote machine through SSH, for example:
+ssh -o BatchMode=yes -o StrictHostKeyChecking=no ${get_codex_remote_host(ip)} "<command>"
+
+Do not assume the current local filesystem is the remote machine. Use SSH for inspection, edits, installs, and command execution unless the user explicitly asks for local work.
+
+User request:
+${prompt}`;
+
+    if (local_attachments.length) {
+      codex_prompt += `\n\nAttachments available to Codex on the local Xuda server:\n${local_attachments.map((attachment_path) => `- ${attachment_path}`).join('\n')}`;
+    }
+
+    if (remote_attachments.length) {
+      codex_prompt += `\n\nAttachments available on the remote machine:\n${remote_attachments.map((attachment_path) => `- ${attachment_path}`).join('\n')}`;
+    }
+
+    const openai_codex_command = get_openai_codex_cli_command();
+    const codex_args = get_openai_codex_exec_args();
+    for (const image_path of image_paths) {
+      codex_args.push('--image', image_path);
+    }
+    codex_args.push('-');
+
+    const ret = await run_process(openai_codex_command, codex_args, codex_prompt, {
+      env: {
+        ...process.env,
+        OPENAI_API_KEY: _conf.OPENAI_API_KEY,
+      },
+      onStdout: create_codex_jsonl_stream_parser(handleCodexEvent),
+    });
+    const events = parse_codex_jsonl(ret.stdout);
+
+    if (ret.exit_code !== 0) {
+      emitToDashboard('stream_phase', 'Codex request failed', { update: true });
+      streamText(`Codex request failed: ${ret.stderr || ret.stdout || `exit code ${ret.exit_code}`}`);
+      emitToDashboard('stream_end');
+
+      return {
+        code: -3,
+        data: {
+          provider: 'openai_codex_cli',
+          remote_host: get_codex_remote_host(ip),
+          command: `${openai_codex_command} ${codex_args.filter((arg) => arg !== '-').join(' ')}`,
+          exit_code: ret.exit_code,
+          stdout: ret.stdout,
+          stderr: ret.stderr,
+          events,
+          reasoning,
+        },
+      };
+    }
+
+    emitToDashboard('stream_end');
+
+    return {
+      code: 0,
+      data: {
+        provider: 'openai_codex_cli',
+        remote_host: get_codex_remote_host(ip),
+        command: `${openai_codex_command} ${codex_args.filter((arg) => arg !== '-').join(' ')}`,
+        stdout: ret.stdout,
+        stderr: ret.stderr,
+        events,
+        reasoning,
+      },
+    };
+  } catch (err) {
+    console.error(err);
+    emitToDashboard('stream_phase', 'Codex request failed', { update: true });
+    streamText(`Codex request failed: ${err.message}`);
+    emitToDashboard('stream_end');
+    return { code: -1, data: err.message };
+  }
+};
+
 export const get_chat_conversation = async function (req) {
   let { conversation_id, order = 'asc', limit = 9999, skip = 0, _id, uid } = req;
 
@@ -1100,6 +1476,7 @@ export const get_chat_conversation = async function (req) {
       conversation_doc = await db_module.get_app_couch_doc_native(reference_doc.shared_from_app_id, reference_doc.share_item_id);
       conversation_doc.reference_doc = reference_doc;
     }
+    conversation_doc.request_started_at = conversation_doc.request_started_at || null;
     let conversation_items = await db_module.find_app_couch_query(account_profile_info.app_id, {
       selector: {
         docType: 'chat_conversation_item',
@@ -1602,6 +1979,7 @@ export const unarchive_ai_chat = async function (req) {
     conversation_doc.stat = 3;
     conversation_doc.ts = Date.now();
     const save_ret = await db_module.save_app_couch_doc(account_profile_info.app_id, conversation_doc);
+    await update_conversation_items_stat(account_profile_info.app_id, 3, conversation_id);
 
     return save_ret;
   } catch (err) {
@@ -2262,7 +2640,7 @@ export const uninstall_ai_agent = async function (req) {
   }
 };
 export const unarchive_ai_agent = async function (req) {
-  let { agent_id, uid } = req;
+  let { agent_id, uid, conversation_id } = req;
 
   const account_profile_info = await get_active_account_profile_info(uid);
 
@@ -2277,8 +2655,9 @@ export const unarchive_ai_agent = async function (req) {
     agent_doc.ts = Date.now();
 
     const save_ret = await db_module.save_app_couch_doc(account_profile_info.app_id, agent_doc);
+    const updated_conversation_items = await update_conversation_stat(account_profile_info.app_id, agent_id, 3, conversation_id);
 
-    return save_ret;
+    return { code: 1, data: { save_ret, updated_conversation_items } };
   } catch (err) {
     return { code: -9, data: err.message };
   }
@@ -2286,11 +2665,12 @@ export const unarchive_ai_agent = async function (req) {
 
 const update_conversation_items_stat = async function (app_id, stat, target_conversation_id) {
   const ts = Date.now();
+  const stat_selector = stat === 5 ? { $lt: 4 } : 5;
   const items_ret = await db_module.find_app_couch_query(app_id, {
     selector: {
       docType: 'chat_conversation_item',
       conversation_id: target_conversation_id,
-      stat: { $lt: 4 },
+      stat: stat_selector,
     },
     limit: 9999,
   });
@@ -3682,7 +4062,7 @@ export const create_openai_conversation = async function () {
 };
 
 export const create_conversation = async function (req, job_id, headers) {
-  const { profile_id, uid, prompt, perform_ai_execution = true, email_id, direction = 'out', from_mailbox, date_created, ai_model = _conf.default_ai_model } = req;
+  const { profile_id, uid, prompt, perform_ai_execution = true, email_id, direction = 'out', from_mailbox, date_created, ai_model = _conf.default_ai_model, plan_mode = false } = req;
   let { reference_type, reference_id = '', conversation_type, email_recipient_type } = req;
 
   const account_profile_info = await get_active_account_profile_info(uid, profile_id);
@@ -3737,6 +4117,7 @@ export const create_conversation = async function (req, job_id, headers) {
       from_mailbox,
       email_recipient_type,
       model: ai_model,
+      plan_mode: normalize_boolean(plan_mode),
     };
     const save_ret = await db_module.save_app_couch_doc(account_profile_info.app_id, conversation_doc);
 
@@ -3925,10 +4306,59 @@ export const submit_chat_conversation = async function (req, job_id, headers) {
     const account_profile_info = await get_active_account_profile_info(uid, profile_id);
 
     let conversation_doc = await db_module.get_app_couch_doc_native(account_profile_info.app_id, conversation_id);
+    const normalized_plan_mode = normalize_boolean(req.plan_mode ?? conversation_doc.plan_mode);
+    const route_to_studio = conversation_doc.conversation_type === 'studio' || req.conversation_type === 'studio' || normalized_plan_mode;
+
+    if (route_to_studio && conversation_doc.conversation_type !== 'studio') {
+      conversation_doc.conversation_type = 'studio';
+      conversation_doc.plan_mode = normalized_plan_mode;
+      await db_module.save_app_couch_doc_native(account_profile_info.app_id, conversation_doc);
+    }
+
+    req.plan_mode = normalized_plan_mode;
     req.conversation_doc = conversation_doc;
     req.metadata = metadata || {};
     let ret;
-    if (conversation_doc.conversation_type === 'studio') {
+
+    switch (conversation_doc.reference_type) {
+      case 'contacts': {
+        req._thread_reentry = Date.now() - conversation_doc.date_created_ts > 60000;
+
+        account_msa.ts_contact(uid, conversation_doc.reference_id);
+
+        switch (conversation_doc.conversation_type) {
+          case 'note': {
+            ret = await chat_note(req, job_id, headers);
+            break;
+          }
+          case 'ai_chat': {
+            ret = await ai_chat_conversation(req, job_id, headers);
+            break;
+          }
+
+          case 'email': {
+            ret = await chat_email(req, job_id, headers);
+            break;
+          }
+
+          case 'chat': {
+            ret = await contact_chat_conversation(req, job_id, headers);
+            break;
+          }
+
+          default:
+            ret = { code: -44, data: 'invalid conversation_type ' + conversation_doc.conversation_type };
+            break;
+        }
+
+        break;
+      }
+
+      default:
+        break;
+    }
+
+    if (route_to_studio) {
       ret = await chat_studio(req, job_id, headers);
     } else if (conversation_doc.reference_type === 'contacts') {
       req._thread_reentry = Date.now() - conversation_doc.date_created_ts > 60000;
@@ -4251,7 +4681,7 @@ const chat_studio = async function (req, job_id, headers) {
   let { prompt, conversation_doc, attachments = [], plan_mode = false, stream = true } = req;
 
   const conversation_id = conversation_doc._id;
-  const normalized_plan_mode = typeof plan_mode === 'string' ? ['true', '1', 'yes', 'on'].includes(plan_mode.toLowerCase()) : Boolean(plan_mode);
+  const normalized_plan_mode = normalize_boolean(plan_mode);
   const save_result_to_studio = normalized_plan_mode ? false : true;
   const plugin_name = '@xuda.io/xuda-library-plugin-studio-ai-app-builder';
   const plugin_method = normalized_plan_mode ? 'app_planner' : 'app_builder';
@@ -4259,6 +4689,7 @@ const chat_studio = async function (req, job_id, headers) {
 
   const prompt_conversation_item_id = await _common.xuda_get_uuid('chat_conversation_item');
   const response_conversation_item_id = await _common.xuda_get_uuid('chat_conversation_item');
+  const request_started_at = Date.now();
 
   let stream_delta_seq = 0;
   let stream_delta_text = '';
@@ -4276,6 +4707,7 @@ const chat_studio = async function (req, job_id, headers) {
         conversation_id,
         job_id,
         delta: content,
+        ...(type === 'stream_start' ? { request_started_at } : {}),
         ...(seq ? { seq } : {}),
         ...(is_stream_end
           ? {
@@ -4432,6 +4864,7 @@ ${conversation_history || `User (studio): ${prompt}`}
 
   try {
     emitToDashboard('stream_start');
+    if (normalized_plan_mode) emitToDashboard('plan_sream_start');
     emitToDashboard('stream_phase', normalized_plan_mode ? 'Planning studio request' : 'Building studio request');
 
     const conversation_item_reference_id = await add_conversation_item(uid, profile_id, conversation_id, prompt, 'studio', undefined, { plan_mode: normalized_plan_mode });
@@ -4470,6 +4903,7 @@ ${conversation_history || `User (studio): ${prompt}`}
     conversation_doc = await db_module.get_app_couch_doc_native(account_profile_info.app_id, conversation_id);
     conversation_doc.ts = Date.now();
     conversation_doc.stat = 2;
+    conversation_doc.request_started_at = request_started_at;
     conversation_doc.job_id = job_id;
     conversation_doc.plan_mode = normalized_plan_mode;
     conversation_doc.target_app_id = target_app_id;
@@ -4544,6 +4978,7 @@ ${conversation_history || `User (studio): ${prompt}`}
 
     emitToDashboard('stream_phase', normalized_plan_mode ? 'Streaming studio plan' : 'Streaming studio result', { update: true });
     streamText(response_text);
+    if (normalized_plan_mode) emitToDashboard('plan_sream_end');
     emitToDashboard('stream_end');
 
     conversation_doc = await db_module.get_app_couch_doc_native(account_profile_info.app_id, conversation_id);
@@ -4590,6 +5025,7 @@ ${conversation_history || `User (studio): ${prompt}`}
     const error_message = get_error_message(err, 'studio request failed');
     emitToDashboard('stream_phase', 'Studio request failed', { update: true });
     streamText(`Studio request failed: ${error_message}`);
+    if (normalized_plan_mode) emitToDashboard('plan_sream_end');
     emitToDashboard('stream_end');
 
     return { code: -16, data: error_message };
@@ -4930,6 +5366,7 @@ const ai_chat_conversation = async function (req, job_id, headers) {
 
   const prompt_conversation_item_id = await _common.xuda_get_uuid('chat_conversation_item');
   const response_conversation_item_id = await _common.xuda_get_uuid('chat_conversation_item');
+  const request_started_at = Date.now();
 
   let out_conversation_item_obj = {
     _id: prompt_conversation_item_id,
@@ -4971,6 +5408,7 @@ const ai_chat_conversation = async function (req, job_id, headers) {
         conversation_id,
         job_id,
         delta: content,
+        ...(type === 'stream_start' ? { request_started_at } : {}),
         ...(seq ? { seq } : {}),
         ...(is_stream_end
           ? {
@@ -5106,6 +5544,7 @@ const ai_chat_conversation = async function (req, job_id, headers) {
 
     conversation_doc.stat = 2;
     conversation_doc.ts = Date.now();
+    conversation_doc.request_started_at = request_started_at;
     conversation_doc.ai_agents = ai_agents;
     conversation_doc.job_id = job_id;
     await db_module.save_app_couch_doc_native(account_profile_info.app_id, conversation_doc);

package/index_ms.mjs

@@ -221,6 +221,10 @@ export const get_person_info = async function (...args) {
   return await broker.send_to_queue("get_person_info", ...args);
 };
 
+export const execute_codex_request = async function (...args) {
+  return await broker.send_to_queue("execute_codex_request", ...args);
+};
+
 export const open_ai_alive_check = async function (...args) {
   return await broker.send_to_queue("open_ai_alive_check", ...args);
 };

package/index_msa.mjs

@@ -221,6 +221,10 @@ export const get_person_info =  function (...args) {
    broker.send_to_queue_async("get_person_info", ...args);
 };
 
+export const execute_codex_request =  function (...args) {
+   broker.send_to_queue_async("execute_codex_request", ...args);
+};
+
 export const open_ai_alive_check =  function (...args) {
    broker.send_to_queue_async("open_ai_alive_check", ...args);
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@xuda.io/ai_module",
-  "version": "1.1.5589",
+  "version": "1.1.5590",
   "description": "Xuda AI Module",
   "main": "index.mjs",
   "type": "module",
@@ -27,7 +27,8 @@
   },
   "devDependencies": {},
   "scripts": {
-    "pub": "npm version patch --force && npm publish"
+    "pub": "npm version patch --force && npm publish",
+    "test:codex": "node tests/execute-codex-request.mjs"
   },
   "author": "Xuda Llc",
   "license": "ISC"

package/tests/execute-codex-request.mjs

@@ -0,0 +1,74 @@
+import path from 'node:path';
+import process from 'node:process';
+import { fileURLToPath } from 'node:url';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+const repoRoot = path.resolve(__dirname, '../../..');
+
+const parseArgs = function (argv) {
+  const args = { attachments: [] };
+
+  for (let i = 0; i < argv.length; i++) {
+    const token = argv[i];
+    const next = argv[i + 1];
+
+    if (token === '--ip' && next) {
+      args.ip = next;
+      i += 1;
+      continue;
+    }
+
+    if ((token === '--prompt' || token === '--prompat') && next) {
+      args.prompt = next;
+      i += 1;
+      continue;
+    }
+
+    if ((token === '--attachment' || token === '--attach') && next) {
+      args.attachments.push(next);
+      i += 1;
+      continue;
+    }
+
+    if (token === '--help') {
+      args.help = true;
+    }
+  }
+
+  return args;
+};
+
+const usage = `
+Usage:
+  node cpi/ai_module/tests/execute-codex-request.mjs [options]
+
+Options:
+  --ip <host>              Remote server IP/host. Default: 134.122.125.174
+  --prompt <text>          Codex prompt. Default: create locksmith website
+  --attachment <path>      Remote attachment path. Can be repeated.
+  --help                  Show this help.
+
+Environment:
+  XUDA_HOME                Defaults to repo root.
+  XUDA_CONFIG              Defaults to config_dev.json.
+`;
+
+const args = parseArgs(process.argv.slice(2));
+
+if (args.help) {
+  console.log(usage.trim());
+  process.exit(0);
+}
+
+process.env.XUDA_HOME ||= repoRoot;
+process.env.XUDA_CONFIG ||= 'config_dev.json';
+
+const ip = args.ip || '134.122.125.174';
+const prompt = args.prompt || 'create locksmith website';
+const attachments = args.attachments;
+
+const aiModule = await import('../index.mjs');
+const response = await aiModule.execute_codex_request(ip, prompt, attachments);
+
+console.log(JSON.stringify(response, null, 2));