Codeman/test/foreign-adoption-guards.test.ts

/**
 * @fileoverview The adoption guards that are not reachable over HTTP: the
 * boot-time workspace-hook sweep, the workspace-trust auto-accept and the
 * new-shell clear.
 *
 * Each acts on a session's WORKSPACE or its PANE, each runs unattended, and each
 * previously keyed off `session.remote`, the mode or nothing at all, none of which
 * sees an adopted session, whose connection facts live on `adopt.remote` /
 * `adopt.docker`. So a tab wrapping someone's claude read as a plain local
 * claude: Codeman wrote `.claude/settings.local.json` into their repo on every
 * restart, and answered a trust dialog that was theirs to answer.
 *
 * Each one is paired with a session Codeman DID start — without that control,
 * "nothing was written" is equally explained by a disabled setting or a loop
 * that never ran.
 *
 * Port: none (no server is listened on).
 */
import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';

const applyWorkspaceHooks = vi.fn(async () => {});
vi.mock('../src/hooks-config.js', async (importOriginal) => {
  const actual = await importOriginal<typeof import('../src/hooks-config.js')>();
  return { ...actual, applyWorkspaceHooks: (...args: unknown[]) => applyWorkspaceHooks(...(args as [])) };
});

const { WebServer } = await import('../src/web/server.js');
const { Session } = await import('../src/session.js');

type AnySession = Record<string, unknown>;

/** The minimum a session needs to reach the sweep's `workspaces` set. */
function fakeSession(over: AnySession): AnySession {
  return { mode: 'claude', workingDir: '/srv/app', isAdopted: false, ...over };
}

describe('the boot workspace-hook sweep', () => {
  let server: InstanceType<typeof WebServer>;

  beforeEach(() => {
    applyWorkspaceHooks.mockClear();
    server = new WebServer(0);
    (server as unknown as { getWorkspaceHooksEnabled: () => Promise<boolean> }).getWorkspaceHooksEnabled = async () =>
      true;
  });
  afterEach(async () => {
    await server.stop().catch(() => {});
  });

  const sweep = async (sessions: AnySession[]) => {
    const map = new Map<string, AnySession>();
    sessions.forEach((s, i) => map.set(`s${i}`, s));
    (server as unknown as { sessions: Map<string, AnySession> }).sessions = map;
    await (
      server as unknown as { ensureHooksForRecoveredWorkspaces: () => Promise<void> }
    ).ensureHooksForRecoveredWorkspaces();
    return applyWorkspaceHooks.mock.calls.map((c) => c[0]);
  };

  it('installs hooks into a workspace Codeman owns', async () => {
    expect(await sweep([fakeSession({ workingDir: '/srv/ours' })])).toContain('/srv/ours');
  });

  it('skips an adopted session even though its mode is claude and `remote` is unset', async () => {
    // This is the exact shape the bug had: the ssh/docker facts hang off
    // `adopt`, so the pre-existing `session.remote` check sees nothing.
    const adopted = fakeSession({
      workingDir: '/home/them/repo',
      isAdopted: true,
      adopt: { location: 'remote', remote: { host: 'box' } },
    });
    expect(await sweep([adopted])).not.toContain('/home/them/repo');
  });

  it('still skips a plain remote session — the older rule is untouched', async () => {
    expect(await sweep([fakeSession({ workingDir: '/srv/far', remote: { host: 'box' } })])).not.toContain('/srv/far');
  });
});

describe('the workspace-trust auto-accept', () => {
  const makeSession = (adopt?: Record<string, unknown>) =>
    new Session({
      id: adopt ? 'adopt-trust' : 'own-trust',
      name: 't',
      workingDir: '/tmp',
      mode: 'claude',
      ...(adopt ? { adopt } : {}),
      // eslint-disable-next-line @typescript-eslint/no-explicit-any
    } as any);

  const scan = (s: InstanceType<typeof Session>) => {
    const priv = s as unknown as {
      _interactiveStartedAt: number;
      _trustDialogAccepted: boolean;
      _maybeAcceptTrustDialog: () => void;
      _trustDialogTimer: unknown;
    };
    priv._interactiveStartedAt = Date.now(); // inside the 90s startup window
    priv._trustDialogAccepted = false;
    priv._maybeAcceptTrustDialog();
    return priv;
  };

  it('arms the scan for a session Codeman started', async () => {
    const s = makeSession();
    const priv = scan(s);
    expect(priv._trustDialogAccepted).toBe(false);
    await s.stop(true).catch(() => {});
  });

  it('never answers a dialog in an adopted pane', async () => {
    // That pane holds SOMEONE ELSE'S claude. And boot recovery re-opens the 90s
    // window on every restart, so this is not a one-shot at adoption time.
    const s = makeSession({
      location: 'local',
      socketPath: '/tmp/tmux-0/default',
      targetSession: 'work',
      viewSession: '',
    });
    const priv = scan(s);
    expect(priv._trustDialogAccepted).toBe(true); // short-circuited, never scans again
    expect(priv._trustDialogTimer).toBeFalsy();
    await s.stop(true).catch(() => {});
  });
});

describe('the new-shell clear', () => {
  /** What a shell session writes to its pane once the mux attach is up. */
  const bytesWrittenAfterStart = async (adopt?: Record<string, unknown>) => {
    const s = new Session({
      id: adopt ? 'adopt-shell' : 'own-shell',
      name: 't',
      workingDir: '/tmp',
      mode: 'shell',
      useMux: true,
      mux: {},
      ...(adopt ? { adopt } : {}),
      // eslint-disable-next-line @typescript-eslint/no-explicit-any
    } as any);
    const write = vi.fn();
    const disposable = () => ({ dispose() {} });
    const priv = s as unknown as Record<string, unknown>;
    priv._setupOrAttachMuxSession = async () => {
      priv.ptyProcess = { write, onData: disposable, onExit: disposable, kill() {}, pid: 1 };
      return { isRestored: false, respawnedDeadPane: false };
    };
    await s.startShell();
    await new Promise((resolve) => setTimeout(resolve, 200));
    priv.ptyProcess = null;
    await s.stop(true).catch(() => {});
    return write.mock.calls.map((c) => c[0]);
  };

  it('clears a shell Codeman started', async () => {
    expect(await bytesWrittenAfterStart()).toEqual(['clear\n']);
  });

  it('types nothing into an adopted pane', async () => {
    // ⚠️ That pane is someone else's, and `shell` is also the answer for anything the
    // classifier cannot name (vim, psql, a `read` prompt). `clear` plus a newline landed
    // on a half-typed command or in whatever was reading stdin, on every adoption.
    const adopt = { location: 'local', socketPath: '/tmp/tmux-0/default', targetSession: 'work', viewSession: '' };
    expect(await bytesWrittenAfterStart(adopt)).toEqual([]);
  });
});