git-daemon 0.1.1 → 0.1.2

package/dist/deps.js

@@ -0,0 +1,101 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.installDeps = void 0;
+const path_1 = __importDefault(require("path"));
+const fs_1 = require("fs");
+const process_1 = require("./process");
+const workspace_1 = require("./workspace");
+const tools_1 = require("./tools");
+const installDeps = async (ctx, workspaceRoot, request) => {
+    const repoPath = await (0, workspace_1.resolveInsideWorkspace)(workspaceRoot, request.repoPath);
+    await fs_1.promises.access(path_1.default.join(repoPath, "package.json"));
+    const manager = await selectManager(repoPath, request.manager);
+    const { command, args } = await buildInstallCommand(repoPath, manager, request.mode, request.safer);
+    ctx.progress({ kind: "deps", detail: `${command} ${args.join(" ")}` });
+    await (0, process_1.runCommand)(ctx, command, args, { cwd: repoPath });
+};
+exports.installDeps = installDeps;
+const selectManager = async (repoPath, requested) => {
+    if (requested !== "auto") {
+        const installed = await (0, tools_1.isToolInstalled)(requested);
+        if (!installed) {
+            throw new Error(`${requested} is not installed.`);
+        }
+        return requested;
+    }
+    const packageManager = await readPackageManager(repoPath);
+    if (packageManager) {
+        const name = packageManager.split("@")[0];
+        if (name === "pnpm" || name === "yarn" || name === "npm") {
+            const installed = await (0, tools_1.isToolInstalled)(name);
+            if (installed) {
+                return name;
+            }
+        }
+    }
+    if (await fileExists(path_1.default.join(repoPath, "pnpm-lock.yaml"))) {
+        return "pnpm";
+    }
+    if (await fileExists(path_1.default.join(repoPath, "yarn.lock"))) {
+        return "yarn";
+    }
+    if (await fileExists(path_1.default.join(repoPath, "package-lock.json"))) {
+        return "npm";
+    }
+    return "npm";
+};
+const readPackageManager = async (repoPath) => {
+    try {
+        const raw = await fs_1.promises.readFile(path_1.default.join(repoPath, "package.json"), "utf8");
+        const parsed = JSON.parse(raw);
+        return parsed.packageManager;
+    }
+    catch {
+        return null;
+    }
+};
+const buildInstallCommand = async (repoPath, manager, mode, safer) => {
+    const lockfileExists = await hasAnyLockfile(repoPath);
+    const useCi = mode === "ci" || (mode === "auto" && lockfileExists);
+    if (manager === "pnpm") {
+        const args = ["install"];
+        if (useCi) {
+            args.push("--frozen-lockfile");
+        }
+        if (safer) {
+            args.push("--ignore-scripts");
+        }
+        return { command: "pnpm", args };
+    }
+    if (manager === "yarn") {
+        const args = ["install"];
+        const isBerry = await fileExists(path_1.default.join(repoPath, ".yarnrc.yml"));
+        if (useCi || isBerry) {
+            args.push("--immutable");
+        }
+        if (safer) {
+            args.push("--ignore-scripts");
+        }
+        return { command: "yarn", args };
+    }
+    const args = [useCi ? "ci" : "install"];
+    if (safer) {
+        args.push("--ignore-scripts");
+    }
+    return { command: "npm", args };
+};
+const hasAnyLockfile = async (repoPath) => (await fileExists(path_1.default.join(repoPath, "pnpm-lock.yaml"))) ||
+    (await fileExists(path_1.default.join(repoPath, "yarn.lock"))) ||
+    (await fileExists(path_1.default.join(repoPath, "package-lock.json")));
+const fileExists = async (target) => {
+    try {
+        await fs_1.promises.access(target);
+        return true;
+    }
+    catch {
+        return false;
+    }
+};

package/dist/errors.js

@@ -0,0 +1,43 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.internalError = exports.timeoutError = exports.pathNotFound = exports.repoNotFound = exports.jobNotFound = exports.capabilityNotGranted = exports.invalidRepoUrl = exports.pathOutsideWorkspace = exports.workspaceRequired = exports.rateLimited = exports.originNotAllowed = exports.authInvalid = exports.authRequired = exports.errorBody = exports.ApiError = void 0;
+class ApiError extends Error {
+    constructor(status, body) {
+        super(body.message);
+        this.status = status;
+        this.body = body;
+    }
+}
+exports.ApiError = ApiError;
+const errorBody = (errorCode, message, details) => ({
+    errorCode,
+    message,
+    ...(details ? { details } : {}),
+});
+exports.errorBody = errorBody;
+const authRequired = () => new ApiError(401, (0, exports.errorBody)("auth_required", "Bearer token required."));
+exports.authRequired = authRequired;
+const authInvalid = () => new ApiError(401, (0, exports.errorBody)("auth_invalid", "Bearer token invalid or expired."));
+exports.authInvalid = authInvalid;
+const originNotAllowed = () => new ApiError(403, (0, exports.errorBody)("origin_not_allowed", "Origin not allowed."));
+exports.originNotAllowed = originNotAllowed;
+const rateLimited = () => new ApiError(429, (0, exports.errorBody)("rate_limited", "Too many requests."));
+exports.rateLimited = rateLimited;
+const workspaceRequired = () => new ApiError(409, (0, exports.errorBody)("workspace_required", "Workspace root not configured."));
+exports.workspaceRequired = workspaceRequired;
+const pathOutsideWorkspace = () => new ApiError(409, (0, exports.errorBody)("path_outside_workspace", "Path is outside the workspace root."));
+exports.pathOutsideWorkspace = pathOutsideWorkspace;
+const invalidRepoUrl = () => new ApiError(422, (0, exports.errorBody)("invalid_repo_url", "Repository URL is invalid."));
+exports.invalidRepoUrl = invalidRepoUrl;
+const capabilityNotGranted = () => new ApiError(409, (0, exports.errorBody)("capability_not_granted", "Capability approval required."));
+exports.capabilityNotGranted = capabilityNotGranted;
+const jobNotFound = () => new ApiError(404, (0, exports.errorBody)("job_not_found", "Job not found."));
+exports.jobNotFound = jobNotFound;
+const repoNotFound = () => new ApiError(404, (0, exports.errorBody)("internal_error", "Repository not found."));
+exports.repoNotFound = repoNotFound;
+const pathNotFound = () => new ApiError(404, (0, exports.errorBody)("internal_error", "Path not found."));
+exports.pathNotFound = pathNotFound;
+const timeoutError = () => new ApiError(500, (0, exports.errorBody)("timeout", "Job timed out."));
+exports.timeoutError = timeoutError;
+const internalError = (message = "Unexpected error.") => new ApiError(500, (0, exports.errorBody)("internal_error", message));
+exports.internalError = internalError;

package/dist/git.js

@@ -0,0 +1,156 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+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;
+const path_1 = __importDefault(require("path"));
+const fs_1 = require("fs");
+const process_1 = require("./process");
+const workspace_1 = require("./workspace");
+class RepoNotFoundError extends Error {
+}
+exports.RepoNotFoundError = RepoNotFoundError;
+const cloneRepo = async (ctx, workspaceRoot, repoUrl, destRelative, options) => {
+    (0, workspace_1.ensureRelative)(destRelative);
+    const destPath = await (0, workspace_1.resolveInsideWorkspace)(workspaceRoot, destRelative, true);
+    const args = ["clone", repoUrl, destPath];
+    if (options?.branch) {
+        args.splice(1, 0, "--branch", options.branch);
+    }
+    if (options?.depth) {
+        args.splice(1, 0, "--depth", options.depth.toString());
+    }
+    await (0, process_1.runCommand)(ctx, "git", args, { cwd: workspaceRoot });
+};
+exports.cloneRepo = cloneRepo;
+const fetchRepo = async (ctx, workspaceRoot, repoPath, remote = "origin", prune = false) => {
+    const resolved = await (0, exports.resolveRepoPath)(workspaceRoot, repoPath);
+    const args = ["-C", resolved, "fetch", remote];
+    if (prune) {
+        args.push("--prune");
+    }
+    await (0, process_1.runCommand)(ctx, "git", args);
+};
+exports.fetchRepo = fetchRepo;
+const getRepoStatus = 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",
+    ]);
+    return parseStatus(result.stdout);
+};
+exports.getRepoStatus = getRepoStatus;
+const resolveRepoPath = async (workspaceRoot, repoPath) => {
+    const resolved = await (0, workspace_1.resolveInsideWorkspace)(workspaceRoot, repoPath);
+    await assertRepoExists(resolved);
+    return resolved;
+};
+exports.resolveRepoPath = resolveRepoPath;
+const assertRepoExists = async (repoPath) => {
+    const stats = await fs_1.promises.stat(repoPath);
+    if (!stats.isDirectory()) {
+        throw new RepoNotFoundError("Repository path is not a directory.");
+    }
+    const gitPath = path_1.default.join(repoPath, ".git");
+    try {
+        await fs_1.promises.access(gitPath);
+    }
+    catch {
+        throw new RepoNotFoundError("Repository .git directory not found.");
+    }
+};
+const parseStatus = (output) => {
+    let branch = "";
+    let ahead = 0;
+    let behind = 0;
+    let stagedCount = 0;
+    let unstagedCount = 0;
+    let untrackedCount = 0;
+    let conflictsCount = 0;
+    const lines = output.split(/\r?\n/);
+    for (const line of lines) {
+        if (line.startsWith("# branch.head")) {
+            branch = line.split(" ").slice(2).join(" ").trim();
+            continue;
+        }
+        if (line.startsWith("# branch.ab")) {
+            const parts = line.split(" ");
+            const aheadPart = parts.find((part) => part.startsWith("+"));
+            const behindPart = parts.find((part) => part.startsWith("-"));
+            ahead = aheadPart ? Number(aheadPart.slice(1)) : 0;
+            behind = behindPart ? Number(behindPart.slice(1)) : 0;
+            continue;
+        }
+        if (line.startsWith("?")) {
+            untrackedCount += 1;
+            continue;
+        }
+        if (line.startsWith("u")) {
+            conflictsCount += 1;
+            continue;
+        }
+        if (line.startsWith("1 ") || line.startsWith("2 ")) {
+            const x = line[2];
+            const y = line[3];
+            if (x && x !== ".") {
+                stagedCount += 1;
+            }
+            if (y && y !== ".") {
+                unstagedCount += 1;
+            }
+        }
+    }
+    const clean = stagedCount === 0 &&
+        unstagedCount === 0 &&
+        untrackedCount === 0 &&
+        conflictsCount === 0;
+    return {
+        branch,
+        ahead,
+        behind,
+        stagedCount,
+        unstagedCount,
+        untrackedCount,
+        conflictsCount,
+        clean,
+    };
+};

package/dist/jobs.js

@@ -0,0 +1,163 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.JobManager = exports.Job = void 0;
+const events_1 = require("events");
+const crypto_1 = __importDefault(require("crypto"));
+const errors_1 = require("./errors");
+const MAX_EVENTS = 2000;
+class Job {
+    constructor() {
+        this.state = "queued";
+        this.createdAt = new Date().toISOString();
+        this.events = [];
+        this.emitter = new events_1.EventEmitter();
+        this.cancelRequested = false;
+        this.id = crypto_1.default.randomUUID();
+    }
+    setCancel(fn) {
+        this.cancelFn = fn;
+    }
+    async cancel() {
+        this.cancelRequested = true;
+        if (this.cancelFn) {
+            await this.cancelFn();
+        }
+    }
+    emit(event) {
+        this.events.push(event);
+        if (this.events.length > MAX_EVENTS) {
+            this.events.shift();
+        }
+        this.emitter.emit("event", event);
+    }
+    snapshot() {
+        return {
+            id: this.id,
+            state: this.state,
+            createdAt: this.createdAt,
+            startedAt: this.startedAt,
+            finishedAt: this.finishedAt,
+            error: this.error,
+        };
+    }
+}
+exports.Job = Job;
+class JobManager {
+    constructor(maxConcurrent, timeoutSeconds) {
+        this.running = 0;
+        this.queue = [];
+        this.jobs = new Map();
+        this.history = [];
+        this.maxConcurrent = maxConcurrent;
+        this.timeoutMs = timeoutSeconds * 1000;
+    }
+    enqueue(run) {
+        const job = new Job();
+        this.jobs.set(job.id, job);
+        this.queue.push({ job, run });
+        this.track(job);
+        this.drain();
+        return job;
+    }
+    get(id) {
+        return this.jobs.get(id);
+    }
+    cancel(id) {
+        const queuedIndex = this.queue.findIndex((entry) => entry.job.id === id);
+        if (queuedIndex >= 0) {
+            const [entry] = this.queue.splice(queuedIndex, 1);
+            entry.job.state = "cancelled";
+            entry.job.finishedAt = new Date().toISOString();
+            entry.job.emit({ type: "state", state: "cancelled" });
+            return true;
+        }
+        const runningJob = this.jobs.get(id);
+        if (!runningJob) {
+            return false;
+        }
+        if (runningJob.state !== "running") {
+            return false;
+        }
+        void runningJob.cancel();
+        runningJob.state = "cancelled";
+        runningJob.finishedAt = new Date().toISOString();
+        runningJob.emit({ type: "state", state: "cancelled" });
+        return true;
+    }
+    listRecent() {
+        return this.history.map((job) => job.snapshot());
+    }
+    track(job) {
+        this.history.push(job);
+        if (this.history.length > 100) {
+            this.history.shift();
+        }
+    }
+    drain() {
+        while (this.running < this.maxConcurrent && this.queue.length > 0) {
+            const entry = this.queue.shift();
+            if (!entry) {
+                return;
+            }
+            this.runJob(entry.job, entry.run);
+        }
+    }
+    runJob(job, run) {
+        this.running += 1;
+        job.state = "running";
+        job.startedAt = new Date().toISOString();
+        job.emit({ type: "state", state: "running" });
+        let timeoutHandle;
+        if (this.timeoutMs > 0) {
+            timeoutHandle = setTimeout(async () => {
+                if (job.state !== "running") {
+                    return;
+                }
+                job.error = (0, errors_1.timeoutError)().body;
+                await job.cancel();
+                job.state = "error";
+                job.finishedAt = new Date().toISOString();
+                job.emit({ type: "state", state: "error", message: "Timed out" });
+            }, this.timeoutMs);
+        }
+        const ctx = {
+            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 }),
+            setCancel: (fn) => job.setCancel(fn),
+            isCancelled: () => job.cancelRequested,
+        };
+        run(ctx)
+            .then(() => {
+            if (job.state !== "running") {
+                return;
+            }
+            job.state = "done";
+            job.finishedAt = new Date().toISOString();
+            job.emit({ type: "state", state: "done" });
+        })
+            .catch((err) => {
+            if (job.state !== "running") {
+                return;
+            }
+            job.state = "error";
+            job.finishedAt = new Date().toISOString();
+            job.error = {
+                errorCode: "internal_error",
+                message: err instanceof Error ? err.message : "Job failed.",
+            };
+            job.emit({ type: "state", state: "error", message: job.error.message });
+        })
+            .finally(() => {
+            if (timeoutHandle) {
+                clearTimeout(timeoutHandle);
+            }
+            this.running -= 1;
+            this.drain();
+        });
+    }
+}
+exports.JobManager = JobManager;

package/dist/logger.js

@@ -0,0 +1,77 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createHttpLogger = exports.createLogger = void 0;
+const path_1 = __importDefault(require("path"));
+const fs_1 = require("fs");
+const pino_1 = __importDefault(require("pino"));
+const pino_http_1 = __importDefault(require("pino-http"));
+const rotating_file_stream_1 = require("rotating-file-stream");
+const createLogger = async (configDir, logging, enabled = true) => {
+    const level = process.env.GIT_DAEMON_LOG_LEVEL || "info";
+    const logToStdout = process.env.GIT_DAEMON_LOG_STDOUT === "1";
+    const prettyStdout = logToStdout && process.env.GIT_DAEMON_LOG_PRETTY !== "0";
+    const logDir = path_1.default.join(configDir, logging.directory);
+    await fs_1.promises.mkdir(logDir, { recursive: true });
+    const stream = (0, rotating_file_stream_1.createStream)("daemon.log", {
+        size: `${logging.maxBytes}B`,
+        maxFiles: logging.maxFiles,
+        path: logDir,
+    });
+    if (!logToStdout) {
+        return (0, pino_1.default)({ enabled, level }, stream);
+    }
+    const streams = [{ stream }];
+    if (prettyStdout) {
+        const { default: pretty } = await Promise.resolve().then(() => __importStar(require("pino-pretty")));
+        streams.push({
+            stream: pretty({
+                colorize: true,
+                translateTime: "SYS:standard",
+                ignore: "pid,hostname",
+            }),
+        });
+    }
+    else {
+        streams.push({ stream: process.stdout });
+    }
+    return (0, pino_1.default)({ enabled, level }, pino_1.default.multistream(streams));
+};
+exports.createLogger = createLogger;
+const createHttpLogger = (logger) => (0, pino_http_1.default)({ logger: logger });
+exports.createHttpLogger = createHttpLogger;

package/dist/os.js

@@ -0,0 +1,42 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.openTarget = void 0;
+const execa_1 = require("execa");
+const openTarget = async (target, resolvedPath) => {
+    const platform = process.platform;
+    if (target === "folder") {
+        if (platform === "darwin") {
+            await (0, execa_1.execa)("open", [resolvedPath]);
+            return;
+        }
+        if (platform === "win32") {
+            await (0, execa_1.execa)("cmd", ["/c", "start", "", resolvedPath]);
+            return;
+        }
+        await (0, execa_1.execa)("xdg-open", [resolvedPath]);
+        return;
+    }
+    if (target === "terminal") {
+        if (platform === "darwin") {
+            await (0, execa_1.execa)("open", ["-a", "Terminal", resolvedPath]);
+            return;
+        }
+        if (platform === "win32") {
+            await (0, execa_1.execa)("cmd", [
+                "/c",
+                "start",
+                "",
+                "cmd.exe",
+                "/k",
+                "cd",
+                "/d",
+                resolvedPath,
+            ]);
+            return;
+        }
+        await (0, execa_1.execa)("x-terminal-emulator", ["--working-directory", resolvedPath]);
+        return;
+    }
+    await (0, execa_1.execa)("code", [resolvedPath]);
+};
+exports.openTarget = openTarget;

package/dist/pairing.js

@@ -0,0 +1,41 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PairingManager = void 0;
+const crypto_1 = __importDefault(require("crypto"));
+const PAIRING_TTL_MS = 10 * 60 * 1000;
+class PairingManager {
+    constructor(tokenStore, ttlDays) {
+        this.codes = new Map();
+        this.tokenStore = tokenStore;
+        this.ttlDays = ttlDays;
+    }
+    start(origin) {
+        const code = crypto_1.default.randomBytes(4).toString("hex");
+        const expiresAt = Date.now() + PAIRING_TTL_MS;
+        this.codes.set(origin, { code, expiresAt });
+        return {
+            step: "start",
+            instructions: "Enter this code in the Git Daemon pairing prompt within 10 minutes.",
+            code,
+            expiresAt: new Date(expiresAt).toISOString(),
+        };
+    }
+    async confirm(origin, code) {
+        const entry = this.codes.get(origin);
+        if (!entry || entry.code !== code || entry.expiresAt < Date.now()) {
+            return null;
+        }
+        this.codes.delete(origin);
+        const { token, expiresAt } = await this.tokenStore.issueToken(origin, this.ttlDays);
+        return {
+            step: "confirm",
+            accessToken: token,
+            tokenType: "Bearer",
+            expiresAt,
+        };
+    }
+}
+exports.PairingManager = PairingManager;

package/dist/process.js

@@ -0,0 +1,46 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runCommand = void 0;
+const execa_1 = require("execa");
+const tree_kill_1 = __importDefault(require("tree-kill"));
+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 runCommand = async (ctx, command, args, options) => {
+    const subprocess = (0, execa_1.execa)(command, args, {
+        ...options,
+        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.stdout, ctx.logStdout);
+    attachLineReader(subprocess.stderr, ctx.logStderr);
+    await subprocess;
+};
+exports.runCommand = runCommand;