@oscharko-dev/keiko-server 0.2.7 → 0.2.9

package/dist/gitRepositoryReads.js

@@ -0,0 +1,314 @@
+// Read-only Git repository summary / history / remotes BFF (Issue #1573, Epic #1572). Git execution
+// stays server-side with fixed args/env, selected-root containment, unsafe-owner surfacing, and
+// bounded output. Reuses the hardened runner + containment from gitRoutes.ts and the shared
+// porcelain-v2 parser; every response body is content-free (counts, typed codes, branch/remote
+// names, ISO dates) and passes through `deps.redactor`.
+import { stat } from "node:fs/promises";
+import { isAbsolute, resolve } from "node:path";
+import { GIT_HISTORY_SCHEMA_VERSION, GIT_REPOSITORY_SUMMARY_SCHEMA_VERSION, } from "@oscharko-dev/keiko-contracts";
+import { classifyFailure, isContained, optionsWithDefaults, resolveRepository, } from "./gitRoutes.js";
+import { parsePorcelainV2Branch } from "./gitPorcelainStatus.js";
+import { FilesError, runFilesHandler } from "./files.js";
+const HISTORY_RECORD_SEP = "\x1e";
+const HISTORY_FIELD_SEP = "\x1f";
+const HISTORY_PRETTY_FORMAT = `format:${HISTORY_RECORD_SEP}%H${HISTORY_FIELD_SEP}%h${HISTORY_FIELD_SEP}%P${HISTORY_FIELD_SEP}%an${HISTORY_FIELD_SEP}%aI${HISTORY_FIELD_SEP}%D${HISTORY_FIELD_SEP}%s`;
+const HISTORY_LIMIT_DEFAULT = 50;
+const HISTORY_LIMIT_MAX = 200;
+const HISTORY_SKIP_MAX = 100_000;
+function redacted(deps, value) {
+    return deps.redactor(value);
+}
+function unavailableState(reason) {
+    return reason === "unsafe-repository" ? "unsafe" : "unavailable";
+}
+function isUnavailable(repo) {
+    return "available" in repo;
+}
+// --- remotes ----------------------------------------------------------------
+// `git remote -v` emits `name\turl (fetch|push)` lines; fetch/push URLs are deduplicated by name.
+export function parseRemotes(stdout) {
+    const byName = new Map();
+    const order = [];
+    for (const line of stdout.split(/\r?\n/u)) {
+        const match = /^(\S+)\t(.+?)\s+\((fetch|push)\)$/u.exec(line.trim());
+        if (match === null)
+            continue;
+        const [, name, url, kind] = match;
+        if (name === undefined || url === undefined)
+            continue;
+        if (!byName.has(name)) {
+            byName.set(name, { name });
+            order.push(name);
+        }
+        const entry = byName.get(name);
+        if (entry === undefined)
+            continue;
+        if (kind === "fetch")
+            entry.fetchUrl = url;
+        else
+            entry.pushUrl = url;
+    }
+    return order.map((name) => {
+        const entry = byName.get(name) ?? { name };
+        return { name: entry.name, fetchUrl: entry.fetchUrl, pushUrl: entry.pushUrl };
+    });
+}
+function runGit(repo, options, args) {
+    return options.runner(["--no-pager", "--no-optional-locks", "-C", repo.repositoryRoot, ...args], {
+        cwd: repo.repositoryRoot,
+        maxBytes: options.maxStatusBytes,
+        timeoutMs: options.timeoutMs,
+    });
+}
+// --- last sync (FETCH_HEAD mtime) -------------------------------------------
+async function readLastSync(repo, options) {
+    try {
+        const result = await runGit(repo, options, ["rev-parse", "--git-path", "FETCH_HEAD"]);
+        if (result.exitCode !== 0)
+            return undefined;
+        const rawPath = result.stdout.split(/\r?\n/u)[0]?.trim();
+        if (rawPath === undefined || rawPath.length === 0)
+            return undefined;
+        // Defence-in-depth: `--git-path` resolves relative to the repository root, but verify the
+        // resolved path is contained under it before stat-ing so a manipulated rev-parse result can
+        // never stat an out-of-tree file. Containment failure ⇒ omit lastSync (metadata stays optional).
+        const path = isAbsolute(rawPath) ? rawPath : resolve(repo.repositoryRoot, rawPath);
+        if (!isContained(repo.repositoryRoot, path))
+            return undefined;
+        const info = await stat(path);
+        return { lastFetchAtMs: Math.round(info.mtimeMs) };
+    }
+    catch {
+        return undefined;
+    }
+}
+// --- summary ----------------------------------------------------------------
+// `GitRemotesResponse` IS the shared unavailable envelope head; the summary spreads it and adds the
+// zeroed status fields, so both responses stay byte-identical for the common fields.
+function unavailableRemotes(root, repositoryRoot, reason) {
+    return {
+        schemaVersion: GIT_REPOSITORY_SUMMARY_SCHEMA_VERSION,
+        root,
+        repositoryRoot,
+        state: reason === undefined ? "unavailable" : unavailableState(reason),
+        available: false,
+        reason,
+        remotes: [],
+        truncated: false,
+    };
+}
+function unavailableSummary(root, repositoryRoot, reason) {
+    return {
+        ...unavailableRemotes(root, repositoryRoot, reason),
+        detached: false,
+        ahead: 0,
+        behind: 0,
+        stagedCount: 0,
+        unstagedCount: 0,
+        untrackedCount: 0,
+        conflictedCount: 0,
+        clean: true,
+    };
+}
+function buildSummary(repo, status, remotes, lastSync) {
+    const parsed = parsePorcelainV2Branch(status.stdout);
+    const remoteAliases = remotes.map((remote) => ({ name: remote.name }));
+    return {
+        schemaVersion: GIT_REPOSITORY_SUMMARY_SCHEMA_VERSION,
+        root: repo.root,
+        repositoryRoot: repo.repositoryRoot,
+        state: "available",
+        available: true,
+        branch: parsed.branch,
+        detached: parsed.detached,
+        upstream: parsed.upstream,
+        ahead: parsed.ahead,
+        behind: parsed.behind,
+        stagedCount: parsed.stagedCount,
+        unstagedCount: parsed.unstagedCount,
+        untrackedCount: parsed.untrackedCount,
+        conflictedCount: parsed.conflictedCount,
+        clean: !parsed.dirty,
+        remotes: remoteAliases,
+        lastSync,
+        truncated: status.truncated,
+    };
+}
+export async function handleGitSummary(ctx, deps, rawOptions) {
+    return runFilesHandler(async () => {
+        const options = optionsWithDefaults(rawOptions ?? deps.gitRouteOptions);
+        const repo = await resolveRepository(ctx, deps, options);
+        if (isUnavailable(repo)) {
+            const body = unavailableSummary(repo.root, repo.repositoryRoot, repo.reason);
+            return { status: 200, body: redacted(deps, body) };
+        }
+        const status = await runGit(repo, options, [
+            "status",
+            "--porcelain=v2",
+            "--branch",
+            "-z",
+            "--untracked-files=all",
+        ]);
+        if (status.exitCode !== 0) {
+            const reason = classifyFailure(status);
+            return {
+                status: 200,
+                body: redacted(deps, unavailableSummary(repo.root, repo.repositoryRoot, reason)),
+            };
+        }
+        const remotesResult = await runGit(repo, options, ["remote", "-v"]);
+        const remotes = remotesResult.exitCode === 0 ? parseRemotes(remotesResult.stdout) : [];
+        const lastSync = await readLastSync(repo, options);
+        return { status: 200, body: redacted(deps, buildSummary(repo, status, remotes, lastSync)) };
+    });
+}
+// --- remotes route ----------------------------------------------------------
+export async function handleGitRemotes(ctx, deps, rawOptions) {
+    return runFilesHandler(async () => {
+        const options = optionsWithDefaults(rawOptions ?? deps.gitRouteOptions);
+        const repo = await resolveRepository(ctx, deps, options);
+        if (isUnavailable(repo)) {
+            const body = unavailableRemotes(repo.root, repo.repositoryRoot, repo.reason);
+            return { status: 200, body: redacted(deps, body) };
+        }
+        const result = await runGit(repo, options, ["remote", "-v"]);
+        if (result.exitCode !== 0) {
+            const reason = classifyFailure(result);
+            const body = unavailableRemotes(repo.root, repo.repositoryRoot, reason);
+            return { status: 200, body: redacted(deps, { ...body, truncated: result.truncated }) };
+        }
+        return {
+            status: 200,
+            body: redacted(deps, {
+                schemaVersion: GIT_REPOSITORY_SUMMARY_SCHEMA_VERSION,
+                root: repo.root,
+                repositoryRoot: repo.repositoryRoot,
+                state: "available",
+                available: true,
+                remotes: parseRemotes(result.stdout),
+                truncated: result.truncated,
+            }),
+        };
+    });
+}
+// --- history ----------------------------------------------------------------
+function parseInteger(raw, fallback, min, max) {
+    if (raw === null || raw.trim().length === 0)
+        return fallback;
+    if (!/^-?\d+$/u.test(raw.trim())) {
+        throw new FilesError(400, "BAD_REQUEST", "The limit and skip parameters must be integers.");
+    }
+    const value = Number.parseInt(raw.trim(), 10);
+    if (value < min)
+        return min;
+    if (value > max)
+        return max;
+    return value;
+}
+// The `--shortstat` summary line carries "N files changed"; merge/empty commits omit it (⇒ 0).
+function parseChangedFileCount(remainder) {
+    const match = /(\d+)\s+files?\s+changed/u.exec(remainder);
+    return match?.[1] === undefined ? 0 : Number.parseInt(match[1], 10);
+}
+function parseHistoryEntry(record) {
+    const newline = record.indexOf("\n");
+    const head = newline === -1 ? record : record.slice(0, newline);
+    const remainder = newline === -1 ? "" : record.slice(newline + 1);
+    const fields = head.split(HISTORY_FIELD_SEP);
+    const [sha, shortSha, parents, author, date, refs] = fields;
+    if (sha === undefined || shortSha === undefined || sha.length === 0)
+        return undefined;
+    const subject = fields.slice(6).join(HISTORY_FIELD_SEP);
+    return {
+        sha,
+        shortSha,
+        subject,
+        author: author ?? "",
+        date: date ?? "",
+        refs: (refs ?? "")
+            .split(", ")
+            .map((ref) => ref.trim())
+            .filter((ref) => ref.length > 0),
+        parentCount: (parents ?? "").split(/\s+/u).filter((entry) => entry.length > 0).length,
+        changedFileCount: parseChangedFileCount(remainder),
+    };
+}
+export function parseHistory(stdout) {
+    return stdout
+        .split(HISTORY_RECORD_SEP)
+        .filter((record) => record.length > 0)
+        .map(parseHistoryEntry)
+        .filter((entry) => entry !== undefined);
+}
+// An empty repository (no commits yet) makes `git log` exit non-zero; treat that as empty history.
+function isEmptyRepository(result) {
+    const text = `${result.stdout}\n${result.stderr}`.toLowerCase();
+    return (text.includes("does not have any commits yet") ||
+        text.includes("bad default revision 'head'") ||
+        text.includes("bad revision 'head'"));
+}
+function unavailableHistory(root, repositoryRoot, reason, limit, skip) {
+    return {
+        schemaVersion: GIT_HISTORY_SCHEMA_VERSION,
+        root,
+        repositoryRoot,
+        state: reason === undefined ? "unavailable" : unavailableState(reason),
+        available: false,
+        reason,
+        entries: [],
+        limit,
+        skip,
+        truncated: false,
+    };
+}
+function availableHistory(repo, entries, limit, skip, truncated) {
+    return {
+        schemaVersion: GIT_HISTORY_SCHEMA_VERSION,
+        root: repo.root,
+        repositoryRoot: repo.repositoryRoot,
+        state: "available",
+        available: true,
+        entries,
+        limit,
+        skip,
+        truncated,
+    };
+}
+function historyArgs(limit, skip) {
+    return [
+        "log",
+        "--no-color",
+        `--max-count=${String(limit)}`,
+        `--skip=${String(skip)}`,
+        `--pretty=${HISTORY_PRETTY_FORMAT}`,
+        "--shortstat",
+    ];
+}
+export async function handleGitHistory(ctx, deps, rawOptions) {
+    return runFilesHandler(async () => {
+        const options = optionsWithDefaults(rawOptions ?? deps.gitRouteOptions);
+        const limit = parseInteger(ctx.url.searchParams.get("limit"), HISTORY_LIMIT_DEFAULT, 1, HISTORY_LIMIT_MAX);
+        const skip = parseInteger(ctx.url.searchParams.get("skip"), 0, 0, HISTORY_SKIP_MAX);
+        const repo = await resolveRepository(ctx, deps, options);
+        if (isUnavailable(repo)) {
+            const body = unavailableHistory(repo.root, repo.repositoryRoot, repo.reason, limit, skip);
+            return { status: 200, body: redacted(deps, body) };
+        }
+        const result = await runGit(repo, options, historyArgs(limit, skip));
+        if (result.exitCode !== 0) {
+            if (isEmptyRepository(result)) {
+                return {
+                    status: 200,
+                    body: redacted(deps, availableHistory(repo, [], limit, skip, false)),
+                };
+            }
+            const reason = classifyFailure(result);
+            const body = unavailableHistory(repo.root, repo.repositoryRoot, reason, limit, skip);
+            return { status: 200, body: redacted(deps, body) };
+        }
+        const entries = parseHistory(result.stdout);
+        const truncated = result.truncated || entries.length === limit;
+        const body = availableHistory(repo, entries, limit, skip, truncated);
+        return { status: 200, body: redacted(deps, body) };
+    });
+}

package/dist/gitRepositoryRoutes.d.ts

@@ -0,0 +1,7 @@
+import type { RouteContext, RouteResult } from "./routes.js";
+import type { UiHandlerDeps } from "./deps.js";
+type CloneRepositoryRunner = (repositoryUrl: string, destinationPath: string) => Promise<RouteResult | null>;
+export declare function createCloneRepositoryHandler(cloneRunner?: CloneRepositoryRunner): (ctx: RouteContext, deps: UiHandlerDeps) => Promise<RouteResult>;
+export declare const handleCloneRepository: (ctx: RouteContext, deps: UiHandlerDeps) => Promise<RouteResult>;
+export {};
+//# sourceMappingURL=gitRepositoryRoutes.d.ts.map

package/dist/gitRepositoryRoutes.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"gitRepositoryRoutes.d.ts","sourceRoot":"","sources":["../src/gitRepositoryRoutes.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,YAAY,EAAE,WAAW,EAAE,MAAM,aAAa,CAAC;AAC7D,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,WAAW,CAAC;AAuI/C,KAAK,qBAAqB,GAAG,CAC3B,aAAa,EAAE,MAAM,EACrB,eAAe,EAAE,MAAM,KACpB,OAAO,CAAC,WAAW,GAAG,IAAI,CAAC,CAAC;AAuEjC,wBAAgB,4BAA4B,CAC1C,WAAW,GAAE,qBAAuC,GACnD,CAAC,GAAG,EAAE,YAAY,EAAE,IAAI,EAAE,aAAa,KAAK,OAAO,CAAC,WAAW,CAAC,CA2BlE;AAED,eAAO,MAAM,qBAAqB,QA7BzB,YAAY,QAAQ,aAAa,KAAK,OAAO,CAAC,WAAW,CA6BC,CAAC"}

package/dist/gitRepositoryRoutes.js

@@ -0,0 +1,221 @@
+import { spawn } from "node:child_process";
+import { Buffer } from "node:buffer";
+import { statSync } from "node:fs";
+import { dirname, isAbsolute, normalize } from "node:path";
+import { errorBody } from "./routes.js";
+import { pathIsDenied } from "./files-deny.js";
+import { assertUiDbOutsideProject, isProjectAvailable, validateProjectPath, } from "./store/index.js";
+const MAX_BODY_BYTES = 32 * 1024;
+const MAX_OUTPUT_BYTES = 64 * 1024;
+const CLONE_TIMEOUT_MS = 120_000;
+class BodyTooLargeError extends Error {
+    constructor() {
+        super("body too large");
+        this.name = "BodyTooLargeError";
+    }
+}
+function readBody(req) {
+    return new Promise((resolve, reject) => {
+        const chunks = [];
+        let total = 0;
+        let capped = false;
+        req.on("data", (chunk) => {
+            total += chunk.length;
+            if (total > MAX_BODY_BYTES) {
+                if (!capped) {
+                    capped = true;
+                    chunks.length = 0;
+                    reject(new BodyTooLargeError());
+                    req.resume();
+                }
+                return;
+            }
+            chunks.push(chunk);
+        });
+        req.on("end", () => {
+            if (!capped)
+                resolve(Buffer.concat(chunks).toString("utf8"));
+        });
+        req.on("error", reject);
+    });
+}
+async function readJsonObject(req) {
+    const raw = await readBody(req);
+    const parsed = JSON.parse(raw);
+    if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) {
+        throw new Error("Expected JSON object");
+    }
+    return parsed;
+}
+function optionalString(body, key) {
+    const value = body[key];
+    if (value === undefined || value === null)
+        return undefined;
+    if (typeof value !== "string")
+        throw new Error(`${key} must be a string`);
+    const trimmed = value.trim();
+    return trimmed.length === 0 ? undefined : trimmed;
+}
+function requireString(body, key) {
+    const value = optionalString(body, key);
+    if (value === undefined)
+        throw new Error(`${key} is required`);
+    return value;
+}
+function projectWithAvailability(project) {
+    return { ...project, available: isProjectAvailable(project) };
+}
+function invalid(message) {
+    return { status: 400, body: errorBody("BAD_REQUEST", message) };
+}
+function forbidden(message) {
+    return { status: 403, body: errorBody("DENIED", message) };
+}
+function repositoryUrlAllowed(input) {
+    if (containsControlCharacter(input))
+        return false;
+    if (/^git@[^:\s]+:[^\s]+$/u.test(input))
+        return true;
+    try {
+        const url = new URL(input);
+        if (url.username !== "" || url.password !== "")
+            return false;
+        return url.protocol === "https:" || url.protocol === "ssh:";
+    }
+    catch {
+        return false;
+    }
+}
+function containsControlCharacter(input) {
+    for (const char of input) {
+        const code = char.charCodeAt(0);
+        if (code < 32 || code === 127)
+            return true;
+    }
+    return false;
+}
+function assertDestination(candidate) {
+    if (!isAbsolute(candidate))
+        return invalid("Destination path must be absolute.");
+    const normalized = normalize(candidate);
+    if (pathIsDenied(normalized)) {
+        return forbidden("The destination path is excluded from Keiko's safe repository surface.");
+    }
+    try {
+        statSync(normalized);
+        return invalid("Destination path already exists.");
+    }
+    catch {
+        // Expected: git clone creates the final directory.
+    }
+    const parent = dirname(normalized);
+    if (pathIsDenied(parent)) {
+        return forbidden("The destination parent is excluded from Keiko's safe repository surface.");
+    }
+    try {
+        const info = statSync(parent);
+        if (!info.isDirectory())
+            return invalid("Destination parent must be a directory.");
+    }
+    catch {
+        return invalid("Destination parent must exist.");
+    }
+    return normalized;
+}
+function gitEnv() {
+    return {
+        PATH: process.env.PATH ?? "",
+        GIT_TERMINAL_PROMPT: "0",
+        GIT_PAGER: "cat",
+        PAGER: "cat",
+    };
+}
+const cloneRepository = function cloneRepository(repositoryUrl, destinationPath) {
+    return new Promise((resolveResult) => {
+        const child = spawn("git", ["clone", "--", repositoryUrl, destinationPath], {
+            cwd: dirname(destinationPath),
+            env: gitEnv(),
+            shell: false,
+            windowsHide: true,
+            stdio: ["ignore", "pipe", "pipe"],
+        });
+        monitorCloneProcess(child, resolveResult);
+    });
+};
+function cloneFailure(truncated) {
+    return {
+        status: truncated ? 504 : 409,
+        body: errorBody(truncated ? "GIT_CLONE_TIMEOUT" : "GIT_CLONE_FAILED", truncated
+            ? "Repository clone did not finish within the bounded execution window."
+            : "Repository clone failed. Check the URL, credentials, and destination path."),
+    };
+}
+function monitorCloneProcess(child, resolveResult) {
+    let outputBytes = 0;
+    let truncated = false;
+    let settled = false;
+    const timer = setTimeout(() => {
+        truncated = true;
+        child.kill("SIGTERM");
+    }, CLONE_TIMEOUT_MS);
+    const capture = (chunk) => {
+        outputBytes += chunk.byteLength;
+        if (outputBytes > MAX_OUTPUT_BYTES) {
+            truncated = true;
+            child.kill("SIGTERM");
+        }
+    };
+    child.stdout?.on("data", capture);
+    child.stderr?.on("data", capture);
+    child.on("error", () => {
+        if (settled)
+            return;
+        settled = true;
+        clearTimeout(timer);
+        resolveResult({
+            status: 503,
+            body: errorBody("GIT_UNAVAILABLE", "Git is not available on this host."),
+        });
+    });
+    child.on("close", (code) => {
+        if (settled)
+            return;
+        settled = true;
+        clearTimeout(timer);
+        if (code === 0) {
+            resolveResult(null);
+            return;
+        }
+        resolveResult(cloneFailure(truncated));
+    });
+}
+export function createCloneRepositoryHandler(cloneRunner = cloneRepository) {
+    return async (ctx, deps) => {
+        try {
+            const body = await readJsonObject(ctx.req);
+            const repositoryUrl = requireString(body, "repositoryUrl");
+            const destinationInput = requireString(body, "destinationPath");
+            const name = optionalString(body, "name");
+            if (!repositoryUrlAllowed(repositoryUrl)) {
+                return invalid("Repository URL must be HTTPS, SSH, or git@host:path without embedded secrets.");
+            }
+            const destination = assertDestination(destinationInput);
+            if (typeof destination !== "string")
+                return destination;
+            assertUiDbOutsideProject(deps.uiDbPath, destination);
+            const cloneResult = await cloneRunner(repositoryUrl, destination);
+            if (cloneResult !== null)
+                return cloneResult;
+            const normalizedPath = validateProjectPath(destination, { mustExist: true });
+            const project = deps.store.createProject(normalizedPath, name);
+            return { status: 201, body: { project: projectWithAvailability(project) } };
+        }
+        catch (error) {
+            if (error instanceof BodyTooLargeError) {
+                return { status: 413, body: errorBody("PAYLOAD_TOO_LARGE", "Request body is too large.") };
+            }
+            return invalid("The clone request is invalid.");
+        }
+    };
+}
+export const handleCloneRepository = createCloneRepositoryHandler();

package/dist/gitRoutes.d.ts

@@ -0,0 +1,66 @@
+import type { GitRepositoryStatusResponse } from "@oscharko-dev/keiko-contracts";
+import { GIT_REPOSITORY_SCHEMA_VERSION } from "@oscharko-dev/keiko-contracts";
+import { type RouteContext, type RouteResult } from "./routes.js";
+import type { UiHandlerDeps } from "./deps.js";
+export interface GitProcessResult {
+    readonly exitCode: number | null;
+    readonly signal: NodeJS.Signals | null;
+    readonly stdout: string;
+    readonly stderr: string;
+    readonly truncated: boolean;
+}
+export interface GitProcessOptions {
+    readonly cwd: string;
+    readonly maxBytes: number;
+    readonly timeoutMs: number;
+}
+export type GitProcessRunner = (args: readonly string[], options: GitProcessOptions) => Promise<GitProcessResult>;
+export interface GitRouteOptions {
+    readonly runner?: GitProcessRunner | undefined;
+    readonly maxStatusBytes?: number | undefined;
+    readonly maxDiffBytes?: number | undefined;
+    readonly maxChanges?: number | undefined;
+    readonly timeoutMs?: number | undefined;
+}
+export interface NormalizedGitRouteOptions {
+    readonly runner: GitProcessRunner;
+    readonly maxStatusBytes: number;
+    readonly maxDiffBytes: number;
+    readonly maxChanges: number;
+    readonly timeoutMs: number;
+}
+export interface RepositoryContext {
+    readonly root: string;
+    readonly realRoot: string;
+    readonly repositoryRoot: string;
+    readonly selectedRootPrefix: string;
+}
+export interface GitBranchListEntry {
+    readonly name: string;
+    readonly headRefHash: string;
+    readonly current: boolean;
+}
+export interface GitBranchListResponse {
+    readonly schemaVersion: typeof GIT_REPOSITORY_SCHEMA_VERSION;
+    readonly root: string;
+    readonly repositoryRoot?: string | undefined;
+    readonly available: boolean;
+    readonly state: "available" | "unavailable" | "unsafe";
+    readonly reason?: GitRepositoryStatusResponse["reason"] | undefined;
+    readonly message?: string | undefined;
+    readonly branches: readonly GitBranchListEntry[];
+    readonly truncated: boolean;
+}
+export declare function gitEnv(): NodeJS.ProcessEnv;
+export declare function networkGitEnv(): NodeJS.ProcessEnv;
+export declare function createGitProcessRunner(buildEnv: () => NodeJS.ProcessEnv): GitProcessRunner;
+export declare const defaultGitProcessRunner: GitProcessRunner;
+export declare const defaultGitNetworkProcessRunner: GitProcessRunner;
+export declare function isContained(root: string, target: string): boolean;
+export declare function classifyFailure(result: GitProcessResult): GitRepositoryStatusResponse["reason"];
+export declare function optionsWithDefaults(options: GitRouteOptions | undefined): NormalizedGitRouteOptions;
+export declare function resolveRepository(ctx: RouteContext, deps: UiHandlerDeps, options: NormalizedGitRouteOptions): Promise<RepositoryContext | GitRepositoryStatusResponse>;
+export declare function handleGitBranches(ctx: RouteContext, deps: UiHandlerDeps, rawOptions?: GitRouteOptions): Promise<RouteResult>;
+export declare function handleGitStatus(ctx: RouteContext, deps: UiHandlerDeps, rawOptions?: GitRouteOptions): Promise<RouteResult>;
+export declare function handleGitDiff(ctx: RouteContext, deps: UiHandlerDeps, rawOptions?: GitRouteOptions): Promise<RouteResult>;
+//# sourceMappingURL=gitRoutes.d.ts.map

package/dist/gitRoutes.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"gitRoutes.d.ts","sourceRoot":"","sources":["../src/gitRoutes.ts"],"names":[],"mappings":"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"}