tower-studio 0.1.2 → 0.1.5

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

@@ -1,283 +0,0 @@
-// @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

@@ -1,34 +0,0 @@
-// @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

@@ -1,177 +0,0 @@
-// @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",
-    ]);
-  });
-});