termdock 1.4.0 → 1.4.2

package/dist/server/agent/plugins.js

@@ -0,0 +1,271 @@
+/**
+ * Agent plugin system: user-defined agents loaded from
+ * `~/.termdock/agent-plugins/<slug>/manifest.json`.
+ *
+ * Each plugin can define:
+ * 1. Agent identity (display name, aliases, accent color, icon)
+ * 2. Hook installation config (target file + event mappings)
+ * 3. Resume command support
+ *
+ * Plugins are merged into the built-in agent registry and hook installer
+ * list at startup. Slugs that collide with built-in agents are skipped.
+ */
+import fs from 'node:fs';
+import path from 'node:path';
+import os from 'node:os';
+const PLUGINS_DIR = path.join(os.homedir(), '.termdock', 'agent-plugins');
+const MANIFEST_FILE = 'manifest.json';
+const ICON_FILE = 'icon.svg';
+// ---------------------------------------------------------------------------
+// Manifest schema
+// ---------------------------------------------------------------------------
+export const PLUGIN_MANIFEST_VERSION = 1;
+// ---------------------------------------------------------------------------
+// Known sentinel event kinds — the set of events our state machine accepts
+// ---------------------------------------------------------------------------
+const VALID_EVENT_KINDS = new Set([
+    'session-start',
+    'prompt-submit',
+    'permission-request',
+    'question-asked',
+    'tool-complete',
+    'notification',
+    'stop',
+    'session-end',
+]);
+// ---------------------------------------------------------------------------
+// Slug validation (alphanumeric + hyphens, non-empty)
+// ---------------------------------------------------------------------------
+const SLUG_RE = /^[a-z][a-z0-9-]*$/;
+function isValidSlug(s) {
+    return SLUG_RE.test(s) && s.length <= 40;
+}
+// ---------------------------------------------------------------------------
+// Hex color validation
+// ---------------------------------------------------------------------------
+const HEX_COLOR_RE = /^#[0-9A-Fa-f]{6}$/;
+// ---------------------------------------------------------------------------
+// Path resolution: ~ → home directory
+// ---------------------------------------------------------------------------
+function resolveHome(p) {
+    if (p.startsWith('~')) {
+        return path.join(os.homedir(), p.slice(1));
+    }
+    return p;
+}
+function validateManifest(raw, dir) {
+    const errors = [];
+    if (!raw || typeof raw !== 'object' || Array.isArray(raw)) {
+        return { error: { slug: path.basename(dir), errors: ['manifest.json is not a JSON object'] } };
+    }
+    const m = raw;
+    const version = m.version;
+    if (typeof version !== 'number' || version !== PLUGIN_MANIFEST_VERSION) {
+        errors.push(`version must be ${PLUGIN_MANIFEST_VERSION}`);
+    }
+    const slug = m.slug;
+    if (typeof slug !== 'string' || !isValidSlug(slug)) {
+        errors.push('slug must be a lowercase alphanumeric string with hyphens (max 40 chars)');
+    }
+    const displayName = m.displayName;
+    if (typeof displayName !== 'string' || displayName.trim().length === 0) {
+        errors.push('displayName is required and must be a non-empty string');
+    }
+    const aliases = m.aliases;
+    if (!Array.isArray(aliases) || aliases.length === 0 || !aliases.every((a) => typeof a === 'string' && a.trim().length > 0)) {
+        errors.push('aliases must be a non-empty array of strings');
+    }
+    const accentColor = m.accentColor;
+    if (typeof accentColor !== 'string' || !HEX_COLOR_RE.test(accentColor)) {
+        errors.push('accentColor must be a 6-digit hex color (e.g. "#4385BE")');
+    }
+    // Optional hooks
+    let hooks;
+    if (m.hooks !== undefined) {
+        if (typeof m.hooks !== 'object' || Array.isArray(m.hooks) || m.hooks === null) {
+            errors.push('hooks must be an object if present');
+        }
+        else {
+            const h = m.hooks;
+            const target = h.target;
+            if (typeof target !== 'string' || target.trim().length === 0) {
+                errors.push('hooks.target is required and must be a file path (~-abbreviated ok)');
+            }
+            const events = h.events;
+            if (!Array.isArray(events) || events.length === 0) {
+                errors.push('hooks.events must be a non-empty array');
+            }
+            else {
+                const validEvents = [];
+                for (let i = 0; i < events.length; i++) {
+                    const e = events[i];
+                    if (!e || typeof e !== 'object') {
+                        errors.push(`hooks.events[${i}] is not an object`);
+                        continue;
+                    }
+                    const evt = e;
+                    const hook = evt.hook;
+                    const event = evt.event;
+                    if (typeof hook !== 'string' || hook.trim().length === 0) {
+                        errors.push(`hooks.events[${i}].hook is required`);
+                    }
+                    if (typeof event !== 'string' || !VALID_EVENT_KINDS.has(event)) {
+                        errors.push(`hooks.events[${i}].event must be one of: ${[...VALID_EVENT_KINDS].join(', ')}`);
+                    }
+                    const matcher = evt.matcher;
+                    if (matcher !== undefined && typeof matcher !== 'string') {
+                        errors.push(`hooks.events[${i}].matcher must be a string if provided`);
+                    }
+                    const timeout = evt.timeout;
+                    if (timeout !== undefined && (typeof timeout !== 'number' || timeout <= 0)) {
+                        errors.push(`hooks.events[${i}].timeout must be a positive number if provided`);
+                    }
+                    validEvents.push({
+                        hook: hook,
+                        event: event,
+                        matcher: typeof matcher === 'string' ? matcher : undefined,
+                        timeout: typeof timeout === 'number' ? timeout : undefined,
+                    });
+                }
+                if (validEvents.length > 0) {
+                    hooks = { target: target, events: validEvents };
+                }
+            }
+        }
+    }
+    // Optional resume
+    let resumeConfig;
+    if (m.resume !== undefined) {
+        if (typeof m.resume !== 'object' || Array.isArray(m.resume) || m.resume === null) {
+            errors.push('resume must be an object if present');
+        }
+        else {
+            const r = m.resume;
+            const command = r.command;
+            if (typeof command !== 'string' || !command.includes('{sessionId}')) {
+                errors.push('resume.command must contain the {sessionId} placeholder');
+            }
+            const staleFlags = r.staleFlags;
+            if (staleFlags !== undefined && (!Array.isArray(staleFlags) || !staleFlags.every((f) => typeof f === 'string'))) {
+                errors.push('resume.staleFlags must be an array of strings if provided');
+            }
+            resumeConfig = {
+                command: command,
+                staleFlags: Array.isArray(staleFlags) ? staleFlags : undefined,
+            };
+        }
+    }
+    if (errors.length > 0) {
+        return { error: { slug: typeof slug === 'string' ? slug : path.basename(dir), errors } };
+    }
+    return {
+        manifest: {
+            version: version,
+            slug: slug,
+            displayName: displayName.trim(),
+            aliases: aliases.map((a) => a.trim().toLowerCase()),
+            accentColor: accentColor,
+            hooks,
+            resume: resumeConfig,
+        },
+    };
+}
+/**
+ * Scan ~/.termdock/agent-plugins/ for plugin directories, validate each
+ * manifest, and return the loaded plugins + any validation errors.
+ */
+export function loadPlugins() {
+    const plugins = [];
+    const errors = [];
+    let entries;
+    try {
+        entries = fs.readdirSync(PLUGINS_DIR, { withFileTypes: true });
+    }
+    catch {
+        return { plugins, errors };
+    }
+    for (const entry of entries) {
+        if (!entry.isDirectory())
+            continue;
+        const dir = path.join(PLUGINS_DIR, entry.name);
+        const manifestPath = path.join(dir, MANIFEST_FILE);
+        let raw;
+        try {
+            raw = fs.readFileSync(manifestPath, 'utf8');
+        }
+        catch {
+            continue;
+        }
+        let parsed;
+        try {
+            parsed = JSON.parse(raw);
+        }
+        catch {
+            errors.push({ slug: entry.name, errors: ['manifest.json is not valid JSON'] });
+            continue;
+        }
+        const result = validateManifest(parsed, dir);
+        if ('error' in result) {
+            errors.push(result.error);
+            continue;
+        }
+        const iconPath = path.join(dir, ICON_FILE);
+        plugins.push({
+            manifest: result.manifest,
+            dir,
+            iconPath: fs.existsSync(iconPath) ? iconPath : null,
+        });
+    }
+    return { plugins, errors };
+}
+/**
+ * Save a plugin manifest to disk, creating the plugin directory.
+ */
+export function savePlugin(manifest) {
+    const dir = path.join(PLUGINS_DIR, manifest.slug);
+    fs.mkdirSync(dir, { recursive: true });
+    const manifestPath = path.join(dir, MANIFEST_FILE);
+    fs.writeFileSync(manifestPath, JSON.stringify(manifest, null, 2), 'utf8');
+    return dir;
+}
+/**
+ * Remove a plugin directory from disk.
+ */
+export function removePlugin(slug) {
+    const dir = path.join(PLUGINS_DIR, slug);
+    if (!fs.existsSync(dir)) {
+        throw new Error(`Plugin "${slug}" not found`);
+    }
+    fs.rmSync(dir, { recursive: true, force: true });
+}
+/**
+ * List all plugin slugs (both currently loaded and directories on disk).
+ */
+export function listPluginDirectories() {
+    try {
+        return fs.readdirSync(PLUGINS_DIR, { withFileTypes: true })
+            .filter((e) => e.isDirectory())
+            .map((e) => e.name);
+    }
+    catch {
+        return [];
+    }
+}
+/**
+ * Resolve a ~-abbreviated path from a plugin's hooks.target to an absolute path.
+ */
+export function resolveHookTarget(hooksTargetPath) {
+    return resolveHome(hooksTargetPath);
+}
+/**
+ * Read an icon SVG from a plugin directory as a string.
+ */
+export function readPluginIcon(slug) {
+    const iconPath = path.join(PLUGINS_DIR, slug, ICON_FILE);
+    try {
+        return fs.readFileSync(iconPath, 'utf8');
+    }
+    catch {
+        return null;
+    }
+}

package/dist/server/agent/registry.js

@@ -1,23 +1,3 @@
-/**
- * Third-party CLI coding-agent registry + detection.
- * （设计移植自 tty7 的 core/cli_agent.rs，Apache-2.0；此处为 TypeScript 重写）
- *
- * termdock recognizes when a pane is running a known coding agent (Claude
- * Code, Codex, Gemini CLI, …) so the tab can brand it and notifications can
- * say *which* agent finished or needs you. Detection is a pure function over
- * the foreground process's argv (which the server already polls for program
- * labels), so it works identically in shell mode and tmux mode.
- *
- * Strategy:
- * 1. Strip leading `VAR=value` environment assignments.
- * 2. If the launcher's own basename matches a known agent, that's it.
- * 3. Otherwise only if the launcher is a script *interpreter* (node, bun,
- *    python, npx, …), scan remaining path-like arguments for a segment that
- *    names an agent — the npm/pip-wrapped case (`node …/claude-code/cli.js`).
- *    The interpreter gate keeps `cat codex.md` from false-matching.
- * 4. User-defined rules (`agentCommands` in program-detection config): a map
- *    from command basename to agent slug, for personal wrappers (`cc`).
- */
 // Registry order matters only for iteration stability; lookup is by alias.
 // flexoki-allow-file — vendor brand accents are deliberately theme-independent.
 const AGENTS = [
@@ -239,6 +219,88 @@ function replayFlags(agent, argv) {
 export function buildResumeCommand(agent, sessionId, launchArgv) {
     if (!sessionId || !/^[A-Za-z0-9._-]+$/.test(sessionId))
         return null;
+    // Plugin-defined resume: use the command template
+    if (agent.isPlugin) {
+        const pluginResume = getPluginResumeConfig(agent.slug);
+        if (pluginResume) {
+            const safe = (t) => /^[A-Za-z0-9._-]+$/.test(t);
+            if (!safe(sessionId))
+                return null;
+            const cmd = pluginResume.command.replace('{sessionId}', sessionId);
+            // Shell-safety: refuse anything non-alphanumeric
+            if (!/^[A-Za-z0-9_[\]{},./:;@+=~'"!?#&()<>*|$ -]+$/.test(cmd))
+                return null;
+            return cmd;
+        }
+        return null;
+    }
     const flags = launchArgv ? replayFlags(agent, launchArgv) ?? [] : [];
     return resumeCommandFor(agent, sessionId, flags);
 }
+// ---------------------------------------------------------------------------
+// Plugin agent integration
+// ---------------------------------------------------------------------------
+/** Plugin-defined resume configs, keyed by slug. */
+const pluginResumeConfigs = new Map();
+/**
+ * Register plugin agents into the lookup maps. Plugins whose slug or aliases
+ * collide with built-in agents are skipped. Call `clearPluginAgents()` first
+ * when reloading.
+ */
+export function registerPluginAgents(plugins) {
+    let registered = 0;
+    const skipped = [];
+    for (const p of plugins) {
+        const { manifest } = p;
+        if (BY_SLUG.has(manifest.slug)) {
+            skipped.push(`${manifest.slug} (slug conflicts with built-in)`);
+            continue;
+        }
+        let aliasConflict = false;
+        for (const alias of manifest.aliases) {
+            if (BY_ALIAS.has(alias)) {
+                skipped.push(`${manifest.slug} (alias "${alias}" conflicts with built-in)`);
+                aliasConflict = true;
+                break;
+            }
+        }
+        if (aliasConflict)
+            continue;
+        const info = {
+            slug: manifest.slug,
+            displayName: manifest.displayName,
+            aliases: manifest.aliases,
+            accentColor: manifest.accentColor,
+            icon: manifest.slug, // plugins use slug as icon key; frontend checks /agent-plugin-icon/<slug>
+            isPlugin: true,
+        };
+        BY_SLUG.set(info.slug, info);
+        for (const alias of info.aliases)
+            BY_ALIAS.set(alias, info);
+        if (manifest.resume) {
+            pluginResumeConfigs.set(manifest.slug, {
+                command: manifest.resume.command,
+                staleFlags: manifest.resume.staleFlags ?? [],
+            });
+        }
+        registered++;
+    }
+    return { registered, skipped };
+}
+export function clearPluginAgents() {
+    for (const [slug, info] of BY_SLUG) {
+        if (info.isPlugin)
+            BY_SLUG.delete(slug);
+    }
+    for (const [alias, info] of BY_ALIAS) {
+        if (info.isPlugin)
+            BY_ALIAS.delete(alias);
+    }
+    pluginResumeConfigs.clear();
+}
+export function getPluginResumeConfig(slug) {
+    return pluginResumeConfigs.get(slug);
+}
+export function isPluginAgent(slug) {
+    return BY_SLUG.get(slug)?.isPlugin === true;
+}

package/dist/server/cli.js

@@ -145,8 +145,11 @@ Options:
   --change-audit-show <id> [cwd]
                      Print one hunk's diff/context by Termdock hunk ID.
   --change-audit-explain <id> [cwd]
-                     Read a natural-language explanation from stdin and inject
-                     it for the specified Termdock hunk ID.
+                      Read a natural-language explanation from stdin and inject
+                      it for the specified Termdock hunk ID.
+  --agent-plugin-init <slug>
+                      Scaffold a new agent plugin with a manifest template and
+                      guidance. Creates ~/.termdock/agent-plugins/<slug>/.
   -h, --help         Show this help message
 
 Short commands:
@@ -178,6 +181,7 @@ Short commands:
   pc                 Same as --clear-password
   pwc                Same as --clear-password
   https              Same as --setup-local-https
+  ap <slug>          Same as --agent-plugin-init <slug>
 
 Password examples:
   ${c.dim('# Set password interactively (recommended)')}
@@ -465,6 +469,8 @@ function parseArgs(argv) {
     let changeAuditList;
     let changeAuditShow;
     let injectChangeAuditHunk;
+    let agentPluginInit = false;
+    let agentPluginSlug;
     // Short command aliases for the common path. Keep these positional-only so
     // long-form flags remain the single source of truth for option semantics.
     if (argv[0] && !argv[0].startsWith('-')) {
@@ -560,6 +566,11 @@ function parseArgs(argv) {
                 injectChangeAuditHunk = { id: next, cwd };
             argv = argv.slice(cwd ? 3 : 2);
         }
+        else if (command === 'ap' && next && !next.startsWith('-')) {
+            agentPluginInit = true;
+            agentPluginSlug = next;
+            argv = argv.slice(2);
+        }
     }
     for (let index = 0; index < argv.length; index += 1) {
         const arg = argv[index];
@@ -732,6 +743,17 @@ function parseArgs(argv) {
             index += cwd ? 2 : 1;
             continue;
         }
+        if (arg === '--agent-plugin-init') {
+            agentPluginInit = true;
+            const slug = argv[index + 1];
+            if (!slug || slug.startsWith('-')) {
+                console.error(`${ICON.err} ${c.red('--agent-plugin-init requires a slug')}`);
+                process.exit(1);
+            }
+            agentPluginSlug = slug;
+            index += 1;
+            continue;
+        }
         if (!arg.startsWith('-')) {
             if (attachTmux && !attachTmuxName) {
                 attachTmuxName = arg;
@@ -773,6 +795,8 @@ function parseArgs(argv) {
         changeAuditList,
         changeAuditShow,
         injectChangeAuditHunk,
+        agentPluginInit,
+        agentPluginSlug,
     };
 }
 // Reads a single line from stdin without echoing keystrokes. Used for password
@@ -2311,6 +2335,98 @@ async function refreshDefaultHttpsCertificateSafely() {
         return false;
     }
 }
+// ---------------------------------------------------------------------------
+// Agent plugin scaffolding
+// ---------------------------------------------------------------------------
+const VALID_PLUGIN_SLUG_RE = /^[a-z][a-z0-9-]*$/;
+async function runAgentPluginInit(slug) {
+    if (!VALID_PLUGIN_SLUG_RE.test(slug) || slug.length > 40) {
+        console.error(`${ICON.err} ${c.red(`Invalid slug: "${slug}"`)}`);
+        console.error('  Slug must be lowercase alphanumeric with hyphens, 1–40 chars (e.g. "my-agent").');
+        process.exit(1);
+    }
+    const pluginsDir = path.join(os.homedir(), '.termdock', 'agent-plugins');
+    const pluginDir = path.join(pluginsDir, slug);
+    if (fs.existsSync(pluginDir)) {
+        console.error(`${ICON.err} ${c.red(`Plugin "${slug}" already exists at ${pluginDir}`)}`);
+        console.error('  Remove it first or use a different slug.');
+        process.exit(1);
+    }
+    const manifest = {
+        version: 1,
+        slug,
+        displayName: slug, // user should rename
+        aliases: [slug],
+        accentColor: '#4385BE',
+        hooks: {
+            target: `~/.${slug}/settings.json`,
+            events: [
+                { hook: 'SessionStart', event: 'session-start' },
+                { hook: 'UserPromptSubmit', event: 'prompt-submit' },
+                { hook: 'Notification', event: 'notification' },
+                { hook: 'PostToolUse', event: 'tool-complete' },
+                { hook: 'Stop', event: 'stop' },
+                { hook: 'SessionEnd', event: 'session-end' },
+            ],
+        },
+        resume: {
+            command: `${slug} --resume {sessionId}`,
+            staleFlags: ['--resume', '-r', '--session'],
+        },
+    };
+    const iconSvg = `<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24" fill="none" stroke="white" stroke-width="2" stroke-linecap="round" stroke-linejoin="round">
+  <circle cx="12" cy="12" r="10"/>
+  <path d="M12 6v6l4 2"/>
+</svg>
+`;
+    fs.mkdirSync(pluginDir, { recursive: true });
+    fs.writeFileSync(path.join(pluginDir, 'manifest.json'), JSON.stringify(manifest, null, 2), 'utf8');
+    fs.writeFileSync(path.join(pluginDir, 'icon.svg'), iconSvg, 'utf8');
+    console.log(`${ICON.ok} Plugin scaffolded at ${c.cyan(pluginDir)}`);
+    console.log('');
+    console.log(`  ${c.bold('manifest.json')}  — agent identity, aliases, hook events, resume command`);
+    console.log(`  ${c.bold('icon.svg')}     — brand icon (SVG, used as CSS mask)`);
+    console.log('');
+    console.log(c.bold('Next steps:'));
+    console.log('');
+    console.log(`  1. Edit ${c.cyan(`"displayName"`)} — the human-readable label shown in the UI.`);
+    console.log(`  2. Check ${c.cyan(`"aliases"`)} — add all command names your agent uses.`);
+    console.log(`  3. Set ${c.cyan(`"accentColor"`)} to your agent's brand color (hex, e.g. "#FF6600").`);
+    console.log(`  4. Verify ${c.cyan(`"hooks.target"`)} — the path to your agent's own hooks config file.`);
+    console.log(`     Use ${c.dim('~')}-abbreviated absolute paths (e.g. ${c.dim('~/.claude/settings.json')}).`);
+    console.log(`  5. Map ${c.cyan(`"hooks.events"`)} — left side is your agent's event name,`);
+    console.log(`     right side is one of our sentinel events:`);
+    console.log('');
+    console.log('     ' + c.bold('Sentinel events (what they mean):'));
+    console.log(`       ${c.green('session-start')}       — agent session begins (resets state)`);
+    console.log(`       ${c.green('prompt-submit')}        — user sent a prompt (agent starts working)`);
+    console.log(`       ${c.green('permission-request')}   — agent is blocked, needs your approval`);
+    console.log(`       ${c.green('question-asked')}        — agent is blocked, needs your answer`);
+    console.log(`       ${c.green('notification')}         — agent nudged you (only escalates mid-turn)`);
+    console.log(`       ${c.green('tool-complete')}        — a tool finished (recovery from waiting)`);
+    console.log(`       ${c.green('stop')}                 — turn finished, agent idle`);
+    console.log(`       ${c.green('session-end')}          — agent session ended (keeps resume id)`);
+    console.log('');
+    console.log('     Optional per-event fields:');
+    console.log(`       ${c.dim('"matcher"')} — narrow the event by type (e.g. ${c.dim('"elicitation_dialog"')})`);
+    console.log(`       ${c.dim('"timeout"')} — hook timeout in seconds (default: no limit)`);
+    console.log('');
+    console.log(`  6. Replace ${c.cyan('icon.svg')} with your agent's brand icon (SVG, 24×24 viewBox).`);
+    console.log(`     The icon is rendered white-on-brand-color as a CSS mask.`);
+    console.log('');
+    console.log(`  7. Set the ${c.cyan('"resume.command"')} to your agent's session resume command.`);
+    console.log(`     Must contain ${c.dim('{sessionId}')} — replaced with the real id at runtime.`);
+    console.log('');
+    console.log('  After editing, restart termdock to load the plugin:');
+    console.log(`    ${c.cyan('td --stop && td')}`);
+    console.log('');
+    console.log('  Then go to Settings → Agent Hooks to install hooks for your agent.');
+    console.log('');
+    console.log('  For manual plugins from JSON, use the "Add Plugin" panel in Settings.');
+    console.log('');
+    console.log(c.dim('  Built-in agents with hook support live in src/server/agent/installers.ts'));
+    console.log(c.dim('  as a reference for more complex integrations (owned JS/TS files, etc.).'));
+}
 async function main() {
     if (options.setupLocalHttps) {
         try {
@@ -2362,6 +2478,10 @@ async function main() {
         await runInjectChangeAuditHunk(options.injectChangeAuditHunk);
         process.exit(0);
     }
+    if (options.agentPluginInit) {
+        await runAgentPluginInit(options.agentPluginSlug);
+        process.exit(0);
+    }
     if (options.setPassword) {
         await runSetPassword();
         process.exit(0);

package/dist/server/routes/filesystem.js

@@ -2795,10 +2795,9 @@ router.get('/diff', async (req, res) => {
                     args.push('--', pathspec);
                 return args;
             };
-            // Default sidebar diffs should represent every changed file from the list:
-            // staged-only changes, unstaged changes, and untracked files. Plain
-            // `git diff` only shows unstaged tracked edits, which made staged-only
-            // additions/deletions/renames look empty in the UI.
+            // Use `git diff HEAD` to present a merged view of all worktree changes
+            // (staged + unstaged) against HEAD. Untracked files are handled separately
+            // with `--no-index` below.
             let truncatedByGit = false;
             const readLimitedDiff = async (args, maxBytes = MAX_DIFF_BYTES) => {
                 const gitResult = await execGitLimited(args, gitCwd, maxBytes, false, controller.signal, { id: requestId, action, op: 'git.diff', path: requestedPath, extra: { traceId, interactionId, requestSlotId } });
@@ -2812,12 +2811,15 @@ router.get('/diff', async (req, res) => {
                     truncatedByGit = true;
                 return gitResult.stdout;
             };
+            const buildHeadDiffArgs = () => {
+                const args = ['diff', '-M', ...diffOptionArgs, 'HEAD'];
+                if (pathspec)
+                    args.push('--', pathspec);
+                return args;
+            };
             let diff = cached
                 ? await readLimitedDiff(buildDiffArgs(true))
-                : [
-                    await readLimitedDiff(buildDiffArgs(true)),
-                    await readLimitedDiff(buildDiffArgs(false)),
-                ].filter(Boolean).join('\n');
+                : await readLimitedDiff(buildHeadDiffArgs());
             let totalBytes = getDiffByteLength(diff);
             // If git diff produced no output for a specific file, it might be an
             // untracked (new) file.  Use `git diff --no-index /dev/null <path>` to