tower-studio 0.2.7 → 0.2.9

package/src/mcp/tools/task-tools.ts

@@ -1,272 +0,0 @@
-import { z } from "zod";
-import { execFileSync } from "child_process";
-import { copyFileSync, existsSync, statSync, mkdirSync } from "fs";
-import { basename, extname, join, resolve } from "path";
-import { db } from "../db";
-import { stripCacheUuidSuffix, isAssistantCachePath } from "@/lib/file-utils";
-
-// Derive project root from this file's location (src/mcp/tools/ → ../../..)
-// This avoids depending on process.cwd() which varies when MCP is spawned from .tower/
-const MCP_PROJECT_ROOT = resolve(__dirname, "../../..");
-
-const TaskStatus = z.enum(["TODO", "IN_PROGRESS", "IN_REVIEW", "DONE", "CANCELLED"]);
-const Priority = z.enum(["LOW", "MEDIUM", "HIGH", "CRITICAL"]);
-
-export const taskTools = {
-  list_tasks: {
-    description: "List all tasks in a project, optionally filtered by status. Includes labels and is ordered by position then creation date.",
-    schema: z.object({
-      projectId: z.string(),
-      status: TaskStatus.optional(),
-    }),
-    handler: async (args: { projectId: string; status?: string }) => {
-      const tasks = await db.task.findMany({
-        where: {
-          projectId: args.projectId,
-          ...(args.status ? { status: args.status as "TODO" | "IN_PROGRESS" | "IN_REVIEW" | "DONE" | "CANCELLED" } : {}),
-          // Exclude system tasks tagged with the builtin "Tower" label
-          NOT: { labels: { some: { label: { name: "Tower", isBuiltin: true } } } },
-        },
-        include: {
-          labels: { include: { label: true } },
-        },
-        orderBy: [{ order: "asc" }, { createdAt: "desc" }],
-      });
-
-      return tasks.map((task) => ({
-        ...task,
-        labels: task.labels.map((tl) => tl.label),
-      }));
-    },
-  },
-
-  create_task: {
-    description: "Create a new task in a project. Priority defaults to MEDIUM, status defaults to TODO. Set useWorktree=true for branch isolation. Set autoStart=true (default) to immediately start execution. Pass references as file paths to attach as project assets.",
-    schema: z.object({
-      projectId: z.string(),
-      title: z.string(),
-      description: z.string().optional(),
-      priority: Priority.optional().default("MEDIUM"),
-      status: TaskStatus.optional().default("TODO"),
-      labelIds: z.array(z.string()).optional(),
-      subPath: z.string().optional(),
-      useWorktree: z.boolean().optional().default(false),
-      baseBranch: z.string().optional().describe("Base branch for worktree checkout. Only used when useWorktree=true. If omitted, auto-detects the project's current branch."),
-      autoStart: z.boolean().optional().default(true),
-      references: z.array(z.string()).max(20).optional(),
-    }),
-    handler: async (args: {
-      projectId: string;
-      title: string;
-      description?: string;
-      priority?: string;
-      status?: string;
-      labelIds?: string[];
-      subPath?: string;
-      useWorktree?: boolean;
-      baseBranch?: string;
-      autoStart?: boolean;
-      references?: string[];
-    }) => {
-      // Determine baseBranch: explicit param > auto-detect from project's current git branch
-      let baseBranch: string | null = null;
-      if (args.useWorktree) {
-        if (args.baseBranch) {
-          baseBranch = args.baseBranch;
-        } else {
-          const project = await db.project.findUnique({ where: { id: args.projectId }, select: { localPath: true } });
-          if (project?.localPath) {
-            try {
-              baseBranch = execFileSync("git", ["branch", "--show-current"], {
-                cwd: project.localPath, encoding: "utf-8", timeout: 5000,
-              }).trim() || null;
-            } catch {
-              // fallback: no baseBranch, task runs in direct mode
-            }
-          }
-        }
-      }
-
-      const task = await db.task.create({
-        data: {
-          title: args.title,
-          description: args.description,
-          projectId: args.projectId,
-          priority: (args.priority ?? "MEDIUM") as "LOW" | "MEDIUM" | "HIGH" | "CRITICAL",
-          status: (args.status ?? "TODO") as "TODO" | "IN_PROGRESS" | "IN_REVIEW" | "DONE" | "CANCELLED",
-          baseBranch,
-        },
-      });
-
-      if (args.labelIds && args.labelIds.length > 0) {
-        await db.taskLabel.createMany({
-          data: args.labelIds.map((labelId) => ({ taskId: task.id, labelId })),
-        });
-      }
-
-      // Copy reference files to assets and create ProjectAsset records
-      const attachedFiles: string[] = [];
-      let updatedDesc: string | null = null;
-      if (args.references && args.references.length > 0) {
-        const assetsDir = join(MCP_PROJECT_ROOT, "data", "assets", args.projectId);
-        mkdirSync(assetsDir, { recursive: true });
-
-        for (const filePath of args.references) {
-          try {
-            if (!existsSync(filePath)) continue;
-            const stat = statSync(filePath);
-            if (!stat.isFile()) continue;
-
-            const isCache = isAssistantCachePath(filePath);
-            let filename = isCache
-              ? stripCacheUuidSuffix(basename(filePath))
-              : basename(filePath);
-            // Avoid overwriting existing assets
-            if (existsSync(join(assetsDir, filename))) {
-              const ext = extname(filename);
-              const base = basename(filename, ext);
-              if (isCache) {
-                // Use counter suffix for readable cache asset names: "设计稿 (1).png"
-                let counter = 1;
-                while (existsSync(join(assetsDir, `${base} (${counter})${ext}`))) {
-                  counter++;
-                }
-                filename = `${base} (${counter})${ext}`;
-              } else {
-                filename = `${base}-${Date.now()}${ext}`;
-              }
-            }
-            const dest = join(assetsDir, filename);
-            copyFileSync(filePath, dest);
-
-            await db.projectAsset.create({
-              data: {
-                filename,
-                path: dest,
-                size: stat.size,
-                projectId: args.projectId,
-                taskId: task.id,
-                description: `Reference: ${basename(filePath)}`,
-              },
-            });
-            attachedFiles.push(filename);
-          } catch {
-            // Skip files that can't be copied
-          }
-        }
-
-        // Append reference info to task description with full absolute paths
-        if (attachedFiles.length > 0) {
-          const refText = attachedFiles.map((f) => `- ${join(assetsDir, f)}`).join("\n");
-          updatedDesc = (task.description ?? "") + `\n\nAttached references:\n${refText}`;
-          await db.task.update({ where: { id: task.id }, data: { description: updatedDesc } });
-        }
-      }
-
-      // Auto-start execution if requested — pass title as prompt since
-      // startPtyExecution already injects task description as context.
-      //
-      // We always surface the outcome on the response so the assistant doesn't
-      // claim "Execution started" when the kanban still shows TODO. Common
-      // failure modes worth keeping visible:
-      //   - Next.js server unreachable (wrong port / not running)
-      //   - Concurrency limit hit (system.maxConcurrentExecutions)
-      //   - Project missing localPath
-      if (args.autoStart) {
-        const PORT = process.env.PORT ?? "3000";
-        const prompt = args.title;
-        try {
-          const res = await fetch(`http://localhost:${PORT}/api/internal/terminal/${task.id}/start`, {
-            method: "POST",
-            headers: { "Content-Type": "application/json" },
-            body: JSON.stringify({ prompt }),
-          });
-          if (res.ok) {
-            const execData = await res.json();
-            return { ...task, execution: execData };
-          }
-          let errMsg = `HTTP ${res.status}`;
-          try {
-            const errBody = (await res.json()) as { error?: string };
-            if (errBody?.error) errMsg = errBody.error;
-          } catch {
-            /* response body wasn't JSON; keep status code */
-          }
-          return { ...task, execution: null, executionError: errMsg };
-        } catch (err) {
-          return {
-            ...task,
-            execution: null,
-            executionError: err instanceof Error ? err.message : String(err),
-          };
-        }
-      }
-
-      return task;
-    },
-  },
-
-  update_task: {
-    description: "Update a task's title, description, priority, labels, and/or subPath. If labelIds is provided, replaces all existing labels.",
-    schema: z.object({
-      taskId: z.string(),
-      title: z.string().optional(),
-      description: z.string().optional(),
-      priority: Priority.optional(),
-      labelIds: z.array(z.string()).optional(),
-      subPath: z.string().optional(),
-    }),
-    handler: async (args: {
-      taskId: string;
-      title?: string;
-      description?: string;
-      priority?: string;
-      labelIds?: string[];
-      subPath?: string;
-    }) => {
-      const { labelIds, taskId, ...updateData } = args;
-
-      return db.$transaction(async (tx) => {
-        const task = await tx.task.update({
-          where: { id: taskId },
-          data: updateData as { title?: string; description?: string; priority?: "LOW" | "MEDIUM" | "HIGH" | "CRITICAL"; subPath?: string },
-        });
-
-        if (labelIds !== undefined) {
-          await tx.taskLabel.deleteMany({ where: { taskId } });
-          if (labelIds.length > 0) {
-            await tx.taskLabel.createMany({
-              data: labelIds.map((labelId) => ({ taskId, labelId })),
-            });
-          }
-        }
-
-        return task;
-      });
-    },
-  },
-
-  move_task: {
-    description: "Move a task to a different status column (e.g. TODO, IN_PROGRESS, IN_REVIEW, DONE, CANCELLED).",
-    schema: z.object({
-      taskId: z.string(),
-      status: TaskStatus,
-    }),
-    handler: async (args: { taskId: string; status: string }) => {
-      // Delegate to updateTaskStatus to trigger side effects (dreaming on DONE, worktree cleanup on CANCELLED, etc.)
-      const { updateTaskStatus } = await import("@/actions/task-actions");
-      return updateTaskStatus(args.taskId, args.status as "TODO" | "IN_PROGRESS" | "IN_REVIEW" | "DONE" | "CANCELLED");
-    },
-  },
-
-  delete_task: {
-    description: "Delete a task by ID.",
-    schema: z.object({
-      taskId: z.string(),
-    }),
-    handler: async (args: { taskId: string }) => {
-      await db.task.delete({ where: { id: args.taskId } });
-      return { deleted: true, taskId: args.taskId };
-    },
-  },
-};

package/src/mcp/tools/terminal-tools.ts

@@ -1,154 +0,0 @@
-import { z } from "zod";
-import { db } from "../db";
-
-const PORT = process.env.PORT ?? "3000";
-const BRIDGE_BASE = `http://localhost:${PORT}/api/internal/terminal`;
-const CUID_RE = /^c[a-z0-9]{20,30}$/;
-
-async function bridgeFetch(path: string, init?: RequestInit): Promise<Response> {
-  return fetch(`${BRIDGE_BASE}${path}`, init);
-}
-
-function validateMcpTaskId(taskId: string): string | null {
-  if (!CUID_RE.test(taskId)) return "Invalid taskId format — expected CUID";
-  return null;
-}
-
-export const terminalTools = {
-  start_task_execution: {
-    description:
-      "Start a Claude CLI terminal session for a task. The prompt is sent as the initial instruction. The task status will change to IN_PROGRESS. Returns executionId and worktreePath (if worktree mode).",
-    schema: z.object({
-      taskId: z.string(),
-      prompt: z.string().optional(),
-    }),
-    handler: async (args: { taskId: string; prompt?: string }) => {
-      const err = validateMcpTaskId(args.taskId);
-      if (err) return { error: err, taskId: args.taskId };
-      const tid = encodeURIComponent(args.taskId);
-      const response = await bridgeFetch(`/${tid}/start`, {
-        method: "POST",
-        headers: { "Content-Type": "application/json" },
-        body: JSON.stringify({ prompt: args.prompt ?? "" }),
-      });
-
-      if (response.ok) {
-        const data = await response.json();
-        return { ok: true, ...data };
-      }
-
-      const errData = await response.json().catch(() => ({}));
-      return { error: (errData as Record<string, unknown>).error ?? "Failed to start execution", status: response.status };
-    },
-  },
-
-  get_task_terminal_output: {
-    description:
-      "Get recent terminal output lines from a running task's PTY session. Returns the last N lines (default 50, max 500).",
-    schema: z.object({
-      taskId: z.string(),
-      lines: z.number().int().min(1).max(500).optional(),
-    }),
-    handler: async (args: { taskId: string; lines?: number }) => {
-      const err = validateMcpTaskId(args.taskId);
-      if (err) return { error: err, taskId: args.taskId };
-      const tid = encodeURIComponent(args.taskId);
-      const response = await bridgeFetch(`/${tid}/buffer?lines=${args.lines ?? 50}`);
-
-      if (response.status === 404) {
-        return { error: "No active terminal session for this task", taskId: args.taskId };
-      }
-
-      if (response.ok) {
-        const data = await response.json() as { taskId: string; lines: string[]; total: number; killed: boolean };
-        return { taskId: data.taskId, lines: data.lines, total: data.total, killed: data.killed };
-      }
-
-      return { error: "Bridge request failed", status: response.status };
-    },
-  },
-
-  send_task_terminal_input: {
-    description:
-      "Send text input to a running task's PTY terminal. The text is forwarded directly to the Claude CLI process. Include \\n for Enter key.",
-    schema: z.object({
-      taskId: z.string(),
-      text: z.string().min(1).max(10000),
-    }),
-    handler: async (args: { taskId: string; text: string }) => {
-      const err = validateMcpTaskId(args.taskId);
-      if (err) return { error: err, taskId: args.taskId };
-      const tid = encodeURIComponent(args.taskId);
-      const response = await bridgeFetch(`/${tid}/input`, {
-        method: "POST",
-        headers: { "Content-Type": "application/json" },
-        body: JSON.stringify({ text: args.text }),
-      });
-
-      if (response.status === 404) {
-        return { error: "No active terminal session for this task", taskId: args.taskId };
-      }
-
-      if (response.status === 410) {
-        return { error: "Terminal session has exited", taskId: args.taskId };
-      }
-
-      if (response.ok) {
-        return { ok: true, taskId: args.taskId };
-      }
-
-      return { error: "Bridge request failed", status: response.status };
-    },
-  },
-
-  get_task_execution_status: {
-    description:
-      "Get the execution status of a task including whether its terminal is running, idle, or exited. Also returns a snippet of recent output.",
-    schema: z.object({
-      taskId: z.string(),
-    }),
-    handler: async (args: { taskId: string }) => {
-      const err = validateMcpTaskId(args.taskId);
-      if (err) return { error: err, taskId: args.taskId };
-
-      const execution = await db.taskExecution.findFirst({
-        where: { taskId: args.taskId },
-        orderBy: { createdAt: "desc" },
-      });
-
-      if (!execution) {
-        return { error: "No execution found for this task", taskId: args.taskId };
-      }
-
-      const tid = encodeURIComponent(args.taskId);
-      const bufferResponse = await bridgeFetch(`/${tid}/buffer?lines=10`);
-
-      let terminalStatus: "running" | "exited" | "not_running";
-      let outputSnippet: string | null = null;
-
-      if (bufferResponse.status === 404) {
-        // No active session — check DB status
-        const doneStatuses = ["COMPLETED", "FAILED"];
-        terminalStatus = doneStatuses.includes(execution.status) ? "exited" : "not_running";
-      } else if (bufferResponse.ok) {
-        const bufferData = await bufferResponse.json() as { lines: string[]; killed: boolean };
-        terminalStatus = bufferData.killed ? "exited" : "running";
-        if (bufferData.lines && bufferData.lines.length > 0) {
-          outputSnippet = bufferData.lines.slice(-5).join("\n");
-        }
-      } else {
-        terminalStatus = "not_running";
-      }
-
-      return {
-        taskId: args.taskId,
-        executionId: execution.id,
-        executionStatus: execution.status,
-        terminalStatus,
-        startedAt: execution.startedAt,
-        endedAt: execution.endedAt,
-        outputSnippet,
-      };
-    },
-  },
-};

package/src/mcp/tools/workspace-tools.ts

@@ -1,73 +0,0 @@
-import { z } from "zod";
-import { db } from "../db";
-
-export const workspaceTools = {
-  list_workspaces: {
-    description: "List all workspaces ordered by last updated, including project count for each.",
-    schema: z.object({}),
-    handler: async (_args: Record<string, never>) => {
-      const workspaces = await db.workspace.findMany({
-        include: {
-          projects: {
-            select: { id: true },
-          },
-        },
-        orderBy: { updatedAt: "desc" },
-      });
-
-      return workspaces.map(({ projects, ...rest }) => ({
-        ...rest,
-        projectCount: projects.length,
-      }));
-    },
-  },
-
-  create_workspace: {
-    description: "Create a new workspace with a name and optional description.",
-    schema: z.object({
-      name: z.string(),
-      description: z.string().optional(),
-    }),
-    handler: async (args: { name: string; description?: string }) => {
-      return db.workspace.create({
-        data: {
-          name: args.name,
-          description: args.description,
-        },
-      });
-    },
-  },
-
-  update_workspace: {
-    description: "Update an existing workspace's name and/or description.",
-    schema: z.object({
-      workspaceId: z.string(),
-      name: z.string().optional(),
-      description: z.string().optional(),
-    }),
-    handler: async (args: { workspaceId: string; name?: string; description?: string }) => {
-      return db.workspace.update({
-        where: { id: args.workspaceId },
-        data: {
-          name: args.name,
-          description: args.description,
-        },
-      });
-    },
-  },
-
-  delete_workspace: {
-    description: "Delete a workspace by ID. Cascade delete is handled by the Prisma schema.",
-    schema: z.object({
-      workspaceId: z.string(),
-    }),
-    handler: async (args: { workspaceId: string }) => {
-      const count = await db.workspace.count();
-      if (count <= 1) {
-        throw new Error("Cannot delete the last workspace");
-      }
-      await db.workspace.delete({ where: { id: args.workspaceId } });
-      return { deleted: true, workspaceId: args.workspaceId };
-    },
-  },
-};