project.test.ts

import * as OtelEnvironment from "@t3tools/shared/otelEnvironment";
import { DEFAULT_SIGNAL_EXPORT } from "@t3tools/shared/observability";
// @effect-diagnostics nodeBuiltinImport:off - CLI integration uses temporary Node paths.
import * as NodeFS from "node:fs";
import * as NodeOS from "node:os";
import * as NodePath from "node:path";

import * as NodeCrypto from "@effect/platform-node/NodeCrypto";
import * as NodeServices from "@effect/platform-node/NodeServices";
import { assert, it } from "@effect/vitest";
import {
  CommandId,
  EventId,
  ProviderInstanceId,
  ThreadId,
  type OrchestrationV2AppThread,
  type ProjectId,
} from "@t3tools/contracts";
import * as NetService from "@t3tools/shared/Net";
import * as DateTime from "effect/DateTime";
import * as Effect from "effect/Effect";
import * as Fiber from "effect/Fiber";
import * as FileSystem from "effect/FileSystem";
import * as Layer from "effect/Layer";
import * as References from "effect/References";
import * as Stream from "effect/Stream";
import { Command } from "effect/cli";
import { FetchHttpClient } from "effect/http";
import * as TestClock from "effect/testing/TestClock";

import * as ServerSecretStore from "../auth/ServerSecretStore.ts";
import { cli } from "../binCli.ts";
import * as ServerConfig from "../config.ts";
import * as EventSink from "../orchestration-v2/EventSink.ts";
import * as EventStore from "../orchestration-v2/EventStore.ts";
import * as ProjectionStore from "../orchestration-v2/ProjectionStore.ts";
import * as RuntimeLayer from "../orchestration-v2/runtimeLayer.ts";
import * as SqlitePersistence from "../persistence/Sqlite.ts";
import * as ProjectEnrichmentService from "../project/ProjectEnrichmentService.ts";
import * as ProjectFaviconResolver from "../project/ProjectFaviconResolver.ts";
import * as ProjectService from "../project/ProjectService.ts";
import * as RepositoryIdentityResolver from "../project/RepositoryIdentityResolver.ts";
import * as T3ProjectFileLoader from "../project/T3ProjectFileLoader.ts";
import {
  makePersistedServerRuntimeState,
  persistServerRuntimeState,
} from "../serverRuntimeState.ts";
import * as ServerSettings from "../serverSettings.ts";
import * as ManagedPolicy from "../policy/ManagedPolicy.ts";
import * as WorkspacePaths from "../workspace/WorkspacePaths.ts";

const layerCliRuntime = Layer.mergeAll(NodeServices.layer, NodeCrypto.layer, NetService.layer);
const runCli = (args: ReadonlyArray<string>) =>
  Command.runWith(cli, { version: "0.0.0" })(args).pipe(Effect.provide(layerCliRuntime));

const makeConfig = (baseDir: string) =>
  Effect.gen(function* () {
    const derivedPaths = yield* ServerConfig.deriveServerPaths(baseDir, undefined);
    return {
      logLevel: "Info",
      traceMinLevel: "Info",
      traceTimingEnabled: true,
      traceBatchWindowMs: 200,
      traceMaxBytes: 10 * 1024 * 1024,
      traceMaxFiles: 10,
      otelEnvironment: OtelEnvironment.none,
      otlpTracesUrl: undefined,
      otlpMetricsUrl: undefined,
      otlpLogsUrl: undefined,
      otlpTracesExport: DEFAULT_SIGNAL_EXPORT,
      otlpMetricsExport: DEFAULT_SIGNAL_EXPORT,
      otlpLogsExport: DEFAULT_SIGNAL_EXPORT,
      mode: "web",
      port: 0,
      host: "127.0.0.1",
      cwd: process.cwd(),
      baseDir,
      ...derivedPaths,
      staticDir: undefined,
      devUrl: undefined,
      devAllowedOrigins: [],
      noBrowser: true,
      startupPresentation: "browser",
      desktopBootstrapToken: undefined,
      autoBootstrapProjectFromCwd: false,
      logWebSocketEvents: false,
      tailscaleServeEnabled: false,
      tailscaleServePort: 443,
    } satisfies ServerConfig.ServerConfig["Service"];
  });

const readProjects = (baseDir: string) =>
  Effect.gen(function* () {
    const config = yield* makeConfig(baseDir);
    const layer = RuntimeLayer.layerProjectService.pipe(
      Layer.provideMerge(ProjectEnrichmentService.layer),
      Layer.provideMerge(RepositoryIdentityResolver.layer),
      Layer.provideMerge(ProjectFaviconResolver.layer),
      Layer.provideMerge(T3ProjectFileLoader.layer),
      Layer.provideMerge(WorkspacePaths.layer),
      Layer.provideMerge(
        ServerSettings.layer.pipe(
          Layer.provide(Layer.merge(ServerSecretStore.layer, ManagedPolicy.layerTest())),
        ),
      ),
      Layer.provideMerge(SqlitePersistence.layerConfig),
      Layer.provideMerge(Layer.mergeAll(NodeServices.layer, NodeCrypto.layer)),
      Layer.provide(ServerConfig.layer(config)),
      Layer.provide(Layer.succeed(References.MinimumLogLevel, config.logLevel)),
    );
    return yield* ProjectService.ProjectService.pipe(
      Effect.flatMap((projects) => projects.snapshot),
      Effect.provide(layer),
    );
  });

it.effect("adds, renames, and removes projects through the V2 project CLI domain", () =>
  Effect.gen(function* () {
    const baseDir = NodeFS.mkdtempSync(NodePath.join(NodeOS.tmpdir(), "t3-v2-project-cli-"));
    const workspaceRoot = NodeFS.mkdtempSync(
      NodePath.join(NodeOS.tmpdir(), "t3-v2-project-workspace-"),
    );

    yield* runCli(["project", "add", workspaceRoot, "--title", "Alpha", "--base-dir", baseDir]);
    const added = (yield* readProjects(baseDir)).projects[0];
    assert.equal(added?.title, "Alpha");
    assert.equal(added?.workspaceRoot, workspaceRoot);

    yield* runCli(["project", "rename", workspaceRoot, "Beta", "--base-dir", baseDir]);
    assert.equal((yield* readProjects(baseDir)).projects[0]?.title, "Beta");

    yield* runCli(["project", "remove", added?.id ?? "", "--base-dir", baseDir]);
    assert.deepEqual((yield* readProjects(baseDir)).projects, []);
  }).pipe(Effect.provide(Layer.mergeAll(NodeServices.layer, NodeCrypto.layer))),
);

it.effect.each(["snapshot", "mutation"] as const)(
  "waits for a busy live server's %s response",
  (slowRequest) =>
    Effect.gen(function* () {
      const fs = yield* FileSystem.FileSystem;
      const root = yield* fs.makeTempDirectoryScoped({ prefix: "t3-live-project-cli-" });
      const baseDir = NodePath.join(root, "state");
      const workspaceRoot = NodePath.join(root, "workspace");
      yield* fs.makeDirectory(workspaceRoot);
      yield* persistServerRuntimeState({
        path: NodePath.join(baseDir, "userdata", "server-runtime.json"),
        state: yield* makePersistedServerRuntimeState({
          config: { host: "127.0.0.1", devUrl: undefined },
          port: 3_773,
        }),
      });
      const now = "2026-01-01T00:00:00.000Z";
      const requestReceived = Promise.withResolvers<void>();
      const releaseResponse = Promise.withResolvers<void>();
      let snapshotRequests = 0;
      let mutations = 0;
      const fetch: typeof globalThis.fetch = async (_input, init) => {
        const isMutation = init?.method === "POST";
        if (isMutation) mutations++;
        else snapshotRequests++;
        if (slowRequest === "mutation" ? isMutation : !isMutation && snapshotRequests === 2) {
          requestReceived.resolve();
          await releaseResponse.promise;
        }
        return Response.json(
          isMutation
            ? {
                id: "live-project",
                title: NodePath.basename(workspaceRoot),
                workspaceRoot,
                defaultModelSelection: null,
                scripts: [],
                createdAt: now,
                updatedAt: now,
                deletedAt: null,
              }
            : { projects: [], updatedAt: now },
        );
      };

      const add = yield* runCli(["project", "add", workspaceRoot, "--base-dir", baseDir]).pipe(
        Effect.provideService(FetchHttpClient.Fetch, fetch),
        Effect.forkChild,
      );
      yield* Effect.promise(() => requestReceived.promise);
      yield* TestClock.adjust("2 seconds");
      releaseResponse.resolve();
      yield* Fiber.join(add);

      assert.equal(snapshotRequests, 2);
      assert.equal(mutations, 1);
      assert.deepEqual((yield* readProjects(baseDir)).projects, []);
    }).pipe(Effect.provide(NodeServices.layer), Effect.scoped),
);

const makeProjectLookupFixture = Effect.fn("ProjectCliTest.makeProjectLookupFixture")(function* () {
  const fs = yield* FileSystem.FileSystem;
  const root = yield* fs.makeTempDirectoryScoped({ prefix: "t3-v2-project-lookup-" });
  const baseDir = NodePath.join(root, "state");
  const workspaceRoot = NodePath.join(root, "workspace");
  yield* fs.makeDirectory(workspaceRoot);
  yield* runCli(["project", "add", workspaceRoot, "--base-dir", baseDir]);
  const project = (yield* readProjects(baseDir)).projects[0];
  assert.isDefined(project);
  return { baseDir, workspaceRoot, project: project! };
});

const makeThreadPersistenceLayer = Effect.fn("ProjectCliTest.makeThreadPersistenceLayer")(
  function* (baseDir: string) {
    const config = yield* makeConfig(baseDir);
    return Layer.mergeAll(
      RuntimeLayer.layerEventSink,
      ProjectionStore.layer,
      EventStore.layer,
    ).pipe(
      Layer.provideMerge(SqlitePersistence.layerConfig),
      Layer.provideMerge(Layer.mergeAll(NodeServices.layer, NodeCrypto.layer)),
      Layer.provide(ServerConfig.layer(config)),
      Layer.provide(Layer.succeed(References.MinimumLogLevel, config.logLevel)),
    );
  },
);

const seedNativeThreads = Effect.fn("ProjectCliTest.seedNativeThreads")(function* (
  baseDir: string,
  threads: ReadonlyArray<{
    readonly id: ThreadId;
    readonly projectId: ProjectId;
    readonly archived: boolean;
  }>,
) {
  const layer = yield* makeThreadPersistenceLayer(baseDir);
  const createdAt = DateTime.makeUnsafe("2026-09-04T12:00:00.000Z");
  const providerInstanceId = ProviderInstanceId.make("codex");
  yield* Effect.gen(function* () {
    const eventSink = yield* EventSink.EventSinkV2;
    yield* eventSink.write({
      commandId: CommandId.make("project-cli-seed-threads"),
      events: threads.map(({ id, projectId, archived }) => {
        const payload: OrchestrationV2AppThread = {
          createdBy: "user",
          creationSource: "web",
          id,
          projectId,
          title: id,
          providerInstanceId,
          modelSelection: { instanceId: providerInstanceId, model: "gpt-5" },
          runtimeMode: "full-access",
          interactionMode: "default",
          branch: null,
          worktreePath: null,
          activeProviderThreadId: null,
          lineage: { parentThreadId: null, relationshipToParent: null, rootThreadId: id },
          forkedFrom: null,
          createdAt,
          updatedAt: createdAt,
          archivedAt: archived ? createdAt : null,
          settledOverride: null,
          settledAt: null,
          lastVisitedAt: null,
          deletedAt: null,
        };
        return {
          id: EventId.make(`project-cli-create-${id}`),
          type: "thread.created" as const,
          threadId: id,
          providerInstanceId,
          occurredAt: createdAt,
          payload,
        };
      }),
    });
  }).pipe(Effect.provide(layer));
});

const readNativeThreadState = Effect.fn("ProjectCliTest.readNativeThreadState")(function* (
  baseDir: string,
  threadId: ThreadId,
) {
  const layer = yield* makeThreadPersistenceLayer(baseDir);
  return yield* Effect.gen(function* () {
    const projections = yield* ProjectionStore.ProjectionStoreV2;
    const events = yield* EventStore.EventStoreV2;
    return {
      thread: yield* projections.getThread(threadId),
      events: yield* events.read({ threadId }).pipe(Stream.runCollect),
    };
  }).pipe(Effect.provide(layer));
});

it.layer(Layer.mergeAll(NodeServices.layer, NodeCrypto.layer))(
  "project deletion with native V2 threads",
  (it) => {
    it.effect.each([
      { label: "an active thread", archived: false, missing: false },
      {
        label: "an archived thread after its workspace disappears",
        archived: true,
        missing: true,
      },
    ])("rejects unforced removal of a project with $label", ({ archived, missing }) =>
      Effect.gen(function* () {
        const fs = yield* FileSystem.FileSystem;
        const { baseDir, workspaceRoot, project } = yield* makeProjectLookupFixture();
        const threadId = ThreadId.make("project-cli-preserved-thread");
        yield* seedNativeThreads(baseDir, [{ id: threadId, projectId: project.id, archived }]);
        const before = yield* readNativeThreadState(baseDir, threadId);
        if (missing) yield* fs.rename(workspaceRoot, `${workspaceRoot}-removed`);

        const error = yield* runCli([
          "project",
          "remove",
          missing ? workspaceRoot : project.id,
          "--base-dir",
          baseDir,
        ]).pipe(
          Effect.match({
            onFailure: (error) => error,
            onSuccess: () => assert.fail("Removing a nonempty project must require --force."),
          }),
        );

        assert.include(error.message, "not empty");
        assert.deepEqual(
          (yield* readProjects(baseDir)).projects.map((entry) => entry.id),
          [project.id],
        );
        assert.deepEqual(yield* readNativeThreadState(baseDir, threadId), before);
        assert.equal(yield* fs.exists(workspaceRoot), !missing);
      }),
    );

    it.effect.each(["present", "missing"] as const)(
      "force-removes active and archived V2 threads with the workspace %s, preserving unrelated projects",
      (workspace) =>
        Effect.gen(function* () {
          const fs = yield* FileSystem.FileSystem;
          const { baseDir, workspaceRoot, project } = yield* makeProjectLookupFixture();
          const otherWorkspace = `${workspaceRoot}-other`;
          yield* fs.makeDirectory(otherWorkspace);
          yield* runCli(["project", "add", otherWorkspace, "--base-dir", baseDir]);
          const otherProject = (yield* readProjects(baseDir)).projects.find(
            (entry) => entry.workspaceRoot === otherWorkspace,
          );
          assert.isDefined(otherProject);
          const activeId = ThreadId.make("project-cli-deleted-active");
          const archivedId = ThreadId.make("project-cli-deleted-archived");
          const unrelatedId = ThreadId.make("project-cli-unrelated-thread");
          yield* seedNativeThreads(baseDir, [
            { id: activeId, projectId: project.id, archived: false },
            { id: archivedId, projectId: project.id, archived: true },
            { id: unrelatedId, projectId: otherProject!.id, archived: false },
          ]);
          const unrelatedBefore = yield* readNativeThreadState(baseDir, unrelatedId);
          if (workspace === "missing") {
            yield* fs.rename(workspaceRoot, `${workspaceRoot}-removed`);
          }

          yield* runCli([
            "project",
            "remove",
            workspace === "missing" ? workspaceRoot : project.id,
            "--force",
            "--base-dir",
            baseDir,
          ]);

          assert.deepEqual(
            (yield* readProjects(baseDir)).projects.map((entry) => entry.id),
            [otherProject!.id],
          );
          for (const threadId of [activeId, archivedId]) {
            const state = yield* readNativeThreadState(baseDir, threadId);
            assert.isNotNull(state.thread.deletedAt);
            assert.lengthOf(
              state.events.filter((record) => record.event.type === "thread.deleted"),
              1,
            );
          }
          assert.deepEqual(yield* readNativeThreadState(baseDir, unrelatedId), unrelatedBefore);
          assert.equal(yield* fs.exists(workspaceRoot), workspace === "present");
          assert.isTrue(yield* fs.exists(otherWorkspace));
        }),
    );
  },
);

it.layer(Layer.mergeAll(NodeServices.layer, NodeCrypto.layer))(
  "project lookup with unavailable workspaces",
  (it) => {
    it.effect.each([
      "id",
      "stored path",
      "relative path",
      "path with a trailing separator",
    ] as const)("removes an empty project by %s after its directory is gone", (identifier) =>
      Effect.gen(function* () {
        const fs = yield* FileSystem.FileSystem;
        const { baseDir, workspaceRoot, project } = yield* makeProjectLookupFixture();
        yield* fs.rename(workspaceRoot, `${workspaceRoot}-removed`);
        const target = {
          id: project.id,
          "stored path": workspaceRoot,
          "relative path": NodePath.relative(process.cwd(), workspaceRoot),
          "path with a trailing separator": `${workspaceRoot}${NodePath.sep}`,
        }[identifier];
        yield* runCli(["project", "remove", target, "--base-dir", baseDir]);
        assert.deepEqual((yield* readProjects(baseDir)).projects, []);
        assert.isFalse(yield* fs.exists(workspaceRoot));
      }),
    );

    it.effect("does not resolve another environment's project ID in an empty database", () =>
      Effect.gen(function* () {
        const fs = yield* FileSystem.FileSystem;
        const { baseDir, workspaceRoot, project } = yield* makeProjectLookupFixture();
        yield* fs.rename(workspaceRoot, `${workspaceRoot}-removed`);
        const replacementDir = yield* fs.makeTempDirectoryScoped({
          prefix: "t3-v2-project-empty-",
        });
        const error = yield* runCli([
          "project",
          "remove",
          project.id,
          "--force",
          "--base-dir",
          replacementDir,
        ]).pipe(Effect.flip);
        assert.include(error.message, "No active project found");
        assert.deepEqual(
          (yield* readProjects(baseDir)).projects.map((entry) => entry.id),
          [project.id],
        );
        assert.deepEqual((yield* readProjects(replacementDir)).projects, []);
      }),
    );

    it.effect("normalizes existing paths without conflating separately registered symlinks", () =>
      Effect.gen(function* () {
        const { baseDir, workspaceRoot, project } = yield* makeProjectLookupFixture();
        yield* runCli([
          "project",
          "rename",
          `${workspaceRoot}${NodePath.sep}.`,
          "Normalized",
          "--base-dir",
          baseDir,
        ]);
        assert.equal((yield* readProjects(baseDir)).projects[0]?.title, "Normalized");
        const aliasPath = `${workspaceRoot}-alias`;
        NodeFS.symlinkSync(workspaceRoot, aliasPath, "junction");
        const unknownAlias = yield* runCli([
          "project",
          "remove",
          aliasPath,
          "--base-dir",
          baseDir,
        ]).pipe(Effect.flip);
        assert.include(unknownAlias.message, "No active project found");
        yield* runCli(["project", "add", aliasPath, "--base-dir", baseDir]);
        const added = (yield* readProjects(baseDir)).projects;
        assert.equal(added.length, 2);
        const aliasProject = added.find((entry) => entry.workspaceRoot === aliasPath);
        assert.isDefined(aliasProject);
        assert.notEqual(aliasProject?.id, project.id);
        yield* runCli(["project", "remove", `${aliasPath}${NodePath.sep}.`, "--base-dir", baseDir]);
        assert.deepEqual(
          (yield* readProjects(baseDir)).projects.map((entry) => entry.id),
          [project.id],
        );
        assert.isTrue(NodeFS.existsSync(workspaceRoot));
      }),
    );
  },
);