roundabout

import { spawn } from "node:child_process";

import { existsSync } from "node:fs";

import { fileURLToPath } from "node:url";

const packagedCli = fileURLToPath(new URL("./bin/rabt", import.meta.url));

function cli() {

  return process.env.ROUNDABOUT_CLI || (existsSync(packagedCli) ? packagedCli : "rabt");

}

function invoke(event, context, input = {}) {

  return new Promise((resolve) => {

    const child = spawn(cli(), ["hook", event], { stdio: ["pipe", "pipe", "ignore"] });

    let output = "";

    const timeout = setTimeout(() => child.kill("SIGKILL"), event === "omp-session-end" ? 2000 : 10000);

    timeout.unref();

    child.on("error", () => {});

    child.stdout.on("data", (chunk) => {

      output += chunk;

    });

    child.on("close", (code) => {

      clearTimeout(timeout);

      if (code !== 0 || !output) return resolve(undefined);

      try {

        resolve(JSON.parse(output));

      } catch {

        resolve(undefined);

      }

    });

    child.stdin.on("error", () => {});

    child.stdin.end(JSON.stringify({

      session_id: context.sessionManager.getSessionId(),

      cwd: context.cwd,

      ...input,

    }));

  });

}

export default function roundabout(pi) {

  pi.on("tool_call", async (event, context) => {

    if (event.toolName !== "bash") return;

    const output = await invoke("omp-pre-tool-use", context, {

      cwd: event.input.cwd || context.cwd,

      tool_name: "Bash",

      tool_input: event.input,

    });

    const verdict = output?.hookSpecificOutput;

    if (verdict?.permissionDecision === "deny") {

      return { block: true, reason: verdict.permissionDecisionReason };

    }

    return {

      input: {

        ...event.input,

        ...verdict?.updatedInput,

        env: {

          ...event.input.env,

          ROUNDABOUT_SESSION_ID: context.sessionManager.getSessionId(),

        },

      },

    };

  });

  pi.on("tool_result", async (event, context) => {

    if (event.isError) return;

    const output = await invoke("omp-post-tool-use", context);

    const reminder = output?.hookSpecificOutput?.additionalContext;

    if (reminder) {

      return { content: [...event.content, { type: "text", text: reminder }] };

    }

  });

  pi.on("before_agent_start", async (_event, context) => {

    const output = await invoke("omp-prompt-submit", context);

    const reminder = output?.hookSpecificOutput?.additionalContext;

    if (reminder) {

      return {

        message: {

          customType: "roundabout",

          content: reminder,

          display: true,

          attribution: "agent",

        },

      };

    }

  });

  pi.on("session_stop", async (event, context) => {

    const output = await invoke("omp-stop", context);

    if (output?.decision === "block") {

      return { decision: "block", reason: output.reason };

    }

    if (event.stop_hook_active) return;

    const reminder = output?.hookSpecificOutput?.additionalContext;

    if (reminder) return { continue: true, additionalContext: reminder };

    if (output?.systemMessage && context.hasUI) {

      context.ui.notify(output.systemMessage, "warning");

    }

  });

  pi.on("agent_end", async (_event, context) => {

    if (context.agent.kind !== "sub") return;

    const output = await invoke("omp-subagent-stop", context);

    const reminder = output?.reason || output?.hookSpecificOutput?.additionalContext || output?.systemMessage;

    if (reminder && context.hasUI) context.ui.notify(reminder, "warning");

  });

  pi.on("session_before_switch", async (_event, context) => {

    await invoke("omp-session-end", context);

  });

  pi.on("session_shutdown", async (_event, context) => {

    await invoke("omp-session-end", context);

  });

}