Simplify command palette project browse flow

Author: Noojuno

apps/server/src/orchestration/commandInvariants.test.ts

@@ -16,6 +16,7 @@ import {
   requireNonNegativeInteger,
   requireThread,
   requireThreadAbsent,
+  requireProjectWorkspaceRootAvailable,
 } from "./commandInvariants.ts";
 
 const now = new Date().toISOString();
@@ -178,6 +179,40 @@ describe("commandInvariants", () => {
     ).rejects.toThrow("already exists");
   });
 
+  it("rejects duplicate active project workspace roots", async () => {
+    await expect(
+      Effect.runPromise(
+        requireProjectWorkspaceRootAvailable({
+          readModel,
+          command: {
+            type: "project.create",
+            commandId: CommandId.makeUnsafe("cmd-project-dup-root"),
+            projectId: ProjectId.makeUnsafe("project-c"),
+            title: "Project C",
+            workspaceRoot: "/tmp/project-a",
+            defaultModel: "gpt-5-codex",
+            createdAt: now,
+          },
+          workspaceRoot: "/tmp/project-a",
+        }),
+      ),
+    ).rejects.toThrow("already used");
+
+    await Effect.runPromise(
+      requireProjectWorkspaceRootAvailable({
+        readModel,
+        command: {
+          type: "project.meta.update",
+          commandId: CommandId.makeUnsafe("cmd-project-update-root"),
+          projectId: ProjectId.makeUnsafe("project-a"),
+          workspaceRoot: "/tmp/project-a",
+        },
+        workspaceRoot: "/tmp/project-a",
+        ignoredProjectId: ProjectId.makeUnsafe("project-a"),
+      }),
+    );
+  });
+
   it("requires non-negative integers", async () => {
     await Effect.runPromise(
       requireNonNegativeInteger({

apps/server/src/orchestration/commandInvariants.ts

@@ -38,6 +38,19 @@ export function listThreadsByProjectId(
   return readModel.threads.filter((thread) => thread.projectId === projectId);
 }
 
+function findActiveProjectByWorkspaceRoot(
+  readModel: OrchestrationReadModel,
+  workspaceRoot: string,
+  ignoredProjectId?: ProjectId,
+): OrchestrationProject | undefined {
+  return readModel.projects.find(
+    (project) =>
+      project.deletedAt === null &&
+      project.workspaceRoot === workspaceRoot &&
+      project.id !== ignoredProjectId,
+  );
+}
+
 export function requireProject(input: {
   readonly readModel: OrchestrationReadModel;
   readonly command: OrchestrationCommand;
@@ -71,6 +84,28 @@ export function requireProjectAbsent(input: {
   );
 }
 
+export function requireProjectWorkspaceRootAvailable(input: {
+  readonly readModel: OrchestrationReadModel;
+  readonly command: OrchestrationCommand;
+  readonly workspaceRoot: string;
+  readonly ignoredProjectId?: ProjectId;
+}): Effect.Effect<void, OrchestrationCommandInvariantError> {
+  const existingProject = findActiveProjectByWorkspaceRoot(
+    input.readModel,
+    input.workspaceRoot,
+    input.ignoredProjectId,
+  );
+  if (!existingProject) {
+    return Effect.void;
+  }
+  return Effect.fail(
+    invariantError(
+      input.command.type,
+      `Project workspace root '${input.workspaceRoot}' is already used by project '${existingProject.id}'.`,
+    ),
+  );
+}
+
 export function requireThread(input: {
   readonly readModel: OrchestrationReadModel;
   readonly command: OrchestrationCommand;

apps/server/src/orchestration/decider.ts

@@ -9,6 +9,7 @@ import { OrchestrationCommandInvariantError } from "./Errors.ts";
 import {
   requireProject,
   requireProjectAbsent,
+  requireProjectWorkspaceRootAvailable,
   requireThread,
   requireThreadAbsent,
 } from "./commandInvariants.ts";
@@ -64,6 +65,11 @@ export const decideOrchestrationCommand = Effect.fn("decideOrchestrationCommand"
         command,
         projectId: command.projectId,
       });
+      yield* requireProjectWorkspaceRootAvailable({
+        readModel,
+        command,
+        workspaceRoot: command.workspaceRoot,
+      });
 
       return {
         ...withEventBase({
@@ -91,6 +97,14 @@ export const decideOrchestrationCommand = Effect.fn("decideOrchestrationCommand"
         command,
         projectId: command.projectId,
       });
+      if (command.workspaceRoot !== undefined) {
+        yield* requireProjectWorkspaceRootAvailable({
+          readModel,
+          command,
+          workspaceRoot: command.workspaceRoot,
+          ignoredProjectId: command.projectId,
+        });
+      }
       const occurredAt = nowIso();
       return {
         ...withEventBase({

apps/server/src/wsServer.test.ts

@@ -1606,6 +1606,53 @@ describe("WebSocket Server", () => {
     });
   });
 
+  it("resolves relative filesystem.browse paths against the provided cwd", async () => {
+    const workspace = makeTempDir("t3code-ws-filesystem-browse-relative-");
+    fs.mkdirSync(path.join(workspace, "apps"), { recursive: true });
+    fs.mkdirSync(path.join(workspace, "docs"), { recursive: true });
+
+    server = await createTestServer({ cwd: "/test" });
+    const addr = server.address();
+    const port = typeof addr === "object" && addr !== null ? addr.port : 0;
+
+    const [ws] = await connectAndAwaitWelcome(port);
+    connections.push(ws);
+
+    const response = await sendRequest(ws, WS_METHODS.filesystemBrowse, {
+      partialPath: "../d",
+      cwd: path.join(workspace, "apps"),
+    });
+
+    expect(response.error).toBeUndefined();
+    expect(response.result).toEqual({
+      parentPath: workspace,
+      entries: [
+        {
+          name: "docs",
+          fullPath: path.join(workspace, "docs"),
+        },
+      ],
+    });
+  });
+
+  it("rejects relative filesystem.browse paths without a cwd", async () => {
+    server = await createTestServer({ cwd: "/test" });
+    const addr = server.address();
+    const port = typeof addr === "object" && addr !== null ? addr.port : 0;
+
+    const [ws] = await connectAndAwaitWelcome(port);
+    connections.push(ws);
+
+    const response = await sendRequest(ws, WS_METHODS.filesystemBrowse, {
+      partialPath: "./docs",
+    });
+
+    expect(response.result).toBeUndefined();
+    expect(response.error?.message).toContain(
+      "Relative filesystem browse paths require a current project.",
+    );
+  });
+
   it("supports projects.writeFile within the workspace root", async () => {
     const workspace = makeTempDir("t3code-ws-write-file-");
 

apps/server/src/wsServer.ts

@@ -110,6 +110,32 @@ const isServerNotRunningError = (error: Error): boolean => {
   );
 };
 
+function isExplicitRelativePath(value: string): boolean {
+  return (
+    value.startsWith("./") ||
+    value.startsWith("../") ||
+    value.startsWith(".\\") ||
+    value.startsWith("..\\")
+  );
+}
+
+function resolveFilesystemBrowseInputPath(input: {
+  cwd: string | undefined;
+  path: Path.Path;
+  partialPath: string;
+}): Effect.Effect<string | null, never, Path.Path> {
+  return Effect.gen(function* () {
+    if (!isExplicitRelativePath(input.partialPath)) {
+      return input.path.resolve(yield* expandHomePath(input.partialPath));
+    }
+    if (!input.cwd) {
+      return null;
+    }
+    const expandedCwd = yield* expandHomePath(input.cwd);
+    return input.path.resolve(expandedCwd, input.partialPath);
+  });
+}
+
 function rejectUpgrade(socket: Duplex, statusCode: number, message: string): void {
   socket.end(
     `HTTP/1.1 ${statusCode} ${statusCode === 401 ? "Unauthorized" : "Bad Request"}\r\n` +
@@ -868,14 +894,30 @@ export const createServer = Effect.fn(function* (): Effect.fn.Return<
 
       case WS_METHODS.filesystemBrowse: {
         const body = stripRequestTag(request.body);
-        const expanded = path.resolve(yield* expandHomePath(body.partialPath));
+        const resolvedInputPath = yield* resolveFilesystemBrowseInputPath({
+          cwd: body.cwd,
+          path,
+          partialPath: body.partialPath,
+        });
+        if (resolvedInputPath === null) {
+          return yield* new RouteRequestError({
+            message: "Relative filesystem browse paths require a current project.",
+          });
+        }
+
+        const expanded = resolvedInputPath;
         const endsWithSep = /[\\/]$/.test(body.partialPath) || body.partialPath === "~";
         const parentDir = endsWithSep ? expanded : path.dirname(expanded);
         const prefix = endsWithSep ? "" : path.basename(expanded);
 
-        const names = yield* fileSystem
-          .readDirectory(parentDir)
-          .pipe(Effect.catch(() => Effect.succeed([] as string[])));
+        const names = yield* fileSystem.readDirectory(parentDir).pipe(
+          Effect.mapError(
+            (cause) =>
+              new RouteRequestError({
+                message: `Unable to browse '${parentDir}': ${Cause.pretty(Cause.fail(cause)).trim()}`,
+              }),
+          ),
+        );
 
         const showHidden = prefix.startsWith(".");
         const lowerPrefix = prefix.toLowerCase();
@@ -889,18 +931,19 @@ export const createServer = Effect.fn(function* (): Effect.fn.Return<
         const entries = yield* Effect.forEach(
           filtered,
           (name) =>
-            fileSystem.stat(path.join(parentDir, name)).pipe(
-              Effect.map((s) =>
-                s.type === "Directory" ? { name, fullPath: path.join(parentDir, name) } : null,
+            fileSystem
+              .stat(path.join(parentDir, name))
+              .pipe(
+                Effect.map((s) =>
+                  s.type === "Directory" ? { name, fullPath: path.join(parentDir, name) } : null,
+                ),
               ),
-              Effect.catch(() => Effect.succeed(null)),
-            ),
           { concurrency: 16 },
         );
 
         return {
           parentPath: parentDir,
-          entries: entries.filter(Boolean).slice(0, 50),
+          entries: entries.filter(Boolean),
         };
       }