roundabout

import assert from "node:assert/strict";

import { spawnSync } from "node:child_process";

import { mkdtempSync, readFileSync, rmSync, writeFileSync } from "node:fs";

import { tmpdir } from "node:os";

import { join } from "node:path";

import { after, beforeEach, test } from "node:test";

import roundabout from "../plugin/omp/index.js";

const temporary = mkdtempSync(join(tmpdir(), "roundabout-omp-"));

const captured = join(temporary, "input.json");

const mockCli = process.env.ROUNDABOUT_TEST_CLI;

const handlers = new Map();

const notifications = [];

const context = {

  cwd: temporary,

  hasUI: true,

  agent: { kind: "main" },

  sessionManager: { getSessionId: () => "omp-session" },

  ui: { notify: (...args) => notifications.push(args) },

};

const bash = { toolName: "bash", input: { command: "cargo build", env: { KEEP: "yes" }, async: true } };

roundabout({ on: (name, handler) => handlers.set(name, handler) });

beforeEach(() => {

  process.env.ROUNDABOUT_CLI = mockCli;

  process.env.ROUNDABOUT_TEST_INPUT = captured;

  delete process.env.ROUNDABOUT_TEST_OUTPUT;

  delete process.env.ROUNDABOUT_TEST_EXIT;

  notifications.length = 0;

  rmSync(captured, { force: true });

});

after(() => rmSync(temporary, { recursive: true, force: true }));

function output(value) {

  process.env.ROUNDABOUT_TEST_OUTPUT = JSON.stringify(value);

}

function input() {

  return JSON.parse(readFileSync(captured, "utf8"));

}

test("maps build guards and preserves wrapped command arguments", async () => {

  output({ hookSpecificOutput: { permissionDecision: "deny", permissionDecisionReason: "use roundabout run" } });

  assert.deepEqual(await handlers.get("tool_call")(bash, context), { block: true, reason: "use roundabout run" });

  assert.equal(input().event, "omp-pre-tool-use");

  assert.equal(input().input.tool_name, "Bash");

  output({ hookSpecificOutput: { updatedInput: { command: "roundabout run -s m -- cargo build" } } });

  const result = await handlers.get("tool_call")({ ...bash, input: { ...bash.input, cwd: "/project" } }, context);

  assert.equal(input().input.cwd, "/project");

  assert.equal(result.input.command, "roundabout run -s m -- cargo build");

  assert.equal(result.input.async, true);

  assert.deepEqual(result.input.env, { KEEP: "yes", ROUNDABOUT_SESSION_ID: "omp-session" });

});

test("fails open for malformed output, nonzero exits and missing CLI", async () => {

  process.env.ROUNDABOUT_TEST_OUTPUT = "not JSON";

  assert.equal((await handlers.get("tool_call")(bash, context)).input.command, "cargo build");

  output({ hookSpecificOutput: { permissionDecision: "deny" } });

  process.env.ROUNDABOUT_TEST_EXIT = "1";

  assert.equal((await handlers.get("tool_call")(bash, context)).block, undefined);

  process.env.ROUNDABOUT_CLI = join(temporary, "missing-roundabout");

  assert.equal((await handlers.get("tool_call")(bash, context)).block, undefined);

});

test("maps artifact policies and bounds advisory continuations", async () => {

  output({ decision: "block", reason: "clean artifacts" });

  assert.deepEqual(await handlers.get("session_stop")({ stop_hook_active: true }, context), {

    decision: "block", reason: "clean artifacts",

  });

  output({ hookSpecificOutput: { additionalContext: "clean artifacts" } });

  assert.deepEqual(await handlers.get("session_stop")({ stop_hook_active: false }, context), {

    continue: true, additionalContext: "clean artifacts",

  });

  assert.equal(await handlers.get("session_stop")({ stop_hook_active: true }, context), undefined);

  output({ systemMessage: "over cap" });

  await handlers.get("session_stop")({ stop_hook_active: false }, context);

  assert.deepEqual(notifications, [["over cap", "warning"]]);

});

test("the CLI tracks OMP sessions ahead of inherited agent identities", () => {

  const roundabout = process.env.ROUNDABOUT_TEST_RABT;

  const config = join(temporary, "config.toml");

  writeFileSync(config, '[queue]\nlinger = "1s"\n');

  const env = {

    ...process.env,

    ROUNDABOUT_CONFIG: config,

    ROUNDABOUT_STATE_DIR: join(temporary, "state"),

    ROUNDABOUT_RUNTIME_DIR: join(temporary, "run"),

    ROUNDABOUT_SESSION_ID: "omp-session",

    CLAUDE_CODE_SESSION_ID: "inherited-claude",

    CODEX_THREAD_ID: "inherited-codex",

  };

  function run(args, payload) {

    const result = spawnSync(roundabout, args, { env, input: payload, encoding: "utf8", timeout: 10000 });

    assert.equal(result.status, 0, result.stderr);

    return result.stdout;

  }

  run(["expect", "-s", "s"]);

  assert.equal(JSON.parse(run(["status", "--json"])).intents[0].session, "omp-session");

  run(["hook", "omp-session-end"], JSON.stringify({ session_id: "omp-session" }));

  assert.equal(JSON.parse(run(["status", "--json"])).intents.length, 0);

  run(["expect", "--session", "explicit", "-s", "s"]);

  assert.equal(JSON.parse(run(["status", "--json"])).intents[0].session, "explicit");

  run(["expect", "--session", "explicit", "--done"]);

});