Skip to content

Claude Code. Any Model. The most powerful AI coding agent now speaks every language.

6.4 KB
Raw Blame
/** Process-level coverage for caller setup inheritance in a real headless magmux pane. */

import { afterEach, beforeEach, describe, expect, test } from "bun:test";
import {
  existsSync,
  mkdirSync,
  readFileSync,
  readdirSync,
  realpathSync,
  statSync,
  writeFileSync,
} from "node:fs";
import { isAbsolute, join, sep } from "node:path";

import {
  MAGMUX,
  NO_MAGMUX_MESSAGE,
  type PaneTestEnv,
  killLeftovers,
  makePaneTestEnv,
  waitNoOrphans,
} from "../pane/test-helpers/hermetic-env.js";
import { SessionManager } from "./session-manager.js";

const T_PANE = 30_000;

type ChildProbe = { argv: string[]; env: Record<string, string>; cwd: string };
type InheritedSettings = { enabledPlugins: Record<string, boolean>; model?: string };

function waitUntil(predicate: () => boolean, timeoutMs = 10_000): Promise<void> {
  return new Promise((resolve, reject) => {
    const deadline = Date.now() + timeoutMs;
    const check = () => {
      if (predicate()) return resolve();
      if (Date.now() >= deadline) return reject(new Error("waitUntil timed out"));
      setTimeout(check, 20);
    };
    check();
  });
}

describe.skipIf(!MAGMUX)(
  `SessionCreateOptions setup inheritance (${MAGMUX ? "magmux" : NO_MAGMUX_MESSAGE})`,
  () => {
    let t: PaneTestEnv;
    let sessionsDir: string;
    let probe: string;
    let managers: SessionManager[];

    beforeEach(() => {
      t = makePaneTestEnv();
      sessionsDir = join(t.tmp, "sessions");
      probe = join(t.tmp, "probe-{session}.json");
      managers = [];
    });

    afterEach(async () => {
      for (const m of managers) await m.shutdownAll();
      const report = await waitNoOrphans({ sockRoot: t.sockRoot }, 10_000);
      killLeftovers({ sockRoot: t.sockRoot });
      t.cleanup();
      expect(report).toEqual({ processes: [], files: [] });
    });

    function makeManager(): SessionManager {
      const manager = new SessionManager({
        sessionsDir,
        hostPid: 1,
        parentEnv: { ...t.env, FAKE_PROBE_FILE: probe },
        paneTimings: { replStableMs: 200 },
      });
      managers.push(manager);
      return manager;
    }

    async function childProbe(manager: SessionManager, sessionId: string): Promise<ChildProbe> {
      const path = probe.replace("{session}", manager.getSession(sessionId).claudeSessionId);
      await waitUntil(() => existsSync(path));
      return JSON.parse(readFileSync(path, "utf-8")) as ChildProbe;
    }

    async function expectInheritedSession(claudishFlags: string[]): Promise<InheritedSettings> {
      const caller = join(t.tmp, "caller");
      const work = join(t.tmp, "work");
      mkdirSync(join(caller, ".claude"), { recursive: true });
      mkdirSync(work);
      const callerSettings = join(caller, ".claude", "settings.json");
      writeFileSync(callerSettings, '{"enabledPlugins":{"dev@magus":true}}\n');
      const before = readFileSync(callerSettings);
      const manager = makeManager();

      const sessionId = await manager.createSession({
        model: "fake-env_probe",
        cwd: work,
        setupFrom: caller,
        claudishFlags,
      });
      const child = await childProbe(manager, sessionId);
      const sessionDir = join(sessionsDir, sessionId);
      expect(manager.getDiagnostics(sessionId).sessionDir).toBe(sessionDir);
      expect(child.argv.filter((arg) => arg === "--settings")).toHaveLength(1);
      expect(child.argv.some((arg) => arg.startsWith("--settings="))).toBe(false);
      const settingsPath = child.argv[child.argv.indexOf("--settings") + 1];
      expect(isAbsolute(settingsPath)).toBe(true);
      expect(settingsPath).toBe(join(sessionDir, "inherited-settings.json"));
      expect(settingsPath.startsWith(`${sessionsDir}${sep}`)).toBe(true);
      expect(settingsPath.startsWith(`${work}${sep}`)).toBe(false);
      expect(settingsPath.startsWith(`${caller}${sep}`)).toBe(false);

      const settings = JSON.parse(readFileSync(settingsPath, "utf-8")) as InheritedSettings;
      expect(settings.enabledPlugins["dev@magus"]).toBe(true);
      expect(statSync(settingsPath).mode & 0o777).toBe(0o600);
      expect(child.cwd).toBe(realpathSync(work));
      const spawn = JSON.parse(readFileSync(join(sessionDir, "spawn.json"), "utf-8")) as Record<
        string,
        unknown
      >;
      expect(spawn.setupFrom).toBe(caller);

      await manager.shutdownAll();
      expect(readdirSync(work)).toEqual([]);
      expect(readFileSync(callerSettings)).toEqual(before);
      return settings;
    }

    test(
      "inherits caller plugins through one private settings file outside the work directory",
      async () => {
        // REGRESSION: MTL-204/MTL-185 sandbox child lost the caller's plugins — /dev:fix session dev-fix-20261022-023522-f75563b5
        await expectInheritedSession([]);
      },
      T_PANE
    );

    test(
      "merges a caller settings flag into the inherited file without adding another settings flag",
      async () => {
        // REGRESSION: MTL-204/MTL-185 sandbox child lost the caller's plugins — /dev:fix session dev-fix-20261022-023522-f75563b5
        const settings = await expectInheritedSession(["--settings", '{"model":"c"}']);
        expect(settings.model).toBe("c");
      },
      T_PANE
    );

    test(
      "omitting setupFrom adds no settings flag, inherited file, or spawn metadata",
      async () => {
        // REGRESSION: MTL-204/MTL-185 sandbox child lost the caller's plugins — /dev:fix session dev-fix-20261022-023522-f75563b5
        const work = join(t.tmp, "work");
        mkdirSync(work);
        const manager = makeManager();
        const sessionId = await manager.createSession({
          model: "fake-env_probe",
          cwd: work,
          claudishFlags: [],
        });
        const child = await childProbe(manager, sessionId);
        const sessionDir = join(sessionsDir, sessionId);

        expect(manager.getDiagnostics(sessionId).sessionDir).toBe(sessionDir);
        expect(
          child.argv.filter((arg) => arg === "--settings" || arg.startsWith("--settings="))
        ).toEqual([]);
        expect(existsSync(join(sessionDir, "inherited-settings.json"))).toBe(false);
        const spawn = JSON.parse(readFileSync(join(sessionDir, "spawn.json"), "utf-8")) as Record<
          string,
          unknown
        >;
        expect(spawn).not.toHaveProperty("setupFrom");
        expect(child.cwd).toBe(realpathSync(work));

        await manager.shutdownAll();
        expect(readdirSync(work)).toEqual([]);
      },
      T_PANE
    );
  }
);