PaperClipAI/server/src/services/managed-environments.test.ts

import { describe, expect, it, vi } from "vitest";
import { applyManagedEnvironments } from "./managed-environments.js";
import {
  environmentRow,
  environmentsSeam,
  noDb,
  parsedConfig,
  readyDriverResolver,
  reconciliationResult,
  recoveryHandle,
  runningWorkerManager,
  tick,
} from "./managed-environments.test-support.js";

describe("applyManagedEnvironments", () => {
  it("no-ops for self-hosted instances and for documents without environments", async () => {
    expect(await applyManagedEnvironments(noDb, null)).toBeNull();
    expect(await applyManagedEnvironments(noDb, parsedConfig())).toBeNull();
  });

  it("refuses startup when a forced execution mode also claims the managed sandbox slot", async () => {
    const config = parsedConfig({
      environments: [{ name: "Daytona", provider: "daytona" }],
    });
    await expect(
      applyManagedEnvironments(noDb, config, {
        env: { PAPERCLIP_EXECUTION_MODE: "kubernetes" },
      }),
    ).rejects.toThrow(/mutually exclusive/);
  });

  it("ensures each declared environment through the provider-agnostic service call", async () => {
    const ensureManagedSandboxEnvironment = vi
      .fn()
      .mockResolvedValue(reconciliationResult());
    const config = parsedConfig({
      environments: [
        {
          name: "Daytona",
          description: "Managed Daytona sandbox.",
          provider: "daytona",
          config: { target: "us" },
        },
      ],
    });

    const resolveSandboxProviderDriver = readyDriverResolver();
    const workerManager = runningWorkerManager();
    const result = await applyManagedEnvironments(noDb, config, {
      env: {},
      workerManager,
      environments: environmentsSeam({ ensureManagedSandboxEnvironment }),
      resolveSandboxProviderDriver,
    });

    expect(result).toMatchObject({ ensured: 1, failed: 0, added: 1, skipped: 0 });
    expect(result).toMatchObject({ removed: 0, backedUp: 0 });
    expect(resolveSandboxProviderDriver).toHaveBeenCalledWith({ db: noDb, driverKey: "daytona" });
    expect(workerManager.isRunning).toHaveBeenCalledWith("plugin-1");
    expect(ensureManagedSandboxEnvironment).toHaveBeenCalledTimes(1);
    expect(ensureManagedSandboxEnvironment).toHaveBeenCalledWith({
      name: "Daytona",
      description: "Managed Daytona sandbox.",
      provider: "daytona",
      config: { target: "us" },
      stockVersion: "2026.720.0",
      platformFullyManaged: true,
    });
    // The frozen parsed config must not leak into the service (the row's
    // config is mutated downstream when the provider key is forced in).
    const passedConfig = ensureManagedSandboxEnvironment.mock.calls[0]?.[0]?.config;
    expect(Object.isFrozen(passedConfig)).toBe(false);
  });

  it("waits for the bundled-plugin startup pass before ensuring anything", async () => {
    const ensureManagedSandboxEnvironment = vi
      .fn()
      .mockResolvedValue(reconciliationResult());
    const config = parsedConfig({
      environments: [{ name: "Daytona", provider: "daytona" }],
    });

    let releasePlugins!: () => void;
    const pluginsReady = new Promise<void>((resolve) => {
      releasePlugins = resolve;
    });

    const pending = applyManagedEnvironments(noDb, config, {
      env: {},
      pluginsReady,
      workerManager: runningWorkerManager(),
      environments: environmentsSeam({ ensureManagedSandboxEnvironment }),
      resolveSandboxProviderDriver: readyDriverResolver(),
    });

    // Give the ensure every chance to (incorrectly) run early.
    await new Promise((resolve) => setImmediate(resolve));
    expect(ensureManagedSandboxEnvironment).not.toHaveBeenCalled();

    releasePlugins();
    expect(await pending).toMatchObject({ ensured: 1, failed: 0, added: 1 });
    expect(ensureManagedSandboxEnvironment).toHaveBeenCalledTimes(1);
  });

  it("reports operator-modified rows as skipped with a stock update still available", async () => {
    const environments = environmentsSeam({
      ensureManagedSandboxEnvironment: vi.fn().mockResolvedValue(reconciliationResult({
        action: "skipped",
        stockStatus: "operator_modified",
        updateAvailable: true,
      })),
    });
    const result = await applyManagedEnvironments(noDb, parsedConfig({
      environments: [{ name: "Daytona", provider: "daytona" }],
    }), {
      env: {},
      workerManager: runningWorkerManager(),
      environments,
      resolveSandboxProviderDriver: readyDriverResolver(),
    });

    expect(result).toMatchObject({
      ensured: 0,
      failed: 0,
      added: 0,
      updated: 0,
      unchanged: 0,
      skipped: 1,
      outcomes: [{
        action: "skipped",
        stockStatus: "operator_modified",
        updateAvailable: true,
      }],
    });
  });

  it("skips an entry whose provider plugin is missing and archives its stale row", async () => {
    const environments = environmentsSeam({
      archiveManagedSandboxEnvironment: vi.fn().mockResolvedValue(environmentRow({ status: "archived" })),
    });
    const config = parsedConfig({
      environments: [{ name: "Daytona", provider: "daytona" }],
    });

    const result = await applyManagedEnvironments(noDb, config, {
      env: {},
      workerManager: runningWorkerManager(),
      environments,
      resolveSandboxProviderDriver: vi.fn(async () => null),
    });

    expect(result).toMatchObject({ ensured: 0, failed: 1 });
    expect(environments.ensureManagedSandboxEnvironment).not.toHaveBeenCalled();
    expect(environments.archiveManagedSandboxEnvironment).toHaveBeenCalledWith({
      provider: "daytona",
    });
  });

  it("skips (and counts failed) an entry whose provider plugin is not ready", async () => {
    const environments = environmentsSeam();
    const config = parsedConfig({
      environments: [{ name: "Daytona", provider: "daytona" }],
    });

    const result = await applyManagedEnvironments(noDb, config, {
      env: {},
      workerManager: runningWorkerManager(),
      environments,
      resolveSandboxProviderDriver: readyDriverResolver("disabled"),
    });

    expect(result).toMatchObject({ ensured: 0, failed: 1 });
    expect(environments.ensureManagedSandboxEnvironment).not.toHaveBeenCalled();
    expect(environments.archiveManagedSandboxEnvironment).toHaveBeenCalledWith({
      provider: "daytona",
    });
  });

  it("skips an entry whose plugin record is ready but whose worker is not running", async () => {
    const environments = environmentsSeam();
    const config = parsedConfig({
      environments: [{ name: "Daytona", provider: "daytona" }],
    });

    const workerManager = runningWorkerManager(false);
    const result = await applyManagedEnvironments(noDb, config, {
      env: {},
      workerManager,
      environments,
      resolveSandboxProviderDriver: readyDriverResolver(),
    });

    expect(result).toMatchObject({ ensured: 0, failed: 1 });
    expect(workerManager.isRunning).toHaveBeenCalledWith("plugin-1");
    expect(environments.ensureManagedSandboxEnvironment).not.toHaveBeenCalled();
    expect(environments.archiveManagedSandboxEnvironment).toHaveBeenCalledWith({
      provider: "daytona",
    });
    // No registered handle → no respawn is coming; degraded until next boot.
    expect(workerManager.getWorker).toHaveBeenCalledWith("plugin-1");
  });

  it("reactivates the archived environment once when the provider worker recovers", async () => {
    const environments = environmentsSeam();
    const config = parsedConfig({
      environments: [
        { name: "Daytona", provider: "daytona", config: { target: "us" } },
      ],
    });

    const { handle, fireReady } = recoveryHandle();
    const workerManager = {
      isRunning: vi.fn(() => false),
      getWorker: vi.fn(() => handle),
    };
    const result = await applyManagedEnvironments(noDb, config, {
      env: {},
      workerManager,
      environments,
      resolveSandboxProviderDriver: readyDriverResolver(),
    });

    // The boot pass itself stays degraded: archived, counted failed.
    expect(result).toMatchObject({ ensured: 0, failed: 1 });
    expect(environments.archiveManagedSandboxEnvironment).toHaveBeenCalledWith({
      provider: "daytona",
    });
    expect(environments.ensureManagedSandboxEnvironment).not.toHaveBeenCalled();

    // Worker manager respawns the worker → the handle re-emits `ready`.
    fireReady();
    fireReady();
    await tick();

    expect(environments.ensureManagedSandboxEnvironment).toHaveBeenCalledTimes(1);
    expect(environments.ensureManagedSandboxEnvironment).toHaveBeenCalledWith({
      name: "Daytona",
      description: undefined,
      provider: "daytona",
      config: { target: "us" },
      stockVersion: "2026.720.0",
      platformFullyManaged: true,
    });
    expect(handle.off).toHaveBeenCalledTimes(1);
  });

  it("re-checks isRunning after subscribing so a recovery during the archive is not missed", async () => {
    const environments = environmentsSeam();
    const config = parsedConfig({
      environments: [{ name: "Daytona", provider: "daytona" }],
    });

    const { handle } = recoveryHandle();
    // Down at the gate check, already back up by the time the listener is
    // registered — the `ready` event has been missed.
    const workerManager = {
      isRunning: vi
        .fn()
        .mockReturnValueOnce(false)
        .mockReturnValue(true),
      getWorker: vi.fn(() => handle),
    };
    const result = await applyManagedEnvironments(noDb, config, {
      env: {},
      workerManager,
      environments,
      resolveSandboxProviderDriver: readyDriverResolver(),
    });
    await tick();

    expect(result).toMatchObject({ ensured: 0, failed: 1 });
    expect(environments.ensureManagedSandboxEnvironment).toHaveBeenCalledTimes(1);
  });

  it("does not subscribe for recovery when the plugin record is missing or not ready", async () => {
    const config = parsedConfig({
      environments: [{ name: "Daytona", provider: "daytona" }],
    });

    for (const resolveSandboxProviderDriver of [
      vi.fn(async () => null),
      readyDriverResolver("disabled"),
    ]) {
      const workerManager = runningWorkerManager(false);
      await applyManagedEnvironments(noDb, config, {
        env: {},
        workerManager,
        environments: environmentsSeam(),
        resolveSandboxProviderDriver,
      });
      expect(workerManager.getWorker).not.toHaveBeenCalled();
    }
  });

  it("logs, not throws, when the recovery re-ensure fails", async () => {
    const environments = environmentsSeam({
      ensureManagedSandboxEnvironment: vi.fn().mockRejectedValue(new Error("db exploded")),
    });
    const config = parsedConfig({
      environments: [{ name: "Daytona", provider: "daytona" }],
    });

    const { handle, fireReady } = recoveryHandle();
    const workerManager = {
      isRunning: vi.fn(() => false),
      getWorker: vi.fn(() => handle),
    };
    await applyManagedEnvironments(noDb, config, {
      env: {},
      workerManager,
      environments,
      resolveSandboxProviderDriver: readyDriverResolver(),
    });

    fireReady();
    await tick();
    // The rejection is swallowed into a log line; reaching this point without
    // an unhandled rejection is the assertion.
    expect(environments.ensureManagedSandboxEnvironment).toHaveBeenCalledTimes(1);
  });

  it("fails closed when no worker manager is provided", async () => {
    const environments = environmentsSeam();
    const config = parsedConfig({
      environments: [{ name: "Daytona", provider: "daytona" }],
    });

    const result = await applyManagedEnvironments(noDb, config, {
      env: {},
      environments,
      resolveSandboxProviderDriver: readyDriverResolver(),
    });

    expect(result).toMatchObject({ ensured: 0, failed: 1 });
    expect(environments.ensureManagedSandboxEnvironment).not.toHaveBeenCalled();
  });

  it("counts a skipped entry once even when archiving its stale row fails", async () => {
    const environments = environmentsSeam({
      archiveManagedSandboxEnvironment: vi.fn().mockRejectedValue(new Error("db exploded")),
    });
    const config = parsedConfig({
      environments: [{ name: "Daytona", provider: "daytona" }],
    });

    const result = await applyManagedEnvironments(noDb, config, {
      env: {},
      workerManager: runningWorkerManager(),
      environments,
      resolveSandboxProviderDriver: vi.fn(async () => null),
    });

    expect(result).toMatchObject({ ensured: 0, failed: 1 });
    expect(environments.archiveManagedSandboxEnvironment).toHaveBeenCalledTimes(1);
  });

  it("is fail-safe per entry: an ensure failure is counted, not thrown", async () => {
    const environments = environmentsSeam({
      ensureManagedSandboxEnvironment: vi.fn().mockRejectedValue(new Error("db exploded")),
    });
    const config = parsedConfig({
      environments: [{ name: "Daytona", provider: "daytona" }],
    });

    const result = await applyManagedEnvironments(noDb, config, {
      env: {},
      workerManager: runningWorkerManager(),
      environments,
      resolveSandboxProviderDriver: readyDriverResolver(),
    });

    expect(result).toMatchObject({ ensured: 0, failed: 1 });
    expect(environments.archiveManagedSandboxEnvironment).not.toHaveBeenCalled();
  });

  it("fills the instance default with the managed sandbox under managed-sandbox-only", async () => {
    const fillInstanceDefault = vi.fn(async () => ({ filled: true, previousDefaultEnvironmentId: null }));
    const config = parsedConfig({
      features: { enableManagedSandboxOnly: true },
      environments: [{ name: "Daytona", provider: "daytona" }],
    });

    await applyManagedEnvironments(noDb, config, {
      env: {},
      workerManager: runningWorkerManager(),
      fillInstanceDefault,
      environments: environmentsSeam(),
      resolveSandboxProviderDriver: readyDriverResolver(),
    });

    // The locked fill (`fillUnsetInstanceDefault`) decides whether to write.
    expect(fillInstanceDefault).toHaveBeenCalledWith("env-1");
  });

  it("leaves the instance default alone while managed-sandbox-only is not declared", async () => {
    // Without the mode, local execution is a legitimate default; provisioning
    // the managed environment must not silently move runs into the sandbox.
    const fillInstanceDefault = vi.fn(async () => ({ filled: true, previousDefaultEnvironmentId: null }));
    const config = parsedConfig({
      environments: [{ name: "Daytona", provider: "daytona" }],
    });

    await applyManagedEnvironments(noDb, config, {
      env: {},
      workerManager: runningWorkerManager(),
      fillInstanceDefault,
      environments: environmentsSeam(),
      resolveSandboxProviderDriver: readyDriverResolver(),
    });

    expect(fillInstanceDefault).not.toHaveBeenCalled();
  });

  it("never reverts a filled default when managed-sandbox-only is not declared", async () => {
    // A filled default is an ordinary set value. With the mode off, and even
    // with no environments declared, boot writes nothing to the default.
    const fillInstanceDefault = vi.fn(async () => ({ filled: true, previousDefaultEnvironmentId: null }));
    const environments = environmentsSeam();
    expect(await applyManagedEnvironments(noDb, parsedConfig({}), {
      env: {},
      workerManager: runningWorkerManager(),
      fillInstanceDefault,
      environments,
    })).toBeNull();
    expect(fillInstanceDefault).not.toHaveBeenCalled();
    expect(environments.ensureManagedSandboxEnvironment).not.toHaveBeenCalled();
  });

  it("keeps the environment ensured when filling the default fails", async () => {
    const result = await applyManagedEnvironments(noDb, parsedConfig({
      features: { enableManagedSandboxOnly: true },
      environments: [{ name: "Daytona", provider: "daytona" }],
    }), {
      env: {},
      workerManager: runningWorkerManager(),
      fillInstanceDefault: vi.fn().mockRejectedValue(new Error("db exploded")),
      environments: environmentsSeam(),
      resolveSandboxProviderDriver: readyDriverResolver(),
    });
    expect(result).toMatchObject({ ensured: 1, failed: 0 });
  });
});