tower-studio 0.1.2 → 0.1.3

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

@@ -1,157 +0,0 @@
-// @vitest-environment node
-import { describe, it, expect, beforeAll, afterAll, afterEach, vi } from "vitest";
-import { PrismaClient } from "@prisma/client";
-
-// Mock next/cache to avoid "static generation store missing" error in test environment
-vi.mock("next/cache", () => ({
-  revalidatePath: vi.fn(),
-  revalidateTag: vi.fn(),
-}));
-
-const testDb = new PrismaClient({
-  datasources: {
-    db: { url: process.env.DATABASE_URL ?? "file:./prisma/dev.db" },
-  },
-});
-
-let startTaskExecutionFn: (
-  taskId: string,
-  agent?: string,
-  worktreePath?: string,
-  worktreeBranch?: string
-) => Promise<any>;
-
-let workspaceId: string;
-let projectId: string;
-let taskId: string;
-
-beforeAll(async () => {
-  await testDb.$connect();
-
-  // Dynamic import: agent-actions.ts uses "use server" directive
-  const mod = await import("@/actions/agent-actions");
-  startTaskExecutionFn = mod.startTaskExecution as any;
-
-  // Create workspace, project, and task for tests
-  const workspace = await testDb.workspace.create({
-    data: { name: "Test Workspace for agent-actions" },
-  });
-  workspaceId = workspace.id;
-
-  const project = await testDb.project.create({
-    data: { name: "Test Project for agent-actions", workspaceId },
-  });
-  projectId = project.id;
-
-  const task = await testDb.task.create({
-    data: { title: "Test Task for agent-actions", projectId },
-  });
-  taskId = task.id;
-});
-
-afterAll(async () => {
-  // Clean up test workspace (cascades to projects, tasks, executions)
-  await testDb.workspace.deleteMany({
-    where: { name: "Test Workspace for agent-actions" },
-  });
-  await testDb.$disconnect();
-});
-
-afterEach(async () => {
-  // Clean up executions after each test
-  await testDb.taskExecution.deleteMany({ where: { taskId } });
-  // Reset task status back to TODO
-  await testDb.task.update({ where: { id: taskId }, data: { status: "TODO" } });
-});
-
-let getActiveExecutionsFn: () => Promise<any[]>;
-
-describe("getActiveExecutionsAcrossWorkspaces", () => {
-  beforeAll(async () => {
-    const mod = await import("@/actions/agent-actions");
-    getActiveExecutionsFn = mod.getActiveExecutionsAcrossWorkspaces as any;
-  });
-
-  it("returns empty array when no RUNNING executions exist", async () => {
-    // Ensure no running executions
-    await testDb.taskExecution.updateMany({
-      where: { taskId, status: "RUNNING" },
-      data: { status: "FAILED", endedAt: new Date() },
-    });
-    const result = await getActiveExecutionsFn();
-    expect(Array.isArray(result)).toBe(true);
-    expect(result.filter((e: any) => e.taskId === taskId)).toEqual([]);
-  });
-
-  it("returns RUNNING executions with full join chain", async () => {
-    const execution = await testDb.taskExecution.create({
-      data: {
-        taskId,
-        agent: "CLAUDE_CODE",
-        status: "RUNNING",
-        startedAt: new Date(),
-      },
-    });
-
-    const result = await getActiveExecutionsFn();
-    const found = result.find((e: any) => e.executionId === execution.id);
-    expect(found).toBeDefined();
-    expect(found).toMatchObject({
-      executionId: execution.id,
-      taskId,
-      projectId,
-      workspaceId,
-    });
-    expect(typeof found.taskTitle).toBe("string");
-    expect(typeof found.projectName).toBe("string");
-    expect(typeof found.workspaceName).toBe("string");
-
-    // Cleanup
-    await testDb.taskExecution.delete({ where: { id: execution.id } });
-  });
-
-  it("excludes COMPLETED and FAILED executions", async () => {
-    const completed = await testDb.taskExecution.create({
-      data: { taskId, agent: "CLAUDE_CODE", status: "COMPLETED", startedAt: new Date(), endedAt: new Date() },
-    });
-    const failed = await testDb.taskExecution.create({
-      data: { taskId, agent: "CLAUDE_CODE", status: "FAILED", startedAt: new Date(), endedAt: new Date() },
-    });
-
-    const result = await getActiveExecutionsFn();
-    const ids = result.map((e: any) => e.executionId);
-    expect(ids).not.toContain(completed.id);
-    expect(ids).not.toContain(failed.id);
-
-    await testDb.taskExecution.deleteMany({ where: { id: { in: [completed.id, failed.id] } } });
-  });
-});
-
-describe("startTaskExecution with worktree fields", () => {
-  it("persists worktreePath and worktreeBranch when provided", async () => {
-    const execution = await startTaskExecutionFn(
-      taskId,
-      "CLAUDE_CODE",
-      "/tmp/wt",
-      "task/abc123"
-    );
-
-    const found = await testDb.taskExecution.findUnique({
-      where: { id: execution.id },
-    });
-    expect(found).not.toBeNull();
-    expect(found!.worktreePath).toBe("/tmp/wt");
-    expect(found!.worktreeBranch).toBe("task/abc123");
-  });
-
-  it("results in null for both worktree fields when not provided", async () => {
-    const execution = await startTaskExecutionFn(taskId);
-
-    const found = await testDb.taskExecution.findUnique({
-      where: { id: execution.id },
-    });
-    expect(found).not.toBeNull();
-    expect(found!.worktreePath).toBeNull();
-    expect(found!.worktreeBranch).toBeNull();
-  });
-});

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

@@ -1,170 +0,0 @@
-// @vitest-environment node
-import { describe, it, expect, beforeAll, afterAll, afterEach } from "vitest";
-import { PrismaClient } from "@prisma/client";
-
-const testDb = new PrismaClient({
-  datasources: {
-    db: { url: process.env.DATABASE_URL ?? "file:./prisma/dev.db" },
-  },
-});
-
-let getConfigValueFn: <T>(key: string, defaultValue: T) => Promise<T>;
-let setConfigValueFn: (key: string, value: unknown) => Promise<void>;
-let getConfigValuesFn: (keys: string[]) => Promise<Record<string, unknown>>;
-let resolveGitLocalPathFn: (url: string) => Promise<string>;
-
-beforeAll(async () => {
-  await testDb.$connect();
-
-  // Dynamic import: config-actions.ts uses "use server" directive
-  const mod = await import("@/actions/config-actions");
-  getConfigValueFn = mod.getConfigValue;
-  setConfigValueFn = mod.setConfigValue;
-  getConfigValuesFn = mod.getConfigValues;
-  resolveGitLocalPathFn = mod.resolveGitLocalPath;
-});
-
-afterAll(async () => {
-  await testDb.$disconnect();
-});
-
-afterEach(async () => {
-  // Clean up test rows
-  await testDb.$executeRawUnsafe(
-    `DELETE FROM SystemConfig WHERE key LIKE 'test.%' OR key = 'git.pathMappingRules'`
-  );
-});
-
-describe("getConfigValue", () => {
-  it("returns defaultValue when key does not exist in DB", async () => {
-    const result = await getConfigValueFn("test.nonexistent.key", 42);
-    expect(result).toBe(42);
-  });
-
-  it("returns stored string value after setConfigValue", async () => {
-    await setConfigValueFn("test.key.str", "hello");
-    const result = await getConfigValueFn("test.key.str", "");
-    expect(result).toBe("hello");
-  });
-
-  it("returns stored number value after setConfigValue", async () => {
-    await setConfigValueFn("test.key.num", 100);
-    const result = await getConfigValueFn("test.key.num", 0);
-    expect(result).toBe(100);
-  });
-
-  it("returns stored boolean value after setConfigValue", async () => {
-    await setConfigValueFn("test.key.bool", true);
-    const result = await getConfigValueFn("test.key.bool", false);
-    expect(result).toBe(true);
-  });
-
-  it("returns defaultValue when stored value is malformed JSON", async () => {
-    // Directly insert a malformed JSON value
-    await testDb.$executeRawUnsafe(
-      `INSERT INTO SystemConfig (id, key, value, createdAt, updatedAt) VALUES ('test-malformed-id', 'test.malformed', 'not-valid-json{{', datetime('now'), datetime('now'))`
-    );
-    const result = await getConfigValueFn("test.malformed", "fallback");
-    expect(result).toBe("fallback");
-  });
-});
-
-describe("setConfigValue", () => {
-  it("creates a new row when key does not exist", async () => {
-    await setConfigValueFn("test.new.key", "value1");
-    const row = await testDb.$queryRaw<{ value: string }[]>`
-      SELECT value FROM SystemConfig WHERE key = 'test.new.key'
-    `;
-    expect(row).toHaveLength(1);
-    expect(JSON.parse((row[0] as { value: string }).value)).toBe("value1");
-  });
-
-  it("updates existing row when key already exists (upsert update path)", async () => {
-    await setConfigValueFn("test.upsert.key", "v1");
-    await setConfigValueFn("test.upsert.key", "v2");
-    const result = await getConfigValueFn("test.upsert.key", "");
-    expect(result).toBe("v2");
-
-    // Confirm only one row exists
-    const rows = await testDb.$queryRaw<{ count: number }[]>`
-      SELECT COUNT(*) as count FROM SystemConfig WHERE key = 'test.upsert.key'
-    `;
-    expect(Number((rows[0] as { count: number }).count)).toBe(1);
-  });
-});
-
-describe("getConfigValues", () => {
-  it("returns stored values for existing keys and null for missing keys", async () => {
-    await setConfigValueFn("test.batch.key1", "value-a");
-    await setConfigValueFn("test.batch.key2", 999);
-
-    const result = await getConfigValuesFn([
-      "test.batch.key1",
-      "test.batch.key2",
-      "test.batch.missing",
-    ]);
-
-    expect(result["test.batch.key1"]).toBe("value-a");
-    expect(result["test.batch.key2"]).toBe(999);
-    expect(result["test.batch.missing"]).toBeNull();
-  });
-
-  it("returns CONFIG_DEFAULTS defaultValue for keys registered in defaults", async () => {
-    // git.pathMappingRules is in CONFIG_DEFAULTS with defaultValue: []
-    const result = await getConfigValuesFn(["git.pathMappingRules"]);
-    expect(result["git.pathMappingRules"]).toEqual([]);
-  });
-});
-
-describe("resolveGitLocalPath", () => {
-  it("returns empty string for empty URL input", async () => {
-    const result = await resolveGitLocalPathFn("");
-    expect(result).toBe("");
-  });
-
-  it("returns empty string for whitespace-only URL input", async () => {
-    const result = await resolveGitLocalPathFn("   ");
-    expect(result).toBe("");
-  });
-
-  it("falls back to hardcoded gitUrlToLocalPath when no rules in DB", async () => {
-    // No rules stored, should use hardcoded logic for github.com/jp-liu
-    const result = await resolveGitLocalPathFn("https://github.com/jp-liu/test-repo");
-    // Hardcoded logic maps jp-liu → ~/project/i/{repo}
-    expect(result).toContain("project/i/test-repo");
-  });
-
-  it("uses rule-based matching when matching rules exist in DB", async () => {
-    const rules = [
-      {
-        id: "rule-1",
-        host: "github.com",
-        ownerMatch: "jp-liu",
-        localPathTemplate: "~/custom/path/{repo}",
-        priority: 0,
-      },
-    ];
-    await setConfigValueFn("git.pathMappingRules", rules);
-
-    const result = await resolveGitLocalPathFn("https://github.com/jp-liu/test-repo");
-    const home = (await import("os")).default.homedir();
-    expect(result).toBe(`${home}/custom/path/test-repo`);
-  });
-
-  it("falls back to hardcoded logic when no rule matches the URL", async () => {
-    const rules = [
-      {
-        id: "rule-1",
-        host: "gitlab.com",
-        ownerMatch: "*",
-        localPathTemplate: "~/gitlab/{repo}",
-        priority: 0,
-      },
-    ];
-    await setConfigValueFn("git.pathMappingRules", rules);
-
-    // URL is github.com, rule is for gitlab.com — should fall back
-    const result = await resolveGitLocalPathFn("https://github.com/jp-liu/test-repo");
-    expect(result).toContain("project/i/test-repo");
-  });
-});

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([]);
-  });
-});