@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, 04:45 UTC

main
ts 177 lines 7.69 KB
Raw
1 import type { ClaudeSettings, ProviderInstanceEnvironment } from "@t3tools/contracts";
2 import * as Effect from "effect/Effect";
3 import * as FileSystem from "effect/FileSystem";
4 import * as Path from "effect/Path";
5 import * as Schema from "effect/Schema";
6
7 import { mergeProviderInstanceEnvironment } from "@t3tools/provider-core/server/instanceEnvironment";
8 import { expandHomePath } from "@t3tools/provider-core/server/pathExpansion";
9 import * as HostProcess from "@t3tools/shared/HostProcess";
10
11 import { readClaudeSettingsEnv } from "./ClaudeSkills.ts";
12
13 const quotePath = Schema.encodeSync(Schema.fromJsonString(Schema.String));
14
15 export const resolveClaudeHomePath = Effect.fn("resolveClaudeHomePath")(function* (
16 config: Pick<ClaudeSettings, "homePath">,
17 environment?: NodeJS.ProcessEnv,
18 ): Effect.fn.Return<string, never, Path.Path> {
19 const path = yield* Path.Path;
20 const home = yield* HostProcess.HomeDirectory;
21 const homePath = config.homePath.trim();
22 if (homePath.length > 0) {
23 return path.resolve(expandHomePath(homePath, home));
24 }
25 // Inherited env vars are not shell-expanded, so a literal `~` stays literal.
26 const inherited = environment?.CLAUDE_CONFIG_DIR?.trim() ?? "";
27 if (inherited.length > 0) {
28 return path.resolve(inherited);
29 }
30 return path.resolve(path.join(home, ".claude"));
31 });
32
33 export const makeClaudeEnvironment = Effect.fn("makeClaudeEnvironment")(function* (
34 config: Pick<ClaudeSettings, "homePath">,
35 baseEnv?: NodeJS.ProcessEnv,
36 ): Effect.fn.Return<NodeJS.ProcessEnv, never, Path.Path> {
37 const resolvedBaseEnv = baseEnv ?? process.env;
38 const homePath = config.homePath.trim();
39 if (homePath.length === 0) return resolvedBaseEnv;
40 const resolvedHomePath = yield* resolveClaudeHomePath(config);
41 return {
42 ...resolvedBaseEnv,
43 // Changing HOME hides macOS Keychain credentials; use CLAUDE_CONFIG_DIR to keep login access.
44 CLAUDE_CONFIG_DIR: resolvedHomePath,
45 };
46 });
47
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
65 /**
66 * Base env for the Claude processes T3 Code runs, before `makeClaudeEnvironment`.
67 * Claude Code reads its entrypoint from the process env, not its settings `env`, so T3 Code applies that override itself.
68 */
69 export const mergeClaudeProcessEnvironment = Effect.fn("mergeClaudeProcessEnvironment")(function* (
70 config: Pick<ClaudeSettings, "homePath">,
71 instanceEnvironment: ProviderInstanceEnvironment | undefined,
72 hostEnvironment: NodeJS.ProcessEnv,
73 ) {
74 const baseEnvironment: NodeJS.ProcessEnv = {
75 ...hostEnvironment,
76 CLAUDE_CODE_ENTRYPOINT: "t3-code",
77 };
78 for (const name of CLAUDE_HOST_SESSION_VARIABLES) delete baseEnvironment[name];
79 // The desktop runs the server as Node through Electron. Commands Claude runs inherit its env, so
80 // an Electron app they start (T3 Code itself, VS Code) would run as Node and exit.
81 delete baseEnvironment.ELECTRON_RUN_AS_NODE;
82 const environment = yield* mergeProviderInstanceEnvironment(instanceEnvironment, baseEnvironment);
83 const settingsEntrypoint = (yield* readClaudeSettingsEnv(config, undefined, environment))
84 .CLAUDE_CODE_ENTRYPOINT;
85 return settingsEntrypoint
86 ? { ...environment, CLAUDE_CODE_ENTRYPOINT: settingsEntrypoint }
87 : environment;
88 });
89
90 /** managed-mcp.json excludes other MCP config and forbids --strict-mcp-config; omit the flag when present. */
91 export const hasClaudeManagedMcpConfig = Effect.fn("hasClaudeManagedMcpConfig")(function* () {
92 const fileSystem = yield* FileSystem.FileSystem;
93 const platform = yield* HostProcess.Platform;
94 const managedMcpConfigPath =
95 platform === "darwin"
96 ? "/Library/Application Support/ClaudeCode/managed-mcp.json"
97 : platform === "win32"
98 ? "C:\\Program Files\\ClaudeCode\\managed-mcp.json"
99 : "/etc/claude-code/managed-mcp.json";
100 return yield* fileSystem.exists(managedMcpConfigPath).pipe(Effect.orElseSucceed(() => false));
101 });
102
103 // A worktree's .git file points at <main>/.git/worktrees/<name>, whose commondir leads back to
104 // <main>/.git. A bare repository has no main checkout, so its worktree keeps its own file.
105 // Untraced because claudeLocalSettingsDirectory already owns the span.
106 const mainCheckoutRoot = Effect.fnUntraced(function* (checkout: string) {
107 const fileSystem = yield* FileSystem.FileSystem;
108 const path = yield* Path.Path;
109 return yield* fileSystem.readFileString(path.join(checkout, ".git")).pipe(
110 Effect.flatMap((pointer) => {
111 const gitDir = /^gitdir:\s*(.+)$/m.exec(pointer)?.[1]?.trim();
112 if (gitDir === undefined) return Effect.succeed(checkout);
113 const worktreeGitDir = path.resolve(checkout, gitDir);
114 return fileSystem.readFileString(path.join(worktreeGitDir, "commondir")).pipe(
115 Effect.map((commonDir) => {
116 const common = path.resolve(worktreeGitDir, commonDir.trim());
117 return path.basename(common) === ".git" ? path.dirname(common) : checkout;
118 }),
119 );
120 }),
121 Effect.orElseSucceed(() => checkout),
122 );
123 });
124
125 // Claude Code keeps .claude/settings.local.json at the repository root, or in cwd outside a
126 // repository, on Windows, or when the root is home. Its owner check is skipped, so callers must
127 // stay safe when Claude Code ignores the root file.
128 export const claudeLocalSettingsDirectory = Effect.fn("claudeLocalSettingsDirectory")(function* (
129 cwd: string,
130 ) {
131 const fileSystem = yield* FileSystem.FileSystem;
132 const path = yield* Path.Path;
133 if ((yield* HostProcess.Platform) === "win32") return cwd;
134 for (let directory = cwd; ; directory = path.dirname(directory)) {
135 const isCheckout = yield* fileSystem
136 .exists(path.join(directory, ".git"))
137 .pipe(Effect.orElseSucceed(() => false));
138 if (isCheckout) {
139 const root = yield* mainCheckoutRoot(directory);
140 return root === (yield* HostProcess.HomeDirectory) ? cwd : root;
141 }
142 if (path.dirname(directory) === directory) return cwd;
143 }
144 });
145
146 export const makeClaudeContinuationGroupKey = Effect.fn("makeClaudeContinuationGroupKey")(
147 function* (
148 config: Pick<ClaudeSettings, "homePath">,
149 environment?: NodeJS.ProcessEnv,
150 ): Effect.fn.Return<string, never, Path.Path> {
151 const resolvedHomePath = yield* resolveClaudeHomePath(config, environment);
152 return `claude:home:${resolvedHomePath}`;
153 },
154 );
155
156 export const makeClaudeCapabilitiesCacheKey = Effect.fn("makeClaudeCapabilitiesCacheKey")(
157 function* (
158 config: Pick<ClaudeSettings, "binaryPath" | "homePath">,
159 cwd?: string,
160 environment?: NodeJS.ProcessEnv,
161 ): Effect.fn.Return<string, never, Path.Path> {
162 const resolvedHomePath = yield* resolveClaudeHomePath(config, environment);
163 return `${config.binaryPath}\0${resolvedHomePath}\0${cwd ?? ""}`;
164 },
165 );
166
167 /** Separate spawn env from login commands to preserve literal paths, including relative inherited values. */
168 export const claudeSignedOutMessage = (input: {
169 readonly configDir: string | undefined;
170 readonly cwd: string;
171 }): string => {
172 const configuration =
173 input.configDir !== undefined
174 ? ` from ${quotePath(input.cwd)}, with CLAUDE_CONFIG_DIR set to ${quotePath(input.configDir)}`
175 : "";
176 return `Claude could not authenticate. For subscription login, run \`claude auth login\` on this environment's machine${configuration}, then start a new thread. For API-key authentication, check this instance's configured credentials.`;
177 };