openclaw-codex-app-server 0.0.0

package/src/pending-input.ts

@@ -0,0 +1,785 @@
+import crypto from "node:crypto";
+import type {
+  PendingApprovalDecision,
+  PendingInputAction,
+  PendingInputState,
+  PendingQuestionnaireAnswer,
+  PendingQuestionnaireQuestion,
+  PendingQuestionnaireState,
+} from "./types.js";
+
+const MAX_PENDING_REQUEST_TEXT_CHARS = 1200;
+const MAX_PENDING_PROMPT_TEXT_CHARS = 2200;
+
+function asRecord(value: unknown): Record<string, unknown> | undefined {
+  return value && typeof value === "object" && !Array.isArray(value)
+    ? (value as Record<string, unknown>)
+    : undefined;
+}
+
+function pickString(
+  record: Record<string, unknown> | undefined,
+  keys: readonly string[],
+): string | undefined {
+  for (const key of keys) {
+    const value = record?.[key];
+    if (typeof value !== "string") {
+      continue;
+    }
+    const trimmed = value.trim();
+    if (trimmed) {
+      return trimmed;
+    }
+  }
+  return undefined;
+}
+
+function findFirstStringByKeys(
+  value: unknown,
+  keys: readonly string[],
+  depth = 0,
+): string | undefined {
+  if (depth > 5) {
+    return undefined;
+  }
+  if (Array.isArray(value)) {
+    for (const item of value) {
+      const match = findFirstStringByKeys(item, keys, depth + 1);
+      if (match) {
+        return match;
+      }
+    }
+    return undefined;
+  }
+  const record = asRecord(value);
+  if (!record) {
+    return undefined;
+  }
+  const direct = pickString(record, keys);
+  if (direct) {
+    return direct;
+  }
+  for (const nested of Object.values(record)) {
+    const match = findFirstStringByKeys(nested, keys, depth + 1);
+    if (match) {
+      return match;
+    }
+  }
+  return undefined;
+}
+
+function isFileChangeApprovalMethod(methodLower: string): boolean {
+  return methodLower.includes("filechange/requestapproval");
+}
+
+function isCommandApprovalMethod(methodLower: string): boolean {
+  return methodLower.includes("commandexecution/requestapproval") || methodLower === "turn/requestapproval";
+}
+
+function normalizeApprovalDecision(value: string): PendingApprovalDecision | null {
+  const normalized = value.trim().toLowerCase();
+  switch (normalized) {
+    case "accept":
+    case "approve":
+    case "allow":
+      return "accept";
+    case "acceptwithexecpolicyamendment":
+    case "acceptforsession":
+    case "approveforsession":
+    case "allowforsession":
+      return "acceptForSession";
+    case "decline":
+    case "deny":
+    case "reject":
+      return "decline";
+    case "cancel":
+    case "abort":
+    case "stop":
+      return "cancel";
+    default:
+      return null;
+  }
+}
+
+function humanizeApprovalDecision(
+  decision: PendingApprovalDecision,
+  sessionPrefix?: string,
+): string {
+  switch (decision) {
+    case "accept":
+      return "Approve Once";
+    case "acceptForSession":
+      return sessionPrefix ? `Approve for Session (${sessionPrefix})` : "Approve for Session";
+    case "decline":
+      return "Decline";
+    case "cancel":
+      return "Cancel";
+  }
+}
+
+function extractSessionPrefix(value: unknown): string | undefined {
+  const record = asRecord(value);
+  return (
+    findFirstStringByKeys(record?.proposedExecpolicyAmendment, [
+      "prefix",
+      "commandPrefix",
+      "prefixToApprove",
+      "allowedPrefix",
+      "command_prefix",
+    ]) ??
+    findFirstStringByKeys(record?.sessionApproval, [
+      "prefix",
+      "commandPrefix",
+      "prefixToApprove",
+      "allowedPrefix",
+      "command_prefix",
+    ]) ??
+    findFirstStringByKeys(record?.execPolicyAmendment, [
+      "prefix",
+      "commandPrefix",
+      "prefixToApprove",
+      "allowedPrefix",
+      "command_prefix",
+    ])
+  );
+}
+
+function buildApprovalActionsFromDecisions(value: unknown): PendingInputAction[] {
+  const record = asRecord(value);
+  const rawDecisions = record?.availableDecisions ?? record?.decisions;
+  if (!Array.isArray(rawDecisions)) {
+    return [];
+  }
+  const actions: PendingInputAction[] = [];
+  for (const entry of rawDecisions) {
+    if (typeof entry === "string") {
+      const decision = normalizeApprovalDecision(entry);
+      if (!decision) {
+        continue;
+      }
+      actions.push({
+        kind: "approval",
+        decision,
+        responseDecision: entry,
+        label: humanizeApprovalDecision(decision),
+      });
+      continue;
+    }
+    const decisionRecord = asRecord(entry);
+    const decisionValue =
+      pickString(decisionRecord, ["decision", "value", "name", "id", "action"]) ?? "";
+    const decision = normalizeApprovalDecision(decisionValue);
+    if (!decision) {
+      continue;
+    }
+    const sessionPrefix =
+      decision === "acceptForSession" ? extractSessionPrefix(decisionRecord) : undefined;
+    const proposedExecpolicyAmendment =
+      decision === "acceptForSession"
+        ? (asRecord(decisionRecord?.proposedExecpolicyAmendment) ??
+          asRecord(decisionRecord?.execPolicyAmendment) ??
+          undefined)
+        : undefined;
+    actions.push({
+      kind: "approval",
+      decision,
+      responseDecision: decisionValue || decision,
+      ...(proposedExecpolicyAmendment ? { proposedExecpolicyAmendment } : {}),
+      ...(sessionPrefix ? { sessionPrefix } : {}),
+      label:
+        pickString(decisionRecord, ["label", "title", "text"]) ??
+        humanizeApprovalDecision(decision, sessionPrefix),
+    });
+  }
+  return actions;
+}
+
+function resolveApprovalDecisionFromText(text: string): PendingApprovalDecision | null {
+  const normalized = text.trim().toLowerCase();
+  if (!normalized) {
+    return null;
+  }
+  if (normalized.includes("session")) {
+    return "acceptForSession";
+  }
+  if (/cancel|abort|stop/.test(normalized)) {
+    return "cancel";
+  }
+  if (/deny|decline|reject|block|no/.test(normalized)) {
+    return "decline";
+  }
+  if (/approve|allow|accept|yes/.test(normalized)) {
+    return "accept";
+  }
+  return null;
+}
+
+function buildApprovalActionsFromOptions(options: string[]): PendingInputAction[] {
+  const seen = new Set<PendingApprovalDecision>();
+  const actions: PendingInputAction[] = [];
+  for (const option of options) {
+    const decision = resolveApprovalDecisionFromText(option);
+    if (!decision || seen.has(decision)) {
+      continue;
+    }
+    seen.add(decision);
+    actions.push({
+      kind: "approval",
+      decision,
+      responseDecision: decision,
+      label: option.trim() || humanizeApprovalDecision(decision),
+    });
+  }
+  return actions;
+}
+
+function buildApprovalActionsFromMethod(
+  methodLower: string,
+  requestParams: unknown,
+): PendingInputAction[] {
+  if (isFileChangeApprovalMethod(methodLower)) {
+    return [
+      {
+        kind: "approval",
+        decision: "accept",
+        responseDecision: "accept",
+        label: "Approve File Changes",
+      },
+      {
+        kind: "approval",
+        decision: "decline",
+        responseDecision: "decline",
+        label: "Decline",
+      },
+    ];
+  }
+  if (!isCommandApprovalMethod(methodLower)) {
+    return [];
+  }
+  const sessionPrefix = extractSessionPrefix(requestParams);
+  const actions: PendingInputAction[] = [
+    {
+      kind: "approval",
+      decision: "accept",
+      responseDecision: "accept",
+      label: "Approve Once",
+    },
+  ];
+  if (sessionPrefix) {
+    actions.push({
+      kind: "approval",
+      decision: "acceptForSession",
+      responseDecision: "acceptForSession",
+      sessionPrefix,
+      label: humanizeApprovalDecision("acceptForSession", sessionPrefix),
+    });
+  }
+  actions.push(
+    {
+      kind: "approval",
+      decision: "decline",
+      responseDecision: "decline",
+      label: "Decline",
+    },
+    {
+      kind: "approval",
+      decision: "cancel",
+      responseDecision: "cancel",
+      label: "Cancel",
+    },
+  );
+  return actions;
+}
+
+function extractFilePaths(value: unknown): string[] {
+  const record = asRecord(value);
+  if (!record) {
+    return [];
+  }
+  const seen = new Set<string>();
+  const out: string[] = [];
+  const pushPath = (pathValue: unknown) => {
+    if (typeof pathValue !== "string") {
+      return;
+    }
+    const trimmed = pathValue.trim();
+    if (!trimmed || seen.has(trimmed)) {
+      return;
+    }
+    seen.add(trimmed);
+    out.push(trimmed);
+  };
+  const filePaths = Array.isArray(record.filePaths)
+    ? record.filePaths
+    : Array.isArray(record.file_paths)
+      ? record.file_paths
+      : [];
+  filePaths.forEach((entry) => pushPath(entry));
+  const changes = Array.isArray(record.changes) ? record.changes : [];
+  changes.forEach((entry) => pushPath(asRecord(entry)?.path));
+  return out;
+}
+
+export function buildPendingUserInputActions(params: {
+  method?: string;
+  requestParams?: unknown;
+  options?: string[];
+}): PendingInputAction[] {
+  const methodLower = params.method?.trim().toLowerCase() ?? "";
+  const options = params.options?.map((option) => option.trim()).filter(Boolean) ?? [];
+  if (methodLower.includes("requestapproval")) {
+    const approvalActions = buildApprovalActionsFromDecisions(params.requestParams);
+    const resolvedApprovalActions =
+      approvalActions.length > 0
+        ? approvalActions
+        : buildApprovalActionsFromOptions(options).length > 0
+          ? buildApprovalActionsFromOptions(options)
+          : buildApprovalActionsFromMethod(methodLower, params.requestParams);
+    return [...resolvedApprovalActions, { kind: "steer", label: "Tell Codex What To Do" }];
+  }
+  return options.map((option) => ({
+    kind: "option",
+    label: option,
+    value: option,
+  }));
+}
+
+function dedupeJoinedText(chunks: string[]): string {
+  const seen = new Set<string>();
+  const out: string[] = [];
+  for (const chunk of chunks.map((value) => value.trim()).filter(Boolean)) {
+    if (seen.has(chunk)) {
+      continue;
+    }
+    seen.add(chunk);
+    out.push(chunk);
+  }
+  return out.join("\n\n").trim();
+}
+
+function truncateWithNotice(text: string, maxChars: number, notice: string): string {
+  const trimmed = text.trim();
+  if (trimmed.length <= maxChars) {
+    return trimmed;
+  }
+  return `${trimmed.slice(0, Math.max(1, maxChars)).trimEnd()}\n\n${notice}`;
+}
+
+function parseQuestionnaireOption(line: string): { key: string; label: string } | null {
+  const match = line.trim().match(/^[•*-]?\s*([A-Z])[\.\)]?\s+(.+)$/);
+  if (!match?.[1] || !match[2]) {
+    return null;
+  }
+  return {
+    key: match[1],
+    label: match[2].trim(),
+  };
+}
+
+function extractQuestionnaireFromStructuredRequest(
+  value: unknown,
+): PendingQuestionnaireState | undefined {
+  const record = asRecord(value);
+  const rawQuestions = Array.isArray(record?.questions) ? record.questions : [];
+  if (rawQuestions.length === 0) {
+    return undefined;
+  }
+  const questions: PendingQuestionnaireQuestion[] = rawQuestions
+    .map((entry, index) => {
+      const question = asRecord(entry);
+      if (!question) {
+        return null;
+      }
+      const rawOptions = Array.isArray(question.options) ? question.options : [];
+      const options = rawOptions
+        .map((option, optionIndex) => {
+          const optionRecord = asRecord(option);
+          if (!optionRecord) {
+            return null;
+          }
+          const label = pickString(optionRecord, ["label", "title", "text"]);
+          if (!label) {
+            return null;
+          }
+          return {
+            key: String.fromCharCode(65 + optionIndex),
+            label,
+            description: pickString(optionRecord, ["description", "details", "summary"]),
+            recommended: /\(recommended\)/i.test(label),
+          };
+        })
+        .filter(Boolean) as PendingQuestionnaireQuestion["options"];
+      if (options.length === 0) {
+        return null;
+      }
+      const header = pickString(question, ["header"]);
+      const prompt = pickString(question, ["question"]) ?? header ?? `Question ${index + 1}`;
+      return {
+        index,
+        id: pickString(question, ["id"]) ?? `q${index + 1}`,
+        header,
+        prompt,
+        options,
+        guidance: [],
+        allowFreeform: question.isOther === true || question.is_other === true,
+      };
+    })
+    .filter(Boolean) as PendingQuestionnaireQuestion[];
+  if (questions.length === 0) {
+    return undefined;
+  }
+  return {
+    questions,
+    currentIndex: 0,
+    answers: questions.map(() => null),
+    responseMode: "structured",
+  };
+}
+
+export function parsePendingQuestionnaire(text: string): PendingQuestionnaireState | undefined {
+  const normalized = text.replace(/\r\n/g, "\n").trim();
+  if (!normalized) {
+    return undefined;
+  }
+  const starts = [...normalized.matchAll(/(?:^|\n)(\d+)\.\s+/g)].map((match) => match.index ?? 0);
+  if (starts.length < 2) {
+    return undefined;
+  }
+  const questions: PendingQuestionnaireQuestion[] = [];
+  for (let index = 0; index < starts.length; index += 1) {
+    const start = starts[index] ?? 0;
+    const end = starts[index + 1] ?? normalized.length;
+    const block = normalized
+      .slice(start, end)
+      .trim()
+      .replace(/^\d+\.\s+/, "");
+    const lines = block.split("\n");
+    const prompt = lines.shift()?.trim() ?? "";
+    if (!prompt) {
+      continue;
+    }
+    const options: Array<{ key: string; label: string }> = [];
+    const guidance: string[] = [];
+    let inGuidance = false;
+    for (const rawLine of lines) {
+      const line = rawLine.trim();
+      if (!line) {
+        continue;
+      }
+      if (/^guidance:?$/i.test(line)) {
+        inGuidance = true;
+        continue;
+      }
+      const option = parseQuestionnaireOption(line);
+      if (option && !inGuidance) {
+        options.push(option);
+        continue;
+      }
+      if (inGuidance) {
+        guidance.push(line.replace(/^[•*-]\s*/, "").trim());
+      }
+    }
+    if (options.length === 0) {
+      continue;
+    }
+    questions.push({
+      index: questions.length,
+      id: `q${questions.length + 1}`,
+      prompt,
+      options,
+      guidance,
+    });
+  }
+  if (questions.length < 2) {
+    return undefined;
+  }
+  return {
+    questions,
+    currentIndex: 0,
+    answers: questions.map(() => null),
+    responseMode: "compact",
+  };
+}
+
+export function formatPendingQuestionnairePrompt(
+  questionnaire: PendingQuestionnaireState,
+): string {
+  const question = questionnaire.questions[questionnaire.currentIndex];
+  if (!question) {
+    return "Codex needs input.";
+  }
+  const heading =
+    question.header && question.prompt && question.header !== question.prompt
+      ? `${question.header}: ${question.prompt}`
+      : (question.header ?? question.prompt);
+  const lines = [
+    `Codex plan question ${questionnaire.currentIndex + 1} of ${questionnaire.questions.length}`,
+    "",
+    heading,
+    "",
+  ];
+  for (const option of question.options) {
+    lines.push(`${option.key}. ${option.label}`);
+    if (option.description) {
+      lines.push(`   ${option.description}`);
+    }
+  }
+  if (question.guidance.length > 0) {
+    lines.push("", "Guidance:");
+    for (const item of question.guidance) {
+      lines.push(`- ${item}`);
+    }
+  }
+  if (question.allowFreeform) {
+    lines.push("", "Other: You can reply with free text.");
+  }
+  const currentAnswer = questionnaire.answers[questionnaire.currentIndex];
+  if (currentAnswer) {
+    lines.push(
+      "",
+      `Current answer: ${
+        currentAnswer.kind === "option"
+          ? `${currentAnswer.optionKey}. ${currentAnswer.optionLabel}`
+          : currentAnswer.text
+      }`,
+    );
+  } else if (questionnaire.awaitingFreeform) {
+    lines.push("", "Current answer: waiting for your free-form reply");
+  }
+  return lines.join("\n");
+}
+
+export function renderPendingQuestionnaireAnswer(answer: PendingQuestionnaireAnswer | null): string {
+  if (!answer) {
+    return "";
+  }
+  return answer.kind === "option" ? answer.optionLabel.trim() : answer.text.trim();
+}
+
+export function buildPendingQuestionnaireResponse(
+  questionnaire: PendingQuestionnaireState,
+): { answers: Record<string, { answers: string[] }> } | string {
+  if (questionnaire.responseMode === "compact") {
+    return questionnaire.questions
+      .map((question, index) => {
+        const answer = questionnaire.answers[index];
+        if (!answer) {
+          return "";
+        }
+        return answer.kind === "option"
+          ? `${question.index + 1}${answer.optionKey}`
+          : `${question.index + 1}: ${answer.text.trim()}`;
+      })
+      .filter(Boolean)
+      .join(" ");
+  }
+  return {
+    answers: Object.fromEntries(
+      questionnaire.questions.map((question, index) => {
+        const answer = questionnaire.answers[index];
+        const rendered = renderPendingQuestionnaireAnswer(answer);
+        return [question.id, { answers: rendered ? [rendered] : [] }];
+      }),
+    ),
+  };
+}
+
+export function questionnaireIsComplete(questionnaire: PendingQuestionnaireState): boolean {
+  return questionnaire.answers.every(
+    (answer) =>
+      answer != null &&
+      (answer.kind === "option" || (answer.kind === "text" && answer.text.trim().length > 0)),
+  );
+}
+
+export function questionnaireCurrentQuestionHasAnswer(
+  questionnaire: PendingQuestionnaireState,
+): boolean {
+  const answer = questionnaire.answers[questionnaire.currentIndex];
+  return (
+    answer != null &&
+    (answer.kind === "option" || (answer.kind === "text" && answer.text.trim().length > 0))
+  );
+}
+
+function collectText(value: unknown): string[] {
+  if (typeof value === "string") {
+    const trimmed = value.trim();
+    return trimmed ? [trimmed] : [];
+  }
+  if (Array.isArray(value)) {
+    return value.flatMap((entry) => collectText(entry));
+  }
+  const record = asRecord(value);
+  if (!record) {
+    return [];
+  }
+  const directKeys = [
+    "text",
+    "delta",
+    "message",
+    "prompt",
+    "question",
+    "summary",
+    "title",
+    "content",
+    "description",
+    "reason",
+  ];
+  const out = directKeys.flatMap((key) => collectText(record[key]));
+  for (const nestedKey of ["item", "turn", "thread", "response", "result", "data", "questions"]) {
+    out.push(...collectText(record[nestedKey]));
+  }
+  return out;
+}
+
+function buildMarkdownCodeBlock(text: string, language = ""): string {
+  const normalized = text.replace(/\r\n/g, "\n").trim();
+  if (!normalized) {
+    return "";
+  }
+  const fenceMatches = [...normalized.matchAll(/`{3,}/g)];
+  const longestFence = fenceMatches.reduce((max, match) => Math.max(max, match[0].length), 2);
+  const fence = "`".repeat(longestFence + 1);
+  const languageTag = language.trim();
+  return `${fence}${languageTag}\n${normalized}\n${fence}`;
+}
+
+export function buildPendingPromptText(params: {
+  method: string;
+  requestId: string;
+  options: string[];
+  actions: PendingInputAction[];
+  expiresAt: number;
+  requestParams: unknown;
+}): string {
+  const methodLower = params.method.trim().toLowerCase();
+  const lines = [
+    /requestapproval/i.test(params.method)
+      ? isFileChangeApprovalMethod(methodLower)
+        ? `Codex file change approval requested (${params.requestId})`
+        : isCommandApprovalMethod(methodLower)
+          ? `Codex command approval requested (${params.requestId})`
+          : `Codex approval requested (${params.requestId})`
+      : `Codex input requested (${params.requestId})`,
+  ];
+  const requestText = dedupeJoinedText(collectText(params.requestParams));
+  if (requestText) {
+    lines.push(
+      truncateWithNotice(
+        requestText,
+        MAX_PENDING_REQUEST_TEXT_CHARS,
+        "[Request details truncated. Use steer text if you want to redirect Codex.]",
+      ),
+    );
+  }
+  const command =
+    findFirstStringByKeys(params.requestParams, [
+      "command",
+      "cmd",
+      "displayCommand",
+      "rawCommand",
+      "shellCommand",
+    ]) ?? "";
+  if (command) {
+    lines.push("", "Command:", "", buildMarkdownCodeBlock(command, "sh"));
+  }
+  const grantRoot = findFirstStringByKeys(params.requestParams, ["grantRoot", "grant_root"]);
+  if (grantRoot) {
+    lines.push("", `Requested writable root: \`${grantRoot}\``);
+  }
+  if (isFileChangeApprovalMethod(methodLower)) {
+    const filePaths = extractFilePaths(params.requestParams);
+    if (filePaths.length > 0) {
+      lines.push("", "Files:");
+      for (const filePath of filePaths.slice(0, 12)) {
+        lines.push(`- \`${filePath}\``);
+      }
+      if (filePaths.length > 12) {
+        lines.push(`- ...and ${filePaths.length - 12} more`);
+      }
+    }
+  }
+  if (params.actions.length > 0) {
+    lines.push("", "Choices:");
+    params.actions
+      .filter((action) => action.kind !== "steer")
+      .forEach((action, index) => {
+        lines.push(`${index + 1}. ${action.label}`);
+      });
+    lines.push("", 'Reply with "1", "2", "option 1", etc., or use a button.');
+    if (/requestapproval/i.test(params.method)) {
+      lines.push("You can also reply with free text to tell Codex what to do instead.");
+    }
+  } else if (params.options.length > 0) {
+    lines.push("", "Options:");
+    params.options.forEach((option, index) => {
+      lines.push(`${index + 1}. ${option}`);
+    });
+  } else {
+    lines.push("Reply with a free-form response.");
+  }
+  const seconds = Math.max(1, Math.round((params.expiresAt - Date.now()) / 1_000));
+  lines.push(`Expires in: ${seconds}s`);
+  return truncateWithNotice(
+    lines.join("\n"),
+    MAX_PENDING_PROMPT_TEXT_CHARS,
+    "[Prompt truncated for chat delivery. Use the buttons or reply with steer text.]",
+  );
+}
+
+export function createPendingInputState(params: {
+  method: string;
+  requestId: string;
+  requestParams: unknown;
+  options: string[];
+  expiresAt: number;
+}): PendingInputState {
+  const actions = buildPendingUserInputActions({
+    method: params.method,
+    requestParams: params.requestParams,
+    options: params.options,
+  });
+  const questionnaire =
+    extractQuestionnaireFromStructuredRequest(params.requestParams) ??
+    parsePendingQuestionnaire(dedupeJoinedText(collectText(params.requestParams)));
+  return {
+    requestId: params.requestId,
+    options: params.options,
+    actions,
+    expiresAt: params.expiresAt,
+    questionnaire,
+    promptText: buildPendingPromptText({
+      method: params.method,
+      requestId: params.requestId,
+      options: params.options,
+      actions,
+      expiresAt: params.expiresAt,
+      requestParams: params.requestParams,
+    }),
+    method: params.method,
+  };
+}
+
+export function parseCodexUserInput(
+  text: string,
+  optionsCount: number,
+): { kind: "option"; index: number } | { kind: "text"; text: string } {
+  const normalized = text.trim();
+  if (!normalized) {
+    return { kind: "text", text: "" };
+  }
+  const match = normalized.match(/^\s*(?:option\s*)?([1-9]\d*)\s*$/i);
+  if (!match) {
+    return { kind: "text", text: normalized };
+  }
+  const oneBased = Number.parseInt(match[1] ?? "", 10);
+  if (Number.isInteger(oneBased) && oneBased >= 1 && oneBased <= optionsCount) {
+    return { kind: "option", index: oneBased - 1 };
+  }
+  return { kind: "text", text: normalized };
+}
+
+export function requestToken(requestId: string): string {
+  return crypto.createHash("sha1").update(requestId).digest("base64url").slice(0, 10);
+}