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),