Skip to content

Commit 7289d4d

Browse files
committed
Merge remote-tracking branch 'origin/main' into t3/reduce-runtime-recovery-startup-cost
2 parents 8c7e34b + edc37c9 commit 7289d4d

22 files changed

Lines changed: 461 additions & 265 deletions

‎apps/marketing/src/lib/site.ts‎

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -7,6 +7,6 @@ export const ANDROID_PLAY_STORE_URL =
77
"https://play.google.com/store/apps/details?id=com.t3tools.t3code";
88

99
export const MARKETING_STATS = {
10-
githubStars: "31k+",
10+
githubStars: "40k+",
1111
users: "500,000",
1212
} as const;

‎apps/server/src/cli/claudeHistory.ts‎

Lines changed: 10 additions & 7 deletions
Original file line numberDiff line numberDiff line change
@@ -1,8 +1,6 @@
11
import * as Effect from "effect/Effect";
22
import { Argument, Command } from "effect/cli";
33

4-
import { runClaudeHistoryWorker } from "../claudeHistoryWorker.ts";
5-
64
/** Single-executable builds lack Node, so they use this subcommand instead of claudeHistoryWorker.mjs. */
75
export const claudeHistoryCommand = Command.make("__claude-history", {
86
method: Argument.String("method"),
@@ -11,11 +9,16 @@ export const claudeHistoryCommand = Command.make("__claude-history", {
119
}).pipe(
1210
Command.unlisted,
1311
Command.withHandler(({ method, sessionId, options }) =>
14-
Effect.promise(() =>
15-
runClaudeHistoryWorker(
16-
method,
17-
sessionId,
18-
options._tag === "Some" ? options.value : undefined,
12+
// Two effects, so an interrupt during the import never starts the worker.
13+
Effect.promise(() => import("../claudeHistoryWorker.ts")).pipe(
14+
Effect.flatMap(({ runClaudeHistoryWorker }) =>
15+
Effect.promise(() =>
16+
runClaudeHistoryWorker(
17+
method,
18+
sessionId,
19+
options._tag === "Some" ? options.value : undefined,
20+
),
21+
),
1922
),
2023
),
2124
),
Lines changed: 167 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,167 @@
1+
// @effect-diagnostics nodeBuiltinImport:off - CLI integration uses temporary Node paths.
2+
import * as NodePath from "node:path";
3+
4+
import * as NodeServices from "@effect/platform-node/NodeServices";
5+
import { assert, it } from "@effect/vitest";
6+
import * as NetService from "@t3tools/shared/Net";
7+
import * as Effect from "effect/Effect";
8+
import * as Exit from "effect/Exit";
9+
import * as Fiber from "effect/Fiber";
10+
import * as FileSystem from "effect/FileSystem";
11+
import * as Layer from "effect/Layer";
12+
import { Command } from "effect/cli";
13+
import { FetchHttpClient } from "effect/http";
14+
import { vi } from "vite-plus/test";
15+
16+
import { cli } from "../binCli.ts";
17+
import {
18+
makePersistedServerRuntimeState,
19+
persistServerRuntimeState,
20+
} from "../serverRuntimeState.ts";
21+
22+
const hooks = vi.hoisted(() => ({
23+
importsAttempted: [] as string[],
24+
historyImportStarted: Promise.withResolvers<void>(),
25+
releaseHistoryImport: Promise.withResolvers<void>(),
26+
runClaudeHistoryWorker: vi.fn(async () => {}),
27+
}));
28+
29+
vi.mock("../server.ts", () => {
30+
hooks.importsAttempted.push("server");
31+
throw new Error("server import failed");
32+
});
33+
vi.mock("../orchestration-v2/runtimeLayer.ts", () => {
34+
hooks.importsAttempted.push("runtimeLayer");
35+
throw new Error("runtime import failed");
36+
});
37+
vi.mock("../claudeHistoryWorker.ts", async () => {
38+
hooks.importsAttempted.push("claudeHistoryWorker");
39+
hooks.historyImportStarted.resolve();
40+
await hooks.releaseHistoryImport.promise;
41+
return { runClaudeHistoryWorker: hooks.runClaudeHistoryWorker };
42+
});
43+
44+
const layerCliRuntime = Layer.mergeAll(NodeServices.layer, NetService.layer);
45+
const runCli = (args: ReadonlyArray<string>) =>
46+
Command.runWith(cli, { version: "0.0.0" })(args).pipe(Effect.provide(layerCliRuntime));
47+
48+
it.layer(NodeServices.layer)("CLI deferred imports", (it) => {
49+
it.effect("runs commands that do not need them without loading them", () =>
50+
Effect.gen(function* () {
51+
hooks.importsAttempted.length = 0;
52+
for (const args of [["--version"], ["--help"], ["project", "--help"], ["thread", "--help"]]) {
53+
yield* runCli(args);
54+
}
55+
assert.deepEqual(hooks.importsAttempted, []);
56+
}),
57+
);
58+
59+
it.effect("fails a server start on a broken import before resolving config", () =>
60+
Effect.gen(function* () {
61+
const fs = yield* FileSystem.FileSystem;
62+
const root = yield* fs.makeTempDirectoryScoped({ prefix: "t3-deferred-server-" });
63+
const baseDir = NodePath.join(root, "state");
64+
65+
for (const command of ["serve", "start"]) {
66+
const exit = yield* runCli([command, "--base-dir", baseDir]).pipe(Effect.exit);
67+
assert.isTrue(Exit.hasDies(exit));
68+
}
69+
70+
assert.isFalse(yield* fs.exists(baseDir));
71+
}),
72+
);
73+
74+
it.effect("keeps server state when the offline project runtime fails to import", () =>
75+
Effect.gen(function* () {
76+
const fs = yield* FileSystem.FileSystem;
77+
const root = yield* fs.makeTempDirectoryScoped({ prefix: "t3-deferred-project-" });
78+
const baseDir = NodePath.join(root, "state");
79+
const runtimeStatePath = NodePath.join(baseDir, "userdata", "server-runtime.json");
80+
yield* persistServerRuntimeState({
81+
path: runtimeStatePath,
82+
state: yield* makePersistedServerRuntimeState({
83+
config: { host: "127.0.0.1", devUrl: undefined },
84+
port: 3_773,
85+
}),
86+
});
87+
const unreachable: typeof globalThis.fetch = () =>
88+
Promise.reject(new Error("connection refused"));
89+
90+
const exit = yield* runCli(["project", "add", root, "--base-dir", baseDir]).pipe(
91+
Effect.provideService(FetchHttpClient.Fetch, unreachable),
92+
Effect.exit,
93+
);
94+
95+
assert.isTrue(Exit.hasDies(exit));
96+
assert.isTrue(yield* fs.exists(runtimeStatePath));
97+
assert.isFalse(yield* fs.exists(NodePath.join(baseDir, "userdata", "server-owner.sqlite")));
98+
}),
99+
);
100+
101+
it.effect("forwards live project mutations without importing the offline runtime", () =>
102+
Effect.gen(function* () {
103+
const fs = yield* FileSystem.FileSystem;
104+
const root = yield* fs.makeTempDirectoryScoped({ prefix: "t3-deferred-live-project-" });
105+
const baseDir = NodePath.join(root, "state");
106+
const workspaceRoot = NodePath.join(root, "workspace");
107+
yield* fs.makeDirectory(workspaceRoot);
108+
yield* persistServerRuntimeState({
109+
path: NodePath.join(baseDir, "userdata", "server-runtime.json"),
110+
state: yield* makePersistedServerRuntimeState({
111+
config: { host: "127.0.0.1", devUrl: undefined },
112+
port: 3_773,
113+
}),
114+
});
115+
116+
hooks.importsAttempted.length = 0;
117+
let mutations = 0;
118+
const fetch: typeof globalThis.fetch = async (_input, init) => {
119+
const isMutation = init?.method === "POST";
120+
if (isMutation) mutations++;
121+
return Response.json(
122+
isMutation
123+
? {
124+
id: "live-project",
125+
title: NodePath.basename(workspaceRoot),
126+
workspaceRoot,
127+
defaultModelSelection: null,
128+
scripts: [],
129+
createdAt: "2026-01-01T00:00:00.000Z",
130+
updatedAt: "2026-01-01T00:00:00.000Z",
131+
deletedAt: null,
132+
}
133+
: { projects: [], updatedAt: "2026-01-01T00:00:00.000Z" },
134+
);
135+
};
136+
137+
const exit = yield* runCli(["project", "add", workspaceRoot, "--base-dir", baseDir]).pipe(
138+
Effect.provideService(FetchHttpClient.Fetch, fetch),
139+
Effect.exit,
140+
);
141+
142+
assert.isTrue(Exit.isSuccess(exit));
143+
assert.equal(mutations, 1);
144+
assert.deepEqual(hooks.importsAttempted, []);
145+
}),
146+
);
147+
148+
it.effect("never starts the history worker after an interrupted import", () =>
149+
Effect.gen(function* () {
150+
const history = yield* runCli(["__claude-history", "getSessionMessages", "session"]).pipe(
151+
Effect.forkChild,
152+
);
153+
yield* Effect.promise(() => hooks.historyImportStarted.promise);
154+
yield* Fiber.interrupt(history);
155+
hooks.releaseHistoryImport.resolve();
156+
yield* Effect.promise(() => import("../claudeHistoryWorker.ts"));
157+
assert.equal(hooks.runClaudeHistoryWorker.mock.calls.length, 0);
158+
159+
yield* runCli(["__claude-history", "getSessionMessages", "session"]);
160+
yield* runCli(["__claude-history", "forkSession", "session", '{"dir":"/repo"}']);
161+
assert.deepEqual(hooks.runClaudeHistoryWorker.mock.calls, [
162+
["getSessionMessages", "session", undefined],
163+
["forkSession", "session", '{"dir":"/repo"}'],
164+
]);
165+
}),
166+
);
167+
});

‎apps/server/src/cli/project.ts‎

Lines changed: 22 additions & 17 deletions
Original file line numberDiff line numberDiff line change
@@ -28,7 +28,7 @@ import * as ServerConfig from "../config.ts";
2828
import * as SqlitePersistence from "../persistence/Sqlite.ts";
2929
import * as ProcessRunner from "../processRunner.ts";
3030
import * as ServerOwnership from "../serverOwnership.ts";
31-
import * as RuntimeLayer from "../orchestration-v2/runtimeLayer.ts";
31+
import type * as RuntimeLayer from "../orchestration-v2/runtimeLayer.ts";
3232
import * as ProjectEnrichmentService from "../project/ProjectEnrichmentService.ts";
3333
import * as ProjectFaviconResolver from "../project/ProjectFaviconResolver.ts";
3434
import * as RepositoryIdentityResolver from "../project/RepositoryIdentityResolver.ts";
@@ -201,23 +201,24 @@ const projectCommandUuid = Crypto.Crypto.pipe(
201201
),
202202
);
203203

204-
const layerProjectCliRuntime = RuntimeLayer.layerProjectService.pipe(
205-
Layer.provideMerge(ProjectEnrichmentService.layer),
206-
Layer.provideMerge(RepositoryIdentityResolver.layer),
207-
Layer.provideMerge(
208-
ProjectFaviconResolver.layer.pipe(
209-
Layer.provide(WorkspacePaths.layer),
210-
Layer.provide(T3ProjectFileLoader.layer),
204+
const makeProjectCliRuntimeLayer = (layerProjectService: typeof RuntimeLayer.layerProjectService) =>
205+
layerProjectService.pipe(
206+
Layer.provideMerge(ProjectEnrichmentService.layer),
207+
Layer.provideMerge(RepositoryIdentityResolver.layer),
208+
Layer.provideMerge(
209+
ProjectFaviconResolver.layer.pipe(
210+
Layer.provide(WorkspacePaths.layer),
211+
Layer.provide(T3ProjectFileLoader.layer),
212+
),
211213
),
212-
),
213-
Layer.provideMerge(WorkspacePaths.layer),
214-
Layer.provideMerge(
215-
ServerSettings.layer.pipe(
216-
Layer.provide(Layer.merge(ServerSecretStore.layer, ManagedPolicy.layer)),
214+
Layer.provideMerge(WorkspacePaths.layer),
215+
Layer.provideMerge(
216+
ServerSettings.layer.pipe(
217+
Layer.provide(Layer.merge(ServerSecretStore.layer, ManagedPolicy.layer)),
218+
),
217219
),
218-
),
219-
Layer.provideMerge(SqlitePersistence.layerConfig),
220-
);
220+
Layer.provideMerge(SqlitePersistence.layerConfig),
221+
);
221222

222223
const PROJECT_CLI_LIVE_SERVER_PROBE_TIMEOUT = Duration.seconds(1);
223224
const PROJECT_CLI_LIVE_SERVER_REQUEST_TIMEOUT = Duration.seconds(10);
@@ -426,7 +427,11 @@ const runProjectMutation = Effect.fn("runProjectMutation")(function* (
426427
);
427428
}
428429

429-
const layerOfflineRuntime = layerProjectCliRuntime.pipe(
430+
// Before ownership and clearing, so a failed import leaves server state alone.
431+
const { layerProjectService } = yield* Effect.promise(
432+
() => import("../orchestration-v2/runtimeLayer.ts"),
433+
);
434+
const layerOfflineRuntime = makeProjectCliRuntimeLayer(layerProjectService).pipe(
430435
Layer.provide(ServerConfig.layer(config)),
431436
Layer.provide(Layer.succeed(References.MinimumLogLevel, minimumLogLevel)),
432437
);

‎apps/server/src/cli/server.ts‎

Lines changed: 2 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -8,7 +8,6 @@ import * as CliError from "effect/cli/CliError";
88

99
import * as ServerConfig from "../config.ts";
1010
import { awaitLauncherLoss } from "../launcherWatch.ts";
11-
import { runServer } from "../server.ts";
1211
import { type CliServerFlags, resolveServerConfig, sharedServerCommandFlags } from "./config.ts";
1312

1413
const encodeCommand = Schema.encodeEffect(Schema.fromJsonString(Schema.String));
@@ -28,6 +27,8 @@ const runServerCommand = Effect.fn("server.runServerCommand")(function* (
2827
readonly rejectRunningServer?: boolean;
2928
},
3029
) {
30+
// Before config resolution, which claims a port and creates directories.
31+
const { runServer } = yield* Effect.promise(() => import("../server.ts"));
3132
const logLevel = yield* GlobalFlag.LogLevel;
3233
const config = yield* resolveServerConfig(flags, logLevel, options);
3334
const run = runServer.pipe(Effect.provideService(ServerConfig.ServerConfig, config));

‎apps/server/src/provider/Drivers/ClaudeHome.test.ts‎

Lines changed: 37 additions & 22 deletions
Original file line numberDiff line numberDiff line change
@@ -59,29 +59,44 @@ it.layer(NodeServices.layer)("ClaudeHome", (it) => {
5959
);
6060
});
6161

62-
it.effect("labels Claude processes t3-code unless instance env or Claude settings set one", () =>
63-
Effect.gen(function* () {
64-
const fileSystem = yield* FileSystem.FileSystem;
65-
const path = yield* Path.Path;
66-
const homePath = yield* fileSystem.makeTempDirectoryScoped({ prefix: "t3-claude-home-" });
67-
const host = { CLAUDE_CODE_ENTRYPOINT: "claude-desktop", KEEP: "1" };
68-
const instance = [{ name: "CLAUDE_CODE_ENTRYPOINT", value: "instance", sensitive: false }];
62+
it.effect(
63+
"drops the launching Claude session and labels processes t3-code unless overridden",
64+
() =>
65+
Effect.gen(function* () {
66+
const fileSystem = yield* FileSystem.FileSystem;
67+
const path = yield* Path.Path;
68+
const homePath = yield* fileSystem.makeTempDirectoryScoped({ prefix: "t3-claude-home-" });
69+
const host = {
70+
CLAUDE_CODE_ENTRYPOINT: "claude-desktop",
71+
CLAUDECODE: "1",
72+
CLAUDE_CODE_SESSION_ID: "host-session",
73+
CLAUDE_CODE_MESSAGING_SOCKET: "/tmp/host-claude.sock",
74+
CLAUDE_EFFORT: "high",
75+
KEEP: "1",
76+
};
77+
const instance = [
78+
{ name: "CLAUDE_CODE_ENTRYPOINT", value: "instance", sensitive: false },
79+
{ name: "CLAUDE_EFFORT", value: "low", sensitive: false },
80+
];
6981

70-
expect(yield* mergeClaudeProcessEnvironment({ homePath }, undefined, host)).toMatchObject({
71-
CLAUDE_CODE_ENTRYPOINT: "t3-code",
72-
KEEP: "1",
73-
});
74-
expect(
75-
(yield* mergeClaudeProcessEnvironment({ homePath }, instance, host)).CLAUDE_CODE_ENTRYPOINT,
76-
).toBe("instance");
82+
expect(yield* mergeClaudeProcessEnvironment({ homePath }, undefined, host)).toEqual({
83+
CLAUDE_CODE_ENTRYPOINT: "t3-code",
84+
KEEP: "1",
85+
});
86+
expect(yield* mergeClaudeProcessEnvironment({ homePath }, instance, host)).toEqual({
87+
CLAUDE_CODE_ENTRYPOINT: "instance",
88+
CLAUDE_EFFORT: "low",
89+
KEEP: "1",
90+
});
7791

78-
yield* fileSystem.writeFileString(
79-
path.join(homePath, "settings.json"),
80-
JSON.stringify({ env: { CLAUDE_CODE_ENTRYPOINT: "custom" } }),
81-
);
82-
expect(
83-
(yield* mergeClaudeProcessEnvironment({ homePath }, instance, host)).CLAUDE_CODE_ENTRYPOINT,
84-
).toBe("custom");
85-
}),
92+
yield* fileSystem.writeFileString(
93+
path.join(homePath, "settings.json"),
94+
JSON.stringify({ env: { CLAUDE_CODE_ENTRYPOINT: "custom" } }),
95+
);
96+
expect(
97+
(yield* mergeClaudeProcessEnvironment({ homePath }, instance, host))
98+
.CLAUDE_CODE_ENTRYPOINT,
99+
).toBe("custom");
100+
}),
86101
);
87102
});

‎apps/server/src/provider/Drivers/ClaudeHome.ts‎

Lines changed: 21 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -45,6 +45,23 @@ export const makeClaudeEnvironment = Effect.fn("makeClaudeEnvironment")(function
4545
};
4646
});
4747

48+
// A Claude Code session that launched T3 exports these. A claude spawned with them acts as part of
49+
// that session: its session id, messaging socket and token, and effort.
50+
const CLAUDE_HOST_SESSION_VARIABLES = [
51+
"CLAUDECODE",
52+
"CLAUDE_CODE_SESSION_ID",
53+
"CLAUDE_CODE_HOST_SESSION_ID",
54+
"CLAUDE_CODE_CHILD_SESSION",
55+
"CLAUDE_CODE_SESSION_ATTENDED",
56+
"CLAUDE_CODE_MESSAGING_SOCKET",
57+
"CLAUDE_CODE_MESSAGING_TOKEN",
58+
"CLAUDE_CODE_EXECPATH",
59+
"CLAUDE_CODE_DESKTOP_APP_VERSION",
60+
"CLAUDE_EFFORT",
61+
"CLAUDE_PID",
62+
"CLAUDE_AGENT_SDK_VERSION",
63+
];
64+
4865
/**
4966
* Base env for the Claude processes T3 Code runs, before `makeClaudeEnvironment`.
5067
* Claude Code reads its entrypoint from the process env, not its settings `env`, so T3 Code applies that override itself.
@@ -54,10 +71,12 @@ export const mergeClaudeProcessEnvironment = Effect.fn("mergeClaudeProcessEnviro
5471
instanceEnvironment: ProviderInstanceEnvironment | undefined,
5572
hostEnvironment: NodeJS.ProcessEnv,
5673
) {
57-
const environment = yield* mergeProviderInstanceEnvironment(instanceEnvironment, {
74+
const baseEnvironment: NodeJS.ProcessEnv = {
5875
...hostEnvironment,
5976
CLAUDE_CODE_ENTRYPOINT: "t3-code",
60-
});
77+
};
78+
for (const name of CLAUDE_HOST_SESSION_VARIABLES) delete baseEnvironment[name];
79+
const environment = yield* mergeProviderInstanceEnvironment(instanceEnvironment, baseEnvironment);
6180
const settingsEntrypoint = (yield* readClaudeSettingsEnv(config, undefined, environment))
6281
.CLAUDE_CODE_ENTRYPOINT;
6382
return settingsEntrypoint

0 commit comments

Comments
 (0)