Add version control command center

apps/desktop/src/electron/ElectronMenu.test.ts

@@ -103,6 +103,35 @@ describe("ElectronMenu", () => {
     }).pipe(Effect.provide(TestLayer)),
   );
 
+  it.effect("inserts a destructive separator when the first destructive item starts the menu", () =>
+    Effect.gen(function* () {
+      buildFromTemplateMock.mockImplementation(() => ({
+        popup: (options: Electron.PopupOptions) => {
+          options.callback?.();
+        },
+      }));
+
+      const electronMenu = yield* ElectronMenu.ElectronMenu;
+      yield* electronMenu.showContextMenu({
+        window: {} as Electron.BrowserWindow,
+        items: [
+          { id: "delete-draft", label: "Delete draft", destructive: true },
+          { id: "copy", label: "Copy" },
+          { id: "delete-file", label: "Delete file", destructive: true },
+        ],
+        position: Option.none(),
+      });
+
+      const template = buildFromTemplateMock.mock.calls[0]?.[0] as
+        | Electron.MenuItemConstructorOptions[]
+        | undefined;
+      assert.deepEqual(
+        template?.map((item) => item.type ?? item.label),
+        ["Delete draft", "Copy", "separator", "Delete file"],
+      );
+    }).pipe(Effect.provide(TestLayer)),
+  );
+
   it.effect("defers popupTemplate side effects until the returned Effect runs", () =>
     Effect.gen(function* () {
       const popupMock = vi.fn();

apps/desktop/src/electron/ElectronMenu.ts

@@ -61,13 +61,27 @@ export class ElectronMenu extends Context.Service<
 
 function normalizeContextMenuItems(source: readonly ContextMenuItem[]): ContextMenuItem[] {
   const normalizedItems: ContextMenuItem[] = [];
+  let lastWasSeparator = false;
 
   for (const sourceItem of source) {
     if (typeof sourceItem.id !== "string" || typeof sourceItem.label !== "string") {
       continue;
     }
 
-    // Header items are decorative section labels for the web fallback only —
+    if (sourceItem.separator === true) {
+      if (normalizedItems.length === 0 || lastWasSeparator) {
+        continue;
+      }
+      normalizedItems.push({
+        id: sourceItem.id,
+        label: "",
+        separator: true,
+      });
+      lastWasSeparator = true;
+      continue;
+    }
+
+    // Header items are decorative section labels for the web fallback only -
     // Electron's native menu has no equivalent affordance, so we skip them.
     if (sourceItem.header === true) {
       continue;
@@ -78,6 +92,7 @@ function normalizeContextMenuItems(source: readonly ContextMenuItem[]): ContextM
       label: sourceItem.label,
       destructive: sourceItem.destructive === true,
       disabled: sourceItem.disabled === true,
+      separator: false,
     };
 
     if (sourceItem.children) {
@@ -89,6 +104,11 @@ function normalizeContextMenuItems(source: readonly ContextMenuItem[]): ContextM
     }
 
     normalizedItems.push(normalizedItem);
+    lastWasSeparator = false;
+  }
+
+  if (normalizedItems.at(-1)?.separator === true) {
+    normalizedItems.pop();
   }
 
   return normalizedItems;
@@ -134,11 +154,23 @@ export const make = Effect.gen(function* () {
   ): Electron.MenuItemConstructorOptions[] => {
     const template: Electron.MenuItemConstructorOptions[] = [];
     let hasInsertedDestructiveSeparator = false;
+    let lastWasSeparator = false;
 
     for (const item of entries) {
-      if (item.destructive && !hasInsertedDestructiveSeparator && template.length > 0) {
-        template.push({ type: "separator" });
-        hasInsertedDestructiveSeparator = true;
+      if (item.separator === true) {
+        if (template.length > 0 && !lastWasSeparator) {
+          template.push({ type: "separator" });
+          lastWasSeparator = true;
+        }
+        continue;
+      }
+
+      if (item.destructive && !hasInsertedDestructiveSeparator) {
+        if (template.length > 0 && !lastWasSeparator) {
+          template.push({ type: "separator" });
+          lastWasSeparator = true;
+          hasInsertedDestructiveSeparator = true;
+        }
       }
 
       const itemOption: Electron.MenuItemConstructorOptions = {
@@ -158,6 +190,7 @@ export const make = Effect.gen(function* () {
       }
 
       template.push(itemOption);
+      lastWasSeparator = false;
     }
 
     return template;

apps/server/src/diagnostics/ErrorCause.ts

@@ -0,0 +1,82 @@
+const MAX_DIAGNOSTIC_TEXT_LENGTH = 2_000;
+
+export interface SanitizedErrorCause {
+  readonly tag?: string;
+  readonly name?: string;
+  readonly message?: string;
+  readonly detail?: string;
+  readonly code?: string;
+  readonly exitCode?: number;
+  readonly timeoutMs?: number;
+  readonly truncated?: boolean;
+}
+
+type MutableSanitizedErrorCause = {
+  -readonly [Key in keyof SanitizedErrorCause]?: SanitizedErrorCause[Key];
+};
+
+function truncateDiagnosticText(value: string): {
+  readonly text: string;
+  readonly truncated: boolean;
+} {
+  if (value.length <= MAX_DIAGNOSTIC_TEXT_LENGTH) {
+    return { text: value, truncated: false };
+  }
+  return {
+    text: `${value.slice(0, MAX_DIAGNOSTIC_TEXT_LENGTH)}\n\n[truncated]`,
+    truncated: true,
+  };
+}
+
+function stringField(record: Record<PropertyKey, unknown>, key: string): string | undefined {
+  const value = record[key];
+  return typeof value === "string" && value.length > 0 ? value : undefined;
+}
+
+function numberField(record: Record<PropertyKey, unknown>, key: string): number | undefined {
+  const value = record[key];
+  return typeof value === "number" && Number.isFinite(value) ? value : undefined;
+}
+
+function addTextField(
+  output: MutableSanitizedErrorCause,
+  key: "tag" | "name" | "message" | "detail" | "code",
+  value: string | undefined,
+) {
+  if (!value) return;
+  const truncated = truncateDiagnosticText(value);
+  output[key] = truncated.text;
+  if (truncated.truncated) output.truncated = true;
+}
+
+export function sanitizeErrorCause(cause: unknown): SanitizedErrorCause {
+  if (typeof cause === "string") {
+    const output: MutableSanitizedErrorCause = {};
+    addTextField(output, "message", cause);
+    return output;
+  }
+
+  if (typeof cause === "object" && cause !== null) {
+    const record = cause as Record<PropertyKey, unknown>;
+    const output: MutableSanitizedErrorCause = {};
+    addTextField(output, "tag", stringField(record, "_tag"));
+    addTextField(output, "name", cause instanceof Error ? cause.name : stringField(record, "name"));
+    addTextField(
+      output,
+      "message",
+      cause instanceof Error ? cause.message : stringField(record, "message"),
+    );
+    addTextField(output, "detail", stringField(record, "detail"));
+    addTextField(output, "code", stringField(record, "code"));
+
+    const exitCode = numberField(record, "exitCode");
+    if (exitCode !== undefined) output.exitCode = exitCode;
+
+    const timeoutMs = numberField(record, "timeoutMs");
+    if (timeoutMs !== undefined) output.timeoutMs = timeoutMs;
+
+    return Object.keys(output).length > 0 ? output : { tag: "Object" };
+  }
+
+  return { message: "Unknown error" };
+}

apps/server/src/git/GitManager.test.ts

@@ -581,6 +581,7 @@ function createGitHubCliWithFakeGh(scenario: FakeGhScenario = {}): {
           cwd: input.cwd,
           args: ["repo", "view", input.repository, "--json", "nameWithOwner,url,sshUrl"],
         }).pipe(Effect.map((result) => JSON.parse(result.stdout))),
+      getCommitAvatarUrl: () => Effect.succeed(null),
       createRepository: (input) =>
         Effect.fail(
           new GitHubCli.GitHubCliCommandError({

apps/server/src/sourceControl/AzureDevOpsCli.ts

@@ -157,6 +157,7 @@ const AzureDevOpsRepositoryDecodeOperation = Schema.Literals([
   "getRepositoryCloneUrls",
   "getDefaultBranch",
   "createRepository",
+  "getCommitAvatarUrl",
 ]);
 
 export class AzureDevOpsRepositoryDecodeError extends Schema.TaggedErrorClass<AzureDevOpsRepositoryDecodeError>()(
@@ -207,6 +208,8 @@ export class AzureDevOpsCli extends Context.Service<
       readonly cwd: string;
       readonly headSelector: string;
       readonly source?: SourceControlProvider.SourceControlRefSelector;
+      readonly repository?: string;
+      readonly project?: string;
       readonly state: "open" | "closed" | "merged" | "all";
       readonly limit?: number;
     }) => Effect.Effect<ReadonlyArray<NormalizedAzureDevOpsPullRequestRecord>, AzureDevOpsCliError>;
@@ -221,6 +224,13 @@ export class AzureDevOpsCli extends Context.Service<
       readonly repository: string;
     }) => Effect.Effect<AzureDevOpsRepositoryCloneUrls, AzureDevOpsCliError>;
 
+    readonly getCommitAvatarUrl: (input: {
+      readonly cwd: string;
+      readonly repository: string;
+      readonly sha: string;
+      readonly project?: string;
+    }) => Effect.Effect<string | null, AzureDevOpsCliError>;
+
     readonly createRepository: (input: {
       readonly cwd: string;
       readonly repository: string;
@@ -281,6 +291,14 @@ const RawAzureDevOpsRepositorySchema = Schema.Struct({
   defaultBranch: Schema.optional(Schema.NullOr(Schema.String)),
 });
 
+const RawAzureDevOpsCommitSchema = Schema.Struct({
+  author: Schema.optional(
+    Schema.Struct({
+      imageUrl: Schema.optional(Schema.NullOr(Schema.String)),
+    }),
+  ),
+});
+
 function normalizeDefaultBranch(value: string | null | undefined): string | null {
   const trimmed = value?.trim().replace(/^refs\/heads\//, "") ?? "";
   return trimmed.length > 0 ? trimmed : null;
@@ -377,6 +395,8 @@ export const make = Effect.gen(function* () {
           "list",
           "--detect",
           "true",
+          ...(input.repository ? ["--repository", input.repository] : []),
+          ...(input.project ? ["--project", input.project] : []),
           "--source-branch",
           SourceControlProvider.sourceBranch(input),
           "--status",
@@ -458,6 +478,35 @@ export const make = Effect.gen(function* () {
         ),
         Effect.map(normalizeRepositoryCloneUrls),
       ),
+    getCommitAvatarUrl: (input) =>
+      executeJson({
+        cwd: input.cwd,
+        args: [
+          "devops",
+          "invoke",
+          "--detect",
+          "true",
+          "--area",
+          "git",
+          "--resource",
+          "commits",
+          "--route-parameters",
+          ...(input.project ? [`project=${input.project}`] : []),
+          `repositoryId=${input.repository}`,
+          `commitId=${input.sha}`,
+          "--api-version",
+          "7.1-preview",
+        ],
+      }).pipe(
+        Effect.map((result) => result.stdout.trim()),
+        Effect.flatMap((raw) =>
+          decodeAzureDevOpsJson(raw, RawAzureDevOpsCommitSchema, "getCommitAvatarUrl", input.cwd),
+        ),
+        Effect.map((commit) => {
+          const avatarUrl = commit.author?.imageUrl?.trim();
+          return avatarUrl && avatarUrl.length > 0 ? avatarUrl : null;
+        }),
+      ),
     createRepository: (input) => {
       const repository = parseRepositorySpecifier(input.repository);
       // Azure Repos access is governed by project/organization permissions.