The IDE you know, rebuilt in Rust. IntelliJ IDEA–style keymap, tool windows and search-everywhere in a fast native app: editor, code insight, debugger, Git, terminal, database and HTTP clients for 60+ languages.
TypeScript code-editorcross-platformdapdatabase-clientdebuggerdesktop-appdeveloper-toolsgithttp-clientideintellijlsprusttauriterminal
/**
* Running git operations: error reporting, console output, network ops with
* progress / cancellation, and writing text back into working files.
*/
import { Channel } from "@tauri-apps/api/core";
import { create } from "zustand";
import type { GitOperation, RemoteOp } from "@/bindings";
import { executeAction } from "@/platform/actions";
import { tx } from "@/platform/i18n";
import { call, commands, isCancelled, nextRequestId } from "@/platform/ipc";
import { attachDocument, editorsFor } from "@/editor/api";
import { maybeEditorService, notifications } from "@/workbench/contributions";
import { cancelTask, upsertTaskSoon, useTasks } from "@/workbench/tasks";
import { progressFraction } from "./model";
import { beginGitWork, conflictedFiles, currentRepo, refreshNow, repoName, useVcs } from "./store";
// ---------------------------------------------------------------------------
// Console (Git tool window → Console tab)
export type ConsoleKind = "cmd" | "out" | "err" | "info";
export interface ConsoleLine {
id: number;
time: number;
kind: ConsoleKind;
text: string;
}
interface ConsoleState {
lines: ConsoleLine[];
}
const MAX_LINES = 5000;
let lineSeq = 0;
export const useVcsConsole = create<ConsoleState>(() => ({ lines: [] }));
export function logConsole(kind: ConsoleKind, text: string) {
const time = Date.now();
const add = text
.replace(/\r\n?/g, "\n")
.split("\n")
.filter((l, i, all) => l.length > 0 || (i > 0 && i < all.length - 1))
.map((l) => ({ id: ++lineSeq, time, kind, text: l }));
if (!add.length) return;
useVcsConsole.setState((s) => {
const lines = s.lines.concat(add);
return { lines: lines.length > MAX_LINES ? lines.slice(lines.length - MAX_LINES) : lines };
});
}
export function clearConsole() {
useVcsConsole.setState({ lines: [] });
}
export function errorMessage(e: unknown): string {
return e instanceof Error ? e.message : String(e);
}
// ---------------------------------------------------------------------------
// Local operations
export interface OpOptions<T> {
/** Success balloon text. */
success?: string | ((value: T) => string);
/** Refresh status afterwards (default true). */
refresh?: boolean;
/** Extra actions on the error balloon. */
errorActions?: (message: string) => Array<{ label: string; run: () => void }>;
/** Don't show an error balloon (the caller handles it). */
quiet?: boolean;
/** Called with the failure message; returning true suppresses the error balloon. */
onError?: (message: string) => boolean | Promise<boolean>;
}
/** Runs `fn`, logging to the console and reporting failures. `undefined` on error. */
export async function runOp<T>(title: string, fn: () => Promise<T>, opts: OpOptions<T> = {}): Promise<T | undefined> {
logConsole("cmd", title);
const endWork = beginGitWork();
try {
const value = await fn();
const msg = typeof opts.success === "function" ? opts.success(value) : opts.success;
if (msg) {
logConsole("info", msg);
notifications().notify({ group: "vcs", level: "info", title: msg });
}
return value;
} catch (e) {
const message = errorMessage(e);
logConsole("err", message);
const handled = opts.onError ? await opts.onError(message) : false;
if (!opts.quiet && !handled)
notifications().notify({
group: "vcs",
level: "error",
title: tx`${title} failed`,
body: message,
actions: opts.errorActions?.(message),
});
return undefined;
} finally {
endWork();
if (opts.refresh !== false) void refreshNow();
}
}
/** Saves all documents so git sees the editor contents. */
export async function saveAll() {
try {
await maybeEditorService()?.saveAll();
} catch {
// Saving is best effort; git then works on what is on disk.
}
}
// ---------------------------------------------------------------------------
// Network operations
const REMOTE_TITLE: Record<RemoteOp["op"], [string, string]> = {
fetch: ["Fetching", "Fetch"],
pull: ["Updating project", "Update"],
resetToUpstream: ["Updating project", "Update"],
pullFrom: ["Pulling", "Pull"],
push: ["Pushing", "Push"],
deleteBranch: ["Deleting remote branch", "Delete remote branch"],
pushBranch: ["Pushing", "Push"],
updateBranch: ["Updating branch", "Update"],
pushTag: ["Pushing", "Push"],
deleteRemoteTag: ["Deleting remote tag", "Delete remote tag"],
};
let activeRemote: number | null = null;
/** Error message of the last failed remote operation (null after a success / cancel). */
let lastRemoteError: string | null = null;
export function lastRemoteFailure(): string | null {
return lastRemoteError;
}
export function cancelRemote() {
if (activeRemote === null) return;
const taskId = `vcs:${activeRemote}`;
if (useTasks.getState().tasks.some((t) => t.id === taskId)) cancelTask(taskId);
else void commands.cancelRequest(activeRemote);
}
/** Every repository of the project (Fetch and Update Project act on all of them, as in IDEA). */
export function allRepos(): Array<string | null> {
const roots = useVcs.getState().roots;
return roots.length ? roots : [null];
}
/**
* Runs fetch / pull / push with progress in the status bar and output in the console,
* in each of `repos` (default: the selected repository) in turn.
*/
export async function runRemote(
op: RemoteOp,
detail?: string,
repos: ReadonlyArray<string | null> = [currentRepo()],
/** Failures the caller reports itself (e.g. a rejected push it goes on to update). */
handled?: (message: string) => boolean,
): Promise<boolean> {
if (useVcs.getState().remoteBusy) {
notifications().notify({ group: "vcs", level: "warning", title: "Another remote operation is in progress" });
return false;
}
const [progressText, doneTitle] = REMOTE_TITLE[op.op];
const progressTitle = tx(progressText);
const request = nextRequestId();
const taskId = `vcs:${request}`;
activeRemote = request;
useVcs.setState({ remoteBusy: progressTitle });
const cancel = () => void commands.cancelRequest(request);
const task = (message: string | null, fraction: number | null, done: boolean) =>
upsertTaskSoon({ id: taskId, title: progressTitle, message, fraction, done, cancel });
task(detail ?? null, null, false);
notifications().notify({
group: "vcs",
level: "info",
key: "vcs.remote",
title: `${progressTitle}…`,
body: detail,
sticky: true,
actions: [{ label: "Cancel", run: cancelRemote }],
});
logConsole("cmd", `git ${op.op}${detail ? ` (${detail})` : ""}`);
const channel = new Channel<string>();
let lastLine = "";
channel.onmessage = (line) => {
logConsole("out", line);
const text = line.trim();
if (text) lastLine = text;
task(text || null, progressFraction(text), false);
};
try {
// Every repository is tried; the failures are reported together. A pull skips the
// repositories that have nothing to pull from (detached HEAD, e.g. submodules; no upstream).
const failures: string[] = [];
const updated: UpdatedRange[] = [];
const pushed: Array<{ to: string; commits: number }> = [];
for (const repo of repos) {
const name = repos.length > 1 && repo ? repoName(repo) : null;
if (name) logConsole("info", name);
if (op.op === "pull" && repos.length > 1) {
const info = await call(commands.vcsBranchInfo(repo)).catch(() => null);
if (info && (!info.head || !info.upstream)) {
logConsole("info", info.head ? "No upstream branch, skipped" : "Detached HEAD, skipped");
continue;
}
}
try {
const before = isUpdate(op) ? await publishedTip(repo, op) : null;
// The push summary counts what the push carries: the commits the branch is
// ahead of its upstream before the push (pushing does not move the local head).
// Another remote or target receives other commits than "ahead of the upstream".
if (op.op === "push" || (op.op === "pushBranch" && !op.target && !op.remote)) {
const info = await call(commands.vcsBranchInfo(repo)).catch(() => null);
if (info?.upstream && info.ahead > 0) pushed.push({ to: info.upstream, commits: info.ahead });
}
await call(commands.vcsRemote(repo, request, op, channel));
const after = before ? await publishedTip(repo, op) : null;
if (before && after && before !== after) updated.push({ repo, from: before, to: after });
} catch (e) {
if (isCancelled(e) || !name) throw e;
logConsole("err", errorMessage(e));
failures.push(`${name}: ${errorMessage(e)}`);
}
}
if (failures.length) throw new Error(failures.join("\n"));
lastRemoteError = null;
if (isUpdate(op)) await notifyUpdated(updated);
else {
// One repository's push names what went out; a partial multi-repo push stays generic.
const one = pushed.length === 1 ? pushed[0] : null;
notifications().notify({
group: "vcs",
level: "info",
key: "vcs.remote",
title:
op.op === "pushTag"
? tx`Pushed tag ${op.tag} to ${op.remote}`
: one
? pushedTitle(one.commits, one.to)
: `${doneTitle} successful`,
body: lastLine && !/%/.test(lastLine) ? lastLine : undefined,
});
}
return true;
} catch (e) {
const cancelled = isCancelled(e);
lastRemoteError = cancelled ? null : errorMessage(e);
logConsole(cancelled ? "info" : "err", cancelled ? `${doneTitle} cancelled` : errorMessage(e));
// The user asked for it: the progress balloon just goes away.
if (cancelled || handled?.(errorMessage(e))) notifications().expire?.("vcs.remote");
else if (isUpdate(op) && (await stoppedOnConflicts())) {
// An update that stopped on conflicts opens them for resolving, not an error.
notifications().expire?.("vcs.remote");
void executeAction("vcs.resolveConflicts");
} else
notifications().notify({
group: "vcs",
level: "error",
key: "vcs.remote",
title: `${doneTitle} failed`,
body: errorMessage(e),
});
return false;
} finally {
task(null, 1, true);
activeRemote = null;
useVcs.setState({ remoteBusy: null });
void refreshNow();
}
}
interface UpdatedRange {
repo: string | null;
from: string;
to: string;
}
/** Update Project and the operations that bring the branch up to date like it. */
const isUpdate = (op: RemoteOp) => op.op === "pull" || op.op === "pullFrom" || op.op === "resetToUpstream";
async function stoppedOnConflicts(): Promise<boolean> {
await refreshNow();
return conflictedFiles().length > 0;
}
const headCommit = (repo: string | null) =>
call(commands.vcsBranchInfo(repo)).then(
(i) => i.headCommit,
() => null,
);
/**
* Where the branch meets the branch it updates from (their merge base), the start and
* end of what an update brought in: the incoming commits only, not the local ones a
* rebase rewrites or the merge commit. HEAD when that branch can't be resolved.
*/
async function publishedTip(repo: string | null, op: RemoteOp): Promise<string | null> {
const tracked =
op.op === "pull" || op.op === "resetToUpstream" || (op.op === "pullFrom" && !op.branches.length)
? "@{u}"
: op.op === "pullFrom" && op.branches.length === 1
? `${op.remote}/${op.branches[0]}`
: null;
const base = tracked ? await call(commands.vcsMergeBase(repo, "HEAD", tracked)).catch(() => null) : null;
return base ?? headCommit(repo);
}
/** Counts for a translated sentence: each variant is its own source text, as "{count} files". */
const filesText = (n: number) => (n === 1 ? tx`${n} file` : tx`${n} files`);
const commitsText = (n: number) => (n === 1 ? tx`${n} commit` : tx`${n} commits`);
/** "Pushed 3 commits to origin/main", translated per count. */
const pushedTitle = (n: number, to: string) =>
n === 1 ? tx`Pushed ${n} commit to ${to}` : tx`Pushed ${n} commits to ${to}`;
/** IDEA's Update Project result: "N files updated in M commits" with View Commits. */
async function notifyUpdated(updated: readonly UpdatedRange[]) {
if (!updated.length) {
notifications().notify({ group: "vcs", level: "info", key: "vcs.remote", title: "All files are up-to-date" });
return;
}
let files = 0;
let commits = 0;
await Promise.all(
updated.map(async ({ repo, from, to }) => {
const [changed, log] = await Promise.all([
call(commands.vcsDiffRevisions(repo, from, to)).catch(() => []),
call(
commands.vcsLog(repo, {
branch: null,
path: null,
author: null,
text: null,
range: `${from}..${to}`,
skip: 0,
limit: 0,
}),
).catch(() => []),
]);
files += changed.length;
commits += log.length;
}),
);
notifications().notify({
group: "vcs",
level: "info",
key: "vcs.remote",
title: `${filesText(files)} updated in ${commitsText(commits)}`,
actions: [
{
label: "View Commits",
run: () => {
const { repo, from, to } = updated.find((u) => u.repo === currentRepo()) ?? updated[0]!;
void import("./CompareBranches").then((m) => m.showCommitRange("Update Info", from, to, repo));
},
},
],
});
}
// ---------------------------------------------------------------------------
// Local history operations (continue / abort / cherry-pick / revert / reset)
export interface GitOperationOptions {
/** Status bar / balloon text while running, e.g. "Cherry-picking". */
progress: string;
/** Past-tense balloon on success, e.g. "Cherry-picked abc123"; a function is called after the status refreshed. */
success: string | (() => string);
/** Title of the error balloon, e.g. "Cherry-pick failed". */
failure: string;
/** Called with the failure message; returning true suppresses the error balloon. */
onError?: (message: string) => boolean | Promise<boolean>;
/** Links of the success balloon (e.g. Undo), worked out after the status refreshed. */
successActions?: () => Promise<{ label: string; run: () => void }[]>;
/** Links of the error balloon, worked out after the status refreshed. */
errorActions?: (message: string) => Array<{ label: string; run: () => void }>;
}
/**
* Runs a long local git operation like `runRemote`: progress in the status bar,
* output in the Git console, a sticky balloon with Cancel.
*/
export async function runGitOperation(
op: GitOperation,
opts: GitOperationOptions,
repo = currentRepo(),
): Promise<boolean> {
if (useVcs.getState().remoteBusy) {
notifications().notify({ group: "vcs", level: "warning", title: "Another Git operation is in progress" });
return false;
}
await saveAll();
const request = nextRequestId();
const taskId = `vcs:${request}`;
activeRemote = request;
const progress = tx(opts.progress);
useVcs.setState({ remoteBusy: progress });
const cancel = () => void commands.cancelRequest(request);
const task = (message: string | null, done: boolean) =>
upsertTaskSoon({ id: taskId, title: progress, message, fraction: done ? 1 : null, done, cancel });
task(null, false);
notifications().notify({
group: "vcs",
level: "info",
key: "vcs.operation",
title: `${progress}…`,
sticky: true,
actions: [{ label: "Cancel", run: cancelRemote }],
});
logConsole("cmd", `git ${describeOperation(op)}`);
const channel = new Channel<string>();
channel.onmessage = (line) => {
logConsole("out", line);
task(line.trim() || null, false);
};
try {
await call(commands.vcsOperation(repo, request, op, channel));
let success = opts.success;
if (typeof success === "function") {
await refreshNow();
success = success();
}
logConsole("info", success);
const actions = opts.successActions ? await opts.successActions() : undefined;
notifications().notify({ group: "vcs", level: "info", key: "vcs.operation", title: success, actions });
return true;
} catch (e) {
const cancelled = isCancelled(e);
const message = errorMessage(e);
logConsole(cancelled ? "info" : "err", cancelled ? `${opts.failure}: cancelled` : message);
notifications().expire?.("vcs.operation");
await refreshNow();
const handled = cancelled || (opts.onError ? await opts.onError(message) : false);
if (!handled)
notifications().notify({
group: "vcs",
level: "error",
key: "vcs.operation",
title: opts.failure,
body: message,
actions: opts.errorActions?.(message),
});
return false;
} finally {
task(null, true);
activeRemote = null;
useVcs.setState({ remoteBusy: null });
void refreshNow();
}
}
export function describeOperation(op: GitOperation): string {
switch (op.op) {
case "continue":
case "abort":
case "skip":
return `${useVcs.getState().branch?.operation ?? ""} --${op.op}`.trim();
case "stageAndContinue":
return `add -u && ${useVcs.getState().branch?.operation ?? ""} --continue`.trim();
case "cherryPick":
return `cherry-pick ${op.commits.map((c) => c.slice(0, 8)).join(" ")}`;
case "revert":
return `revert ${op.commits.map((c) => c.slice(0, 8)).join(" ")}`;
case "reset":
return `reset --${op.mode} ${op.commit.slice(0, 8)}`;
case "interactiveRebase":
return `rebase --interactive ${op.base ? op.base.slice(0, 8) : "--root"}`;
}
}
// ---------------------------------------------------------------------------
// Working file text
export interface TextEdit {
from: number;
to: number;
insert: string;
}
/** Current text of a working file: the open editor's buffer, else the file (read-only). */
export async function readWorkingText(path: string): Promise<string | null> {
const editor = editorsFor(path)[0];
if (editor) return editor.view.state.doc.toString();
try {
return await call(commands.fsReadText(path));
} catch {
return null;
}
}
const tick = (ms: number) => new Promise((r) => setTimeout(r, ms));
/**
* Applies edits (in the coordinates of `readWorkingText(path)`) to a working
* file: through the open editor (one undoable transaction) or, when the file
* isn't open, through a transient backend document that is saved.
*/
export async function applyFileEdits(path: string, edits: TextEdit[], opts: { save?: boolean; exact?: boolean } = {}) {
const editor = editorsFor(path)[0];
if (editor) {
editor.view.dispatch({ changes: edits, userEvent: "input.vcs", scrollIntoView: true });
if (opts.save) {
if (opts.exact) await saveExactText(path);
else {
// Let editor/core sync the change to the backend before saving.
await tick(60);
await maybeEditorService()?.saveAll();
}
}
return;
}
const info = await call(commands.docOpen(path));
try {
await call(commands.docEdit(info.id, info.version, { changes: [...edits].sort((a, b) => a.from - b.from) }));
await call(commands.docSave(info.id));
} finally {
void commands.docClose(info.id);
}
}
/** Replaces the whole content of a working file. */
export async function writeFileText(path: string, text: string, opts: { save?: boolean; exact?: boolean } = {}) {
const current = (await readWorkingText(path)) ?? "";
if (current === text) {
if (opts.save) {
if (opts.exact) await saveExactText(path);
else await saveAll();
}
return;
}
await applyFileEdits(path, [{ from: 0, to: current.length, insert: text }], opts);
}
/** Merge results keep their text even when the file is also shown in an editor tab. */
async function saveExactText(path: string) {
const document = await attachDocument(path);
try {
await document.save({ exact: true });
} finally {
document.release();
}
}