dores-codex 4.0.0

package/lib/hook-runner.js

@@ -0,0 +1,101 @@
+#!/usr/bin/env node
+
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import process from "node:process";
+import { spawn } from "node:child_process";
+
+const hookType = process.argv[2];
+const projectPath = process.argv[3];
+
+if (!hookType || !projectPath) {
+  console.error("Usage: hook-runner.js <hook-type> <project-path>");
+  process.exit(1);
+}
+
+function normalizePath(filePath) {
+  if (os.platform() !== "win32") {
+    return filePath;
+  }
+
+  let normalized = filePath.replace(/\//g, "\\");
+
+  if (normalized.match(/^\\[a-z]\\/) || normalized.match(/^\\[a-z]\\/i)) {
+    normalized =
+      normalized.charAt(1).toUpperCase() +
+      ":" +
+      normalized.substring(2).replace(/\//g, "\\");
+  }
+
+  if (!normalized.match(/^[A-Z]:\\/i)) {
+    normalized = path.resolve(normalized);
+  }
+
+  return normalized;
+}
+
+async function readStdin() {
+  if (process.stdin.isTTY) {
+    return "";
+  }
+
+  let input = "";
+  process.stdin.setEncoding("utf8");
+  for await (const chunk of process.stdin) {
+    input += chunk;
+  }
+  return input;
+}
+
+const hookMap = {
+  SessionStart: "startup-hook.js",
+  UserPromptSubmit: "user-prompt-submit-hook.js",
+  PreToolUse: "pre-tool-use-hook.js",
+  PostToolUse: "post-tool-use-hook.js",
+  Stop: "stop-hook.js"
+};
+
+const hookFile = hookMap[hookType];
+if (!hookFile) {
+  console.error(`Unknown hook type: ${hookType}`);
+  process.exit(1);
+}
+
+const normalizedProjectPath = normalizePath(projectPath);
+const hookPath = path.join(normalizedProjectPath, "lib", hookFile);
+
+if (process.env.DEBUG_HOOKS) {
+  console.log(`[DEBUG] Hook type: ${hookType}`);
+  console.log(`[DEBUG] Project path (raw): ${projectPath}`);
+  console.log(`[DEBUG] Project path (normalized): ${normalizedProjectPath}`);
+  console.log(`[DEBUG] Hook path: ${hookPath}`);
+  console.log(`[DEBUG] Platform: ${os.platform()}`);
+}
+
+if (!fs.existsSync(hookPath)) {
+  console.error(`Hook file not found: ${hookPath}`);
+  console.error(`Current directory: ${process.cwd()}`);
+  console.error(`Platform: ${os.platform()}`);
+  process.exit(1);
+}
+
+const stdinPayload = await readStdin();
+
+const child = spawn(process.execPath, [hookPath], {
+  stdio: ["pipe", "inherit", "inherit"],
+  env: { ...process.env, PROJECT_PATH: normalizedProjectPath },
+  cwd: normalizedProjectPath
+});
+
+child.on("error", (error) => {
+  console.error(`Failed to run hook: ${error.message}`);
+  process.exit(1);
+});
+
+child.stdin.on("error", () => {});
+child.stdin.end(stdinPayload);
+
+child.on("exit", (code) => {
+  process.exit(code ?? 0);
+});

package/lib/hook-shared.js

@@ -0,0 +1,362 @@
+#!/usr/bin/env node
+
+import fs from "node:fs";
+import path from "node:path";
+import process from "node:process";
+import {
+  DORES_CLIENT_UNAVAILABLE_MESSAGE,
+  formatDoresClientErrorMessage,
+  normalizeDoresClientConnectionError
+} from "./dores-client.js";
+import { buildClientEventMessage } from "./client-event.js";
+
+const DEFAULT_WS_URL = "ws://127.0.0.1:8765";
+const DEFAULT_EVENT_IDE = "codex";
+const DEFAULT_CLOSE_DELAY_MS = 500;
+const DEFAULT_TIMEOUT_MS = 1500;
+
+function shouldWriteDirectHookLog() {
+  return (process.env.CODEX_PLUGIN_HOOK_DIRECT_LOG ?? "0").trim() === "1";
+}
+
+function resolveHookLogFile() {
+  const explicit = (process.env.CODEX_PLUGIN_HOOK_LOG_FILE ?? "").trim();
+  if (explicit) {
+    return explicit;
+  }
+
+  const projectPath = (process.env.PROJECT_PATH ?? "").trim();
+  if (!projectPath) {
+    return null;
+  }
+
+  return path.join(projectPath, "runtime", "codex-plugin.log");
+}
+
+export function logHook(label, message) {
+  const line = `[${label}] ${message}\n`;
+  process.stderr.write(line);
+
+  if (!shouldWriteDirectHookLog()) {
+    return;
+  }
+
+  const logFile = resolveHookLogFile();
+  if (!logFile) {
+    return;
+  }
+
+  try {
+    fs.mkdirSync(path.dirname(logFile), { recursive: true });
+    fs.appendFileSync(logFile, `${new Date().toISOString()} ${line}`, "utf8");
+  } catch {
+    // Keep hook execution non-blocking if direct log writes fail.
+  }
+}
+
+export async function readHookInput(label) {
+  if (process.stdin.isTTY) {
+    return null;
+  }
+
+  let inputData = "";
+  process.stdin.setEncoding("utf8");
+
+  for await (const chunk of process.stdin) {
+    inputData += chunk;
+  }
+
+  if (!inputData.trim()) {
+    return null;
+  }
+
+  try {
+    const parsed = JSON.parse(inputData);
+    logHook(label, `Received hook data: ${JSON.stringify(parsed)}`);
+    return parsed;
+  } catch (error) {
+    logHook(label, `Failed to parse input: ${error.message}`);
+    return {
+      raw_text: inputData
+    };
+  }
+}
+
+export function resolveHookWsUrl() {
+  const value = (
+    process.env.CODEX_PLUGIN_APP_WS_URL ??
+    process.env.CODEX_PLUGIN_LIVE2D_WS_URL ??
+    DEFAULT_WS_URL
+  ).trim();
+  return value || DEFAULT_WS_URL;
+}
+
+export function resolveHookEventIde() {
+  const value = (
+    process.env.CODEX_PLUGIN_HOOK_EVENT_IDE ??
+    DEFAULT_EVENT_IDE
+  ).trim().toLowerCase();
+  return value || DEFAULT_EVENT_IDE;
+}
+
+export function parseHookJson(value) {
+  if (value == null) {
+    return null;
+  }
+
+  if (typeof value !== "string") {
+    return value;
+  }
+
+  const trimmed = value.trim();
+  if (!trimmed) {
+    return null;
+  }
+
+  try {
+    return JSON.parse(trimmed);
+  } catch {
+    return value;
+  }
+}
+
+function readNestedValue(value, pathParts) {
+  let current = value;
+  for (const key of pathParts) {
+    if (!current || typeof current !== "object") {
+      return undefined;
+    }
+    current = current[key];
+  }
+  return current;
+}
+
+function coerceFiniteNumber(value) {
+  if (typeof value === "number" && Number.isFinite(value)) {
+    return value;
+  }
+
+  if (typeof value === "string" && /^-?\d+$/.test(value.trim())) {
+    return Number.parseInt(value.trim(), 10);
+  }
+
+  return null;
+}
+
+export function resolveHookEventName(hookData = null, fallbackEventName = "") {
+  return String(
+    hookData?.hook_event_name ?? hookData?.event ?? fallbackEventName ?? ""
+  ).trim();
+}
+
+export function normalizeCommand(value) {
+  if (Array.isArray(value)) {
+    return value.map((part) => String(part)).join(" ").trim() || null;
+  }
+
+  if (typeof value === "string") {
+    return value.trim() || null;
+  }
+
+  return value == null ? null : String(value);
+}
+
+export function extractCommand(hookData = null) {
+  return normalizeCommand(hookData?.tool_input?.command ?? hookData?.command ?? null);
+}
+
+export function parseToolResponse(hookData = null) {
+  return parseHookJson(hookData?.tool_response ?? null);
+}
+
+export function extractExitCode(toolResponse) {
+  const parsed = parseHookJson(toolResponse);
+  const candidatePaths = [
+    ["exit_code"],
+    ["exitCode"],
+    ["code"],
+    ["status"],
+    ["metadata", "exit_code"],
+    ["metadata", "exitCode"],
+    ["metadata", "code"]
+  ];
+
+  for (const pathParts of candidatePaths) {
+    const candidate = coerceFiniteNumber(readNestedValue(parsed, pathParts));
+    if (candidate != null) {
+      return candidate;
+    }
+  }
+
+  if (typeof parsed?.ok === "boolean") {
+    return parsed.ok ? 0 : 1;
+  }
+
+  if (typeof parsed?.success === "boolean") {
+    return parsed.success ? 0 : 1;
+  }
+
+  return null;
+}
+
+export function summarizePostToolUse(hookData = null) {
+  const toolResponse = parseToolResponse(hookData);
+  const exitCode = extractExitCode(toolResponse);
+  const command = extractCommand(hookData);
+  const ok = exitCode == null ? null : exitCode === 0;
+
+  return {
+    command,
+    exitCode,
+    ok,
+    status:
+      ok === false ? "failed" : ok === true ? "succeeded" : "completed",
+    toolResponse
+  };
+}
+
+export function buildHookPayload(hookData = null, extraPayload = {}) {
+  const payload = {
+    cwd: hookData?.cwd ?? process.cwd(),
+    model: hookData?.model ?? null,
+    raw: hookData ?? null,
+    session_id: hookData?.session_id ?? null,
+    source: extraPayload.source ?? "codex-native-hook",
+    timestamp: extraPayload.timestamp ?? new Date().toISOString(),
+    transcript_path: hookData?.transcript_path ?? null,
+    turn_id: hookData?.turn_id ?? null,
+    ...extraPayload
+  };
+
+  const hookEventName = resolveHookEventName(
+    {
+      ...hookData,
+      ...payload
+    },
+    extraPayload.hook_event_name
+  );
+
+  return {
+    ...payload,
+    event: hookEventName || null,
+    hook_event_name: hookEventName || null
+  };
+}
+
+export function buildHookMessage(hookEventName, payload) {
+  return buildClientEventMessage(hookEventName, payload, {
+    eventIde: resolveHookEventIde()
+  });
+}
+
+async function sendHookSocketMessage(
+  label,
+  message,
+  { errorHint = null, errorExitCode = 0 } = {}
+) {
+  const wsUrl = resolveHookWsUrl();
+  const timeoutMs = Number.parseInt(
+    process.env.CODEX_PLUGIN_HOOK_WS_TIMEOUT ?? String(DEFAULT_TIMEOUT_MS),
+    10
+  );
+
+  if (typeof WebSocket !== "function") {
+    logHook(label, "WebSocket runtime unavailable in this Node.js version.");
+    return errorExitCode;
+  }
+
+  return new Promise((resolve) => {
+    let settled = false;
+    let opened = false;
+    const socket = new WebSocket(wsUrl);
+
+    const reportUnavailable = (error) => {
+      if (settled) {
+        return;
+      }
+
+      const normalized = normalizeDoresClientConnectionError(error, {
+        url: wsUrl
+      });
+      logHook(
+        label,
+        formatDoresClientErrorMessage(normalized, {
+          fallbackMessage: DORES_CLIENT_UNAVAILABLE_MESSAGE
+        })
+      );
+      if (errorHint && normalized === error) {
+        logHook(label, errorHint);
+      }
+      finish(errorExitCode);
+    };
+
+    const finish = (code = 0) => {
+      if (settled) {
+        return;
+      }
+
+      settled = true;
+      clearTimeout(timeoutId);
+      resolve(code);
+    };
+
+    const timeoutId = setTimeout(() => {
+      try {
+        socket.close();
+      } catch {
+        // Ignore close races.
+      }
+      reportUnavailable(new Error(`Timed out while connecting to ${wsUrl}.`));
+    }, Number.isFinite(timeoutMs) && timeoutMs > 0 ? timeoutMs : DEFAULT_TIMEOUT_MS);
+
+    socket.addEventListener("open", () => {
+      opened = true;
+      try {
+        socket.send(JSON.stringify(message));
+        logHook(label, `Sent hook websocket message: ${JSON.stringify(message)}`);
+      } catch (error) {
+        logHook(label, `Failed to send WebSocket message: ${error.message}`);
+        finish(errorExitCode);
+        return;
+      }
+
+      setTimeout(() => {
+        try {
+          socket.close();
+        } catch {
+          // Ignore close races.
+        }
+        finish(0);
+      }, DEFAULT_CLOSE_DELAY_MS);
+    });
+
+    socket.addEventListener("error", (event) => {
+      reportUnavailable(
+        event.error ?? new Error(`Failed to connect to dores client WebSocket at ${wsUrl}.`)
+      );
+    });
+
+    socket.addEventListener("close", () => {
+      if (!opened) {
+        reportUnavailable(
+          new Error(`WebSocket socket closed before connecting to ${wsUrl}.`)
+        );
+        return;
+      }
+      finish(0);
+    });
+  });
+}
+
+export async function dispatchHookEvent(
+  label,
+  hookData = null,
+  { errorHint = null, errorExitCode = 0, extraPayload = {} } = {}
+) {
+  const payload = buildHookPayload(hookData, extraPayload);
+
+  return sendHookSocketMessage(label, buildHookMessage(payload.hook_event_name, payload), {
+    errorExitCode,
+    errorHint
+  });
+}

package/lib/post-tool-use-hook.js

@@ -0,0 +1,27 @@
+#!/usr/bin/env node
+
+import {
+  buildHookPayload,
+  dispatchHookEvent,
+  readHookInput,
+  summarizePostToolUse
+} from "./hook-shared.js";
+
+const label = "post-tool-use-hook";
+const hookData = await readHookInput(label);
+const summary = summarizePostToolUse(hookData);
+const payload = buildHookPayload(hookData, {
+  command: summary.command,
+  exit_code: summary.exitCode,
+  ok: summary.ok,
+  status: summary.status,
+  tool_name: hookData?.tool_name ?? null,
+  tool_response: summary.toolResponse,
+  tool_use_id: hookData?.tool_use_id ?? null
+});
+
+process.exit(
+  await dispatchHookEvent(label, hookData, {
+    extraPayload: payload
+  })
+);

package/lib/pre-tool-use-hook.js

@@ -0,0 +1,23 @@
+#!/usr/bin/env node
+
+import {
+  buildHookPayload,
+  dispatchHookEvent,
+  extractCommand,
+  readHookInput
+} from "./hook-shared.js";
+
+const label = "pre-tool-use-hook";
+const hookData = await readHookInput(label);
+const payload = buildHookPayload(hookData, {
+  command: extractCommand(hookData),
+  status: "in_progress",
+  tool_name: hookData?.tool_name ?? null,
+  tool_use_id: hookData?.tool_use_id ?? null
+});
+
+process.exit(
+  await dispatchHookEvent(label, hookData, {
+    extraPayload: payload
+  })
+);

package/lib/setup-hooks.js

@@ -0,0 +1,193 @@
+#!/usr/bin/env node
+
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+
+const MANAGED_STATUS_PREFIX = "dores-codex:";
+const PACKAGE_ROOT = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "..");
+const DEFAULT_CODEX_HOME = path.join(os.homedir(), ".codex");
+const HOOK_EVENTS = [
+  ["SessionStart", "startup|resume"],
+  ["UserPromptSubmit", null],
+  ["PreToolUse", "Bash"],
+  ["PostToolUse", "Bash"],
+  ["Stop", null]
+];
+
+function resolveCodexHome() {
+  const explicit = (process.env.CODEX_PLUGIN_CODEX_HOME ?? "").trim();
+  return path.resolve(explicit || DEFAULT_CODEX_HOME);
+}
+
+function resolveConfigFile(codexHome) {
+  const explicit = (process.env.CODEX_PLUGIN_CODEX_CONFIG_FILE ?? "").trim();
+  return path.resolve(explicit || path.join(codexHome, "config.toml"));
+}
+
+function resolveHooksFile(codexHome) {
+  return path.join(codexHome, "hooks.json");
+}
+
+function ensureParentDirectory(filePath) {
+  fs.mkdirSync(path.dirname(filePath), { recursive: true });
+}
+
+function readJsonFile(filePath) {
+  if (!fs.existsSync(filePath)) {
+    return null;
+  }
+
+  const text = fs.readFileSync(filePath, "utf8");
+  if (!text.trim()) {
+    return null;
+  }
+
+  return JSON.parse(text);
+}
+
+function writeJsonFile(filePath, value) {
+  ensureParentDirectory(filePath);
+  fs.writeFileSync(filePath, `${JSON.stringify(value, null, 2)}\n`, "utf8");
+}
+
+function buildHookCommand(eventName) {
+  const dispatchPath = path.join(PACKAGE_ROOT, ".codex", "bin", "dores-hook-dispatch");
+  return `bash -lc 'exec "$1" "$2" "$3"' _ ${JSON.stringify(dispatchPath)} ${JSON.stringify(eventName)} ${JSON.stringify(PACKAGE_ROOT)}`;
+}
+
+function buildManagedGroup(eventName, matcher) {
+  const group = {
+    hooks: [
+      {
+        type: "command",
+        command: buildHookCommand(eventName),
+        statusMessage: `${MANAGED_STATUS_PREFIX} ${eventName}`
+      }
+    ]
+  };
+
+  if (matcher) {
+    group.matcher = matcher;
+  }
+
+  return group;
+}
+
+function isManagedGroup(group) {
+  return Array.isArray(group?.hooks) && group.hooks.some((hook) => {
+    const statusMessage = typeof hook?.statusMessage === "string" ? hook.statusMessage : "";
+    return statusMessage.startsWith(MANAGED_STATUS_PREFIX);
+  });
+}
+
+function loadHooksDocument(hooksFile) {
+  const existing = readJsonFile(hooksFile);
+  if (existing == null) {
+    return { hooks: {} };
+  }
+
+  if (!existing || typeof existing !== "object" || Array.isArray(existing)) {
+    throw new Error(`${hooksFile} must contain a JSON object.`);
+  }
+
+  if (existing.hooks == null) {
+    existing.hooks = {};
+  }
+
+  if (!existing.hooks || typeof existing.hooks !== "object" || Array.isArray(existing.hooks)) {
+    throw new Error(`${hooksFile} must contain a top-level "hooks" object.`);
+  }
+
+  return existing;
+}
+
+function updateHooksDocument(hooksDoc) {
+  for (const [eventName, matcher] of HOOK_EVENTS) {
+    const currentGroups = Array.isArray(hooksDoc.hooks[eventName])
+      ? hooksDoc.hooks[eventName]
+      : [];
+    const preservedGroups = currentGroups.filter((group) => !isManagedGroup(group));
+    hooksDoc.hooks[eventName] = [...preservedGroups, buildManagedGroup(eventName, matcher)];
+  }
+
+  return hooksDoc;
+}
+
+function ensureCodexHooksEnabled(configFile) {
+  const original = fs.existsSync(configFile)
+    ? fs.readFileSync(configFile, "utf8")
+    : "";
+
+  const newline = original.includes("\r\n") ? "\r\n" : "\n";
+  const lines = original ? original.split(/\r?\n/) : [];
+
+  let sectionStart = -1;
+  let sectionEnd = lines.length;
+
+  for (let index = 0; index < lines.length; index += 1) {
+    if (/^\s*\[features\]\s*$/.test(lines[index])) {
+      sectionStart = index;
+      sectionEnd = lines.length;
+      for (let inner = index + 1; inner < lines.length; inner += 1) {
+        if (/^\s*\[[^\]]+\]\s*$/.test(lines[inner])) {
+          sectionEnd = inner;
+          break;
+        }
+      }
+      break;
+    }
+  }
+
+  if (sectionStart === -1) {
+    const nextContent = original.trim()
+      ? `${original.replace(/\s*$/, "")}${newline}${newline}[features]${newline}codex_hooks = true${newline}`
+      : `[features]${newline}codex_hooks = true${newline}`;
+    ensureParentDirectory(configFile);
+    fs.writeFileSync(configFile, nextContent, "utf8");
+    return true;
+  }
+
+  for (let index = sectionStart + 1; index < sectionEnd; index += 1) {
+    if (/^\s*codex_hooks\s*=/.test(lines[index])) {
+      if (/^\s*codex_hooks\s*=\s*true\s*$/.test(lines[index])) {
+        return false;
+      }
+      lines[index] = "codex_hooks = true";
+      ensureParentDirectory(configFile);
+      fs.writeFileSync(configFile, `${lines.join(newline)}${newline}`, "utf8");
+      return true;
+    }
+  }
+
+  lines.splice(sectionEnd, 0, "codex_hooks = true");
+  ensureParentDirectory(configFile);
+  fs.writeFileSync(configFile, `${lines.join(newline)}${newline}`, "utf8");
+  return true;
+}
+
+function main() {
+  const codexHome = resolveCodexHome();
+  const hooksFile = resolveHooksFile(codexHome);
+  const configFile = resolveConfigFile(codexHome);
+  const hooksDoc = updateHooksDocument(loadHooksDocument(hooksFile));
+  writeJsonFile(hooksFile, hooksDoc);
+  const configChanged = ensureCodexHooksEnabled(configFile);
+
+  console.log(`[codex-plugin-setup] package root: ${PACKAGE_ROOT}`);
+  console.log(`[codex-plugin-setup] hooks file: ${hooksFile}`);
+  console.log(`[codex-plugin-setup] config file: ${configFile}`);
+  console.log(
+    `[codex-plugin-setup] codex_hooks feature: ${configChanged ? "updated" : "already enabled"}`
+  );
+  console.log("[codex-plugin-setup] installed native Codex hooks into the global Codex config.");
+  console.log(
+    "[codex-plugin-setup] default websocket: ws://127.0.0.1:8765"
+  );
+  console.log(
+    "[codex-plugin-setup] run native `codex` in any directory to trigger these global hooks."
+  );
+}
+
+main();