boss/tests/fixtures/codex-app-server-runtime.mjs

#!/usr/bin/env node

import readline from "node:readline";

const rl = readline.createInterface({ input: process.stdin });
const received = [];
let injectedItems = [];
let overloadedTurnStartEmitted = false;

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

rl.on("line", (line) => {
  const message = JSON.parse(line);
  received.push(message);

  if (message.method === "initialize") {
    send({
      id: message.id,
      result: {
        userAgent: "boss-test-codex-app-server",
        platformFamily: "mac",
        platformOs: "darwin",
      },
    });
    return;
  }

  if (message.method === "initialized") {
    return;
  }

  if (message.method === "thread/resume") {
    send({
      id: message.id,
      result: {
        thread: {
          id: message.params?.threadId ?? "thread-fixture",
          name: "fixture thread",
        },
      },
    });
    return;
  }

  if (message.method === "thread/read") {
    send({
      id: message.id,
      result: {
        thread: {
          id: message.params?.threadId,
          name: "源线程",
        },
        items: [
          {
            type: "message",
            role: "assistant",
            content: [
              {
                type: "output_text",
                text: "源线程最近结论：优先使用 app-server 协议。",
              },
            ],
          },
        ],
      },
    });
    return;
  }

  if (message.method === "thread/inject_items") {
    injectedItems = message.params?.items ?? [];
    send({
      id: message.id,
      result: {
        injected: injectedItems.length,
      },
    });
    return;
  }

  if (message.method === "thread/start") {
    send({
      id: message.id,
      result: {
        thread: {
          id: "thread-started-fixture",
          name: "new fixture thread",
        },
      },
    });
    return;
  }

  if (message.method === "turn/start") {
    if (
      process.env.BOSS_CODEX_APP_SERVER_FIXTURE_OVERLOAD_ON_TURN_START === "1" &&
      !overloadedTurnStartEmitted
    ) {
      overloadedTurnStartEmitted = true;
      send({
        id: message.id,
        error: {
          code: -32001,
          message: "Server overloaded; retry later.",
        },
      });
      return;
    }
    const text = message.params?.input?.find?.((item) => item?.type === "text")?.text ?? "";
    send({
      id: message.id,
      result: {
        turn: {
          id: "turn-fixture",
          threadId: message.params?.threadId,
        },
      },
    });
    if (process.env.BOSS_CODEX_APP_SERVER_FIXTURE_EXIT_AFTER_TURN_START === "1") {
      process.exit(0);
    }
    if (process.env.BOSS_CODEX_APP_SERVER_FIXTURE_EMIT_PROGRESS === "1") {
      send({
        method: "turn/plan/updated",
        params: {
          threadId: message.params?.threadId,
          turnId: "turn-fixture",
          plan: [
            { text: "读取 Codex 官方 app-server 协议", status: "completed" },
            { text: "执行 targeted/full test", status: "in_progress" },
          ],
        },
      });
      send({
        method: "turn/diff/updated",
        params: {
          threadId: message.params?.threadId,
          turnId: "turn-fixture",
          diff: {
            changedFiles: 3,
            additions: 181,
            deletions: 52,
          },
        },
      });
      send({
        method: "item/completed",
        params: {
          threadId: message.params?.threadId,
          turnId: "turn-fixture",
          item: {
            type: "fileChange",
            id: "file-change-1",
            changes: [
              { path: "docs/protocol-snapshots/codex-app-server/codex-app-server-protocol-0.135.0.json" },
            ],
          },
        },
      });
      send({
        method: "thread/started",
        params: {
          thread: {
            id: "subagent-thread",
            source: {
              subAgent: {
                thread_spawn: {
                  agent_nickname: "Mendel",
                  agent_role: "explorer",
                },
              },
            },
          },
        },
      });
    }
    if (process.env.BOSS_CODEX_APP_SERVER_FIXTURE_EMIT_GUARDIAN_EVENTS === "1") {
      send({
        id: "cmd-approval-1",
        method: "item/commandExecution/requestApproval",
        params: {
          threadId: message.params?.threadId,
          turnId: "turn-fixture",
          itemId: "command-item-1",
          startedAtMs: Date.now(),
          reason: "需要确认命令执行",
          command: "npm run build -- --token sk-secret-should-not-leak",
          cwd: "/Users/kris/code/boss",
        },
      });
      send({
        method: "item/autoApprovalReview/started",
        params: {
          threadId: message.params?.threadId,
          turnId: "turn-fixture",
          reviewId: "review-1",
          startedAtMs: Date.now(),
          targetItemId: "command-item-1",
          action: {
            type: "command",
            command: "npm run build -- --token sk-secret-should-not-leak",
            cwd: "/Users/kris/code/boss",
          },
          review: {
            status: "running",
            riskLevel: "medium",
            userAuthorization: null,
            rationale: "contains a fake secret that must not be surfaced",
          },
        },
      });
      send({
        method: "guardianWarning",
        params: {
          threadId: message.params?.threadId,
          message: "检测到需要用户确认的命令执行。",
        },
      });
      send({
        method: "item/fileChange/patchUpdated",
        params: {
          threadId: message.params?.threadId,
          turnId: "turn-fixture",
          itemId: "file-change-item-1",
          changes: [
            {
              path: "src/app/page.tsx",
              kind: "update",
              diff: "+ const secret = 'sk-secret-should-not-leak'",
            },
            {
              path: "docs/architecture/codex_server_progress_card_cn.md",
              kind: "add",
              diff: "+ internal prompt should not leak",
            },
          ],
        },
      });
      send({
        method: "item/autoApprovalReview/completed",
        params: {
          threadId: message.params?.threadId,
          turnId: "turn-fixture",
          reviewId: "review-1",
          startedAtMs: Date.now(),
          completedAtMs: Date.now(),
          targetItemId: "command-item-1",
          decisionSource: "auto_review",
          action: {
            type: "command",
            command: "npm run build -- --token sk-secret-should-not-leak",
            cwd: "/Users/kris/code/boss",
          },
          review: {
            status: "approved",
            riskLevel: "medium",
            userAuthorization: null,
            rationale: "contains a fake secret that must not be surfaced",
          },
        },
      });
      send({
        method: "serverRequest/resolved",
        params: {
          requestId: "cmd-approval-1",
          threadId: message.params?.threadId,
        },
      });
    }
    send({
      method: "item/agentMessage/delta",
      params: {
        threadId: message.params?.threadId,
        turnId: "turn-fixture",
        delta:
          process.env.BOSS_CODEX_APP_SERVER_FIXTURE_INTER_THREAD === "1"
            ? `INTER_THREAD_INJECTED:${JSON.stringify(injectedItems)}`
            : `APP_SERVER_REPLY:${text}`,
      },
    });
    send({
      method: "turn/completed",
      params: {
        threadId: message.params?.threadId,
        turn: {
          id: "turn-fixture",
          status: "completed",
        },
      },
    });
    process.stderr.write(`${JSON.stringify({ received })}\n`);
    return;
  }

  if (message.method === "turn/steer") {
    const text = message.params?.input?.find?.((item) => item?.type === "text")?.text ?? "";
    send({
      id: message.id,
      result: {
        turn: {
          id: message.params?.expectedTurnId,
          threadId: message.params?.threadId,
        },
      },
    });
    send({
      method: "item/agentMessage/delta",
      params: {
        threadId: message.params?.threadId,
        turnId: message.params?.expectedTurnId,
        delta:
          process.env.BOSS_CODEX_APP_SERVER_FIXTURE_STEER === "1"
            ? `STEERED:${text}`
            : `APP_SERVER_STEERED:${text}`,
      },
    });
    send({
      method: "turn/completed",
      params: {
        threadId: message.params?.threadId,
        turn: {
          id: message.params?.expectedTurnId,
          status: "completed",
        },
      },
    });
    process.stderr.write(`${JSON.stringify({ received })}\n`);
    return;
  }

  send({
    id: message.id,
    error: {
      code: -32601,
      message: `unknown method ${message.method}`,
    },
  });
});