agentgui 1.0.1090 → 1.0.1091

package/lib/ws-handlers-util.js

@@ -2,7 +2,7 @@ import fs from 'fs';
 import os from 'os';
 import path from 'path';
 import crypto from 'crypto';
-import { execSync, spawnSync } from 'child_process';
+import { execSync, spawnSync, execFile } from 'child_process';
 import { runClaudeWithStreaming } from './claude-runner-run.js';
 import { registry } from './claude-runner-agents.js';
 import { confineToRoots, fsAllowRoots } from './http-handler.js';
@@ -10,6 +10,49 @@ import { restart as restartAcpAgent } from './acp-sdk-manager.js';
 
 function err(code, message) { const e = new Error(message); e.code = code; throw e; }
 
+// Promisified execFile — array-args form only, never a shell string, so a
+// crafted branch/path/file value cannot be interpreted as a shell command.
+function execFileP(cmd, args, opts) {
+  return new Promise((resolve, reject) => {
+    execFile(cmd, args, { encoding: 'utf-8', timeout: 30000, maxBuffer: 20 * 1024 * 1024, ...opts }, (e, stdout, stderr) => {
+      if (e) { e.stdout = stdout; e.stderr = stderr; reject(e); return; }
+      resolve({ stdout, stderr });
+    });
+  });
+}
+
+// Resolve + confine a client-supplied cwd to the same allowlist the file
+// explorer / chat.sendMessage use (fsAllowRoots via confineToRoots). Falls
+// back to STARTUP_CWD (itself an allowed root) when no cwd is given.
+function resolveGitCwd(p, STARTUP_CWD) {
+  if (!p?.cwd) return STARTUP_CWD;
+  const conf = confineToRoots(p.cwd, fsAllowRoots());
+  if (!conf.ok) err(conf.reason === 'not found' ? 400 : 403, `cwd outside allowed roots: ${p.cwd}`);
+  return conf.realPath;
+}
+
+// A relative in-repo file path: no leading '-' (flag injection), no shell
+// metacharacters, no absolute path (git resolves it relative to cwd already).
+const SAFE_REL_PATH_RE = /^[^\0]{1,4096}$/;
+function assertSafeRelPath(v, label) {
+  if (typeof v !== 'string' || !v.length) err(400, `${label} required`);
+  if (v.startsWith('-')) err(400, `${label} must not start with '-'`);
+  if (/[\0]/.test(v)) err(400, `${label} contains invalid characters`);
+  if (!SAFE_REL_PATH_RE.test(v)) err(400, `${label} invalid`);
+  return v;
+}
+
+// A git branch/ref name — conservative allowlist (git's own ref-format is
+// more permissive, but this blocks every shell-metacharacter and flag-
+// injection vector while still covering normal branch names).
+const SAFE_BRANCH_RE = /^[A-Za-z0-9][A-Za-z0-9_.\/-]{0,199}$/;
+function assertSafeBranch(v, label) {
+  if (typeof v !== 'string' || !v.length) err(400, `${label} required`);
+  if (v.startsWith('-') || v.includes('..') || v.includes('//')) err(400, `${label} invalid`);
+  if (!SAFE_BRANCH_RE.test(v)) err(400, `${label} invalid`);
+  return v;
+}
+
 const SUB_AGENT_MAP = {
   'opencode': [{ id: 'gm-oc', name: 'GM OpenCode' }], 'cli-opencode': [{ id: 'gm-oc', name: 'GM OpenCode' }],
   'gemini': [{ id: 'gm-gc', name: 'GM Gemini' }], 'cli-gemini': [{ id: 'gm-gc', name: 'GM Gemini' }],
@@ -281,6 +324,84 @@ export function register(router, deps) {
     } catch (e) { err(500, e.message); }
   });
 
+  // --- git.diff: unified diff for a single file or the whole working tree.
+  // p.cwd (optional) is confined via confineToRoots/fsAllowRoots, same as
+  // chat.sendMessage; p.file (optional) is validated to reject flags/shell
+  // metacharacters. execFile array-args form only, never a shell string.
+  router.handle('git.diff', async (p) => {
+    const cwd = resolveGitCwd(p, STARTUP_CWD);
+    const args = ['diff', '--no-color'];
+    if (p?.staged) args.push('--staged');
+    if (p?.file) args.push('--', assertSafeRelPath(p.file, 'file'));
+    try {
+      const { stdout } = await execFileP('git', args, { cwd });
+      return { diff: stdout, file: p?.file || null, staged: !!p?.staged };
+    } catch (e) { err(500, (e.stderr || e.message || 'git diff failed').trim()); }
+  });
+
+  // --- git.log: recent commit list, limit param (default 20, capped 200).
+  router.handle('git.log', async (p) => {
+    const cwd = resolveGitCwd(p, STARTUP_CWD);
+    const limit = Math.max(1, Math.min(200, parseInt(p?.limit, 10) || 20));
+    const FIELD_SEP = '\x1f';
+    const REC_SEP = '\x1e';
+    const args = ['log', `-n${limit}`, `--pretty=format:%H${FIELD_SEP}%an${FIELD_SEP}%ad${FIELD_SEP}%s${REC_SEP}`, '--date=iso-strict'];
+    try {
+      const { stdout } = await execFileP('git', args, { cwd });
+      const commits = stdout.split(REC_SEP).map(s => s.trim()).filter(Boolean).map(rec => {
+        const [hash, author, date, ...rest] = rec.split(FIELD_SEP);
+        return { hash, author, date, subject: rest.join(FIELD_SEP) };
+      });
+      return { commits };
+    } catch (e) { err(500, (e.stderr || e.message || 'git log failed').trim()); }
+  });
+
+  // --- worktree.list / create / remove ---
+  router.handle('worktree.list', async (p) => {
+    const cwd = resolveGitCwd(p, STARTUP_CWD);
+    try {
+      const { stdout } = await execFileP('git', ['worktree', 'list', '--porcelain'], { cwd });
+      // Parse the porcelain block format: records separated by blank lines,
+      // each line "key value" or a bare flag ("bare", "detached", "locked").
+      const worktrees = [];
+      let cur = null;
+      for (const line of stdout.split('\n')) {
+        if (!line.trim()) { if (cur) { worktrees.push(cur); cur = null; } continue; }
+        if (!cur) cur = {};
+        const sp = line.indexOf(' ');
+        if (sp === -1) { cur[line] = true; continue; }
+        cur[line.slice(0, sp)] = line.slice(sp + 1);
+      }
+      if (cur) worktrees.push(cur);
+      return { worktrees: worktrees.map(w => ({ path: w.worktree || null, head: w.HEAD || null, branch: w.branch || null, bare: !!w.bare, detached: !!w.detached, locked: !!w.locked })) };
+    } catch (e) { err(500, (e.stderr || e.message || 'git worktree list failed').trim()); }
+  });
+
+  router.handle('worktree.create', async (p) => {
+    const cwd = resolveGitCwd(p, STARTUP_CWD);
+    const wtPath = assertSafeRelPath(p?.path, 'path');
+    const args = ['worktree', 'add'];
+    if (p?.newBranch) { args.push('-b', assertSafeBranch(p.newBranch, 'newBranch')); }
+    args.push(wtPath);
+    if (p?.branch) args.push(assertSafeBranch(p.branch, 'branch'));
+    try {
+      const { stdout, stderr } = await execFileP('git', args, { cwd });
+      return { ok: true, output: (stdout || stderr || '').trim(), path: wtPath };
+    } catch (e) { err(500, (e.stderr || e.message || 'git worktree add failed').trim()); }
+  });
+
+  router.handle('worktree.remove', async (p) => {
+    const cwd = resolveGitCwd(p, STARTUP_CWD);
+    const wtPath = assertSafeRelPath(p?.path, 'path');
+    const args = ['worktree', 'remove'];
+    if (p?.force) args.push('--force');
+    args.push(wtPath);
+    try {
+      const { stdout, stderr } = await execFileP('git', args, { cwd });
+      return { ok: true, output: (stdout || stderr || '').trim() };
+    } catch (e) { err(500, (e.stderr || e.message || 'git worktree remove failed').trim()); }
+  });
+
   router.handle('auth.configs', () => getProviderConfigs());
 
   router.handle('auth.save', (p) => {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agentgui",
-  "version": "1.0.1090",
+  "version": "1.0.1091",
   "description": "Multi-agent ACP client with real-time communication",
   "type": "module",
   "main": "electron/main.js",

package/site/app/js/app.js

@@ -43,6 +43,10 @@ const state = {
   activeTimer: null,
   eventsLimit: 300,   // how many of the most-recent events to render; grows via "load older"
   files: { path: '', segments: [], entries: [], roots: [], loading: false, error: null, preview: null, sort: 'name', sortDir: 'asc', filter: '' },
+  // Minimal git/worktree panel state. The richer visual component
+  // (GitDiffView/WorktreeSwitcher) lives in anentrypoint-design; this is a
+  // plain list/text render until the vendored SDK bundle picks those up.
+  git: { loading: false, error: null, diff: '', commits: [], worktrees: [], file: '' },
 };
 
 // Two-step arm controls auto-reset after this delay so an accidental first click
@@ -641,6 +645,8 @@ function view() {
     crumbLeaf = 'files';
   } else if (state.tab === 'live') {
     crumbLeaf = 'live · ' + ((state.active && state.active.length) || 0);
+  } else if (state.tab === 'git') {
+    crumbLeaf = 'git';
   } else if (state.tab === 'settings') {
     // Same word as the rail item - location chrome must not fork vocabulary.
     crumbLeaf = 'settings';
@@ -725,6 +731,7 @@ function workspaceRail() {
     { key: 'history', label: 'History', icon: 'thread', active: state.tab === 'history', onClick: () => navTo('history') },
     { key: 'files', label: 'Files', icon: 'folder', active: state.tab === 'files', onClick: () => navTo('files') },
     { key: 'live', label: 'Live', icon: 'activity', active: state.tab === 'live', count: liveCount || null, rail: liveHasError ? 'flame' : undefined, onClick: () => navTo('live') },
+    { key: 'git', label: 'Git', icon: 'branch', active: state.tab === 'git', onClick: () => navTo('git') },
     { key: 'settings', label: 'Settings', icon: 'settings', active: state.tab === 'settings', onClick: () => navTo('settings') },
   ];
   return WorkspaceRail({
@@ -928,9 +935,76 @@ function mainContent() {
   if (state.tab === 'history') return historyMain();
   if (state.tab === 'files')   return filesMain();
   if (state.tab === 'live')    return liveMain();
+  if (state.tab === 'git')     return gitMain();
   return settingsMain();
 }
 
+// --- git (diff/log + worktree list) ---
+// Minimal panel: loads git.log + worktree.list on entry, git.diff on demand.
+// A richer visual component (GitDiffView/WorktreeSwitcher) is being built in
+// anentrypoint-design in parallel; swap this for those exports once the
+// vendored SDK bundle (site/app/vendor/anentrypoint-design) is rebuilt to
+// include them - it does not yet (checked: no GitDiffView/WorktreeSwitcher
+// in the vendored 247420.js as of this change).
+async function loadGitPanel() {
+  state.git.loading = true; state.git.error = null; render();
+  try {
+    const [commits, worktrees] = await Promise.all([
+      B.gitLog(state.backend, { limit: 20 }),
+      B.worktreeList(state.backend, {}),
+    ]);
+    state.git.commits = commits;
+    state.git.worktrees = worktrees;
+  } catch (e) {
+    state.git.error = e.message || 'Could not load git status.';
+  }
+  state.git.loading = false; render();
+}
+
+async function loadGitDiff(file) {
+  state.git.diffLoading = true; state.git.diffError = null; render();
+  try {
+    const { diff } = await B.gitDiff(state.backend, { file: file || undefined });
+    state.git.diff = diff || '(no changes)';
+    state.git.file = file || '';
+  } catch (e) {
+    state.git.diffError = e.message || 'Could not load diff.';
+  }
+  state.git.diffLoading = false; render();
+}
+
+function gitMain() {
+  if (!state.git.loading && !state.git.commits.length && !state.git.worktrees.length && !state.git.error) loadGitPanel();
+  const g = state.git;
+  return [
+    PageHeader({ compact: true, dense: true, title: 'Git', lede: 'Working-tree diff, recent commits, and worktrees.' }),
+    g.error ? Alert({ key: 'git-err', kind: 'error', title: 'Git error', children: g.error }) : null,
+    Row({ key: 'git-actions', children: [
+      Btn({ key: 'refresh', onClick: () => loadGitPanel(), children: g.loading ? 'loading…' : 'refresh' }),
+      Btn({ key: 'diff-all', onClick: () => loadGitDiff(''), children: g.diffLoading ? 'loading diff…' : 'load full diff' }),
+    ] }),
+    Panel({ id: 'git-diff', title: g.file ? ('diff: ' + g.file) : 'diff', children:
+      g.diffError ? h('p', { key: 'de', class: 't-meta field-error' }, g.diffError)
+      : h('pre', { key: 'dp', class: 'git-diff-pre' }, g.diff || '(no diff loaded)') }),
+    Panel({ id: 'git-log', title: 'recent commits', children:
+      !g.commits.length ? h('p', { key: 'nc', class: 't-meta' }, g.loading ? 'loading…' : 'no commits')
+      : h('ul', { key: 'cl', class: 'git-commit-list' }, g.commits.map(c =>
+          h('li', { key: c.hash }, [
+            h('code', { key: 'h' }, (c.hash || '').slice(0, 8)),
+            ' ' + (c.subject || ''),
+            h('span', { key: 'm', class: 't-meta' }, ' — ' + (c.author || '') + ' · ' + (c.date || '')),
+            Btn({ key: 'view', small: true, onClick: () => loadGitDiff(''), children: 'view' }),
+          ]))) }),
+    Panel({ id: 'git-worktrees', title: 'worktrees', children:
+      !g.worktrees.length ? h('p', { key: 'nw', class: 't-meta' }, g.loading ? 'loading…' : 'no worktrees')
+      : h('ul', { key: 'wl', class: 'git-worktree-list' }, g.worktrees.map((w, i) =>
+          h('li', { key: w.path || i }, [
+            h('code', { key: 'p' }, w.path || ''),
+            ' ' + (w.branch || (w.detached ? '(detached)' : '')),
+          ]))) }),
+  ];
+}
+
 // --- files (folder browser) ---
 async function loadDir(dirPath, { fromHash = false } = {}) {
   state.files = state.files || {};

package/site/app/js/backend.js

@@ -428,6 +428,30 @@ export async function listAgentModels(base, agentId) {
   } catch { return []; }
 }
 
+// ---------- Git / worktrees (WS) ----------
+
+export async function gitDiff(base, { cwd, file, staged } = {}) {
+  return wsCall(base, 'git.diff', { cwd, file, staged });
+}
+
+export async function gitLog(base, { cwd, limit } = {}) {
+  const { commits } = await wsCall(base, 'git.log', { cwd, limit });
+  return commits || [];
+}
+
+export async function worktreeList(base, { cwd } = {}) {
+  const { worktrees } = await wsCall(base, 'worktree.list', { cwd });
+  return worktrees || [];
+}
+
+export async function worktreeCreate(base, { cwd, path, branch, newBranch } = {}) {
+  return wsCall(base, 'worktree.create', { cwd, path, branch, newBranch });
+}
+
+export async function worktreeRemove(base, { cwd, path, force } = {}) {
+  return wsCall(base, 'worktree.remove', { cwd, path, force });
+}
+
 // ---------- Streaming chat (WS) ----------
 //
 // Yields events of shape: