agentgui 1.0.699 → 1.0.701

package/CLAUDE.md

@@ -73,7 +73,7 @@ XState v5 machines provide formal state tracking alongside (not replacing) the e
 - WebSocket endpoint is at `BASE_URL + /sync`. Supports subscribe/unsubscribe by sessionId or conversationId, and ping.
 - All WS RPC uses msgpack binary encoding (lib/codec.js). Wire format: `{ r, m, p }` request, `{ r, d }` reply, `{ type, seq }` broadcast push.
 - `perMessageDeflate` is disabled on the WS server — msgpack binary doesn't compress well and brotli/gzip was blocking the event loop. HTTP-layer gzip handles static assets.
-- Static assets use `Cache-Control: max-age=31536000, immutable` + ETag. Compressed once on first request, served from RAM (`_assetCache` Map keyed by etag).
+- Static assets use `Cache-Control: public, no-cache` + ETag. Browser always revalidates (sends If-None-Match), server returns 304 if unchanged. Compressed once on first request, served from RAM (`_assetCache` Map keyed by etag).
 - Deployment: runs behind Traefik/Caddy which handles TLS and can support WebTransport/QUIC.
 
 ## Environment Variables
@@ -82,6 +82,7 @@ XState v5 machines provide formal state tracking alongside (not replacing) the e
 - `BASE_URL` - URL prefix (default: /gm)
 - `STARTUP_CWD` - Working directory passed to agents
 - `HOT_RELOAD` - Set to "false" to disable watch mode
+- `CODEX_HOME` - Override Codex CLI home directory (default: `~/.codex`)
 
 ## ACP Tool Lifecycle
 
@@ -123,6 +124,11 @@ All routes are prefixed with `BASE_URL` (default `/gm`).
 - `GET /api/tools/:id/history` - Get tool install/update history (query: limit, offset)
 - `POST /api/tools/update` - Batch update all tools with available updates
 - `POST /api/tools/refresh-all` - Refresh all tool statuses from package manager
+- `POST /api/codex-oauth/start` - Start Codex CLI OAuth flow (returns `{ authUrl, mode }`)
+- `GET /api/codex-oauth/status` - Get current Codex OAuth state `{ status, email, error }`
+- `POST /api/codex-oauth/relay` - Relay OAuth code+state from remote browser (body: `{ code, state }`)
+- `POST /api/codex-oauth/complete` - Complete OAuth by pasting redirect URL (body: `{ url }`)
+- `GET /codex-oauth2callback` - OAuth callback endpoint (redirect_uri for local flows)
 
 ## Tool Update System
 
@@ -286,6 +292,27 @@ Speech models (~470MB total) are downloaded automatically on server startup. No
 - **Client init:** `loadAgents()`, `loadConversations()`, `checkSpeechStatus()` run in parallel via `Promise.all()`.
 - **`perMessageDeflate: false`** on WebSocket server — msgpack binary doesn't compress well, and zlib was blocking the event loop on every streaming_progress send.
 
+## Codex CLI OAuth
+
+OpenAI Codex CLI uses PKCE authorization code flow against `https://auth.openai.com`.
+
+**Flow:**
+1. `POST /api/codex-oauth/start` generates PKCE (SHA-256 S256 challenge), CSRF state, returns `authUrl`
+2. User opens `authUrl` in browser and authenticates via OpenAI/ChatGPT
+3. **Local**: Browser redirects to `http://localhost:1455/auth/callback` — but since agentgui's server is on a different port, the redirect goes to `GET /codex-oauth2callback` (agentgui intercepts via matching route). Token exchange happens server-side.
+4. **Remote**: Redirect goes to `/codex-oauth2callback` which serves a relay page. Relay POSTs `{ code, state }` to `/api/codex-oauth/relay`. Token exchange happens on the server.
+5. Tokens saved to `$CODEX_HOME/auth.json` (default: `~/.codex/auth.json`) as `{ auth_mode: "chatgpt", tokens: { id_token, access_token, refresh_token }, last_refresh }`
+
+**Constants (in server.js):**
+- Issuer: `https://auth.openai.com`
+- Client ID: `app_EMoamEEZ73f0CkXaXp7hrann`
+- Scopes: `openid profile email offline_access api.connectors.read api.connectors.invoke`
+- Redirect URI (local): `http://localhost:1455/auth/callback` (actual callback goes to agentgui's `/codex-oauth2callback`)
+
+**WebSocket handlers** (in `lib/ws-handlers-util.js`): `codex.start`, `codex.status`, `codex.relay`, `codex.complete`
+
+**Agent auth**: `POST /api/agents/codex/auth` starts OAuth flow same as Gemini — broadcasts `script_started`/`script_output`/`script_stopped` events as OAuth progresses.
+
 ## ACP SDK Integration
 
 - **@agentclientprotocol/sdk** (`^0.4.1`) added to dependencies

package/lib/execution-machine.js

@@ -38,6 +38,9 @@ const machine = createMachine({
             queue: [...context.queue, event.item],
           })),
         },
+        SET_QUEUE: {
+          actions: assign(({ event }) => ({ queue: event.queue })),
+        },
         COMPLETE: [
           {
             guard: ({ context }) => context.queue.length > 0,
@@ -102,10 +105,21 @@ const machine = createMachine({
 });
 
 const actors = new Map();
+// Per-convId listeners: Map<convId, Set<(snapshot) => void>>
+const listeners = new Map();
+
+function notifyListeners(convId, snapshot) {
+  const set = listeners.get(convId);
+  if (!set) return;
+  for (const fn of set) {
+    try { fn(snapshot); } catch (_) {}
+  }
+}
 
 export function getOrCreate(convId) {
   if (actors.has(convId)) return actors.get(convId);
   const actor = createActor(machine);
+  actor.subscribe(snapshot => notifyListeners(convId, snapshot));
   actor.start();
   actors.set(convId, actor);
   return actor;
@@ -118,6 +132,7 @@ export function get(convId) {
 export function remove(convId) {
   const actor = actors.get(convId);
   if (actor) { actor.stop(); actors.delete(convId); }
+  listeners.delete(convId);
 }
 
 export function snapshot(convId) {
@@ -130,18 +145,38 @@ export function isStreaming(convId) {
   return s ? s.value === 'streaming' || s.value === 'rate_limited' : false;
 }
 
+export function isActive(convId) {
+  const s = snapshot(convId);
+  if (!s) return false;
+  return s.value === 'streaming' || s.value === 'rate_limited' || s.value === 'draining';
+}
+
 export function getContext(convId) {
   const s = snapshot(convId);
   return s ? s.context : null;
 }
 
+export function getQueue(convId) {
+  const ctx = getContext(convId);
+  return ctx ? ctx.queue : [];
+}
+
 export function send(convId, event) {
   const actor = getOrCreate(convId);
   actor.send(event);
   return actor.getSnapshot();
 }
 
+// Subscribe to state transitions for a conversation.
+// Returns an unsubscribe function.
+export function subscribe(convId, fn) {
+  if (!listeners.has(convId)) listeners.set(convId, new Set());
+  listeners.get(convId).add(fn);
+  return () => listeners.get(convId)?.delete(fn);
+}
+
 export function stopAll() {
   for (const [, actor] of actors) actor.stop();
   actors.clear();
+  listeners.clear();
 }

package/lib/ws-handlers-conv.js

@@ -55,7 +55,7 @@ export function register(router, deps) {
 
   router.handle('conv.ls', () => {
     const conversations = queries.getConversationsList();
-    for (const c of conversations) { if (c.isStreaming && !activeExecutions.has(c.id)) c.isStreaming = 0; }
+    for (const c of conversations) { if (c.isStreaming && !execMachine.isActive(c.id)) c.isStreaming = 0; }
     return { conversations };
   });
 
@@ -72,7 +72,7 @@ export function register(router, deps) {
     const conv = queries.getConversation(p.id);
     if (!conv) notFound();
     const machineSnap = execMachine.snapshot(p.id);
-    return { conversation: conv, isActivelyStreaming: activeExecutions.has(p.id), latestSession: queries.getLatestSession(p.id), executionState: machineSnap?.value || 'idle' };
+    return { conversation: conv, isActivelyStreaming: execMachine.isActive(p.id), latestSession: queries.getLatestSession(p.id), executionState: machineSnap?.value || 'idle' };
   });
 
   router.handle('conv.upd', (p) => {
@@ -110,7 +110,7 @@ export function register(router, deps) {
     const machineSnap = execMachine.snapshot(p.id);
     return {
       conversation: conv,
-      isActivelyStreaming: activeExecutions.has(p.id),
+      isActivelyStreaming: execMachine.isActive(p.id),
       executionState: machineSnap?.value || 'idle',
       latestSession: queries.getLatestSession(p.id),
       chunks,
@@ -141,15 +141,13 @@ export function register(router, deps) {
   });
 
   router.handle('conv.cancel', (p) => {
-    const entry = activeExecutions.get(p.id);
-    if (!entry) notFound('No active execution to cancel');
-    const { pid, sessionId } = entry;
+    if (!execMachine.isActive(p.id)) notFound('No active execution to cancel');
+    const ctx = execMachine.getContext(p.id);
+    const pid = ctx?.pid || activeExecutions.get(p.id)?.pid;
+    const sessionId = ctx?.sessionId || activeExecutions.get(p.id)?.sessionId;
     if (pid) { try { process.kill(-pid, 'SIGKILL'); } catch { try { process.kill(pid, 'SIGKILL'); } catch {} } }
     if (sessionId) queries.updateSession(sessionId, { status: 'interrupted', completed_at: Date.now() });
-
-    // Use atomic cleanup function to ensure state consistency
     cleanupExecution(p.id, false);
-
     broadcastSync({ type: 'streaming_complete', sessionId, conversationId: p.id, interrupted: true, timestamp: Date.now() });
     return { ok: true, cancelled: true, conversationId: p.id, sessionId };
   });
@@ -158,9 +156,8 @@ export function register(router, deps) {
     const conv = queries.getConversation(p.id);
     if (!conv) notFound('Conversation not found');
     if (!p.content) fail(400, 'Missing content');
-    const entry = activeExecutions.get(p.id);
     const message = queries.createMessage(p.id, 'user', '[INJECTED] ' + p.content);
-    if (!entry) {
+    if (!execMachine.isActive(p.id)) {
       const agentId = conv.agentId || 'claude-code';
       const session = queries.createSession(p.id, agentId, 'pending');
       processMessageWithStreaming(p.id, message.id, session.id, message.content, agentId, conv.model || null, conv.subAgent || null);
@@ -173,10 +170,11 @@ export function register(router, deps) {
     const conv = queries.getConversation(p.id);
     if (!conv) notFound('Conversation not found');
 
-    const entry = activeExecutions.get(p.id);
-    if (!entry) fail(409, 'No active execution to steer');
+    if (!execMachine.isActive(p.id)) fail(409, 'No active execution to steer');
 
-    const { pid, sessionId } = entry;
+    const ctx = execMachine.getContext(p.id);
+    const pid = ctx?.pid || activeExecutions.get(p.id)?.pid;
+    const sessionId = ctx?.sessionId || activeExecutions.get(p.id)?.sessionId;
 
     if (pid) {
       try { process.kill(-pid, 'SIGKILL'); } catch { try { process.kill(pid, 'SIGKILL'); } catch (e) {} }
@@ -184,6 +182,7 @@ export function register(router, deps) {
 
     if (sessionId) queries.updateSession(sessionId, { status: 'interrupted', completed_at: Date.now() });
     queries.setIsStreaming(p.id, false);
+    execMachine.send(p.id, { type: 'CANCEL' });
     activeExecutions.delete(p.id);
 
     // Clear claudeSessionId so new execution starts fresh without --resume on a killed session
@@ -218,6 +217,8 @@ export function register(router, deps) {
   function startExecution(convId, message, agentId, model, content, subAgent) {
     const session = queries.createSession(convId);
     queries.createEvent('session.created', { messageId: message.id, sessionId: session.id }, convId, session.id);
+    // Machine is authoritative — START event sets sessionId in context
+    execMachine.send(convId, { type: 'START', sessionId: session.id });
     activeExecutions.set(convId, { pid: null, startTime: Date.now(), sessionId: session.id, lastActivity: Date.now() });
     queries.setIsStreaming(convId, true);
     broadcastSync({ type: 'streaming_start', sessionId: session.id, conversationId: convId, messageId: message.id, agentId, timestamp: Date.now() });
@@ -226,9 +227,13 @@ export function register(router, deps) {
   }
 
   function enqueue(convId, content, agentId, model, messageId, subAgent) {
+    const item = { content, agentId, model, messageId, subAgent };
+    // Machine is authoritative for queue — ENQUEUE event adds to machine context.queue
+    execMachine.send(convId, { type: 'ENQUEUE', item });
+    // Keep messageQueues in sync for legacy REST endpoints
     if (!messageQueues.has(convId)) messageQueues.set(convId, []);
-    messageQueues.get(convId).push({ content, agentId, model, messageId, subAgent });
-    const queueLength = messageQueues.get(convId).length;
+    messageQueues.get(convId).push(item);
+    const queueLength = execMachine.getQueue(convId).length;
     broadcastSync({ type: 'queue_status', conversationId: convId, queueLength, messageId, timestamp: Date.now() });
     return queueLength;
   }
@@ -249,14 +254,13 @@ export function register(router, deps) {
     const message = queries.createMessage(p.id, 'user', p.content, idempotencyKey);
     queries.createEvent('message.created', { role: 'user', messageId: message.id }, p.id);
 
-    // Only broadcast message_created if NOT queuing - queued messages show in queue indicator instead
-    if (!activeExecutions.has(p.id)) {
+    // Machine is authoritative: gate on machine state, not Map
+    if (!execMachine.isActive(p.id)) {
       broadcastSync({ type: 'message_created', conversationId: p.id, message, timestamp: Date.now() });
       const session = startExecution(p.id, message, agentId, model, p.content, subAgent);
       return { message, session, idempotencyKey };
     }
 
-    // Message is queued - don't broadcast as message_created, let queue_status handle the UI update
     const qp = enqueue(p.id, p.content, agentId, model, message.id, subAgent);
     return { message, queued: true, queuePosition: qp, idempotencyKey };
   });
@@ -283,20 +287,19 @@ export function register(router, deps) {
     const userMessage = queries.createMessage(p.id, 'user', prompt);
     queries.createEvent('message.created', { role: 'user', messageId: userMessage.id }, p.id);
 
-    // Only broadcast message_created if NOT queuing - queued messages show in queue indicator instead
-    if (!activeExecutions.has(p.id)) {
+    // Machine is authoritative: gate on machine state, not Map
+    if (!execMachine.isActive(p.id)) {
       broadcastSync({ type: 'message_created', conversationId: p.id, message: userMessage, timestamp: Date.now() });
       const session = startExecution(p.id, userMessage, agentId, model, prompt, subAgent);
       return { message: userMessage, session, streamId: session.id };
     }
 
-    // Message is queued - don't broadcast as message_created, let queue_status handle the UI update
     const qp = enqueue(p.id, prompt, agentId, model, userMessage.id, subAgent);
     const seq = getNextQueueSeq(p.id);
     broadcastSync({
       type: 'queue_status',
       conversationId: p.id,
-      queueLength: messageQueues.get(p.id)?.length || 1,
+      queueLength: execMachine.getQueue(p.id).length,
       seq,
       timestamp: Date.now()
     });
@@ -305,21 +308,34 @@ export function register(router, deps) {
 
   router.handle('q.ls', (p) => {
     if (!queries.getConversation(p.id)) notFound('Conversation not found');
-    return { queue: messageQueues.get(p.id) || [] };
+    // Read queue from machine context (authoritative), fall back to Map for compatibility
+    const machineQueue = execMachine.getQueue(p.id);
+    return { queue: machineQueue.length > 0 ? machineQueue : (messageQueues.get(p.id) || []) };
   });
 
   router.handle('q.del', (p) => {
-    const queue = messageQueues.get(p.id);
-    if (!queue) notFound('Queue not found');
-    const idx = queue.findIndex(q => q.messageId === p.messageId);
-    if (idx === -1) notFound('Queued message not found');
-    queue.splice(idx, 1);
-    if (queue.length === 0) messageQueues.delete(p.id);
+    const machineQueue = execMachine.getQueue(p.id);
+    const mapQueue = messageQueues.get(p.id);
+    if (!machineQueue.length && !mapQueue) notFound('Queue not found');
+    // Remove from both machine and Map
+    const idx = machineQueue.findIndex(q => q.messageId === p.messageId);
+    if (idx === -1 && (!mapQueue || mapQueue.findIndex(q => q.messageId === p.messageId) === -1)) notFound('Queued message not found');
+    // Update machine queue via direct send
+    if (idx !== -1) {
+      const newQueue = [...machineQueue];
+      newQueue.splice(idx, 1);
+      execMachine.send(p.id, { type: 'SET_QUEUE', queue: newQueue });
+    }
+    if (mapQueue) {
+      const mi = mapQueue.findIndex(q => q.messageId === p.messageId);
+      if (mi !== -1) mapQueue.splice(mi, 1);
+      if (mapQueue.length === 0) messageQueues.delete(p.id);
+    }
     const seq = getNextQueueSeq(p.id);
     broadcastSync({
       type: 'queue_status',
       conversationId: p.id,
-      queueLength: queue?.length || 0,
+      queueLength: execMachine.getQueue(p.id).length,
       seq,
       timestamp: Date.now()
     });
@@ -327,9 +343,10 @@ export function register(router, deps) {
   });
 
   router.handle('q.upd', (p) => {
-    const queue = messageQueues.get(p.id);
-    if (!queue) notFound('Queue not found');
-    const item = queue.find(q => q.messageId === p.messageId);
+    const machineQueue = execMachine.getQueue(p.id);
+    const mapQueue = messageQueues.get(p.id);
+    if (!machineQueue.length && !mapQueue) notFound('Queue not found');
+    const item = machineQueue.find(q => q.messageId === p.messageId) || mapQueue?.find(q => q.messageId === p.messageId);
     if (!item) notFound('Queued message not found');
     if (p.content !== undefined) item.content = p.content;
     if (p.agentId !== undefined) item.agentId = p.agentId;

package/lib/ws-handlers-util.js

@@ -9,6 +9,7 @@ export function register(router, deps) {
   const { queries, wsOptimizer, modelDownloadState, ensureModelsDownloaded,
     broadcastSync, getSpeech, getProviderConfigs, saveProviderConfig,
     startGeminiOAuth, exchangeGeminiOAuthCode, geminiOAuthState,
+    startCodexOAuth, exchangeCodexOAuthCode, codexOAuthState,
     STARTUP_CWD, activeScripts, voiceCacheManager, toolManager, discoveredAgents } = deps;
 
   router.handle('home', () => ({ home: os.homedir(), cwd: STARTUP_CWD }));
@@ -175,6 +176,45 @@ export function register(router, deps) {
     } catch (e) { err(400, e.message); }
   });
 
+  router.handle('codex.start', async () => {
+    try {
+      const result = await startCodexOAuth();
+      return { authUrl: result.authUrl, mode: result.mode };
+    } catch (e) { err(500, e.message); }
+  });
+
+  router.handle('codex.status', () => {
+    const st = typeof codexOAuthState === 'function' ? codexOAuthState() : codexOAuthState;
+    return st;
+  });
+
+  router.handle('codex.relay', async (p) => {
+    const { code, state } = p;
+    if (!code || !state) err(400, 'Missing code or state');
+    try {
+      const email = await exchangeCodexOAuthCode(code, state);
+      return { success: true, email };
+    } catch (e) { err(400, e.message); }
+  });
+
+  router.handle('codex.complete', async (p) => {
+    const pastedUrl = (p.url || '').trim();
+    if (!pastedUrl) err(400, 'No URL provided');
+    let parsed;
+    try { parsed = new URL(pastedUrl); } catch { err(400, 'Invalid URL. Paste the full URL from the browser address bar.'); }
+    const urlError = parsed.searchParams.get('error');
+    if (urlError) {
+      const desc = parsed.searchParams.get('error_description') || urlError;
+      return { error: desc };
+    }
+    const code = parsed.searchParams.get('code');
+    const state = parsed.searchParams.get('state');
+    try {
+      const email = await exchangeCodexOAuthCode(code, state);
+      return { success: true, email };
+    } catch (e) { err(400, e.message); }
+  });
+
   router.handle('ws.stats', () => wsOptimizer.getStats());
 
   router.handle('conv.scripts', (p) => {
@@ -268,47 +308,47 @@ export function register(router, deps) {
     }
   });
 
-  router.handle('agent.subagents', async (p) => {
-    const { id } = p;
-    if (!id) err(400, 'Missing agent id');
-
-    // Claude Code: run 'claude agents list' and parse output
-    if (id === 'claude-code' || id === 'cli-claude') {
-      const spawnEnv = { ...process.env };
-      delete spawnEnv.CLAUDECODE;
-      const result = spawnSync('claude', ['agents', 'list'], {
-        encoding: 'utf-8', timeout: 10000, stdio: ['pipe', 'pipe', 'pipe'],
-        env: spawnEnv
-      });
-      if (result.status !== 0 || !result.stdout) return { subAgents: [] };
-      const output = result.stdout.trim();
-      // Output format: '  agentId · model' lines under section headers
-      const agents = [];
-      for (const line of output.split('\n').filter(l => l.trim())) {
-        const match = line.match(/^  (\S+)\s+·/);
-        if (match) {
-          const id = match[1];
-          agents.push({ id, name: id });
-        }
-      }
-      console.log('[agent.subagents] claude agents list found:', agents.map(a => a.id).join(', '));
-      return { subAgents: agents };
-    }
-
-    // ACP agents: hardcoded map filtered by installed tools
-    const subAgentMap = {
-      'opencode':     [{ id: 'gm-oc',   name: 'GM OpenCode' }],
-      'cli-opencode': [{ id: 'gm-oc',   name: 'GM OpenCode' }],
-      'gemini':       [{ id: 'gm-gc',   name: 'GM Gemini'   }],
-      'cli-gemini':   [{ id: 'gm-gc',   name: 'GM Gemini'   }],
-      'kilo':         [{ id: 'gm-kilo', name: 'GM Kilo'     }],
-      'cli-kilo':     [{ id: 'gm-kilo', name: 'GM Kilo'     }],
-      'codex':        [],
-      'cli-codex':    []
-    };
-    const subAgents = subAgentMap[id] || [];
-    const tools = await toolManager.getAllToolsAsync();
-    const installed = new Set(tools.filter(t => t.category === 'plugin' && t.installed).map(t => t.id));
-    return { subAgents: subAgents.filter(sa => installed.has(sa.id)) };
+  router.handle('agent.subagents', async (p) => {
+    const { id } = p;
+    if (!id) err(400, 'Missing agent id');
+
+    // Claude Code: run 'claude agents list' and parse output
+    if (id === 'claude-code' || id === 'cli-claude') {
+      const spawnEnv = { ...process.env };
+      delete spawnEnv.CLAUDECODE;
+      const result = spawnSync('claude', ['agents', 'list'], {
+        encoding: 'utf-8', timeout: 10000, stdio: ['pipe', 'pipe', 'pipe'],
+        env: spawnEnv
+      });
+      if (result.status !== 0 || !result.stdout) return { subAgents: [] };
+      const output = result.stdout.trim();
+      // Output format: '  agentId · model' lines under section headers
+      const agents = [];
+      for (const line of output.split('\n').filter(l => l.trim())) {
+        const match = line.match(/^  (\S+)\s+·/);
+        if (match) {
+          const id = match[1];
+          agents.push({ id, name: id });
+        }
+      }
+      console.log('[agent.subagents] claude agents list found:', agents.map(a => a.id).join(', '));
+      return { subAgents: agents };
+    }
+
+    // ACP agents: hardcoded map filtered by installed tools
+    const subAgentMap = {
+      'opencode':     [{ id: 'gm-oc',   name: 'GM OpenCode' }],
+      'cli-opencode': [{ id: 'gm-oc',   name: 'GM OpenCode' }],
+      'gemini':       [{ id: 'gm-gc',   name: 'GM Gemini'   }],
+      'cli-gemini':   [{ id: 'gm-gc',   name: 'GM Gemini'   }],
+      'kilo':         [{ id: 'gm-kilo', name: 'GM Kilo'     }],
+      'cli-kilo':     [{ id: 'gm-kilo', name: 'GM Kilo'     }],
+      'codex':        [],
+      'cli-codex':    []
+    };
+    const subAgents = subAgentMap[id] || [];
+    const tools = await toolManager.getAllToolsAsync();
+    const installed = new Set(tools.filter(t => t.category === 'plugin' && t.installed).map(t => t.id));
+    return { subAgents: subAgents.filter(sa => installed.has(sa.id)) };
   });
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agentgui",
-  "version": "1.0.699",
+  "version": "1.0.701",
   "description": "Multi-agent ACP client with real-time communication",
   "type": "module",
   "main": "server.js",