tower-studio 0.1.2 → 0.1.5

package/.next/standalone/tower/src/actions/file-actions.ts

@@ -1,262 +0,0 @@
-"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/.next/standalone/tower/src/actions/git-actions.ts

@@ -1,90 +0,0 @@
-"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/.next/standalone/tower/src/actions/label-actions.ts

@@ -1,67 +0,0 @@
-"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/.next/standalone/tower/src/actions/note-actions.ts

@@ -1,87 +0,0 @@
-"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/.next/standalone/tower/src/actions/onboarding-actions.ts

@@ -1,103 +0,0 @@
-"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/.next/standalone/tower/src/actions/preview-actions.ts

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