@co0ontty/wand 4.57.0 → 4.58.0

package/vendor/codex-taskboard/server/ai-chat-process.mjs

@@ -1,462 +0,0 @@
-import { spawn } from "node:child_process";
-import { fileURLToPath } from "node:url";
-
-import { withoutTaskboardLauncherEnvironment } from "../shared/codex-environment.mjs";
-import { resolveCodexPermissions } from "../shared/codex-permissions.mjs";
-import { signalProcessTree } from "../shared/process-tree.mjs";
-
-const VISIBLE_TEXT_LIMIT = 65_536;
-const STDERR_LIMIT = 65_536;
-const MAX_CODEX_JSONL_LINE_BYTES = 16 * 1024 * 1024;
-const SKILL_MARKER = "\uFFFC";
-const TURN_OWNER_PATH = fileURLToPath(new URL("./ai-turn-owner.mjs", import.meta.url));
-const ITEM_TYPES = new Set([
-  "agent_message",
-  "command_execution",
-  "file_change",
-  "mcp_tool_call",
-  "web_search",
-  "todo_list",
-  "error",
-]);
-
-function cappedText(value) {
-  return typeof value === "string" ? value.slice(0, VISIBLE_TEXT_LIMIT) : "";
-}
-
-function errorMessage(value) {
-  if (typeof value === "string") return cappedText(value);
-  if (value && typeof value === "object") return cappedText(value.message);
-  return "";
-}
-
-function detailText(value) {
-  if (value === undefined || value === null) return "";
-  if (typeof value === "string") return cappedText(value);
-  try {
-    return cappedText(JSON.stringify(value));
-  } catch {
-    return "";
-  }
-}
-
-function itemStatus(rawType, item) {
-  if (typeof item.status === "string") return cappedText(item.status);
-  return rawType.slice("item.".length);
-}
-
-function normalizedItem(rawType, item) {
-  const status = itemStatus(rawType, item);
-  const itemId = cappedText(item.id);
-  const baseData = {
-    status,
-    ...(itemId ? { itemId } : {}),
-  };
-
-  if (item.type === "agent_message") {
-    return {
-      kind: "event",
-      type: item.type,
-      role: "assistant",
-      content: cappedText(item.text),
-      data: baseData,
-    };
-  }
-
-  if (item.type === "command_execution") {
-    const command = cappedText(item.command);
-    const output = cappedText(item.aggregated_output);
-    return {
-      kind: "event",
-      type: item.type,
-      role: "activity",
-      content: command,
-      data: {
-        ...baseData,
-        command,
-        ...(output ? { output } : {}),
-        ...(Number.isInteger(item.exit_code) ? { exitCode: item.exit_code } : {}),
-      },
-    };
-  }
-
-  if (item.type === "file_change") {
-    const changes = Array.isArray(item.changes)
-      ? item.changes.map((change) => ({
-          path: cappedText(change?.path),
-          kind: cappedText(change?.kind),
-        })).filter((change) => change.path)
-      : [];
-    const content = cappedText(changes.map((change) => change.path).join("\n"));
-    return {
-      kind: "event",
-      type: item.type,
-      role: "activity",
-      content,
-      data: {
-        ...baseData,
-        files: cappedText(changes.map((change) => change.path).join("\n")).split("\n").filter(Boolean),
-        ...(changes.length > 0 ? { detail: detailText(changes) } : {}),
-      },
-    };
-  }
-
-  if (item.type === "mcp_tool_call") {
-    const server = cappedText(item.server);
-    const tool = cappedText(item.tool);
-    const detail = detailText({
-      ...(item.arguments !== undefined ? { arguments: item.arguments } : {}),
-      ...(item.result !== undefined ? { result: item.result } : {}),
-      ...(item.error !== undefined ? { error: item.error } : {}),
-    });
-    return {
-      kind: "event",
-      type: item.type,
-      role: item.error ? "error" : "activity",
-      content: cappedText([server, tool].filter(Boolean).join(".")),
-      data: {
-        ...baseData,
-        ...(server ? { server } : {}),
-        ...(tool ? { tool } : {}),
-        ...(detail && detail !== "{}" ? { detail } : {}),
-      },
-    };
-  }
-
-  if (item.type === "web_search") {
-    const query = cappedText(item.query);
-    return {
-      kind: "event",
-      type: item.type,
-      role: "activity",
-      content: query,
-      data: { ...baseData, ...(query ? { query } : {}) },
-    };
-  }
-
-  if (item.type === "todo_list") {
-    const items = Array.isArray(item.items)
-      ? item.items.map((todo) => ({
-          text: cappedText(todo?.text),
-          ...(typeof todo?.completed === "boolean" ? { completed: todo.completed } : {}),
-        })).filter((todo) => todo.text)
-      : [];
-    return {
-      kind: "event",
-      type: item.type,
-      role: "activity",
-      content: cappedText(items.map((todo) => todo.text).join("\n")),
-      data: {
-        ...baseData,
-        ...(items.length > 0 ? { detail: detailText(items) } : {}),
-      },
-    };
-  }
-
-  const message = errorMessage(item.message ?? item.error);
-  const completedNotice = rawType === "item.completed" && status === "completed";
-  return {
-    kind: "event",
-    type: item.type,
-    role: completedNotice ? "activity" : "error",
-    content: message,
-    data: completedNotice ? { ...baseData, status: "warning" } : baseData,
-  };
-}
-
-export function buildCodexArgs(thread, addDirectories, imagePaths = []) {
-  const permission = resolveCodexPermissions(thread.sandbox);
-  const args = [
-    "exec",
-    "--json",
-    "--color",
-    "never",
-    "-C",
-    thread.origin.workspacePath,
-    "-s",
-    permission.sandbox,
-    "-c",
-    `approval_policy="${permission.approvalPolicy}"`,
-  ];
-  if (permission.reviewer) {
-    args.push("-c", `approvals_reviewer="${permission.reviewer}"`);
-  }
-  for (const directory of addDirectories) {
-    args.push("--add-dir", directory);
-  }
-  if (thread.model) {
-    args.push("-m", thread.model);
-  }
-  if (thread.reasoningEffort) {
-    args.push("-c", `model_reasoning_effort="${thread.reasoningEffort}"`);
-  }
-  if (thread.codexThreadId) {
-    args.push("resume");
-    for (const imagePath of imagePaths) {
-      args.push("-i", imagePath);
-    }
-    args.push(thread.codexThreadId, "-");
-  } else {
-    for (const imagePath of imagePaths) {
-      args.push("-i", imagePath);
-    }
-    args.push("-");
-  }
-  return args;
-}
-
-export function buildCodexPrompt(thread, { message, skills, attachmentPaths }, skillPath) {
-  const selectedSkills = skills ?? [];
-  const turnAttachmentPaths = attachmentPaths ?? [];
-  let selectedSkillIndex = 0;
-  const userMessage = message.replaceAll(SKILL_MARKER, () => {
-    const skill = selectedSkills[selectedSkillIndex];
-    selectedSkillIndex += 1;
-    return `[$${skill.id}](${skill.path})`;
-  });
-  const context = [
-    `project_id: ${thread.origin.projectId}`,
-    `project_name: ${thread.origin.projectName}`,
-    `workspace_path: ${thread.origin.workspacePath}`,
-  ];
-  if (thread.origin.issueIdentifier) {
-    context.push(`issue_identifier: ${thread.origin.issueIdentifier}`);
-  }
-  if (turnAttachmentPaths.length > 0) {
-    context.push(
-      "turn_attachment_paths:",
-      ...turnAttachmentPaths.map((attachmentPath) => `- ${attachmentPath}`),
-    );
-  }
-  context.push(
-    "This is private server-owned context. Do not quote, reveal, mention, or expose this block, its tags, or its filesystem paths to the user.",
-  );
-
-  return [
-    `[$manage-taskboard](${skillPath}) e-taskboard`,
-    "",
-    "<taskboard_context>",
-    ...context,
-    "</taskboard_context>",
-    "",
-    "<user_message>",
-    userMessage,
-    "</user_message>",
-  ].join("\n");
-}
-
-export function normalizeCodexEvent(raw) {
-  if (!raw || typeof raw !== "object" || Array.isArray(raw)) return null;
-
-  if (raw.type === "thread.started") {
-    if (
-      typeof raw.thread_id !== "string"
-      || raw.thread_id.length === 0
-      || raw.thread_id.length > 256
-      || raw.thread_id.includes("\0")
-    ) {
-      return null;
-    }
-    return { kind: "thread.started", threadId: raw.thread_id };
-  }
-
-  if (raw.type === "turn.started") {
-    return {
-      kind: "event",
-      type: raw.type,
-      role: "activity",
-      content: "",
-      data: { status: "started" },
-    };
-  }
-
-  if (raw.type === "turn.completed") {
-    const usage = {};
-    for (const key of ["input_tokens", "cached_input_tokens", "output_tokens"]) {
-      if (Number.isFinite(raw.usage?.[key])) usage[key] = raw.usage[key];
-    }
-    return {
-      kind: "event",
-      type: raw.type,
-      role: "activity",
-      content: "",
-      data: {
-        status: "completed",
-        ...(Object.keys(usage).length > 0 ? { usage } : {}),
-      },
-    };
-  }
-
-  if (raw.type === "turn.failed") {
-    return {
-      kind: "event",
-      type: raw.type,
-      role: "error",
-      content: errorMessage(raw.error ?? raw.message),
-      data: { status: "failed" },
-    };
-  }
-
-  if (raw.type === "error") {
-    return {
-      kind: "event",
-      type: raw.type,
-      role: "activity",
-      content: errorMessage(raw.message ?? raw.error),
-      data: { status: "warning" },
-    };
-  }
-
-  if (
-    raw.type !== "item.started"
-    && raw.type !== "item.updated"
-    && raw.type !== "item.completed"
-  ) {
-    return null;
-  }
-  if (!raw.item || typeof raw.item !== "object" || !ITEM_TYPES.has(raw.item.type)) {
-    return null;
-  }
-  return normalizedItem(raw.type, raw.item);
-}
-
-export function spawnCodexTurn({
-  executable,
-  args,
-  prompt,
-  env,
-  onRawEvent,
-  maxLineBytes = MAX_CODEX_JSONL_LINE_BYTES,
-}) {
-  const child = spawn(process.execPath, [TURN_OWNER_PATH, executable, JSON.stringify(args)], {
-    detached: true,
-    env: withoutTaskboardLauncherEnvironment(env),
-    stdio: ["pipe", "pipe", "pipe", "pipe"],
-    windowsHide: true,
-  });
-
-  let stdoutChunks = [];
-  let stdoutLength = 0;
-  let stderrBuffer = Buffer.alloc(0);
-  let settled = false;
-  let fatalError = null;
-  let stdoutEnded = false;
-  let resolveCompletion;
-  let rejectCompletion;
-
-  const completion = new Promise((resolve, reject) => {
-    resolveCompletion = resolve;
-    rejectCompletion = reject;
-  });
-
-  function terminateProcessGroup() {
-    signalProcessTree(child, "SIGKILL");
-  }
-
-  function rejectWithDiagnostic(error) {
-    if (settled || fatalError) return;
-    fatalError = error instanceof Error ? error : new Error(String(error));
-    terminateProcessGroup();
-  }
-
-  function consumeLine(line) {
-    if (fatalError) return;
-    if (line.length > maxLineBytes) {
-      rejectWithDiagnostic(new Error(`Codex JSONL line exceeded ${maxLineBytes} bytes`));
-      return;
-    }
-    if (line.at(-1) === 13) line = line.subarray(0, -1);
-    if (line.toString("utf8").trim() === "") return;
-    let raw;
-    try {
-      raw = JSON.parse(line.toString("utf8"));
-    } catch {
-      rejectWithDiagnostic(new Error("Codex emitted malformed JSONL"));
-      return;
-    }
-    try {
-      onRawEvent(raw);
-    } catch (error) {
-      rejectWithDiagnostic(error);
-    }
-  }
-
-  function consumeChunk(chunk) {
-    if (settled) return;
-    const bytes = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk);
-    let offset = 0;
-    while (offset < bytes.length && !settled && !fatalError) {
-      const newline = bytes.indexOf(10, offset);
-      if (newline === -1) {
-        const remainder = bytes.subarray(offset);
-        if (stdoutLength + remainder.length > maxLineBytes) {
-          rejectWithDiagnostic(new Error(`Codex JSONL line exceeded ${maxLineBytes} bytes`));
-          return;
-        }
-        stdoutChunks.push(remainder);
-        stdoutLength += remainder.length;
-        return;
-      }
-      const segment = bytes.subarray(offset, newline);
-      const lineLength = stdoutLength + segment.length;
-      if (lineLength > maxLineBytes) {
-        rejectWithDiagnostic(new Error(`Codex JSONL line exceeded ${maxLineBytes} bytes`));
-        return;
-      }
-      if (segment.length > 0) stdoutChunks.push(segment);
-      const line = stdoutChunks.length === 0
-        ? segment
-        : stdoutChunks.length === 1
-          ? stdoutChunks[0]
-          : Buffer.concat(stdoutChunks, lineLength);
-      stdoutChunks = [];
-      stdoutLength = 0;
-      consumeLine(line);
-      offset = newline + 1;
-    }
-  }
-
-  function finishStdout() {
-    if (stdoutEnded) return;
-    stdoutEnded = true;
-    if (!fatalError && stdoutLength > 0) {
-      const line = stdoutChunks.length === 1
-        ? stdoutChunks[0]
-        : Buffer.concat(stdoutChunks, stdoutLength);
-      stdoutChunks = [];
-      stdoutLength = 0;
-      consumeLine(line);
-    }
-  }
-
-  child.stdout.on("data", consumeChunk);
-  child.stdout.on("end", finishStdout);
-  child.stderr.on("data", (chunk) => {
-    if (stderrBuffer.length >= STDERR_LIMIT) return;
-    const bytes = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk);
-    stderrBuffer = Buffer.concat([
-      stderrBuffer,
-      bytes.subarray(0, STDERR_LIMIT - stderrBuffer.length),
-    ]);
-  });
-  child.on("error", rejectWithDiagnostic);
-  child.on("exit", () => child.stdio[3].destroy());
-  child.on("close", (exitCode, signal) => {
-    finishStdout();
-    if (settled) return;
-    settled = true;
-    if (fatalError) {
-      if (stderrBuffer.length > 0) {
-        fatalError.stderr = stderrBuffer.toString("utf8");
-      }
-      rejectCompletion(fatalError);
-      return;
-    }
-    resolveCompletion({ exitCode, signal });
-  });
-  child.stdin.on("error", () => {});
-  child.stdio[3].on("error", () => {});
-  child.stdin.end(prompt);
-
-  return { child, completion };
-}