@devries-cameron20 / t3code Mirror · read-only / commits / f7bef383b1
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 22, 23:15 UTC

fix(server): bare repositories now group with projects of the same remote (#17340)

Co-authored-by: Claude Opus 5.5 <noreply@anthropic.com> Co-authored-by: Julius Marminge <julius0216@outlook.com>

Shrikant Kalar committed Oct 20, 2026 at 10:26 UTC f7bef383b1321d8ae4774f004b465ff208b0d57d
3 files changed +168 -26
apps/server/src/project/RepositoryIdentityResolver.test.ts
+111 -17
@@ -130,22 +130,20 @@ it.layer(NodeServices.layer)("RepositoryIdentityResolverLive", (it) => {
130 });
131
132 it.effect("retries Git root discovery after the negative TTL", () => {
133 - const calls: Array<ReadonlyArray<string>> = [];
134 - let rootAttempts = 0;
133 + let attempts = 0;
134 + let unavailable = true;
135 const layerProcessRunner = Layer.succeed(ProcessRunner.ProcessRunner, {
136 run: (input) =>
137 Effect.sync(() => {
138 - calls.push(input.args);
139 - const rootLookup = input.args.includes("rev-parse");
140 - const failed = rootLookup && rootAttempts++ === 0;
138 + attempts++;
139 return {
142 - stdout: rootLookup
143 - ? failed
144 - ? ""
145 - : "/repo\n"
146 - : "origin\tgit@github.com:T3Tools/t3code.git (fetch)\n",
147 - stderr: failed ? "temporary Git failure" : "",
148 - code: ChildProcessSpawner.ExitCode(failed ? 1 : 0),
140 + stdout: unavailable
141 + ? ""
142 + : input.args.includes("remote")
143 + ? "origin\tgit@github.com:T3Tools/t3code.git (fetch)\n"
144 + : "/repo\n",
145 + stderr: unavailable ? "temporary Git failure" : "",
146 + code: ChildProcessSpawner.ExitCode(unavailable ? 1 : 0),
147 timedOut: false,
148 stdoutTruncated: false,
149 stderrTruncated: false,
@@ -162,22 +160,63 @@ it.layer(NodeServices.layer)("RepositoryIdentityResolverLive", (it) => {
160 return Effect.gen(function* () {
161 const resolver = yield* RepositoryIdentityResolver.RepositoryIdentityResolver;
162 expect(yield* resolver.resolve("/repo/packages/web")).toBeNull();
163 + const failedAttempts = attempts;
164 + unavailable = false;
165 expect(yield* resolver.resolve("/repo/packages/web")).toBeNull();
166 + expect(attempts).toBe(failedAttempts);
167
168 yield* TestClock.adjust(Duration.minutes(1));
169 const recovered = yield* resolver.resolve("/repo/packages/web");
170 expect(recovered?.rootPath).toBe("/repo");
170 - expect(calls).toEqual([
171 - ["-C", "/repo/packages/web", "rev-parse", "--show-toplevel"],
172 - ["-C", "/repo/packages/web", "rev-parse", "--show-toplevel"],
173 - ["-C", "/repo", "remote", "-v"],
174 - ]);
171 + expect(recovered?.canonicalKey).toBe("github.com/t3tools/t3code");
172 }).pipe(Effect.provide(Layer.merge(TestClock.layer(), layerResolver)));
173 });
174
175 + it.effect.each(["times out", "cannot start"] as const)(
176 + "skips the bare repository probe when Git root discovery %s",
177 + (failure) => {
178 + let attempts = 0;
179 + const layerProcessRunner = Layer.succeed(ProcessRunner.ProcessRunner, {
180 + run: (input) =>
181 + Effect.suspend(() => {
182 + attempts++;
183 + return failure === "times out"
184 + ? Effect.succeed({
185 + stdout: "",
186 + stderr: "",
187 + code: null,
188 + timedOut: true,
189 + stdoutTruncated: false,
190 + stderrTruncated: false,
191 + stdoutInvalidUtf8: false,
192 + stderrInvalidUtf8: false,
193 + })
194 + : Effect.fail(
195 + new ProcessRunner.ProcessSpawnError({
196 + command: input.command,
197 + argumentCount: input.args.length,
198 + cause: new Error("git is not installed"),
199 + }),
200 + );
201 + }),
202 + });
203 + const layerResolver = Layer.effect(
204 + RepositoryIdentityResolver.RepositoryIdentityResolver,
205 + RepositoryIdentityResolver.make(),
206 + ).pipe(Layer.provide(layerProcessRunner));
207 +
208 + return Effect.gen(function* () {
209 + const resolver = yield* RepositoryIdentityResolver.RepositoryIdentityResolver;
210 + expect(yield* resolver.resolve("/repo")).toBeNull();
211 + expect(attempts).toBe(1);
212 + }).pipe(Effect.provide(layerResolver));
213 + },
214 + );
215 +
216 it.effect("normalizes equivalent GitHub remotes into a stable repository identity", () =>
217 Effect.gen(function* () {
218 const fileSystem = yield* FileSystem.FileSystem;
219 + const path = yield* Path.Path;
220 const cwd = yield* fileSystem.makeTempDirectoryScoped({
221 prefix: "t3-repository-identity-test-",
222 });
@@ -200,6 +239,7 @@ it.layer(NodeServices.layer)("RepositoryIdentityResolverLive", (it) => {
239 expect(identity?.provider).toBe("github");
240 expect(identity?.owner).toBe("T3Tools");
241 expect(identity?.name).toBe("t3code");
242 + expect(yield* resolver.resolve(path.join(cwd, ".git"))).toBeNull();
243 }).pipe(Effect.provide(RepositoryIdentityResolver.layer)),
244 );
245
@@ -254,6 +294,60 @@ it.layer(NodeServices.layer)("RepositoryIdentityResolverLive", (it) => {
294 }).pipe(Effect.provide(RepositoryIdentityResolver.layer)),
295 );
296
297 + it.effect.each(["bare clone", "dot-bare"] as const)(
298 + "resolves a %s to its Git directory and the same identity as a checkout",
299 + (layout) =>
300 + Effect.gen(function* () {
301 + const fileSystem = yield* FileSystem.FileSystem;
302 + const path = yield* Path.Path;
303 + const checkout = yield* fileSystem.makeTempDirectoryScoped({
304 + prefix: "t3-repository-identity-checkout-",
305 + });
306 + const root = yield* fileSystem.makeTempDirectoryScoped({
307 + prefix: "t3-repository-identity-bare-",
308 + });
309 + const bareGitDir = layout === "dot-bare" ? path.join(root, ".bare") : root;
310 +
311 + yield* git(checkout, ["init"]);
312 + yield* git(checkout, ["remote", "add", "origin", "git@github.com:T3Tools/t3code.git"]);
313 + yield* git(root, ["init", "--bare", bareGitDir]);
314 + if (layout === "dot-bare") {
315 + yield* fileSystem.writeFileString(path.join(root, ".git"), "gitdir: ./.bare\n");
316 + }
317 + yield* git(root, [
318 + "--git-dir",
319 + bareGitDir,
320 + "remote",
321 + "add",
322 + "origin",
323 + "https://github.com/T3Tools/t3code.git",
324 + ]);
325 +
326 + const resolver = yield* RepositoryIdentityResolver.RepositoryIdentityResolver;
327 + const checkoutIdentity = yield* resolver.resolve(checkout);
328 + expect(checkoutIdentity?.canonicalKey).toBe("github.com/t3tools/t3code");
329 + const resolvedBareGitDir = NodeFS.realpathSync.native(bareGitDir);
330 + const projectRoots = layout === "dot-bare" ? [root, bareGitDir] : [root];
331 +
332 + for (const projectRoot of projectRoots) {
333 + const identity = yield* resolver.resolve(projectRoot);
334 + const resolvedIdentityRoot =
335 + identity?.rootPath === undefined ? "" : NodeFS.realpathSync.native(identity.rootPath);
336 +
337 + expect(identity).not.toBeNull();
338 + expect(identity?.canonicalKey).toBe(checkoutIdentity?.canonicalKey);
339 + expect(normalizeResolvedPath(resolvedIdentityRoot)).toBe(
340 + normalizeResolvedPath(resolvedBareGitDir),
341 + );
342 + }
343 +
344 + yield* git(root, ["--git-dir", bareGitDir, "remote", "remove", "origin"]);
345 + for (const projectRoot of projectRoots) {
346 + expect(yield* resolver.resolve(projectRoot, { refresh: true })).toBeNull();
347 + }
348 + }).pipe(Effect.provide(RepositoryIdentityResolver.layer)),
349 + );
350 +
351 it.effect("returns null for non-git folders and repos without remotes", () =>
352 Effect.gen(function* () {
353 const fileSystem = yield* FileSystem.FileSystem;
apps/server/src/project/RepositoryIdentityResolver.ts
+56 -9
@@ -6,6 +6,7 @@ import {
6 } from "@t3tools/shared/git";
7 import * as Cache from "effect/Cache";
8 import * as Context from "effect/Context";
9 +import * as Data from "effect/Data";
10 import * as Duration from "effect/Duration";
11 import * as Effect from "effect/Effect";
12 import * as Exit from "effect/Exit";
@@ -137,9 +138,15 @@ function buildRepositoryIdentity(input: {
138 };
139 }
140
141 +class RepositoryIdentityCacheKey extends Data.Class<{
142 + readonly rootPath: string;
143 + readonly isBare: boolean;
144 +}> {}
145 +
146 const resolveRepositoryIdentityCacheKey = Effect.fn("RepositoryIdentityResolver.resolveCacheKey")(
147 function* (cwd: string) {
148 const processRunner = yield* ProcessRunner.ProcessRunner;
149 + const env = explicitBareRepositoryEnv(process.env, yield* HostProcess.Platform);
150
151 // git is a real executable on every platform — no cmd.exe shell mode, which
152 // would split paths containing spaces during cmd's re-tokenization.
@@ -147,29 +154,62 @@ const resolveRepositoryIdentityCacheKey = Effect.fn("RepositoryIdentityResolver.
154 .run({
155 command: "git",
156 args: ["-C", cwd, "rev-parse", "--show-toplevel"],
150 - env: explicitBareRepositoryEnv(process.env, yield* HostProcess.Platform),
157 + env,
158 timeoutBehavior: "timedOutResult",
159 })
160 .pipe(Effect.option);
154 - if (topLevelResult._tag === "None" || topLevelResult.value.code !== 0) {
161 + if (topLevelResult._tag === "None" || topLevelResult.value.timedOut) {
162 return null;
163 }
164 + if (topLevelResult.value.code === 0) {
165 + const rootPath = topLevelResult.value.stdout.trim();
166 + return rootPath.length > 0
167 + ? new RepositoryIdentityCacheKey({ rootPath, isBare: false })
168 + : null;
169 + }
170 +
171 + // Explicit Git directories preserve safe.bareRepository=explicit for both layouts.
172 + for (const gitDir of [".", ".git"]) {
173 + const bareResult = yield* processRunner
174 + .run({
175 + command: "git",
176 + args: [
177 + "-C",
178 + cwd,
179 + `--git-dir=${gitDir}`,
180 + "rev-parse",
181 + "--is-bare-repository",
182 + "--absolute-git-dir",
183 + ],
184 + env,
185 + timeoutBehavior: "timedOutResult",
186 + })
187 + .pipe(Effect.option);
188 + if (bareResult._tag === "None" || bareResult.value.timedOut) return null;
189 + if (bareResult.value.code !== 0) continue;
190
158 - const candidate = topLevelResult.value.stdout.trim();
159 - return candidate.length > 0 ? candidate : null;
191 + const [isBare, rootPath = ""] = bareResult.value.stdout
192 + .split("\n")
193 + .map((line) => line.trim());
194 + // A checkout's .git directory contains remotes but is not a project root.
195 + return isBare === "true" && rootPath.length > 0
196 + ? new RepositoryIdentityCacheKey({ rootPath, isBare: true })
197 + : null;
198 + }
199 + return null;
200 },
201 );
202
203 const resolveRepositoryIdentityFromCacheKey = Effect.fn(
204 "RepositoryIdentityResolver.resolveFromCacheKey",
205 )(function* (
166 - cacheKey: string,
206 + cacheKey: RepositoryIdentityCacheKey,
207 ): Effect.fn.Return<RepositoryIdentity | null, never, ProcessRunner.ProcessRunner> {
208 const processRunner = yield* ProcessRunner.ProcessRunner;
209 const remoteResult = yield* processRunner
210 .run({
211 command: "git",
172 - args: ["-C", cacheKey, "remote", "-v"],
212 + args: ["-C", cacheKey.rootPath, ...(cacheKey.isBare ? ["--git-dir=."] : []), "remote", "-v"],
213 env: explicitBareRepositoryEnv(process.env, yield* HostProcess.Platform),
214 timeoutBehavior: "timedOutResult",
215 })
@@ -181,7 +221,11 @@ const resolveRepositoryIdentityFromCacheKey = Effect.fn(
221 const remotes = parseRemoteFetchUrls(remoteResult.value.stdout);
222 const remote = pickPrimaryRemote(remotes);
223 return remote
184 - ? buildRepositoryIdentity({ ...remote, originUrl: remotes.get("origin"), rootPath: cacheKey })
224 + ? buildRepositoryIdentity({
225 + ...remote,
226 + originUrl: remotes.get("origin"),
227 + rootPath: cacheKey.rootPath,
228 + })
229 : null;
230 });
231
@@ -200,7 +244,7 @@ export const make = Effect.fn("RepositoryIdentityResolver.make")(function* (
244 onFailure: () => Duration.zero,
245 });
246
203 - const repositoryRootCache = yield* Cache.makeWith<string, string | null>(
247 + const repositoryRootCache = yield* Cache.makeWith<string, RepositoryIdentityCacheKey | null>(
248 (cwd) =>
249 resolveRepositoryIdentityCacheKey(cwd).pipe(
250 Effect.provideService(ProcessRunner.ProcessRunner, processRunner),
@@ -208,7 +252,10 @@ export const make = Effect.fn("RepositoryIdentityResolver.make")(function* (
252 { capacity: cacheCapacity, timeToLive },
253 );
254
211 - const repositoryIdentityCache = yield* Cache.makeWith<string, RepositoryIdentity | null>(
255 + const repositoryIdentityCache = yield* Cache.makeWith<
256 + RepositoryIdentityCacheKey,
257 + RepositoryIdentity | null
258 + >(
259 (cacheKey) =>
260 resolveRepositoryIdentityFromCacheKey(cacheKey).pipe(
261 Effect.provideService(ProcessRunner.ProcessRunner, processRunner),
packages/contracts/src/environment.ts
+1
@@ -180,6 +180,7 @@ export const RepositoryIdentity = Schema.Struct({
180 canonicalKey: TrimmedNonEmptyString,
181 locator: RepositoryIdentityLocator,
182 webUrl: Schema.optionalKey(TrimmedNonEmptyString),
183 + /** Work tree root, or the git dir for a bare repository. */
184 rootPath: Schema.optionalKey(TrimmedNonEmptyString),
185 displayName: Schema.optionalKey(TrimmedNonEmptyString),
186 provider: Schema.optionalKey(TrimmedNonEmptyString),