Skip to content
TypeScript

fix(cli): expand home-relative thread project paths (#30721)

Johan Vaz6d5772b33dea
diff --git a/apps/server/src/cli/thread.test.ts b/apps/server/src/cli/thread.test.ts
index 1fab7881bcb..f182f708c4c 100644
--- a/apps/server/src/cli/thread.test.ts
+++ b/apps/server/src/cli/thread.test.ts
@@ -1,12 +1,139 @@
+import * as NodeCrypto from "@effect/platform-node/NodeCrypto";
+import * as NodeServices from "@effect/platform-node/NodeServices";
import { assert, it } from "@effect/vitest";
-import { RunId, ThreadId } from "@t3tools/contracts";
+import { AuthSessionId, ProjectId, RunId, ThreadId } from "@t3tools/contracts";
+import * as HostProcess from "@t3tools/shared/HostProcess";
+import * as NetService from "@t3tools/shared/Net";
+import * as ConfigProvider from "effect/ConfigProvider";
+import * as DateTime from "effect/DateTime";
import * as Effect from "effect/Effect";
+import * as FileSystem from "effect/FileSystem";
+import * as Layer from "effect/Layer";
+import * as Path from "effect/Path";
+import * as TestConsole from "effect/testing/TestConsole";
+import { Command } from "effect/cli";
+import { vi } from "vite-plus/test";
-import { readLatestMessages, type ThreadTools, titleFromMessage, waitForRun } from "./thread.ts";
+import * as McpBridge from "../mcp/AcpMcpStdioBridge.ts";
+import {
+ makePersistedServerRuntimeState,
+ persistServerRuntimeState,
+} from "../serverRuntimeState.ts";
+import {
+ readLatestMessages,
+ threadCommand,
+ type ThreadTools,
+ titleFromMessage,
+ waitForRun,
+} from "./thread.ts";
+
+vi.mock("../auth/EnvironmentAuth.ts", async (importOriginal) => {
+ const actual = await importOriginal<typeof import("../auth/EnvironmentAuth.ts")>();
+ return {
+ ...actual,
+ layerRuntime: Layer.mock(actual.EnvironmentAuth)({
+ issueMcpClientSession: () =>
+ Effect.map(DateTime.now, (expiresAt) => ({
+ sessionId: AuthSessionId.make("test-session"),
+ token: "synthetic-token",
+ expiresAt,
+ })),
+ revokeSession: () => Effect.succeed(true),
+ }),
+ };
+});
const threadId = ThreadId.make("thread-1");
const runId = RunId.make("run-1");
+it.effect(
+ "start resolves home-relative project paths while preserving ids and relative paths",
+ () =>
+ Effect.gen(function* () {
+ const fs = yield* FileSystem.FileSystem;
+ const path = yield* Path.Path;
+ const root = yield* fs
+ .makeTempDirectoryScoped({ prefix: "t3-thread-project-path-" })
+ .pipe(Effect.flatMap((directory) => fs.realPath(directory)));
+ const home = path.join(root, "home");
+ const cwd = path.join(root, "current");
+ const workspaceRoot = path.join(home, "My Project");
+ const nestedRoot = path.join(workspaceRoot, "nested");
+ const baseDir = path.join(root, "state");
+ yield* fs.makeDirectory(nestedRoot, { recursive: true });
+ yield* fs.makeDirectory(cwd);
+ const projects = [
+ { id: ProjectId.make("current-project"), title: "Current", workspaceRoot: cwd },
+ { id: ProjectId.make("home-project"), title: "Home", workspaceRoot: home },
+ { id: ProjectId.make("intended-project"), title: "Intended", workspaceRoot },
+ { id: ProjectId.make("nested-project"), title: "Nested", workspaceRoot: nestedRoot },
+ { id: ProjectId.make("~/literal-id"), title: "Exact id", workspaceRoot: cwd },
+ ];
+ yield* persistServerRuntimeState({
+ path: path.join(baseDir, "userdata", "server-runtime.json"),
+ state: yield* makePersistedServerRuntimeState({
+ config: { host: "127.0.0.1", devUrl: undefined },
+ port: 3_773,
+ }),
+ });
+ using _session = vi.spyOn(McpBridge, "mcpToolSession").mockReturnValue(
+ Effect.succeed({
+ call: (tool, args) => {
+ switch (tool) {
+ case "t3_project_list":
+ return Effect.succeed({ structuredContent: { projects, nextCursor: null } });
+ case "t3_thread_launch":
+ return Effect.succeed({
+ structuredContent: { threadId, projectId: args.projectId, runId: null },
+ });
+ default:
+ return Effect.die(`unexpected ${tool} call`);
+ }
+ },
+ }),
+ );
+
+ for (const [identifier, expectedProjectId] of [
+ ["intended-project", "intended-project"],
+ ["~/literal-id", "~/literal-id"],
+ [workspaceRoot, "intended-project"],
+ [path.relative(cwd, workspaceRoot), "intended-project"],
+ [".", "current-project"],
+ ["~/My Project", "intended-project"],
+ ["~", "home-project"],
+ ["~/My Project/nested", "nested-project"],
+ ["~/My Project/missing", "intended-project"],
+ ] as const) {
+ yield* Command.runWith(threadCommand, { version: "0.0.0" })([
+ "start",
+ identifier,
+ "Inspect this project",
+ "--json",
+ "--base-dir",
+ baseDir,
+ ]).pipe(
+ Effect.provideService(HostProcess.HomeDirectory, home),
+ Effect.provideService(HostProcess.WorkingDirectory, cwd),
+ );
+ assert.strictEqual(
+ (yield* TestConsole.logLines).at(-1),
+ JSON.stringify({ threadId, projectId: expectedProjectId, runId: null }),
+ identifier,
+ );
+ }
+ }).pipe(
+ Effect.scoped,
+ Effect.provide(
+ Layer.mergeAll(
+ NodeServices.layer,
+ NodeCrypto.layer,
+ NetService.layer,
+ ConfigProvider.layer(ConfigProvider.fromEnv({ env: { T3CODE_PORT: "3773" } })),
+ ),
+ ),
+ ),
+);
+
/** Answers each tool call with the next scripted response for that tool. */
const scriptedTools = (script: Record<string, Array<unknown>>) => {
const calls: Array<{ readonly tool: string; readonly args: unknown }> = [];
diff --git a/apps/server/src/cli/thread.ts b/apps/server/src/cli/thread.ts
index 7bfddda4723..80dfad018e1 100644
--- a/apps/server/src/cli/thread.ts
+++ b/apps/server/src/cli/thread.ts
@@ -29,6 +29,7 @@ import { Argument, Command, Flag, GlobalFlag } from "effect/cli";
import * as EnvironmentAuth from "../auth/EnvironmentAuth.ts";
import * as ServerConfig from "../config.ts";
import { mcpToolSession, type McpToolSession } from "../mcp/AcpMcpStdioBridge.ts";
+import { expandHomePath } from "../os-jank.ts";
import { readPersistedServerRuntimeState } from "../serverRuntimeState.ts";
import { projectLocationFlags, resolveCliAuthConfig } from "./config.ts";
@@ -287,7 +288,9 @@ const resolveProject = Effect.fn("cli.thread.resolveProject")(function* (
// through a symlink (macOS /tmp), so both sides compare as real paths.
const realPath = (value: string) =>
fileSystem.realPath(value).pipe(Effect.orElseSucceed(() => value));
- const target = yield* realPath(path.resolve(yield* HostProcess.WorkingDirectory, identifier));
+ const target = yield* realPath(
+ path.resolve(yield* HostProcess.WorkingDirectory, yield* expandHomePath(identifier)),
+ );
const roots = yield* Effect.forEach(projects, (project) =>
Effect.map(realPath(project.workspaceRoot), (root) => ({ project, root })),
);