tower-studio 0.1.1 → 0.1.3

package/src/actions/file-actions.ts

@@ -0,0 +1,262 @@
+"use server";
+
+import { readdir, readFile, writeFile, mkdir, rename, rm, unlink, stat } from "fs/promises";
+import { existsSync } from "fs";
+import path from "path";
+import ignore from "ignore";
+import { execFileSync } from "child_process";
+import { safeResolvePath } from "@/lib/fs-security";
+import { z } from "zod";
+
+export interface FileEntry {
+  name: string;
+  relativePath: string; // relative to worktreePath
+  isDirectory: boolean;
+  gitStatus?: "M" | "A" | "D";
+}
+
+// ---- listDirectory ----
+const listDirectorySchema = z.object({
+  worktreePath: z.string().min(1),
+  relativePath: z.string().default("."),
+});
+
+export async function listDirectory(
+  worktreePath: string,
+  relativePath: string = "."
+): Promise<FileEntry[]> {
+  listDirectorySchema.parse({ worktreePath, relativePath });
+  const absoluteDir = safeResolvePath(worktreePath, relativePath);
+
+  const ig = ignore();
+  ig.add(".git"); // always filter .git regardless of .gitignore
+  const gitignorePath = path.join(worktreePath, ".gitignore");
+  if (existsSync(gitignorePath)) {
+    const content = await readFile(gitignorePath, "utf-8");
+    ig.add(content);
+  }
+
+  const entries = await readdir(absoluteDir, { withFileTypes: true });
+  const filtered = entries.filter((e) => {
+    // CRITICAL: must use path relative to worktree root, not absolute
+    const rel = path.relative(worktreePath, path.join(absoluteDir, e.name));
+    return !ig.ignores(rel);
+  });
+
+  return filtered
+    .sort((a, b) => {
+      if (a.isDirectory() !== b.isDirectory())
+        return a.isDirectory() ? -1 : 1;
+      return a.name.localeCompare(b.name);
+    })
+    .map((e) => ({
+      name: e.name,
+      relativePath: path.relative(worktreePath, path.join(absoluteDir, e.name)),
+      isDirectory: e.isDirectory(),
+    }));
+}
+
+// ---- getGitStatus ----
+// In direct mode (no baseBranch/taskBranch), falls back to `git status --porcelain`.
+// If cwd is not a git repo, execFileSync throws and the catch returns {} — this is expected.
+export async function getGitStatus(
+  worktreePath: string,
+  baseBranch: string | null,
+  taskBranch: string | null
+): Promise<Record<string, "M" | "A" | "D">> {
+  try {
+    let output: string;
+    if (baseBranch && taskBranch) {
+      // Worktree mode: diff between branches
+      output = execFileSync(
+        "git",
+        ["diff", "--name-status", `${baseBranch}...${taskBranch}`],
+        { cwd: worktreePath, encoding: "utf-8", timeout: 10000 }
+      );
+    } else {
+      // Direct mode: working tree status via git status
+      output = execFileSync(
+        "git",
+        ["status", "--porcelain", "-uall"],
+        { cwd: worktreePath, encoding: "utf-8", timeout: 10000 }
+      );
+    }
+    const result: Record<string, "M" | "A" | "D"> = {};
+    if (baseBranch && taskBranch) {
+      for (const line of output.split("\n").filter(Boolean)) {
+        const parts = line.split("\t");
+        const status = parts[0];
+        const filePath = parts[1];
+        if ((status === "M" || status === "A" || status === "D") && filePath) {
+          result[filePath] = status as "M" | "A" | "D";
+        }
+      }
+    } else {
+      // Parse porcelain format: "XY filename"
+      for (const line of output.split("\n").filter(Boolean)) {
+        const xy = line.substring(0, 2);
+        const filePath = line.substring(3);
+        if (!filePath) continue;
+        if (xy.includes("D")) {
+          result[filePath] = "D";
+        } else if (xy === "??" || xy.includes("A")) {
+          result[filePath] = "A";
+        } else {
+          result[filePath] = "M";
+        }
+      }
+    }
+    return result;
+  } catch {
+    return {};
+  }
+}
+
+// ---- createFile ----
+export async function createFile(
+  worktreePath: string,
+  relativePath: string
+): Promise<void> {
+  z.object({ worktreePath: z.string().min(1), relativePath: z.string().min(1) })
+    .parse({ worktreePath, relativePath });
+  const absolute = safeResolvePath(worktreePath, relativePath);
+  await writeFile(absolute, "", { flag: "wx" }); // wx = fail if exists
+}
+
+// ---- createDirectory ----
+export async function createDirectory(
+  worktreePath: string,
+  relativePath: string
+): Promise<void> {
+  z.object({ worktreePath: z.string().min(1), relativePath: z.string().min(1) })
+    .parse({ worktreePath, relativePath });
+  const absolute = safeResolvePath(worktreePath, relativePath);
+  await mkdir(absolute, { recursive: true });
+}
+
+// ---- renameEntry ----
+export async function renameEntry(
+  worktreePath: string,
+  oldRelativePath: string,
+  newRelativePath: string
+): Promise<void> {
+  z.object({
+    worktreePath: z.string().min(1),
+    oldRelativePath: z.string().min(1),
+    newRelativePath: z.string().min(1),
+  }).parse({ worktreePath, oldRelativePath, newRelativePath });
+  const oldAbsolute = safeResolvePath(worktreePath, oldRelativePath);
+  const newAbsolute = safeResolvePath(worktreePath, newRelativePath);
+  await rename(oldAbsolute, newAbsolute);
+}
+
+// ---- deleteEntry ----
+export async function deleteEntry(
+  worktreePath: string,
+  relativePath: string
+): Promise<void> {
+  z.object({ worktreePath: z.string().min(1), relativePath: z.string().min(1) })
+    .parse({ worktreePath, relativePath });
+  // Guard: never delete .git/ — checked before path resolution (D-10)
+  if (path.basename(relativePath) === ".git") {
+    throw new Error("Cannot delete .git directory");
+  }
+  const absolute = safeResolvePath(worktreePath, relativePath);
+  const info = await stat(absolute);
+  if (info.isDirectory()) {
+    await rm(absolute, { recursive: true, force: true });
+  } else {
+    await unlink(absolute);
+  }
+}
+
+// ---- listAllFiles ----
+const listAllFilesSchema = z.object({
+  worktreePath: z.string().min(1),
+});
+
+export async function listAllFiles(
+  worktreePath: string
+): Promise<string[]> {
+  listAllFilesSchema.parse({ worktreePath });
+
+  const ig = ignore();
+  ig.add(".git");
+  const gitignorePath = path.join(worktreePath, ".gitignore");
+  if (existsSync(gitignorePath)) {
+    const content = await readFile(gitignorePath, "utf-8");
+    ig.add(content);
+  }
+
+  const results: string[] = [];
+
+  async function walk(dir: string) {
+    const entries = await readdir(dir, { withFileTypes: true });
+    for (const entry of entries) {
+      const abs = path.join(dir, entry.name);
+      const rel = path.relative(worktreePath, abs);
+      if (ig.ignores(rel)) continue;
+      if (entry.isDirectory()) {
+        await walk(abs);
+      } else {
+        results.push(rel);
+      }
+    }
+  }
+
+  await walk(worktreePath);
+  return results;
+}
+
+// ---- readFileContent ----
+const readFileContentSchema = z.object({
+  worktreePath: z.string().min(1),
+  relativePath: z.string().min(1),
+});
+
+export async function readFileContent(
+  worktreePath: string,
+  relativePath: string
+): Promise<string> {
+  readFileContentSchema.parse({ worktreePath, relativePath });
+  const absolute = safeResolvePath(worktreePath, relativePath);
+  return readFile(absolute, "utf-8");
+}
+
+// ---- writeFileContent ----
+const writeFileContentSchema = z.object({
+  worktreePath: z.string().min(1),
+  relativePath: z.string().min(1),
+  content: z.string(),
+});
+
+export async function writeFileContent(
+  worktreePath: string,
+  relativePath: string,
+  content: string
+): Promise<void> {
+  writeFileContentSchema.parse({ worktreePath, relativePath, content });
+  const absolute = safeResolvePath(worktreePath, relativePath);
+  await writeFile(absolute, content, "utf-8");
+}
+
+/**
+ * Reveal a file or folder in the system file manager.
+ */
+export async function revealInFinder(worktreePath: string, relativePath: string): Promise<void> {
+  const absolute = safeResolvePath(worktreePath, relativePath);
+  const { execFile } = await import("child_process");
+  const platform = process.platform;
+
+  await new Promise<void>((resolve, reject) => {
+    if (platform === "darwin") {
+      execFile("open", ["-R", absolute], (err) => err ? reject(err) : resolve());
+    } else if (platform === "linux") {
+      execFile("xdg-open", [path.dirname(absolute)], (err) => err ? reject(err) : resolve());
+    } else if (platform === "win32") {
+      execFile("explorer", ["/select,", absolute], (err) => err ? reject(err) : resolve());
+    } else {
+      reject(new Error("Unsupported platform"));
+    }
+  });
+}

package/src/actions/git-actions.ts

@@ -0,0 +1,90 @@
+"use server";
+
+import { execSync, spawn } from "child_process";
+import path from "path";
+import os from "os";
+
+function expandHome(p: string): string {
+  if (p.startsWith("~/") || p === "~") {
+    return path.join(os.homedir(), p.slice(1));
+  }
+  return p;
+}
+
+/** Get the currently checked-out branch name */
+function readCurrentBranch(resolved: string): string {
+  return execSync("git rev-parse --abbrev-ref HEAD", {
+    cwd: resolved, encoding: "utf-8", timeout: 5000,
+  }).trim();
+}
+
+/**
+ * Read local + remote branches from the cached git refs.
+ * No network call — returns instantly from the local .git directory.
+ */
+function readBranches(resolved: string): string[] {
+  // Local branches
+  const localRaw = execSync(
+    "git branch --format='%(refname:short)'",
+    { cwd: resolved, encoding: "utf-8", timeout: 5000 }
+  ).trim();
+  const locals = new Set(
+    localRaw.split("\n").filter(Boolean).map((b) => b.replace(/'/g, ""))
+  );
+
+  // Remote branches (strip origin/ prefix, deduplicate against locals)
+  const remoteRaw = execSync(
+    "git branch -r --format='%(refname:short)'",
+    { cwd: resolved, encoding: "utf-8", timeout: 5000 }
+  ).trim();
+  const remotes = remoteRaw
+    .split("\n")
+    .filter(Boolean)
+    .map((b) => b.replace(/'/g, "").replace(/^origin\//, ""))
+    .filter((b) => b !== "HEAD" && !locals.has(b));
+
+  return [...locals, ...remotes];
+}
+
+/**
+ * Get branches instantly from cache, kick off a background fetch.
+ * Call again after a few seconds to get updated list.
+ */
+export async function getCurrentBranch(localPath: string): Promise<string | null> {
+  if (!localPath?.trim()) return null;
+  const resolved = path.resolve(expandHome(localPath));
+  try {
+    return readCurrentBranch(resolved);
+  } catch {
+    return null;
+  }
+}
+
+export async function getProjectBranches(localPath: string): Promise<string[]> {
+  if (!localPath?.trim()) return [];
+  const resolved = path.resolve(expandHome(localPath));
+  try {
+    return readBranches(resolved);
+  } catch {
+    return [];
+  }
+}
+
+/**
+ * Trigger a background git fetch --prune, returns immediately.
+ * Call getProjectBranches again after this completes for updated list.
+ */
+export async function fetchRemoteBranches(localPath: string): Promise<void> {
+  if (!localPath?.trim()) return;
+  const resolved = path.resolve(expandHome(localPath));
+  try {
+    const child = spawn("git", ["fetch", "--prune"], {
+      cwd: resolved,
+      stdio: "ignore",
+      detached: true,
+    });
+    child.unref();
+  } catch {
+    // Ignore fetch errors (offline, no remote, etc.)
+  }
+}

package/src/actions/label-actions.ts

@@ -0,0 +1,67 @@
+"use server";
+
+import { db } from "@/lib/db";
+import { revalidatePath } from "next/cache";
+import { createLabelSchema } from "@/lib/schemas";
+
+// Get all labels available for a workspace (builtin + workspace-specific)
+export async function getLabelsForWorkspace(workspaceId: string) {
+  return db.label.findMany({
+    where: {
+      OR: [
+        { isBuiltin: true },
+        { workspaceId },
+      ],
+    },
+    orderBy: [{ isBuiltin: "desc" }, { name: "asc" }],
+  });
+}
+
+// Create a custom label for a workspace
+export async function createLabel(data: {
+  name: string;
+  color: string;
+  workspaceId: string;
+}) {
+  const v = createLabelSchema.parse(data);
+  const label = await db.label.create({
+    data: {
+      name: v.name,
+      color: v.color,
+      workspaceId: v.workspaceId,
+    },
+  });
+  revalidatePath("/workspaces");
+  return label;
+}
+
+// Delete a custom label (not builtin)
+export async function deleteLabel(id: string) {
+  const label = await db.label.findUnique({ where: { id } });
+  if (!label) throw new Error("Label not found");
+  if (label.isBuiltin) throw new Error("Cannot delete builtin labels");
+  await db.label.delete({ where: { id } });
+  revalidatePath("/workspaces");
+}
+
+// Set labels on a task (replace all) — wrapped in transaction for atomicity
+export async function setTaskLabels(taskId: string, labelIds: string[]) {
+  await db.$transaction(async (tx) => {
+    await tx.taskLabel.deleteMany({ where: { taskId } });
+    if (labelIds.length > 0) {
+      await tx.taskLabel.createMany({
+        data: labelIds.map((labelId) => ({ taskId, labelId })),
+      });
+    }
+  });
+  revalidatePath("/workspaces");
+}
+
+// Get labels for a task
+export async function getTaskLabels(taskId: string) {
+  const taskLabels = await db.taskLabel.findMany({
+    where: { taskId },
+    include: { label: true },
+  });
+  return taskLabels.map((tl) => tl.label);
+}

package/src/actions/note-actions.ts

@@ -0,0 +1,87 @@
+"use server";
+
+import { z } from "zod";
+import { db } from "@/lib/db";
+import { revalidatePath } from "next/cache";
+import { syncNoteToFts, deleteNoteFromFts } from "@/lib/fts";
+
+const createNoteSchema = z.object({
+  title: z.string().min(1).max(200),
+  content: z.string(),
+  category: z.string().max(50).optional(),
+  projectId: z.string().min(1),
+  taskId: z.string().optional(),
+});
+
+const updateNoteSchema = z.object({
+  title: z.string().min(1).max(200).optional(),
+  content: z.string().optional(),
+  category: z.string().max(50).optional(),
+});
+
+export async function createNote(data: {
+  title: string;
+  content: string;
+  category?: string;
+  projectId: string;
+  taskId?: string;
+}) {
+  const parsed = createNoteSchema.parse(data);
+  const note = await db.projectNote.create({
+    data: {
+      title: parsed.title,
+      content: parsed.content,
+      category: parsed.category ?? "备忘",
+      projectId: parsed.projectId,
+      taskId: parsed.taskId ?? null,
+    },
+  });
+  await syncNoteToFts(db, { id: note.id, title: note.title, content: note.content });
+  revalidatePath(`/workspace`);
+  return note;
+}
+
+export async function updateNote(
+  noteId: string,
+  data: { title?: string; content?: string; category?: string }
+) {
+  const parsed = updateNoteSchema.parse(data);
+  const note = await db.projectNote.update({
+    where: { id: noteId },
+    data: parsed,
+  });
+  await syncNoteToFts(db, { id: note.id, title: note.title, content: note.content });
+  revalidatePath(`/workspace`);
+  return note;
+}
+
+export async function deleteNote(noteId: string) {
+  await deleteNoteFromFts(db, noteId);
+  await db.projectNote.delete({ where: { id: noteId } });
+  revalidatePath(`/workspace`);
+}
+
+export async function getNoteById(noteId: string) {
+  return db.projectNote.findUnique({ where: { id: noteId } });
+}
+
+export async function getProjectNotes(
+  projectId: string,
+  options?: { category?: string }
+) {
+  return db.projectNote.findMany({
+    where: {
+      projectId,
+      taskId: null,
+      ...(options?.category ? { category: options.category } : {}),
+    },
+    orderBy: { updatedAt: "desc" },
+  });
+}
+
+export async function getTaskNotes(taskId: string) {
+  return db.projectNote.findMany({
+    where: { taskId },
+    orderBy: { updatedAt: "desc" },
+  });
+}

package/src/actions/onboarding-actions.ts

@@ -0,0 +1,103 @@
+"use server";
+
+import { db } from "@/lib/db";
+import { revalidatePath } from "next/cache";
+import { logger } from "@/lib/logger";
+
+export interface OnboardingStatus {
+  isFirstRun: boolean;
+  isCompleted: boolean;
+  lastStep: number;
+  username: string | null;
+}
+
+export interface TaskCompletionPayload {
+  taskId: string;
+  taskTitle: string;
+  status: "COMPLETED" | "FAILED";
+  executionId: string;
+  workspaceId: string;
+}
+
+const ONBOARDING_KEYS = ["onboarding.completed", "onboarding.lastStep", "onboarding.username"] as const;
+
+export async function getOnboardingStatus(): Promise<OnboardingStatus> {
+  const rows = await db.systemConfig.findMany({
+    where: { key: { in: [...ONBOARDING_KEYS] } },
+  });
+
+  const stored: Record<string, unknown> = {};
+  for (const row of rows) {
+    try {
+      stored[row.key] = JSON.parse(row.value);
+    } catch {
+      stored[row.key] = null;
+    }
+  }
+
+  const isCompleted = stored["onboarding.completed"] === true;
+  const rawStep = stored["onboarding.lastStep"];
+  const lastStep = typeof rawStep === "number" ? rawStep : 0;
+  const rawUsername = stored["onboarding.username"];
+  const username = typeof rawUsername === "string" && rawUsername.length > 0 ? rawUsername : null;
+
+  return {
+    isFirstRun: !isCompleted,
+    isCompleted,
+    lastStep,
+    username,
+  };
+}
+
+export async function setOnboardingProgress(step: number): Promise<void> {
+  await db.systemConfig.upsert({
+    where: { key: "onboarding.lastStep" },
+    create: { key: "onboarding.lastStep", value: JSON.stringify(step) },
+    update: { value: JSON.stringify(step) },
+  });
+  revalidatePath("/", "layout");
+}
+
+export async function completeOnboarding(username?: string): Promise<void> {
+  await db.systemConfig.upsert({
+    where: { key: "onboarding.completed" },
+    create: { key: "onboarding.completed", value: "true" },
+    update: { value: "true" },
+  });
+  await db.systemConfig.upsert({
+    where: { key: "onboarding.lastStep" },
+    create: { key: "onboarding.lastStep", value: "2" },
+    update: { value: "2" },
+  });
+  if (username !== undefined) {
+    const sanitized = username.trim().slice(0, 64).replace(/[\r\n]/g, " ");
+    if (sanitized.length > 0) {
+      await db.systemConfig.upsert({
+        where: { key: "onboarding.username" },
+        create: { key: "onboarding.username", value: JSON.stringify(sanitized) },
+        update: { value: JSON.stringify(sanitized) },
+      });
+    }
+  }
+  revalidatePath("/", "layout");
+}
+
+export async function dispatchTaskCompletionEvent(
+  payload: TaskCompletionPayload
+): Promise<void> {
+  try {
+    const log = logger.create("task-completion");
+    log.info("Task completion event dispatched", {
+      taskId: payload.taskId,
+      taskTitle: payload.taskTitle,
+      status: payload.status,
+      executionId: payload.executionId,
+    });
+
+    // Broadcast via WebSocket to all notification clients
+    const { broadcastNotification } = await import("@/lib/pty/ws-server");
+    broadcastNotification({ ...payload, type: "completion" });
+  } catch {
+    // Best-effort: notifications are non-critical
+  }
+}

package/src/actions/preview-actions.ts

@@ -0,0 +1,76 @@
+"use server";
+
+import { spawn } from "node:child_process";
+import { execFileSync } from "node:child_process";
+import { readFileSync } from "node:fs";
+import { join, isAbsolute } from "node:path";
+import {
+  registerPreviewProcess,
+  killPreviewProcess,
+  isPreviewRunning,
+} from "@/lib/preview-process";
+import { readConfigValue } from "@/lib/config-reader";
+
+export async function startPreview(
+  taskId: string,
+  command: string,
+  cwd: string
+): Promise<{ started: boolean; error?: string }> {
+  if (isPreviewRunning(taskId)) {
+    killPreviewProcess(taskId);
+  }
+  try {
+    // Split command by whitespace into args — shell: false (security requirement)
+    const parts = command.trim().split(/\s+/);
+    const [cmd, ...args] = parts;
+    // Removed console.log per coding standards — use structured logging if needed
+    const child = spawn(cmd, args, {
+      cwd,
+      shell: false,
+      detached: false,
+      stdio: "ignore",
+    });
+    registerPreviewProcess(taskId, child);
+    return { started: true };
+  } catch (err) {
+    return { started: false, error: String(err) };
+  }
+}
+
+export async function stopPreview(taskId: string): Promise<void> {
+  killPreviewProcess(taskId);
+}
+
+/**
+ * Detect the frontend framework from package.json in the given directory.
+ * Returns "vite" | "next" | "nuxt" | "angular" | null
+ */
+export async function detectFramework(cwd: string): Promise<string | null> {
+  try {
+    const raw = readFileSync(join(cwd, "package.json"), "utf-8");
+    const pkg = JSON.parse(raw);
+    const allDeps = { ...pkg.dependencies, ...pkg.devDependencies };
+    if (allDeps["vite"] || allDeps["@vitejs/plugin-vue"] || allDeps["@vitejs/plugin-react"]) return "vite";
+    if (allDeps["next"]) return "next";
+    if (allDeps["nuxt"]) return "nuxt";
+    if (allDeps["@angular/core"]) return "angular";
+    return null;
+  } catch {
+    return null;
+  }
+}
+
+// macOS-only: uses built-in `open -a` command
+// Uses execFileSync with args array — no shell interpolation (security constraint)
+const ALLOWED_TERMINAL_APPS = ["Terminal", "iTerm", "iTerm2", "Warp", "Hyper", "Alacritty", "WezTerm", "kitty"];
+
+export async function openInTerminal(worktreePath: string): Promise<void> {
+  if (!worktreePath || !isAbsolute(worktreePath)) {
+    throw new Error("openInTerminal requires an absolute path");
+  }
+  const terminalApp = await readConfigValue<string>("terminal.app", "Terminal");
+  if (!ALLOWED_TERMINAL_APPS.includes(terminalApp)) {
+    throw new Error(`Terminal app '${terminalApp}' is not in the allowed list`);
+  }
+  execFileSync("open", ["-a", terminalApp, worktreePath]);
+}