feat: harden workspace runtime operations

Author: pallyoung

packages/server/src/__tests__/fs/file-io.test.ts

@@ -2,7 +2,7 @@
  * Tests for file-io operations.
  */
 
-import { mkdir, mkdtemp, readFile, rm, stat, writeFile } from "fs/promises";
+import { mkdir, mkdtemp, readFile, rm, stat, symlink, writeFile } from "fs/promises";
 import { tmpdir } from "os";
 import { join, win32 } from "path";
 import { afterEach, beforeEach, describe, expect, it } from "vitest";
@@ -82,6 +82,19 @@ describe("readFile", () => {
     await expect(readWorkspaceFile("ws-1", testDir, "nonexistent.txt")).rejects.toThrow();
   });
 
+  it("rejects symlinked files that resolve outside the workspace root", async () => {
+    const outsideDir = await mkdtemp(join(tmpdir(), "fileio-outside-"));
+    const outsideFile = join(outsideDir, "secret.txt");
+    await writeFile(outsideFile, "secret");
+    await symlink(outsideFile, join(testDir, "escape.txt"));
+
+    await expect(readWorkspaceFile("ws-1", testDir, "escape.txt")).rejects.toMatchObject({
+      code: "path_escape",
+    });
+
+    await rm(outsideDir, { recursive: true, force: true });
+  });
+
   it("should return an image descriptor with a signed-in asset URL for png files", async () => {
     // Minimal 1x1 PNG so we exercise the binary branch without depending on
     // fixture files; exact bytes don't matter since the endpoint just streams
@@ -169,6 +182,19 @@ describe("writeFile", () => {
     // Try to write with outdated baseHash
     await expect(writeWorkspaceFile(testDir, "test.txt", "Updated", "wronghash")).rejects.toThrow();
   });
+
+  it("rejects writing through symlinked files outside the workspace root", async () => {
+    const outsideDir = await mkdtemp(join(tmpdir(), "fileio-outside-"));
+    const outsideFile = join(outsideDir, "secret.txt");
+    await writeFile(outsideFile, "secret");
+    await symlink(outsideFile, join(testDir, "escape.txt"));
+
+    await expect(writeWorkspaceFile(testDir, "escape.txt", "updated")).rejects.toMatchObject({
+      code: "path_escape",
+    });
+
+    await rm(outsideDir, { recursive: true, force: true });
+  });
 });
 
 describe("createFile", () => {
@@ -283,4 +309,17 @@ describe("deleteEntry", () => {
       code: "path_escape",
     });
   });
+
+  it("rejects deleting symlinked files outside the workspace root", async () => {
+    const outsideDir = await mkdtemp(join(tmpdir(), "fileio-outside-"));
+    const outsideFile = join(outsideDir, "secret.txt");
+    await writeFile(outsideFile, "secret");
+    await symlink(outsideFile, join(testDir, "escape.txt"));
+
+    await expect(deleteEntry(testDir, "escape.txt")).rejects.toMatchObject({
+      code: "path_escape",
+    });
+
+    await rm(outsideDir, { recursive: true, force: true });
+  });
 });

packages/server/src/__tests__/fs/tree.test.ts

@@ -2,7 +2,7 @@
  * Tests for file tree builder (lazy loading version).
  */
 
-import { mkdir, mkdir as mkdirAsync, rmdir, writeFile } from "fs/promises";
+import { mkdir, mkdir as mkdirAsync, rmdir, symlink, writeFile } from "fs/promises";
 import { tmpdir } from "os";
 import { join } from "path";
 import { afterEach, beforeEach, describe, expect, it } from "vitest";
@@ -162,4 +162,53 @@ describe("readTree", () => {
       isGitIgnored: false,
     });
   });
+
+  it("shows symlinked files and directories using the target kind", async () => {
+    await mkdirAsync(join(testDir, "real-dir"));
+    await writeFile(join(testDir, "real-file.txt"), "content");
+    await symlink(join(testDir, "real-dir"), join(testDir, "linked-dir"), "dir");
+    await symlink(join(testDir, "real-file.txt"), join(testDir, "linked-file.txt"));
+
+    const result = await readTree(testDir);
+
+    expect(result.children).toEqual(
+      expect.arrayContaining([
+        expect.objectContaining({
+          name: "linked-dir",
+          path: "linked-dir",
+          kind: "dir",
+          isSymlink: true,
+        }),
+        expect.objectContaining({
+          name: "linked-file.txt",
+          path: "linked-file.txt",
+          kind: "file",
+          isSymlink: true,
+        }),
+      ])
+    );
+  });
+
+  it("lists external symlink directories but rejects expanding them", async () => {
+    const outsideDir = join(tmpdir(), `tree-test-outside-${Date.now()}`);
+    await mkdirAsync(outsideDir);
+    await symlink(outsideDir, join(testDir, "external-dir"), "dir");
+
+    const rootResult = await readTree(testDir);
+    expect(rootResult.children).toEqual(
+      expect.arrayContaining([
+        expect.objectContaining({
+          name: "external-dir",
+          kind: "dir",
+          isSymlink: true,
+        }),
+      ])
+    );
+
+    await expect(readTree(testDir, "external-dir")).rejects.toMatchObject({
+      code: "path_escape",
+    });
+
+    await rmdir(outsideDir);
+  });
 });

packages/server/src/__tests__/fs/watcher.test.ts

@@ -93,6 +93,19 @@ describe("WorkspaceWatcher", () => {
     expect(ignored?.(join(testDir, "src/index.ts"))).toBe(false);
   });
 
+  it("ignores managed target files used for agent instruction publishing", () => {
+    new WorkspaceWatcher("test-workspace-id", testDir, broadcaster);
+
+    const options = watchSpy.mock.calls[0]?.[1];
+    const ignored = options?.ignored;
+
+    expect(typeof ignored).toBe("function");
+    expect(ignored?.(join(testDir, "AGENTS.md"))).toBe(true);
+    expect(ignored?.(join(testDir, "GEMINI.md"))).toBe(true);
+    expect(ignored?.(join(testDir, ".claude", "CLAUDE.md"))).toBe(true);
+    expect(ignored?.(join(testDir, ".coder-studio", "agent.md"))).toBe(false);
+  });
+
   it("ignores transient git lock files and write-heavy git internals", () => {
     new WorkspaceWatcher("test-workspace-id", testDir, broadcaster);
 
@@ -241,6 +254,20 @@ describe("WorkspaceWatcher", () => {
     );
   });
 
+  it("invokes the dirty callback after a single file event settles", async () => {
+    vi.useFakeTimers();
+    const onDirty = vi.fn();
+
+    new WorkspaceWatcher("test-workspace-id", testDir, broadcaster, undefined, onDirty);
+
+    watcherEvents.all?.("change", join(testDir, ".coder-studio", "agent.md"));
+    await vi.advanceTimersByTimeAsync(199);
+    expect(onDirty).not.toHaveBeenCalled();
+
+    await vi.advanceTimersByTimeAsync(1);
+    expect(onDirty).toHaveBeenCalledWith("test-workspace-id", "fs_change");
+  });
+
   it("broadcasts fs.dirty after consecutive file events settle", async () => {
     vi.useFakeTimers();
     new WorkspaceWatcher("test-workspace-id", testDir, broadcaster);

packages/server/src/__tests__/git/status-parser.test.ts

@@ -16,6 +16,7 @@ describe("parseStatus", () => {
     expect(status.modified).toHaveLength(0);
     expect(status.untracked).toHaveLength(0);
     expect(status.deleted).toHaveLength(0);
+    expect(status.conflicted).toHaveLength(0);
   });
 
   it("should parse branch name", () => {
@@ -144,6 +145,21 @@ describe("parseStatus", () => {
     ]);
   });
 
+  it("parses unmerged conflict entries as merge changes", () => {
+    const porcelain = `# branch.head main
+u UU N... 100644 100644 100644 100644 base123 ours123 theirs123 conflicted.ts`;
+    const status = parseStatus(porcelain);
+
+    expect(status.conflicted).toEqual([
+      {
+        path: "conflicted.ts",
+        status: "conflicted",
+      },
+    ]);
+    expect(status.modified).toHaveLength(0);
+    expect(status.staged).toHaveLength(0);
+  });
+
   it("should handle complex status", () => {
     const porcelain = `# branch.oid abc123
 # branch.head main

packages/server/src/__tests__/lsp-commands.test.ts

@@ -5,6 +5,7 @@ import { tmpdir } from "node:os";
 import { join } from "node:path";
 import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
 import { EventBus } from "../bus/event-bus.js";
+import { SettingsRepo } from "../storage/repositories/settings-repo.js";
 import { WorkspaceRepo } from "../storage/repositories/workspace-repo.js";
 import { WorkspaceManager } from "../workspace/manager.js";
 import type { CommandContext } from "../ws/dispatch.js";
@@ -118,6 +119,9 @@ describe("LSP commands", () => {
   beforeEach(() => {
     stateDir = mkdtempSync(join(tmpdir(), "lsp-command-state-"));
     const eventBus = new EventBus();
+    const settingsRepo = new SettingsRepo({
+      filePath: join(stateDir, "settings.json"),
+    });
     const workspaceMgr = new WorkspaceManager({
       workspaceRepo: new WorkspaceRepo({
         filePath: join(stateDir, "workspaces.json"),
@@ -131,6 +135,7 @@ describe("LSP commands", () => {
       sessionMgr: {} as never,
       terminalMgr: {} as never,
       broadcaster: { broadcast: vi.fn(), sendToClient: vi.fn(), sendBinaryToClient: vi.fn() },
+      settingsRepo,
       providerRegistry: [],
       autoFetch: {} as never,
       fencingMgr: {} as never,

packages/server/src/__tests__/session-commands.test.ts

@@ -10,6 +10,7 @@ import { SessionManager } from "../session/manager.js";
 import type { SessionDatabase } from "../session/types.js";
 import { ProviderConfigRepo } from "../storage/repositories/provider-config-repo.js";
 import { SessionMetadataRepo } from "../storage/repositories/session-metadata-repo.js";
+import { SettingsRepo } from "../storage/repositories/settings-repo.js";
 import { WorkspaceRepo } from "../storage/repositories/workspace-repo.js";
 import type { TerminalManager } from "../terminal/manager.js";
 import { WorkspaceManager } from "../workspace/manager.js";
@@ -40,6 +41,9 @@ describe("Session Commands", () => {
     eventBus = new EventBus();
     stateDir = mkdtempSync(join(tmpdir(), "session-command-state-"));
     const providerConfigRepo = createProviderConfigRepo(join(stateDir, "provider-configs.json"));
+    const settingsRepo = new SettingsRepo({
+      filePath: join(stateDir, "settings.json"),
+    });
     workspaceRepo = new WorkspaceRepo({
       filePath: join(stateDir, "workspaces.json"),
     });
@@ -79,6 +83,7 @@ describe("Session Commands", () => {
       terminalMgr: {} as never,
       eventBus,
       broadcaster,
+      settingsRepo,
       providerRegistry: [],
       fencingMgr: {} as never,
       supervisorMgr: {} as never,
@@ -163,6 +168,73 @@ describe("Session Commands", () => {
       }
     });
 
+    it("publishes agent instructions before session.create starts the agent", async () => {
+      const testDir = join(tmpdir(), `coder-studio-session-publish-${Date.now()}`);
+      mkdirSync(join(testDir, ".git"), { recursive: true });
+      writeFileSync(join(testDir, ".git", "HEAD"), "ref: refs/heads/main\n");
+
+      const calls: string[] = [];
+      ctx.providerRegistry = providerRegistry as ProviderDefinition[];
+      ctx.providerRuntimeDeps = {
+        commandExists: async (command: string) => command === "claude",
+      };
+      ctx.agentInstructionPublisher = {
+        syncWorkspace: vi.fn(async () => {
+          calls.push("publish");
+        }),
+        scheduleWorkspaceSync: vi.fn(),
+        syncAllOpenWorkspaces: vi.fn(),
+      } as never;
+
+      const createSpy = vi.spyOn(sessionMgr, "create").mockImplementation(async () => {
+        calls.push("create");
+        return {
+          id: "sess-1",
+          workspaceId: "ws-1",
+          providerId: "claude",
+          terminalId: "term-1",
+          capability: "full",
+          state: "starting",
+          startedAt: Date.now(),
+          lastActiveAt: Date.now(),
+        };
+      });
+
+      try {
+        const openResult = await dispatch(
+          {
+            kind: "command",
+            id: "workspace-publish-order",
+            op: "workspace.open",
+            args: { path: testDir },
+          },
+          ctx
+        );
+
+        expect(openResult.ok).toBe(true);
+        calls.length = 0;
+
+        const result = await dispatch(
+          {
+            kind: "command",
+            id: "session-publish-order",
+            op: "session.create",
+            args: {
+              workspaceId: openResult.data!.id,
+              providerId: "claude",
+            },
+          },
+          ctx
+        );
+
+        expect(result.ok).toBe(true);
+        expect(calls).toEqual(["publish", "create"]);
+      } finally {
+        createSpy.mockRestore();
+        rmSync(testDir, { recursive: true, force: true });
+      }
+    });
+
     it("launches a custom provider through the existing session.create flow", async () => {
       const testDir = join(tmpdir(), `coder-studio-custom-provider-session-${Date.now()}`);
       mkdirSync(join(testDir, ".git"), { recursive: true });
@@ -235,6 +307,61 @@ describe("Session Commands", () => {
       }
     });
 
+    it.each([
+      { providerId: "gemini", command: "gemini", expectedCapability: "full" },
+      { providerId: "cursor", command: "agent", expectedCapability: "full" },
+      { providerId: "opencode", command: "opencode", expectedCapability: "limited" },
+    ])("launches $providerId through the shared session.create flow", async ({
+      providerId,
+      command,
+      expectedCapability,
+    }) => {
+      const testDir = join(tmpdir(), `coder-studio-${providerId}-session-${Date.now()}`);
+      mkdirSync(join(testDir, ".git"), { recursive: true });
+      writeFileSync(join(testDir, ".git", "HEAD"), "ref: refs/heads/main\n");
+
+      ctx.providerRegistry = providerRegistry as ProviderDefinition[];
+      ctx.providerRuntimeDeps = {
+        commandExists: async (candidate: string) => candidate === command,
+      };
+
+      try {
+        const openResult = await dispatch(
+          {
+            kind: "command",
+            id: `workspace-${providerId}`,
+            op: "workspace.open",
+            args: { path: testDir },
+          },
+          ctx
+        );
+
+        expect(openResult.ok).toBe(true);
+
+        const result = await dispatch(
+          {
+            kind: "command",
+            id: `session-${providerId}`,
+            op: "session.create",
+            args: {
+              workspaceId: openResult.data!.id,
+              providerId,
+            },
+          },
+          ctx
+        );
+
+        expect(result.ok).toBe(true);
+        expect(result.data).toMatchObject({
+          providerId,
+          capability: expectedCapability,
+          state: "starting",
+        });
+      } finally {
+        rmSync(testDir, { recursive: true, force: true });
+      }
+    });
+
     it("captures session objective and git baseline metadata when available", async () => {
       const testDir = join(tmpdir(), `coder-studio-session-metadata-${Date.now()}`);
       mkdirSync(testDir, { recursive: true });