#!/usr/bin/env node

const crypto = require('crypto');
const path = require('path');
const readline = require('readline');
const { spawn } = require('child_process');

const args = process.argv.slice(2);

if (args[0] !== 'app-server') {
  const child = spawn(process.execPath, [path.join(__dirname, 'mock-codex.js'), ...args], {
    stdio: 'inherit',
  });
  child.on('exit', (code, signal) => {
    if (signal) process.kill(process.pid, signal);
    process.exit(code || 0);
  });
  child.on('error', (err) => {
    console.error(err.stack || err.message);
    process.exit(1);
  });
  return;
}

const threads = new Map();
const pendingServerRequests = new Map();
const resumeMismatchThreads = new Set();
let nextServerRequestId = 1;
let mcpReloadCount = 0;

function send(message) {
  process.stdout.write(`${JSON.stringify(message)}\n`);
}

function textFromInput(input) {
  return (Array.isArray(input) ? input : [])
    .map((item) => {
      if (item?.type === 'text') return item.text || '';
      if (item?.type === 'localImage') return `[image:${path.basename(item.path || 'image')}]`;
      return '';
    })
    .filter(Boolean)
    .join('\n')
    .trim();
}

function tokenUsage(text) {
  const inputTokens = Math.max(1, Math.ceil(String(text || '').length / 4));
  const outputTokens = 7;
  return {
    last: {
      inputTokens,
      cachedInputTokens: 1,
      outputTokens,
      reasoningOutputTokens: 0,
      totalTokens: inputTokens + outputTokens + 1,
    },
    total: {
      inputTokens,
      cachedInputTokens: 1,
      outputTokens,
      reasoningOutputTokens: 0,
      totalTokens: inputTokens + outputTokens + 1,
    },
  };
}

function retryScenarioKey(text, marker) {
  return new RegExp(marker.replace(/[.*+?^${}()|[\]\\]/g, '\\$&'), 'i').test(String(text || ''))
    ? marker
    : String(text || '');
}

function collaborationSummary(params = {}) {
  const collaborationMode = params.collaborationMode;
  const settings = collaborationMode?.settings || {};
  return JSON.stringify({
    mode: collaborationMode?.mode || null,
    hasModel: Boolean(settings.model),
    hasDeveloperInstructions: /Codex sub-agent spawning rules/.test(String(settings.developer_instructions || '')),
    hasWaitAgentRetryGuidance: /wait_agent[\s\S]*timeout_ms[\s\S]*additional wait_agent rounds/.test(String(settings.developer_instructions || '')),
    hasReasoningEffort: Object.prototype.hasOwnProperty.call(settings, 'reasoning_effort'),
    hasTopLevelModel: Object.prototype.hasOwnProperty.call(params, 'model'),
    hasTopLevelEffort: Object.prototype.hasOwnProperty.call(params, 'effort'),
  });
}

function ensureThread(threadId, params = {}) {
  const id = threadId || `app-thread-${crypto.randomUUID()}`;
  if (!threads.has(id)) {
    threads.set(id, {
      id,
      cwd: params.cwd || process.cwd(),
      dynamicTools: Array.isArray(params.dynamicTools) ? params.dynamicTools : [],
      config: params.config && typeof params.config === 'object' ? params.config : {},
      activeTurnId: null,
      timer: null,
      steers: [],
      capacityRetryAttempts: new Map(),
      reconnectRetryAttempts: new Map(),
      goal: null,
    });
  }
  const thread = threads.get(id);
  if (Array.isArray(params.dynamicTools)) thread.dynamicTools = params.dynamicTools;
  if (params.config && typeof params.config === 'object') thread.config = params.config;
  return thread;
}

function threadPayload(thread) {
  return {
    id: thread.id,
    cwd: thread.cwd,
    status: thread.activeTurnId ? 'running' : 'idle',
    turns: [],
  };
}

function emitChildCollabTurn(threadId, turnId, finalMessage) {
  const childThread = ensureThread(threadId);
  childThread.activeTurnId = turnId;
  send({
    method: 'turn/started',
    params: {
      threadId,
      turn: {
        id: turnId,
        status: 'running',
        items: [],
      },
    },
  });
  send({
    method: 'item/agentMessage/delta',
    params: {
      threadId,
      turnId,
      itemId: 'agent-msg',
      delta: finalMessage,
    },
  });
  send({
    method: 'item/completed',
    params: {
      threadId,
      turnId,
      completedAtMs: Date.now(),
      item: {
        id: 'agent-msg',
        type: 'agentMessage',
        content: [{ type: 'text', text: finalMessage }],
        status: 'completed',
      },
    },
  });
  send({
    method: 'turn/completed',
    params: {
      threadId,
      turn: {
        id: turnId,
        status: 'completed',
        items: [],
      },
    },
  });
  childThread.activeTurnId = null;
}

function completeTurn(thread, turnId, text, status = 'completed') {
  if (thread.activeTurnId !== turnId) return;
  const suffix = thread.steers.length > 0 ? ` | steer: ${thread.steers.join(' | ')}` : '';
  const responseText = `Codex App mock handled: ${text}${suffix}`;

  send({
    method: 'item/agentMessage/delta',
    params: {
      threadId: thread.id,
      turnId,
      itemId: 'agent-msg',
      delta: responseText,
    },
  });

  if (/tool/i.test(text)) {
    send({
      method: 'item/started',
      params: {
        threadId: thread.id,
        turnId,
        startedAtMs: Date.now(),
        item: {
          id: 'tool-cmd',
          type: 'commandExecution',
          command: '/bin/bash -lc echo codexapp',
          status: 'inProgress',
        },
      },
    });
    send({
      method: 'item/commandExecution/outputDelta',
      params: {
        threadId: thread.id,
        turnId,
        itemId: 'tool-cmd',
        delta: 'codexapp\n',
      },
    });
    send({
      method: 'item/completed',
      params: {
        threadId: thread.id,
        turnId,
        completedAtMs: Date.now(),
        item: {
          id: 'tool-cmd',
          type: 'commandExecution',
          command: '/bin/bash -lc echo codexapp',
          aggregatedOutput: 'codexapp\n',
          exitCode: 0,
          status: 'completed',
        },
      },
    });
  }

  if (/huge output/i.test(text)) {
    const hugeOutput = `huge-output-start\n${'0123456789abcdef'.repeat(30000)}\nhuge-output-end\n`;
    send({
      method: 'item/started',
      params: {
        threadId: thread.id,
        turnId,
        startedAtMs: Date.now(),
        item: {
          id: 'huge-tool',
          type: 'commandExecution',
          command: '/bin/bash -lc huge-output',
          status: 'inProgress',
        },
      },
    });
    send({
      method: 'item/commandExecution/outputDelta',
      params: {
        threadId: thread.id,
        turnId,
        itemId: 'huge-tool',
        delta: hugeOutput,
      },
    });
    send({
      method: 'item/completed',
      params: {
        threadId: thread.id,
        turnId,
        completedAtMs: Date.now(),
        item: {
          id: 'huge-tool',
          type: 'commandExecution',
          command: '/bin/bash -lc huge-output',
          aggregatedOutput: hugeOutput,
          exitCode: 0,
          status: 'completed',
        },
      },
    });
  }

  if (/subagent/i.test(text)) {
    send({
      method: 'item/started',
      params: {
        threadId: thread.id,
        turnId,
        startedAtMs: Date.now(),
        item: {
          id: 'tool-collab',
          type: 'collabAgentToolCall',
          tool: 'spawn_agent',
          prompt: '整理前端改动并回报状态',
          receiverThreadIds: ['child-thread-a', 'child-thread-b'],
          agentsStates: {
            'child-thread-a': {
              name: '实现代理',
              role: 'frontend',
              status: 'in_progress',
              summary: '正在补充结构化渲染与样式',
            },
            'child-thread-b': {
              name: '验证代理',
              role: 'qa',
              status: 'completed',
              summary: '已完成基础事件链检查',
            },
          },
          status: 'inProgress',
        },
      },
    });
    send({
      method: 'item/completed',
      params: {
        threadId: thread.id,
        turnId,
        completedAtMs: Date.now(),
        item: {
          id: 'tool-collab',
          type: 'collabAgentToolCall',
          tool: 'spawn_agent',
          prompt: '整理前端改动并回报状态',
          receiverThreadIds: ['child-thread-a', 'child-thread-b'],
          agentsStates: {
            'child-thread-a': {
              name: '实现代理',
              role: 'frontend',
              status: 'completed',
              summary: '结构化渲染已完成',
            },
            'child-thread-b': {
              name: '验证代理',
              role: 'qa',
              status: 'completed',
              summary: '事件链与持久化检查通过',
            },
          },
          status: 'completed',
        },
      },
    });
    emitChildCollabTurn(
      'child-thread-a',
      'child-turn-a',
      '子代理最终消息：结构化渲染和关闭按钮链路已完成。'
    );
    emitChildCollabTurn(
      'child-thread-b',
      'child-turn-b',
      '子代理最终消息：事件路由、持久化和状态推送检查通过。'
    );
  }

  send({
    method: 'thread/tokenUsage/updated',
    params: {
      threadId: thread.id,
      turnId,
      tokenUsage: tokenUsage(`${text}${suffix}`),
    },
  });
  send({
    method: 'turn/completed',
    params: {
      threadId: thread.id,
      turn: {
        id: turnId,
        status,
        items: [],
      },
    },
  });
  thread.activeTurnId = null;
  thread.timer = null;
  thread.steers = [];
}

function requestClient(method, params, callback) {
  const id = `mock-server-request-${nextServerRequestId++}`;
  pendingServerRequests.set(id, callback);
  send({ id, method, params });
}

function completeDynamicToolTurn(thread, turnId, text) {
  const callId = 'dynamic-ccweb-list';
  send({
    method: 'item/started',
    params: {
      threadId: thread.id,
      turnId,
      startedAtMs: Date.now(),
      item: {
        id: callId,
        type: 'dynamicToolCall',
        namespace: 'ccweb',
        tool: 'ccweb_list_conversations',
        arguments: { limit: 5 },
        status: 'inProgress',
      },
    },
  });
  requestClient('item/tool/call', {
    threadId: thread.id,
    turnId,
    callId,
    namespace: 'ccweb',
    tool: 'ccweb_list_conversations',
    arguments: { limit: 5 },
  }, (message) => {
    const result = message.result || {};
    send({
      method: 'item/completed',
      params: {
        threadId: thread.id,
        turnId,
        completedAtMs: Date.now(),
        item: {
          id: callId,
          type: 'dynamicToolCall',
          namespace: 'ccweb',
          tool: 'ccweb_list_conversations',
          arguments: { limit: 5 },
          status: result.success === false ? 'failed' : 'completed',
          contentItems: result.contentItems || [],
          success: result.success !== false,
          durationMs: 1,
        },
      },
    });
    completeTurn(thread, turnId, `dynamic result: ${JSON.stringify(result)}`);
  });
}

function completeMcpToolTurn(thread, turnId) {
  const itemId = 'mcp-ccweb-list';
  const ccwebConfig = thread.config?.['mcp_servers.ccweb'] || null;
  const projectConfig = thread.config?.['mcp_servers.reg-app-project'] || null;
  const env = ccwebConfig?.env || {};
  const payload = {
    ok: true,
    currentConversationId: env.CC_WEB_SOURCE_SESSION_ID || null,
    sourceHopCount: env.CC_WEB_CROSS_HOP_COUNT || null,
    hasCcwebMcpConfig: Boolean(ccwebConfig),
    hasProjectMcpConfig: Boolean(projectConfig),
    ccwebCommand: ccwebConfig?.command || null,
    ccwebArgs: ccwebConfig?.args || null,
  };
  const itemBase = {
    id: itemId,
    type: 'mcpToolCall',
    server: 'ccweb',
    tool: 'ccweb_list_conversations',
    arguments: { limit: 5 },
  };

  send({
    method: 'item/started',
    params: {
      threadId: thread.id,
      turnId,
      startedAtMs: Date.now(),
      item: {
        ...itemBase,
        status: 'inProgress',
      },
    },
  });
  send({
    method: 'item/completed',
    params: {
      threadId: thread.id,
      turnId,
      completedAtMs: Date.now(),
      item: {
        ...itemBase,
        status: 'completed',
        result: {
          content: [{ type: 'text', text: JSON.stringify(payload, null, 2) }],
          structuredContent: payload,
          isError: false,
        },
      },
    },
  });
  completeTurn(thread, turnId, `mcp result: ${JSON.stringify(payload)}`);
}

function emitCapacityError(thread, turnId) {
  send({
    method: 'error',
    params: {
      threadId: thread.id,
      turnId,
      type: 'error',
      error: {
        type: 'service_unavailable_error',
        code: 'server_is_overloaded',
        message: 'Our servers are currently overloaded. Please try again later.',
        param: null,
      },
      sequence_number: 2,
    },
  });
  thread.activeTurnId = null;
}

function emitPartialCapacityOutput(thread, turnId) {
  send({
    method: 'item/agentMessage/delta',
    params: {
      threadId: thread.id,
      turnId,
      itemId: 'agent-msg',
      delta: 'partial capacity output before retry',
    },
  });
  send({
    method: 'item/started',
    params: {
      threadId: thread.id,
      turnId,
      startedAtMs: Date.now(),
      item: {
        id: 'capacity-tool',
        type: 'commandExecution',
        command: '/bin/bash -lc echo capacity',
        status: 'inProgress',
      },
    },
  });
  send({
    method: 'item/commandExecution/outputDelta',
    params: {
      threadId: thread.id,
      turnId,
      itemId: 'capacity-tool',
      delta: 'capacity tool output\n',
    },
  });
}

function completeGuidedInputTurn(thread, turnId) {
  requestClient('item/tool/requestUserInput', {
    threadId: thread.id,
    turnId,
    itemId: 'guided-input-call',
    questions: [{
      id: 'choice',
      header: '选择',
      question: '选择一个测试答案',
      isOther: true,
      isSecret: false,
      options: [
        { label: 'A', description: '测试选项 A' },
        { label: 'B', description: '测试选项 B' },
      ],
    }],
  }, (message) => {
    const answer = message.result?.answers?.choice?.answers?.[0] || 'empty';
    completeTurn(thread, turnId, `guided answer: ${answer}`);
  });
}

function completeApprovalTurn(thread, turnId) {
  requestClient('item/commandExecution/requestApproval', {
    threadId: thread.id,
    turnId,
    itemId: 'approval-command-call',
    reason: 'Need to run an approval-gated command',
    command: 'echo approved',
    cwd: thread.cwd,
  }, (message) => {
    const decision = message.result?.decision || 'missing';
    completeTurn(thread, turnId, `approval decision: ${decision}`);
  });
}

function completeEmptyReasoningTurn(thread, turnId, text) {
  send({
    method: 'item/started',
    params: {
      threadId: thread.id,
      turnId,
      startedAtMs: Date.now(),
      item: {
        id: 'reasoning-empty',
        type: 'reasoning',
        content: [],
        summary: [],
        status: 'inProgress',
      },
    },
  });
  send({
    method: 'item/completed',
    params: {
      threadId: thread.id,
      turnId,
      completedAtMs: Date.now(),
      item: {
        id: 'reasoning-empty',
        type: 'reasoning',
        content: [],
        summary: [],
        status: 'completed',
      },
    },
  });
  completeTurn(thread, turnId, text);
}

function startTurn(params) {
  const thread = ensureThread(params.threadId, params);
  const turnId = `app-turn-${crypto.randomUUID()}`;
  const text = textFromInput(params.input);
  thread.activeTurnId = turnId;
  thread.steers = [];

  send({
    method: 'turn/started',
    params: {
      threadId: thread.id,
      turn: {
        id: turnId,
        status: 'running',
        items: [],
      },
    },
  });

  if (/runtime warning/i.test(text)) {
    const message = 'Heads up: Long threads and multiple compactions can cause the model to be less accurate. Start a new thread when possible to keep threads small and targeted.';
    for (let i = 0; i < 2; i += 1) {
      send({
        method: 'warning',
        params: {
          threadId: thread.id,
          turnId,
          message,
        },
      });
    }
  }

  if (/codexapp capacity retry/i.test(text)) {
    const retryKey = retryScenarioKey(text, 'codexapp capacity retry');
    const attempts = (thread.capacityRetryAttempts.get(retryKey) || 0) + 1;
    thread.capacityRetryAttempts.set(retryKey, attempts);
    if (attempts <= 2) {
      if (attempts === 2) emitPartialCapacityOutput(thread, turnId);
      emitCapacityError(thread, turnId);
      return { turn: { id: turnId, status: 'running', items: [] } };
    }
  }

  if (/codexapp reconnect retry/i.test(text)) {
    const retryKey = retryScenarioKey(text, 'codexapp reconnect retry');
    const attempts = (thread.reconnectRetryAttempts.get(retryKey) || 0) + 1;
    thread.reconnectRetryAttempts.set(retryKey, attempts);
    if (attempts === 1) {
      emitPartialCapacityOutput(thread, turnId);
      send({
        method: 'error',
        params: {
          threadId: thread.id,
          turnId,
          message: 'Reconnecting... 1/5',
        },
      });
      thread.activeTurnId = null;
      return { turn: { id: turnId, status: 'running', items: [] } };
    }
  }

  if (/codexapp retry thread mismatch/i.test(text)) {
    const retryKey = retryScenarioKey(text, 'codexapp retry thread mismatch');
    const attempts = (thread.capacityRetryAttempts.get(retryKey) || 0) + 1;
    thread.capacityRetryAttempts.set(retryKey, attempts);
    if (attempts === 1) {
      resumeMismatchThreads.add(thread.id);
      emitCapacityError(thread, turnId);
      return { turn: { id: turnId, status: 'running', items: [] } };
    }
  }

  if (/collaboration/i.test(text)) {
    completeTurn(thread, turnId, `collaboration mode: ${collaborationSummary(params)}`);
    return { turn: { id: turnId, status: 'running', items: [] } };
  }

  if (/empty reasoning/i.test(text)) {
    completeEmptyReasoningTurn(thread, turnId, text);
    return { turn: { id: turnId, status: 'running', items: [] } };
  }

  if (/dynamic/i.test(text)) {
    completeMcpToolTurn(thread, turnId);
    return { turn: { id: turnId, status: 'running', items: [] } };
  }

  if (/guided/i.test(text)) {
    if (!params.collaborationMode || params.collaborationMode.mode !== 'plan') {
      completeTurn(thread, turnId, 'guided input unavailable outside plan');
      return { turn: { id: turnId, status: 'running', items: [] } };
    }
    completeGuidedInputTurn(thread, turnId);
    return { turn: { id: turnId, status: 'running', items: [] } };
  }

  if (/approval/i.test(text)) {
    completeApprovalTurn(thread, turnId);
    return { turn: { id: turnId, status: 'running', items: [] } };
  }

  const delay = /recover/i.test(text) ? 5000 : /slow/i.test(text) ? 900 : 80;
  if (/recover/i.test(text)) {
    send({
      method: 'item/agentMessage/delta',
      params: {
        threadId: thread.id,
        turnId,
        itemId: 'agent-msg',
        delta: `partial before restart: ${text}`,
      },
    });
    send({
      method: 'item/started',
      params: {
        threadId: thread.id,
        turnId,
        startedAtMs: Date.now(),
        item: {
          id: 'recover-tool',
          type: 'commandExecution',
          command: '/bin/bash -lc echo recover',
          status: 'inProgress',
        },
      },
    });
    send({
      method: 'item/commandExecution/outputDelta',
      params: {
        threadId: thread.id,
        turnId,
        itemId: 'recover-tool',
        delta: 'recover tool output\n',
      },
    });
  }
  thread.timer = setTimeout(() => completeTurn(thread, turnId, text), delay);
  return { turn: { id: turnId, status: 'running', items: [] } };
}

function interruptTurn(params) {
  const thread = ensureThread(params.threadId, params);
  if (thread.timer) clearTimeout(thread.timer);
  if (thread.activeTurnId === params.turnId) {
    completeTurn(thread, params.turnId, 'interrupted', 'interrupted');
  }
  return {};
}

function steerTurn(params) {
  const thread = ensureThread(params.threadId, params);
  if (!thread.activeTurnId || thread.activeTurnId !== params.expectedTurnId) {
    return {
      error: {
        code: -32001,
        message: 'expectedTurnId does not match active turn',
      },
    };
  }
  const text = textFromInput(params.input);
  if (text) thread.steers.push(text);
  send({
    method: 'item/agentMessage/delta',
    params: {
      threadId: thread.id,
      turnId: thread.activeTurnId,
      itemId: 'agent-msg',
      delta: `\n[steer accepted: ${text}]`,
    },
  });
  return { result: {} };
}

function handleRequest(message) {
  const id = message.id;
  const method = message.method;
  const params = message.params || {};

  if (id && !method && pendingServerRequests.has(id)) {
    const callback = pendingServerRequests.get(id);
    pendingServerRequests.delete(id);
    callback(message);
    return;
  }

  try {
    if (method === 'initialize') {
      send({ id, result: { serverInfo: { name: 'mock-codex-app-server', version: '0.0.0' } } });
      return;
    }
    if (method === 'experimentalFeature/enablement/set') {
      send({ id, result: { enablement: params.enablement || {} } });
      return;
    }
    if (method === 'collaborationMode/list') {
      send({ id, result: { data: [{ mode: 'default' }, { mode: 'plan' }] } });
      return;
    }
    if (method === 'config/mcpServer/reload') {
      mcpReloadCount += 1;
      send({
        method: 'mcpServer/startupStatus/updated',
        params: {
          server: 'ccweb',
          state: 'starting',
          message: 'ccweb MCP starting',
          threadId: null,
        },
      });
      send({
        method: 'mcpServer/startupStatus/updated',
        params: {
          name: 'ccweb',
          status: 'ready',
          message: 'ccweb MCP ready CC_WEB_MCP_TOKEN=mock-secret-token',
          threadId: null,
        },
      });
      send({ id, result: { reloaded: true, reloadCount: mcpReloadCount } });
      return;
    }
    if (method === 'thread/start') {
      const thread = ensureThread(null, params);
      send({ id, result: { thread: threadPayload(thread), model: params.model || 'gpt-5.5', cwd: thread.cwd, modelProvider: 'mock', approvalPolicy: params.approvalPolicy || 'never', approvalsReviewer: 'user', sandbox: params.sandbox || 'danger-full-access' } });
      return;
    }
    if (method === 'thread/resume') {
      if (params.threadId && resumeMismatchThreads.delete(params.threadId)) {
        const thread = ensureThread(null, params);
        send({ id, result: { thread: threadPayload(thread), model: params.model || 'gpt-5.5', cwd: thread.cwd, modelProvider: 'mock', approvalPolicy: params.approvalPolicy || 'never', approvalsReviewer: 'user', sandbox: params.sandbox || 'danger-full-access' } });
        return;
      }
      const thread = ensureThread(params.threadId, params);
      send({ id, result: { thread: threadPayload(thread), model: params.model || 'gpt-5.5', cwd: thread.cwd, modelProvider: 'mock', approvalPolicy: params.approvalPolicy || 'never', approvalsReviewer: 'user', sandbox: params.sandbox || 'danger-full-access' } });
      return;
    }
    if (method === 'thread/goal/get') {
      const thread = ensureThread(params.threadId, params);
      send({ id, result: { goal: thread.goal } });
      return;
    }
    if (method === 'thread/goal/set') {
      const thread = ensureThread(params.threadId, params);
      const now = Date.now();
      const previous = thread.goal || {};
      const objective = String(params.objective || previous.objective || 'mock goal').trim();
      thread.goal = {
        threadId: thread.id,
        objective,
        status: String(params.status || previous.status || 'active'),
        tokenBudget: previous.tokenBudget ?? null,
        tokensUsed: previous.tokensUsed ?? 3,
        timeUsedSeconds: previous.timeUsedSeconds ?? 0,
        createdAt: previous.createdAt || now,
        updatedAt: now,
      };
      send({
        method: 'thread/goal/updated',
        params: { threadId: thread.id, goal: thread.goal },
      });
      send({ id, result: { goal: thread.goal } });
      return;
    }
    if (method === 'thread/goal/clear') {
      const thread = ensureThread(params.threadId, params);
      const cleared = !!thread.goal;
      thread.goal = null;
      send({
        method: 'thread/goal/cleared',
        params: { threadId: thread.id },
      });
      send({ id, result: { cleared } });
      return;
    }
    if (method === 'turn/start') {
      send({ id, result: startTurn(params) });
      return;
    }
    if (method === 'turn/steer') {
      const result = steerTurn(params);
      send({ id, ...result });
      return;
    }
    if (method === 'turn/interrupt') {
      send({ id, result: interruptTurn(params) });
      return;
    }
    if (method === 'initialized') return;

    send({ id, error: { code: -32601, message: `Unknown mock method: ${method}` } });
  } catch (err) {
    send({ id, error: { code: -32603, message: err.message || String(err) } });
  }
}

const rl = readline.createInterface({ input: process.stdin });
rl.on('line', (line) => {
  if (!line.trim()) return;
  let message;
  try {
    message = JSON.parse(line);
  } catch {
    return;
  }
  if (Object.prototype.hasOwnProperty.call(message, 'id')) handleRequest(message);
});