Open History to see the last commit
1import * as OtelEnvironment from "@t3tools/shared/otelEnvironment";
2import { DEFAULT_SIGNAL_EXPORT } from "@t3tools/shared/observability";
3// @effect-diagnostics nodeBuiltinImport:off - CLI integration uses temporary Node paths.
4import * as NodeFS from "node:fs";
5import * as NodeOS from "node:os";
6import * as NodePath from "node:path";
7
8import * as NodeCrypto from "@effect/platform-node/NodeCrypto";
9import * as NodeServices from "@effect/platform-node/NodeServices";
10import { assert, it } from "@effect/vitest";
11import {
12 CommandId,
13 EventId,
14 ProviderInstanceId,
15 ThreadId,
16 type OrchestrationV2AppThread,
17 type ProjectId,
18} from "@t3tools/contracts";
19import * as NetService from "@t3tools/shared/Net";
20import * as DateTime from "effect/DateTime";
21import * as Effect from "effect/Effect";
22import * as Fiber from "effect/Fiber";
23import * as FileSystem from "effect/FileSystem";
24import * as Layer from "effect/Layer";
25import * as References from "effect/References";
26import * as Stream from "effect/Stream";
27import { Command } from "effect/cli";
28import { FetchHttpClient } from "effect/http";
29import * as TestClock from "effect/testing/TestClock";
30
31import * as ServerSecretStore from "../auth/ServerSecretStore.ts";
32import { cli } from "../binCli.ts";
33import * as ServerConfig from "../config.ts";
34import * as EventSink from "../orchestration-v2/EventSink.ts";
35import * as EventStore from "../orchestration-v2/EventStore.ts";
36import * as ProjectionStore from "../orchestration-v2/ProjectionStore.ts";
37import * as RuntimeLayer from "../orchestration-v2/runtimeLayer.ts";
38import * as SqlitePersistence from "../persistence/Sqlite.ts";
39import * as ProjectEnrichmentService from "../project/ProjectEnrichmentService.ts";
40import * as ProjectFaviconResolver from "../project/ProjectFaviconResolver.ts";
41import * as ProjectService from "../project/ProjectService.ts";
42import * as RepositoryIdentityResolver from "../project/RepositoryIdentityResolver.ts";
43import * as T3ProjectFileLoader from "../project/T3ProjectFileLoader.ts";
44import {
45 makePersistedServerRuntimeState,
46 persistServerRuntimeState,
47} from "../serverRuntimeState.ts";
48import * as ServerSettings from "../serverSettings.ts";
49import * as ManagedPolicy from "../policy/ManagedPolicy.ts";
50import * as WorkspacePaths from "../workspace/WorkspacePaths.ts";
51
52const layerCliRuntime = Layer.mergeAll(NodeServices.layer, NodeCrypto.layer, NetService.layer);
53const runCli = (args: ReadonlyArray<string>) =>
54 Command.runWith(cli, { version: "0.0.0" })(args).pipe(Effect.provide(layerCliRuntime));
55
56const makeConfig = (baseDir: string) =>
57 Effect.gen(function* () {
58 const derivedPaths = yield* ServerConfig.deriveServerPaths(baseDir, undefined);
59 return {
60 logLevel: "Info",
61 traceMinLevel: "Info",
62 traceTimingEnabled: true,
63 traceBatchWindowMs: 200,
64 traceMaxBytes: 10 * 1024 * 1024,
65 traceMaxFiles: 10,
66 otelEnvironment: OtelEnvironment.none,
67 otlpTracesUrl: undefined,
68 otlpMetricsUrl: undefined,
69 otlpLogsUrl: undefined,
70 otlpTracesExport: DEFAULT_SIGNAL_EXPORT,
71 otlpMetricsExport: DEFAULT_SIGNAL_EXPORT,
72 otlpLogsExport: DEFAULT_SIGNAL_EXPORT,
73 mode: "web",
74 port: 0,
75 host: "127.0.0.1",
76 cwd: process.cwd(),
77 baseDir,
78 ...derivedPaths,
79 staticDir: undefined,
80 devUrl: undefined,
81 devAllowedOrigins: [],
82 noBrowser: true,
83 startupPresentation: "browser",
84 desktopBootstrapToken: undefined,
85 autoBootstrapProjectFromCwd: false,
86 logWebSocketEvents: false,
87 tailscaleServeEnabled: false,
88 tailscaleServePort: 443,
89 } satisfies ServerConfig.ServerConfig["Service"];
90 });
91
92const readProjects = (baseDir: string) =>
93 Effect.gen(function* () {
94 const config = yield* makeConfig(baseDir);
95 const layer = RuntimeLayer.layerProjectService.pipe(
96 Layer.provideMerge(ProjectEnrichmentService.layer),
97 Layer.provideMerge(RepositoryIdentityResolver.layer),
98 Layer.provideMerge(ProjectFaviconResolver.layer),
99 Layer.provideMerge(T3ProjectFileLoader.layer),
100 Layer.provideMerge(WorkspacePaths.layer),
101 Layer.provideMerge(
102 ServerSettings.layer.pipe(
103 Layer.provide(Layer.merge(ServerSecretStore.layer, ManagedPolicy.layerTest())),
104 ),
105 ),
106 Layer.provideMerge(SqlitePersistence.layerConfig),
107 Layer.provideMerge(Layer.mergeAll(NodeServices.layer, NodeCrypto.layer)),
108 Layer.provide(ServerConfig.layer(config)),
109 Layer.provide(Layer.succeed(References.MinimumLogLevel, config.logLevel)),
110 );
111 return yield* ProjectService.ProjectService.pipe(
112 Effect.flatMap((projects) => projects.snapshot),
113 Effect.provide(layer),
114 );
115 });
116
117it.effect("adds, renames, and removes projects through the V2 project CLI domain", () =>
118 Effect.gen(function* () {
119 const baseDir = NodeFS.mkdtempSync(NodePath.join(NodeOS.tmpdir(), "t3-v2-project-cli-"));
120 const workspaceRoot = NodeFS.mkdtempSync(
121 NodePath.join(NodeOS.tmpdir(), "t3-v2-project-workspace-"),
122 );
123
124 yield* runCli(["project", "add", workspaceRoot, "--title", "Alpha", "--base-dir", baseDir]);
125 const added = (yield* readProjects(baseDir)).projects[0];
126 assert.equal(added?.title, "Alpha");
127 assert.equal(added?.workspaceRoot, workspaceRoot);
128
129 yield* runCli(["project", "rename", workspaceRoot, "Beta", "--base-dir", baseDir]);
130 assert.equal((yield* readProjects(baseDir)).projects[0]?.title, "Beta");
131
132 yield* runCli(["project", "remove", added?.id ?? "", "--base-dir", baseDir]);
133 assert.deepEqual((yield* readProjects(baseDir)).projects, []);
134 }).pipe(Effect.provide(Layer.mergeAll(NodeServices.layer, NodeCrypto.layer))),
135);
136
137it.effect.each(["snapshot", "mutation"] as const)(
138 "waits for a busy live server's %s response",
139 (slowRequest) =>
140 Effect.gen(function* () {
141 const fs = yield* FileSystem.FileSystem;
142 const root = yield* fs.makeTempDirectoryScoped({ prefix: "t3-live-project-cli-" });
143 const baseDir = NodePath.join(root, "state");
144 const workspaceRoot = NodePath.join(root, "workspace");
145 yield* fs.makeDirectory(workspaceRoot);
146 yield* persistServerRuntimeState({
147 path: NodePath.join(baseDir, "userdata", "server-runtime.json"),
148 state: yield* makePersistedServerRuntimeState({
149 config: { host: "127.0.0.1", devUrl: undefined },
150 port: 3_773,
151 }),
152 });
153 const now = "2026-01-01T00:00:00.000Z";
154 const requestReceived = Promise.withResolvers<void>();
155 const releaseResponse = Promise.withResolvers<void>();
156 let snapshotRequests = 0;
157 let mutations = 0;
158 const fetch: typeof globalThis.fetch = async (_input, init) => {
159 const isMutation = init?.method === "POST";
160 if (isMutation) mutations++;
161 else snapshotRequests++;
162 if (slowRequest === "mutation" ? isMutation : !isMutation && snapshotRequests === 2) {
163 requestReceived.resolve();
164 await releaseResponse.promise;
165 }
166 return Response.json(
167 isMutation
168 ? {
169 id: "live-project",
170 title: NodePath.basename(workspaceRoot),
171 workspaceRoot,
172 defaultModelSelection: null,
173 scripts: [],
174 createdAt: now,
175 updatedAt: now,
176 deletedAt: null,
177 }
178 : { projects: [], updatedAt: now },
179 );
180 };
181
182 const add = yield* runCli(["project", "add", workspaceRoot, "--base-dir", baseDir]).pipe(
183 Effect.provideService(FetchHttpClient.Fetch, fetch),
184 Effect.forkChild,
185 );
186 yield* Effect.promise(() => requestReceived.promise);
187 yield* TestClock.adjust("2 seconds");
188 releaseResponse.resolve();
189 yield* Fiber.join(add);
190
191 assert.equal(snapshotRequests, 2);
192 assert.equal(mutations, 1);
193 assert.deepEqual((yield* readProjects(baseDir)).projects, []);
194 }).pipe(Effect.provide(NodeServices.layer), Effect.scoped),
195);
196
197it.effect("does not send a token to whatever took over a dead server's port", () =>
198 Effect.gen(function* () {
199 const fs = yield* FileSystem.FileSystem;
200 const root = yield* fs.makeTempDirectoryScoped({ prefix: "t3-dead-project-cli-" });
201 const baseDir = NodePath.join(root, "state");
202 const workspaceRoot = NodePath.join(root, "workspace");
203 yield* fs.makeDirectory(workspaceRoot);
204 const state = yield* makePersistedServerRuntimeState({
205 config: { host: "127.0.0.1", devUrl: undefined },
206 port: 3_773,
207 });
208 yield* persistServerRuntimeState({
209 path: NodePath.join(baseDir, "userdata", "server-runtime.json"),
210 // Above Linux's PID ceiling, as in pair.test.ts: no process can hold it.
211 state: { ...state, pid: 4_194_305 },
212 });
213 let requests = 0;
214 const fetch: typeof globalThis.fetch = async () => {
215 requests++;
216 return Response.json({ projects: [], updatedAt: "2026-01-01T00:00:00.000Z" });
217 };
218
219 yield* runCli(["project", "add", workspaceRoot, "--base-dir", baseDir]).pipe(
220 Effect.provideService(FetchHttpClient.Fetch, fetch),
221 );
222
223 assert.equal(requests, 0);
224 assert.equal((yield* readProjects(baseDir)).projects[0]?.workspaceRoot, workspaceRoot);
225 }).pipe(Effect.provide(NodeServices.layer), Effect.scoped),
226);
227
228const makeProjectLookupFixture = Effect.fn("ProjectCliTest.makeProjectLookupFixture")(function* () {
229 const fs = yield* FileSystem.FileSystem;
230 const root = yield* fs.makeTempDirectoryScoped({ prefix: "t3-v2-project-lookup-" });
231 const baseDir = NodePath.join(root, "state");
232 const workspaceRoot = NodePath.join(root, "workspace");
233 yield* fs.makeDirectory(workspaceRoot);
234 yield* runCli(["project", "add", workspaceRoot, "--base-dir", baseDir]);
235 const project = (yield* readProjects(baseDir)).projects[0];
236 assert.isDefined(project);
237 return { baseDir, workspaceRoot, project: project! };
238});
239
240const makeThreadPersistenceLayer = Effect.fn("ProjectCliTest.makeThreadPersistenceLayer")(
241 function* (baseDir: string) {
242 const config = yield* makeConfig(baseDir);
243 return Layer.mergeAll(
244 RuntimeLayer.layerEventSink,
245 ProjectionStore.layer,
246 EventStore.layer,
247 ).pipe(
248 Layer.provideMerge(SqlitePersistence.layerConfig),
249 Layer.provideMerge(Layer.mergeAll(NodeServices.layer, NodeCrypto.layer)),
250 Layer.provide(ServerConfig.layer(config)),
251 Layer.provide(Layer.succeed(References.MinimumLogLevel, config.logLevel)),
252 );
253 },
254);
255
256const seedNativeThreads = Effect.fn("ProjectCliTest.seedNativeThreads")(function* (
257 baseDir: string,
258 threads: ReadonlyArray<{
259 readonly id: ThreadId;
260 readonly projectId: ProjectId;
261 readonly archived: boolean;
262 }>,
263) {
264 const layer = yield* makeThreadPersistenceLayer(baseDir);
265 const createdAt = DateTime.makeUnsafe("2026-09-04T12:00:00.000Z");
266 const providerInstanceId = ProviderInstanceId.make("codex");
267 yield* Effect.gen(function* () {
268 const eventSink = yield* EventSink.EventSinkV2;
269 yield* eventSink.write({
270 commandId: CommandId.make("project-cli-seed-threads"),
271 events: threads.map(({ id, projectId, archived }) => {
272 const payload: OrchestrationV2AppThread = {
273 createdBy: "user",
274 creationSource: "web",
275 id,
276 projectId,
277 title: id,
278 providerInstanceId,
279 modelSelection: { instanceId: providerInstanceId, model: "gpt-5" },
280 runtimeMode: "full-access",
281 interactionMode: "default",
282 branch: null,
283 worktreePath: null,
284 activeProviderThreadId: null,
285 lineage: { parentThreadId: null, relationshipToParent: null, rootThreadId: id },
286 forkedFrom: null,
287 createdAt,
288 updatedAt: createdAt,
289 archivedAt: archived ? createdAt : null,
290 settledOverride: null,
291 settledAt: null,
292 lastVisitedAt: null,
293 deletedAt: null,
294 };
295 return {
296 id: EventId.make(`project-cli-create-${id}`),
297 type: "thread.created" as const,
298 threadId: id,
299 providerInstanceId,
300 occurredAt: createdAt,
301 payload,
302 };
303 }),
304 });
305 }).pipe(Effect.provide(layer));
306});
307
308const readNativeThreadState = Effect.fn("ProjectCliTest.readNativeThreadState")(function* (
309 baseDir: string,
310 threadId: ThreadId,
311) {
312 const layer = yield* makeThreadPersistenceLayer(baseDir);
313 return yield* Effect.gen(function* () {
314 const projections = yield* ProjectionStore.ProjectionStoreV2;
315 const events = yield* EventStore.EventStoreV2;
316 return {
317 thread: yield* projections.getThread(threadId),
318 events: yield* events.read({ threadId }).pipe(Stream.runCollect),
319 };
320 }).pipe(Effect.provide(layer));
321});
322
323it.layer(Layer.mergeAll(NodeServices.layer, NodeCrypto.layer))(
324 "project deletion with native V2 threads",
325 (it) => {
326 it.effect.each([
327 { label: "an active thread", archived: false, missing: false },
328 {
329 label: "an archived thread after its workspace disappears",
330 archived: true,
331 missing: true,
332 },
333 ])("rejects unforced removal of a project with $label", ({ archived, missing }) =>
334 Effect.gen(function* () {
335 const fs = yield* FileSystem.FileSystem;
336 const { baseDir, workspaceRoot, project } = yield* makeProjectLookupFixture();
337 const threadId = ThreadId.make("project-cli-preserved-thread");
338 yield* seedNativeThreads(baseDir, [{ id: threadId, projectId: project.id, archived }]);
339 const before = yield* readNativeThreadState(baseDir, threadId);
340 if (missing) yield* fs.rename(workspaceRoot, `${workspaceRoot}-removed`);
341
342 const error = yield* runCli([
343 "project",
344 "remove",
345 missing ? workspaceRoot : project.id,
346 "--base-dir",
347 baseDir,
348 ]).pipe(
349 Effect.match({
350 onFailure: (error) => error,
351 onSuccess: () => assert.fail("Removing a nonempty project must require --force."),
352 }),
353 );
354
355 assert.include(error.message, "not empty");
356 assert.deepEqual(
357 (yield* readProjects(baseDir)).projects.map((entry) => entry.id),
358 [project.id],
359 );
360 assert.deepEqual(yield* readNativeThreadState(baseDir, threadId), before);
361 assert.equal(yield* fs.exists(workspaceRoot), !missing);
362 }),
363 );
364
365 it.effect.each(["present", "missing"] as const)(
366 "force-removes active and archived V2 threads with the workspace %s, preserving unrelated projects",
367 (workspace) =>
368 Effect.gen(function* () {
369 const fs = yield* FileSystem.FileSystem;
370 const { baseDir, workspaceRoot, project } = yield* makeProjectLookupFixture();
371 const otherWorkspace = `${workspaceRoot}-other`;
372 yield* fs.makeDirectory(otherWorkspace);
373 yield* runCli(["project", "add", otherWorkspace, "--base-dir", baseDir]);
374 const otherProject = (yield* readProjects(baseDir)).projects.find(
375 (entry) => entry.workspaceRoot === otherWorkspace,
376 );
377 assert.isDefined(otherProject);
378 const activeId = ThreadId.make("project-cli-deleted-active");
379 const archivedId = ThreadId.make("project-cli-deleted-archived");
380 const unrelatedId = ThreadId.make("project-cli-unrelated-thread");
381 yield* seedNativeThreads(baseDir, [
382 { id: activeId, projectId: project.id, archived: false },
383 { id: archivedId, projectId: project.id, archived: true },
384 { id: unrelatedId, projectId: otherProject!.id, archived: false },
385 ]);
386 const unrelatedBefore = yield* readNativeThreadState(baseDir, unrelatedId);
387 if (workspace === "missing") {
388 yield* fs.rename(workspaceRoot, `${workspaceRoot}-removed`);
389 }
390
391 yield* runCli([
392 "project",
393 "remove",
394 workspace === "missing" ? workspaceRoot : project.id,
395 "--force",
396 "--base-dir",
397 baseDir,
398 ]);
399
400 assert.deepEqual(
401 (yield* readProjects(baseDir)).projects.map((entry) => entry.id),
402 [otherProject!.id],
403 );
404 for (const threadId of [activeId, archivedId]) {
405 const state = yield* readNativeThreadState(baseDir, threadId);
406 assert.isNotNull(state.thread.deletedAt);
407 assert.lengthOf(
408 state.events.filter((record) => record.event.type === "thread.deleted"),
409 1,
410 );
411 }
412 assert.deepEqual(yield* readNativeThreadState(baseDir, unrelatedId), unrelatedBefore);
413 assert.equal(yield* fs.exists(workspaceRoot), workspace === "present");
414 assert.isTrue(yield* fs.exists(otherWorkspace));
415 }),
416 );
417 },
418);
419
420it.layer(Layer.mergeAll(NodeServices.layer, NodeCrypto.layer))(
421 "project lookup with unavailable workspaces",
422 (it) => {
423 it.effect.each([
424 "id",
425 "stored path",
426 "relative path",
427 "path with a trailing separator",
428 ] as const)("removes an empty project by %s after its directory is gone", (identifier) =>
429 Effect.gen(function* () {
430 const fs = yield* FileSystem.FileSystem;
431 const { baseDir, workspaceRoot, project } = yield* makeProjectLookupFixture();
432 yield* fs.rename(workspaceRoot, `${workspaceRoot}-removed`);
433 const target = {
434 id: project.id,
435 "stored path": workspaceRoot,
436 "relative path": NodePath.relative(process.cwd(), workspaceRoot),
437 "path with a trailing separator": `${workspaceRoot}${NodePath.sep}`,
438 }[identifier];
439 yield* runCli(["project", "remove", target, "--base-dir", baseDir]);
440 assert.deepEqual((yield* readProjects(baseDir)).projects, []);
441 assert.isFalse(yield* fs.exists(workspaceRoot));
442 }),
443 );
444
445 it.effect("does not resolve another environment's project ID in an empty database", () =>
446 Effect.gen(function* () {
447 const fs = yield* FileSystem.FileSystem;
448 const { baseDir, workspaceRoot, project } = yield* makeProjectLookupFixture();
449 yield* fs.rename(workspaceRoot, `${workspaceRoot}-removed`);
450 const replacementDir = yield* fs.makeTempDirectoryScoped({
451 prefix: "t3-v2-project-empty-",
452 });
453 const error = yield* runCli([
454 "project",
455 "remove",
456 project.id,
457 "--force",
458 "--base-dir",
459 replacementDir,
460 ]).pipe(Effect.flip);
461 assert.include(error.message, "No active project found");
462 assert.deepEqual(
463 (yield* readProjects(baseDir)).projects.map((entry) => entry.id),
464 [project.id],
465 );
466 assert.deepEqual((yield* readProjects(replacementDir)).projects, []);
467 }),
468 );
469
470 it.effect("normalizes existing paths without conflating separately registered symlinks", () =>
471 Effect.gen(function* () {
472 const { baseDir, workspaceRoot, project } = yield* makeProjectLookupFixture();
473 yield* runCli([
474 "project",
475 "rename",
476 `${workspaceRoot}${NodePath.sep}.`,
477 "Normalized",
478 "--base-dir",
479 baseDir,
480 ]);
481 assert.equal((yield* readProjects(baseDir)).projects[0]?.title, "Normalized");
482 const aliasPath = `${workspaceRoot}-alias`;
483 NodeFS.symlinkSync(workspaceRoot, aliasPath, "junction");
484 const unknownAlias = yield* runCli([
485 "project",
486 "remove",
487 aliasPath,
488 "--base-dir",
489 baseDir,
490 ]).pipe(Effect.flip);
491 assert.include(unknownAlias.message, "No active project found");
492 yield* runCli(["project", "add", aliasPath, "--base-dir", baseDir]);
493 const added = (yield* readProjects(baseDir)).projects;
494 assert.equal(added.length, 2);
495 const aliasProject = added.find((entry) => entry.workspaceRoot === aliasPath);
496 assert.isDefined(aliasProject);
497 assert.notEqual(aliasProject?.id, project.id);
498 yield* runCli(["project", "remove", `${aliasPath}${NodePath.sep}.`, "--base-dir", baseDir]);
499 assert.deepEqual(
500 (yield* readProjects(baseDir)).projects.map((entry) => entry.id),
501 [project.id],
502 );
503 assert.isTrue(NodeFS.existsSync(workspaceRoot));
504 }),
505 );
506 },
507);