klyro 1.0.16 → 1.0.18

package/dist/shared/proxy.d.ts

@@ -0,0 +1,37 @@
+/**
+ * Proxy support (1.3): `HTTP_PROXY` / `HTTPS_PROXY` / `NO_PROXY` (either
+ * case) are honored for provider, web, and update fetches. No dependencies:
+ * plain-HTTP goes through the proxy as a forward absolute-URI request and
+ * HTTPS is tunneled with CONNECT + TLS, all on node:http/https/net/tls.
+ *
+ * Loopback destinations are never proxied. `NO_PROXY` supports exact hosts,
+ * leading-dot and bare suffixes, `*`, and IPv4 CIDR ranges. Only `http://`
+ * proxy URLs are supported (the standard CONNECT-proxy shape); anything
+ * else is treated as unconfigured.
+ */
+import * as net from 'node:net';
+export interface ProxyEndpoint {
+    host: string;
+    port: number;
+    /** `user:password` from the proxy URL userinfo, when present. */
+    auth?: string;
+}
+export interface ProxiedInit extends RequestInit {
+    /** Total-operation timeout (CONNECT, TLS handshake, and response). */
+    timeoutMs?: number;
+}
+/** Resolve the proxy for a URL, or null for a direct connection. */
+export declare function proxyForUrl(rawUrl: string, env?: NodeJS.ProcessEnv): ProxyEndpoint | null;
+/**
+ * Open a CONNECT tunnel to targetHost:targetPort through the proxy.
+ * Resolves with the tunnelled socket (paused); rejects on timeout, abort,
+ * proxy errors, or non-200 responses.
+ */
+export declare function tunnelSocket(targetHost: string, targetPort: number, proxy: ProxyEndpoint, timeoutMs: number, signal?: AbortSignal | null): Promise<net.Socket>;
+/**
+ * Drop-in fetch replacement: routes through HTTP(S)_PROXY when one applies,
+ * otherwise delegates to global fetch (byte-identical behavior, including
+ * redirect following). Follows up to 5 redirects in proxied mode unless
+ * `redirect: 'manual'` is set. Only `string | URL` inputs are supported.
+ */
+export declare function proxiedFetch(input: RequestInfo | URL, init?: ProxiedInit): Promise<Response>;

package/dist/shared/proxy.js

@@ -0,0 +1,360 @@
+/**
+ * Proxy support (1.3): `HTTP_PROXY` / `HTTPS_PROXY` / `NO_PROXY` (either
+ * case) are honored for provider, web, and update fetches. No dependencies:
+ * plain-HTTP goes through the proxy as a forward absolute-URI request and
+ * HTTPS is tunneled with CONNECT + TLS, all on node:http/https/net/tls.
+ *
+ * Loopback destinations are never proxied. `NO_PROXY` supports exact hosts,
+ * leading-dot and bare suffixes, `*`, and IPv4 CIDR ranges. Only `http://`
+ * proxy URLs are supported (the standard CONNECT-proxy shape); anything
+ * else is treated as unconfigured.
+ */
+import * as http from 'node:http';
+import * as https from 'node:https';
+import * as net from 'node:net';
+import * as tls from 'node:tls';
+const DEFAULT_TIMEOUT_MS = 30_000;
+const DEFAULT_PROXY_PORT = 8080;
+const MAX_REDIRECTS = 5;
+function isLoopbackHost(host) {
+    const h = host.toLowerCase().replace(/^\[|\]$/g, '');
+    if (h === 'localhost' || h === '127.0.0.1' || h === '::1')
+        return true;
+    if (h.startsWith('127.')) {
+        const parts = h.split('.');
+        return parts.length === 4 && parts.every((p) => /^\d+$/.test(p) && Number(p) >= 0 && Number(p) <= 255);
+    }
+    return false;
+}
+function ipv4ToInt(ip) {
+    const parts = ip.split('.');
+    if (parts.length !== 4 || !parts.every((p) => /^\d+$/.test(p) && Number(p) >= 0 && Number(p) <= 255))
+        return null;
+    return parts.reduce((acc, p) => acc * 256 + Number(p), 0) >>> 0;
+}
+function noProxyMatch(host, noProxy) {
+    const h = host.toLowerCase();
+    for (const rawEntry of noProxy.split(',')) {
+        const entry = rawEntry.trim().toLowerCase();
+        if (!entry)
+            continue;
+        if (entry === '*')
+            return true;
+        const name = entry.split(':')[0];
+        if (h === name || h.endsWith(`.${name.replace(/^\./, '')}`))
+            return true;
+        const slash = name.indexOf('/');
+        if (slash !== -1) {
+            const base = ipv4ToInt(name.slice(0, slash));
+            const bits = Number(name.slice(slash + 1));
+            const addr = ipv4ToInt(h);
+            if (base !== null && addr !== null && Number.isInteger(bits) && bits >= 0 && bits <= 32) {
+                const mask = bits === 0 ? 0 : (0xffffffff << (32 - bits)) >>> 0;
+                if ((addr & mask) === (base & mask))
+                    return true;
+            }
+        }
+    }
+    return false;
+}
+/** Resolve the proxy for a URL, or null for a direct connection. */
+export function proxyForUrl(rawUrl, env = process.env) {
+    let u;
+    try {
+        u = new URL(rawUrl);
+    }
+    catch {
+        return null;
+    }
+    if (u.protocol !== 'http:' && u.protocol !== 'https:')
+        return null;
+    const host = u.hostname.toLowerCase();
+    if (isLoopbackHost(host))
+        return null;
+    const noProxy = env.NO_PROXY ?? env.no_proxy ?? '';
+    if (noProxy && noProxyMatch(host, noProxy))
+        return null;
+    const raw = u.protocol === 'https:'
+        ? (env.HTTPS_PROXY ?? env.https_proxy ?? env.HTTP_PROXY ?? env.http_proxy)
+        : (env.HTTP_PROXY ?? env.http_proxy);
+    if (!raw)
+        return null;
+    let p;
+    try {
+        p = new URL(raw);
+    }
+    catch {
+        return null;
+    }
+    if (p.protocol !== 'http:' || !p.hostname)
+        return null;
+    const port = p.port ? Number(p.port) : DEFAULT_PROXY_PORT;
+    if (!Number.isInteger(port) || port <= 0 || port > 65535)
+        return null;
+    const auth = p.username ? `${decodeURIComponent(p.username)}:${decodeURIComponent(p.password)}` : undefined;
+    return { host: p.hostname, port, ...(auth ? { auth } : {}) };
+}
+function proxyAuthHeader(proxy) {
+    return proxy.auth ? { 'Proxy-Authorization': `Basic ${Buffer.from(proxy.auth, 'utf-8').toString('base64')}` } : {};
+}
+function abortError(signal) {
+    const reason = signal?.reason;
+    if (reason instanceof Error)
+        return reason;
+    return new Error('aborted');
+}
+function headersToRecord(headers) {
+    const out = {};
+    if (!headers)
+        return out;
+    if (headers instanceof Headers) {
+        headers.forEach((v, k) => { out[k.toLowerCase()] = v; });
+        return out;
+    }
+    if (Array.isArray(headers)) {
+        for (const [k, v] of headers)
+            out[String(k).toLowerCase()] = String(v);
+        return out;
+    }
+    for (const [k, v] of Object.entries(headers))
+        out[k.toLowerCase()] = String(v);
+    return out;
+}
+/**
+ * Open a CONNECT tunnel to targetHost:targetPort through the proxy.
+ * Resolves with the tunnelled socket (paused); rejects on timeout, abort,
+ * proxy errors, or non-200 responses.
+ */
+export function tunnelSocket(targetHost, targetPort, proxy, timeoutMs, signal) {
+    return new Promise((resolve, reject) => {
+        let done = false;
+        const fail = (err) => {
+            if (done)
+                return;
+            done = true;
+            clearTimeout(timer);
+            signal?.removeEventListener('abort', onAbort);
+            try {
+                sock.destroy();
+            }
+            catch { /* ignore */ }
+            reject(err);
+        };
+        const sock = net.connect(proxy.port, proxy.host);
+        const timer = setTimeout(() => fail(new Error(`proxy CONNECT to ${targetHost}:${targetPort} timed out after ${timeoutMs}ms`)), timeoutMs);
+        const onAbort = () => fail(abortError(signal));
+        if (signal?.aborted) {
+            clearTimeout(timer);
+            try {
+                sock.destroy();
+            }
+            catch { /* ignore */ }
+            reject(abortError(signal));
+            return;
+        }
+        signal?.addEventListener('abort', onAbort, { once: true });
+        let head = Buffer.alloc(0);
+        sock.on('connect', () => {
+            sock.write([`CONNECT ${targetHost}:${targetPort} HTTP/1.1`, `Host: ${targetHost}:${targetPort}`]
+                .concat(Object.entries(proxyAuthHeader(proxy)).map(([k, v]) => `${k}: ${v}`))
+                .concat(['', '']).join('\r\n'));
+        });
+        sock.on('data', (chunk) => {
+            head = Buffer.concat([head, chunk]);
+            const end = head.indexOf('\r\n\r\n');
+            if (end === -1) {
+                if (head.length > 8192)
+                    fail(new Error('proxy CONNECT response too long'));
+                return;
+            }
+            const statusLine = head.subarray(0, end).toString('latin1').split('\r\n')[0] ?? '';
+            const statusMatch = /HTTP\/\d+(?:\.\d+)?\s+(\d+)/.exec(statusLine);
+            const code = statusMatch ? Number(statusMatch[1]) : NaN;
+            if (done)
+                return;
+            done = true;
+            clearTimeout(timer);
+            signal?.removeEventListener('abort', onAbort);
+            sock.removeAllListeners('data');
+            if (code !== 200) {
+                try {
+                    sock.destroy();
+                }
+                catch { /* ignore */ }
+                reject(new Error(`proxy CONNECT rejected: ${statusLine.trim() || 'no status'}`));
+                return;
+            }
+            try {
+                sock.pause();
+            }
+            catch { /* ignore */ }
+            resolve(sock);
+        });
+        sock.on('error', (err) => fail(err instanceof Error ? err : new Error(String(err))));
+        sock.on('close', () => { if (!done)
+            fail(new Error('proxy connection closed')); });
+    });
+}
+function collectResponse(req, timeoutMs, signal) {
+    return new Promise((resolve, reject) => {
+        const timer = setTimeout(() => {
+            req.destroy(new Error(`request timed out after ${timeoutMs}ms`));
+        }, timeoutMs);
+        const onAbort = () => {
+            clearTimeout(timer);
+            req.destroy(abortError(signal));
+        };
+        if (signal?.aborted) {
+            clearTimeout(timer);
+            reject(abortError(signal));
+            return;
+        }
+        signal?.addEventListener('abort', onAbort, { once: true });
+        req.on('response', (res) => {
+            const chunks = [];
+            res.on('data', (c) => chunks.push(Buffer.isBuffer(c) ? c : Buffer.from(c)));
+            res.on('end', () => {
+                clearTimeout(timer);
+                signal?.removeEventListener('abort', onAbort);
+                const headers = new Headers();
+                const raw = res.headersDistinct ?? res.headers;
+                for (const [k, v] of Object.entries(raw)) {
+                    if (v === undefined)
+                        continue;
+                    headers.append(k, Array.isArray(v) ? v.join(', ') : String(v));
+                }
+                resolve(new Response(Buffer.concat(chunks), { status: res.statusCode ?? 500, statusText: res.statusMessage ?? '', headers }));
+            });
+            res.on('error', (err) => {
+                clearTimeout(timer);
+                signal?.removeEventListener('abort', onAbort);
+                reject(err instanceof Error ? err : new Error(String(err)));
+            });
+        });
+        req.on('error', (err) => {
+            clearTimeout(timer);
+            signal?.removeEventListener('abort', onAbort);
+            reject(err instanceof Error ? err : new Error(String(err)));
+        });
+    });
+}
+function bodyToBuffer(body) {
+    if (body === undefined || body === null)
+        return undefined;
+    if (typeof body === 'string')
+        return Buffer.from(body, 'utf-8');
+    if (Buffer.isBuffer(body))
+        return body;
+    if (body instanceof Uint8Array)
+        return Buffer.from(body);
+    if (body instanceof ArrayBuffer)
+        return Buffer.from(body);
+    throw new TypeError('proxiedFetch: unsupported body type');
+}
+async function requestViaProxy(url, method, headers, body, proxy, timeoutMs, signal) {
+    if (signal?.aborted)
+        throw abortError(signal);
+    if (url.protocol === 'http:') {
+        const target = `${url.hostname}${url.port ? `:${url.port}` : ''}`;
+        const req = http.request({
+            host: proxy.host,
+            port: proxy.port,
+            method,
+            path: url.href, // forward-proxy form: absolute URI
+            headers: { host: target, ...proxyAuthHeader(proxy), ...headers },
+            signal: signal ?? undefined,
+        });
+        const pending = collectResponse(req, timeoutMs, signal);
+        req.end(body);
+        return pending;
+    }
+    // https: — CONNECT tunnel, then TLS, then ordinary HTTPS on the socket.
+    const port = url.port ? Number(url.port) : 443;
+    const sock = await tunnelSocket(url.hostname, port, proxy, timeoutMs, signal);
+    if (signal?.aborted) {
+        try {
+            sock.destroy();
+        }
+        catch { /* ignore */ }
+        throw abortError(signal);
+    }
+    const tlsSock = tls.connect({ socket: sock, servername: url.hostname });
+    await new Promise((resolve, reject) => {
+        const cleanup = () => {
+            tlsSock.off('secureConnect', onSecure);
+            tlsSock.off('error', onErr);
+            signal?.removeEventListener('abort', onAbort);
+        };
+        const onAbort = () => {
+            cleanup();
+            try {
+                tlsSock.destroy(abortError(signal));
+            }
+            catch { /* ignore */ }
+            reject(abortError(signal));
+        };
+        const onSecure = () => { cleanup(); resolve(); };
+        const onErr = (err) => { cleanup(); reject(err); };
+        if (signal?.aborted)
+            return onAbort();
+        signal?.addEventListener('abort', onAbort, { once: true });
+        tlsSock.once('secureConnect', onSecure);
+        tlsSock.once('error', onErr);
+    });
+    const req = https.request({
+        host: url.hostname,
+        port,
+        path: `${url.pathname}${url.search}`,
+        method,
+        headers: { host: url.host, ...headers },
+        createConnection: () => tlsSock,
+        signal: signal ?? undefined,
+    });
+    const pending = collectResponse(req, timeoutMs, signal);
+    req.end(body);
+    return pending;
+}
+/**
+ * Drop-in fetch replacement: routes through HTTP(S)_PROXY when one applies,
+ * otherwise delegates to global fetch (byte-identical behavior, including
+ * redirect following). Follows up to 5 redirects in proxied mode unless
+ * `redirect: 'manual'` is set. Only `string | URL` inputs are supported.
+ */
+export async function proxiedFetch(input, init = {}) {
+    const { timeoutMs = DEFAULT_TIMEOUT_MS, redirect, ...rest } = init;
+    if (typeof input !== 'string' && !(input instanceof URL)) {
+        throw new TypeError('proxiedFetch: only string | URL inputs are supported');
+    }
+    let url = new URL(String(input));
+    let method = (rest.method ?? 'GET').toUpperCase();
+    const headers = headersToRecord(rest.headers);
+    let body = bodyToBuffer(rest.body);
+    const signal = rest.signal ?? undefined;
+    for (let hop = 0; hop <= MAX_REDIRECTS; hop++) {
+        const proxy = proxyForUrl(url.href);
+        let res;
+        if (!proxy) {
+            res = await globalThis.fetch(url.href, { ...rest, method, headers, body });
+        }
+        else {
+            res = await requestViaProxy(url, method, headers, body, proxy, timeoutMs, signal);
+        }
+        if (redirect === 'manual' || ![301, 302, 303, 307, 308].includes(res.status))
+            return res;
+        const loc = res.headers.get('location');
+        if (!loc)
+            return res;
+        try {
+            await res.arrayBuffer();
+        }
+        catch { /* ignore — drain best-effort */ }
+        url = new URL(loc, url.href);
+        if (res.status === 303 || ((res.status === 301 || res.status === 302) && method === 'POST')) {
+            method = 'GET';
+            body = undefined;
+            delete headers['content-length'];
+            delete headers['content-type'];
+        }
+    }
+    throw new Error('proxiedFetch: too many redirects');
+}

package/dist/tools/agent/task-list.d.ts

@@ -1,4 +1,4 @@
 export declare const taskListTool: import("../types.js").Tool<{
     parentTaskId?: string | undefined;
-    status?: "running" | "succeeded" | "failed" | "cancelled" | "timed_out" | "blocked" | "queued" | undefined;
+    status?: "succeeded" | "failed" | "cancelled" | "timed_out" | "blocked" | "running" | "queued" | undefined;
 }, import("../../agent/task-manager.js").TaskSummary[]>;

package/dist/tools/fs/apply-patch.js

@@ -154,8 +154,8 @@ async function guardWrite(cwd, relPath, resolved) {
 // before the write and refuse if the target moved. Compares canonicalized
 // forms (not raw strings) to avoid false positives from
 // lexical-vs-canonical spellings (e.g. `sub/../a.txt`, short names).
-async function assertSameTarget(cwd, relPath, resolved) {
-    const { resolved: reResolved } = await resolveAndFollowSymlinks(cwd, relPath);
+async function assertSameTarget(cwd, relPath, resolved, extraRoots) {
+    const { resolved: reResolved } = await resolveAndFollowSymlinks(cwd, relPath, extraRoots);
     const canon = async (p) => {
         try {
             return await fs.realpath(p);
@@ -216,7 +216,7 @@ export const applyPatchTool = defineTool({
                 if (ctx.repairGuard?.denyTestEdits && repairGuardHit(sec.path, sec.body.join('\n'))) {
                     throw Object.assign(new Error('repair-guard: test edits denied (denyTestEdits)'), { code: 'POLICY_DENIED' });
                 }
-                const { resolved } = await resolveAndFollowSymlinks(ctx.cwd, sec.path);
+                const { resolved } = await resolveAndFollowSymlinks(ctx.cwd, sec.path, ctx.agentAllowedPaths);
                 if (await allowedHit(ctx.cwd, resolved, ctx.agentAllowedPaths)) {
                     throw Object.assign(new Error(`agent path not allowed: ${resolved} (POLICY_DENIED)`), { code: 'POLICY_DENIED' });
                 }
@@ -240,7 +240,7 @@ export const applyPatchTool = defineTool({
                         .map((l) => l.slice(1))
                         .join('\n');
                     await guardWrite(ctx.cwd, sec.path, resolved);
-                    await assertSameTarget(ctx.cwd, sec.path, resolved);
+                    await assertSameTarget(ctx.cwd, sec.path, resolved, ctx.agentAllowedPaths);
                     await fs.mkdir(path.dirname(resolved), { recursive: true });
                     // Symlink-swap guard: refuse if the final dest became a symlink
                     // since the up-front resolve (lstat never follows the final link).

package/dist/tools/fs/edit-file.js

@@ -78,7 +78,7 @@ export const editFileTool = defineTool({
             const guard = checkRepairGuard(input.path, `${input.find}\n${input.replace}`, ctx.repairGuard?.denyTestEdits);
             if (guard)
                 return guard;
-            const { resolved } = await resolveAndFollowSymlinks(ctx.cwd, input.path);
+            const { resolved } = await resolveAndFollowSymlinks(ctx.cwd, input.path, ctx.agentAllowedPaths);
             const allowed = await checkAllowedPaths(ctx.cwd, resolved, ctx.agentAllowedPaths);
             if (allowed)
                 return allowed;
@@ -161,7 +161,7 @@ export const editFileTool = defineTool({
             // before the write and refuse if the target moved. Compares
             // canonicalized forms (not raw strings) to avoid false positives from
             // lexical-vs-canonical spellings (e.g. `sub/../a.txt`, short names).
-            const { resolved: reResolved } = await resolveAndFollowSymlinks(ctx.cwd, input.path);
+            const { resolved: reResolved } = await resolveAndFollowSymlinks(ctx.cwd, input.path, ctx.agentAllowedPaths);
             const canon = async (p) => {
                 try {
                     return await fs.realpath(p);
@@ -279,7 +279,6 @@ function findClosestMatch(text, needle) {
     const lines = text.split('\n');
     let bestIdx = 0;
     let bestScore = -1;
-    let bestSnippet = '';
     // Simple similarity: longest common substring ratio
     for (let i = 0; i < lines.length; i++) {
         const line = lines[i] ?? '';
@@ -296,7 +295,6 @@ function findClosestMatch(text, needle) {
         if (score > bestScore) {
             bestScore = score;
             bestIdx = i;
-            bestSnippet = line;
         }
     }
     const start = Math.max(0, bestIdx - 2);

package/dist/tools/fs/list-dir.js

@@ -22,7 +22,7 @@ export const listDirTool = defineTool({
     inputSchema: InputSchema,
     execute: async (input, ctx) => {
         return safe(async () => {
-            const { resolved } = await resolveAndFollowSymlinks(ctx.cwd, input.path);
+            const { resolved } = await resolveAndFollowSymlinks(ctx.cwd, input.path, ctx.agentAllowedPaths);
             const stat = await fs.stat(resolved);
             if (!stat.isDirectory()) {
                 return {

package/dist/tools/fs/multi-edit.js

@@ -69,7 +69,7 @@ export const multiEditTool = defineTool({
             const guard = checkRepairGuard(input.path, combined, ctx.repairGuard?.denyTestEdits);
             if (guard)
                 return guard;
-            const { resolved } = await resolveAndFollowSymlinks(ctx.cwd, input.path);
+            const { resolved } = await resolveAndFollowSymlinks(ctx.cwd, input.path, ctx.agentAllowedPaths);
             const allowed = await checkAllowedPaths(ctx.cwd, resolved, ctx.agentAllowedPaths);
             if (allowed)
                 return allowed;
@@ -94,7 +94,7 @@ export const multiEditTool = defineTool({
             // before the write and refuse if the target moved. Compares
             // canonicalized forms (not raw strings) to avoid false positives from
             // lexical-vs-canonical spellings (e.g. `sub/../a.txt`, short names).
-            const { resolved: reResolved } = await resolveAndFollowSymlinks(ctx.cwd, input.path);
+            const { resolved: reResolved } = await resolveAndFollowSymlinks(ctx.cwd, input.path, ctx.agentAllowedPaths);
             const canon = async (p) => {
                 try {
                     return await fs.realpath(p);

package/dist/tools/fs/read-file.js

@@ -36,7 +36,7 @@ export const readFileTool = defineTool({
     renderResult: (output) => `${output.path} (${output.totalLines} lines, ${output.bytesRead} bytes${output.truncated ? ' truncated' : ''})`,
     execute: async (input, ctx) => {
         return safe(async () => {
-            const { resolved } = await resolveAndFollowSymlinks(ctx.cwd, input.path);
+            const { resolved } = await resolveAndFollowSymlinks(ctx.cwd, input.path, ctx.agentAllowedPaths);
             const maxBytes = input.maxBytes ?? DEFAULT_MAX_BYTES;
             const stat = await fs.stat(resolved);
             if (!stat.isFile()) {

package/dist/tools/fs/write-file.js

@@ -68,7 +68,7 @@ export const writeFileTool = defineTool({
             const guard = checkRepairGuard(input.path, input.content, ctx.repairGuard?.denyTestEdits);
             if (guard)
                 return guard;
-            const { resolved } = await resolveAndFollowSymlinks(ctx.cwd, input.path);
+            const { resolved } = await resolveAndFollowSymlinks(ctx.cwd, input.path, ctx.agentAllowedPaths);
             const allowed = await checkAllowedPaths(ctx.cwd, resolved, ctx.agentAllowedPaths);
             if (allowed)
                 return allowed;
@@ -96,7 +96,7 @@ export const writeFileTool = defineTool({
             // the re-resolution is canonical (parent now exists), so compare
             // canonicalized forms — not raw strings — to avoid false positives
             // (e.g. Windows 8.3 short-name expansion after mkdir).
-            const { resolved: reResolved } = await resolveAndFollowSymlinks(ctx.cwd, input.path);
+            const { resolved: reResolved } = await resolveAndFollowSymlinks(ctx.cwd, input.path, ctx.agentAllowedPaths);
             const canon = async (p) => {
                 try {
                     return await fs.realpath(p);

package/dist/tools/git/git-blame.d.ts

@@ -0,0 +1,5 @@
+export declare const gitBlameTool: import("../types.js").Tool<{
+    path: string;
+}, {
+    readonly blame: string;
+}>;

package/dist/tools/git/git-blame.js

@@ -0,0 +1,22 @@
+import { z } from 'zod';
+import { defineTool } from '../types.js';
+import { safe } from '../normalize.js';
+import { runGit } from './run-git.js';
+const InputSchema = z.object({
+    path: z.string().min(1).describe('File path to blame'),
+});
+export const gitBlameTool = defineTool({
+    name: 'git_blame',
+    description: 'Show git blame for a file, line by line. Read-only.',
+    inputSchema: InputSchema,
+    permission: 'read',
+    isConcurrencySafe: true,
+    execute: async (input, ctx) => {
+        return safe(async () => {
+            const res = await runGit(['blame', '--', input.path], ctx.cwd);
+            if (res.code !== 0)
+                throw new Error(res.err || `git blame failed`);
+            return { blame: res.out };
+        });
+    },
+});

package/dist/tools/git/git-diff.js

@@ -2,31 +2,14 @@
  * git_diff — show unstaged (`git diff`) or staged (`git diff --cached`)
  * changes plus a compact per-file stat. Read-only.
  */
-import { spawn } from 'node:child_process';
 import { z } from 'zod';
 import { defineTool } from '../types.js';
 import { safe, TOOL_ERROR_CODES } from '../normalize.js';
+import { runGit } from './run-git.js';
 const InputSchema = z.object({
     staged: z.boolean().optional().describe('Show staged changes instead of unstaged (default false)'),
     path: z.string().optional().describe('Limit to a specific path'),
 });
-function run(args, cwd, timeoutMs = 15_000) {
-    return new Promise((resolve) => {
-        const child = spawn('git', args, { cwd, stdio: ['ignore', 'pipe', 'pipe'], windowsHide: true, shell: false });
-        const out = [];
-        const err = [];
-        const timer = setTimeout(() => { try {
-            child.kill('SIGKILL');
-        }
-        catch { /* noop */ } }, timeoutMs);
-        child.stdout.on('data', (b) => out.push(b));
-        child.stderr.on('data', (b) => err.push(b));
-        child.on('close', (code) => {
-            clearTimeout(timer);
-            resolve({ code: code ?? 1, out: Buffer.concat(out).toString('utf-8'), err: Buffer.concat(err).toString('utf-8') });
-        });
-    });
-}
 export const gitDiffTool = defineTool({
     name: 'git_diff',
     description: 'Show the unified diff of working-tree changes (unstaged by default) or staged changes. Read-only. Returns the diff text, a per-file stat, and the list of changed file paths.',
@@ -37,7 +20,7 @@ export const gitDiffTool = defineTool({
             const args = [...base, '--no-color'];
             if (input.path)
                 args.push('--', input.path);
-            const diff = await run(args, ctx.cwd);
+            const diff = await runGit(args, ctx.cwd);
             if (diff.code !== 0) {
                 return {
                     ok: false,
@@ -47,7 +30,7 @@ export const gitDiffTool = defineTool({
             const statArgs = [...base, '--stat', '--no-color'];
             if (input.path)
                 statArgs.push('--', input.path);
-            const stat = await run(statArgs, ctx.cwd);
+            const stat = await runGit(statArgs, ctx.cwd);
             // Parse changed file paths from `diff --git a/... b/...` lines.
             const patchedFiles = [];
             const newline = /\r?\n/;

package/dist/tools/git/git-log.js

@@ -1,7 +1,7 @@
 import { z } from 'zod';
 import { defineTool } from '../types.js';
 import { safe } from '../normalize.js';
-import { spawn } from 'node:child_process';
+import { runGit } from './run-git.js';
 const InputSchema = z.object({
     limit: z.number().int().min(1).max(100).optional().describe('Number of commits'),
     path: z.string().optional().describe('Filter by path'),
@@ -17,24 +17,10 @@ export const gitLogTool = defineTool({
             const args = ['log', '--oneline', `-${input.limit ?? 20}`];
             if (input.path)
                 args.push('--', input.path);
-            const out = await runGit(args, ctx.cwd);
-            return { log: out };
+            const res = await runGit(args, ctx.cwd);
+            if (res.code !== 0)
+                throw new Error(res.err || `git log failed`);
+            return { log: res.out };
         });
     },
 });
-function runGit(args, cwd) {
-    return new Promise((resolve, reject) => {
-        const child = spawn('git', args, { cwd, shell: false, windowsHide: true });
-        let out = '';
-        let err = '';
-        child.stdout.on('data', (b) => { out += b.toString(); });
-        child.stderr.on('data', (b) => { err += b.toString(); });
-        child.on('error', reject);
-        child.on('close', (code) => {
-            if (code === 0)
-                resolve(out);
-            else
-                reject(new Error(err || `git ${args[0]} failed`));
-        });
-    });
-}

package/dist/tools/git/git-show.d.ts

@@ -0,0 +1,5 @@
+export declare const gitShowTool: import("../types.js").Tool<{
+    target: string;
+}, {
+    readonly content: string;
+}>;