@devries-cameron20 / t3code Mirror · read-only
Fork 0

The best way to control Claude Code, Codex and more from any computer or phone

Mirrored from https://github.com/Camo67/t3code.git

Synced Nov 21, 03:37 UTC

main
ts 196 lines 7.49 KB
Raw
1 import * as NodeCrypto from "@effect/platform-node/NodeCrypto";
2 import * as NodeServices from "@effect/platform-node/NodeServices";
3 import * as McpProviderSessions from "@t3tools/provider-core/server/McpProviderSessions";
4 import { assert, it } from "@effect/vitest";
5 import { ProjectId } from "@t3tools/contracts";
6 import * as Effect from "effect/Effect";
7 import * as FileSystem from "effect/FileSystem";
8 import * as Layer from "effect/Layer";
9 import * as Path from "effect/Path";
10 import * as Schema from "effect/Schema";
11 import * as Stream from "effect/Stream";
12 import * as SqlClient from "effect/sql/SqlClient";
13
14 import * as CheckpointStore from "../checkpointing/CheckpointStore.ts";
15 import * as ServerConfig from "../config.ts";
16 import * as GitWorkflow from "../git/GitWorkflowService.ts";
17 import * as NodeSqliteClient from "@t3tools/shared/nodeSqliteClient";
18
19 import * as McpSessionRegistryTestkit from "../mcp/McpSessionRegistry.testkit.ts";
20 import * as SqlitePersistence from "../persistence/Sqlite.ts";
21 import { runMigrations } from "../persistence/Migrations.ts";
22 import * as ProjectEnrichmentService from "../project/ProjectEnrichmentService.ts";
23 import * as ProjectService from "../project/ProjectService.ts";
24 import * as ModelManifest from "../provider/ModelManifest.ts";
25 import * as ProviderInstanceRegistry from "../provider/ProviderInstanceRegistry.ts";
26 import * as ServerSettings from "../serverSettings.ts";
27 import * as SourceControlProviderRegistry from "../sourceControl/SourceControlProviderRegistry.ts";
28 import * as VcsDriverRegistry from "../vcs/VcsDriverRegistry.ts";
29 import * as VcsProcess from "../vcs/VcsProcess.ts";
30 import * as WorkspacePaths from "../workspace/WorkspacePaths.ts";
31 import * as LegacyV1ThreadImporter from "./legacy/LegacyV1ThreadImporter.ts";
32 import * as RuntimeLayer from "./runtimeLayer.ts";
33
34 const projectId = ProjectId.make("project:upgrade");
35 const icon = { kind: "emoji", emoji: "🦊" } as const;
36 const encodeJson = Schema.encodeSync(Schema.fromJsonString(Schema.Unknown));
37
38 const expectedSettings = {
39 default_thread_env_mode: "worktree",
40 auto_pull: 1,
41 favicon_path: "brand/icon.svg",
42 project_icon_json: encodeJson(icon),
43 };
44
45 const readSettings = Effect.gen(function* () {
46 const sql = yield* SqlClient.SqlClient;
47 const rows = yield* sql<typeof expectedSettings>`
48 SELECT default_thread_env_mode, auto_pull, favicon_path, project_icon_json
49 FROM projection_projects
50 WHERE project_id = ${projectId}
51 `;
52 return rows[0];
53 });
54
55 const seedV1Database = Effect.gen(function* () {
56 const sql = yield* SqlClient.SqlClient;
57 yield* runMigrations({ toMigrationInclusive: 54 });
58 const events = [
59 {
60 type: "project.created",
61 payload: {
62 projectId,
63 title: "Upgrade",
64 workspaceRoot: "/work/upgrade",
65 defaultModelSelection: null,
66 faviconPath: null,
67 projectIcon: null,
68 scripts: [],
69 createdAt: "2026-01-01T00:00:00.000Z",
70 updatedAt: "2026-01-01T00:00:00.000Z",
71 },
72 },
73 {
74 type: "project.meta-updated",
75 payload: {
76 projectId,
77 defaultThreadEnvMode: "worktree",
78 autoPull: true,
79 faviconPath: "brand/icon.svg",
80 projectIcon: icon,
81 updatedAt: "2026-01-02T00:00:00.000Z",
82 },
83 },
84 ] as const;
85 for (const [version, event] of events.entries()) {
86 yield* sql`
87 INSERT INTO orchestration_events (
88 event_id, aggregate_kind, stream_id, stream_version, event_type, occurred_at,
89 command_id, causation_event_id, correlation_id, actor_kind, payload_json, metadata_json
90 ) VALUES (
91 ${`v1:${event.type}`}, 'project', ${projectId}, ${version}, ${event.type},
92 ${event.payload.updatedAt}, ${`command:${event.type}`}, NULL, ${`command:${event.type}`},
93 'client', ${encodeJson(event.payload)}, '{}'
94 )
95 `;
96 }
97 yield* sql`
98 INSERT INTO projection_projects (
99 project_id, title, workspace_root, default_model_selection_json, default_thread_env_mode,
100 auto_pull, favicon_path, project_icon_json, scripts_json, created_at, updated_at, deleted_at
101 ) VALUES (
102 ${projectId}, 'Upgrade', '/work/upgrade', NULL, ${expectedSettings.default_thread_env_mode},
103 1, ${expectedSettings.favicon_path}, ${expectedSettings.project_icon_json}, '[]',
104 '2026-01-01T00:00:00.000Z', '2026-01-02T00:00:00.000Z', NULL
105 )
106 `;
107 yield* sql`
108 INSERT INTO projection_state (projector, last_applied_sequence, updated_at)
109 VALUES ('projection.projects', 2, '2026-01-02T00:00:00.000Z')
110 `;
111 });
112
113 const unusedEnrichment = {
114 repositoryIdentity: null,
115 faviconPath: null,
116 repositoryIdentityResolved: false,
117 };
118
119 const layerRuntime = (dbPath: string) => {
120 const layerPlatform = Layer.merge(
121 Layer.mergeAll(NodeServices.layer, NodeCrypto.layer),
122 Layer.mock(SourceControlProviderRegistry.SourceControlProviderRegistry)({
123 resolveLink: () => Effect.die("unused"),
124 }),
125 );
126 const layerServerConfig = ServerConfig.layerTest(process.cwd(), {
127 prefix: "t3-project-upgrade-",
128 });
129 const layerCheckpointStore = CheckpointStore.layer.pipe(
130 Layer.provide(
131 VcsDriverRegistry.layer.pipe(
132 Layer.provide(VcsProcess.layer),
133 Layer.provide(layerServerConfig),
134 Layer.provide(layerPlatform),
135 ),
136 ),
137 );
138 return Layer.mergeAll(
139 RuntimeLayer.layer.pipe(Layer.provide(RuntimeLayer.layerProjectService)),
140 RuntimeLayer.layerProjectService,
141 ).pipe(
142 Layer.provide(
143 Layer.mock(ProjectEnrichmentService.ProjectEnrichmentService)({
144 peek: () => Effect.succeed(unusedEnrichment),
145 getAvailable: () => Effect.succeed(unusedEnrichment),
146 invalidate: () => Effect.void,
147 }),
148 ),
149 Layer.provide(
150 Layer.mock(WorkspacePaths.WorkspacePaths)({
151 normalizeWorkspaceRoot: (workspaceRoot) => Effect.succeed(workspaceRoot),
152 }),
153 ),
154 Layer.provide(McpSessionRegistryTestkit.layer),
155 Layer.provide(McpProviderSessions.layer),
156 Layer.provideMerge(SqlitePersistence.layerFromPath(dbPath)),
157 Layer.provide(layerCheckpointStore),
158 Layer.provide(layerServerConfig),
159 Layer.provide(ServerSettings.layerTest()),
160 Layer.provide(ModelManifest.layerTest),
161 Layer.provide(
162 Layer.succeed(ProviderInstanceRegistry.ProviderInstanceRegistry, {
163 getInstance: () => Effect.undefined,
164 listInstances: Effect.succeed([]),
165 listUnavailable: Effect.succeed([]),
166 streamChanges: Stream.empty,
167 subscribeChanges: Effect.never,
168 }),
169 ),
170 Layer.provide(
171 Layer.mock(GitWorkflow.GitWorkflowService)({
172 pruneWorktrees: () => Effect.void,
173 }),
174 ),
175 Layer.provide(layerPlatform),
176 );
177 };
178
179 it.live("keeps project settings through the V2 migrations and the first V2 boot", () =>
180 Effect.scoped(
181 Effect.gen(function* () {
182 const fs = yield* FileSystem.FileSystem;
183 const path = yield* Path.Path;
184 const stateDir = yield* fs.makeTempDirectoryScoped({ prefix: "t3-project-upgrade-" });
185 const dbPath = path.join(stateDir, "statev2.sqlite");
186
187 yield* seedV1Database.pipe(Effect.provide(NodeSqliteClient.layer({ filename: dbPath })));
188 yield* Effect.gen(function* () {
189 yield* (yield* LegacyV1ThreadImporter.LegacyV1ThreadImporter).reconcileShells;
190 assert.deepEqual(yield* readSettings, expectedSettings);
191 const project = yield* (yield* ProjectService.ProjectService).getById(projectId);
192 assert.equal(project._tag, "Some");
193 }).pipe(Effect.provide(layerRuntime(dbPath)));
194 }),
195 ).pipe(Effect.provide(Layer.mergeAll(NodeServices.layer, NodeCrypto.layer))),
196 );