@ai-projector/ide 0.0.0-stage → 0.11.1

package/packages/server/modules/agent/hosted-process.js

@@ -0,0 +1,279 @@
+import { EventEmitter } from "node:events";
+import { closeSync, openSync } from "node:fs";
+import { readFile, writeFile } from "node:fs/promises";
+import net from "node:net";
+import { join } from "node:path";
+import { PassThrough, Writable } from "node:stream";
+import { setTimeout as sleep } from "node:timers/promises";
+import { fileURLToPath } from "node:url";
+import { os, } from "../../../core/modules/os/index.js";
+import { rememberHost, runDirectory } from "./agent-runs.js";
+const HOST_SCRIPT = fileURLToPath(new URL("../../../cli/app/agent-host.js", import.meta.url));
+/** How long a freshly started host gets to open its socket. */
+const START_TIMEOUT_MS = 8000;
+const STOP_TIMEOUT_MS = 5000;
+const isRequest = (message) => !!message && message.method !== undefined && message.id !== undefined;
+const idKey = (message) => JSON.stringify(message.id);
+function parse(line) {
+    const mark = line[0];
+    if (mark !== "<" && mark !== ">" && mark !== "!")
+        return undefined;
+    const text = line.slice(2);
+    try {
+        return { mark, text, message: JSON.parse(text) };
+    }
+    catch {
+        return { mark, text };
+    }
+}
+/**
+ * Start a hosted agent: `agent-host.ts` keeps the process and the log of its JSON-RPC traffic
+ * outside this server, which only holds a socket to it. The returned process behaves like a
+ * spawned one for `createAcpConnection`.
+ */
+export async function startHosted(runId, spec) {
+    const dir = runDirectory(runId);
+    await writeFile(join(dir, "spec.json"), JSON.stringify({ ...os.tools.agentLaunch(spec), cwd: spec.cwd }), { mode: 0o600 });
+    const address = os.tools.agentHostAddress(dir);
+    const log = openSync(join(dir, "host.log"), "a");
+    let pid;
+    try {
+        pid = os.tools.spawnAgentHost({
+            script: HOST_SCRIPT,
+            dir,
+            address,
+            env: spec.env ?? {},
+            log,
+        });
+    }
+    finally {
+        closeSync(log);
+    }
+    if (!pid)
+        throw new Error("Не удалось запустить процесс агента");
+    await rememberHost(runId, pid);
+    const deadline = Date.now() + START_TIMEOUT_MS;
+    while (true) {
+        try {
+            return await openHosted(dir, address);
+        }
+        catch (error) {
+            if (Date.now() > deadline || (await os.processes.identity(pid)) === null) {
+                const tail = (await readFile(join(dir, "host.log"), "utf8").catch(() => "")).trim();
+                const trace = (await readFile(join(dir, "trace.log"), "utf8").catch(() => "")).trim();
+                const detail = tail || trace;
+                throw new Error(detail ? `Не удалось запустить агента: ${detail.slice(-800)}` : String(error));
+            }
+            await sleep(40);
+        }
+    }
+}
+/** Rejoin a run of an earlier server: its whole traffic is replayed to the new connection. */
+export function attachHosted(runId) {
+    const dir = runDirectory(runId);
+    return openHosted(dir, os.tools.agentHostAddress(dir), true);
+}
+function connect(address) {
+    return new Promise((resolve) => {
+        const socket = net.connect(address);
+        socket.once("connect", () => resolve(socket));
+        socket.once("error", () => resolve(undefined));
+    });
+}
+/**
+ * The server side of a hosted agent. The host sends its trace (every line so far, in order), then
+ * a `live` marker, then new lines. A fresh run has an empty trace; a rejoined one is replayed:
+ * agent lines are handed to the new connection in order, but each request the earlier server had
+ * written waits for the new connection to write it again and is *not* sent to the agent a second
+ * time, and permission questions that were already answered are neither shown nor repeated.
+ */
+async function openHosted(dir, address, tolerateMissingHost = false) {
+    const socket = await connect(address);
+    if (!socket && !tolerateMissingHost)
+        throw new Error("Хост агента не отвечает");
+    // A finished run has no host any more, but its trace on disk replays the same way.
+    const offline = socket
+        ? undefined
+        : await readFile(join(dir, "trace.log"), "utf8").catch(() => null);
+    if (offline === null)
+        throw new Error("Ход не найден");
+    const child = new EventEmitter();
+    const stdout = new PassThrough({ encoding: "utf8" });
+    const stderr = new PassThrough({ encoding: "utf8" });
+    const queue = [];
+    let answered = new Set();
+    const pendingWrites = [];
+    let live = false;
+    let markLive = () => { };
+    const ready = new Promise((resolve) => {
+        markLive = resolve;
+    });
+    let closed = false;
+    let replaced = false;
+    let inbound = "";
+    let outbound = "";
+    /** Events wait for the listeners: a rejoined run may already end while it is being replayed. */
+    const emitLater = (event, ...args) => setImmediate(() => child.emit(event, ...args));
+    const fail = (message) => {
+        emitLater("error", new Error(message));
+        finish();
+    };
+    function finish(stderrTail = "") {
+        if (closed)
+            return;
+        closed = true;
+        if (stderrTail)
+            stderr.write(stderrTail);
+        socket?.destroy();
+        // After the stderr tail has reached its listener, so the failure message can quote it.
+        emitLater("close", null, null);
+    }
+    /** Delivers what can be delivered; stops at a request the new connection has not written yet. */
+    function pump() {
+        while (queue.length && !closed) {
+            const entry = queue[0];
+            if (entry.mark === "!") {
+                queue.shift();
+                const event = (entry.message ?? {});
+                if (event.replaced)
+                    replaced = true;
+                if (event.error)
+                    emitLater("error", Object.assign(new Error(event.error.message), event.error));
+                if (event.exit || event.error || event.replaced)
+                    finish(event.exit?.stderr);
+                continue;
+            }
+            if (entry.mark === "<") {
+                queue.shift();
+                if (isRequest(entry.message) && answered.has(idKey(entry.message)))
+                    continue;
+                stdout.write(`${entry.text}\n`);
+                continue;
+            }
+            queue.shift();
+            if (!isRequest(entry.message))
+                continue; // an answer given to a request that is skipped above
+            const line = pendingWrites.shift();
+            if (line === undefined) {
+                queue.unshift(entry);
+                return;
+            }
+            const written = parse(`> ${line}`)?.message;
+            if (written?.method !== entry.message.method || written?.id !== entry.message.id)
+                return fail("Ход нельзя восстановить: запросы не совпали с прежними");
+        }
+        if (live) {
+            for (const line of pendingWrites.splice(0))
+                socket?.write(`${line}\n`);
+        }
+    }
+    function accept(line) {
+        const entry = parse(line);
+        if (!entry)
+            return;
+        if (entry.mark === "!" && entry.message?.live === true) {
+            answered = new Set(queue
+                .filter((item) => item.mark === ">" && item.message && !item.message.method)
+                .map((item) => idKey(item.message)));
+            live = true;
+            markLive();
+        }
+        else
+            queue.push(entry);
+        pump();
+    }
+    const feed = (chunk) => {
+        inbound += chunk;
+        let end;
+        while ((end = inbound.indexOf("\n")) !== -1) {
+            const line = inbound.slice(0, end);
+            inbound = inbound.slice(end + 1);
+            if (line)
+                accept(line);
+        }
+    };
+    const stdin = new Writable({
+        write(chunk, _encoding, callback) {
+            outbound += String(chunk);
+            let end;
+            while ((end = outbound.indexOf("\n")) !== -1) {
+                const line = outbound.slice(0, end);
+                outbound = outbound.slice(end + 1);
+                if (line)
+                    pendingWrites.push(line);
+            }
+            pump();
+            callback();
+        },
+    });
+    Object.assign(child, {
+        stdin,
+        stdout,
+        stderr,
+        pid: undefined,
+        exitCode: null,
+        signalCode: null,
+        kill: () => void child.terminate(),
+        /** Stops the agent unless a newer server took the run over, in which case only this link closes. */
+        async terminate() {
+            if (closed)
+                return;
+            const done = new Promise((resolve) => child.once("close", () => resolve()));
+            if (replaced)
+                return finish();
+            const pid = await hostedPid(dir);
+            if (pid)
+                os.tools.killAgentTree(pid);
+            else
+                return finish();
+            await Promise.race([done, sleep(STOP_TIMEOUT_MS)]);
+            finish();
+        },
+        /** Lets go of the run without stopping it: the next server rejoins it. */
+        detach: () => finish(),
+    });
+    if (socket) {
+        socket.setEncoding("utf8");
+        socket.on("data", feed);
+        socket.on("error", () => { });
+        socket.on("close", () => {
+            if (!closed) {
+                queue.push({ mark: "!", text: "", message: { exit: { stderr: "" } } });
+                pump();
+            }
+        });
+        let timer;
+        await Promise.race([
+            ready,
+            new Promise((resolve) => {
+                timer = setTimeout(resolve, START_TIMEOUT_MS);
+            }),
+        ]);
+        clearTimeout(timer);
+        if (!live) {
+            socket.destroy();
+            throw new Error("Хост агента не ответил");
+        }
+    }
+    else {
+        // The host is gone: replay the trace as it ended, with a synthetic end if the run was cut short.
+        setImmediate(() => {
+            feed(offline);
+            feed('! {"live":true}\n');
+            if (!closed) {
+                queue.push({ mark: "!", text: "", message: { exit: { stderr: "" } } });
+                pump();
+            }
+        });
+    }
+    return child;
+}
+async function hostedPid(dir) {
+    try {
+        const { pid, identity } = JSON.parse(await readFile(join(dir, "process.json"), "utf8"));
+        return (await os.processes.identity(pid)) === identity ? pid : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}

package/packages/server/modules/agent/hosted-run.js

@@ -0,0 +1,85 @@
+import { randomUUID } from "node:crypto";
+import { createInterface } from "node:readline";
+import { relayRequest, unrelayRequests } from "./command-bridge.js";
+import { runDirectory } from "./agent-runs.js";
+import { attachHosted, startHosted } from "./hosted-process.js";
+import { registerInjector } from "./injection.js";
+/**
+ * The answer of a hosted run: its runner (see `hosted-runner.ts`) keeps going while this server is
+ * away, so the answer is followed through the host's trace. Questions for the user are relayed to
+ * the client; the answers come back through `completeCommandRequest` and are written to the runner.
+ * `injectable` is the message id a follow-up written during the answer is delivered to.
+ */
+export async function runHostedAgent(options, handle, launch, injectable) {
+    const proc = handle.attach
+        ? await attachHosted(handle.id)
+        : await startHosted(handle.id, {
+            command: process.execPath,
+            args: [launch.runner, runDirectory(handle.id)],
+            cwd: launch.cwd,
+            env: launch.env,
+            // A Node script with an absolute path needs no cmd.exe; its args may contain spaces.
+            shell: false,
+        });
+    const relayedIds = [];
+    const injections = new Map();
+    // An answer that arrives after the run ended has nothing to reach: it is dropped.
+    const answer = (id, result) => {
+        if (proc.stdin.writable)
+            proc.stdin.write(`${JSON.stringify({ id, result })}\n`);
+    };
+    const lines = createInterface({ input: proc.stdout });
+    lines.on("line", (line) => {
+        let message;
+        try {
+            message = JSON.parse(line);
+        }
+        catch {
+            // Not a line the runner writes: nothing to show, and it must not take the server down.
+            return;
+        }
+        if (message.id && typeof message.accepted === "boolean") {
+            injections.get(message.id)?.(message.accepted);
+            injections.delete(message.id);
+        }
+        else if (message.method && message.id !== undefined) {
+            const id = String(message.id);
+            relayedIds.push(id);
+            relayRequest(id, (result) => answer(id, result));
+            options.emit(message.method, message.params);
+        }
+        else if (message.event)
+            options.emit(message.event, message.data);
+    });
+    // A message the user adds during the answer goes to the runner's input.
+    const unregister = injectable
+        ? registerInjector(injectable, (text, inputId) => {
+            if (!proc.stdin.writable)
+                return false;
+            const id = randomUUID();
+            return new Promise((resolve) => {
+                injections.set(id, resolve);
+                proc.stdin.write(`${JSON.stringify({ id, method: "inject", params: { messageId: injectable, text, inputId } })}\n`);
+            });
+        })
+        : undefined;
+    const stop = () => void proc.terminate();
+    options.abort?.addEventListener("abort", stop, { once: true });
+    if (options.abort?.aborted)
+        stop();
+    try {
+        await new Promise((resolve, reject) => {
+            proc.once("error", reject);
+            proc.once("close", () => resolve());
+        });
+    }
+    finally {
+        options.abort?.removeEventListener("abort", stop);
+        unregister?.();
+        for (const resolve of injections.values())
+            resolve(false);
+        injections.clear();
+        unrelayRequests(relayedIds);
+        lines.close();
+    }
+}

package/packages/server/modules/agent/hosted-runner.js

@@ -0,0 +1,126 @@
+// The process side of a hosted run: one agent answer, held by its own process so that a server
+// restart or a hot reload leaves it going. `agent-host.ts` keeps this process and its trace (see
+// `hosted-process.ts`); the server only relays what it prints and the answers it reads.
+//
+// Lines on stdout are either
+//   {"event": name, "data": data}                  an event of the answer, shown as it is
+//   {"id": id, "method": name, "params": data}     a question for the user, answered by the server
+// and lines on stdin are either
+//   {"id": id, "result": {output|error}}           the user's answer to such a question
+//   {"method": "inject", "params": {...}}          a message the user added while the answer runs
+import { readFile } from "node:fs/promises";
+import { join } from "node:path";
+import { createInterface } from "node:readline";
+import { completeCommandRequest, createApprovalBridge, createCommandBridge, createQuestionBridge, createSecretBridge, } from "./command-bridge.js";
+import { injectMessage } from "./injection.js";
+import { resolveJudgeSettings } from "../../../core/modules/agent-judge/index.js";
+import { createJudgedApproval, readJudgeSettings } from "../judge/index.js";
+const REQUESTS = new Set([
+    "permission-request",
+    "question-request",
+    "command-request",
+    "secret-request",
+]);
+/** After the host's stop signal the agent gets this long to end its tools before the process goes. */
+const STOP_GRACE_MS = 2000;
+const write = (line) => process.stdout.write(`${JSON.stringify(line)}\n`);
+const emit = (event, data) => {
+    const id = data?.id;
+    if (REQUESTS.has(event) && typeof id === "string")
+        write({ id, method: event, params: data });
+    else
+        write({ event, data });
+};
+/**
+ * Runs `answer` with the request the server stored in the run directory (`process.argv[2]`) and
+ * ends the process when it is done. The host stops a run with SIGTERM: the answer's `abort` signal
+ * fires so tools can end what they started, and the process leaves after a short grace.
+ */
+export function runHostedRunner(answer) {
+    main(answer).then(() => process.exit(0), (error) => {
+        write({
+            event: "error",
+            data: { error: error instanceof Error ? error.message : String(error) },
+        });
+        process.exit(1);
+    });
+}
+async function main(answer) {
+    const dir = process.argv[2];
+    if (!dir)
+        throw new Error("Usage: <runner> <run directory>");
+    const record = JSON.parse(await readFile(join(dir, "run.json"), "utf8"));
+    const controller = new AbortController();
+    const signal = controller.signal;
+    // The host signals the group and then the runner itself: a second SIGTERM must not hit the
+    // default action before the tools have ended what they started, so the handler stays.
+    process.on("SIGTERM", () => {
+        if (controller.signal.aborted)
+            return;
+        controller.abort();
+        setTimeout(() => process.exit(143), STOP_GRACE_MS).unref();
+    });
+    createInterface({ input: process.stdin }).on("line", async (line) => {
+        if (!line.trim())
+            return;
+        const message = JSON.parse(line);
+        if (message.method === "inject") {
+            if (message.params?.messageId && typeof message.params.text === "string")
+                write({
+                    id: message.id,
+                    accepted: await injectMessage(message.params.messageId, message.params.text, message.params.inputId),
+                });
+        }
+        else if (typeof message.id === "string" && message.result) {
+            completeCommandRequest(message.id, message.result);
+        }
+    });
+    const approval = record.approvals
+        ? createApprovalBridge((event, data) => emit(event, data), signal)
+        : undefined;
+    const approve = approval
+        ? createJudgedApproval({
+            approve: approval,
+            emit: (event, data) => emit(event, data),
+            settings: resolveJudgeSettings(await readJudgeSettings(), record.judge),
+            cwd: record.cwd,
+            backend: record.backend,
+            signal,
+        })
+        : undefined;
+    const options = {
+        backend: record.backend,
+        permissionMode: record.permissionMode,
+        selection: record.selection,
+        role: record.role,
+        message: record.message,
+        parts: record.parts,
+        projectId: record.projectId,
+        cwd: record.cwd,
+        history: record.history,
+        features: record.features,
+        judge: record.judge,
+        sessionId: record.sessionId,
+        messageId: record.messageId,
+        tail: record.tail,
+        providerId: record.providerId,
+        abort: signal,
+        emit,
+        ...(record.approvals
+            ? {
+                approve,
+                ask: createQuestionBridge((event, data) => emit(event, data), signal),
+                secret: createSecretBridge((event, data) => emit(event, data), signal),
+            }
+            : {}),
+        ...(record.commandBridge
+            ? { commands: createCommandBridge((event, data) => emit(event, data), signal) }
+            : {}),
+    };
+    try {
+        await answer(options);
+    }
+    catch (error) {
+        emit("error", { error: error instanceof Error ? error.message : String(error) });
+    }
+}

package/packages/server/modules/agent/index.js

@@ -0,0 +1,35 @@
+// The generic core of the chat agents: the backend contract, the registry the backends join, the
+// runs that outlive a request, the bridges that ask the user, and the chat history. Nothing here
+// names a concrete agent; each agent module (`../acp`, `../claude-code`, ...) registers itself.
+export { registerAgentBackend, listAgentBackends, isAgentBackend, resolveAgentBackend, isHostedAgent, isAgentAvailable, } from "./registry.js";
+export { agentCapabilities, agentCommands, agentControls, agentMcpServers, agentSessions, loadAgentSession, rewindAgentFiles, runAgent, updateAgentSession, deleteAgentSession, } from "./registry.js";
+export { selectionFrom, SESSION_LIST_LIMIT } from "./controls.js";
+export { createReplay } from "./replay.js";
+export { injectMessage, registerInjector } from "./injection.js";
+export { agentEnv, assertHostProject, attachedImages, promptWithHistory } from "./agent-host.js";
+export { attachHosted, startHosted } from "./hosted-process.js";
+export { driveRun, isRunDriven, joinRun } from "./run-hub.js";
+export { handleAgentRun } from "./run-request.js";
+export { runHostedAgent } from "./hosted-run.js";
+export { runHostedRunner } from "./hosted-runner.js";
+export { cancelRun, createRun, listLiveRuns, pruneRuns, readRun, rememberSession, removeRun, rememberHost, runDirectory, schedulePrune, stopRun, trackRun, } from "./agent-runs.js";
+export { completeCommandRequest, createApprovalBridge, createCommandBridge, createQuestionBridge, createSecretBridge, relayRequest, unrelayRequests, } from "./command-bridge.js";
+export { projectDirectory, pushSecretToPage, runSecretScript, SECRET_SHOW_LIMITS, SecretScriptError, } from "./secret-show.js";
+export { readAttachment, saveAttachment } from "./attachments.js";
+export { readAgentHistory, writeAgentHistory } from "./history.js";
+export { readAgentUsage } from "./usage-history.js";
+export { chatMetaOf, chatTitle, closeHistoryStore, readChatFeatures, } from "./history-store.js";
+export { readChatJudge } from "./judge-store.js";
+export { readChatQueue } from "./queue-store.js";
+export { readChatRole } from "./role-store.js";
+export { forgetChat, readRecentChats, removeChatsWithSession, } from "./recent-chats.js";
+export { archiveLiveChat, listArchivedChats, openArchivedChat, removeArchivedChat, renameArchivedChat, } from "./chat-archive.js";
+export { createWorktree, forkWorktree, mergeWorktree, removeWorktree, worktreeCwd, worktreeStatus, } from "./worktrees.js";
+export { answerJob, isFinished, listJobs, readJob, recoverJobs, removeJob, startJob, stopJob, waitForJob, } from "./jobs.js";
+export { forkJob, retryJob, settleJobWorktree } from "./jobs-worktree.js";
+export { followUpJob } from "./jobs-followup.js";
+export { jobDiff, PATCH_LIMIT } from "./jobs-diff.js";
+export { trackEventStream, detachEventStream, bindAgentEventStreams } from "./event-streams.js";
+export { requestFrom } from "./request.js";
+export { sideRequestFrom } from "./side-request.js";
+export { lensRequestFrom } from "./lens-request.js";

package/packages/server/modules/agent/injection.js

@@ -0,0 +1,14 @@
+/** Messages the user adds while an answer is running, by the ID of the message that started it. */
+const injectors = new Map();
+/** Adds a message to the answer running for `messageId`; `false` when it has already finished. */
+export function injectMessage(messageId, text, inputId) {
+    return injectors.get(messageId)?.(text, inputId) ?? false;
+}
+/** A run that can take messages mid-answer registers how to add one; the returned function forgets it. */
+export function registerInjector(messageId, inject) {
+    injectors.set(messageId, inject);
+    return () => {
+        if (injectors.get(messageId) === inject)
+            injectors.delete(messageId);
+    };
+}

package/packages/server/modules/agent/jobs-diff.js

@@ -0,0 +1,114 @@
+import { execFile } from "node:child_process";
+import { stat } from "node:fs/promises";
+import { promisify } from "node:util";
+const run = promisify(execFile);
+const MAX_BUFFER = 16 * 1024 * 1024;
+/** The patch the agent reads: enough for a review, small enough for a model answer. */
+export const PATCH_LIMIT = 60_000;
+const SECRET_NAMES = new Set([".ssh", ".aws", ".npmrc", ".netrc", ".git-credentials"]);
+const SECRET_PATTERNS = [/(^\.|\.)env($|\.)/i, /\.(pem|key)$/i, /^id_(rsa|ed25519)/i, /\.kdbx$/i];
+const secretPath = (path) => path
+    .split("/")
+    .some((segment) => SECRET_NAMES.has(segment.toLowerCase()) ||
+    SECRET_PATTERNS.some((pattern) => pattern.test(segment)));
+async function git(cwd, args) {
+    return (await run("git", args, { cwd, maxBuffer: MAX_BUFFER })).stdout;
+}
+/** `git diff --no-index` exits with 1 when files differ: its stdout is still the patch. */
+async function noIndex(cwd, path) {
+    try {
+        return (await run("git", ["--no-pager", "diff", "--no-index", "--", "/dev/null", path], {
+            cwd,
+            maxBuffer: MAX_BUFFER,
+        })).stdout;
+    }
+    catch (error) {
+        const stdout = error.stdout;
+        return typeof stdout === "string" ? stdout : "";
+    }
+}
+/**
+ * What a job changed in its folder. A job may have committed, staged or left files untracked, so
+ * the patch is taken against HEAD and new files are appended as diffs from `/dev/null`.
+ */
+export async function jobDiff(cwd, limit = PATCH_LIMIT, base, dirty = []) {
+    if (!(await stat(cwd).catch(() => null))?.isDirectory())
+        throw new Error("Папка задания не найдена");
+    const cap = Math.min(Math.max(Math.trunc(limit) || PATCH_LIMIT, 1000), 200_000);
+    const from = base || "HEAD";
+    const dirtySet = new Set(dirty);
+    // Paths that were already dirty when the job started are the user's work, not the job's.
+    const paths = [".", ...dirty.map((path) => `:(exclude,literal)${path}`)];
+    const files = new Set();
+    let summary = "";
+    let patch = "";
+    try {
+        const output = await git(cwd, [
+            "--no-pager",
+            "diff",
+            from,
+            "--name-status",
+            "-z",
+            "--",
+            ...paths,
+        ]);
+        const parts = output.split("\0").filter(Boolean);
+        const changed = [];
+        const secrets = new Set();
+        for (let index = 0; index < parts.length; index++) {
+            const status = parts[index];
+            if (status.startsWith("R") || status.startsWith("C")) {
+                const before = parts[++index];
+                const after = parts[++index];
+                if (!before || !after)
+                    continue;
+                if (secretPath(before) || secretPath(after)) {
+                    secrets.add(before);
+                    secrets.add(after);
+                }
+                else
+                    changed.push(after);
+            }
+            else {
+                const path = parts[++index];
+                if (!path)
+                    continue;
+                if (secretPath(path))
+                    secrets.add(path);
+                else
+                    changed.push(path);
+            }
+        }
+        const visible = [...paths, ...[...secrets].map((path) => `:(exclude,literal)${path}`)];
+        for (const path of changed)
+            files.add(path);
+        summary = (await git(cwd, ["--no-pager", "diff", from, "--stat", "--", ...visible])).trim();
+        patch = await git(cwd, ["--no-pager", "diff", from, "--", ...visible]);
+    }
+    catch {
+        // Not a git repository or no commits yet: the files still come from the working tree.
+    }
+    let untracked = [];
+    try {
+        untracked = (await git(cwd, ["ls-files", "--others", "--exclude-standard", "-z"]))
+            .split("\0")
+            .filter((path) => path && !dirtySet.has(path) && !secretPath(path));
+    }
+    catch {
+        untracked = [];
+    }
+    for (const path of untracked)
+        files.add(path);
+    for (const path of untracked) {
+        if (patch.length >= cap)
+            break;
+        patch += await noIndex(cwd, path);
+    }
+    const truncated = patch.length > cap;
+    return {
+        files: [...files].filter((path) => !dirtySet.has(path)).sort(),
+        stat: summary,
+        patch: truncated ? `${patch.slice(0, cap)}\n…` : patch,
+        truncated,
+    };
+}