guito 0.6.0 → 0.6.2

package/bin/guito-server.js

@@ -1,6 +1,7 @@
 import { existsSync } from 'node:fs';
-import { execFile } from 'node:child_process';
-import { readFile, rm } from 'node:fs/promises';
+import { execFile, spawn } from 'node:child_process';
+import { readFile, rm, writeFile } from 'node:fs/promises';
+import { randomBytes } from 'node:crypto';
 import { basename, isAbsolute, join, relative, resolve, sep } from 'node:path';
 import fastify from 'fastify';
 import fastifyStatic from '@fastify/static';
@@ -9,8 +10,177 @@ import fastifyCompress from '@fastify/compress';
 import { simpleGit } from 'simple-git';
 import { promisify } from 'node:util';
 import { workingTree } from './working-tree.js';
+import { avatarCache } from './avatars.js';
+import { repositoryState } from './repository-state.js';
 const execFileAsync = promisify(execFile);
-export async function startGuitoServer({ repositoryPath, uiRoot, host, port = 8080, apiToken, }) {
+const AZURE_API_VERSION = '5.0';
+/**
+ * Extracts {projectPath, repo} from an Azure DevOps git remote URL.
+ * Supports https (with optional credentials) and ssh (scp-style and ssh://)
+ * forms, a trailing .git, and URL-encoded segments such as %20.
+ */
+export function parseAzureRemoteUrl(remoteUrl) {
+    const value = (remoteUrl ?? '').trim();
+    if (!value) {
+        return null;
+    }
+    let path;
+    const urlMatch = value.match(/^[a-z][a-z0-9+.\-]*:\/\/[^/]*\/(.*)$/i);
+    if (urlMatch) {
+        path = urlMatch[1];
+    }
+    else {
+        // scp-style ssh: git@host:Collection/Project/_git/Repo(.git)
+        const scpMatch = value.match(/^[^@/]+@[^:]+:(.+)$/);
+        if (!scpMatch) {
+            return null;
+        }
+        path = scpMatch[1];
+    }
+    path = path.replace(/\.git\/?$/i, '');
+    try {
+        path = decodeURIComponent(path);
+    }
+    catch {
+        // Keep the raw path when it contains invalid percent-escapes.
+    }
+    const gitIndex = path.toLowerCase().lastIndexOf('/_git/');
+    if (gitIndex < 0) {
+        return null;
+    }
+    const projectPath = path.slice(0, gitIndex).replace(/^\/+|\/+$/g, '');
+    const repo = path.slice(gitIndex + '/_git/'.length).replace(/^\/+|\/+$/g, '');
+    if (!projectPath || !repo) {
+        return null;
+    }
+    return { projectPath, repo };
+}
+/**
+ * Builds the encoded "{origin}[/{collection}]/{project}" prefix for Azure
+ * DevOps REST calls. When the base URL already contains the collection
+ * prefix of the remote path it is not duplicated.
+ */
+export function buildAzureProjectPrefix(baseUrl, remoteUrl) {
+    const base = (baseUrl ?? '').trim().replace(/\/+$/, '');
+    if (!base) {
+        return null;
+    }
+    const info = parseAzureRemoteUrl(remoteUrl);
+    if (!info) {
+        return null;
+    }
+    const encodePath = (value) => value
+        .split('/')
+        .filter(Boolean)
+        .map((segment) => encodeURIComponent(segment))
+        .join('/');
+    try {
+        const parsed = new URL(base);
+        const decode = (path) => path
+            .split('/')
+            .filter(Boolean)
+            .map((segment) => decodeURIComponent(segment));
+        const baseParts = decode(parsed.pathname);
+        const remoteParts = info.projectPath.split('/').filter(Boolean);
+        let overlap = Math.min(baseParts.length, remoteParts.length);
+        while (overlap &&
+            !baseParts
+                .slice(-overlap)
+                .every((part, index) => part.toLowerCase() === remoteParts[index].toLowerCase()))
+            overlap--;
+        return `${parsed.origin}/${[...baseParts, ...remoteParts.slice(overlap)].map(encodeURIComponent).join('/')}`;
+    }
+    catch {
+        return `${base}/${encodePath(info.projectPath)}`;
+    }
+}
+/** Builds the pullrequests REST URL from the server base URL and origin remote. */
+export function buildAzurePullRequestUrl(baseUrl, remoteUrl) {
+    const prefix = buildAzureProjectPrefix(baseUrl, remoteUrl);
+    if (!prefix) {
+        return null;
+    }
+    const info = parseAzureRemoteUrl(remoteUrl);
+    if (!info) {
+        return null;
+    }
+    return `${prefix}/_apis/git/repositories/${encodeURIComponent(info.repo)}/pullrequests?api-version=${AZURE_API_VERSION}`;
+}
+/**
+ * Default Azure DevOps HTTP runner: shells out to the Windows built-in
+ * curl.exe with NTLM + Negotiate and an empty username, which authenticates
+ * with the current Windows session (SSPI single sign-on).
+ */
+function defaultAzureRequest(method, url, body) {
+    return new Promise((resolveRequest, rejectRequest) => {
+        const args = [
+            '-sS',
+            '--ntlm',
+            '--negotiate',
+            '-u',
+            ':',
+            '--max-time',
+            '60',
+            '-w',
+            '\n%{http_code}',
+            '-X',
+            method,
+        ];
+        if (method === 'POST') {
+            args.push('-H', 'Content-Type: application/json', '--data-binary', '@-');
+        }
+        args.push(url);
+        const child = spawn('curl.exe', args, { windowsHide: true });
+        let stdout = '';
+        let stderr = '';
+        child.stdout.on('data', (chunk) => {
+            stdout += chunk;
+        });
+        child.stderr.on('data', (chunk) => {
+            stderr += chunk;
+        });
+        // EPIPE when curl exits before reading the whole body; the close handler
+        // reports the real failure.
+        child.stdin.on('error', () => { });
+        child.on('error', (err) => {
+            rejectRequest(new Error(`Failed to run curl.exe (Windows integrated auth requires Windows): ${err.message}`));
+        });
+        child.on('close', (code) => {
+            if (code !== 0) {
+                rejectRequest(new Error(stderr.trim() || `curl.exe exited with code ${code}.`));
+                return;
+            }
+            // -w appends "\n<http_code>" after the response body.
+            const separator = stdout.lastIndexOf('\n');
+            const status = Number.parseInt(stdout.slice(separator + 1), 10);
+            if (separator < 0 || !Number.isFinite(status)) {
+                rejectRequest(new Error('Unexpected curl.exe output (missing HTTP status).'));
+                return;
+            }
+            resolveRequest({ status, body: stdout.slice(0, separator) });
+        });
+        child.stdin.end(body, 'utf8');
+    });
+}
+const randomBranchSuffix = () => {
+    const alphabet = 'abcdefghijklmnopqrstuvwxyz0123456789';
+    const bytes = randomBytes(6);
+    let suffix = '';
+    for (const byte of bytes) {
+        suffix += alphabet[byte % alphabet.length];
+    }
+    return suffix;
+};
+/** Extracts Azure DevOps' human-readable error message from a REST response. */
+const azureErrorMessage = (result) => {
+    try {
+        return String(JSON.parse(result.body)?.message ?? '');
+    }
+    catch {
+        return result.body;
+    }
+};
+export async function startGuitoServer({ repositoryPath, uiRoot, host, port = 8080, apiToken, azureDevOpsUrl, autoReload, azureRequestImpl, avatarFetchImpl, }) {
     // Initialize server
     const app = fastify({
         logger: false,
@@ -47,6 +217,27 @@ export async function startGuitoServer({ repositoryPath, uiRoot, host, port = 80
     }
     // Initialize git lib
     const git = simpleGit(repositoryPath);
+    const avatars = avatarCache(avatarFetchImpl);
+    app.get('/api/avatar', async (req, reply) => {
+        const email = String(req.query?.email ?? '').trim();
+        if (!email || email.length > 320)
+            return reply.code(400).send({ error: 'Valid email required' });
+        const image = await avatars(email);
+        reply.header('Cache-Control', 'private, max-age=3600');
+        return image ? reply.type(image.contentType).send(image.data) : reply.code(204).send();
+    });
+    let stateRequest;
+    app.get('/api/repository-state', async (_req, reply) => {
+        try {
+            stateRequest ?? (stateRequest = repositoryState(git, repositoryPath).finally(() => {
+                stateRequest = undefined;
+            }));
+            return await stateRequest;
+        }
+        catch (err) {
+            return reply.code(400).send({ error: err.message });
+        }
+    });
     // ==================== Diff parsing ====================
     function parseUnifiedDiff(rawDiff) {
         const files = [];
@@ -138,11 +329,88 @@ export async function startGuitoServer({ repositoryPath, uiRoot, host, port = 80
         return result;
     };
     const repoRoot = async () => (await git.revparse(['--show-toplevel'])).trim();
+    // ==================== Azure DevOps settings ====================
+    // Settings live in the repository's git directory so they are per-repo and
+    // never committed. The VS Code extension passes its own setting via
+    // azureDevOpsUrl, which wins over the file.
+    let settingsPath = '';
+    try {
+        const gitDir = (await git.revparse(['--absolute-git-dir'])).trim();
+        settingsPath = join(gitDir, 'guito-settings.json');
+    }
+    catch {
+        settingsPath = join(repositoryPath, '.git', 'guito-settings.json');
+    }
+    const readSettings = async () => {
+        try {
+            return JSON.parse(await readFile(settingsPath, 'utf8'));
+        }
+        catch {
+            return {};
+        }
+    };
+    const writeSettings = async (settings) => {
+        await writeFile(settingsPath, `${JSON.stringify(settings, null, 2)}\n`, 'utf8');
+    };
+    const azureRequest = azureRequestImpl ?? defaultAzureRequest;
+    const configuredAzureUrl = azureDevOpsUrl?.trim() ?? '';
+    const effectiveAzureUrl = async () => {
+        if (configuredAzureUrl) {
+            return { url: configuredAzureUrl, source: 'vscode' };
+        }
+        const settings = await readSettings();
+        const url = typeof settings.azureDevOpsUrl === 'string' ? settings.azureDevOpsUrl.trim() : '';
+        return { url, source: url ? 'file' : '' };
+    };
+    /** Resolves the Azure DevOps project prefix or throws a user-facing error. */
+    const azureProjectContext = async () => {
+        const effective = await effectiveAzureUrl();
+        if (!effective.url) {
+            throw new Error('Azure DevOps URL is not configured. Set it in Settings (gear icon) or the guito.azureDevOpsUrl VS Code setting.');
+        }
+        let remoteUrl = '';
+        try {
+            remoteUrl = (await git.remote(['get-url', 'origin'])).trim();
+        }
+        catch {
+            throw new Error('No "origin" remote is configured for this repository.');
+        }
+        const prefix = buildAzureProjectPrefix(effective.url, remoteUrl);
+        if (!prefix) {
+            throw new Error(`The origin remote does not point to an Azure DevOps project: ${remoteUrl}`);
+        }
+        return { prefix, remoteUrl };
+    };
+    /** Merges the VS Code settings with the server-side settings file. */
+    const effectiveSettings = async () => {
+        const [file, azure] = await Promise.all([readSettings(), effectiveAzureUrl()]);
+        const fileAutoReload = typeof file.autoReload === 'boolean' ? file.autoReload : undefined;
+        return {
+            azureDevOpsUrl: azure.url,
+            source: azure.source,
+            autoReload: typeof autoReload === 'boolean' ? autoReload : (fileAutoReload ?? true),
+        };
+    };
+    const configuredIdentity = async () => {
+        const config = await git.listConfig();
+        return {
+            name: String(config.all['user.name'] ?? '').trim(),
+            email: String(config.all['user.email'] ?? '').trim(),
+        };
+    };
+    const authorIdentity = (name, email, identity) => ({
+        author_name: identity.name && identity.email && email.trim().toLowerCase() === identity.email.toLowerCase()
+            ? identity.name
+            : name,
+        author_email: email,
+    });
     // ==================== Repository ====================
     app.get('/api/repo', async (_req, resp) => {
         try {
             const root = (await git.revparse(['--show-toplevel'])).trim();
-            return resp.type('application/json').send({ root, name: basename(root) });
+            return resp
+                .type('application/json')
+                .send({ root, name: basename(root), identity: await configuredIdentity() });
         }
         catch (err) {
             return resp.status(400).type('application/json').send({ error: err.message });
@@ -177,12 +445,14 @@ export async function startGuitoServer({ repositoryPath, uiRoot, host, port = 80
             if (Number.isFinite(skip) && skip > 0) {
                 options['--skip'] = String(skip);
             }
-            const [log, count] = await Promise.all([
+            const [log, count, identity] = await Promise.all([
                 git.log(options),
                 git.raw(['rev-list', '--count', '--all']),
+                configuredIdentity(),
             ]);
             const commits = log.all.map((commit) => ({
                 ...commit,
+                ...authorIdentity(commit.author_name, commit.author_email, identity),
                 parents: String(commit.parents ?? '')
                     .split(' ')
                     .filter(Boolean),
@@ -639,6 +909,303 @@ export async function startGuitoServer({ repositoryPath, uiRoot, host, port = 80
             return resp.status(400).type('application/json').send({ error: err.message });
         }
     });
+    // ==================== Settings ====================
+    app.get('/api/settings', async (_req, resp) => {
+        try {
+            const settings = await effectiveSettings();
+            return resp.type('application/json').send(settings);
+        }
+        catch (err) {
+            return resp.status(400).type('application/json').send({ error: err.message });
+        }
+    });
+    app.post('/api/settings', async (req, resp) => {
+        try {
+            const url = String(req.body?.azureDevOpsUrl ?? '').trim();
+            if (url && !/^https?:\/\//i.test(url)) {
+                return resp
+                    .status(400)
+                    .type('application/json')
+                    .send({ error: 'The Azure DevOps URL must start with http:// or https://.' });
+            }
+            const settings = await readSettings();
+            settings.azureDevOpsUrl = url;
+            await writeSettings(settings);
+            const effective = await effectiveSettings();
+            return resp.type('application/json').send(effective);
+        }
+        catch (err) {
+            return resp.status(400).type('application/json').send({ error: err.message });
+        }
+    });
+    // ==================== Azure DevOps Pull Requests ====================
+    app.post('/api/azure-devops/pullrequest', async (req, resp) => {
+        try {
+            const { sourceBranch, targetBranch, title, description, newBranch } = req.body ?? {};
+            if (!targetBranch) {
+                return resp.status(400).type('application/json').send({ error: 'targetBranch required' });
+            }
+            const { prefix, remoteUrl } = await azureProjectContext();
+            const info = parseAzureRemoteUrl(remoteUrl);
+            if (!info) {
+                return resp
+                    .status(400)
+                    .type('application/json')
+                    .send({ error: 'Unable to build the Azure DevOps pull request URL.' });
+            }
+            const prUrl = `${prefix}/_apis/git/repositories/${encodeURIComponent(info.repo)}/pullrequests?api-version=${AZURE_API_VERSION}`;
+            let source = String(sourceBranch ?? '').trim();
+            if (newBranch) {
+                // Create a remote-only branch from the current HEAD; the local
+                // repository and the checked-out branch stay untouched.
+                const name = `pr/${randomBranchSuffix()}`;
+                await git.push(['origin', `HEAD:refs/heads/${name}`]);
+                source = name;
+            }
+            else {
+                if (!source) {
+                    return resp.status(400).type('application/json').send({ error: 'sourceBranch required' });
+                }
+                if (source.startsWith('origin/')) {
+                    // Remote-tracking branch: the PR source is the branch name on the remote.
+                    source = source.slice('origin/'.length);
+                }
+                else {
+                    // Publish the branch first when the remote does not have it yet.
+                    // The remote-tracking ref is a local check; a redundant push is a
+                    // harmless no-op ("Everything up-to-date").
+                    // rev-parse --verify --quiet does not fail reliably through
+                    // simple-git, so list the tracking refs instead.
+                    const trackingRefs = await git.raw([
+                        'for-each-ref',
+                        'refs/remotes/origin',
+                        '--format=%(refname)',
+                    ]);
+                    const published = trackingRefs
+                        .split('\n')
+                        .some((line) => line.trim() === `refs/remotes/origin/${source}`);
+                    if (!published) {
+                        await git.push(['origin', source]);
+                    }
+                }
+            }
+            const payload = {
+                isDraft: req.body?.isDraft === true,
+                sourceRefName: `refs/heads/${source}`,
+                targetRefName: `refs/heads/${String(targetBranch)
+                    .replace(/^refs\/heads\//, '')
+                    .replace(/^origin\//, '')}`,
+            };
+            const trimmedTitle = String(title ?? '').trim();
+            const trimmedDescription = String(description ?? '').trim();
+            if (trimmedTitle) {
+                payload.title = trimmedTitle;
+            }
+            if (trimmedDescription) {
+                payload.description = trimmedDescription;
+            }
+            const reviewerList = Array.isArray(req.body?.reviewers) ? req.body.reviewers : [];
+            const payloadReviewers = reviewerList
+                .map((entry) => ({ id: String(entry?.id ?? ''), isRequired: !!entry?.required }))
+                .filter((entry) => entry.id);
+            if (payloadReviewers.length) {
+                payload.reviewers = payloadReviewers;
+            }
+            const workItemList = Array.isArray(req.body?.workItems) ? req.body.workItems : [];
+            const payloadWorkItems = workItemList
+                .map((id) => Number(id))
+                .filter((id) => Number.isInteger(id) && id > 0);
+            if (payloadWorkItems.length) {
+                payload.workItemRefs = payloadWorkItems.map((id) => ({ id: String(id) }));
+            }
+            const result = await azureRequest('POST', prUrl, JSON.stringify(payload));
+            if (result.status < 200 || result.status >= 300) {
+                return resp
+                    .status(400)
+                    .type('application/json')
+                    .send({
+                    error: azureErrorMessage(result) || `Azure DevOps returned HTTP ${result.status}.`,
+                });
+            }
+            const created = JSON.parse(result.body);
+            // Tags (labels) are a separate resource; add them after the PR exists.
+            const labelNames = (Array.isArray(req.body?.labels) ? req.body.labels : [])
+                .map((name) => String(name ?? '').trim())
+                .filter(Boolean);
+            const warnings = [];
+            if (labelNames.length && created.pullRequestId) {
+                // Built from the prefix: prUrl already carries the api-version query.
+                const labelsUrl = `${prefix}/_apis/git/repositories/${encodeURIComponent(info.repo)}` +
+                    `/pullrequests/${created.pullRequestId}/labels?api-version=${AZURE_API_VERSION}`;
+                for (const name of labelNames) {
+                    try {
+                        const labelResult = await azureRequest('POST', labelsUrl, JSON.stringify({ name }));
+                        if (labelResult.status < 200 || labelResult.status >= 300) {
+                            warnings.push(`Could not add tag "${name}" (HTTP ${labelResult.status}).`);
+                        }
+                    }
+                    catch (err) {
+                        warnings.push(`Could not add tag "${name}": ${err.message}`);
+                    }
+                }
+            }
+            return resp.type('application/json').send({
+                id: created.pullRequestId,
+                url: created._links?.web?.href ?? '',
+                branch: source,
+                ...(warnings.length ? { warnings } : {}),
+            });
+        }
+        catch (err) {
+            return resp.status(400).type('application/json').send({ error: err.message });
+        }
+    });
+    // ==================== Azure DevOps PR metadata ====================
+    // Collection-scoped identity IDs can be passed directly as PR reviewers.
+    app.get('/api/azure-devops/reviewers', async (req, resp) => {
+        try {
+            const query = String((req.query ?? {}).query ?? '').trim();
+            if (!query) {
+                return resp.type('application/json').send({ reviewers: [] });
+            }
+            const { prefix } = await azureProjectContext();
+            const collection = prefix.slice(0, prefix.lastIndexOf('/'));
+            const identityBase = collection.replace('https://dev.azure.com/', 'https://vssps.dev.azure.com/');
+            const url = `${identityBase}/_apis/identities?api-version=5.0` +
+                `&searchFilter=General&filterValue=${encodeURIComponent(query)}&queryMembership=None`;
+            const result = await azureRequest('GET', url, '');
+            if (result.status < 200 || result.status >= 300) {
+                return resp
+                    .status(400)
+                    .type('application/json')
+                    .send({
+                    error: azureErrorMessage(result) || `Azure DevOps returned HTTP ${result.status}.`,
+                });
+            }
+            const data = JSON.parse(result.body);
+            const list = Array.isArray(data) ? data : (data.value ?? data.identities ?? []);
+            const reviewers = list
+                .map((entry) => ({
+                id: String(entry?.id ?? entry?.identity?.id ?? ''),
+                label: String(entry?.customDisplayName ||
+                    entry?.providerDisplayName ||
+                    entry?.label ||
+                    entry?.displayName ||
+                    entry?.name ||
+                    ''),
+                description: entry?.properties?.Mail?.$value ??
+                    entry?.properties?.Account?.$value ??
+                    entry?.description ??
+                    undefined,
+            }))
+                .filter((entry) => entry.id && entry.label);
+            return resp.type('application/json').send({ reviewers });
+        }
+        catch (err) {
+            return resp.status(400).type('application/json').send({ error: err.message });
+        }
+    });
+    // Work item search by id or title: a WIQL query returns ids, a batch read
+    // then fetches title/state for the first matches.
+    app.get('/api/azure-devops/workitems', async (req, resp) => {
+        try {
+            const query = String((req.query ?? {}).query ?? '')
+                .trim()
+                .replace(/^#(?=\d+$)/, '');
+            if (!query) {
+                return resp.type('application/json').send({ workItems: [] });
+            }
+            const { prefix } = await azureProjectContext();
+            const clauses = [`[System.Title] CONTAINS '${query.replace(/'/g, "''")}'`];
+            if (/^\d+$/.test(query)) {
+                clauses.push(`[System.Id] = ${Number(query)}`);
+            }
+            const wiql = 'SELECT [System.Id], [System.Title], [System.State] FROM WorkItems ' +
+                `WHERE [System.TeamProject] = @project AND (${clauses.map((clause) => `(${clause})`).join(' OR ')}) ` +
+                'ORDER BY [System.ChangedDate] DESC';
+            const wiqlResult = await azureRequest('POST', `${prefix}/_apis/wit/wiql?$top=20&api-version=${AZURE_API_VERSION}`, JSON.stringify({ query: wiql }));
+            if (wiqlResult.status < 200 || wiqlResult.status >= 300) {
+                return resp
+                    .status(400)
+                    .type('application/json')
+                    .send({
+                    error: azureErrorMessage(wiqlResult) || `Azure DevOps returned HTTP ${wiqlResult.status}.`,
+                });
+            }
+            const ids = (JSON.parse(wiqlResult.body).workItems ?? [])
+                .map((entry) => Number(entry?.id))
+                .filter((id) => Number.isInteger(id) && id > 0)
+                .slice(0, 20);
+            if (!ids.length) {
+                return resp.type('application/json').send({ workItems: [] });
+            }
+            const batchResult = await azureRequest('GET', `${prefix}/_apis/wit/workitems?ids=${ids.join(',')}` +
+                `&fields=System.Id,System.Title,System.State&api-version=${AZURE_API_VERSION}`, '');
+            if (batchResult.status < 200 || batchResult.status >= 300) {
+                return resp
+                    .status(400)
+                    .type('application/json')
+                    .send({
+                    error: azureErrorMessage(batchResult) || `Azure DevOps returned HTTP ${batchResult.status}.`,
+                });
+            }
+            const workItems = (JSON.parse(batchResult.body).value ?? []).map((item) => ({
+                id: Number(item?.id),
+                title: String(item?.fields?.['System.Title'] ?? ''),
+                state: String(item?.fields?.['System.State'] ?? ''),
+            }));
+            return resp.type('application/json').send({ workItems });
+        }
+        catch (err) {
+            return resp.status(400).type('application/json').send({ error: err.message });
+        }
+    });
+    // Existing pull request labels for the tag autocomplete.
+    app.get('/api/azure-devops/tags', async (_req, resp) => {
+        try {
+            const { prefix, remoteUrl } = await azureProjectContext();
+            const repo = parseAzureRemoteUrl(remoteUrl).repo;
+            // PR labels are distinct from Azure Boards work item tags.
+            const names = new Set();
+            for (let skip = 0;; skip += 100) {
+                const result = await azureRequest('GET', `${prefix}/_apis/git/repositories/${encodeURIComponent(repo)}/pullrequests` +
+                    `?searchCriteria.status=all&$top=100&$skip=${skip}&api-version=${AZURE_API_VERSION}`, '');
+                if (result.status < 200 || result.status >= 300) {
+                    throw new Error(azureErrorMessage(result) || `Azure DevOps returned HTTP ${result.status}.`);
+                }
+                const data = JSON.parse(result.body);
+                const requests = Array.isArray(data) ? data : (data.value ?? []);
+                // Some Server releases omit labels from the PR list response.
+                // Read those resources explicitly, with at most five requests in flight.
+                for (let offset = 0; offset < requests.length; offset += 5) {
+                    const labels = await Promise.all(requests.slice(offset, offset + 5).map(async (request) => {
+                        if (Array.isArray(request.labels))
+                            return request.labels;
+                        if (!Number.isInteger(request.pullRequestId))
+                            return [];
+                        const result = await azureRequest('GET', `${prefix}/_apis/git/repositories/${encodeURIComponent(repo)}` +
+                            `/pullrequests/${request.pullRequestId}/labels?api-version=${AZURE_API_VERSION}`, '');
+                        if (result.status < 200 || result.status >= 300) {
+                            throw new Error(azureErrorMessage(result) || `Azure DevOps returned HTTP ${result.status}.`);
+                        }
+                        const data = JSON.parse(result.body);
+                        return Array.isArray(data) ? data : (data.value ?? []);
+                    }));
+                    for (const label of labels.flat()) {
+                        if (typeof label.name === 'string' && label.name.trim())
+                            names.add(label.name.trim());
+                    }
+                }
+                if (requests.length < 100)
+                    break;
+            }
+            const tags = [...names].sort((a, b) => a.localeCompare(b));
+            return resp.type('application/json').send({ tags });
+        }
+        catch (err) {
+            return resp.status(400).type('application/json').send({ error: err.message });
+        }
+    });
     // ==================== Commit Detail ====================
     app.post('/api/commit/detail', async (req, resp) => {
         try {
@@ -663,8 +1230,7 @@ export async function startGuitoServer({ repositoryPath, uiRoot, host, port = 80
                 message,
                 refs: '',
                 body: body ?? '',
-                author_name: authorName,
-                author_email: authorEmail,
+                ...authorIdentity(authorName, authorEmail, await configuredIdentity()),
                 parents: String(parents ?? '')
                     .split(' ')
                     .filter(Boolean),

package/bin/repository-state.js

@@ -0,0 +1,25 @@
+import { createHash } from 'node:crypto';
+import { readFile, stat } from 'node:fs/promises';
+import { resolve } from 'node:path';
+// Git resolves the per-worktree HEAD/index and shared refs for us. This also
+// handles atomic ref replacement, packed refs and changes made by other tools.
+export async function repositoryState(git, root) {
+    const [refs, head, branch, status, config, mailmap, index] = await Promise.all([
+        git.raw(['for-each-ref', '--format=%(refname) %(objectname)']),
+        git.revparse(['--verify', 'HEAD']).catch(() => ''),
+        git.raw(['symbolic-ref', '--quiet', 'HEAD']).catch(() => ''),
+        git.status(),
+        git.listConfig(),
+        readFile(resolve(root, '.mailmap'), 'utf8').catch(() => ''),
+        git.raw(['diff', '--cached', '--raw', '-z', '--no-abbrev']),
+    ]);
+    const files = await Promise.all(status.files.map(async (file) => {
+        const info = await stat(resolve(root, file.path)).catch(() => null);
+        return [file, info?.mtimeMs, info?.ctimeMs, info?.size];
+    }));
+    const digest = (value) => createHash('sha256').update(JSON.stringify(value)).digest('hex');
+    return {
+        history: digest([refs, head, branch, config.all, mailmap]),
+        working: digest([files, index]),
+    };
+}

package/bin/ui/browser/index.html

@@ -9,5 +9,5 @@
 <style>:root{--bg:#1e1e1e;--bg-alt:#232323;--bg-hover:#2a2d2e;--border:#3c3c3c;--text:#cccccc;--text-bright:#e8e8e8;--text-dim:#9d9d9d;--accent:#3794ff;--red:#f14c4c;--mono:ui-monospace, "Cascadia Code", "SF Mono", Menlo, Consolas, monospace}*{box-sizing:border-box}html,body{height:100%;margin:0}body{font-family:-apple-system,BlinkMacSystemFont,Segoe UI,Roboto,Helvetica Neue,Arial,sans-serif;font-size:13px;color:var(--text);background:var(--bg);overflow:hidden}</style><link rel="stylesheet" href="styles-I7K2YZTW.css" media="print" onload="this.media='all'"><noscript><link rel="stylesheet" href="styles-I7K2YZTW.css"></noscript></head>
 <body>
   <app-root></app-root>
-<script src="polyfills-5CFQRCPP.js" type="module"></script><script src="main-GMXCXTX7.js" type="module"></script></body>
+<script src="polyfills-5CFQRCPP.js" type="module"></script><script src="main-JDFRJ57Z.js" type="module"></script></body>
 </html>