tower-studio 0.1.1 → 0.1.2

package/.next/standalone/tower/src/lib/file-utils.ts

@@ -0,0 +1,108 @@
+import * as crypto from "node:crypto";
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { getStorageDir } from "./tower-dir";
+
+const DATA_ROOT = getStorageDir();
+
+function assertWithinDataRoot(resolved: string): void {
+  if (!resolved.startsWith(DATA_ROOT + path.sep)) {
+    throw new Error("Path traversal detected");
+  }
+}
+
+export function getAssetsDir(projectId: string): string {
+  const dir = path.join(DATA_ROOT, "assets", projectId);
+  assertWithinDataRoot(dir);
+  return dir;
+}
+
+export function getCacheDir(taskId: string): string {
+  const dir = path.join(DATA_ROOT, "cache", taskId);
+  assertWithinDataRoot(dir);
+  return dir;
+}
+
+export function ensureAssetsDir(projectId: string): string {
+  const dir = getAssetsDir(projectId);
+  fs.mkdirSync(dir, { recursive: true });
+  return dir;
+}
+
+export function ensureCacheDir(taskId: string): string {
+  const dir = getCacheDir(taskId);
+  fs.mkdirSync(dir, { recursive: true });
+  return dir;
+}
+
+export function listAssetFiles(projectId: string): string[] {
+  const dir = getAssetsDir(projectId);
+  if (!fs.existsSync(dir)) return [];
+  return fs.readdirSync(dir);
+}
+
+export type CacheFileType = "images" | "files";
+
+export function getAssistantCacheDir(type: CacheFileType = "images"): string {
+  const now = new Date();
+  const ym = `${now.getFullYear()}-${String(now.getMonth() + 1).padStart(2, "0")}`;
+  const dir = path.join(DATA_ROOT, "cache", "assistant", ym, type);
+  assertWithinDataRoot(dir);
+  fs.mkdirSync(dir, { recursive: true });
+  return dir;
+}
+
+export function getAssistantCacheRoot(): string {
+  const dir = path.join(DATA_ROOT, "cache", "assistant");
+  assertWithinDataRoot(dir);
+  return dir;
+}
+
+const MEANINGLESS_STEMS = new Set([
+  "image", "screenshot", "img", "photo", "picture",
+  "clipboard", "paste", "untitled",
+]);
+
+export function buildCacheFilename(originalName: string, ext: string): string {
+  const stem = path.basename(originalName, path.extname(originalName));
+  const uuid8 = crypto.randomUUID().replace(/-/g, "").slice(0, 8);
+
+  const stemLower = stem.toLowerCase();
+  const isMeaningless =
+    !stem ||
+    MEANINGLESS_STEMS.has(stemLower) ||
+    /^screenshot[\s_\-]/i.test(stem);
+
+  if (isMeaningless) {
+    return `tower_image-${uuid8}${ext}`;
+  }
+
+  const sanitized = stem
+    .replace(/[^\p{L}\p{N}]/gu, "_")
+    .replace(/_+/g, "_")
+    .replace(/^_+|_+$/g, "");
+
+  const safeStem = sanitized || "file";
+  return `${safeStem}-${uuid8}${ext}`;
+}
+
+const CACHE_UUID_SUFFIX_RE = /-([0-9a-f]{8})(\.[^.]+)$/i;
+
+/**
+ * Strip the 8-hex UUID suffix added by buildCacheFilename.
+ * e.g. "设计稿-a1b2c3d4.png" → "设计稿.png"
+ *      "tower_image-a1b2c3d4.png" → "tower_image.png"
+ *      "already-clean.png" → "already-clean.png" (no change)
+ */
+export function stripCacheUuidSuffix(filename: string): string {
+  return filename.replace(CACHE_UUID_SUFFIX_RE, "$2");
+}
+
+/**
+ * Returns true if the absolute filePath is inside the assistant cache root.
+ * Used to gate UUID stripping — only strip for cache files.
+ */
+export function isAssistantCachePath(filePath: string): boolean {
+  const root = getAssistantCacheRoot();
+  return filePath.startsWith(root + path.sep);
+}

package/.next/standalone/tower/src/lib/fs-security.ts

@@ -0,0 +1,22 @@
+import path from "path";
+
+/**
+ * Validates that `relative` resolves to a path within `base`.
+ * Prevents path traversal attacks (e.g., ../../etc/passwd).
+ * Per D-02: used by all file operation server actions in Phase 20 and Phase 21 editor.
+ *
+ * @param base - Absolute base directory (the worktree root)
+ * @param relative - Relative path provided by client
+ * @returns Resolved absolute path guaranteed to be within base
+ * @throws Error if path escapes the base directory
+ */
+export function safeResolvePath(base: string, relative: string): string {
+  // Normalize base to remove trailing separator for consistent comparison
+  const normalizedBase = base.endsWith(path.sep) ? base.slice(0, -1) : base;
+  const resolved = path.resolve(normalizedBase, relative);
+  // Allow exact match (relative = "." resolves to base itself)
+  if (resolved !== normalizedBase && !resolved.startsWith(normalizedBase + path.sep)) {
+    throw new Error(`Path traversal attempt: ${relative}`);
+  }
+  return resolved;
+}

package/.next/standalone/tower/src/lib/fts.ts

@@ -0,0 +1,83 @@
+// src/lib/fts.ts — NO Next.js imports
+// FTS5 search helper and sync functions for notes_fts virtual table.
+// Accepts PrismaClient as a parameter (dependency injection) so it is safe
+// for both Next.js server actions and MCP stdio processes.
+import type { PrismaClient } from "@prisma/client";
+
+export interface FtsNoteResult {
+  note_id: string;
+  title: string;
+  content: string;
+}
+
+/**
+ * Search notes for a project using FTS5 (3+ chars) or LIKE fallback (< 3 chars).
+ * Returns an empty array for blank queries.
+ */
+export async function searchNotes(
+  db: PrismaClient,
+  projectId: string,
+  query: string
+): Promise<FtsNoteResult[]> {
+  const trimmed = query.trim();
+  if (!trimmed) return [];
+
+  if (trimmed.length < 3) {
+    // Fallback: LIKE search on the regular note table (FTS5 trigram needs 3+ chars)
+    return db.$queryRawUnsafe<FtsNoteResult[]>(
+      `SELECT id as note_id, title, content FROM "ProjectNote"
+       WHERE "projectId" = ? AND (title LIKE ? OR content LIKE ?)
+       LIMIT 20`,
+      projectId,
+      `%${trimmed}%`,
+      `%${trimmed}%`
+    );
+  }
+
+  // FTS5 trigram search (3+ chars)
+  return db.$queryRawUnsafe<FtsNoteResult[]>(
+    `SELECT f.note_id, f.title, f.content
+     FROM notes_fts f
+     JOIN "ProjectNote" n ON n.id = f.note_id
+     WHERE f.notes_fts MATCH ? AND n."projectId" = ?
+     ORDER BY rank
+     LIMIT 20`,
+    trimmed,
+    projectId
+  );
+}
+
+/**
+ * Insert or replace a note in the notes_fts virtual table.
+ * Performs delete-then-insert to avoid duplicate FTS rows on update.
+ */
+export async function syncNoteToFts(
+  db: PrismaClient,
+  note: { id: string; title: string; content: string }
+): Promise<void> {
+  // Delete existing entry if any, then insert fresh
+  await db.$executeRawUnsafe(
+    "DELETE FROM notes_fts WHERE note_id = ?",
+    note.id
+  );
+  await db.$executeRawUnsafe(
+    "INSERT INTO notes_fts(note_id, title, content) VALUES (?, ?, ?)",
+    note.id,
+    note.title,
+    note.content
+  );
+}
+
+/**
+ * Remove a note from the notes_fts virtual table.
+ * Safe to call even if the note was never indexed.
+ */
+export async function deleteNoteFromFts(
+  db: PrismaClient,
+  noteId: string
+): Promise<void> {
+  await db.$executeRawUnsafe(
+    "DELETE FROM notes_fts WHERE note_id = ?",
+    noteId
+  );
+}

package/.next/standalone/tower/src/lib/git-api.ts

@@ -0,0 +1,19 @@
+/**
+ * Client-side helper for calling the git API.
+ */
+export async function gitAction(
+  path: string,
+  action: string,
+  extra: Record<string, unknown> = {}
+) {
+  const res = await fetch("/api/git", {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify({ action, path, ...extra }),
+  });
+  if (!res.ok) {
+    const err = await res.json();
+    throw new Error(err.error || `${action} failed`);
+  }
+  return res.json();
+}

package/.next/standalone/tower/src/lib/git-url.ts

@@ -0,0 +1,244 @@
+import os from "os";
+import path from "path";
+
+export function expandHome(p: string): string {
+  if (p.startsWith("~/")) return path.join(os.homedir(), p.slice(2));
+  return p;
+}
+
+export interface GitPathRule {
+  id: string;
+  host: string;
+  ownerMatch: string;        // exact owner, or "*" for any
+  localPathTemplate: string; // supports {owner}; {repo} auto-appended
+  priority: number;          // lower number = higher priority
+}
+
+/**
+ * Match a git URL against a list of GitPathRule entries.
+ * Rules are sorted by priority (lower = higher priority).
+ * First matching rule returns the interpolated localPathTemplate.
+ * Returns "" if no rule matches.
+ */
+export function matchGitPathRule(url: string, rules: GitPathRule[]): string {
+  if (!rules.length) return "";
+  const trimmed = url.trim();
+  if (!trimmed) return "";
+  const parsed = parseGitUrl(trimmed);
+  if (!parsed) return "";
+
+  const { host, pathSegments } = parsed;
+  const owner = pathSegments[0] ?? "";
+  const repo = pathSegments[pathSegments.length - 1] ?? "";
+
+  // Exact owner matches take priority over wildcard (*), regardless of priority number
+  const sorted = [...rules].sort((a, b) => {
+    const aExact = a.ownerMatch !== "*" ? 0 : 1;
+    const bExact = b.ownerMatch !== "*" ? 0 : 1;
+    if (aExact !== bExact) return aExact - bExact;
+    return a.priority - b.priority;
+  });
+
+  // Full path = all segments joined (e.g. "EBG_jcjf/jiangsu/NJZSBM/enrollment-static")
+  const fullPath = pathSegments.join("/");
+
+  for (const rule of sorted) {
+    if (rule.host !== host) continue;
+    if (rule.ownerMatch !== "*" && rule.ownerMatch !== owner) continue;
+
+    const tpl = rule.localPathTemplate;
+
+    // If template contains {path}, replace with full path (preserves subgroup structure)
+    if (tpl.includes("{path}")) {
+      const result = tpl
+        .replace("{path}", fullPath)
+        .replace("{owner}", owner)
+        .replace("{repo}", repo)
+        .replace(/\/+$/, "");
+      return expandHome(result);
+    }
+
+    // Default: auto-append repo name to base path
+    const base = tpl
+      .replace("{owner}", owner)
+      .replace("{repo}", "")
+      .replace(/\/+$/, "");
+    return expandHome(`${base}/${repo}`);
+  }
+  return "";
+}
+
+/**
+ * Git URL → Local Path mapping (hardcoded rules for now, will extract to config later)
+ *
+ * Rules:
+ *   code.iflytek.com  → ~/company/{org/path/repo}
+ *   github.com/jp-liu → ~/project/i/{repo}
+ *   github.com/other  → ~/project/f/{repo}
+ */
+
+const GITHUB_USERNAME = "jp-liu";
+const COMPANY_HOST = "code.iflytek.com";
+
+/**
+ * Parse a git URL and return the suggested local path.
+ * Returns empty string if the URL is not recognized.
+ */
+export function gitUrlToLocalPath(url: string): string {
+  const trimmed = url.trim();
+  if (!trimmed) return "";
+
+  try {
+    // Normalize: extract host and path from various URL formats
+    const parsed = parseGitUrl(trimmed);
+    if (!parsed) return "";
+
+    const { host, pathSegments } = parsed;
+
+    if (host === COMPANY_HOST) {
+      return expandHome(companyPath(pathSegments));
+    }
+
+    if (host === "github.com") {
+      return expandHome(githubPath(pathSegments));
+    }
+
+    // Unknown host — fallback: ~/project/f/{repo}
+    const repo = pathSegments[pathSegments.length - 1];
+    return repo ? expandHome(`~/project/f/${repo}`) : "";
+  } catch {
+    return "";
+  }
+}
+
+/**
+ * Normalize any git-related URL into a valid clone URL.
+ *
+ * Browser URLs (not clonable) are converted to HTTPS clone URLs:
+ *   https://code.iflytek.com/osc/_source/EBG_jcjf/.../repo/-/code/
+ *     → https://code.iflytek.com/EBG_jcjf/.../repo.git
+ *   https://github.com/user/repo (no .git)
+ *     → https://github.com/user/repo.git
+ *
+ * Already valid clone URLs are returned as-is:
+ *   git@github.com:user/repo.git
+ *   ssh://git@code.iflytek.com:30004/path.git
+ *   https://github.com/user/repo.git
+ */
+export function toCloneUrl(url: string): string {
+  const trimmed = url.trim();
+  if (!trimmed) return "";
+
+  // SSH shorthand — already a valid clone URL
+  if (trimmed.startsWith("git@")) return trimmed;
+
+  // ssh:// — already a valid clone URL
+  if (trimmed.startsWith("ssh://")) return trimmed;
+
+  // If it ends with .git, assume it's already a clone URL
+  if (trimmed.endsWith(".git")) return trimmed;
+
+  try {
+    const urlObj = new URL(trimmed);
+    const host = urlObj.hostname;
+    const rawPath = decodeURIComponent(urlObj.pathname);
+    const segments = rawPath.split("/").filter(Boolean);
+
+    if (host === COMPANY_HOST) {
+      // Strip GitLab prefixes: osc/_source
+      let parts = [...segments];
+      if (parts[0] === "osc" && parts[1] === "_source") {
+        parts = parts.slice(2);
+      }
+      // Strip GitLab suffixes: /-/code, /-/tree/branch, /-/blob/...
+      const dashIdx = parts.indexOf("-");
+      if (dashIdx > 0) {
+        parts = parts.slice(0, dashIdx);
+      }
+      if (parts.length === 0) return trimmed;
+      return `https://${host}/${parts.join("/")}.git`;
+    }
+
+    // GitHub / other — just append .git
+    return `${urlObj.origin}${urlObj.pathname.replace(/\/$/, "")}.git`;
+  } catch {
+    return trimmed;
+  }
+}
+
+// ─── Internal ────────────────────────────────────────────────────────
+
+export interface ParsedUrl {
+  host: string;
+  pathSegments: string[];
+}
+
+export function parseGitUrl(raw: string): ParsedUrl | null {
+  // SSH shorthand: git@github.com:owner/repo.git
+  const sshShort = raw.match(/^git@([^:]+):(.+)$/);
+  if (sshShort) {
+    const host = sshShort[1];
+    const path = stripGitSuffix(sshShort[2]);
+    return { host, pathSegments: path.split("/").filter(Boolean) };
+  }
+
+  // ssh://git@host:port/path or https://host/path
+  let urlObj: URL;
+  try {
+    // ssh://git@code.iflytek.com:30004/path → need to handle port in URL
+    urlObj = new URL(raw);
+  } catch {
+    return null;
+  }
+
+  const host = urlObj.hostname;
+  const rawPath = stripGitSuffix(decodeURIComponent(urlObj.pathname));
+  const segments = rawPath.split("/").filter(Boolean);
+
+  return { host, pathSegments: segments };
+}
+
+function stripGitSuffix(p: string): string {
+  return p.replace(/\.git\/?$/, "");
+}
+
+/**
+ * code.iflytek.com paths:
+ *   /osc/_source/EBG_jcjf/jiangsu/NJZSBM/enrollment-static/-/code/
+ *   /EBG_jcjf/jiangsu/NJZSBM/enrollment-static
+ *
+ * Strip known prefixes (osc/_source) and suffixes (/-/code, /-/tree, etc.)
+ * Result: ~/company/EBG_jcjf/jiangsu/NJZSBM/enrollment-static
+ */
+function companyPath(segments: string[]): string {
+  let parts = [...segments];
+
+  // Strip leading "osc/_source" or similar prefixes
+  if (parts[0] === "osc" && parts[1] === "_source") {
+    parts = parts.slice(2);
+  }
+
+  // Strip trailing gitlab-like suffixes: /-/code, /-/tree/branch, etc.
+  const dashIdx = parts.indexOf("-");
+  if (dashIdx > 0) {
+    parts = parts.slice(0, dashIdx);
+  }
+
+  if (parts.length === 0) return "";
+  return `~/company/${parts.join("/")}`;
+}
+
+/**
+ * github.com paths:
+ *   /jp-liu/inkos   → ~/project/i/inkos
+ *   /other/opencli  → ~/project/f/opencli
+ */
+function githubPath(segments: string[]): string {
+  // segments: [owner, repo, ...]
+  const owner = segments[0];
+  const repo = segments[1];
+  if (!owner || !repo) return "";
+
+  const prefix = owner === GITHUB_USERNAME ? "~/project/i" : "~/project/f";
+  return `${prefix}/${repo}`;
+}