@chrysb/alphaclaw 0.3.5-beta.0 → 0.3.5-beta.1

package/lib/server/routes/{browse.js → browse/index.js}

@@ -1,35 +1,30 @@
 const path = require("path");
-const { execFile } = require("child_process");
-
-const kDefaultTreeDepth = 10;
-const kIgnoredDirectoryNames = new Set([
-  ".git",
-  ".alphaclaw",
-  "node_modules",
-  ".cache",
-  "dist",
-  "build",
-]);
-const kLockedBrowsePaths = new Set([
-  "hooks/bootstrap/agents.md",
-  "hooks/bootstrap/tools.md",
-  ".alphaclaw/hourly-git-sync.sh",
-  ".alphaclaw/.cli-device-auto-approved",
-]);
-
-const matchesPolicyPath = (policyPathSet, normalizedPath) => {
-  const safeNormalizedPath = String(normalizedPath || "").trim();
-  if (!safeNormalizedPath) return false;
-  for (const policyPath of policyPathSet) {
-    if (
-      safeNormalizedPath === policyPath ||
-      safeNormalizedPath.endsWith(`/${policyPath}`)
-    ) {
-      return true;
-    }
-  }
-  return false;
-};
+const { kLockedBrowsePaths } = require("../../constants");
+const {
+  kDefaultTreeDepth,
+  kIgnoredDirectoryNames,
+  kCommitHistoryLimit,
+} = require("./constants");
+const {
+  normalizePolicyPath,
+  resolveSafePath,
+  toRelativePath,
+  matchesPolicyPath,
+} = require("./path-utils");
+const {
+  isLikelyBinaryFile,
+  getImageMimeType,
+  getAudioMimeType,
+  isSqliteFilePath,
+} = require("./file-helpers");
+const { readSqliteSummary, readSqliteTableData } = require("./sqlite");
+const {
+  runGitCommand,
+  runGitCommandWithExitCode,
+  parseGithubRepoSlug,
+  normalizeChangedPath,
+  parseBranchTracking,
+} = require("./git");
 
 const registerBrowseRoutes = ({ app, fs, kRootDir }) => {
   const kRootResolved = path.resolve(kRootDir);
@@ -40,55 +35,10 @@ const registerBrowseRoutes = ({ app, fs, kRootDir }) => {
     fs.mkdirSync(kRootResolved, { recursive: true });
   }
 
-  const normalizeRelativePath = (inputPath) => {
-    const rawPath = String(inputPath || "").trim();
-    if (!rawPath) return "";
-    return rawPath.replace(/\\/g, "/").replace(/^\/+/, "");
-  };
-
-  const normalizePolicyPath = (inputPath) =>
-    String(inputPath || "")
-      .replace(/\\/g, "/")
-      .replace(/^\.\/+/, "")
-      .replace(/^\/+/, "")
-      .trim()
-      .toLowerCase();
-
-  const resolveSafePath = (inputPath) => {
-    const relativePath = normalizeRelativePath(inputPath);
-    const absolutePath = path.resolve(kRootResolved, relativePath);
-    const isInsideRoot =
-      absolutePath === kRootResolved || absolutePath.startsWith(kRootWithSep);
-    if (!isInsideRoot) {
-      return { ok: false, error: `Path must stay within ${kRootDisplayName}` };
-    }
-    return { ok: true, relativePath, absolutePath };
-  };
-
-  const isLikelyBinaryFile = (targetPath) => {
-    let fileHandle = null;
-    try {
-      fileHandle = fs.openSync(targetPath, "r");
-      const sample = Buffer.alloc(512);
-      const bytesRead = fs.readSync(fileHandle, sample, 0, sample.length, 0);
-      for (let index = 0; index < bytesRead; index += 1) {
-        if (sample[index] === 0) return true;
-      }
-      return false;
-    } finally {
-      if (fileHandle !== null) fs.closeSync(fileHandle);
-    }
-  };
-
-  const toRelativePath = (absolutePath) => {
-    const relative = path.relative(kRootResolved, absolutePath);
-    return relative === "" ? "" : relative.split(path.sep).join("/");
-  };
-
   const buildTreeNode = (absolutePath, depthRemaining) => {
     const stats = fs.statSync(absolutePath);
     const nodeName = path.basename(absolutePath);
-    const nodePath = toRelativePath(absolutePath);
+    const nodePath = toRelativePath(absolutePath, kRootResolved);
 
     if (!stats.isDirectory()) {
       return { type: "file", name: nodeName, path: nodePath };
@@ -106,7 +56,9 @@ const registerBrowseRoutes = ({ app, fs, kRootDir }) => {
         }
         return entry.isDirectory() || entry.isFile();
       })
-      .map((entry) => buildTreeNode(path.join(absolutePath, entry.name), depthRemaining - 1))
+      .map((entry) =>
+        buildTreeNode(path.join(absolutePath, entry.name), depthRemaining - 1),
+      )
       .sort((leftNode, rightNode) => {
         if (leftNode.type !== rightNode.type) {
           return leftNode.type === "folder" ? -1 : 1;
@@ -117,87 +69,30 @@ const registerBrowseRoutes = ({ app, fs, kRootDir }) => {
     return { type: "folder", name: nodeName, path: nodePath, children };
   };
 
-  const runGitCommand = (args) =>
-    new Promise((resolve) => {
-      execFile(
-        "git",
-        args,
-        { timeout: 10000, cwd: kRootResolved },
-        (error, stdout, stderr) => {
-          if (error) {
-            return resolve({
-              ok: false,
-              error: String(stderr || stdout || error.message || "git command failed").trim(),
-            });
-          }
-          return resolve({ ok: true, stdout: String(stdout || "") });
-        },
-      );
-    });
-
-  const runGitCommandWithExitCode = (args) =>
-    new Promise((resolve) => {
-      execFile(
-        "git",
-        args,
-        { timeout: 10000, cwd: kRootResolved },
-        (error, stdout, stderr) => {
-          const safeStdout = String(stdout || "");
-          const safeStderr = String(stderr || "");
-          if (!error) {
-            return resolve({
-              ok: true,
-              stdout: safeStdout,
-              stderr: safeStderr,
-              exitCode: 0,
-            });
-          }
-          return resolve({
-            ok: false,
-            stdout: safeStdout,
-            stderr: safeStderr,
-            exitCode: Number.isInteger(error.code) ? error.code : 1,
-            error: String(error.message || "git command failed"),
-          });
-        },
-      );
-    });
-
-  const parseGithubRepoSlug = (value) => {
-    const raw = String(value || "").trim();
-    if (!raw) return "";
-    return raw
-      .replace(/^git@github\.com:/i, "")
-      .replace(/^https:\/\/github\.com\//i, "")
-      .replace(/\.git$/i, "")
-      .trim();
-  };
-
-  const normalizeChangedPath = (rawPath) => {
-    const value = String(rawPath || "").trim();
-    if (!value) return "";
-    if (value.includes(" -> ")) {
-      const segments = value.split(" -> ");
-      return String(segments[segments.length - 1] || "").trim();
-    }
-    return value;
-  };
-
   app.get("/api/browse/tree", (req, res) => {
     const depthValue = Number.parseInt(String(req.query.depth || ""), 10);
-    const depth = Number.isFinite(depthValue) && depthValue > 0 ? depthValue : kDefaultTreeDepth;
+    const depth =
+      Number.isFinite(depthValue) && depthValue > 0
+        ? depthValue
+        : kDefaultTreeDepth;
     try {
       const tree = buildTreeNode(kRootResolved, depth);
       return res.json({ ok: true, root: tree });
     } catch (error) {
-      return res
-        .status(500)
-        .json({ ok: false, error: error.message || "Could not build file tree" });
+      return res.status(500).json({
+        ok: false,
+        error: error.message || "Could not build file tree",
+      });
     }
   });
 
   app.get("/api/browse/read", (req, res) => {
-    const resolvedPath = resolveSafePath(req.query.path);
+    const resolvedPath = resolveSafePath(
+      req.query.path,
+      kRootResolved,
+      kRootWithSep,
+      kRootDisplayName,
+    );
     if (!resolvedPath.ok) {
       return res.status(400).json({ ok: false, error: resolvedPath.error });
     }
@@ -207,24 +102,70 @@ const registerBrowseRoutes = ({ app, fs, kRootDir }) => {
       if (!stats.isFile()) {
         return res.status(400).json({ ok: false, error: "Path is not a file" });
       }
-      if (isLikelyBinaryFile(resolvedPath.absolutePath)) {
-        return res.status(400).json({ ok: false, error: "Binary files are not editable" });
+      if (isSqliteFilePath(resolvedPath.absolutePath)) {
+        const sqliteSummary = readSqliteSummary(resolvedPath.absolutePath);
+        return res.json({
+          ok: true,
+          path: resolvedPath.relativePath,
+          kind: "sqlite",
+          sqliteSummary,
+          content: "",
+        });
+      }
+      const audioMimeType = getAudioMimeType(resolvedPath.absolutePath);
+      if (audioMimeType) {
+        const audioBytes = fs.readFileSync(resolvedPath.absolutePath);
+        const audioDataUrl = `data:${audioMimeType};base64,${audioBytes.toString("base64")}`;
+        return res.json({
+          ok: true,
+          path: resolvedPath.relativePath,
+          kind: "audio",
+          mimeType: audioMimeType,
+          audioDataUrl,
+          content: "",
+        });
+      }
+      if (isLikelyBinaryFile(fs, resolvedPath.absolutePath)) {
+        const imageMimeType = getImageMimeType(resolvedPath.absolutePath);
+        if (!imageMimeType) {
+          return res
+            .status(400)
+            .json({ ok: false, error: "Binary files are not editable" });
+        }
+        const imageBytes = fs.readFileSync(resolvedPath.absolutePath);
+        const imageDataUrl = `data:${imageMimeType};base64,${imageBytes.toString("base64")}`;
+        return res.json({
+          ok: true,
+          path: resolvedPath.relativePath,
+          kind: "image",
+          mimeType: imageMimeType,
+          imageDataUrl,
+          content: "",
+        });
       }
       const content = fs.readFileSync(resolvedPath.absolutePath, "utf8");
       return res.json({
         ok: true,
         path: resolvedPath.relativePath,
+        kind: "text",
         content,
       });
     } catch (error) {
-      return res.status(500).json({ ok: false, error: error.message || "Could not read file" });
+      return res
+        .status(500)
+        .json({ ok: false, error: error.message || "Could not read file" });
     }
   });
 
   app.get("/api/browse/git-summary", async (req, res) => {
     try {
-      const envRepoSlug = parseGithubRepoSlug(process.env.GITHUB_WORKSPACE_REPO || "");
-      const statusResult = await runGitCommand(["status", "--porcelain", "--branch"]);
+      const envRepoSlug = parseGithubRepoSlug(
+        process.env.GITHUB_WORKSPACE_REPO || "",
+      );
+      const statusResult = await runGitCommand(
+        ["status", "--porcelain", "--branch"],
+        kRootResolved,
+      );
       if (!statusResult.ok) {
         if (/not a git repository/i.test(statusResult.error || "")) {
           return res.json({
@@ -244,8 +185,12 @@ const registerBrowseRoutes = ({ app, fs, kRootDir }) => {
         .map((line) => line.trimEnd())
         .filter(Boolean);
       const branchLine = statusLines.find((line) => line.startsWith("##")) || "";
-      const branch = branchLine.replace(/^##\s*/, "").split("...")[0] || "unknown";
-      const diffNumstatResult = await runGitCommand(["diff", "--numstat", "HEAD"]);
+      const branchTracking = parseBranchTracking(branchLine);
+      const branch = branchTracking.branch;
+      const diffNumstatResult = await runGitCommand(
+        ["diff", "--numstat", "HEAD"],
+        kRootResolved,
+      );
       const diffStatsByPath = new Map();
       if (diffNumstatResult.ok) {
         diffNumstatResult.stdout
@@ -253,7 +198,8 @@ const registerBrowseRoutes = ({ app, fs, kRootDir }) => {
           .map((line) => line.trim())
           .filter(Boolean)
           .forEach((line) => {
-            const [addedRaw = "", deletedRaw = "", rawPath = ""] = line.split("\t");
+            const [addedRaw = "", deletedRaw = "", rawPath = ""] =
+              line.split("\t");
             const normalizedPath = normalizeChangedPath(rawPath);
             if (!normalizedPath) return;
             const addedLines = Number.parseInt(addedRaw, 10);
@@ -290,26 +236,33 @@ const registerBrowseRoutes = ({ app, fs, kRootDir }) => {
 
       let repoSlug = envRepoSlug;
       if (!repoSlug) {
-        const remoteResult = await runGitCommand(["remote", "get-url", "origin"]);
+        const remoteResult = await runGitCommand(
+          ["remote", "get-url", "origin"],
+          kRootResolved,
+        );
         if (remoteResult.ok) {
           repoSlug = parseGithubRepoSlug(remoteResult.stdout || "");
         }
       }
       const repoUrl = repoSlug ? `https://github.com/${repoSlug}` : "";
 
-      const logResult = await runGitCommand([
-        "log",
-        "--pretty=format:%H%x09%h%x09%s%x09%ct",
-        "-n",
-        "5",
-      ]);
+      const logResult = await runGitCommand(
+        [
+          "log",
+          "--pretty=format:%H%x09%h%x09%s%x09%ct",
+          "-n",
+          String(kCommitHistoryLimit),
+        ],
+        kRootResolved,
+      );
       const commits = logResult.ok
         ? logResult.stdout
             .split("\n")
             .map((line) => line.trim())
             .filter(Boolean)
             .map((line) => {
-              const [hash = "", shortHash = "", message = "", unixTs = "0"] = line.split("\t");
+              const [hash = "", shortHash = "", message = "", unixTs = "0"] =
+                line.split("\t");
               return {
                 hash,
                 shortHash,
@@ -327,6 +280,12 @@ const registerBrowseRoutes = ({ app, fs, kRootDir }) => {
         repoSlug,
         repoUrl,
         branch,
+        upstreamBranch: branchTracking.upstreamBranch,
+        hasUpstream: branchTracking.hasUpstream,
+        upstreamGone: branchTracking.upstreamGone,
+        aheadCount: branchTracking.aheadCount,
+        behindCount: branchTracking.behindCount,
+        syncState: branchTracking.syncState,
         isDirty: changedFiles.length > 0,
         changedFilesCount: changedFiles.length,
         changedFiles: changedFiles.slice(0, 16),
@@ -340,8 +299,53 @@ const registerBrowseRoutes = ({ app, fs, kRootDir }) => {
     }
   });
 
+  app.get("/api/browse/sqlite-table", (req, res) => {
+    const resolvedPath = resolveSafePath(
+      req.query.path,
+      kRootResolved,
+      kRootWithSep,
+      kRootDisplayName,
+    );
+    if (!resolvedPath.ok) {
+      return res.status(400).json({ ok: false, error: resolvedPath.error });
+    }
+    if (!isSqliteFilePath(resolvedPath.absolutePath)) {
+      return res.status(400).json({ ok: false, error: "Path is not a sqlite file" });
+    }
+    const tableName = String(req.query.table || "").trim();
+    const limit = req.query.limit;
+    const offset = req.query.offset;
+    const sqliteResult = readSqliteTableData(
+      resolvedPath.absolutePath,
+      tableName,
+      limit,
+      offset,
+    );
+    if (!sqliteResult.ok) {
+      return res.status(400).json({
+        ok: false,
+        error: sqliteResult.error || "Could not read sqlite table",
+      });
+    }
+    return res.json({
+      ok: true,
+      path: resolvedPath.relativePath,
+      table: sqliteResult.table,
+      columns: sqliteResult.columns,
+      rows: sqliteResult.rows,
+      limit: sqliteResult.limit,
+      offset: sqliteResult.offset,
+      totalRows: sqliteResult.totalRows,
+    });
+  });
+
   app.get("/api/browse/git-diff", async (req, res) => {
-    const resolvedPath = resolveSafePath(req.query.path);
+    const resolvedPath = resolveSafePath(
+      req.query.path,
+      kRootResolved,
+      kRootWithSep,
+      kRootDisplayName,
+    );
     if (!resolvedPath.ok) {
       return res.status(400).json({ ok: false, error: resolvedPath.error });
     }
@@ -351,13 +355,14 @@ const registerBrowseRoutes = ({ app, fs, kRootDir }) => {
     }
 
     try {
-      const statusResult = await runGitCommandWithExitCode([
-        "status",
-        "--porcelain",
-        "--",
-        relativePath,
-      ]);
-      if (!statusResult.ok && /not a git repository/i.test(statusResult.stderr || "")) {
+      const statusResult = await runGitCommandWithExitCode(
+        ["status", "--porcelain", "--", relativePath],
+        kRootResolved,
+      );
+      if (
+        !statusResult.ok &&
+        /not a git repository/i.test(statusResult.stderr || "")
+      ) {
         return res.status(400).json({ ok: false, error: "No git repo at this root" });
       }
       const statusLines = statusResult.stdout
@@ -367,14 +372,14 @@ const registerBrowseRoutes = ({ app, fs, kRootDir }) => {
       const isUntracked = statusLines.some((line) => line.startsWith("??"));
 
       const diffResult = isUntracked
-        ? await runGitCommandWithExitCode([
-            "diff",
-            "--no-index",
-            "--",
-            "/dev/null",
-            resolvedPath.absolutePath,
-          ])
-        : await runGitCommandWithExitCode(["diff", "HEAD", "--", relativePath]);
+        ? await runGitCommandWithExitCode(
+            ["diff", "--no-index", "--", "/dev/null", resolvedPath.absolutePath],
+            kRootResolved,
+          )
+        : await runGitCommandWithExitCode(
+            ["diff", "HEAD", "--", relativePath],
+            kRootResolved,
+          );
 
       const untrackedAllowedFailure =
         isUntracked && diffResult.exitCode === 1 && diffResult.stdout;
@@ -394,9 +399,10 @@ const registerBrowseRoutes = ({ app, fs, kRootDir }) => {
         content,
       });
     } catch (error) {
-      return res
-        .status(500)
-        .json({ ok: false, error: error.message || "Could not load file diff" });
+      return res.status(500).json({
+        ok: false,
+        error: error.message || "Could not load file diff",
+      });
     }
   });
 
@@ -404,57 +410,116 @@ const registerBrowseRoutes = ({ app, fs, kRootDir }) => {
     try {
       const commitMessageRaw = String(req.body?.message || "").trim();
       const commitMessage = commitMessageRaw || "sync changes";
-      const statusResult = await runGitCommand(["status", "--porcelain"]);
+      const statusResult = await runGitCommand(
+        ["status", "--porcelain", "--branch"],
+        kRootResolved,
+      );
       if (!statusResult.ok) {
         if (/not a git repository/i.test(statusResult.error || "")) {
-          return res
-            .status(400)
-            .json({ ok: false, error: "No git repo at this root" });
+          return res.status(400).json({ ok: false, error: "No git repo at this root" });
         }
         return res.status(500).json({
           ok: false,
           error: statusResult.error || "Could not read git status",
         });
       }
-      const hasChanges = statusResult.stdout
+      const statusLines = statusResult.stdout
         .split("\n")
-        .map((line) => line.trim())
-        .filter(Boolean).length > 0;
+        .map((line) => line.trimEnd())
+        .filter(Boolean);
+      const branchLine = statusLines.find((line) => line.startsWith("##")) || "";
+      const branchTracking = parseBranchTracking(branchLine);
+      const hasChanges =
+        statusLines
+          .filter((line) => !line.startsWith("##"))
+          .map((line) => line.trim())
+          .filter(Boolean).length > 0;
+      let committed = false;
+      let pushed = false;
+      let shortHash = "";
       if (!hasChanges) {
-        return res.json({
-          ok: true,
-          committed: false,
-          message: "No changes to sync",
-        });
-      }
-      const addResult = await runGitCommand(["add", "-A"]);
-      if (!addResult.ok) {
-        return res.status(500).json({
-          ok: false,
-          error: addResult.error || "Could not stage changes",
-        });
-      }
-      const commitResult = await runGitCommand(["commit", "-m", commitMessage]);
-      if (!commitResult.ok) {
-        if (/nothing to commit/i.test(commitResult.error || "")) {
+        const hasAheadCommits =
+          branchTracking.hasUpstream && branchTracking.aheadCount > 0;
+        if (!hasAheadCommits) {
           return res.json({
             ok: true,
             committed: false,
+            pushed: false,
             message: "No changes to sync",
           });
         }
-        return res.status(500).json({
-          ok: false,
-          error: commitResult.error || "Could not commit changes",
-        });
       }
-      const shortHashResult = await runGitCommand(["rev-parse", "--short", "HEAD"]);
-      const shortHash = shortHashResult.ok ? String(shortHashResult.stdout || "").trim() : "";
+      if (hasChanges) {
+        const addResult = await runGitCommand(["add", "-A"], kRootResolved);
+        if (!addResult.ok) {
+          return res.status(500).json({
+            ok: false,
+            error: addResult.error || "Could not stage changes",
+          });
+        }
+        const commitResult = await runGitCommand(
+          ["commit", "-m", commitMessage],
+          kRootResolved,
+        );
+        if (!commitResult.ok) {
+          if (/nothing to commit/i.test(commitResult.error || "")) {
+            return res.json({
+              ok: true,
+              committed: false,
+              pushed: false,
+              message: "No changes to sync",
+            });
+          }
+          return res.status(500).json({
+            ok: false,
+            error: commitResult.error || "Could not commit changes",
+          });
+        }
+        committed = true;
+        const shortHashResult = await runGitCommand(
+          ["rev-parse", "--short", "HEAD"],
+          kRootResolved,
+        );
+        shortHash = shortHashResult.ok
+          ? String(shortHashResult.stdout || "").trim()
+          : "";
+      }
+      const shouldPush = branchTracking.hasUpstream
+        ? branchTracking.aheadCount > 0 || committed
+        : committed;
+      if (shouldPush) {
+        const pushArgs = branchTracking.hasUpstream
+          ? ["push"]
+          : ["push", "-u", "origin", "HEAD"];
+        const pushResult = await runGitCommand(pushArgs, kRootResolved);
+        if (pushResult.ok) {
+          pushed = true;
+        } else {
+          return res.json({
+            ok: true,
+            committed,
+            pushed: false,
+            shortHash,
+            message: committed
+              ? `Committed ${shortHash || "changes"} locally; push failed`
+              : "Could not push commits",
+            pushError: pushResult.error || "Could not push commits",
+          });
+        }
+      }
+      const syncMessage = pushed
+        ? committed
+          ? `Committed and pushed ${shortHash || "changes"}`
+          : "Pushed local commits"
+        : committed
+          ? `Committed ${shortHash || "changes"}`
+          : "No changes to sync";
       return res.json({
         ok: true,
-        committed: true,
+        committed,
+        pushed,
         shortHash,
-        message: `Committed ${shortHash || "changes"}`,
+        message: syncMessage,
       });
     } catch (error) {
       return res.status(500).json({
@@ -466,7 +531,12 @@ const registerBrowseRoutes = ({ app, fs, kRootDir }) => {
 
   app.put("/api/browse/write", async (req, res) => {
     const { path: targetPath, content } = req.body || {};
-    const resolvedPath = resolveSafePath(targetPath);
+    const resolvedPath = resolveSafePath(
+      targetPath,
+      kRootResolved,
+      kRootWithSep,
+      kRootDisplayName,
+    );
     if (!resolvedPath.ok) {
       return res.status(400).json({ ok: false, error: resolvedPath.error });
     }
@@ -474,7 +544,7 @@ const registerBrowseRoutes = ({ app, fs, kRootDir }) => {
     if (matchesPolicyPath(kLockedBrowsePaths, normalizedPolicyPath)) {
       return res.status(403).json({
         ok: false,
-        error: "This file is managed by Alpha Claw and cannot be edited.",
+        error: "This file is managed by AlphaClaw and cannot be edited.",
       });
     }
     if (typeof content !== "string") {
@@ -492,7 +562,9 @@ const registerBrowseRoutes = ({ app, fs, kRootDir }) => {
         path: resolvedPath.relativePath,
       });
     } catch (error) {
-      return res.status(500).json({ ok: false, error: error.message || "Could not save file" });
+      return res
+        .status(500)
+        .json({ ok: false, error: error.message || "Could not save file" });
     }
   });
 };