tower-studio 0.1.1 → 0.1.2

package/.next/standalone/tower/tests/unit/actions/file-actions.test.ts

@@ -0,0 +1,283 @@
+// @vitest-environment node
+import { vi, describe, it, expect, beforeEach } from "vitest";
+import * as fs from "fs/promises";
+import * as fsSync from "fs";
+import * as childProcess from "child_process";
+
+vi.mock("next/cache", () => ({ revalidatePath: vi.fn() }));
+vi.mock("fs/promises");
+vi.mock("fs");
+vi.mock("child_process");
+
+let mockIgnoreInstance: { add: ReturnType<typeof vi.fn>; ignores: ReturnType<typeof vi.fn> };
+
+vi.mock("ignore", () => {
+  return {
+    default: vi.fn(() => mockIgnoreInstance),
+  };
+});
+
+vi.mock("@/lib/fs-security", () => ({
+  safeResolvePath: vi.fn((base: string, rel: string) => {
+    const nodePath = require("path");
+    const resolved = nodePath.resolve(base, rel);
+    if (!resolved.startsWith(base)) throw new Error("Path traversal attempt");
+    return resolved;
+  }),
+}));
+
+import {
+  listDirectory,
+  createFile,
+  createDirectory,
+  renameEntry,
+  deleteEntry,
+  getGitStatus,
+} from "@/actions/file-actions";
+import { safeResolvePath } from "@/lib/fs-security";
+
+function makeDirent(name: string, isDir: boolean) {
+  return {
+    name,
+    isDirectory: () => isDir,
+    isFile: () => !isDir,
+    isBlockDevice: () => false,
+    isCharacterDevice: () => false,
+    isFIFO: () => false,
+    isSocket: () => false,
+    isSymbolicLink: () => false,
+  };
+}
+
+describe("listDirectory", () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+    // Fresh ignore mock for each test — default: filters .git and node_modules
+    mockIgnoreInstance = {
+      add: vi.fn().mockReturnThis(),
+      ignores: vi.fn((rel: string) => rel === ".git" || rel.startsWith(".git/") || rel === "node_modules"),
+    };
+    vi.mocked(fsSync.existsSync).mockReturnValue(false);
+  });
+
+  it("returns sorted entries with isDirectory flag", async () => {
+    vi.mocked(fs.readdir).mockResolvedValue([
+      makeDirent("zebra.ts", false),
+      makeDirent("alpha", true),
+      makeDirent("beta.ts", false),
+    ] as any);
+
+    const entries = await listDirectory("/worktree", ".");
+    expect(entries[0].isDirectory).toBe(true);
+    expect(entries[0].name).toBe("alpha");
+    expect(entries[1].name).toBe("beta.ts");
+    expect(entries[2].name).toBe("zebra.ts");
+    entries.forEach((e) => {
+      expect(e).toHaveProperty("name");
+      expect(e).toHaveProperty("relativePath");
+      expect(e).toHaveProperty("isDirectory");
+    });
+  });
+
+  it("filters gitignored entries", async () => {
+    vi.mocked(fsSync.existsSync).mockReturnValue(true);
+    vi.mocked(fs.readFile).mockResolvedValue("node_modules\n" as any);
+    vi.mocked(fs.readdir).mockResolvedValue([
+      makeDirent("src", true),
+      makeDirent("node_modules", true),
+    ] as any);
+
+    const entries = await listDirectory("/worktree", ".");
+    const names = entries.map((e) => e.name);
+    expect(names).not.toContain("node_modules");
+    expect(names).toContain("src");
+  });
+
+  it("always filters .git/ directory", async () => {
+    vi.mocked(fsSync.existsSync).mockReturnValue(false);
+    vi.mocked(fs.readdir).mockResolvedValue([
+      makeDirent(".git", true),
+      makeDirent("src", true),
+    ] as any);
+
+    const entries = await listDirectory("/worktree", ".");
+    const names = entries.map((e) => e.name);
+    expect(names).not.toContain(".git");
+    expect(names).toContain("src");
+  });
+
+  it("returns directories before files, then alphabetical", async () => {
+    vi.mocked(fsSync.existsSync).mockReturnValue(false);
+    vi.mocked(fs.readdir).mockResolvedValue([
+      makeDirent("zebra.ts", false),
+      makeDirent("mango", true),
+      makeDirent("apple.ts", false),
+      makeDirent("banana", true),
+    ] as any);
+
+    const entries = await listDirectory("/worktree", ".");
+    expect(entries[0].name).toBe("banana");
+    expect(entries[0].isDirectory).toBe(true);
+    expect(entries[1].name).toBe("mango");
+    expect(entries[1].isDirectory).toBe(true);
+    expect(entries[2].name).toBe("apple.ts");
+    expect(entries[2].isDirectory).toBe(false);
+    expect(entries[3].name).toBe("zebra.ts");
+    expect(entries[3].isDirectory).toBe(false);
+  });
+});
+
+describe("createFile", () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+    mockIgnoreInstance = {
+      add: vi.fn().mockReturnThis(),
+      ignores: vi.fn(() => false),
+    };
+  });
+
+  it("creates file at validated path", async () => {
+    vi.mocked(fs.writeFile).mockResolvedValue(undefined);
+
+    await createFile("/worktree", "src/new-file.ts");
+    expect(safeResolvePath).toHaveBeenCalledWith("/worktree", "src/new-file.ts");
+    expect(fs.writeFile).toHaveBeenCalledWith(
+      expect.stringContaining("new-file.ts"),
+      "",
+      { flag: "wx" }
+    );
+  });
+
+  it("throws on path traversal", async () => {
+    vi.mocked(safeResolvePath).mockImplementationOnce(() => {
+      throw new Error("Path traversal attempt");
+    });
+
+    await expect(createFile("/worktree", "../../etc/passwd")).rejects.toThrow(
+      "Path traversal attempt"
+    );
+  });
+});
+
+describe("createDirectory", () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+    mockIgnoreInstance = {
+      add: vi.fn().mockReturnThis(),
+      ignores: vi.fn(() => false),
+    };
+  });
+
+  it("creates directory recursively", async () => {
+    vi.mocked(fs.mkdir).mockResolvedValue(undefined);
+
+    await createDirectory("/worktree", "src/new/nested");
+    expect(fs.mkdir).toHaveBeenCalledWith(
+      expect.stringContaining("nested"),
+      { recursive: true }
+    );
+  });
+});
+
+describe("renameEntry", () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+    mockIgnoreInstance = {
+      add: vi.fn().mockReturnThis(),
+      ignores: vi.fn(() => false),
+    };
+  });
+
+  it("renames entry at validated path", async () => {
+    vi.mocked(fs.rename).mockResolvedValue(undefined);
+
+    await renameEntry("/worktree", "old-name.ts", "new-name.ts");
+
+    expect(safeResolvePath).toHaveBeenCalledWith("/worktree", "old-name.ts");
+    expect(safeResolvePath).toHaveBeenCalledWith("/worktree", "new-name.ts");
+    expect(fs.rename).toHaveBeenCalledWith(
+      expect.stringContaining("old-name.ts"),
+      expect.stringContaining("new-name.ts")
+    );
+  });
+});
+
+describe("deleteEntry", () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+    mockIgnoreInstance = {
+      add: vi.fn().mockReturnThis(),
+      ignores: vi.fn(() => false),
+    };
+  });
+
+  it("deletes file for valid path", async () => {
+    vi.mocked(fs.stat).mockResolvedValue({ isDirectory: () => false } as any);
+    vi.mocked(fs.unlink).mockResolvedValue(undefined);
+
+    await deleteEntry("/worktree", "src/old-file.ts");
+    expect(fs.unlink).toHaveBeenCalledWith(expect.stringContaining("old-file.ts"));
+  });
+
+  it("refuses to delete .git/ directory", async () => {
+    await expect(deleteEntry("/worktree", ".git")).rejects.toThrow(
+      "Cannot delete .git directory"
+    );
+    // stat and unlink/rm should NOT be called
+    expect(fs.stat).not.toHaveBeenCalled();
+    expect(fs.unlink).not.toHaveBeenCalled();
+    expect(fs.rm).not.toHaveBeenCalled();
+  });
+
+  it("recursively deletes directories with rm({ recursive: true })", async () => {
+    vi.mocked(fs.stat).mockResolvedValue({ isDirectory: () => true } as any);
+    vi.mocked(fs.rm).mockResolvedValue(undefined);
+
+    await deleteEntry("/worktree", "src/old-dir");
+    expect(fs.rm).toHaveBeenCalledWith(
+      expect.stringContaining("old-dir"),
+      { recursive: true, force: true }
+    );
+  });
+});
+
+describe("getGitStatus", () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+    mockIgnoreInstance = {
+      add: vi.fn().mockReturnThis(),
+      ignores: vi.fn(() => false),
+    };
+  });
+
+  it("parses M, A, D lines from git diff output", async () => {
+    vi.mocked(childProcess.execFileSync).mockReturnValue(
+      "M\tsrc/modified.ts\nA\tsrc/added.ts\nD\tsrc/deleted.ts\n" as any
+    );
+
+    const result = await getGitStatus("/worktree", "main", "task/123");
+    expect(result["src/modified.ts"]).toBe("M");
+    expect(result["src/added.ts"]).toBe("A");
+    expect(result["src/deleted.ts"]).toBe("D");
+  });
+
+  it("returns empty map on git error", async () => {
+    vi.mocked(childProcess.execFileSync).mockImplementation(() => {
+      throw new Error("git: not a git repository");
+    });
+
+    const result = await getGitStatus("/worktree", "main", "task/123");
+    expect(result).toEqual({});
+  });
+
+  it("ignores unrecognized status letters", async () => {
+    vi.mocked(childProcess.execFileSync).mockReturnValue(
+      "M\tsrc/modified.ts\nR100\told.ts\tnew.ts\nA\tsrc/added.ts\n" as any
+    );
+
+    const result = await getGitStatus("/worktree", "main", "task/123");
+    expect(Object.keys(result)).toHaveLength(2);
+    expect(result["src/modified.ts"]).toBe("M");
+    expect(result["src/added.ts"]).toBe("A");
+  });
+});

package/.next/standalone/tower/tests/unit/actions/git-actions.test.ts

@@ -0,0 +1,34 @@
+// @vitest-environment node
+import { describe, it, expect, beforeAll } from "vitest";
+
+let getProjectBranchesFn: (localPath: string) => Promise<string[]>;
+
+beforeAll(async () => {
+  // Dynamic import: git-actions.ts uses "use server" directive
+  const mod = await import("@/actions/git-actions");
+  getProjectBranchesFn = mod.getProjectBranches;
+});
+
+describe("getProjectBranches", () => {
+  it("returns an array containing 'main' for the current project root", async () => {
+    const branches = await getProjectBranchesFn(process.cwd());
+    expect(Array.isArray(branches)).toBe(true);
+    expect(branches.length).toBeGreaterThan(0);
+    expect(branches).toContain("main");
+  });
+
+  it("returns empty array for empty string input", async () => {
+    const branches = await getProjectBranchesFn("");
+    expect(branches).toEqual([]);
+  });
+
+  it("returns empty array for nonexistent path without throwing", async () => {
+    const branches = await getProjectBranchesFn("/nonexistent/path/xyz");
+    expect(branches).toEqual([]);
+  });
+
+  it("returns empty array for whitespace-only input", async () => {
+    const branches = await getProjectBranchesFn("   ");
+    expect(branches).toEqual([]);
+  });
+});

package/.next/standalone/tower/tests/unit/actions/preview-actions.test.ts

@@ -0,0 +1,177 @@
+// @vitest-environment node
+import { describe, it, expect, vi, beforeEach } from "vitest";
+
+// Mock node:child_process
+vi.mock("node:child_process", () => ({
+  spawn: vi.fn(),
+  execFileSync: vi.fn(),
+}));
+
+// Mock preview-process-manager
+vi.mock("@/lib/preview-process", () => ({
+  registerPreviewProcess: vi.fn(),
+  killPreviewProcess: vi.fn(),
+  isPreviewRunning: vi.fn(),
+}));
+
+// Mock config-reader
+vi.mock("@/lib/config-reader", () => ({
+  readConfigValue: vi.fn(),
+}));
+
+// Mock next/cache (required for "use server" actions)
+vi.mock("next/cache", () => ({
+  revalidatePath: vi.fn(),
+}));
+
+import { spawn, execFileSync } from "node:child_process";
+import {
+  registerPreviewProcess,
+  killPreviewProcess,
+  isPreviewRunning,
+} from "@/lib/preview-process";
+import { readConfigValue } from "@/lib/config-reader";
+import { startPreview, stopPreview, openInTerminal } from "@/actions/preview-actions";
+
+import type { ChildProcess } from "node:child_process";
+
+const mockedSpawn = vi.mocked(spawn);
+const mockedExecFileSync = vi.mocked(execFileSync);
+const mockedRegisterPreviewProcess = vi.mocked(registerPreviewProcess);
+const mockedKillPreviewProcess = vi.mocked(killPreviewProcess);
+const mockedIsPreviewRunning = vi.mocked(isPreviewRunning);
+const mockedReadConfigValue = vi.mocked(readConfigValue);
+
+function makeFakeChild(): ChildProcess {
+  return {
+    killed: false,
+    kill: vi.fn(),
+    pid: 12345,
+  } as unknown as ChildProcess;
+}
+
+beforeEach(() => {
+  vi.clearAllMocks();
+  mockedReadConfigValue.mockResolvedValue("Terminal");
+  mockedIsPreviewRunning.mockReturnValue(false);
+  mockedKillPreviewProcess.mockReturnValue(false);
+});
+
+describe("startPreview", () => {
+  it("spawns process with correct args and returns { started: true }", async () => {
+    const fakeChild = makeFakeChild();
+    mockedSpawn.mockReturnValue(fakeChild);
+
+    const result = await startPreview("task-1", "pnpm dev", "/some/path");
+
+    expect(mockedSpawn).toHaveBeenCalledWith("pnpm", ["dev"], {
+      cwd: "/some/path",
+      shell: false,
+      detached: false,
+      stdio: "ignore",
+    });
+    expect(mockedRegisterPreviewProcess).toHaveBeenCalledWith("task-1", fakeChild);
+    expect(result).toEqual({ started: true });
+  });
+
+  it("handles single-word command (no args)", async () => {
+    const fakeChild = makeFakeChild();
+    mockedSpawn.mockReturnValue(fakeChild);
+
+    await startPreview("task-1", "npm", "/some/path");
+
+    expect(mockedSpawn).toHaveBeenCalledWith("npm", [], expect.any(Object));
+  });
+
+  it("handles multi-word command correctly", async () => {
+    const fakeChild = makeFakeChild();
+    mockedSpawn.mockReturnValue(fakeChild);
+
+    await startPreview("task-1", "node server.js --port 3000", "/some/path");
+
+    expect(mockedSpawn).toHaveBeenCalledWith(
+      "node",
+      ["server.js", "--port", "3000"],
+      expect.any(Object)
+    );
+  });
+
+  it("kills existing process first when already running", async () => {
+    mockedIsPreviewRunning.mockReturnValue(true);
+    const fakeChild = makeFakeChild();
+    mockedSpawn.mockReturnValue(fakeChild);
+
+    await startPreview("task-1", "pnpm dev", "/some/path");
+
+    expect(mockedKillPreviewProcess).toHaveBeenCalledWith("task-1");
+    expect(mockedSpawn).toHaveBeenCalled();
+  });
+
+  it("does NOT kill process when not already running", async () => {
+    mockedIsPreviewRunning.mockReturnValue(false);
+    const fakeChild = makeFakeChild();
+    mockedSpawn.mockReturnValue(fakeChild);
+
+    await startPreview("task-1", "pnpm dev", "/some/path");
+
+    expect(mockedKillPreviewProcess).not.toHaveBeenCalled();
+  });
+
+  it("returns { started: false, error } when spawn throws", async () => {
+    mockedSpawn.mockImplementation(() => {
+      throw new Error("ENOENT");
+    });
+
+    const result = await startPreview("task-1", "pnpm dev", "/some/path");
+
+    expect(result.started).toBe(false);
+    expect(result.error).toContain("ENOENT");
+  });
+});
+
+describe("stopPreview", () => {
+  it("calls killPreviewProcess with the correct taskId", async () => {
+    await stopPreview("task-1");
+    expect(mockedKillPreviewProcess).toHaveBeenCalledWith("task-1");
+  });
+
+  it("returns undefined (void)", async () => {
+    const result = await stopPreview("task-1");
+    expect(result).toBeUndefined();
+  });
+});
+
+describe("openInTerminal", () => {
+  it("calls execFileSync with open, -a, terminal app, and path", async () => {
+    mockedReadConfigValue.mockResolvedValue("Terminal");
+
+    await openInTerminal("/some/worktree/path");
+
+    expect(mockedExecFileSync).toHaveBeenCalledWith("open", [
+      "-a",
+      "Terminal",
+      "/some/worktree/path",
+    ]);
+  });
+
+  it("reads terminal app from readConfigValue", async () => {
+    mockedReadConfigValue.mockResolvedValue("iTerm");
+
+    await openInTerminal("/some/path");
+
+    expect(mockedReadConfigValue).toHaveBeenCalledWith("terminal.app", "Terminal");
+    expect(mockedExecFileSync).toHaveBeenCalledWith("open", ["-a", "iTerm", "/some/path"]);
+  });
+
+  it("uses default Terminal app when readConfigValue returns Terminal", async () => {
+    mockedReadConfigValue.mockResolvedValue("Terminal");
+
+    await openInTerminal("/another/path");
+
+    expect(mockedExecFileSync).toHaveBeenCalledWith("open", [
+      "-a",
+      "Terminal",
+      "/another/path",
+    ]);
+  });
+});