git-daemon 0.1.8 → 0.1.10

package/dist/git.js

@@ -36,7 +36,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.resolveRepoPath = exports.getRepoStatus = exports.fetchRepo = exports.cloneRepo = exports.RepoNotFoundError = void 0;
+exports.resolveRepoPath = exports.listRepoBranches = exports.getRepoSummary = exports.getRepoStatus = exports.fetchRepo = exports.cloneRepo = exports.RepoNotFoundError = void 0;
 const path_1 = __importDefault(require("path"));
 const fs_1 = require("fs");
 const process_1 = require("./process");
@@ -79,6 +79,56 @@ const getRepoStatus = async (workspaceRoot, repoPath) => {
     return parseStatus(result.stdout);
 };
 exports.getRepoStatus = getRepoStatus;
+const getRepoSummary = async (workspaceRoot, repoPath) => {
+    const resolved = await (0, exports.resolveRepoPath)(workspaceRoot, repoPath);
+    const { execa } = await Promise.resolve().then(() => __importStar(require("execa")));
+    const result = await execa("git", [
+        "-C",
+        resolved,
+        "status",
+        "--porcelain=2",
+        "-b",
+    ]);
+    const info = parseStatusInfo(result.stdout);
+    const dirty = info.stagedCount > 0 ||
+        info.unstagedCount > 0 ||
+        info.untrackedCount > 0 ||
+        info.conflictsCount > 0;
+    const upstream = info.detached ? null : info.upstream;
+    return {
+        repoPath,
+        exists: true,
+        branch: info.branch,
+        upstream,
+        ahead: upstream ? info.ahead : 0,
+        behind: upstream ? info.behind : 0,
+        dirty,
+        staged: info.stagedCount,
+        unstaged: info.unstagedCount,
+        untracked: info.untrackedCount,
+        conflicts: info.conflictsCount,
+        detached: info.detached,
+    };
+};
+exports.getRepoSummary = getRepoSummary;
+const listRepoBranches = async (workspaceRoot, repoPath, options) => {
+    const resolved = await (0, exports.resolveRepoPath)(workspaceRoot, repoPath);
+    const includeRemote = options?.includeRemote ?? true;
+    const { execa } = await Promise.resolve().then(() => __importStar(require("execa")));
+    const refs = ["refs/heads"];
+    if (includeRemote) {
+        refs.push("refs/remotes");
+    }
+    const result = await execa("git", [
+        "-C",
+        resolved,
+        "for-each-ref",
+        "--format=%(refname)\t%(refname:short)\t%(objectname)\t%(HEAD)\t%(upstream:short)",
+        ...refs,
+    ]);
+    return parseBranches(result.stdout);
+};
+exports.listRepoBranches = listRepoBranches;
 const resolveRepoPath = async (workspaceRoot, repoPath) => {
     const resolved = await (0, workspace_1.resolveInsideWorkspace)(workspaceRoot, repoPath);
     await assertRepoExists(resolved);
@@ -99,7 +149,26 @@ const assertRepoExists = async (repoPath) => {
     }
 };
 const parseStatus = (output) => {
-    let branch = "";
+    const info = parseStatusInfo(output);
+    const clean = info.stagedCount === 0 &&
+        info.unstagedCount === 0 &&
+        info.untrackedCount === 0 &&
+        info.conflictsCount === 0;
+    return {
+        branch: info.branch,
+        ahead: info.ahead,
+        behind: info.behind,
+        stagedCount: info.stagedCount,
+        unstagedCount: info.unstagedCount,
+        untrackedCount: info.untrackedCount,
+        conflictsCount: info.conflictsCount,
+        clean,
+    };
+};
+const parseStatusInfo = (output) => {
+    let head = "";
+    let oid = "";
+    let upstream = null;
     let ahead = 0;
     let behind = 0;
     let stagedCount = 0;
@@ -109,7 +178,16 @@ const parseStatus = (output) => {
     const lines = output.split(/\r?\n/);
     for (const line of lines) {
         if (line.startsWith("# branch.head")) {
-            branch = line.split(" ").slice(2).join(" ").trim();
+            head = line.split(" ").slice(2).join(" ").trim();
+            continue;
+        }
+        if (line.startsWith("# branch.oid")) {
+            oid = line.split(" ").slice(2).join(" ").trim();
+            continue;
+        }
+        if (line.startsWith("# branch.upstream")) {
+            const value = line.split(" ").slice(2).join(" ").trim();
+            upstream = value.length > 0 ? value : null;
             continue;
         }
         if (line.startsWith("# branch.ab")) {
@@ -139,18 +217,49 @@ const parseStatus = (output) => {
             }
         }
     }
-    const clean = stagedCount === 0 &&
-        unstagedCount === 0 &&
-        untrackedCount === 0 &&
-        conflictsCount === 0;
+    const detached = head === "(detached)";
+    let branch = head;
+    if (detached) {
+        branch = oid || head;
+        upstream = null;
+    }
     return {
         branch,
+        upstream,
         ahead,
         behind,
         stagedCount,
         unstagedCount,
         untrackedCount,
         conflictsCount,
-        clean,
+        detached,
     };
 };
+const parseBranches = (output) => {
+    const branches = [];
+    const lines = output.split(/\r?\n/);
+    for (const line of lines) {
+        if (!line) {
+            continue;
+        }
+        const [fullName, shortName, , headFlag, upstream] = line.split("\t");
+        if (!fullName || !shortName) {
+            continue;
+        }
+        if (fullName.startsWith("refs/remotes/") && fullName.endsWith("/HEAD")) {
+            continue;
+        }
+        const type = fullName.startsWith("refs/heads/") ? "local" : "remote";
+        const branch = {
+            name: shortName,
+            fullName,
+            type,
+            current: headFlag === "*",
+        };
+        if (upstream) {
+            branch.upstream = upstream;
+        }
+        branches.push(branch);
+    }
+    return branches;
+};

package/dist/healthchecks.js

@@ -0,0 +1,425 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HealthcheckResultStore = exports.runHealthchecks = exports.resolveSelections = exports.listHealthcheckSuites = exports.loadHealthcheckSuites = void 0;
+const path_1 = __importDefault(require("path"));
+const fs_1 = require("fs");
+const execa_1 = require("execa");
+const tree_kill_1 = __importDefault(require("tree-kill"));
+const STATUS_ORDER = {
+    failed: 3,
+    "pass-partial": 2,
+    "pass-full": 1,
+    na: 0,
+};
+const IGNORED_DIRS = new Set(["node_modules", ".git", "dist", "logs"]);
+const readJsonFile = async (filePath) => {
+    const raw = await fs_1.promises.readFile(filePath, "utf8");
+    return JSON.parse(raw);
+};
+const getString = (value) => typeof value === "string" && value.trim() ? value.trim() : null;
+const getNumber = (value) => typeof value === "number" && Number.isFinite(value) ? value : null;
+const getBoolean = (value) => typeof value === "boolean" ? value : null;
+const normalizeSuiteMeta = async (root) => {
+    const suitePath = path_1.default.join(root, "suite.json");
+    try {
+        const parsed = await readJsonFile(suitePath);
+        const id = getString(parsed.id) ?? path_1.default.basename(root);
+        const name = getString(parsed.name) ?? id;
+        return {
+            id,
+            name,
+            version: getString(parsed.version) ?? undefined,
+            description: getString(parsed.description) ?? undefined,
+        };
+    }
+    catch {
+        const id = path_1.default.basename(root);
+        return { id, name: id, version: undefined, description: undefined };
+    }
+};
+const collectManifests = async (root) => {
+    const results = [];
+    const walk = async (dir) => {
+        const entries = await fs_1.promises.readdir(dir, { withFileTypes: true });
+        for (const entry of entries) {
+            if (entry.name.startsWith(".") && entry.isDirectory()) {
+                continue;
+            }
+            const entryPath = path_1.default.join(dir, entry.name);
+            if (entry.isDirectory()) {
+                if (IGNORED_DIRS.has(entry.name)) {
+                    continue;
+                }
+                await walk(entryPath);
+                continue;
+            }
+            if (entry.isFile() && entry.name === "healthcheck.json") {
+                results.push(entryPath);
+            }
+        }
+    };
+    await walk(root);
+    return results;
+};
+const parseManifest = async (manifestPath) => {
+    let parsed;
+    try {
+        parsed = await readJsonFile(manifestPath);
+    }
+    catch {
+        return null;
+    }
+    const id = getString(parsed.id);
+    const name = getString(parsed.name) ?? id;
+    const version = getString(parsed.version);
+    const description = getString(parsed.description) ?? "";
+    const entrypoint = getString(parsed.entrypoint);
+    if (!id || !name || !version || !entrypoint) {
+        return null;
+    }
+    const root = path_1.default.dirname(manifestPath);
+    const entrypointPath = path_1.default.resolve(root, entrypoint);
+    try {
+        await fs_1.promises.access(entrypointPath);
+    }
+    catch {
+        return null;
+    }
+    const argsValue = Array.isArray(parsed.args)
+        ? parsed.args.filter((item) => typeof item === "string")
+        : [];
+    const timeoutSeconds = getNumber(parsed.timeoutSeconds) ?? 60;
+    const cacheable = getBoolean(parsed.cacheable) ?? false;
+    const cacheMaxAgeSeconds = getNumber(parsed.cacheMaxAgeSeconds) ?? undefined;
+    return {
+        id,
+        name,
+        version,
+        description,
+        entrypointPath,
+        args: argsValue,
+        timeoutSeconds,
+        cacheable,
+        cacheMaxAgeSeconds,
+        permissions: parsed.permissions,
+        configSchema: parsed.configSchema,
+        outputSchemaVersion: getNumber(parsed.outputSchemaVersion) ?? undefined,
+        root,
+    };
+};
+const loadHealthcheckSuites = async (configDir, suitePaths) => {
+    const suites = [];
+    for (const suitePath of suitePaths) {
+        const resolved = path_1.default.isAbsolute(suitePath)
+            ? suitePath
+            : path_1.default.resolve(configDir, suitePath);
+        let stats;
+        try {
+            stats = await fs_1.promises.stat(resolved);
+        }
+        catch {
+            continue;
+        }
+        if (!stats.isDirectory()) {
+            continue;
+        }
+        const meta = await normalizeSuiteMeta(resolved);
+        const manifestPaths = await collectManifests(resolved);
+        const checks = [];
+        for (const manifestPath of manifestPaths) {
+            const manifest = await parseManifest(manifestPath);
+            if (manifest) {
+                checks.push(manifest);
+            }
+        }
+        suites.push({
+            ...meta,
+            root: resolved,
+            checks,
+        });
+    }
+    return suites;
+};
+exports.loadHealthcheckSuites = loadHealthcheckSuites;
+const listHealthcheckSuites = (suites) => suites.map((suite) => ({
+    id: suite.id,
+    name: suite.name,
+    version: suite.version,
+    description: suite.description,
+    checks: suite.checks.map((check) => ({
+        id: check.id,
+        name: check.name,
+        version: check.version,
+        description: check.description,
+        timeoutSeconds: check.timeoutSeconds,
+        cacheable: check.cacheable,
+        cacheMaxAgeSeconds: check.cacheMaxAgeSeconds,
+        permissions: check.permissions,
+        configSchema: check.configSchema,
+        outputSchemaVersion: check.outputSchemaVersion,
+    })),
+}));
+exports.listHealthcheckSuites = listHealthcheckSuites;
+const resolveSelections = (suites, request, defaultSuiteId) => {
+    if (suites.length === 0) {
+        throw new Error("No healthcheck suites configured.");
+    }
+    const suiteId = request.suiteId ??
+        defaultSuiteId ??
+        (suites.length === 1 ? suites[0].id : null);
+    const suiteById = new Map(suites.map((suite) => [suite.id, suite]));
+    const selections = [];
+    if (request.checks && request.checks.length > 0) {
+        for (const selection of request.checks) {
+            const targetSuiteId = selection.suiteId ?? suiteId;
+            if (!targetSuiteId) {
+                throw new Error("Suite id is required to select healthchecks.");
+            }
+            const suite = suiteById.get(targetSuiteId);
+            if (!suite) {
+                throw new Error(`Healthcheck suite not found: ${targetSuiteId}.`);
+            }
+            const check = suite.checks.find((item) => item.id === selection.checkId);
+            if (!check) {
+                throw new Error(`Healthcheck not found: ${targetSuiteId}/${selection.checkId}.`);
+            }
+            selections.push({
+                suiteId: targetSuiteId,
+                check,
+                config: selection.config,
+            });
+        }
+    }
+    else {
+        if (!suiteId) {
+            throw new Error("Suite id is required to run healthchecks.");
+        }
+        const suite = suiteById.get(suiteId);
+        if (!suite) {
+            throw new Error(`Healthcheck suite not found: ${suiteId}.`);
+        }
+        for (const check of suite.checks) {
+            selections.push({ suiteId, check });
+        }
+    }
+    return selections;
+};
+exports.resolveSelections = resolveSelections;
+const attachLineReader = (stream, onLine) => {
+    if (!stream) {
+        return;
+    }
+    let buffer = "";
+    stream.on("data", (chunk) => {
+        buffer += chunk.toString();
+        const lines = buffer.split(/\r?\n/);
+        buffer = lines.pop() ?? "";
+        for (const line of lines) {
+            if (line.length > 0) {
+                onLine(line);
+            }
+        }
+    });
+    stream.on("end", () => {
+        if (buffer.length > 0) {
+            onLine(buffer);
+        }
+    });
+};
+const parseOutput = (stdout) => {
+    const trimmed = stdout.trim();
+    if (!trimmed) {
+        return { error: "No output provided." };
+    }
+    const attempt = (value) => {
+        try {
+            return { value: JSON.parse(value) };
+        }
+        catch (err) {
+            return {
+                error: err instanceof Error ? err.message : "Invalid JSON output.",
+            };
+        }
+    };
+    const first = attempt(trimmed);
+    if (!first.error) {
+        return first;
+    }
+    const lines = trimmed.split(/\r?\n/).filter(Boolean);
+    if (lines.length > 1) {
+        return attempt(lines[lines.length - 1]);
+    }
+    return first;
+};
+const normalizeStatus = (value) => {
+    if (value === "na" ||
+        value === "failed" ||
+        value === "pass-partial" ||
+        value === "pass-full") {
+        return value;
+    }
+    return null;
+};
+const buildFailureResult = (suiteId, checkId, summary, explanation, details) => ({
+    suiteId,
+    checkId,
+    status: "failed",
+    summary,
+    explanation,
+    details,
+    cached: false,
+});
+const runCheck = async (ctx, selection, repoPath, repoInfo) => {
+    const { check, suiteId } = selection;
+    const start = Date.now();
+    ctx.progress({
+        kind: "healthcheck",
+        detail: `${check.id}: running`,
+    });
+    const env = {
+        ...process.env,
+        REPO_PATH: repoPath,
+    };
+    if (repoInfo) {
+        env.REPO_INFO = JSON.stringify(repoInfo);
+    }
+    if (selection.config !== undefined) {
+        env.CHECK_CONFIG = JSON.stringify(selection.config);
+    }
+    const subprocess = (0, execa_1.execa)(check.entrypointPath, check.args, {
+        cwd: repoPath,
+        env,
+        timeout: check.timeoutSeconds * 1000,
+        stdout: "pipe",
+        stderr: "pipe",
+    });
+    const pid = subprocess.pid;
+    if (pid) {
+        ctx.setCancel(() => new Promise((resolve) => {
+            (0, tree_kill_1.default)(pid, "SIGTERM", () => resolve());
+        }));
+    }
+    attachLineReader(subprocess.stderr, ctx.logStderr);
+    let stdout = "";
+    if (subprocess.stdout) {
+        subprocess.stdout.on("data", (chunk) => {
+            stdout += chunk.toString();
+        });
+    }
+    try {
+        await subprocess;
+    }
+    catch (err) {
+        const message = err instanceof Error ? err.message : "Healthcheck failed.";
+        if (err.stdout) {
+            stdout += String(err.stdout);
+        }
+        return buildFailureResult(suiteId, check.id, "Healthcheck failed to run", message);
+    }
+    const parsed = parseOutput(stdout);
+    if (parsed.error || !parsed.value) {
+        return buildFailureResult(suiteId, check.id, "Invalid healthcheck output", parsed.error ?? "Unable to parse healthcheck output.");
+    }
+    const status = normalizeStatus(parsed.value.status);
+    const summary = getString(parsed.value.summary);
+    const explanation = getString(parsed.value.explanation);
+    if (!status || !summary || !explanation) {
+        return buildFailureResult(suiteId, check.id, "Invalid healthcheck output", "Healthcheck output is missing required fields.");
+    }
+    const details = Array.isArray(parsed.value.details)
+        ? parsed.value.details
+        : undefined;
+    const metrics = parsed.value.metrics && typeof parsed.value.metrics === "object"
+        ? parsed.value.metrics
+        : undefined;
+    const artifacts = Array.isArray(parsed.value.artifacts)
+        ? parsed.value.artifacts
+        : undefined;
+    const durationMs = getNumber(parsed.value.durationMs) ?? Math.max(0, Date.now() - start);
+    return {
+        suiteId,
+        checkId: check.id,
+        status,
+        summary,
+        explanation,
+        details,
+        metrics,
+        artifacts,
+        durationMs,
+        cached: false,
+    };
+};
+const summarize = (checks) => {
+    const counts = {
+        failed: 0,
+        "pass-partial": 0,
+        "pass-full": 0,
+        na: 0,
+    };
+    for (const check of checks) {
+        counts[check.status] += 1;
+    }
+    return `failed ${counts.failed}, partial ${counts["pass-partial"]}, full ${counts["pass-full"]}, na ${counts.na}`;
+};
+const aggregateStatus = (checks) => {
+    let winner = "na";
+    for (const check of checks) {
+        if (STATUS_ORDER[check.status] > STATUS_ORDER[winner]) {
+            winner = check.status;
+        }
+    }
+    return winner;
+};
+const runHealthchecks = async (ctx, jobId, repoPath, selections, repoInfo) => {
+    const startedAt = new Date().toISOString();
+    const results = [];
+    for (const selection of selections) {
+        if (ctx.isCancelled()) {
+            break;
+        }
+        const result = await runCheck(ctx, selection, repoPath, repoInfo);
+        results.push(result);
+        ctx.progress({
+            kind: "healthcheck",
+            detail: `${selection.check.id}: ${result.status}`,
+        });
+    }
+    const finishedAt = new Date().toISOString();
+    const status = aggregateStatus(results);
+    return {
+        jobId,
+        repoPath,
+        status,
+        summary: summarize(results),
+        checks: results,
+        startedAt,
+        finishedAt,
+    };
+};
+exports.runHealthchecks = runHealthchecks;
+class HealthcheckResultStore {
+    constructor(maxEntries = 200) {
+        this.results = new Map();
+        this.order = [];
+        this.maxEntries = maxEntries;
+    }
+    get(jobId) {
+        return this.results.get(jobId);
+    }
+    set(jobId, result) {
+        if (!this.results.has(jobId)) {
+            this.order.push(jobId);
+        }
+        this.results.set(jobId, result);
+        while (this.order.length > this.maxEntries) {
+            const oldest = this.order.shift();
+            if (oldest) {
+                this.results.delete(oldest);
+            }
+        }
+    }
+}
+exports.HealthcheckResultStore = HealthcheckResultStore;

package/dist/jobs.js

@@ -124,6 +124,7 @@ class JobManager {
             }, this.timeoutMs);
         }
         const ctx = {
+            jobId: job.id,
             logStdout: (line) => job.emit({ type: "log", stream: "stdout", line }),
             logStderr: (line) => job.emit({ type: "log", stream: "stderr", line }),
             progress: (event) => job.emit({ type: "progress", ...event }),

package/dist/validation.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.depsInstallRequestSchema = exports.osOpenRequestSchema = exports.gitStatusQuerySchema = exports.gitFetchRequestSchema = exports.gitCloneRequestSchema = exports.pairRequestSchema = void 0;
+exports.healthcheckRunRequestSchema = exports.depsInstallRequestSchema = exports.osOpenRequestSchema = exports.gitBranchesQuerySchema = exports.gitSummaryQuerySchema = exports.gitStatusQuerySchema = exports.gitFetchRequestSchema = exports.gitCloneRequestSchema = exports.pairRequestSchema = void 0;
 const zod_1 = require("zod");
 const MAX_PATH_LENGTH = 4096;
 const isValidRepoUrl = (value) => {
@@ -50,6 +50,13 @@ exports.gitFetchRequestSchema = zod_1.z.object({
 exports.gitStatusQuerySchema = zod_1.z.object({
     repoPath: zod_1.z.string().min(1).max(MAX_PATH_LENGTH),
 });
+exports.gitSummaryQuerySchema = zod_1.z.object({
+    repoPath: zod_1.z.string().min(1).max(MAX_PATH_LENGTH),
+});
+exports.gitBranchesQuerySchema = zod_1.z.object({
+    repoPath: zod_1.z.string().min(1).max(MAX_PATH_LENGTH),
+    includeRemote: zod_1.z.enum(["true", "false"]).optional(),
+});
 exports.osOpenRequestSchema = zod_1.z.object({
     target: zod_1.z.enum(["folder", "terminal", "vscode"]),
     path: zod_1.z.string().min(1).max(MAX_PATH_LENGTH),
@@ -60,3 +67,15 @@ exports.depsInstallRequestSchema = zod_1.z.object({
     mode: zod_1.z.enum(["auto", "ci", "install"]).optional(),
     safer: zod_1.z.boolean().optional(),
 });
+const healthcheckSelectionSchema = zod_1.z.object({
+    suiteId: zod_1.z.string().min(1).optional(),
+    checkId: zod_1.z.string().min(1),
+    config: zod_1.z.record(zod_1.z.unknown()).optional(),
+    cacheMode: zod_1.z.enum(["prefer", "refresh", "bypass"]).optional(),
+});
+exports.healthcheckRunRequestSchema = zod_1.z.object({
+    repoPath: zod_1.z.string().min(1).max(MAX_PATH_LENGTH),
+    repoInfo: zod_1.z.record(zod_1.z.unknown()).optional(),
+    suiteId: zod_1.z.string().min(1).optional(),
+    checks: zod_1.z.array(healthcheckSelectionSchema).optional(),
+});

package/healthchecks/example-suite/README.md

@@ -0,0 +1,10 @@
+# Example Healthchecks
+
+This suite includes two sample checks:
+
+- `about-description`: Verify the GitHub repo description matches the first
+  sentence of the README (ignores headings and badges).
+- `package-manager`: If a repo has `package.json`, require a `packageManager`
+  field.
+
+Each check is defined by a `healthcheck.json` manifest and a `run.js` entrypoint.

package/healthchecks/example-suite/about-description/healthcheck.json

@@ -0,0 +1,17 @@
+{
+  "id": "about-description",
+  "name": "About description matches README",
+  "version": "1.0.0",
+  "description": "Checks that the GitHub description matches the first README sentence.",
+  "entrypoint": "./run.js",
+  "args": [],
+  "timeoutSeconds": 30,
+  "permissions": {
+    "repoRead": true,
+    "network": false,
+    "secrets": []
+  },
+  "cacheable": true,
+  "cacheMaxAgeSeconds": 3600,
+  "outputSchemaVersion": 1
+}