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
| 1 | // Client-supplied worktrees count only under managed folders or when Git lists them for the project. |
| 2 | import * as HostProcess from "@t3tools/shared/HostProcess"; |
| 3 | import * as NodeSqliteClient from "@t3tools/shared/nodeSqliteClient"; |
| 4 | import * as Context from "effect/Context"; |
| 5 | import * as Effect from "effect/Effect"; |
| 6 | import * as FileSystem from "effect/FileSystem"; |
| 7 | import * as Layer from "effect/Layer"; |
| 8 | import * as Path from "effect/Path"; |
| 9 | import * as Schema from "effect/Schema"; |
| 10 | import * as SqlClient from "effect/sql/SqlClient"; |
| 11 | |
| 12 | import * as ServerConfig from "../config.ts"; |
| 13 | import * as ProjectStore from "../orchestration-v2/ProjectStore.ts"; |
| 14 | import * as ServerSettings from "../serverSettings.ts"; |
| 15 | import * as GitVcsDriver from "../vcs/GitVcsDriver.ts"; |
| 16 | import { isFilesystemRoot, managedWorktreesDirectories } from "../worktreesDirectory.ts"; |
| 17 | |
| 18 | export class UnknownWorkspaceError extends Schema.TaggedError<UnknownWorkspaceError>()( |
| 19 | "UnknownWorkspaceError", |
| 20 | { |
| 21 | cwd: Schema.String, |
| 22 | cause: Schema.optional(Schema.Defect()), |
| 23 | }, |
| 24 | ) { |
| 25 | override get message(): string { |
| 26 | return `'${this.cwd}' is not a registered project, a managed worktree, or a thread's worktree.`; |
| 27 | } |
| 28 | } |
| 29 | |
| 30 | /** Resolve candidate and root consistently before checking containment. */ |
| 31 | export const isWithinRoot = (path: Path.Path, candidate: string, root: string) => { |
| 32 | const relative = path.relative(root, candidate); |
| 33 | return ( |
| 34 | relative === "" || |
| 35 | (relative !== ".." && !relative.startsWith(`..${path.sep}`) && !path.isAbsolute(relative)) |
| 36 | ); |
| 37 | }; |
| 38 | |
| 39 | export class KnownWorkspaces extends Context.Service< |
| 40 | KnownWorkspaces, |
| 41 | { |
| 42 | /** Takes a symlink-resolved path. */ |
| 43 | readonly contains: (realPath: string) => Effect.Effect<boolean>; |
| 44 | /** Fails unless `cwd` exists and resolves inside a known workspace. */ |
| 45 | readonly assertContains: (cwd: string) => Effect.Effect<void, UnknownWorkspaceError>; |
| 46 | } |
| 47 | >()("t3/workspace/KnownWorkspaces") {} |
| 48 | |
| 49 | /** @public */ |
| 50 | export const make = Effect.gen(function* () { |
| 51 | const config = yield* ServerConfig.ServerConfig; |
| 52 | const fileSystem = yield* FileSystem.FileSystem; |
| 53 | const path = yield* Path.Path; |
| 54 | const settings = yield* ServerSettings.ServerSettingsService; |
| 55 | const projectStore = yield* ProjectStore.ProjectStoreV2; |
| 56 | const sql = yield* SqlClient.SqlClient; |
| 57 | const git = yield* GitVcsDriver.GitVcsDriver; |
| 58 | |
| 59 | // Missing roots keep lexical paths; other resolution failures and filesystem roots grant nothing. |
| 60 | const resolveRoot = (value: string) => { |
| 61 | const resolvedPath = path.resolve(value); |
| 62 | return fileSystem.realPath(resolvedPath).pipe( |
| 63 | Effect.catchTags({ |
| 64 | PlatformError: (cause) => |
| 65 | Effect.succeed(cause.reason._tag === "NotFound" ? resolvedPath : null), |
| 66 | }), |
| 67 | Effect.map((root) => (root === null || isFilesystemRoot(root, path) ? null : root)), |
| 68 | ); |
| 69 | }; |
| 70 | |
| 71 | const contains: KnownWorkspaces["Service"]["contains"] = Effect.fn("KnownWorkspaces.contains")( |
| 72 | function* (realPath) { |
| 73 | const within = (root: string | null) => root !== null && isWithinRoot(path, realPath, root); |
| 74 | const worktreeSettings = yield* settings.getSettings.pipe( |
| 75 | Effect.orElseSucceed(() => ({ worktreesDirectory: "", previousWorktreesDirectories: [] })), |
| 76 | ); |
| 77 | const home = yield* HostProcess.HomeDirectory; |
| 78 | const managedDirectories = managedWorktreesDirectories( |
| 79 | worktreeSettings, |
| 80 | config.worktreesDir, |
| 81 | path, |
| 82 | home, |
| 83 | ); |
| 84 | const managed = (yield* Effect.forEach(managedDirectories, resolveRoot)).filter( |
| 85 | (root) => root !== null, |
| 86 | ); |
| 87 | if (managed.some(within)) return true; |
| 88 | |
| 89 | const projects = yield* projectStore.listShells().pipe(Effect.orElseSucceed(() => [])); |
| 90 | for (const project of projects) { |
| 91 | if (within(yield* resolveRoot(project.workspaceRoot))) return true; |
| 92 | } |
| 93 | |
| 94 | const threads = yield* sql<{ readonly worktreePath: string; readonly projectId: string }>` |
| 95 | SELECT DISTINCT |
| 96 | json_extract(payload_json, '$.worktreePath') AS "worktreePath", |
| 97 | project_id AS "projectId" |
| 98 | FROM orchestration_v2_projection_threads |
| 99 | WHERE deleted_at IS NULL AND json_extract(payload_json, '$.worktreePath') IS NOT NULL |
| 100 | `.pipe( |
| 101 | NodeSqliteClient.readOnly, |
| 102 | Effect.orElseSucceed(() => []), |
| 103 | ); |
| 104 | const projectWorktrees = new Map<string, ReadonlyArray<string>>(); |
| 105 | const isProjectWorktree = Effect.fnUntraced(function* ( |
| 106 | projectId: string, |
| 107 | worktreePath: string, |
| 108 | ) { |
| 109 | const project = projects.find((candidate) => candidate.id === projectId); |
| 110 | if (project === undefined) return false; |
| 111 | let listed = projectWorktrees.get(projectId); |
| 112 | if (listed === undefined) { |
| 113 | listed = yield* git.listWorktreePaths(project.workspaceRoot).pipe( |
| 114 | Effect.flatMap((paths) => Effect.forEach(paths, resolveRoot)), |
| 115 | Effect.map((paths) => paths.filter((listedPath) => listedPath !== null)), |
| 116 | Effect.orElseSucceed((): ReadonlyArray<string> => []), |
| 117 | ); |
| 118 | projectWorktrees.set(projectId, listed); |
| 119 | } |
| 120 | const real = yield* resolveRoot(worktreePath); |
| 121 | return real !== null && listed.includes(real); |
| 122 | }); |
| 123 | for (const { worktreePath, projectId } of threads) { |
| 124 | // Relative paths use server cwd; managed paths still need resolution to reject symlinks elsewhere. |
| 125 | if (!path.isAbsolute(worktreePath)) continue; |
| 126 | if (!within(yield* resolveRoot(worktreePath))) continue; |
| 127 | const lexical = path.resolve(worktreePath); |
| 128 | if (managedDirectories.some((directory) => isWithinRoot(path, lexical, directory))) { |
| 129 | return true; |
| 130 | } |
| 131 | if (yield* isProjectWorktree(projectId, worktreePath)) return true; |
| 132 | } |
| 133 | return false; |
| 134 | }, |
| 135 | ); |
| 136 | |
| 137 | const assertContains: KnownWorkspaces["Service"]["assertContains"] = Effect.fn( |
| 138 | "KnownWorkspaces.assertContains", |
| 139 | )(function* (cwd) { |
| 140 | // `..` collapses on the path as named before symlinks resolve, as the write does. |
| 141 | const realCwd = yield* fileSystem |
| 142 | .realPath(path.resolve(cwd)) |
| 143 | .pipe(Effect.mapError((cause) => new UnknownWorkspaceError({ cwd, cause }))); |
| 144 | if (!(yield* contains(realCwd))) return yield* new UnknownWorkspaceError({ cwd }); |
| 145 | }); |
| 146 | |
| 147 | return KnownWorkspaces.of({ contains, assertContains }); |
| 148 | }); |
| 149 | |
| 150 | export const layer = Layer.effect(KnownWorkspaces, make); |