clay-server 4.0.0-beta.8 → 4.0.0

package/lib/daemon-projects.js

@@ -7,6 +7,7 @@
 var fs = require("fs");
 var { scanWorktrees, isWorktree } = require("./worktree");
 var { daemonSync } = require("./daemon-sync");
+var logContext = require("./project-log-context");
 
 // --- Worktree tracking state ---
 var worktreeRegistry = {}; // parentSlug -> [wtSlug, ...]
@@ -28,9 +29,9 @@ function isWorktreeSlug(slug) {
  * @param {string} parentIcon - icon of parent project
  * @param {string} parentOwnerId - owner user ID
  */
-function scanAndRegisterWorktrees(relay, parentPath, parentSlug, parentIcon, parentOwnerId) {
-  if (isWorktree(parentPath)) return;
-  var worktrees = scanWorktrees(parentPath);
+function scanAndRegisterWorktrees(relay, parentPath, parentSlug, parentIcon, parentOwnerId, projectKnowledgeId, osUserInfo) {
+  if (isWorktree(parentPath, osUserInfo)) return;
+  var worktrees = scanWorktrees(parentPath, osUserInfo);
   if (worktrees.length === 0) return;
   if (!worktreeRegistry[parentSlug]) worktreeRegistry[parentSlug] = [];
   for (var i = 0; i < worktrees.length; i++) {
@@ -41,13 +42,14 @@ function scanAndRegisterWorktrees(relay, parentPath, parentSlug, parentIcon, par
       if (worktreeRegistry[parentSlug][j] === wtSlug) { alreadyRegistered = true; break; }
     }
     if (alreadyRegistered) continue;
-    var wtMeta = { parentSlug: parentSlug, branch: wt.branch || wt.dirName, external: wt.external };
+    var context = logContext.resolveWorktreeContext(wt.path, projectKnowledgeId, { branch: wt.branch || wt.dirName }, osUserInfo);
+    var wtMeta = Object.assign({ parentSlug: parentSlug, external: wt.external, projectKnowledgeId: projectKnowledgeId }, context);
     relay.addProject(wt.path, wtSlug, wt.branch || wt.dirName, parentIcon, parentOwnerId, wtMeta);
     worktreeRegistry[parentSlug].push(wtSlug);
     console.log("[daemon] Registered worktree:", wtSlug, "->", wt.path, wt.external ? "(external)" : "(inside project folder)");
   }
   daemonSync.register(getWorktreeSyncKey(parentSlug), function () {
-    rescanWorktrees(relay, parentPath, parentSlug, parentIcon, parentOwnerId);
+    rescanWorktrees(relay, parentPath, parentSlug, parentIcon, parentOwnerId, null, projectKnowledgeId, osUserInfo);
   });
 }
 
@@ -60,11 +62,11 @@ function scanAndRegisterWorktrees(relay, parentPath, parentSlug, parentIcon, par
  * @param {string} parentOwnerId - owner user ID
  * @param {object} [config] - daemon config (optional, for broadcasting project count)
  */
-function rescanWorktrees(relay, parentPath, parentSlug, parentIcon, parentOwnerId, config) {
+function rescanWorktrees(relay, parentPath, parentSlug, parentIcon, parentOwnerId, config, projectKnowledgeId, osUserInfo) {
   if (worktreeScanning[parentSlug]) return;
   worktreeScanning[parentSlug] = true;
   try {
-    var discovered = scanWorktrees(parentPath);
+    var discovered = scanWorktrees(parentPath, osUserInfo);
     var changed = false;
     var existingSlugs = worktreeRegistry[parentSlug] || [];
     var discoveredNames = {};
@@ -79,7 +81,8 @@ function rescanWorktrees(relay, parentPath, parentSlug, parentIcon, parentOwnerI
         if (existingSlugs[ei] === wtSlug) { found = true; break; }
       }
       if (!found) {
-        var wtMeta = { parentSlug: parentSlug, branch: wt.branch || wt.dirName, external: wt.external };
+        var context = logContext.resolveWorktreeContext(wt.path, projectKnowledgeId, { branch: wt.branch || wt.dirName }, osUserInfo);
+        var wtMeta = Object.assign({ parentSlug: parentSlug, external: wt.external, projectKnowledgeId: projectKnowledgeId }, context);
         relay.addProject(wt.path, wtSlug, wt.branch || wt.dirName, parentIcon, parentOwnerId, wtMeta);
         if (!worktreeRegistry[parentSlug]) worktreeRegistry[parentSlug] = [];
         worktreeRegistry[parentSlug].push(wtSlug);
@@ -91,6 +94,7 @@ function rescanWorktrees(relay, parentPath, parentSlug, parentIcon, parentOwnerI
       var sSlug = existingSlugs[si];
       var dirName = sSlug.split("--").slice(1).join("--");
       if (!discoveredNames[dirName]) {
+        if (relay.setProjectLogContextState) relay.setProjectLogContextState(sSlug, "archived");
         relay.removeProject(sSlug);
         existingSlugs.splice(si, 1);
         console.log("[daemon] Rescan: removed stale worktree:", sSlug);
@@ -112,6 +116,7 @@ function rescanWorktrees(relay, parentPath, parentSlug, parentIcon, parentOwnerI
 function cleanupWorktreesForParent(relay, parentSlug) {
   var wtSlugs = worktreeRegistry[parentSlug] || [];
   for (var i = 0; i < wtSlugs.length; i++) {
+    if (relay.setProjectLogContextState) relay.setProjectLogContextState(wtSlugs[i], "archived");
     relay.removeProject(wtSlugs[i]);
     console.log("[daemon] Cascade removed worktree:", wtSlugs[i]);
   }

package/lib/daemon.js

@@ -34,7 +34,9 @@ var { checkAclSupport, grantProjectAccess, revokeProjectAccess, provisionAllUser
 var usersModule = require("./users");
 var { createWorktree, removeWorktree, isWorktree } = require("./worktree");
 var mates = require("./mates");
+var mateKnowledgeMigration = require("./mate-knowledge-migration");
 var { isWorktreeSlug, scanAndRegisterWorktrees, rescanWorktrees, cleanupWorktreesForParent, getFilteredRemovedProjects, registerWorktreeSlug, unregisterWorktreeSlug } = require("./daemon-projects");
+var projectLogContext = require("./project-log-context");
 
 var daemonVersion = require("../package.json").version;
 var configFile = process.env.CLAY_CONFIG || process.env.CLAUDE_RELAY_CONFIG || require("./config").configPath();
@@ -64,6 +66,11 @@ try {
   console.error("[daemon] ensureMultiUser threw (continuing):", e && e.message);
 }
 
+if (projectLogContext.initializeProjectKnowledge(config)) {
+  saveConfig(config);
+  console.log("[daemon] Assigned stable knowledge identities to existing projects");
+}
+
 // --- OS users mode: check required system dependencies ---
 // Supplementary-group inheritance (issue #367): default on so sessions behave
 // like a normal login; operators can disable via config / the settings toggle.
@@ -152,6 +159,39 @@ var lanIp = (function () {
 // --- Create multi-project server ---
 var listenHost = config.host || "0.0.0.0";
 
+function rememberedProjectKnowledgeId(projectPath) {
+  var removed = config.removedProjects || [];
+  for (var i = removed.length - 1; i >= 0; i--) {
+    if (removed[i].path === projectPath && projectLogContext.validId(removed[i].projectKnowledgeId)) {
+      return removed[i].projectKnowledgeId;
+    }
+  }
+  return projectLogContext.createProjectKnowledgeId();
+}
+
+function projectRuntimeOptions(project) {
+  return { projectKnowledgeId: project.projectKnowledgeId };
+}
+
+function worktreeOsUserInfo(project, requestUser) {
+  if (!config.osUsers) return null;
+  var owner = project && project.ownerId ? usersModule.findUserById(project.ownerId) : null;
+  var executionUser = owner && owner.linuxUser ? owner : requestUser;
+  if (!executionUser || !executionUser.linuxUser) {
+    throw new Error("The project owner does not have a provisioned Linux account");
+  }
+  return osUsersMod.resolveOsUserInfo(executionUser.linuxUser);
+}
+
+function registerProjectWorktrees(project, requestUser) {
+  try {
+    var osUserInfo = worktreeOsUserInfo(project, requestUser);
+    scanAndRegisterWorktrees(relay, project.path, project.slug, project.icon, project.ownerId, project.projectKnowledgeId, osUserInfo);
+  } catch (e) {
+    console.error("[daemon] Failed to scan worktrees for " + project.slug + ": " + e.message);
+  }
+}
+
 var relay = createServer({
   tlsOptions: tlsOptions,
   caPath: caRoot,
@@ -172,13 +212,14 @@ var relay = createServer({
     }
     var slugs = config.projects.map(function (p) { return p.slug; });
     var slug = generateSlug(absPath, slugs);
-    relay.addProject(absPath, slug, null, null, wsUser ? wsUser.id : null);
     var projectEntry = { path: absPath, slug: slug, addedAt: Date.now(), visibility: "private" };
+    projectEntry.projectKnowledgeId = rememberedProjectKnowledgeId(absPath);
     // The user who adds a project always becomes the owner
     if (wsUser && wsUser.id) {
       projectEntry.ownerId = wsUser.id;
     }
     config.projects.push(projectEntry);
+    relay.addProject(absPath, slug, null, null, wsUser ? wsUser.id : null, null, projectRuntimeOptions(projectEntry));
     // Remove from removedProjects if present
     if (config.removedProjects) {
       config.removedProjects = config.removedProjects.filter(function (rp) { return rp.path !== absPath; });
@@ -197,7 +238,7 @@ var relay = createServer({
       }
     }
     // Discover and register worktrees for the new project
-    scanAndRegisterWorktrees(relay, absPath, slug, null, wsUser && wsUser.id && wsUser.role !== "admin" ? wsUser.id : null);
+    registerProjectWorktrees(projectEntry, wsUser);
     // Broadcast updated project list to all clients
     relay.broadcastAll({
       type: "projects_updated",
@@ -254,10 +295,11 @@ var relay = createServer({
     }
     // Register project - creator always becomes owner, default private
     var projectEntry = { path: targetDir, slug: slug, addedAt: Date.now(), visibility: "private" };
+    projectEntry.projectKnowledgeId = projectLogContext.createProjectKnowledgeId();
     if (wsUser && wsUser.id) {
       projectEntry.ownerId = wsUser.id;
     }
-    relay.addProject(targetDir, slug, null, null, wsUser ? wsUser.id : null);
+    relay.addProject(targetDir, slug, null, null, wsUser ? wsUser.id : null, null, projectRuntimeOptions(projectEntry));
     config.projects.push(projectEntry);
     saveConfig(config);
     try { syncClayrc(config.projects); } catch (e) {}
@@ -344,10 +386,11 @@ var relay = createServer({
       // Register project - creator always becomes owner
       // Creator always becomes owner, default private
       var projectEntry = { path: targetDir, slug: slug, addedAt: Date.now(), visibility: "private" };
+      projectEntry.projectKnowledgeId = projectLogContext.createProjectKnowledgeId();
       if (wsUser && wsUser.id) {
         projectEntry.ownerId = wsUser.id;
       }
-      relay.addProject(targetDir, slug);
+      relay.addProject(targetDir, slug, null, null, wsUser ? wsUser.id : null, null, projectRuntimeOptions(projectEntry));
       config.projects.push(projectEntry);
       saveConfig(config);
       try { syncClayrc(config.projects); } catch (e) {}
@@ -379,11 +422,21 @@ var relay = createServer({
         if (config.projects[pi].slug === wtParent) { parentProject = config.projects[pi]; break; }
       }
       if (parentProject) {
-        var rmResult = removeWorktree(parentProject.path, wtDirName);
+        var wtPath = path.join(parentProject.path, wtDirName);
+        var removeUser = userId ? usersModule.findUserById(userId) : null;
+        var removeOsUserInfo;
+        try {
+          removeOsUserInfo = worktreeOsUserInfo(parentProject, removeUser);
+        } catch (e) {
+          return { ok: false, error: e.message };
+        }
+        var contextStatus = projectLogContext.isMerged(parentProject.path, wtPath, removeOsUserInfo) ? "merged" : "archived";
+        var rmResult = removeWorktree(parentProject.path, wtDirName, removeOsUserInfo);
         if (!rmResult.ok) {
           console.log("[daemon] Failed to remove worktree:", slug, rmResult.error);
           return { ok: false, error: rmResult.error };
         }
+        relay.setProjectLogContextState(slug, contextStatus);
       }
       relay.removeProject(slug);
       unregisterWorktreeSlug(wtParent, slug);
@@ -409,6 +462,7 @@ var relay = createServer({
       title: found.title || null,
       icon: found.icon || null,
       userId: userId || null,
+      projectKnowledgeId: found.projectKnowledgeId || null,
       removedAt: Date.now(),
     });
     // Cap at 20 entries (oldest first)
@@ -739,6 +793,7 @@ var relay = createServer({
       inheritGroups: config.inheritGroups !== false,
       chatLayout: config.chatLayout || "channel",
       matesEnabled: config.matesEnabled === true,
+      capsulesEnabled: config.capsulesEnabled === true,
       pinEnabled: !!config.pinHash,
       platform: process.platform,
       hostname: os2.hostname(),
@@ -817,6 +872,13 @@ var relay = createServer({
     console.log("[daemon] Project Mate DMs:", want ? "shown" : "hidden", "(web)");
     return { ok: true, matesEnabled: want };
   },
+  onSetCapsulesEnabled: function (value) {
+    var want = value === true;
+    config.capsulesEnabled = want;
+    saveConfig(config);
+    console.log("[daemon] Experimental Capsules:", want ? "enabled" : "disabled", "(web)");
+    return { ok: true, capsulesEnabled: want };
+  },
   onGetToolPalettes: function () {
     return config.toolPalettes || {};
   },
@@ -967,19 +1029,30 @@ var relay = createServer({
     if (!config.osUsers || !linuxUser) return;
     deactivateLinuxUser(linuxUser);
   },
-  onCreateWorktree: function (parentSlug, branchName, dirName, baseBranch) {
+  onCreateWorktree: function (parentSlug, branchName, dirName, baseBranch, requestUser) {
     // Find the parent project
     var parent = null;
     for (var j = 0; j < config.projects.length; j++) {
       if (config.projects[j].slug === parentSlug) { parent = config.projects[j]; break; }
     }
     if (!parent) return { ok: false, error: "Parent project not found" };
-    if (isWorktree(parent.path)) return { ok: false, error: "Cannot create worktrees from a worktree project" };
-    var result = createWorktree(parent.path, branchName, dirName, baseBranch);
+    var osUserInfo;
+    try {
+      osUserInfo = worktreeOsUserInfo(parent, requestUser);
+    } catch (e) {
+      return { ok: false, error: e.message };
+    }
+    if (isWorktree(parent.path, osUserInfo)) return { ok: false, error: "Cannot create worktrees from a worktree project" };
+    var baseCommit = projectLogContext.commit(parent.path, baseBranch || "HEAD", osUserInfo);
+    var result = createWorktree(parent.path, branchName, dirName, baseBranch, osUserInfo);
     if (!result.ok) return result;
     // Register the new worktree as ephemeral project
     var wtSlug = parentSlug + "--" + dirName;
-    var wtMeta = { parentSlug: parentSlug, branch: branchName, external: false };
+    var context = projectLogContext.resolveWorktreeContext(result.path, parent.projectKnowledgeId, {
+      branch: branchName,
+      baseCommit: baseCommit,
+    }, osUserInfo);
+    var wtMeta = Object.assign({ parentSlug: parentSlug, external: false, projectKnowledgeId: parent.projectKnowledgeId }, context);
     relay.addProject(result.path, wtSlug, branchName, parent.icon, parent.ownerId, wtMeta);
     registerWorktreeSlug(parentSlug, wtSlug);
     console.log("[daemon] Created worktree:", wtSlug, "->", result.path);
@@ -1065,13 +1138,15 @@ var ipc = createIPCServer(socketPath(), function (msg) {
       }
       var slugs = config.projects.map(function (p) { return p.slug; });
       var slug = generateSlug(absPath, slugs);
-      relay.addProject(absPath, slug);
-      config.projects.push({ path: absPath, slug: slug, addedAt: Date.now(), visibility: "private" });
+      var projectEntry = { path: absPath, slug: slug, addedAt: Date.now(), visibility: "private" };
+      projectEntry.projectKnowledgeId = rememberedProjectKnowledgeId(absPath);
+      relay.addProject(absPath, slug, null, null, null, null, projectRuntimeOptions(projectEntry));
+      config.projects.push(projectEntry);
       saveConfig(config);
       try { syncClayrc(config.projects); } catch (e) {}
       console.log("[daemon] Added project:", slug, "→", absPath);
       // Discover and register worktrees for the new project
-      scanAndRegisterWorktrees(relay, absPath, slug, null, null);
+      registerProjectWorktrees(projectEntry, null);
       relay.broadcastAll({
         type: "projects_updated",
         projects: relay.getProjects(),
@@ -1093,6 +1168,23 @@ var ipc = createIPCServer(socketPath(), function (msg) {
         }
       }
       if (!target) return { ok: false, error: "project not found" };
+      var removedProject = null;
+      for (var ri = 0; ri < config.projects.length; ri++) {
+        if (config.projects[ri].slug === target) { removedProject = config.projects[ri]; break; }
+      }
+      if (removedProject) {
+        if (!config.removedProjects) config.removedProjects = [];
+        config.removedProjects.push({
+          path: removedProject.path,
+          title: removedProject.title || null,
+          icon: removedProject.icon || null,
+          projectKnowledgeId: removedProject.projectKnowledgeId || null,
+          removedAt: Date.now(),
+        });
+        if (config.removedProjects.length > 20) {
+          config.removedProjects = config.removedProjects.slice(config.removedProjects.length - 20);
+        }
+      }
       relay.removeProject(target);
       config.projects = config.projects.filter(function (p) { return p.slug !== target; });
       saveConfig(config);
@@ -1283,9 +1375,9 @@ for (var i = 0; i < projects.length; i++) {
   var p = projects[i];
   if (fs.existsSync(p.path)) {
     console.log("[daemon] Adding project:", p.slug, "→", p.path);
-    relay.addProject(p.path, p.slug, p.title, p.icon, p.ownerId);
+    relay.addProject(p.path, p.slug, p.title, p.icon, p.ownerId, null, projectRuntimeOptions(p));
     // Discover and register worktrees for this project
-    scanAndRegisterWorktrees(relay, p.path, p.slug, p.icon, p.ownerId);
+    registerProjectWorktrees(p, null);
   } else {
     console.log("[daemon] Skipping missing project:", p.path);
   }
@@ -1294,6 +1386,27 @@ for (var i = 0; i < projects.length; i++) {
 // Migrate legacy mates storage before registration
 mates.migrateLegacyMates();
 
+// Import durable Mate knowledge into the Clay-wide Knowledge backend. Runs on
+// every start, imports nothing when there is nothing new, and never touches
+// the legacy files that remain the live source for existing read paths.
+mateKnowledgeMigration.runAtStartup({
+  extraRoots: (function () {
+    var roots = [];
+    try {
+      if (!usersModule.isMultiUser()) return roots;
+      var all = usersModule.getAllUsers() || [];
+      for (var mi = 0; mi < all.length; mi++) {
+        if (!all[mi] || !all[mi].linuxUser) continue;
+        roots.push({
+          userId: all[mi].id,
+          matesRoot: mates.resolveMatesRoot({ userId: all[mi].id, multiUser: true, linuxUser: all[mi].linuxUser }),
+        });
+      }
+    } catch (e) {}
+    return roots;
+  })(),
+});
+
 // Register existing mates as projects
 if (usersModule.isMultiUser()) {
   // Multi-user mode: iterate over all users and load each user's mates

package/lib/git-cli.js

@@ -6,6 +6,7 @@ var { execFile, execFileSync } = require("child_process");
 var { wrapSpawnAsUser } = require("./os-users");
 
 var MAX_DIFF_BYTES = 2 * 1024 * 1024;
+var MAX_REMOTE_LABEL = 64;
 
 function gitEnvironment(osUserInfo) {
   var overrides = { GIT_TERMINAL_PROMPT: "0" };
@@ -157,6 +158,24 @@ function normalizeGitPath(cwd, value) {
   return path.normalize(path.isAbsolute(value) ? value : path.resolve(cwd, value));
 }
 
+// Whether this checkout is a linked worktree. The two directories have to be
+// compared through realpath: git answers --absolute-git-dir already resolved
+// but --git-common-dir relative to cwd, so on any platform where the working
+// directory sits behind a symlink (macOS /var -> /private/var, for one) a
+// plain string compare reports every ordinary repository as a worktree.
+function isLinkedWorktree(gitDir, commonDir) {
+  if (!gitDir || !commonDir) return false;
+  return realGitPath(gitDir) !== realGitPath(commonDir);
+}
+
+function realGitPath(value) {
+  try {
+    return fs.realpathSync(value);
+  } catch (e) {
+    return value;
+  }
+}
+
 function parseWorktrees(raw) {
   var blocks = String(raw || "").trim().split(/\n\n+/);
   var result = [];
@@ -219,7 +238,7 @@ function getStatus(cwd, osUserInfo) {
     origin: origin,
     gitDir: gitDir,
     commonDir: commonDir,
-    isWorktree: !!(gitDir && commonDir && gitDir !== commonDir),
+    isWorktree: isLinkedWorktree(gitDir, commonDir),
     mainWorktree: worktrees.length > 0 ? worktrees[0].path : root,
     worktrees: worktrees,
     files: parsed.files,
@@ -227,6 +246,78 @@ function getStatus(cwd, osUserInfo) {
   };
 }
 
+// A bounded, credential-free remote label. The raw remote URL can carry an
+// embedded token, so the userinfo segment is dropped before the label is
+// built rather than after.
+function shortRemoteLabel(origin) {
+  if (!origin) return null;
+  var label = String(origin).trim()
+    .replace(/^git@([^:]+):/, "$1/")
+    .replace(/^[a-z][a-z0-9+.-]*:\/\//i, "")
+    .replace(/^[^@/]*@/, "")
+    .replace(/\.git$/, "")
+    .replace(/\/+$/, "");
+  if (label.length > MAX_REMOTE_LABEL) label = label.slice(0, MAX_REMOTE_LABEL - 1) + "…";
+  return label || null;
+}
+
+function countChangedFiles(files) {
+  var counts = { changed: files.length, staged: 0, unstaged: 0, untracked: 0, conflicted: 0 };
+  for (var i = 0; i < files.length; i++) {
+    var file = files[i];
+    if (file.conflicted) counts.conflicted++;
+    if (file.untracked) counts.untracked++;
+    if (file.staged) counts.staged++;
+    if (file.unstaged && !file.untracked) counts.unstaged++;
+  }
+  return counts;
+}
+
+// Cheap always-visible repository placard data. Deliberately narrower than
+// getStatus: three git invocations instead of six, no per-file payload, no
+// session attribution, and no filesystem path in the result. Identity is
+// derived here so the client never resolves or renders a repository path.
+function getSummary(cwd, osUserInfo) {
+  var probe;
+  try {
+    probe = runGitSync(cwd, [
+      "rev-parse", "--is-inside-work-tree", "--show-toplevel",
+      "--absolute-git-dir", "--git-common-dir",
+    ], null, osUserInfo);
+  } catch (e) {
+    return { isRepository: false };
+  }
+  var lines = String(probe || "").trim().split("\n");
+  if (String(lines[0] || "").trim() !== "true" || !lines[1]) return { isRepository: false };
+
+  var root = String(lines[1]).trim();
+  var gitDir = lines[2] ? normalizeGitPath(cwd, String(lines[2]).trim()) : null;
+  var commonDir = lines[3] ? normalizeGitPath(cwd, String(lines[3]).trim()) : null;
+  var parsed = parsePorcelainV2(runGitSync(root, ["status", "--porcelain=v2", "--branch", "-z"], null, osUserInfo));
+  var origin = null;
+  try { origin = runGitSync(cwd, ["remote", "get-url", "origin"], null, osUserInfo).trim() || null; } catch (e) {}
+
+  var detached = parsed.branch === "(detached)";
+  var counts = countChangedFiles(parsed.files);
+  return {
+    isRepository: true,
+    name: path.basename(root),
+    branch: detached ? null : parsed.branch,
+    detached: detached,
+    shortOid: parsed.oid && parsed.oid !== "(initial)" ? String(parsed.oid).slice(0, 8) : null,
+    isWorktree: isLinkedWorktree(gitDir, commonDir),
+    hasUpstream: !!parsed.upstream,
+    ahead: parsed.ahead,
+    behind: parsed.behind,
+    changed: counts.changed,
+    staged: counts.staged,
+    unstaged: counts.unstaged,
+    untracked: counts.untracked,
+    conflicted: counts.conflicted,
+    remote: shortRemoteLabel(origin),
+  };
+}
+
 function resolveChangedPaths(status, requestedPaths) {
   if (!Array.isArray(requestedPaths) || requestedPaths.length === 0 || requestedPaths.length > 200) {
     throw new Error("Select at least one changed file");
@@ -363,8 +454,11 @@ module.exports = {
   getFileAtCommit: getFileAtCommit,
   getFileDiff: getFileDiff,
   getStatus: getStatus,
+  getSummary: getSummary,
   parsePorcelainV2: parsePorcelainV2,
   parseWorktrees: parseWorktrees,
   readWorkingTreeFile: readWorkingTreeFile,
+  runGitSync: runGitSync,
   runAction: runAction,
+  shortRemoteLabel: shortRemoteLabel,
 };