tower-studio 0.1.0 → 0.1.2

package/.next/standalone/tower/src/lib/config-defaults.ts

@@ -0,0 +1,121 @@
+export interface ConfigEntry {
+  defaultValue: unknown;
+  type: "string" | "number" | "boolean" | "object";
+  label: string;
+}
+
+export const CONFIG_DEFAULTS: Record<string, ConfigEntry> = {
+  "git.pathMappingRules": {
+    defaultValue: [],
+    type: "object",
+    label: "Git Path Mapping Rules",
+  },
+  "system.maxUploadBytes": {
+    defaultValue: 52428800,
+    type: "number",
+    label: "Max Upload Size (bytes)",
+  },
+  "system.maxConcurrentExecutions": {
+    defaultValue: 20,
+    type: "number",
+    label: "Max Concurrent Executions",
+  },
+  "git.timeoutSec": {
+    defaultValue: 30,
+    type: "number",
+    label: "Git Operation Timeout (seconds)",
+  },
+  "search.resultLimit": {
+    defaultValue: 20,
+    type: "number",
+    label: "Search Result Limit",
+  },
+  "search.allModeCap": {
+    defaultValue: 5,
+    type: "number",
+    label: "All-Mode Per-Type Cap",
+  },
+  "search.debounceMs": {
+    defaultValue: 250,
+    type: "number",
+    label: "Search Debounce (ms)",
+  },
+  "search.snippetLength": {
+    defaultValue: 80,
+    type: "number",
+    label: "Snippet Length (characters)",
+  },
+  "missions.grid.minCols": {
+    defaultValue: 1,
+    type: "number",
+    label: "Grid Min Columns",
+  },
+  "missions.grid.maxCols": {
+    defaultValue: 5,
+    type: "number",
+    label: "Grid Max Columns",
+  },
+  "missions.grid.minRows": {
+    defaultValue: 1,
+    type: "number",
+    label: "Grid Min Rows",
+  },
+  "missions.grid.maxRows": {
+    defaultValue: 5,
+    type: "number",
+    label: "Grid Max Rows",
+  },
+  "terminal.app": {
+    defaultValue: "Terminal",
+    type: "string",
+    label: "Default Terminal App",
+  },
+  "terminal.wsPort": {
+    defaultValue: 3001,
+    type: "number",
+    label: "WebSocket Port",
+  },
+  "terminal.idleTimeoutSec": {
+    defaultValue: 180,
+    type: "number",
+    label: "Idle Timeout (seconds)",
+  },
+  "assistant.systemPrompt": {
+    defaultValue: [
+      "You are Tower Assistant — the built-in AI operator for the Tower task management platform.",
+      "",
+      "## Identity",
+      "- You are a task management operator, NOT a coding assistant.",
+      "- You can ONLY use Tower MCP tools. You CANNOT read files, edit code, run shell commands, or search the web.",
+      "- Always respond in the same language the user uses.",
+      "",
+      "## Capabilities",
+      "When users ask what you can do, respond with EXACTLY these 6 groups. Translate to the user's language.",
+      "",
+      "1. **Workspace & Project** — View, create, update, delete workspaces and projects. Search projects and repositories.",
+      "2. **Task Management** — Create tasks (priority, labels, worktree branch isolation, sub-path, auto-start). Move task status (TODO → IN_PROGRESS → IN_REVIEW → DONE / CANCELLED). Update task info and labels.",
+      "3. **Execution Monitor** — Start task execution, check execution status, get terminal output, send commands to running terminals.",
+      "4. **Daily Report & Todo** — Generate daily work summary (completed + in-progress). View pending task list sorted by priority.",
+      "5. **Labels & Notes & Assets** — Manage workspace labels, project notes, and file attachments.",
+      "6. **Global Search** — Search tasks, projects, repositories, notes, and assets by keyword.",
+      "",
+      "Do NOT list any capabilities beyond the above. Do NOT mention code editing, debugging, testing, git operations, or any development capabilities.",
+      "",
+      "## Scope Boundary",
+      "If the user asks you to write code, explain code, debug, search the web, read/write files, or anything outside Tower task management, reply:",
+      "\"抱歉，我只能帮你管理工作区、项目和任务。编码、调试等操作请在任务终端中完成。\"",
+    ].join("\n"),
+    type: "string",
+    label: "Assistant System Prompt",
+  },
+  "assistant.displayMode": {
+    defaultValue: "sidebar",
+    type: "string",
+    label: "Assistant Display Mode",
+  },
+  "assistant.communicationMode": {
+    defaultValue: "chat",
+    type: "string",
+    label: "Assistant Communication Mode",
+  },
+};

package/.next/standalone/tower/src/lib/config-reader.ts

@@ -0,0 +1,16 @@
+/**
+ * Thin config reader for non-Next.js server modules (process-manager, adapters).
+ * Does NOT use "use server" or next/cache — safe to import from any Node.js context.
+ * Mirrors the getConfigValue logic from config-actions.ts without Next.js dependencies.
+ */
+import { db } from "@/lib/db";
+
+export async function readConfigValue<T>(key: string, defaultValue: T): Promise<T> {
+  const row = await db.systemConfig.findUnique({ where: { key } });
+  if (!row) return defaultValue;
+  try {
+    return JSON.parse(row.value) as T;
+  } catch {
+    return defaultValue;
+  }
+}

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

@@ -0,0 +1,26 @@
+import type { TaskStatus } from "@prisma/client";
+
+export const BOARD_COLUMNS: { id: TaskStatus; label: string; color: string }[] = [
+  { id: "TODO", label: "To Do", color: "bg-slate-400" },
+  { id: "IN_PROGRESS", label: "In Progress", color: "bg-amber-400" },
+  { id: "IN_REVIEW", label: "In Review", color: "bg-sky-400" },
+  { id: "DONE", label: "Done", color: "bg-emerald-400" },
+  { id: "CANCELLED", label: "Cancelled", color: "bg-rose-400" },
+];
+
+export const PRIORITY_CONFIG = {
+  LOW: { label: "低", color: "bg-slate-500/20 text-slate-300 border border-slate-500/30" },
+  MEDIUM: { label: "中", color: "bg-amber-500/20 text-amber-300 border border-amber-500/30" },
+  HIGH: { label: "高", color: "bg-orange-500/20 text-orange-300 border border-orange-500/30" },
+  CRITICAL: { label: "紧急", color: "bg-rose-500/20 text-rose-300 border border-rose-500/30" },
+} as const;
+
+/** System label name for project workbench tasks — hidden from kanban board */
+export const TOWER_LABEL_NAME = "Tower";
+export const TOWER_LABEL_COLOR = "#8b5cf6"; // purple
+
+export const AGENTS = ["CLAUDE_CODE", "MINIMAX"] as const;
+export type AgentType = (typeof AGENTS)[number];
+
+export const NOTE_CATEGORIES_PRESET = ["账号", "环境", "需求", "备忘"] as const;
+export type NoteCategoryPreset = (typeof NOTE_CATEGORIES_PRESET)[number];

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

@@ -0,0 +1,28 @@
+import { PrismaClient } from "@prisma/client";
+
+const globalForPrisma = globalThis as unknown as {
+  prisma: PrismaClient | undefined;
+};
+
+export const db =
+  globalForPrisma.prisma ??
+  new PrismaClient({
+    log: process.env.NODE_ENV === "development" ? ["query"] : [],
+  });
+
+if (process.env.NODE_ENV !== "production") globalForPrisma.prisma = db;
+
+let initialized = false;
+
+export async function initDb(): Promise<PrismaClient> {
+  if (initialized) return db;
+  await db.$connect();
+  await db.$queryRaw`PRAGMA journal_mode=WAL`;
+  await db.$queryRaw`PRAGMA busy_timeout=5000`;
+  initialized = true;
+  return db;
+}
+
+// Ensure WAL is flushed and connections closed on exit
+process.on("SIGTERM", () => { db.$disconnect().catch(() => {}); });
+process.on("SIGINT", () => { db.$disconnect().catch(() => {}); });

package/.next/standalone/tower/src/lib/diff-parser.ts

@@ -0,0 +1,132 @@
+import { execFileSync } from "child_process";
+
+export interface DiffFile {
+  filename: string;
+  added: number;
+  removed: number;
+  isBinary: boolean;
+  patch: string; // unified diff content for this file
+}
+
+export interface DiffResponse {
+  files: DiffFile[];
+  totalAdded: number;
+  totalRemoved: number;
+  hasConflicts: boolean;
+  conflictFiles: string[];
+}
+
+/**
+ * Parse git diff --numstat and git diff --unified=3 output into structured DiffFile array.
+ * Returns data without hasConflicts/conflictFiles (those are added by the caller).
+ */
+export function parseDiffOutput(
+  numstat: string,
+  unifiedDiff: string
+): Omit<DiffResponse, "hasConflicts" | "conflictFiles"> {
+  // Parse numstat: each line is `{added}\t{removed}\t{filename}`
+  // Binary files have `-\t-\t{filename}`
+  const numstatEntries: Array<{
+    filename: string;
+    added: number;
+    removed: number;
+    isBinary: boolean;
+  }> = [];
+
+  for (const line of numstat.split("\n")) {
+    const trimmed = line.trim();
+    if (!trimmed) continue;
+    const parts = trimmed.split("\t");
+    if (parts.length < 3) continue;
+    const [addedStr, removedStr, ...filenameParts] = parts;
+    const filename = filenameParts.join("\t");
+    if (addedStr === "-" && removedStr === "-") {
+      numstatEntries.push({ filename, added: 0, removed: 0, isBinary: true });
+    } else {
+      numstatEntries.push({
+        filename,
+        added: parseInt(addedStr, 10) || 0,
+        removed: parseInt(removedStr, 10) || 0,
+        isBinary: false,
+      });
+    }
+  }
+
+  // Parse unified diff: split on lines matching `^diff --git a/.+ b/.+`
+  const DIFF_GIT_HEADER = /^diff --git a\/.+ b\/.+$/m;
+  const diffHeaderRegex = /^diff --git a\/(.+) b\/(.+)$/;
+
+  // Split into segments per file
+  const patchMap = new Map<string, string>();
+
+  if (unifiedDiff.trim()) {
+    const isTruncationNeeded = unifiedDiff.length > 500 * 1024; // 500KB
+
+    // Split at each diff --git header line
+    const segments = unifiedDiff.split(/(?=^diff --git )/m);
+    for (const segment of segments) {
+      if (!segment.trim()) continue;
+      const firstLine = segment.split("\n")[0];
+      const match = diffHeaderRegex.exec(firstLine);
+      if (!match) continue;
+      const filename = match[2]; // Use b/ filename
+
+      let patch = segment;
+      if (isTruncationNeeded) {
+        const lines = segment.split("\n");
+        if (lines.length > 200) {
+          patch = lines.slice(0, 200).join("\n") + "\n... (truncated)";
+        }
+      }
+      patchMap.set(filename, patch);
+    }
+  }
+
+  // Match numstat entries to unified diff segments by filename
+  const files: DiffFile[] = numstatEntries.map((entry) => ({
+    filename: entry.filename,
+    added: entry.added,
+    removed: entry.removed,
+    isBinary: entry.isBinary,
+    patch: patchMap.get(entry.filename) ?? "",
+  }));
+
+  const totalAdded = files.reduce((sum, f) => sum + f.added, 0);
+  const totalRemoved = files.reduce((sum, f) => sum + f.removed, 0);
+
+  return { files, totalAdded, totalRemoved };
+}
+
+/**
+ * Check if merging worktreeBranch into baseBranch would produce conflicts.
+ * Uses `git merge-tree --write-tree` for a dry-run conflict check.
+ */
+export function checkConflicts(
+  localPath: string,
+  baseBranch: string,
+  worktreeBranch: string
+): { hasConflicts: boolean; conflictFiles: string[] } {
+  try {
+    execFileSync(
+      "git", ["merge-tree", "--write-tree", baseBranch, worktreeBranch],
+      { cwd: localPath, encoding: "utf-8", timeout: 10000, stdio: "pipe" }
+    );
+    return { hasConflicts: false, conflictFiles: [] };
+  } catch (err: unknown) {
+    // Exit code 1 means conflicts exist — parse stdout for CONFLICT lines
+    const output =
+      err instanceof Error && "stdout" in err
+        ? String((err as NodeJS.ErrnoException & { stdout?: string }).stdout ?? "")
+        : "";
+    const conflictFiles = output
+      .split("\n")
+      .filter((line) => line.includes("CONFLICT"))
+      .map((line) => {
+        // Lines look like: "CONFLICT (content): Merge conflict in path/to/file"
+        const match = line.match(/CONFLICT.*?:\s*(.+)$/);
+        return match ? match[1].trim() : line.trim();
+      })
+      .filter(Boolean);
+    return { hasConflicts: true, conflictFiles };
+  }
+}

package/.next/standalone/tower/src/lib/execution-summary.ts

@@ -0,0 +1,287 @@
+import { execFileSync } from "child_process";
+import { existsSync } from "fs";
+import { db } from "@/lib/db";
+import { generateSummaryFromLog, generateDreamingInsight, type DreamingResult } from "@/lib/claude-session";
+
+const TERMINAL_LOG_MAX = 10 * 1024; // 10 KB
+
+/** Format dreaming insights into readable Markdown content */
+function formatDreamingContent(dream: DreamingResult): string {
+  const lines: string[] = [];
+  lines.push("## Summary");
+  lines.push(dream.summary);
+  lines.push("");
+
+  if (dream.insights.length > 0) {
+    lines.push("## Insights");
+    for (const insight of dream.insights) {
+      lines.push(`- **[${insight.type}]**: ${insight.content}`);
+    }
+  }
+
+  return lines.join("\n");
+}
+
+interface GitStats {
+  commits: number;
+  filesChanged: number;
+  insertions: number;
+  deletions: number;
+}
+
+function runGit(args: string[], cwd: string): string {
+  return execFileSync("git", args, {
+    cwd,
+    timeout: 10_000,
+    encoding: "utf-8",
+    stdio: ["pipe", "pipe", "pipe"],
+  }).trim();
+}
+
+function getMergeBase(cwd: string): string | null {
+  // Try common base branch names
+  for (const base of ["main", "master", "develop"]) {
+    try {
+      return runGit(["merge-base", "HEAD", base], cwd);
+    } catch {
+      // branch doesn't exist, try next
+    }
+  }
+  return null;
+}
+
+function captureGitLog(cwd: string): string | null {
+  try {
+    const mergeBase = getMergeBase(cwd);
+    if (mergeBase) {
+      const log = runGit(["log", "--oneline", `${mergeBase}..HEAD`], cwd);
+      if (log) return log;
+    }
+    // Fallback: last 3 commits
+    return runGit(["log", "--oneline", "-3"], cwd) || null;
+  } catch {
+    return null;
+  }
+}
+
+function captureGitStats(cwd: string): GitStats | null {
+  try {
+    let diffOutput: string;
+    const mergeBase = getMergeBase(cwd);
+    if (mergeBase) {
+      diffOutput = runGit(["diff", "--stat", `${mergeBase}..HEAD`], cwd);
+    } else {
+      // Fallback
+      diffOutput = runGit(["diff", "--stat", "HEAD~20", "HEAD"], cwd);
+    }
+    if (!diffOutput) return null;
+    return parseDiffStat(diffOutput);
+  } catch {
+    return null;
+  }
+}
+
+function parseDiffStat(output: string): GitStats | null {
+  // Match the summary line: "5 files changed, 47 insertions(+), 12 deletions(-)"
+  const lines = output.split("\n");
+  const summaryLine = lines[lines.length - 1];
+  if (!summaryLine) return null;
+
+  const filesMatch = summaryLine.match(/(\d+)\s+files?\s+changed/);
+  const insertionsMatch = summaryLine.match(/(\d+)\s+insertions?\(\+\)/);
+  const deletionsMatch = summaryLine.match(/(\d+)\s+deletions?\(-\)/);
+
+  if (!filesMatch && !insertionsMatch && !deletionsMatch) return null;
+
+  return {
+    commits: 0, // filled in by caller
+    filesChanged: filesMatch ? parseInt(filesMatch[1], 10) : 0,
+    insertions: insertionsMatch ? parseInt(insertionsMatch[1], 10) : 0,
+    deletions: deletionsMatch ? parseInt(deletionsMatch[1], 10) : 0,
+  };
+}
+
+function buildSummary(gitLog: string | null): string | null {
+  if (!gitLog) return null;
+  const lines = gitLog.split("\n").filter(Boolean);
+  if (lines.length === 0) return null;
+
+  // Extract commit message (after the short hash)
+  const firstMessage = lines[0].replace(/^[a-f0-9]+\s+/, "");
+  if (lines.length === 1) return firstMessage;
+  return `${lines.length} commits: ${firstMessage}`;
+}
+
+/** Strip ANSI escape sequences, cursor control, and OSC sequences from terminal output */
+function stripAnsi(str: string): string {
+  return str
+    // OSC sequences (e.g. title set): ESC ] ... ST/BEL
+    .replace(/\x1b\][^\x07\x1b]*(?:\x07|\x1b\\)/g, "")
+    // CSI sequences (e.g. colors, cursor): ESC [ ... final_byte
+    .replace(/\x1b\[[0-9;?]*[A-Za-z]/g, "")
+    // Other ESC sequences
+    .replace(/\x1b[^[\]()][^\x1b]*/g, "")
+    // Bare control chars (except \n \r \t)
+    .replace(/[\x00-\x08\x0b\x0c\x0e-\x1f\x7f]/g, "")
+    // Collapse multiple blank lines
+    .replace(/\n{3,}/g, "\n\n")
+    .trim();
+}
+
+function trimTerminalBuffer(buffer: string): string {
+  const clean = stripAnsi(buffer);
+  if (clean.length <= TERMINAL_LOG_MAX) return clean;
+  return clean.slice(clean.length - TERMINAL_LOG_MAX);
+}
+
+/**
+ * Capture an execution summary after a PTY session ends.
+ * This function is designed to never throw — all errors are caught and logged.
+ */
+export async function captureExecutionSummary(
+  executionId: string,
+  _taskId: string,
+  exitCode: number,
+  terminalBuffer: string,
+  worktreePath: string | null
+): Promise<void> {
+  try {
+    console.error(`[captureExecutionSummary] Starting: exec=${executionId.slice(0, 8)} exit=${exitCode} buffer=${terminalBuffer.length}chars worktree=${worktreePath}`);
+
+    let gitLog: string | null = null;
+    let gitStats: GitStats | null = null;
+    let summary: string | null = null;
+
+    // Capture git data if we have a valid git worktree
+    if (worktreePath && existsSync(worktreePath)) {
+      try {
+        // Verify it's a git repo
+        runGit(["rev-parse", "--git-dir"], worktreePath);
+
+        gitLog = captureGitLog(worktreePath);
+        gitStats = captureGitStats(worktreePath);
+
+        // Fill in commit count from gitLog
+        if (gitStats && gitLog) {
+          const commitCount = gitLog.split("\n").filter(Boolean).length;
+          gitStats = { ...gitStats, commits: commitCount };
+        }
+
+        summary = buildSummary(gitLog);
+      } catch {
+        // Not a git repo or git not available — continue without git data
+      }
+    }
+
+    const terminalLog = trimTerminalBuffer(terminalBuffer);
+
+    // sessionId is now reported by PostToolUse hook → /api/internal/hooks/session
+    // No need to scan ~/.claude/projects/ directory here
+
+    // Phase 1: Immediate save — git data + terminal log (no blocking)
+    await db.taskExecution.update({
+      where: { id: executionId },
+      data: {
+        summary: summary ?? (gitLog ? buildSummary(gitLog) : null),
+        gitLog: gitLog ?? null,
+        gitStats: gitStats ? JSON.stringify(gitStats) : null,
+        exitCode,
+        terminalLog: terminalLog || null,
+      },
+    });
+
+    // Phase 2: Background AI summary — fire and forget, updates DB when done
+    // Dreaming (Phase 3) moved to captureTaskDreaming() — runs only on task DONE
+    if (terminalLog && worktreePath) {
+      console.error("[captureExecutionSummary] Starting background AI summary...");
+      generateSummaryFromLog(terminalLog, worktreePath)
+        .then(async (aiSummary) => {
+          if (aiSummary) {
+            console.error(`[captureExecutionSummary] AI summary ready: ${aiSummary.slice(0, 80)}`);
+            await db.taskExecution.update({
+              where: { id: executionId },
+              data: { summary: aiSummary },
+            });
+          }
+        })
+        .catch((err: unknown) => {
+          console.error("[captureExecutionSummary] Background AI summary failed:", err);
+        });
+    }
+  } catch (err: unknown) {
+    console.error("[captureExecutionSummary] Failed to capture summary:", err);
+  }
+}
+
+/**
+ * Run dreaming analysis on a completed task. Called once when task status → DONE.
+ * Collects terminal logs from all executions and generates a single insight note.
+ * Fire-and-forget — never throws.
+ */
+export async function captureTaskDreaming(taskId: string): Promise<void> {
+  try {
+    // Get all executions for this task
+    const task = await db.task.findUnique({
+      where: { id: taskId },
+      select: {
+        projectId: true,
+        executions: {
+          orderBy: { createdAt: "desc" },
+          select: { id: true, terminalLog: true, worktreePath: true, summary: true },
+        },
+      },
+    });
+    if (!task || task.executions.length === 0) return;
+
+    // Combine terminal logs from all executions (most recent first, cap at 8000 chars)
+    let combinedLog = "";
+    let worktreePath: string | null = null;
+    const summaries: string[] = [];
+    for (const exec of task.executions) {
+      if (exec.terminalLog) {
+        combinedLog += exec.terminalLog + "\n---\n";
+      }
+      if (exec.summary) {
+        summaries.push(exec.summary);
+      }
+      if (!worktreePath && exec.worktreePath) {
+        worktreePath = exec.worktreePath;
+      }
+    }
+    combinedLog = combinedLog.slice(-8000);
+    if (!combinedLog.trim()) return;
+
+    const combinedSummary = summaries.join("\n");
+    const effectivePath = worktreePath || process.cwd();
+
+    console.error(`[captureTaskDreaming] Starting for task=${taskId.slice(0, 8)}, ${task.executions.length} executions`);
+
+    const dream = await generateDreamingInsight(combinedLog, effectivePath, combinedSummary);
+    if (!dream || !dream.shouldCreateNote) {
+      console.error("[captureTaskDreaming] No note needed");
+      return;
+    }
+
+    // Create ProjectNote
+    const note = await db.projectNote.create({
+      data: {
+        title: dream.noteTitle || dream.summary.slice(0, 50),
+        content: formatDreamingContent(dream),
+        category: "session-insight",
+        projectId: task.projectId,
+        taskId,
+      },
+    });
+
+    // Link to the latest execution
+    const latestExecId = task.executions[0].id;
+    await db.taskExecution.update({
+      where: { id: latestExecId },
+      data: { insightNoteId: note.id },
+    });
+
+    console.error(`[captureTaskDreaming] Note created: ${note.id}`);
+  } catch (err: unknown) {
+    console.error("[captureTaskDreaming] Failed:", err);
+  }
+}

package/.next/standalone/tower/src/lib/file-serve-client.ts

@@ -0,0 +1,13 @@
+/**
+ * Browser-safe utility for converting local asset paths to API URLs.
+ * No Node.js dependencies — safe to import from "use client" components.
+ */
+export function localPathToApiUrl(src: string): string {
+  // Match assets/{projectId}/{filename} under storage/ (.tower/storage/assets/...)
+  // Also supports legacy data/assets/ paths for backward compatibility
+  const match = src.match(/(?:^|\/)(?:storage|data)\/assets\/([^/]+)\/([^/]+)$/);
+  if (match) {
+    return `/api/files/assets/${match[1]}/${match[2]}`;
+  }
+  return src;
+}

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

@@ -0,0 +1,32 @@
+import * as path from "node:path";
+import { getStorageDir } from "./tower-dir";
+
+const DATA_ROOT = getStorageDir();
+
+export const MIME_MAP: Record<string, string> = {
+  ".png": "image/png",
+  ".jpg": "image/jpeg",
+  ".jpeg": "image/jpeg",
+  ".gif": "image/gif",
+  ".webp": "image/webp",
+  ".svg": "image/svg+xml",
+  ".pdf": "application/pdf",
+  ".txt": "text/plain",
+  ".md": "text/markdown",
+  ".json": "application/json",
+};
+
+export function resolveAssetPath(
+  projectId: string,
+  filename: string
+): { resolved: string | null; error: string | null } {
+  const resolved = path.resolve(DATA_ROOT, "assets", projectId, filename);
+  const safePrefix = path.resolve(DATA_ROOT, "assets") + path.sep;
+  if (!resolved.startsWith(safePrefix)) {
+    return { resolved: null, error: "Invalid path" };
+  }
+  return { resolved, error: null };
+}
+
+// Re-export from browser-safe module for backward compatibility
+export { localPathToApiUrl } from "./file-serve-client";