tower-studio 0.1.2 → 0.1.3

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

@@ -1,257 +0,0 @@
-// @vitest-environment node
-import { describe, it, expect, beforeAll, afterAll, vi } from "vitest";
-import { PrismaClient } from "@prisma/client";
-import * as fileUtils from "@/lib/file-utils";
-
-// Mock next/cache before importing server actions
-vi.mock("next/cache", () => ({
-  revalidatePath: vi.fn(),
-}));
-
-import {
-  createAsset,
-  deleteAsset,
-  getProjectAssets,
-  getAssetById,
-} from "@/actions/asset-actions";
-
-const testDb = new PrismaClient({
-  datasources: {
-    db: { url: process.env.DATABASE_URL ?? "file:./prisma/dev.db" },
-  },
-});
-
-let testWorkspaceId: string;
-let testProjectId: string;
-
-beforeAll(async () => {
-  await testDb.$connect();
-
-  const workspace = await testDb.workspace.create({
-    data: { name: "Asset Actions Test Workspace" },
-  });
-  testWorkspaceId = workspace.id;
-
-  const project = await testDb.project.create({
-    data: {
-      name: "Asset Actions Test Project",
-      workspaceId: testWorkspaceId,
-    },
-  });
-  testProjectId = project.id;
-
-  // Spy on ensureAssetsDir to avoid creating real directories in tests
-  vi.spyOn(fileUtils, "ensureAssetsDir").mockReturnValue("/fake/assets/dir");
-});
-
-afterAll(async () => {
-  await testDb.projectAsset.deleteMany({ where: { projectId: testProjectId } });
-  await testDb.workspace.delete({ where: { id: testWorkspaceId } });
-  await testDb.$disconnect();
-  vi.restoreAllMocks();
-});
-
-describe("createAsset", () => {
-  it("creates an asset record with correct fields", async () => {
-    const asset = await createAsset({
-      filename: "screenshot.png",
-      path: `/data/assets/${testProjectId}/screenshot.png`,
-      mimeType: "image/png",
-      size: 1024,
-      projectId: testProjectId,
-    });
-
-    expect(asset.id).toBeTruthy();
-    expect(asset.filename).toBe("screenshot.png");
-    expect(asset.mimeType).toBe("image/png");
-    expect(asset.size).toBe(1024);
-    expect(asset.projectId).toBe(testProjectId);
-
-    // Cleanup
-    await testDb.projectAsset.delete({ where: { id: asset.id } });
-  });
-
-  it("calls ensureAssetsDir before creating db record", async () => {
-    const ensureSpy = vi.spyOn(fileUtils, "ensureAssetsDir").mockReturnValue("/fake/assets/dir");
-
-    await createAsset({
-      filename: "doc.pdf",
-      path: `/data/assets/${testProjectId}/doc.pdf`,
-      projectId: testProjectId,
-    });
-
-    expect(ensureSpy).toHaveBeenCalledWith(testProjectId);
-
-    // Cleanup — find and delete the asset
-    const assets = await testDb.projectAsset.findMany({
-      where: { projectId: testProjectId, filename: "doc.pdf" },
-    });
-    for (const a of assets) {
-      await testDb.projectAsset.delete({ where: { id: a.id } });
-    }
-  });
-
-  it("creates an asset without optional fields (mimeType, size)", async () => {
-    const asset = await createAsset({
-      filename: "notes.txt",
-      path: `/data/assets/${testProjectId}/notes.txt`,
-      projectId: testProjectId,
-    });
-
-    expect(asset.filename).toBe("notes.txt");
-    expect(asset.mimeType).toBeNull();
-    expect(asset.size).toBeNull();
-
-    // Cleanup
-    await testDb.projectAsset.delete({ where: { id: asset.id } });
-  });
-
-  it("throws ZodError for empty filename", async () => {
-    await expect(
-      createAsset({
-        filename: "",
-        path: "/some/path",
-        projectId: testProjectId,
-      })
-    ).rejects.toThrow();
-  });
-
-  it("throws ZodError for missing projectId", async () => {
-    await expect(
-      createAsset({
-        filename: "file.txt",
-        path: "/some/path",
-        projectId: "",
-      })
-    ).rejects.toThrow();
-  });
-
-  it("creates an asset with a description", async () => {
-    const asset = await createAsset({
-      filename: "described.png",
-      path: `/data/assets/${testProjectId}/described.png`,
-      mimeType: "image/png",
-      size: 2048,
-      projectId: testProjectId,
-      description: "A screenshot of the dashboard",
-    });
-
-    expect(asset.description).toBe("A screenshot of the dashboard");
-
-    await testDb.projectAsset.delete({ where: { id: asset.id } });
-  });
-
-  it("creates an asset with null description when not provided", async () => {
-    const asset = await createAsset({
-      filename: "no-desc.png",
-      path: `/data/assets/${testProjectId}/no-desc.png`,
-      projectId: testProjectId,
-    });
-
-    // description is optional in Zod, so undefined input -> Prisma uses default (null or "")
-    expect(asset.description === null || asset.description === "").toBe(true);
-
-    await testDb.projectAsset.delete({ where: { id: asset.id } });
-  });
-
-  it("throws ZodError for description exceeding 500 chars", async () => {
-    await expect(
-      createAsset({
-        filename: "long-desc.png",
-        path: `/data/assets/${testProjectId}/long-desc.png`,
-        projectId: testProjectId,
-        description: "x".repeat(501),
-      })
-    ).rejects.toThrow();
-  });
-});
-
-describe("getProjectAssets", () => {
-  it("returns all assets for a project ordered by createdAt desc", async () => {
-    const asset1 = await createAsset({
-      filename: "first.png",
-      path: `/data/assets/${testProjectId}/first.png`,
-      projectId: testProjectId,
-    });
-    const asset2 = await createAsset({
-      filename: "second.png",
-      path: `/data/assets/${testProjectId}/second.png`,
-      projectId: testProjectId,
-    });
-
-    const assets = await getProjectAssets(testProjectId);
-    const filenames = assets.map((a) => a.filename);
-    expect(filenames).toContain("first.png");
-    expect(filenames).toContain("second.png");
-
-    // Cleanup
-    await testDb.projectAsset.deleteMany({
-      where: { id: { in: [asset1.id, asset2.id] } },
-    });
-  });
-
-  it("returns empty array when project has no assets", async () => {
-    // Create a fresh project with no assets
-    const cleanProject = await testDb.project.create({
-      data: { name: "Empty Asset Project", workspaceId: testWorkspaceId },
-    });
-
-    const assets = await getProjectAssets(cleanProject.id);
-    expect(assets).toEqual([]);
-
-    await testDb.project.delete({ where: { id: cleanProject.id } });
-  });
-});
-
-describe("deleteAsset", () => {
-  it("removes the asset record from the database", async () => {
-    const asset = await createAsset({
-      filename: "to-delete.png",
-      path: `/data/assets/${testProjectId}/to-delete.png`,
-      projectId: testProjectId,
-    });
-
-    await deleteAsset(asset.id);
-
-    const found = await testDb.projectAsset.findUnique({ where: { id: asset.id } });
-    expect(found).toBeNull();
-  });
-});
-
-describe("getAssetById", () => {
-  it("returns the asset when found", async () => {
-    const asset = await createAsset({
-      filename: "find-me.jpg",
-      path: `/data/assets/${testProjectId}/find-me.jpg`,
-      projectId: testProjectId,
-    });
-
-    const found = await getAssetById(asset.id);
-    expect(found).not.toBeNull();
-    expect(found!.id).toBe(asset.id);
-    expect(found!.filename).toBe("find-me.jpg");
-
-    // Cleanup
-    await testDb.projectAsset.delete({ where: { id: asset.id } });
-  });
-
-  it("returns null for a non-existent asset", async () => {
-    const found = await getAssetById("nonexistent-asset-id");
-    expect(found).toBeNull();
-  });
-
-  it("returns the description field for an asset", async () => {
-    const asset = await createAsset({
-      filename: "with-desc.jpg",
-      path: `/data/assets/${testProjectId}/with-desc.jpg`,
-      projectId: testProjectId,
-      description: "Test description",
-    });
-
-    const found = await getAssetById(asset.id);
-    expect(found).not.toBeNull();
-    expect(found!.description).toBe("Test description");
-
-    await testDb.projectAsset.delete({ where: { id: asset.id } });
-  });
-});

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

@@ -1,102 +0,0 @@
-// @vitest-environment node
-import { describe, it, expect, beforeAll, afterAll, afterEach } from "vitest";
-import * as os from "node:os";
-import * as fs from "node:fs";
-import * as path from "node:path";
-
-// We'll use vi.spyOn on process.cwd() to redirect the data root to a temp dir
-import { vi } from "vitest";
-
-const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "file-utils-test-"));
-
-// Mock process.cwd() before importing file-utils so DATA_ROOT resolves to tmpDir
-vi.spyOn(process, "cwd").mockReturnValue(tmpDir);
-
-// Import after mocking cwd
-import {
-  getAssetsDir,
-  getCacheDir,
-  ensureAssetsDir,
-  ensureCacheDir,
-  listAssetFiles,
-} from "@/lib/file-utils";
-
-afterAll(() => {
-  fs.rmSync(tmpDir, { recursive: true, force: true });
-  vi.restoreAllMocks();
-});
-
-afterEach(() => {
-  // Clean up data dir between tests
-  const dataDir = path.join(tmpDir, "data");
-  if (fs.existsSync(dataDir)) {
-    fs.rmSync(dataDir, { recursive: true, force: true });
-  }
-});
-
-describe("getAssetsDir", () => {
-  it("returns path ending in data/assets/{projectId}", () => {
-    const result = getAssetsDir("proj123");
-    expect(result).toMatch(/data[/\\]assets[/\\]proj123$/);
-  });
-
-  it("uses different ids for different projects", () => {
-    const a = getAssetsDir("aaa");
-    const b = getAssetsDir("bbb");
-    expect(a).not.toBe(b);
-    expect(a).toMatch(/aaa$/);
-    expect(b).toMatch(/bbb$/);
-  });
-});
-
-describe("getCacheDir", () => {
-  it("returns path ending in data/cache/{taskId}", () => {
-    const result = getCacheDir("task456");
-    expect(result).toMatch(/data[/\\]cache[/\\]task456$/);
-  });
-});
-
-describe("ensureAssetsDir", () => {
-  it("creates the directory and returns the path", () => {
-    const dir = ensureAssetsDir("proj123");
-    expect(fs.existsSync(dir)).toBe(true);
-    expect(dir).toMatch(/data[/\\]assets[/\\]proj123$/);
-  });
-
-  it("is idempotent — does not throw if directory already exists", () => {
-    ensureAssetsDir("proj123");
-    expect(() => ensureAssetsDir("proj123")).not.toThrow();
-  });
-});
-
-describe("ensureCacheDir", () => {
-  it("creates the directory and returns the path", () => {
-    const dir = ensureCacheDir("task456");
-    expect(fs.existsSync(dir)).toBe(true);
-    expect(dir).toMatch(/data[/\\]cache[/\\]task456$/);
-  });
-});
-
-describe("listAssetFiles", () => {
-  it("returns empty array when directory does not exist", () => {
-    const result = listAssetFiles("nonexistent");
-    expect(result).toEqual([]);
-  });
-
-  it("returns filenames when directory has files", () => {
-    const dir = ensureAssetsDir("proj-with-files");
-    fs.writeFileSync(path.join(dir, "file1.png"), "data");
-    fs.writeFileSync(path.join(dir, "file2.pdf"), "data");
-
-    const result = listAssetFiles("proj-with-files");
-    expect(result).toHaveLength(2);
-    expect(result).toContain("file1.png");
-    expect(result).toContain("file2.pdf");
-  });
-
-  it("returns empty array for a project with no files but existing dir", () => {
-    ensureAssetsDir("empty-proj");
-    const result = listAssetFiles("empty-proj");
-    expect(result).toEqual([]);
-  });
-});

package/.next/standalone/tower/tests/unit/lib/fs-security.test.ts

@@ -1,34 +0,0 @@
-// @vitest-environment node
-import { describe, it, expect } from "vitest";
-import { safeResolvePath } from "@/lib/fs-security";
-
-describe("safeResolvePath", () => {
-  const base = "/tmp/worktree";
-
-  it("returns resolved path for valid subpath", () => {
-    const result = safeResolvePath(base, "src/index.ts");
-    expect(result).toBe("/tmp/worktree/src/index.ts");
-  });
-
-  it("allows exact base match (relative='.')", () => {
-    const result = safeResolvePath(base, ".");
-    expect(result).toBe("/tmp/worktree");
-  });
-
-  it("throws on path traversal with ../", () => {
-    expect(() => safeResolvePath(base, "../etc/passwd")).toThrow("Path traversal");
-  });
-
-  it("throws on nested path traversal", () => {
-    expect(() => safeResolvePath(base, "sub/../../etc")).toThrow("Path traversal");
-  });
-
-  it("works with trailing-slash base", () => {
-    const result = safeResolvePath("/tmp/worktree/", "src/file.ts");
-    expect(result).toBe("/tmp/worktree/src/file.ts");
-  });
-
-  it("does not allow a sibling directory", () => {
-    expect(() => safeResolvePath(base, "../worktree2/file.ts")).toThrow("Path traversal");
-  });
-});

package/.next/standalone/tower/tests/unit/lib/fts.test.ts

@@ -1,214 +0,0 @@
-// @vitest-environment node
-import { describe, it, expect, beforeAll, afterAll, afterEach } from "vitest";
-import { PrismaClient } from "@prisma/client";
-import { searchNotes, syncNoteToFts, deleteNoteFromFts } from "@/lib/fts";
-
-const testDb = new PrismaClient({
-  datasources: {
-    db: { url: process.env.DATABASE_URL ?? "file:./prisma/dev.db" },
-  },
-});
-
-let testWorkspaceId: string;
-let testProjectId: string;
-
-beforeAll(async () => {
-  await testDb.$connect();
-
-  // Ensure FTS5 table exists
-  await testDb.$executeRawUnsafe(`
-    CREATE VIRTUAL TABLE IF NOT EXISTS notes_fts
-    USING fts5(
-      note_id UNINDEXED,
-      title,
-      content,
-      tokenize='trigram case_sensitive 0'
-    )
-  `);
-
-  // Create test workspace and project
-  const workspace = await testDb.workspace.create({
-    data: { name: "FTS Test Workspace" },
-  });
-  testWorkspaceId = workspace.id;
-
-  const project = await testDb.project.create({
-    data: {
-      name: "FTS Test Project",
-      workspaceId: testWorkspaceId,
-    },
-  });
-  testProjectId = project.id;
-});
-
-afterAll(async () => {
-  // Clean up test workspace (cascades to projects and notes)
-  await testDb.workspace.delete({ where: { id: testWorkspaceId } });
-  await testDb.$disconnect();
-});
-
-afterEach(async () => {
-  // Remove all notes for this project and clean FTS
-  const notes = await testDb.projectNote.findMany({
-    where: { projectId: testProjectId },
-  });
-  for (const note of notes) {
-    await testDb.$executeRawUnsafe("DELETE FROM notes_fts WHERE note_id = ?", note.id);
-  }
-  await testDb.projectNote.deleteMany({ where: { projectId: testProjectId } });
-});
-
-describe("searchNotes", () => {
-  it("returns empty array for empty query", async () => {
-    const results = await searchNotes(testDb, testProjectId, "");
-    expect(results).toEqual([]);
-  });
-
-  it("returns empty array for whitespace-only query", async () => {
-    const results = await searchNotes(testDb, testProjectId, "   ");
-    expect(results).toEqual([]);
-  });
-
-  it("uses LIKE fallback for 2-char query and finds matching note", async () => {
-    // Create a note and sync it to FTS
-    const note = await testDb.projectNote.create({
-      data: {
-        title: "AB Test Note",
-        content: "Some content here",
-        projectId: testProjectId,
-      },
-    });
-
-    // 2-char query: should use LIKE fallback (not FTS5 which needs 3+ chars)
-    const results = await searchNotes(testDb, testProjectId, "AB");
-    expect(results.length).toBeGreaterThan(0);
-    expect(results[0].note_id).toBe(note.id);
-    expect(results[0].title).toBe("AB Test Note");
-  });
-
-  it("uses FTS5 MATCH for 3+ char query", async () => {
-    const note = await testDb.projectNote.create({
-      data: {
-        title: "API Configuration",
-        content: "This note covers API setup",
-        projectId: testProjectId,
-      },
-    });
-    await syncNoteToFts(testDb, { id: note.id, title: note.title, content: note.content });
-
-    const results = await searchNotes(testDb, testProjectId, "API");
-    expect(results.length).toBeGreaterThan(0);
-    expect(results[0].note_id).toBe(note.id);
-  });
-
-  it("FTS5 search returns Chinese characters (3+ chars)", async () => {
-    const note = await testDb.projectNote.create({
-      data: {
-        title: "账号配置",
-        content: "这是账号相关的配置信息",
-        projectId: testProjectId,
-      },
-    });
-    await syncNoteToFts(testDb, { id: note.id, title: note.title, content: note.content });
-
-    // Chinese "账号配" is 3 chars
-    const results = await searchNotes(testDb, testProjectId, "账号配");
-    expect(results.length).toBeGreaterThan(0);
-    expect(results[0].note_id).toBe(note.id);
-  });
-
-  it("does not return notes from other projects", async () => {
-    // Create another project
-    const otherProject = await testDb.project.create({
-      data: { name: "Other Project", workspaceId: testWorkspaceId },
-    });
-
-    const otherNote = await testDb.projectNote.create({
-      data: {
-        title: "Other Project Note",
-        content: "secret content",
-        projectId: otherProject.id,
-      },
-    });
-    await syncNoteToFts(testDb, { id: otherNote.id, title: otherNote.title, content: otherNote.content });
-
-    const results = await searchNotes(testDb, testProjectId, "secret");
-
-    // Should not find the other project's note
-    const found = results.find((r) => r.note_id === otherNote.id);
-    expect(found).toBeUndefined();
-
-    // Cleanup
-    await testDb.$executeRawUnsafe("DELETE FROM notes_fts WHERE note_id = ?", otherNote.id);
-    await testDb.project.delete({ where: { id: otherProject.id } });
-  });
-});
-
-describe("syncNoteToFts", () => {
-  it("inserts a row into notes_fts", async () => {
-    const note = await testDb.projectNote.create({
-      data: {
-        title: "Sync Test",
-        content: "content for sync test",
-        projectId: testProjectId,
-      },
-    });
-
-    await syncNoteToFts(testDb, { id: note.id, title: note.title, content: note.content });
-
-    const rows = await testDb.$queryRawUnsafe<{ note_id: string }[]>(
-      "SELECT note_id FROM notes_fts WHERE note_id = ?",
-      note.id
-    );
-    expect(rows.length).toBe(1);
-    expect(rows[0].note_id).toBe(note.id);
-  });
-
-  it("replaces existing FTS row on re-sync (delete+insert)", async () => {
-    const note = await testDb.projectNote.create({
-      data: {
-        title: "Original Title",
-        content: "Original content",
-        projectId: testProjectId,
-      },
-    });
-
-    // Sync once
-    await syncNoteToFts(testDb, { id: note.id, title: "Original Title", content: "Original content" });
-    // Sync again with updated data — should not duplicate
-    await syncNoteToFts(testDb, { id: note.id, title: "Updated Title", content: "Updated content" });
-
-    const rows = await testDb.$queryRawUnsafe<{ note_id: string; title: string }[]>(
-      "SELECT note_id, title FROM notes_fts WHERE note_id = ?",
-      note.id
-    );
-    // Should have exactly 1 row with updated title
-    expect(rows.length).toBe(1);
-    expect(rows[0].title).toBe("Updated Title");
-  });
-});
-
-describe("deleteNoteFromFts", () => {
-  it("removes the note from notes_fts", async () => {
-    const note = await testDb.projectNote.create({
-      data: {
-        title: "To Delete",
-        content: "delete me",
-        projectId: testProjectId,
-      },
-    });
-
-    await syncNoteToFts(testDb, { id: note.id, title: note.title, content: note.content });
-    await deleteNoteFromFts(testDb, note.id);
-
-    const rows = await testDb.$queryRawUnsafe<{ note_id: string }[]>(
-      "SELECT note_id FROM notes_fts WHERE note_id = ?",
-      note.id
-    );
-    expect(rows.length).toBe(0);
-  });
-
-  it("does not throw when deleting a non-existent note from FTS", async () => {
-    await expect(deleteNoteFromFts(testDb, "nonexistent-id")).resolves.not.toThrow();
-  });
-});