openpond 0.0.30 → 0.0.32

package/dist/chunks/chunk-E5RVRUJB.js

@@ -0,0 +1,1222 @@
+import { createRequire as __openpondCreateRequire } from "node:module"; var require = __openpondCreateRequire(import.meta.url);
+import {
+  now
+} from "./chunk-Q5MZCRJA.js";
+
+// ../server/src/workspace/workspace-command.ts
+import { spawn, spawnSync } from "node:child_process";
+import { accessSync, constants, existsSync, promises as fs } from "node:fs";
+import path from "node:path";
+var MACOS_GIT_MISSING_DEVELOPER_TOOLS_ERROR = "Git is required for OpenPond app workspaces, but macOS reports Apple Command Line Tools are not installed. OpenPond skipped /usr/bin/git to avoid opening the Xcode installer prompt. Install Command Line Tools with `xcode-select --install`, install Git from Homebrew, or put a non-Apple git binary earlier on PATH.";
+var resolvedGitCommand;
+function isExecutable(filePath) {
+  try {
+    if (!existsSync(filePath)) return false;
+    accessSync(filePath, constants.X_OK);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function firstNonAppleGitOnPath() {
+  const pathEntries = (process.env.PATH ?? "").split(path.delimiter).map((entry) => entry.trim()).filter(Boolean);
+  for (const entry of pathEntries) {
+    const candidate = path.join(entry, "git");
+    if (candidate === "/usr/bin/git" || candidate === "/bin/git") continue;
+    if (isExecutable(candidate)) return candidate;
+  }
+  return null;
+}
+function appleDeveloperToolsAvailable() {
+  const result = spawnSync("/usr/bin/xcode-select", ["-p"], {
+    encoding: "utf8",
+    stdio: ["ignore", "pipe", "pipe"]
+  });
+  return result.status === 0 && Boolean(result.stdout.trim());
+}
+function resolveWorkspaceCommand(command) {
+  if (command !== "git" || process.platform !== "darwin") return { command };
+  if (resolvedGitCommand !== void 0) {
+    return { command: resolvedGitCommand };
+  }
+  const nonAppleGit = firstNonAppleGitOnPath();
+  if (nonAppleGit) {
+    resolvedGitCommand = nonAppleGit;
+    return { command: nonAppleGit };
+  }
+  if (appleDeveloperToolsAvailable()) {
+    resolvedGitCommand = "git";
+    return { command: "git" };
+  }
+  return { error: MACOS_GIT_MISSING_DEVELOPER_TOOLS_ERROR };
+}
+function runCommand(command, args, cwd, extraEnv = {}, stdin) {
+  return new Promise((resolve) => {
+    const resolved = resolveWorkspaceCommand(command);
+    if ("error" in resolved) {
+      resolve({ code: 1, stdout: "", stderr: resolved.error });
+      return;
+    }
+    const child = spawn(resolved.command, args, {
+      cwd,
+      env: {
+        ...process.env,
+        ...extraEnv,
+        GIT_TERMINAL_PROMPT: "0"
+      },
+      stdio: [stdin === void 0 ? "ignore" : "pipe", "pipe", "pipe"]
+    });
+    const stdoutChunks = [];
+    const stderrChunks = [];
+    if (stdin !== void 0) {
+      child.stdin?.end(stdin);
+    }
+    child.stdout?.on("data", (chunk) => stdoutChunks.push(chunk));
+    child.stderr?.on("data", (chunk) => stderrChunks.push(chunk));
+    child.on("error", (error) => {
+      resolve({ code: 1, stdout: "", stderr: error.message });
+    });
+    child.on("close", (code) => {
+      resolve({
+        code: code ?? 1,
+        stdout: Buffer.concat(stdoutChunks).toString("utf8"),
+        stderr: Buffer.concat(stderrChunks).toString("utf8")
+      });
+    });
+  });
+}
+function isMacOSGitDeveloperToolsMissing(value) {
+  return Boolean(value && value.includes(MACOS_GIT_MISSING_DEVELOPER_TOOLS_ERROR.slice(0, 80)));
+}
+async function checkWorkspaceGitAvailability(cwd) {
+  await fs.mkdir(cwd, { recursive: true });
+  const result = await runCommand("git", ["--version"], cwd);
+  if (result.code === 0) {
+    return {
+      ok: true,
+      command: resolvedGitCommand ?? "git",
+      version: (result.stdout || result.stderr).trim()
+    };
+  }
+  const error = result.stderr.trim() || result.stdout.trim() || "Git is required for OpenPond app workspaces.";
+  return {
+    ok: false,
+    error,
+    installAction: process.platform === "darwin" && isMacOSGitDeveloperToolsMissing(error) ? "macos_command_line_tools" : "manual_git_install"
+  };
+}
+function startMacOSCommandLineToolsInstall() {
+  if (process.platform !== "darwin") {
+    return { ok: false, error: "Apple Command Line Tools installation is only available on macOS." };
+  }
+  if (appleDeveloperToolsAvailable()) {
+    return { ok: true, message: "Apple Command Line Tools already appear to be installed." };
+  }
+  try {
+    const child = spawn("/usr/bin/xcode-select", ["--install"], {
+      detached: true,
+      stdio: "ignore"
+    });
+    child.unref();
+    return { ok: true, message: "Opened the Apple Command Line Tools installer." };
+  } catch (error) {
+    return { ok: false, error: error instanceof Error ? error.message : String(error) };
+  }
+}
+
+// ../server/src/workspace/workspace-common.ts
+import { promises as fs2 } from "node:fs";
+import path2 from "node:path";
+var MAX_PATCH_CHARS = 24e3;
+var MAX_FILE_CHARS = 8e4;
+var MAX_READABLE_FILE_BYTES = 512 * 1024;
+var MAX_WORKSPACE_IMAGE_BYTES = 15 * 1024 * 1024;
+var GENERATED_WORKSPACE_DIRS = /* @__PURE__ */ new Set([
+  ".cache",
+  ".eggs",
+  ".git",
+  ".ipynb_checkpoints",
+  ".mypy_cache",
+  ".next",
+  ".nox",
+  ".nuxt",
+  ".openpond",
+  ".output",
+  ".parcel-cache",
+  ".pytest_cache",
+  ".pyre",
+  ".ruff_cache",
+  ".svelte-kit",
+  ".tox",
+  ".turbo",
+  ".venv",
+  "__pycache__",
+  "artifacts",
+  "build",
+  "coverage",
+  "dist",
+  "env",
+  "node_modules",
+  "out",
+  "site-packages",
+  "target",
+  "venv",
+  "volumes"
+]);
+var BINARY_WORKSPACE_EXTENSIONS = /* @__PURE__ */ new Set([
+  ".7z",
+  ".avif",
+  ".db",
+  ".gif",
+  ".gz",
+  ".ico",
+  ".jpeg",
+  ".jpg",
+  ".mov",
+  ".mp4",
+  ".pdf",
+  ".png",
+  ".sqlite",
+  ".tar",
+  ".webp",
+  ".xls",
+  ".xlsm",
+  ".xlsx",
+  ".zip"
+]);
+var WORKSPACE_IMAGE_CONTENT_TYPES = /* @__PURE__ */ new Map([
+  [".avif", "image/avif"],
+  [".gif", "image/gif"],
+  [".jpeg", "image/jpeg"],
+  [".jpg", "image/jpeg"],
+  [".png", "image/png"],
+  [".webp", "image/webp"]
+]);
+function safeAppSegment(appId) {
+  return appId.replace(/[^a-zA-Z0-9._-]/g, "-").slice(0, 120) || "app";
+}
+function sourceFromRemote(remoteUrl) {
+  if (!remoteUrl) return "unknown";
+  try {
+    const host = new URL(remoteUrl).hostname.toLowerCase();
+    if (host === "github.com" || host.endsWith(".github.com")) return "github";
+    if (host === "openpond.ai" || host.endsWith(".openpond.ai")) return "openpond";
+  } catch {
+    return "unknown";
+  }
+  return "local_git";
+}
+function redactRemoteUrl(value) {
+  return value.replace(/x-access-token:[^@]+@/g, "x-access-token:***@").replace(/Authorization:\s*Basic\s+[A-Za-z0-9+/=]+/gi, "Authorization: Basic ***");
+}
+async function pathExists(targetPath) {
+  try {
+    await fs2.access(targetPath);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function isGitRepo(repoPath) {
+  if (!await pathExists(repoPath)) return false;
+  const result = await runCommand("git", ["rev-parse", "--git-dir"], repoPath);
+  return result.code === 0;
+}
+function truncatePatch(value) {
+  if (value.length <= MAX_PATCH_CHARS) return value;
+  return `${value.slice(0, MAX_PATCH_CHARS)}
+
+[diff truncated]`;
+}
+function truncateFileContent(value) {
+  if (value.length <= MAX_FILE_CHARS) return value;
+  return `${value.slice(0, MAX_FILE_CHARS)}
+
+[file truncated]`;
+}
+async function readWorkspaceFile(repoPath, filePath) {
+  const target = path2.resolve(repoPath, filePath);
+  const root = path2.resolve(repoPath);
+  if (target !== root && !target.startsWith(`${root}${path2.sep}`)) return null;
+  try {
+    const stat = await fs2.lstat(target);
+    if (!stat.isFile()) return null;
+    if (!isReadableTextWorkspaceFile(filePath, stat.size)) return null;
+    return truncateFileContent(await fs2.readFile(target, "utf8"));
+  } catch {
+    return null;
+  }
+}
+function workspaceImageContentType(filePath) {
+  return WORKSPACE_IMAGE_CONTENT_TYPES.get(path2.extname(filePath).toLowerCase()) ?? null;
+}
+async function readWorkspaceImageFile(repoPath, filePath) {
+  const normalizedPath = normalizeWorkspaceFilePath(filePath);
+  if (!normalizedPath) return null;
+  const contentType = workspaceImageContentType(normalizedPath);
+  if (!contentType) return null;
+  const target = path2.resolve(repoPath, normalizedPath);
+  const root = path2.resolve(repoPath);
+  if (target !== root && !target.startsWith(`${root}${path2.sep}`)) return null;
+  try {
+    const stat = await fs2.lstat(target);
+    if (!stat.isFile() || stat.size > MAX_WORKSPACE_IMAGE_BYTES) return null;
+    return {
+      path: normalizedPath,
+      contentType,
+      bytes: await fs2.readFile(target),
+      sizeBytes: stat.size
+    };
+  } catch {
+    return null;
+  }
+}
+async function readLocalImageFile(filePath) {
+  const cleanedPath = cleanLocalImagePath(filePath);
+  if (!cleanedPath) return null;
+  const contentType = workspaceImageContentType(cleanedPath);
+  if (!contentType) return null;
+  const target = path2.resolve(cleanedPath);
+  try {
+    const stat = await fs2.lstat(target);
+    if (!stat.isFile() || stat.size > MAX_WORKSPACE_IMAGE_BYTES) return null;
+    return {
+      path: target,
+      contentType,
+      bytes: await fs2.readFile(target),
+      sizeBytes: stat.size
+    };
+  } catch {
+    return null;
+  }
+}
+function cleanLocalImagePath(value) {
+  let cleaned = value.trim();
+  if (!cleaned) return null;
+  cleaned = cleaned.replace(/^['"`]+|['"`]+$/g, "");
+  if (cleaned.startsWith("file://")) {
+    try {
+      cleaned = decodeURIComponent(new URL(cleaned).pathname);
+    } catch {
+      cleaned = cleaned.replace(/^file:\/\//, "");
+    }
+  }
+  if (!path2.isAbsolute(cleaned)) return null;
+  return cleaned;
+}
+function isReadableTextWorkspaceFile(filePath, sizeBytes) {
+  if (sizeBytes > MAX_READABLE_FILE_BYTES) return false;
+  return !BINARY_WORKSPACE_EXTENSIONS.has(path2.extname(filePath).toLowerCase());
+}
+async function isWorkspaceDirectory(repoPath, filePath) {
+  const target = path2.resolve(repoPath, filePath);
+  const root = path2.resolve(repoPath);
+  if (target !== root && !target.startsWith(`${root}${path2.sep}`)) return false;
+  try {
+    const stat = await fs2.lstat(target);
+    return stat.isDirectory();
+  } catch {
+    return false;
+  }
+}
+function normalizeWorkspaceFilePath(input) {
+  const normalized = input.replace(/\\/g, "/").replace(/^\.\/+/, "");
+  if (!normalized.trim() || normalized.startsWith("/")) return null;
+  const parts = normalized.split("/").filter(Boolean);
+  if (parts.length === 0 || parts.some((part) => part === ".." || part === ".git")) return null;
+  return parts.join("/");
+}
+function isGeneratedWorkspacePath(filePath) {
+  const normalized = normalizeWorkspaceFilePath(filePath);
+  if (!normalized) return true;
+  return normalized.split("/").some((part) => GENERATED_WORKSPACE_DIRS.has(part) || part === ".env" || part.startsWith(".env.") || part.endsWith(".egg-info") || part.endsWith(".pyc") || part.endsWith(".pyo"));
+}
+async function isVisibleGitWorkspaceFile(repoPath, filePath) {
+  if (isGeneratedWorkspacePath(filePath)) return false;
+  const result = await runCommand("git", ["ls-files", "--cached", "--others", "--exclude-standard", "--", filePath], repoPath);
+  if (result.code !== 0) return false;
+  return result.stdout.split("\n").map((line) => line.trim()).some((line) => line === filePath);
+}
+function parseStatusLine(line) {
+  if (!line.trim() || line.startsWith("## ")) return null;
+  const code = line.slice(0, 2);
+  const rawPath = line.slice(3).trim();
+  const path4 = rawPath.includes(" -> ") ? rawPath.split(" -> ").pop().trim() : rawPath;
+  if (!path4) return null;
+  if (code === "??") return { path: path4, status: "untracked" };
+  if (code.includes("A")) return { path: path4, status: "added" };
+  if (code.includes("D")) return { path: path4, status: "deleted" };
+  if (code.includes("R")) return { path: path4, status: "renamed" };
+  return { path: path4, status: "modified" };
+}
+function parseBranchStatusLine(line) {
+  const trackingPart = line.replace(/^##\s*/, "").split("...")[1]?.trim();
+  if (!trackingPart) return { upstreamBranch: null, ahead: 0, behind: 0 };
+  const bracketIndex = trackingPart.indexOf("[");
+  const upstreamBranch = (bracketIndex >= 0 ? trackingPart.slice(0, bracketIndex) : trackingPart).trim() || null;
+  const aheadMatch = trackingPart.match(/ahead\s+(\d+)/);
+  const behindMatch = trackingPart.match(/behind\s+(\d+)/);
+  return {
+    upstreamBranch,
+    ahead: aheadMatch ? Number(aheadMatch[1]) || 0 : 0,
+    behind: behindMatch ? Number(behindMatch[1]) || 0 : 0
+  };
+}
+function parseNumstat(stdout) {
+  const stats = /* @__PURE__ */ new Map();
+  for (const line of stdout.split("\n")) {
+    if (!line.trim()) continue;
+    const [additionsRaw, deletionsRaw, ...pathParts] = line.split("	");
+    const filePath = pathParts.join("	").trim();
+    if (!filePath) continue;
+    stats.set(filePath, {
+      additions: additionsRaw === "-" ? 0 : Number(additionsRaw) || 0,
+      deletions: deletionsRaw === "-" ? 0 : Number(deletionsRaw) || 0
+    });
+  }
+  return stats;
+}
+function uniqueSortedPaths(paths) {
+  return Array.from(new Set(paths.filter(Boolean))).sort((left, right) => left.localeCompare(right));
+}
+var MAX_PLAIN_WORKSPACE_FILES = 2e3;
+async function listPlainWorkspaceFiles(rootPath) {
+  const files = [];
+  async function walk(currentPath, prefix = "") {
+    if (files.length >= MAX_PLAIN_WORKSPACE_FILES) return;
+    let entries;
+    try {
+      entries = await fs2.readdir(currentPath, { withFileTypes: true });
+    } catch {
+      return;
+    }
+    entries.sort((left, right) => left.name.localeCompare(right.name));
+    for (const entry of entries) {
+      if (files.length >= MAX_PLAIN_WORKSPACE_FILES) return;
+      const relativePath = prefix ? `${prefix}/${entry.name}` : entry.name;
+      if (isGeneratedWorkspacePath(relativePath)) continue;
+      const absolutePath = path2.join(currentPath, entry.name);
+      if (entry.isDirectory()) {
+        await walk(absolutePath, relativePath);
+      } else if (entry.isFile()) {
+        files.push(relativePath);
+      }
+    }
+  }
+  await walk(rootPath);
+  return uniqueSortedPaths(files);
+}
+function normalizeGitHost(host) {
+  const trimmed = host?.trim();
+  if (!trimmed) return null;
+  try {
+    const url = new URL(trimmed.includes("://") ? trimmed : `https://${trimmed}`);
+    return url.host.replace(/\/+$/, "");
+  } catch {
+    return trimmed.replace(/^https?:\/\//i, "").replace(/\/+$/, "");
+  }
+}
+function normalizeGitBaseUrl(baseUrl) {
+  const trimmed = baseUrl?.trim();
+  if (!trimmed) return null;
+  try {
+    const url = new URL(trimmed);
+    return { protocol: url.protocol || "https:", host: url.host };
+  } catch {
+    return null;
+  }
+}
+function isDefaultOpenPondGitHost(host) {
+  const normalized = normalizeGitHost(host);
+  return !normalized || normalized === "openpond.ai" || normalized === "www.openpond.ai";
+}
+function expectedRemoteUrl(workspace, gitBaseUrl) {
+  const owner = workspace.gitOwner?.trim();
+  const repo = workspace.gitRepo?.trim();
+  if (!owner || !repo) return null;
+  const accountGitBase = normalizeGitBaseUrl(gitBaseUrl);
+  const appGitHost = normalizeGitHost(workspace.gitHost);
+  const host = accountGitBase && isDefaultOpenPondGitHost(appGitHost) ? accountGitBase.host : appGitHost || accountGitBase?.host || "openpond.ai";
+  const protocol = accountGitBase && host === accountGitBase.host ? accountGitBase.protocol : "https:";
+  const normalizedRepo = repo.endsWith(".git") ? repo : `${repo}.git`;
+  return `${protocol}//${host}/${owner}/${normalizedRepo}`;
+}
+function isOpenPondRemote(remoteUrl) {
+  try {
+    const host = new URL(remoteUrl).hostname.toLowerCase();
+    return host === "openpond.ai" || host.endsWith(".openpond.ai");
+  } catch {
+    return false;
+  }
+}
+function gitBasicAuthEnv(remoteUrl, token) {
+  if (!token || !isOpenPondRemote(remoteUrl)) return {};
+  const encoded = Buffer.from(`x-access-token:${token}`, "utf8").toString("base64");
+  return {
+    GIT_CONFIG_COUNT: "1",
+    GIT_CONFIG_KEY_0: "http.extraHeader",
+    GIT_CONFIG_VALUE_0: `Authorization: Basic ${encoded}`
+  };
+}
+function assertSafeBranchName(branch) {
+  const trimmed = branch.trim();
+  if (!trimmed) throw new Error("Branch name is required");
+  if (trimmed.includes("..")) throw new Error("Branch name cannot contain '..'");
+  if (/[~^:\\\s]/.test(trimmed)) throw new Error("Branch name contains unsupported characters");
+  if (trimmed.startsWith("/") || trimmed.endsWith("/") || trimmed.startsWith("-")) {
+    throw new Error("Branch name is not safe");
+  }
+}
+function appWorkspacePaths(storeDir, appId) {
+  const workspacePath = path2.join(storeDir, "workspaces", safeAppSegment(appId));
+  return {
+    workspacePath,
+    repoPath: path2.join(workspacePath, "repo")
+  };
+}
+async function cloneWorkspace(repoPath, workspacePath, remoteUrl, token) {
+  await fs2.mkdir(workspacePath, { recursive: true });
+  const alreadyExists = await pathExists(repoPath);
+  const result = await runCommand("git", ["clone", "--quiet", remoteUrl, repoPath], workspacePath, gitBasicAuthEnv(remoteUrl, token));
+  if (result.code !== 0) {
+    if (!alreadyExists) await fs2.rm(repoPath, { recursive: true, force: true }).catch(() => null);
+    throw new Error(redactRemoteUrl(result.stderr.trim() || result.stdout.trim() || "git clone failed"));
+  }
+  const sanitize = await runCommand("git", ["remote", "set-url", "origin", remoteUrl], repoPath);
+  if (sanitize.code !== 0) {
+    throw new Error(redactRemoteUrl(sanitize.stderr.trim() || sanitize.stdout.trim() || "git remote set-url failed"));
+  }
+}
+async function lastFetchAt(repoPath) {
+  const fetchHead = await runCommand("git", ["rev-parse", "--git-path", "FETCH_HEAD"], repoPath);
+  const fetchHeadPath = fetchHead.code === 0 && fetchHead.stdout.trim() ? path2.resolve(repoPath, fetchHead.stdout.trim()) : path2.join(repoPath, ".git", "FETCH_HEAD");
+  try {
+    const stat = await fs2.stat(fetchHeadPath);
+    return stat.mtime.toISOString();
+  } catch {
+    return null;
+  }
+}
+
+// ../server/src/workspace/workspace-state.ts
+import { promises as fs3 } from "node:fs";
+async function loadWorkspaceState(storeDir, app, options = {}) {
+  return loadWorkspaceStateAtPath(appWorkspacePaths(storeDir, app.id), app, options);
+}
+async function loadWorkspaceStateAtPath(paths, workspace, options = {}) {
+  const { workspacePath, repoPath } = paths;
+  const expected = expectedRemoteUrl(workspace, options.gitBaseUrl);
+  await fs3.mkdir(workspacePath, { recursive: true });
+  let initialized = await isGitRepo(repoPath);
+  let error = null;
+  if (!initialized && options.clone && expected) {
+    try {
+      await cloneWorkspace(repoPath, workspacePath, expected, options.token);
+      initialized = true;
+    } catch (cloneError) {
+      error = cloneError instanceof Error ? cloneError.message : String(cloneError);
+    }
+  }
+  if (!initialized) {
+    if (options.allowPlainFolder && await pathExists(repoPath)) {
+      return {
+        appId: workspace.id,
+        source: "local_folder",
+        workspacePath,
+        repoPath,
+        initialized: true,
+        remoteUrl: null,
+        expectedRemoteUrl: expected,
+        currentBranch: null,
+        headCommit: null,
+        upstreamBranch: null,
+        ahead: 0,
+        behind: 0,
+        diverged: false,
+        linkedSourceHeadCommit: options.linkedSourceHeadCommit?.trim() || null,
+        aheadOfLinkedSource: 0,
+        behindLinkedSource: 0,
+        divergedFromLinkedSource: false,
+        linkedSourceComparisonError: null,
+        lastFetchAt: null,
+        defaultBranch: workspace.defaultBranch ?? null,
+        branches: [],
+        dirty: false,
+        changedFilesCount: 0,
+        untrackedFilesCount: 0,
+        error,
+        updatedAt: now()
+      };
+    }
+    return {
+      appId: workspace.id,
+      source: sourceFromRemote(expected),
+      workspacePath,
+      repoPath,
+      initialized,
+      remoteUrl: null,
+      expectedRemoteUrl: expected,
+      currentBranch: null,
+      headCommit: null,
+      upstreamBranch: null,
+      ahead: 0,
+      behind: 0,
+      diverged: false,
+      linkedSourceHeadCommit: options.linkedSourceHeadCommit?.trim() || null,
+      aheadOfLinkedSource: 0,
+      behindLinkedSource: 0,
+      divergedFromLinkedSource: false,
+      linkedSourceComparisonError: null,
+      lastFetchAt: null,
+      defaultBranch: workspace.defaultBranch ?? null,
+      branches: [],
+      dirty: false,
+      changedFilesCount: 0,
+      untrackedFilesCount: 0,
+      error,
+      updatedAt: now()
+    };
+  }
+  const [branchResult, branchesResult, statusResult, remoteResult, headResult] = await Promise.all([
+    runCommand("git", ["branch", "--show-current"], repoPath),
+    runCommand("git", ["branch", "--format=%(refname:short)"], repoPath),
+    runCommand("git", ["status", "--porcelain=v1", "-b"], repoPath),
+    runCommand("git", ["config", "--get", "remote.origin.url"], repoPath),
+    runCommand("git", ["rev-parse", "--verify", "HEAD"], repoPath)
+  ]);
+  const remoteUrl = remoteResult.code === 0 ? redactRemoteUrl(remoteResult.stdout.trim()) || null : null;
+  const statusLines = statusResult.code === 0 ? statusResult.stdout.split("\n").filter((line) => line.trim()) : [];
+  const branchStatus = parseBranchStatusLine(statusLines.find((line) => line.startsWith("## ")) ?? "");
+  const changedLines = statusLines.filter((line) => {
+    if (line.startsWith("## ")) return false;
+    const entry = parseStatusLine(line);
+    const normalizedPath = entry ? normalizeWorkspaceFilePath(entry.path) : null;
+    return Boolean(normalizedPath && !isGeneratedWorkspacePath(normalizedPath));
+  });
+  const untrackedFilesCount = changedLines.filter((line) => line.startsWith("??")).length;
+  const branch = branchResult.code === 0 && branchResult.stdout.trim() ? branchResult.stdout.trim() : null;
+  const headCommit = headResult.code === 0 ? headResult.stdout.trim() || null : null;
+  const branches = branchesResult.code === 0 ? branchesResult.stdout.split("\n").map((line) => line.trim()).filter(Boolean) : [];
+  const remoteSource = sourceFromRemote(remoteUrl);
+  const effectiveSourceUrl = remoteSource === "unknown" && expected ? expected : remoteUrl ?? expected;
+  const linkedSourceComparison = await compareLinkedSourceCommit(
+    repoPath,
+    options.linkedSourceHeadCommit,
+    headCommit
+  );
+  return {
+    appId: workspace.id,
+    source: effectiveSourceUrl ? sourceFromRemote(effectiveSourceUrl) : "local_git",
+    workspacePath,
+    repoPath,
+    initialized,
+    remoteUrl,
+    expectedRemoteUrl: expected,
+    currentBranch: branch,
+    headCommit,
+    upstreamBranch: branchStatus.upstreamBranch,
+    ahead: branchStatus.ahead,
+    behind: branchStatus.behind,
+    diverged: branchStatus.ahead > 0 && branchStatus.behind > 0,
+    linkedSourceHeadCommit: linkedSourceComparison.linkedSourceHeadCommit,
+    aheadOfLinkedSource: linkedSourceComparison.aheadOfLinkedSource,
+    behindLinkedSource: linkedSourceComparison.behindLinkedSource,
+    divergedFromLinkedSource: linkedSourceComparison.divergedFromLinkedSource,
+    linkedSourceComparisonError: linkedSourceComparison.error,
+    lastFetchAt: await lastFetchAt(repoPath),
+    defaultBranch: workspace.defaultBranch ?? null,
+    branches,
+    dirty: changedLines.length > 0,
+    changedFilesCount: changedLines.length,
+    untrackedFilesCount,
+    error,
+    updatedAt: now()
+  };
+}
+async function compareLinkedSourceCommit(repoPath, linkedSourceHeadCommit, headCommit) {
+  const linkedCommit = linkedSourceHeadCommit?.trim() || null;
+  const empty = {
+    linkedSourceHeadCommit: linkedCommit,
+    aheadOfLinkedSource: 0,
+    behindLinkedSource: 0,
+    divergedFromLinkedSource: false,
+    error: null
+  };
+  if (!linkedCommit || !headCommit || linkedCommit === headCommit) return empty;
+  const result = await runCommand(
+    "git",
+    ["rev-list", "--left-right", "--count", `${linkedCommit}...${headCommit}`],
+    repoPath
+  );
+  if (result.code !== 0) {
+    return {
+      ...empty,
+      error: result.stderr.trim() || result.stdout.trim() || "Unable to compare linked source commit."
+    };
+  }
+  const [behindRaw, aheadRaw] = result.stdout.trim().split(/\s+/, 2);
+  const behindLinkedSource = Number(behindRaw) || 0;
+  const aheadOfLinkedSource = Number(aheadRaw) || 0;
+  return {
+    linkedSourceHeadCommit: linkedCommit,
+    aheadOfLinkedSource,
+    behindLinkedSource,
+    divergedFromLinkedSource: aheadOfLinkedSource > 0 && behindLinkedSource > 0,
+    error: null
+  };
+}
+async function createAndCheckoutBranch(storeDir, app, branch) {
+  return createAndCheckoutBranchAtPath(appWorkspacePaths(storeDir, app.id), app, branch);
+}
+async function createAndCheckoutBranchAtPath(paths, workspace, branch, options = {}) {
+  assertSafeBranchName(branch);
+  const state = await loadWorkspaceStateAtPath(paths, workspace, { ...options, clone: false });
+  if (!state.initialized) throw new Error(state.error || "Workspace is not initialized");
+  const result = await runCommand("git", ["checkout", "-b", branch.trim()], state.repoPath);
+  if (result.code !== 0) {
+    throw new Error(result.stderr.trim() || result.stdout.trim() || "Unable to create branch");
+  }
+  return loadWorkspaceStateAtPath(paths, workspace, { ...options, clone: false });
+}
+async function checkoutBranch(storeDir, app, branch) {
+  return checkoutBranchAtPath(appWorkspacePaths(storeDir, app.id), app, branch);
+}
+async function checkoutBranchAtPath(paths, workspace, branch, options = {}) {
+  assertSafeBranchName(branch);
+  const state = await loadWorkspaceStateAtPath(paths, workspace, { ...options, clone: false });
+  if (!state.initialized) throw new Error(state.error || "Workspace is not initialized");
+  if (state.dirty && state.currentBranch !== branch.trim()) {
+    throw new Error("Commit or discard local changes before switching branches");
+  }
+  const result = await runCommand("git", ["checkout", branch.trim()], state.repoPath);
+  if (result.code !== 0) {
+    throw new Error(result.stderr.trim() || result.stdout.trim() || "Unable to switch branch");
+  }
+  return loadWorkspaceStateAtPath(paths, workspace, { ...options, clone: false });
+}
+
+// ../server/src/workspace/workspace-diff.ts
+import path3 from "node:path";
+import { promises as fs4 } from "node:fs";
+var WORKSPACE_DIFF_FILE_CONCURRENCY = 6;
+var WORKSPACE_DIFF_CACHE_MAX_ENTRIES = 60;
+var WORKSPACE_EXPLICIT_FILE_SEARCH_MAX_ENTRIES = 1e4;
+var workspaceDiffCache = /* @__PURE__ */ new Map();
+async function mapWorkspaceDiffEntriesWithConcurrency(entries, mapper, concurrency = WORKSPACE_DIFF_FILE_CONCURRENCY) {
+  const limit = Math.max(1, Math.floor(concurrency));
+  const results = new Array(entries.length);
+  let nextIndex = 0;
+  async function worker() {
+    while (nextIndex < entries.length) {
+      const index = nextIndex;
+      nextIndex += 1;
+      results[index] = await mapper(entries[index], index);
+    }
+  }
+  await Promise.all(
+    Array.from({ length: Math.min(limit, entries.length) }, () => worker())
+  );
+  return results;
+}
+function clearWorkspaceDiffCacheForTests() {
+  workspaceDiffCache.clear();
+}
+async function loadWorkspaceDiff(storeDir, app, options = {}) {
+  const { repoPath } = appWorkspacePaths(storeDir, app.id);
+  return loadWorkspaceDiffAtPath(repoPath, app.id, options);
+}
+async function loadWorkspaceDiffAtPath(repoPath, workspaceId, options = {}) {
+  const initialized = await isGitRepo(repoPath);
+  if (!initialized) {
+    const repoFiles2 = await listPlainWorkspaceFiles(repoPath);
+    return {
+      appId: workspaceId,
+      repoPath,
+      initialized: repoFiles2.length > 0 || await pathExists(repoPath),
+      dirty: false,
+      filesChanged: 0,
+      additions: 0,
+      deletions: 0,
+      repoFiles: repoFiles2,
+      files: [],
+      error: null,
+      updatedAt: now()
+    };
+  }
+  const gitContext = await gitWorkspaceContext(repoPath);
+  const pathspec = gitContext.pathPrefix || ".";
+  const [headResult, statusResult] = await Promise.all([
+    runCommand("git", ["rev-parse", "HEAD"], gitContext.commandCwd),
+    runCommand("git", ["status", "--porcelain=v1", "-uall", "--", pathspec], gitContext.commandCwd)
+  ]);
+  if (statusResult.code !== 0) {
+    return {
+      appId: workspaceId,
+      repoPath,
+      initialized,
+      dirty: false,
+      filesChanged: 0,
+      additions: 0,
+      deletions: 0,
+      repoFiles: [],
+      files: [],
+      error: statusResult.stderr.trim() || statusResult.stdout.trim() || "Unable to read workspace diff",
+      updatedAt: now()
+    };
+  }
+  const entries = statusResult.stdout.split("\n").map(parseStatusLine).filter((entry) => Boolean(entry)).map((entry) => {
+    const scopedPath = pathInWorkspace(entry.path, gitContext.pathPrefix);
+    if (!scopedPath) return null;
+    const normalizedPath = normalizeWorkspaceFilePath(scopedPath);
+    return normalizedPath ? { ...entry, path: normalizedPath } : null;
+  }).filter((entry) => {
+    if (!entry) return false;
+    return !isGeneratedWorkspacePath(entry.path);
+  });
+  const worktreeSignature = await workspaceDiffWorktreeSignature(repoPath, entries);
+  const cacheKey = workspaceDiffCacheKey({
+    repoPath,
+    workspaceId,
+    includeFileDetails: Boolean(options.includeFileDetails),
+    head: headResult.code === 0 ? headResult.stdout.trim() : "unborn",
+    pathPrefix: gitContext.pathPrefix,
+    status: statusResult.stdout,
+    worktreeSignature
+  });
+  const cached = workspaceDiffCache.get(cacheKey);
+  if (cached) return cloneWorkspaceDiffSummary(cached);
+  const fileEntries = (await mapWorkspaceDiffEntriesWithConcurrency(entries, async (entry) => entry.status === "deleted" || !await isWorkspaceDirectory(repoPath, entry.path) ? entry : null)).filter((entry) => Boolean(entry));
+  const trackedFilesResult = await runCommand("git", ["ls-files", "--", pathspec], gitContext.commandCwd);
+  const repoFiles = uniqueSortedPaths([
+    ...trackedFilesResult.code === 0 ? trackedFilesResult.stdout.split("\n").map((line) => pathInWorkspace(line.trim(), gitContext.pathPrefix)).filter((line) => Boolean(line)) : [],
+    ...fileEntries.map((entry) => entry.path)
+  ].filter((filePath) => !isGeneratedWorkspacePath(filePath)));
+  const numstatResult = await runCommand("git", ["diff", "--numstat", "HEAD", "--", pathspec], gitContext.commandCwd);
+  const stats = numstatResult.code === 0 ? scopedNumstat(parseNumstat(numstatResult.stdout), gitContext.pathPrefix) : /* @__PURE__ */ new Map();
+  const trackedPatchMap = options.includeFileDetails ? await loadTrackedGitPatchMap(gitContext, fileEntries.filter((entry) => entry.status !== "untracked")) : /* @__PURE__ */ new Map();
+  const files = await mapWorkspaceDiffEntriesWithConcurrency(fileEntries, async (entry) => {
+    const shouldReadContent = options.includeFileDetails || entry.status === "untracked";
+    const content = shouldReadContent && entry.status !== "deleted" ? await readWorkspaceFile(repoPath, entry.path) : null;
+    const fileStats = entry.status === "untracked" ? { additions: countTextLines(content), deletions: 0 } : stats.get(entry.path) ?? { additions: 0, deletions: 0 };
+    if (options.includeFileDetails) {
+      return loadGitWorkspaceFileDetail(repoPath, entry, gitContext, fileStats, {
+        content,
+        patch: entry.status === "untracked" ? null : trackedPatchMap.get(entry.path) ?? null
+      });
+    }
+    return {
+      path: entry.path,
+      status: entry.status,
+      additions: fileStats.additions,
+      deletions: fileStats.deletions,
+      patch: "",
+      content: null
+    };
+  });
+  const additions = files.reduce((sum, file) => sum + file.additions, 0);
+  const deletions = files.reduce((sum, file) => sum + file.deletions, 0);
+  const summary = {
+    appId: workspaceId,
+    repoPath,
+    initialized,
+    dirty: files.length > 0,
+    filesChanged: files.length,
+    additions,
+    deletions,
+    repoFiles,
+    files,
+    error: null,
+    updatedAt: now()
+  };
+  writeWorkspaceDiffCache(cacheKey, summary);
+  return cloneWorkspaceDiffSummary(summary);
+}
+async function loadGitCommitDiffAtPath(repoPath, workspaceId, baseCommit, headCommit) {
+  const initialized = await isGitRepo(repoPath);
+  if (!initialized) throw new Error("Candidate source is not a Git repository.");
+  const gitContext = await gitWorkspaceContext(repoPath);
+  const range = `${baseCommit}..${headCommit}`;
+  const [base, head, statusResult, patchResult, repoFilesResult] = await Promise.all([
+    runCommand("git", ["rev-parse", "--verify", `${baseCommit}^{commit}`], gitContext.commandCwd),
+    runCommand("git", ["rev-parse", "--verify", `${headCommit}^{commit}`], gitContext.commandCwd),
+    runCommand(
+      "git",
+      ["-c", "core.quotePath=false", "diff", "--name-status", "--find-renames", range, "--", "."],
+      gitContext.commandCwd
+    ),
+    runCommand(
+      "git",
+      ["-c", "core.quotePath=false", "diff", "--no-ext-diff", "--unified=80", range, "--", "."],
+      gitContext.commandCwd
+    ),
+    runCommand(
+      "git",
+      ["-c", "core.quotePath=false", "ls-tree", "-r", "--name-only", headCommit],
+      gitContext.commandCwd
+    )
+  ]);
+  if (base.code !== 0 || head.code !== 0) {
+    throw new Error("Candidate Git history is no longer available.");
+  }
+  if (statusResult.code !== 0) {
+    throw new Error(statusResult.stderr.trim() || "Unable to read the candidate change.");
+  }
+  const entries = parseCommitDiffEntries(statusResult.stdout).filter((entry) => !isGeneratedWorkspacePath(entry.path));
+  const patchMap = patchResult.code === 0 ? parseGitPatchStreamByWorkspacePath(patchResult.stdout || patchResult.stderr, "") : /* @__PURE__ */ new Map();
+  const files = await mapWorkspaceDiffEntriesWithConcurrency(entries, async (entry) => {
+    const statsResult = await runCommand(
+      "git",
+      ["diff", "--numstat", range, "--", entry.path],
+      gitContext.commandCwd
+    );
+    const stats = statsResult.code === 0 ? [...parseNumstat(statsResult.stdout).values()][0] ?? { additions: 0, deletions: 0 } : { additions: 0, deletions: 0 };
+    const contentResult = entry.status === "deleted" ? null : await runCommand("git", ["show", `${headCommit}:${entry.path}`], gitContext.commandCwd);
+    return {
+      path: entry.path,
+      status: entry.status,
+      additions: stats.additions,
+      deletions: stats.deletions,
+      patch: truncatePatch(patchMap.get(entry.path) ?? ""),
+      content: contentResult?.code === 0 ? contentResult.stdout : null
+    };
+  });
+  const repoFiles = repoFilesResult.code === 0 ? uniqueSortedPaths(
+    repoFilesResult.stdout.split("\n").map((value) => value.trim()).filter((value) => value && !isGeneratedWorkspacePath(value))
+  ) : files.map((file) => file.path);
+  return {
+    appId: workspaceId,
+    repoPath,
+    initialized: true,
+    dirty: files.length > 0,
+    filesChanged: files.length,
+    additions: files.reduce((sum, file) => sum + file.additions, 0),
+    deletions: files.reduce((sum, file) => sum + file.deletions, 0),
+    repoFiles,
+    files,
+    error: null,
+    updatedAt: now()
+  };
+}
+function parseCommitDiffEntries(output) {
+  return output.split(/\r?\n/).filter(Boolean).flatMap((line) => {
+    const [rawStatus, firstPath, secondPath] = line.split("	");
+    const statusCode = rawStatus?.[0] ?? "M";
+    const rawPath = statusCode === "R" || statusCode === "C" ? secondPath : firstPath;
+    const normalized = rawPath ? normalizeWorkspaceFilePath(rawPath) : null;
+    if (!normalized) return [];
+    const status = statusCode === "A" || statusCode === "C" ? "added" : statusCode === "D" ? "deleted" : statusCode === "R" ? "renamed" : "modified";
+    return [{ path: normalized, status }];
+  });
+}
+function countTextLines(content) {
+  if (!content) return 0;
+  const withoutTrailingNewline = content.endsWith("\n") ? content.slice(0, -1) : content;
+  return withoutTrailingNewline ? withoutTrailingNewline.split("\n").length : 0;
+}
+async function workspaceDiffWorktreeSignature(repoPath, entries) {
+  const rows = await mapWorkspaceDiffEntriesWithConcurrency(entries, async (entry) => {
+    if (entry.status === "deleted") return `${entry.path}	${entry.status}	deleted`;
+    const target = path3.resolve(repoPath, entry.path);
+    const root = path3.resolve(repoPath);
+    if (target !== root && !target.startsWith(`${root}${path3.sep}`)) {
+      return `${entry.path}	${entry.status}	outside`;
+    }
+    try {
+      const stat = await fs4.lstat(target);
+      const kind = stat.isDirectory() ? "dir" : stat.isFile() ? "file" : "other";
+      return `${entry.path}	${entry.status}	${kind}	${stat.size}	${Math.trunc(stat.mtimeMs)}	${Math.trunc(stat.ctimeMs)}`;
+    } catch {
+      return `${entry.path}	${entry.status}	missing`;
+    }
+  });
+  return rows.sort((left, right) => left.localeCompare(right)).join("\n");
+}
+function workspaceDiffCacheKey(input) {
+  return JSON.stringify(input);
+}
+function writeWorkspaceDiffCache(key, summary) {
+  if (workspaceDiffCache.has(key)) workspaceDiffCache.delete(key);
+  workspaceDiffCache.set(key, cloneWorkspaceDiffSummary(summary));
+  while (workspaceDiffCache.size > WORKSPACE_DIFF_CACHE_MAX_ENTRIES) {
+    const oldest = workspaceDiffCache.keys().next().value;
+    if (!oldest) break;
+    workspaceDiffCache.delete(oldest);
+  }
+}
+function cloneWorkspaceDiffSummary(summary) {
+  return {
+    ...summary,
+    repoFiles: [...summary.repoFiles],
+    files: summary.files.map((file) => ({ ...file }))
+  };
+}
+async function gitWorkspaceContext(repoPath) {
+  const result = await runCommand("git", ["rev-parse", "--show-toplevel"], repoPath);
+  if (result.code !== 0) return { commandCwd: repoPath, pathPrefix: "" };
+  const topLevel = result.stdout.trim();
+  if (!topLevel) return { commandCwd: repoPath, pathPrefix: "" };
+  const relative = path3.relative(path3.resolve(topLevel), path3.resolve(repoPath));
+  const pathPrefix = normalizeWorkspaceFilePath(relative.replace(/\\/g, "/")) ?? "";
+  return {
+    commandCwd: topLevel,
+    pathPrefix
+  };
+}
+function pathInWorkspace(filePath, pathPrefix) {
+  const normalizedPath = normalizeWorkspaceFilePath(filePath);
+  if (!normalizedPath) return null;
+  if (!pathPrefix) return normalizedPath;
+  if (normalizedPath === pathPrefix) return null;
+  return normalizedPath.startsWith(`${pathPrefix}/`) ? normalizedPath.slice(pathPrefix.length + 1) : null;
+}
+function gitPathForWorkspacePath(filePath, pathPrefix) {
+  return pathPrefix ? `${pathPrefix}/${filePath}` : filePath;
+}
+function scopedNumstat(stats, pathPrefix) {
+  const scoped = /* @__PURE__ */ new Map();
+  for (const [filePath, fileStats] of stats) {
+    const workspacePath = pathInWorkspace(filePath, pathPrefix);
+    if (workspacePath) scoped.set(workspacePath, fileStats);
+  }
+  return scoped;
+}
+async function loadTrackedGitPatchMap(gitContext, entries) {
+  if (entries.length === 0) return /* @__PURE__ */ new Map();
+  const pathspec = gitContext.pathPrefix || ".";
+  const result = await runCommand(
+    "git",
+    ["-c", "core.quotePath=false", "diff", "--no-ext-diff", "--unified=80", "HEAD", "--", pathspec],
+    gitContext.commandCwd
+  );
+  if (result.code !== 0) return /* @__PURE__ */ new Map();
+  return parseGitPatchStreamByWorkspacePath(result.stdout || result.stderr, gitContext.pathPrefix);
+}
+function parseGitPatchStreamByWorkspacePath(stdout, pathPrefix) {
+  const patches = /* @__PURE__ */ new Map();
+  for (const chunk of stdout.split(/(?=^diff --git )/m)) {
+    if (!chunk.trim()) continue;
+    const workspacePath = workspacePathForGitPatchChunk(chunk, pathPrefix);
+    if (workspacePath) patches.set(workspacePath, chunk);
+  }
+  return patches;
+}
+function workspacePathForGitPatchChunk(chunk, pathPrefix) {
+  const lines = chunk.split("\n");
+  for (const line of lines) {
+    const newPath = gitPatchMarkerPath(line, "+++ ");
+    if (newPath) return pathInWorkspace(newPath, pathPrefix);
+  }
+  for (const line of lines) {
+    const oldPath = gitPatchMarkerPath(line, "--- ");
+    if (oldPath) return pathInWorkspace(oldPath, pathPrefix);
+  }
+  for (const line of lines) {
+    if (line.startsWith("rename to ")) {
+      const renamedPath = normalizeWorkspaceFilePath(line.slice("rename to ".length).trim());
+      if (renamedPath) return pathInWorkspace(renamedPath, pathPrefix);
+    }
+  }
+  const header = lines.find((line) => line.startsWith("diff --git "));
+  if (!header) return null;
+  const destinationIndex = header.lastIndexOf(" b/");
+  if (destinationIndex < 0) return null;
+  const destinationPath = normalizeWorkspaceFilePath(header.slice(destinationIndex + 3).trim());
+  return destinationPath ? pathInWorkspace(destinationPath, pathPrefix) : null;
+}
+function gitPatchMarkerPath(line, prefix) {
+  if (!line.startsWith(prefix)) return null;
+  const value = line.slice(prefix.length).trim();
+  if (!value || value === "/dev/null") return null;
+  const withoutGitPrefix = value.startsWith("a/") || value.startsWith("b/") ? value.slice(2) : value;
+  return normalizeWorkspaceFilePath(withoutGitPrefix);
+}
+async function loadWorkspaceFile(storeDir, app, filePath) {
+  const { repoPath } = appWorkspacePaths(storeDir, app.id);
+  return loadWorkspaceFileAtPath(repoPath, filePath);
+}
+async function loadWorkspaceImageFile(storeDir, app, filePath) {
+  const { repoPath } = appWorkspacePaths(storeDir, app.id);
+  return loadWorkspaceImageFileAtPath(repoPath, filePath);
+}
+async function loadWorkspaceImageFileAtPath(repoPath, filePath) {
+  const initialized = await isGitRepo(repoPath);
+  const normalizedPath = normalizeWorkspaceFileRequestPath(repoPath, filePath);
+  if (!normalizedPath) throw new Error("Image not found");
+  if (initialized && !await isVisibleGitWorkspaceFile(repoPath, normalizedPath)) throw new Error("Image not found");
+  const image = await readWorkspaceImageFile(repoPath, normalizedPath);
+  if (!image) throw new Error("Image not found");
+  return image;
+}
+function normalizeWorkspaceFileRequestPath(repoPath, filePath) {
+  const cleaned = cleanWorkspaceFileRequestPath(filePath);
+  if (!cleaned) return null;
+  if (!path3.isAbsolute(cleaned)) return normalizeWorkspaceFilePath(cleaned);
+  const relative = path3.relative(path3.resolve(repoPath), path3.resolve(cleaned));
+  if (!relative || relative.startsWith("..") || path3.isAbsolute(relative)) return null;
+  return normalizeWorkspaceFilePath(relative);
+}
+function cleanWorkspaceFileRequestPath(value) {
+  let cleaned = value.trim();
+  if (!cleaned) return null;
+  cleaned = cleaned.replace(/^['"`]+|['"`]+$/g, "");
+  const hashIndex = cleaned.indexOf("#");
+  if (hashIndex >= 0) cleaned = cleaned.slice(0, hashIndex);
+  const queryIndex = cleaned.indexOf("?");
+  if (queryIndex >= 0) cleaned = cleaned.slice(0, queryIndex);
+  if (cleaned.startsWith("file://")) {
+    try {
+      cleaned = decodeURIComponent(new URL(cleaned).pathname);
+    } catch {
+      cleaned = cleaned.replace(/^file:\/\//, "");
+    }
+  }
+  return cleaned.trim() || null;
+}
+async function loadWorkspaceFileAtPath(repoPath, filePath) {
+  const initialized = await isGitRepo(repoPath);
+  const normalizedPath = normalizeWorkspaceFileRequestPath(repoPath, filePath);
+  if (!normalizedPath) throw new Error("File not found");
+  if (isGeneratedWorkspacePath(normalizedPath)) throw new Error("File not found");
+  if (initialized) {
+    const detail = await loadGitWorkspaceFileAtPath(repoPath, normalizedPath);
+    if (detail) return detail;
+  }
+  let resolvedPath = normalizedPath;
+  let content = await readWorkspaceFile(repoPath, resolvedPath);
+  if (content === null) {
+    const basenameMatch = await resolveExplicitMarkdownBasenamePath(repoPath, normalizedPath);
+    if (basenameMatch) {
+      resolvedPath = basenameMatch;
+      content = await readWorkspaceFile(repoPath, resolvedPath);
+    }
+  }
+  if (content === null) throw new Error("File not found");
+  return {
+    path: resolvedPath,
+    status: "unchanged",
+    additions: 0,
+    deletions: 0,
+    patch: "",
+    content
+  };
+}
+async function loadGitWorkspaceFileAtPath(repoPath, filePath) {
+  const gitContext = await gitWorkspaceContext(repoPath);
+  const gitPath = gitPathForWorkspacePath(filePath, gitContext.pathPrefix);
+  const statusResult = await runCommand("git", ["status", "--porcelain=v1", "-uall", "--", gitPath], gitContext.commandCwd);
+  if (statusResult.code !== 0) return null;
+  const entry = statusResult.stdout.split("\n").map(parseStatusLine).filter((item) => Boolean(item)).map((item) => {
+    const scopedPath = pathInWorkspace(item.path, gitContext.pathPrefix);
+    if (!scopedPath) return null;
+    const normalizedScopedPath = normalizeWorkspaceFilePath(scopedPath);
+    return normalizedScopedPath ? { ...item, path: normalizedScopedPath } : null;
+  }).find((item) => Boolean(item && item.path === filePath));
+  if (!entry) return null;
+  const fileStats = entry.status === "untracked" ? { additions: countTextLines(await readWorkspaceFile(repoPath, entry.path)), deletions: 0 } : await gitNumstatForFile(gitContext, entry.path);
+  return loadGitWorkspaceFileDetail(repoPath, entry, gitContext, fileStats);
+}
+async function resolveExplicitMarkdownBasenamePath(repoPath, normalizedPath) {
+  if (normalizedPath.includes("/") || !isMarkdownWorkspacePath(normalizedPath)) return null;
+  const targetName = normalizedPath.toLowerCase();
+  const matches = [];
+  const queue = [{ absolutePath: repoPath, prefix: "" }];
+  let visitedEntries = 0;
+  while (queue.length > 0 && visitedEntries < WORKSPACE_EXPLICIT_FILE_SEARCH_MAX_ENTRIES) {
+    const current = queue.shift();
+    let entries;
+    try {
+      entries = await fs4.readdir(current.absolutePath, { withFileTypes: true });
+    } catch {
+      continue;
+    }
+    entries.sort((left, right) => left.name.localeCompare(right.name));
+    for (const entry of entries) {
+      if (visitedEntries >= WORKSPACE_EXPLICIT_FILE_SEARCH_MAX_ENTRIES) break;
+      const relativePath = current.prefix ? `${current.prefix}/${entry.name}` : entry.name;
+      if (isGeneratedWorkspacePath(relativePath)) continue;
+      visitedEntries += 1;
+      const absolutePath = path3.join(current.absolutePath, entry.name);
+      if (entry.isDirectory()) {
+        queue.push({ absolutePath, prefix: relativePath });
+      } else if (entry.isFile() && entry.name.toLowerCase() === targetName) {
+        matches.push(relativePath);
+      }
+    }
+  }
+  if (matches.length === 1) return matches[0] ?? null;
+  const workingDocMatches = matches.filter((candidate) => candidate.startsWith("docs/working-docs/"));
+  return workingDocMatches.length === 1 ? workingDocMatches[0] ?? null : null;
+}
+function isMarkdownWorkspacePath(filePath) {
+  return /\.(?:md|markdown|mdx)$/i.test(filePath);
+}
+async function loadGitWorkspaceFileDetail(repoPath, entry, gitContext, fileStats, overrides = {}) {
+  const content = overrides.content !== void 0 ? overrides.content : entry.status === "deleted" ? null : await readWorkspaceFile(repoPath, entry.path);
+  const gitPath = gitPathForWorkspacePath(entry.path, gitContext.pathPrefix);
+  const diffArgs = entry.status === "untracked" ? ["diff", "--no-index", "--unified=80", "--", "/dev/null", path3.join(repoPath, entry.path)] : ["diff", "--no-ext-diff", "--unified=80", "HEAD", "--", gitPath];
+  let patch = overrides.patch ?? "";
+  if (overrides.patch === null || overrides.patch === void 0) {
+    const patchResult = await runCommand("git", diffArgs, gitContext.commandCwd);
+    patch = patchResult.stdout || patchResult.stderr;
+  }
+  return {
+    path: entry.path,
+    status: entry.status,
+    additions: fileStats.additions,
+    deletions: fileStats.deletions,
+    patch: truncatePatch(patch),
+    content
+  };
+}
+async function gitNumstatForFile(gitContext, filePath) {
+  const gitPath = gitPathForWorkspacePath(filePath, gitContext.pathPrefix);
+  const result = await runCommand("git", ["diff", "--numstat", "HEAD", "--", gitPath], gitContext.commandCwd);
+  if (result.code !== 0) return { additions: 0, deletions: 0 };
+  return scopedNumstat(parseNumstat(result.stdout), gitContext.pathPrefix).get(filePath) ?? { additions: 0, deletions: 0 };
+}
+
+export {
+  MACOS_GIT_MISSING_DEVELOPER_TOOLS_ERROR,
+  runCommand,
+  isMacOSGitDeveloperToolsMissing,
+  checkWorkspaceGitAvailability,
+  startMacOSCommandLineToolsInstall,
+  sourceFromRemote,
+  redactRemoteUrl,
+  pathExists,
+  isGitRepo,
+  truncatePatch,
+  readWorkspaceFile,
+  workspaceImageContentType,
+  readWorkspaceImageFile,
+  readLocalImageFile,
+  isWorkspaceDirectory,
+  normalizeWorkspaceFilePath,
+  isGeneratedWorkspacePath,
+  isVisibleGitWorkspaceFile,
+  parseStatusLine,
+  parseBranchStatusLine,
+  parseNumstat,
+  uniqueSortedPaths,
+  listPlainWorkspaceFiles,
+  expectedRemoteUrl,
+  assertSafeBranchName,
+  appWorkspacePaths,
+  cloneWorkspace,
+  lastFetchAt,
+  loadWorkspaceState,
+  loadWorkspaceStateAtPath,
+  createAndCheckoutBranch,
+  createAndCheckoutBranchAtPath,
+  checkoutBranch,
+  checkoutBranchAtPath,
+  mapWorkspaceDiffEntriesWithConcurrency,
+  clearWorkspaceDiffCacheForTests,
+  loadWorkspaceDiff,
+  loadWorkspaceDiffAtPath,
+  loadGitCommitDiffAtPath,
+  loadWorkspaceFile,
+  loadWorkspaceImageFile,
+  loadWorkspaceImageFileAtPath,
+  loadWorkspaceFileAtPath
+};