tower-studio 0.1.0 → 0.1.2

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

@@ -0,0 +1,296 @@
+// @vitest-environment node
+import { describe, it, expect, beforeAll, afterAll, vi } from "vitest";
+import { PrismaClient } from "@prisma/client";
+
+// Mock next/cache before importing server actions
+vi.mock("next/cache", () => ({
+  revalidatePath: vi.fn(),
+}));
+
+// Use real fts.ts — it operates against the same SQLite DB
+import {
+  createNote,
+  updateNote,
+  deleteNote,
+  getNoteById,
+  getProjectNotes,
+} from "@/actions/note-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();
+
+  // 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: "Note Actions Test Workspace" },
+  });
+  testWorkspaceId = workspace.id;
+
+  const project = await testDb.project.create({
+    data: {
+      name: "Note Actions Test Project",
+      workspaceId: testWorkspaceId,
+    },
+  });
+  testProjectId = project.id;
+});
+
+afterAll(async () => {
+  // Delete all notes' FTS entries then clean up workspace (cascade)
+  const notes = await testDb.projectNote.findMany({
+    where: { projectId: testProjectId },
+  });
+  for (const n of notes) {
+    await testDb.$executeRawUnsafe("DELETE FROM notes_fts WHERE note_id = ?", n.id);
+  }
+  await testDb.workspace.delete({ where: { id: testWorkspaceId } });
+  await testDb.$disconnect();
+});
+
+describe("createNote", () => {
+  it("creates a note with default category '备忘'", async () => {
+    const note = await createNote({
+      title: "Test Note Default Category",
+      content: "Some content",
+      projectId: testProjectId,
+    });
+
+    expect(note.id).toBeTruthy();
+    expect(note.title).toBe("Test Note Default Category");
+    expect(note.content).toBe("Some content");
+    expect(note.category).toBe("备忘");
+    expect(note.projectId).toBe(testProjectId);
+
+    // Cleanup
+    await testDb.$executeRawUnsafe("DELETE FROM notes_fts WHERE note_id = ?", note.id);
+    await testDb.projectNote.delete({ where: { id: note.id } });
+  });
+
+  it("creates a note with a custom category", async () => {
+    const note = await createNote({
+      title: "Account Note",
+      content: "Login credentials",
+      category: "账号",
+      projectId: testProjectId,
+    });
+
+    expect(note.category).toBe("账号");
+
+    // Cleanup
+    await testDb.$executeRawUnsafe("DELETE FROM notes_fts WHERE note_id = ?", note.id);
+    await testDb.projectNote.delete({ where: { id: note.id } });
+  });
+
+  it("syncs note to FTS after creation", async () => {
+    const note = await createNote({
+      title: "FTS Sync Test Note",
+      content: "Should appear in FTS",
+      projectId: testProjectId,
+    });
+
+    const rows = await testDb.$queryRawUnsafe<{ note_id: string }[]>(
+      "SELECT note_id FROM notes_fts WHERE note_id = ?",
+      note.id
+    );
+    expect(rows.length).toBe(1);
+
+    // Cleanup
+    await testDb.$executeRawUnsafe("DELETE FROM notes_fts WHERE note_id = ?", note.id);
+    await testDb.projectNote.delete({ where: { id: note.id } });
+  });
+
+  it("throws ZodError for empty title", async () => {
+    await expect(
+      createNote({
+        title: "",
+        content: "Some content",
+        projectId: testProjectId,
+      })
+    ).rejects.toThrow();
+  });
+
+  it("throws ZodError for missing projectId", async () => {
+    await expect(
+      createNote({
+        title: "Valid Title",
+        content: "Some content",
+        projectId: "",
+      })
+    ).rejects.toThrow();
+  });
+});
+
+describe("updateNote", () => {
+  it("updates the title and content of a note", async () => {
+    const note = await createNote({
+      title: "Original Title",
+      content: "Original content",
+      projectId: testProjectId,
+    });
+
+    const updated = await updateNote(note.id, {
+      title: "Updated Title",
+      content: "Updated content",
+    });
+
+    expect(updated.title).toBe("Updated Title");
+    expect(updated.content).toBe("Updated content");
+    expect(updated.id).toBe(note.id);
+
+    // Cleanup
+    await testDb.$executeRawUnsafe("DELETE FROM notes_fts WHERE note_id = ?", note.id);
+    await testDb.projectNote.delete({ where: { id: note.id } });
+  });
+
+  it("re-syncs FTS after update", async () => {
+    const note = await createNote({
+      title: "Before Update",
+      content: "Old content",
+      projectId: testProjectId,
+    });
+
+    await updateNote(note.id, { title: "After Update", content: "New content" });
+
+    const rows = await testDb.$queryRawUnsafe<{ title: string }[]>(
+      "SELECT title FROM notes_fts WHERE note_id = ?",
+      note.id
+    );
+    expect(rows.length).toBe(1);
+    expect(rows[0].title).toBe("After Update");
+
+    // Cleanup
+    await testDb.$executeRawUnsafe("DELETE FROM notes_fts WHERE note_id = ?", note.id);
+    await testDb.projectNote.delete({ where: { id: note.id } });
+  });
+
+  it("throws ZodError for title that is empty string", async () => {
+    const note = await createNote({
+      title: "Valid Note",
+      content: "Valid content",
+      projectId: testProjectId,
+    });
+
+    await expect(updateNote(note.id, { title: "" })).rejects.toThrow();
+
+    // Cleanup
+    await testDb.$executeRawUnsafe("DELETE FROM notes_fts WHERE note_id = ?", note.id);
+    await testDb.projectNote.delete({ where: { id: note.id } });
+  });
+});
+
+describe("deleteNote", () => {
+  it("deletes the note and removes from FTS", async () => {
+    const note = await createNote({
+      title: "To Delete",
+      content: "Delete me",
+      projectId: testProjectId,
+    });
+
+    await deleteNote(note.id);
+
+    const found = await testDb.projectNote.findUnique({ where: { id: note.id } });
+    expect(found).toBeNull();
+
+    const ftsRows = await testDb.$queryRawUnsafe<{ note_id: string }[]>(
+      "SELECT note_id FROM notes_fts WHERE note_id = ?",
+      note.id
+    );
+    expect(ftsRows.length).toBe(0);
+  });
+});
+
+describe("getNoteById", () => {
+  it("returns the note when found", async () => {
+    const note = await createNote({
+      title: "Get By ID",
+      content: "Found it",
+      projectId: testProjectId,
+    });
+
+    const found = await getNoteById(note.id);
+    expect(found).not.toBeNull();
+    expect(found!.id).toBe(note.id);
+
+    // Cleanup
+    await testDb.$executeRawUnsafe("DELETE FROM notes_fts WHERE note_id = ?", note.id);
+    await testDb.projectNote.delete({ where: { id: note.id } });
+  });
+
+  it("returns null for a non-existent note", async () => {
+    const found = await getNoteById("nonexistent-id-12345");
+    expect(found).toBeNull();
+  });
+});
+
+describe("getProjectNotes", () => {
+  it("returns all notes for a project without category filter", async () => {
+    const note1 = await createNote({
+      title: "Note One",
+      content: "Content 1",
+      category: "账号",
+      projectId: testProjectId,
+    });
+    const note2 = await createNote({
+      title: "Note Two",
+      content: "Content 2",
+      category: "环境",
+      projectId: testProjectId,
+    });
+
+    const notes = await getProjectNotes(testProjectId);
+    const ids = notes.map((n) => n.id);
+    expect(ids).toContain(note1.id);
+    expect(ids).toContain(note2.id);
+
+    // Cleanup
+    for (const n of [note1, note2]) {
+      await testDb.$executeRawUnsafe("DELETE FROM notes_fts WHERE note_id = ?", n.id);
+      await testDb.projectNote.delete({ where: { id: n.id } });
+    }
+  });
+
+  it("filters notes by category when category option is provided", async () => {
+    const accountNote = await createNote({
+      title: "Account Note",
+      content: "Account info",
+      category: "账号",
+      projectId: testProjectId,
+    });
+    const envNote = await createNote({
+      title: "Env Note",
+      content: "Env config",
+      category: "环境",
+      projectId: testProjectId,
+    });
+
+    const accountNotes = await getProjectNotes(testProjectId, { category: "账号" });
+    const ids = accountNotes.map((n) => n.id);
+    expect(ids).toContain(accountNote.id);
+    expect(ids).not.toContain(envNote.id);
+
+    // Cleanup
+    for (const n of [accountNote, envNote]) {
+      await testDb.$executeRawUnsafe("DELETE FROM notes_fts WHERE note_id = ?", n.id);
+      await testDb.projectNote.delete({ where: { id: n.id } });
+    }
+  });
+});

package/.next/standalone/tower/tests/unit/lib/preview-process-manager.test.ts

@@ -0,0 +1,107 @@
+// @vitest-environment node
+import { describe, it, expect, vi, beforeEach } from "vitest";
+
+// We import the module under test — module-level Map persists within a test file
+import {
+  registerPreviewProcess,
+  killPreviewProcess,
+  isPreviewRunning,
+} from "@/lib/preview-process";
+
+import type { ChildProcess } from "node:child_process";
+
+/** Create a fake ChildProcess with controllable state */
+function makeFakeChild(killed = false): ChildProcess {
+  return {
+    killed,
+    kill: vi.fn(),
+    pid: Math.floor(Math.random() * 10000),
+    on: vi.fn(),
+  } as unknown as ChildProcess;
+}
+
+// Clear any registered processes between tests by killing them all
+beforeEach(() => {
+  // Stop any lingering processes from previous tests
+  // We use a known taskId list approach — just call kill on common IDs
+  killPreviewProcess("task-1");
+  killPreviewProcess("task-2");
+  killPreviewProcess("task-3");
+  killPreviewProcess("task-unknown");
+});
+
+describe("registerPreviewProcess", () => {
+  it("stores the process so isPreviewRunning returns true", () => {
+    const child = makeFakeChild();
+    registerPreviewProcess("task-1", child);
+    expect(isPreviewRunning("task-1")).toBe(true);
+  });
+
+  it("overwrites an existing process for the same taskId", () => {
+    const child1 = makeFakeChild();
+    const child2 = makeFakeChild();
+    registerPreviewProcess("task-1", child1);
+    registerPreviewProcess("task-1", child2);
+    // Still running (child2 is alive)
+    expect(isPreviewRunning("task-1")).toBe(true);
+    // Clean up
+    killPreviewProcess("task-1");
+  });
+});
+
+describe("isPreviewRunning", () => {
+  it("returns false for unknown taskId", () => {
+    expect(isPreviewRunning("task-unknown")).toBe(false);
+  });
+
+  it("returns true when process is registered and not killed", () => {
+    const child = makeFakeChild(false);
+    registerPreviewProcess("task-1", child);
+    expect(isPreviewRunning("task-1")).toBe(true);
+  });
+
+  it("returns false when process has been killed externally", () => {
+    const child = makeFakeChild(true);
+    registerPreviewProcess("task-1", child);
+    expect(isPreviewRunning("task-1")).toBe(false);
+  });
+});
+
+describe("killPreviewProcess", () => {
+  it("returns false for unknown taskId", () => {
+    const result = killPreviewProcess("task-unknown");
+    expect(result).toBe(false);
+  });
+
+  it("calls kill(SIGTERM), removes from map, and returns true for a live process", () => {
+    const child = makeFakeChild(false);
+    registerPreviewProcess("task-1", child);
+
+    const result = killPreviewProcess("task-1");
+
+    expect(result).toBe(true);
+    expect(child.kill).toHaveBeenCalledWith("SIGTERM");
+    // Process removed from map
+    expect(isPreviewRunning("task-1")).toBe(false);
+  });
+
+  it("returns false (not re-killed) when process is already killed", () => {
+    const child = makeFakeChild(true); // already killed
+    registerPreviewProcess("task-2", child);
+
+    const result = killPreviewProcess("task-2");
+
+    // Removed from map, but kill() not called because already killed
+    expect(result).toBe(false);
+    expect(child.kill).not.toHaveBeenCalled();
+  });
+
+  it("after killing, isPreviewRunning returns false", () => {
+    const child = makeFakeChild(false);
+    registerPreviewProcess("task-3", child);
+
+    killPreviewProcess("task-3");
+
+    expect(isPreviewRunning("task-3")).toBe(false);
+  });
+});

package/.next/standalone/tower/tests/unit/lib/process-manager.test.ts

@@ -0,0 +1,10 @@
+// @vitest-environment node
+// This test file is intentionally empty.
+// The adapter process-manager (canStartExecution, runningProcesses) was removed in Phase 29
+// as part of adapter dead-code cleanup. Task execution is now fully handled by the
+// PTY session layer (src/lib/pty-session.ts) with no per-execution concurrency gate.
+import { describe, it } from "vitest";
+
+describe("process-manager (removed)", () => {
+  it.todo("adapter process-manager deleted in Phase 29 — tests no longer applicable");
+});

package/.next/standalone/tower/tests/unit/lib/pty-session.test.ts

@@ -0,0 +1,171 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from "vitest";
+
+// Mock node-pty to avoid native addon in test environment
+const mockPty = {
+  onData: vi.fn(),
+  onExit: vi.fn(),
+  write: vi.fn(),
+  resize: vi.fn(),
+  kill: vi.fn(),
+};
+
+vi.mock("node-pty", () => ({
+  spawn: vi.fn(() => mockPty),
+}));
+
+import { PtySession } from "@/lib/pty/pty-session";
+
+describe("PtySession", () => {
+  let onData: ReturnType<typeof vi.fn>;
+  let onExit: ReturnType<typeof vi.fn>;
+  let session: PtySession;
+
+  beforeEach(() => {
+    vi.clearAllMocks();
+    onData = vi.fn();
+    onExit = vi.fn();
+    // Reset mockPty callbacks
+    mockPty.onData.mockImplementation(() => {});
+    mockPty.onExit.mockImplementation(() => {});
+    session = new PtySession("task-1", "bash", [], "/tmp", onData, onExit);
+  });
+
+  afterEach(() => {
+    // Clean up
+  });
+
+  describe("constructor", () => {
+    it("sets taskId", () => {
+      expect(session.taskId).toBe("task-1");
+    });
+
+    it("initializes killed as false", () => {
+      expect(session.killed).toBe(false);
+    });
+
+    it("initializes disconnectTimer as null", () => {
+      expect(session.disconnectTimer).toBeNull();
+    });
+
+    it("registers onData and onExit callbacks on the PTY", () => {
+      expect(mockPty.onData).toHaveBeenCalledOnce();
+      expect(mockPty.onExit).toHaveBeenCalledOnce();
+    });
+  });
+
+  describe("ring buffer", () => {
+    it("accumulates data in buffer", () => {
+      const dataCallback = mockPty.onData.mock.calls[0][0];
+      dataCallback("hello");
+      dataCallback(" world");
+      expect(session.getBuffer()).toBe("hello world");
+    });
+
+    it("calls onData listener for each chunk", () => {
+      const dataCallback = mockPty.onData.mock.calls[0][0];
+      dataCallback("chunk1");
+      dataCallback("chunk2");
+      expect(onData).toHaveBeenCalledTimes(2);
+      expect(onData).toHaveBeenCalledWith("chunk1");
+      expect(onData).toHaveBeenCalledWith("chunk2");
+    });
+
+    it("trims buffer to BUFFER_MAX (50KB)", () => {
+      const dataCallback = mockPty.onData.mock.calls[0][0];
+      // Write 60KB of data
+      const bigChunk = "x".repeat(60 * 1024);
+      dataCallback(bigChunk);
+      const buffer = session.getBuffer();
+      expect(buffer.length).toBe(50 * 1024);
+    });
+  });
+
+  describe("onExit", () => {
+    it("sets killed=true on PTY exit", () => {
+      const exitCallback = mockPty.onExit.mock.calls[0][0];
+      exitCallback({ exitCode: 0, signal: 0 });
+      expect(session.killed).toBe(true);
+    });
+
+    it("calls onExit callback with exitCode", () => {
+      const exitCallback = mockPty.onExit.mock.calls[0][0];
+      exitCallback({ exitCode: 1, signal: 15 });
+      expect(onExit).toHaveBeenCalledWith(1, 15);
+    });
+
+    it("notifies the registered exit listener via setExitListener", () => {
+      const listener1 = vi.fn();
+      const listener2 = vi.fn();
+      session.setExitListener(listener1);
+      session.setExitListener(listener2);
+
+      const exitCallback = mockPty.onExit.mock.calls[0][0];
+      exitCallback({ exitCode: 0, signal: 0 });
+
+      // setExitListener replaces previous listener — only listener2 should fire
+      expect(listener2).toHaveBeenCalledWith(0);
+    });
+  });
+
+  describe("setDataListener", () => {
+    it("replaces the data listener", () => {
+      const newListener = vi.fn();
+      session.setDataListener(newListener);
+
+      const dataCallback = mockPty.onData.mock.calls[0][0];
+      dataCallback("new data");
+
+      expect(newListener).toHaveBeenCalledWith("new data");
+      // Original listener should NOT be called for new data
+      // (it was called during construction if any data arrived then)
+    });
+  });
+
+  describe("write", () => {
+    it("forwards data to PTY when not killed", () => {
+      session.write("hello");
+      expect(mockPty.write).toHaveBeenCalledWith("hello");
+    });
+
+    it("does NOT write to PTY when killed", () => {
+      session.kill();
+      session.write("hello");
+      expect(mockPty.write).not.toHaveBeenCalled();
+    });
+  });
+
+  describe("resize", () => {
+    it("forwards resize to PTY when not killed", () => {
+      session.resize(120, 40);
+      expect(mockPty.resize).toHaveBeenCalledWith(120, 40);
+    });
+
+    it("does NOT resize PTY when killed", () => {
+      session.kill();
+      session.resize(120, 40);
+      expect(mockPty.resize).not.toHaveBeenCalled();
+    });
+  });
+
+  describe("kill (double-kill guard)", () => {
+    it("kills the PTY on first call", () => {
+      session.kill();
+      expect(session.killed).toBe(true);
+      expect(mockPty.kill).toHaveBeenCalledOnce();
+    });
+
+    it("does NOT kill again on second call", () => {
+      session.kill();
+      session.kill();
+      expect(mockPty.kill).toHaveBeenCalledOnce();
+    });
+
+    it("handles PTY already dead (kill throws)", () => {
+      mockPty.kill.mockImplementationOnce(() => {
+        throw new Error("Process already dead");
+      });
+      expect(() => session.kill()).not.toThrow();
+      expect(session.killed).toBe(true);
+    });
+  });
+});