git-daemon 0.1.0 → 0.1.2

package/README.md

@@ -1,6 +1,7 @@
 # Git Daemon
 
-![Git Daemon logo](logo.png)
+![Git Daemon logo](https://raw.githubusercontent.com/bunnybones1/git-daemon/master/logo.png)
+[![npm](https://img.shields.io/npm/v/git-daemon)](https://www.npmjs.com/package/git-daemon)
 
 Git Daemon is a local Node.js service that exposes a small, authenticated HTTP API for a trusted web UI to perform Git and developer convenience actions on your machine. It is designed to run on `127.0.0.1` only, enforce a strict Origin allowlist, and sandbox all filesystem access to a configured workspace root.
 
@@ -38,7 +39,13 @@ npm install
 npm run daemon
 ```
 
-The daemon listens on `http://127.0.0.1:8787` by default.
+The daemon listens on `http://127.0.0.1:8790` by default.
+
+Verbose logging options:
+
+- `GIT_DAEMON_LOG_STDOUT=1` to mirror logs to stdout
+- `GIT_DAEMON_LOG_PRETTY=0` to disable pretty formatting when stdout is enabled
+- `GIT_DAEMON_LOG_LEVEL=debug` to increase verbosity
 
 ## Pairing flow
 
@@ -50,7 +57,7 @@ Pairing is required before using protected endpoints.
 curl -H "Origin: https://app.example.com" \
   -H "Content-Type: application/json" \
   -d '{"step":"start"}' \
-  http://127.0.0.1:8787/v1/pair
+  http://127.0.0.1:8790/v1/pair
 ```
 
 2. Confirm pairing with the code:
@@ -59,7 +66,7 @@ curl -H "Origin: https://app.example.com" \
 curl -H "Origin: https://app.example.com" \
   -H "Content-Type: application/json" \
   -d '{"step":"confirm","code":"<CODE>"}' \
-  http://127.0.0.1:8787/v1/pair
+  http://127.0.0.1:8790/v1/pair
 ```
 
 The response includes `accessToken` to use as `Authorization: Bearer <token>`.
@@ -70,7 +77,7 @@ Check meta:
 
 ```bash
 curl -H "Origin: https://app.example.com" \
-  http://127.0.0.1:8787/v1/meta
+  http://127.0.0.1:8790/v1/meta
 ```
 
 Clone a repo (job):
@@ -81,7 +88,7 @@ curl -X POST \
   -H "Authorization: Bearer <TOKEN>" \
   -H "Content-Type: application/json" \
   -d '{"repoUrl":"git@github.com:owner/repo.git","destRelative":"owner/repo"}' \
-  http://127.0.0.1:8787/v1/git/clone
+  http://127.0.0.1:8790/v1/git/clone
 ```
 
 Stream job logs (SSE):
@@ -90,7 +97,7 @@ Stream job logs (SSE):
 curl -N \
   -H "Origin: https://app.example.com" \
   -H "Authorization: Bearer <TOKEN>" \
-  http://127.0.0.1:8787/v1/jobs/<JOB_ID>/stream
+  http://127.0.0.1:8790/v1/jobs/<JOB_ID>/stream
 ```
 
 ## Configuration

package/config.schema.json

@@ -35,7 +35,7 @@
           "type": "integer",
           "minimum": 1,
           "maximum": 65535,
-          "default": 8787
+          "default": 8790
         }
       }
     },

package/design.md

@@ -399,7 +399,7 @@ Same, except UI origin is localhost and allowlisted.
 
 ```bash
 curl -H "Origin: https://app.example.com" \
-     http://127.0.0.1:8787/v1/meta
+     http://127.0.0.1:8790/v1/meta
 ```
 
 ### Clone
@@ -410,7 +410,7 @@ curl -X POST \
   -H "Authorization: Bearer <TOKEN>" \
   -H "Content-Type: application/json" \
   -d '{"repoUrl":"git@github.com:owner/repo.git","destRelative":"owner/repo"}' \
-  http://127.0.0.1:8787/v1/git/clone
+  http://127.0.0.1:8790/v1/git/clone
 ```
 
 ### Stream job logs (SSE)
@@ -419,7 +419,7 @@ curl -X POST \
 curl -N \
   -H "Origin: https://app.example.com" \
   -H "Authorization: Bearer <TOKEN>" \
-  http://127.0.0.1:8787/v1/jobs/<JOB_ID>/stream
+  http://127.0.0.1:8790/v1/jobs/<JOB_ID>/stream
 ```
 
 ---

package/dist/app.js

@@ -0,0 +1,306 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createApp = void 0;
+const express_1 = __importDefault(require("express"));
+const express_rate_limit_1 = __importDefault(require("express-rate-limit"));
+const fs_1 = require("fs");
+const path_1 = __importDefault(require("path"));
+const logger_1 = require("./logger");
+const security_1 = require("./security");
+const errors_1 = require("./errors");
+const validation_1 = require("./validation");
+const workspace_1 = require("./workspace");
+const git_1 = require("./git");
+const deps_1 = require("./deps");
+const os_1 = require("./os");
+const approvals_1 = require("./approvals");
+const parseBody = (schema, body, opts) => {
+    const parsed = schema.safeParse(body);
+    if (!parsed.success) {
+        if (opts?.repoUrl &&
+            parsed.error.issues.some((issue) => issue.path.includes("repoUrl"))) {
+            throw new errors_1.ApiError(422, (0, errors_1.errorBody)("invalid_repo_url", "Repository URL is invalid."));
+        }
+        throw new errors_1.ApiError(422, (0, errors_1.errorBody)("internal_error", "Invalid input."));
+    }
+    return parsed.data;
+};
+const rateLimitHandler = (_req, res) => {
+    const body = (0, errors_1.rateLimited)().body;
+    res.status(429).json(body);
+};
+const createApp = (ctx) => {
+    const app = (0, express_1.default)();
+    app.disable("x-powered-by");
+    app.use((0, logger_1.createHttpLogger)(ctx.logger));
+    app.use(express_1.default.json({ limit: "256kb" }));
+    app.use((0, security_1.loopbackGuard)());
+    app.use((0, security_1.hostGuard)());
+    app.use((0, security_1.originGuard)(ctx.config.originAllowlist));
+    app.use("/v1", (0, express_rate_limit_1.default)({
+        windowMs: 5 * 60 * 1000,
+        max: 300,
+        standardHeaders: true,
+        legacyHeaders: false,
+        handler: rateLimitHandler,
+    }));
+    app.get("/v1/meta", (_req, res) => {
+        const origin = (0, security_1.getOrigin)(_req);
+        const pairingRecord = ctx.tokenStore.getActiveToken(origin);
+        res.json({
+            version: ctx.version,
+            build: ctx.build,
+            pairing: {
+                required: true,
+                paired: Boolean(pairingRecord),
+            },
+            workspace: {
+                configured: Boolean(ctx.config.workspaceRoot),
+                root: ctx.config.workspaceRoot ?? undefined,
+            },
+            capabilities: ctx.capabilities,
+        });
+    });
+    app.post("/v1/pair", (0, express_rate_limit_1.default)({
+        windowMs: 10 * 60 * 1000,
+        max: 10,
+        standardHeaders: true,
+        legacyHeaders: false,
+        handler: rateLimitHandler,
+    }), async (req, res, next) => {
+        try {
+            const origin = (0, security_1.getOrigin)(req);
+            const payload = parseBody(validation_1.pairRequestSchema, req.body);
+            if (payload.step === "start") {
+                res.json(ctx.pairingManager.start(origin));
+                return;
+            }
+            const response = await ctx.pairingManager.confirm(origin, payload.code);
+            if (!response) {
+                throw new errors_1.ApiError(422, (0, errors_1.errorBody)("internal_error", "Invalid pairing code."));
+            }
+            res.json(response);
+        }
+        catch (err) {
+            next(err);
+        }
+    });
+    app.get("/v1/jobs/:id", (0, security_1.authGuard)(ctx.tokenStore), (req, res, next) => {
+        try {
+            const job = ctx.jobManager.get(req.params.id);
+            if (!job) {
+                throw (0, errors_1.jobNotFound)();
+            }
+            res.json(job.snapshot());
+        }
+        catch (err) {
+            next(err);
+        }
+    });
+    app.get("/v1/jobs/:id/stream", (0, security_1.authGuard)(ctx.tokenStore), (req, res, next) => {
+        const job = ctx.jobManager.get(req.params.id);
+        if (!job) {
+            next((0, errors_1.jobNotFound)());
+            return;
+        }
+        res.writeHead(200, {
+            "Content-Type": "text/event-stream",
+            "Cache-Control": "no-cache",
+            Connection: "keep-alive",
+            "X-Accel-Buffering": "no",
+        });
+        res.flushHeaders?.();
+        const sendEvent = (event) => {
+            res.write(`data: ${JSON.stringify(event)}\n\n`);
+        };
+        for (const event of job.events) {
+            sendEvent(event);
+        }
+        const listener = (event) => sendEvent(event);
+        job.emitter.on("event", listener);
+        req.on("close", () => {
+            job.emitter.off("event", listener);
+        });
+    });
+    app.post("/v1/jobs/:id/cancel", (0, security_1.authGuard)(ctx.tokenStore), (req, res, next) => {
+        try {
+            const job = ctx.jobManager.get(req.params.id);
+            if (!job) {
+                throw (0, errors_1.jobNotFound)();
+            }
+            if (job.state !== "queued" && job.state !== "running") {
+                res
+                    .status(409)
+                    .json((0, errors_1.errorBody)("internal_error", "Job is not cancellable."));
+                return;
+            }
+            ctx.jobManager.cancel(job.id);
+            res.json({ accepted: true });
+        }
+        catch (err) {
+            next(err);
+        }
+    });
+    app.post("/v1/git/clone", (0, security_1.authGuard)(ctx.tokenStore), async (req, res, next) => {
+        try {
+            const payload = parseBody(validation_1.gitCloneRequestSchema, req.body, {
+                repoUrl: true,
+            });
+            const workspaceRoot = (0, workspace_1.ensureWorkspaceRoot)(ctx.config.workspaceRoot);
+            (0, workspace_1.ensureRelative)(payload.destRelative);
+            const destPath = await (0, workspace_1.resolveInsideWorkspace)(workspaceRoot, payload.destRelative, true);
+            try {
+                await fs_1.promises.access(destPath);
+                res
+                    .status(409)
+                    .json((0, errors_1.errorBody)("internal_error", "Destination already exists."));
+                return;
+            }
+            catch (err) {
+                if (err.code !== "ENOENT") {
+                    throw err;
+                }
+            }
+            await fs_1.promises.mkdir(path_1.default.dirname(destPath), { recursive: true });
+            const job = ctx.jobManager.enqueue(async (jobCtx) => {
+                await (0, git_1.cloneRepo)(jobCtx, workspaceRoot, payload.repoUrl, payload.destRelative, payload.options);
+            });
+            res.status(202).json({ jobId: job.id });
+        }
+        catch (err) {
+            next(err);
+        }
+    });
+    app.post("/v1/git/fetch", (0, security_1.authGuard)(ctx.tokenStore), async (req, res, next) => {
+        try {
+            const payload = parseBody(validation_1.gitFetchRequestSchema, req.body);
+            const workspaceRoot = (0, workspace_1.ensureWorkspaceRoot)(ctx.config.workspaceRoot);
+            await (0, git_1.resolveRepoPath)(workspaceRoot, payload.repoPath);
+            const job = ctx.jobManager.enqueue(async (jobCtx) => {
+                await (0, git_1.fetchRepo)(jobCtx, workspaceRoot, payload.repoPath, payload.remote, payload.prune);
+            });
+            res.status(202).json({ jobId: job.id });
+        }
+        catch (err) {
+            if (err instanceof git_1.RepoNotFoundError ||
+                err instanceof workspace_1.MissingPathError) {
+                next((0, errors_1.repoNotFound)());
+                return;
+            }
+            next(err);
+        }
+    });
+    app.get("/v1/git/status", (0, security_1.authGuard)(ctx.tokenStore), async (req, res, next) => {
+        try {
+            const { repoPath } = parseBody(validation_1.gitStatusQuerySchema, req.query);
+            const workspaceRoot = (0, workspace_1.ensureWorkspaceRoot)(ctx.config.workspaceRoot);
+            const status = await (0, git_1.getRepoStatus)(workspaceRoot, repoPath);
+            res.json(status);
+        }
+        catch (err) {
+            if (err instanceof git_1.RepoNotFoundError ||
+                err instanceof workspace_1.MissingPathError) {
+                next((0, errors_1.repoNotFound)());
+                return;
+            }
+            next(err);
+        }
+    });
+    app.post("/v1/os/open", (0, security_1.authGuard)(ctx.tokenStore), async (req, res, next) => {
+        try {
+            const origin = (0, security_1.getOrigin)(req);
+            const payload = parseBody(validation_1.osOpenRequestSchema, req.body);
+            const workspaceRoot = (0, workspace_1.ensureWorkspaceRoot)(ctx.config.workspaceRoot);
+            const resolved = await (0, workspace_1.resolveInsideWorkspace)(workspaceRoot, payload.path);
+            if (payload.target === "terminal") {
+                (0, approvals_1.requireApproval)(ctx.config, origin, resolved, "open-terminal", workspaceRoot);
+            }
+            if (payload.target === "vscode") {
+                (0, approvals_1.requireApproval)(ctx.config, origin, resolved, "open-vscode", workspaceRoot);
+            }
+            await (0, os_1.openTarget)(payload.target, resolved);
+            res.json({ ok: true });
+        }
+        catch (err) {
+            if (err instanceof workspace_1.MissingPathError) {
+                next((0, errors_1.pathNotFound)());
+                return;
+            }
+            next(err);
+        }
+    });
+    app.post("/v1/deps/install", (0, security_1.authGuard)(ctx.tokenStore), async (req, res, next) => {
+        try {
+            const origin = (0, security_1.getOrigin)(req);
+            const payload = parseBody(validation_1.depsInstallRequestSchema, req.body);
+            const workspaceRoot = (0, workspace_1.ensureWorkspaceRoot)(ctx.config.workspaceRoot);
+            const resolved = await (0, workspace_1.resolveInsideWorkspace)(workspaceRoot, payload.repoPath);
+            try {
+                await fs_1.promises.access(path_1.default.join(resolved, "package.json"));
+            }
+            catch {
+                throw (0, errors_1.repoNotFound)();
+            }
+            (0, approvals_1.requireApproval)(ctx.config, origin, resolved, "deps/install", workspaceRoot);
+            const job = ctx.jobManager.enqueue(async (jobCtx) => {
+                await (0, deps_1.installDeps)(jobCtx, workspaceRoot, {
+                    repoPath: payload.repoPath,
+                    manager: payload.manager ?? "auto",
+                    mode: payload.mode ?? "auto",
+                    safer: payload.safer ?? ctx.config.deps.defaultSafer,
+                });
+            });
+            res.status(202).json({ jobId: job.id });
+        }
+        catch (err) {
+            if (err instanceof workspace_1.MissingPathError) {
+                next((0, errors_1.pathNotFound)());
+                return;
+            }
+            next(err);
+        }
+    });
+    app.get("/v1/diagnostics", (0, security_1.authGuard)(ctx.tokenStore), (req, res, next) => {
+        try {
+            const summary = {
+                configVersion: ctx.config.configVersion,
+                server: ctx.config.server,
+                originAllowlist: ctx.config.originAllowlist,
+                workspaceRoot: ctx.config.workspaceRoot,
+                pairing: ctx.config.pairing,
+                jobs: ctx.config.jobs,
+                deps: ctx.config.deps,
+                logging: ctx.config.logging,
+            };
+            res.json({
+                config: summary,
+                recentErrors: [],
+                jobs: ctx.jobManager.listRecent(),
+                logTail: [],
+            });
+        }
+        catch (err) {
+            next(err);
+        }
+    });
+    app.use((err, _req, res, _next) => {
+        if (err instanceof errors_1.ApiError) {
+            res.status(err.status).json(err.body);
+            return;
+        }
+        if (err.type === "entity.too.large") {
+            res
+                .status(413)
+                .json((0, errors_1.errorBody)("request_too_large", "Request too large."));
+            return;
+        }
+        ctx.logger.error({ err }, "Unhandled error");
+        const fallback = (0, errors_1.internalError)();
+        res.status(fallback.status).json(fallback.body);
+    });
+    return app;
+};
+exports.createApp = createApp;

package/dist/approvals.js

@@ -0,0 +1,27 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.requireApproval = exports.hasApproval = void 0;
+const path_1 = __importDefault(require("path"));
+const errors_1 = require("./errors");
+const hasApproval = (config, origin, repoPath, capability, workspaceRoot) => config.approvals.entries.some((entry) => {
+    if (entry.origin !== origin || !entry.capabilities.includes(capability)) {
+        return false;
+    }
+    if (entry.repoPath === repoPath) {
+        return true;
+    }
+    if (workspaceRoot && !path_1.default.isAbsolute(entry.repoPath)) {
+        return path_1.default.resolve(workspaceRoot, entry.repoPath) === repoPath;
+    }
+    return false;
+});
+exports.hasApproval = hasApproval;
+const requireApproval = (config, origin, repoPath, capability, workspaceRoot) => {
+    if (!(0, exports.hasApproval)(config, origin, repoPath, capability, workspaceRoot)) {
+        throw (0, errors_1.capabilityNotGranted)();
+    }
+};
+exports.requireApproval = requireApproval;

package/dist/config.js

@@ -0,0 +1,107 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.saveConfig = exports.loadConfig = exports.ensureDir = exports.defaultConfig = exports.getTokensPath = exports.getConfigPath = exports.getConfigDir = void 0;
+const env_paths_1 = __importDefault(require("env-paths"));
+const path_1 = __importDefault(require("path"));
+const fs_1 = require("fs");
+const CONFIG_VERSION = 1;
+const CONFIG_FILE = "config.json";
+const TOKENS_FILE = "tokens.json";
+const getConfigDir = () => {
+    const override = process.env.GIT_DAEMON_CONFIG_DIR;
+    if (override) {
+        return override;
+    }
+    const paths = (0, env_paths_1.default)("Git Daemon", { suffix: "" });
+    return paths.config;
+};
+exports.getConfigDir = getConfigDir;
+const getConfigPath = (configDir) => path_1.default.join(configDir, CONFIG_FILE);
+exports.getConfigPath = getConfigPath;
+const getTokensPath = (configDir) => path_1.default.join(configDir, TOKENS_FILE);
+exports.getTokensPath = getTokensPath;
+const defaultConfig = () => ({
+    configVersion: CONFIG_VERSION,
+    server: {
+        host: "127.0.0.1",
+        port: 8790,
+    },
+    originAllowlist: ["https://app.example.com"],
+    workspaceRoot: null,
+    pairing: {
+        tokenTtlDays: 30,
+    },
+    jobs: {
+        maxConcurrent: 1,
+        timeoutSeconds: 3600,
+    },
+    deps: {
+        defaultSafer: true,
+    },
+    logging: {
+        directory: "logs",
+        maxFiles: 5,
+        maxBytes: 5 * 1024 * 1024,
+    },
+    approvals: {
+        entries: [],
+    },
+});
+exports.defaultConfig = defaultConfig;
+const ensureDir = async (dir) => {
+    await fs_1.promises.mkdir(dir, { recursive: true });
+};
+exports.ensureDir = ensureDir;
+const loadConfig = async (configDir) => {
+    await (0, exports.ensureDir)(configDir);
+    const configPath = (0, exports.getConfigPath)(configDir);
+    try {
+        const raw = await fs_1.promises.readFile(configPath, "utf8");
+        const data = JSON.parse(raw);
+        return {
+            ...(0, exports.defaultConfig)(),
+            ...data,
+            server: {
+                ...(0, exports.defaultConfig)().server,
+                ...data.server,
+            },
+            pairing: {
+                ...(0, exports.defaultConfig)().pairing,
+                ...data.pairing,
+            },
+            jobs: {
+                ...(0, exports.defaultConfig)().jobs,
+                ...data.jobs,
+            },
+            deps: {
+                ...(0, exports.defaultConfig)().deps,
+                ...data.deps,
+            },
+            logging: {
+                ...(0, exports.defaultConfig)().logging,
+                ...data.logging,
+            },
+            approvals: {
+                entries: data.approvals?.entries ?? [],
+            },
+        };
+    }
+    catch (err) {
+        if (err.code !== "ENOENT") {
+            throw err;
+        }
+        const config = (0, exports.defaultConfig)();
+        await (0, exports.saveConfig)(configDir, config);
+        return config;
+    }
+};
+exports.loadConfig = loadConfig;
+const saveConfig = async (configDir, config) => {
+    const configPath = (0, exports.getConfigPath)(configDir);
+    await (0, exports.ensureDir)(configDir);
+    await fs_1.promises.writeFile(configPath, JSON.stringify(config, null, 2));
+};
+exports.saveConfig = saveConfig;

package/dist/context.js

@@ -0,0 +1,58 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createContext = void 0;
+const path_1 = __importDefault(require("path"));
+const fs_1 = require("fs");
+const logger_1 = require("./logger");
+const tools_1 = require("./tools");
+const config_1 = require("./config");
+const tokens_1 = require("./tokens");
+const pairing_1 = require("./pairing");
+const jobs_1 = require("./jobs");
+const readPackageVersion = async () => {
+    try {
+        const pkgPath = path_1.default.resolve(__dirname, "..", "package.json");
+        const raw = await fs_1.promises.readFile(pkgPath, "utf8");
+        const parsed = JSON.parse(raw);
+        return parsed.version ?? "0.0.0";
+    }
+    catch {
+        return "0.0.0";
+    }
+};
+const createContext = async () => {
+    const configDir = (0, config_1.getConfigDir)();
+    const config = await (0, config_1.loadConfig)(configDir);
+    if (!config.originAllowlist.length) {
+        throw new Error("originAllowlist must contain at least one entry.");
+    }
+    if (config.server.host !== "127.0.0.1") {
+        throw new Error("Server host must be 127.0.0.1 for loopback-only binding.");
+    }
+    const tokenStore = new tokens_1.TokenStore(configDir);
+    await tokenStore.load();
+    const logger = await (0, logger_1.createLogger)(configDir, config.logging);
+    const capabilities = await (0, tools_1.detectCapabilities)();
+    const pairingManager = new pairing_1.PairingManager(tokenStore, config.pairing.tokenTtlDays);
+    const jobManager = new jobs_1.JobManager(config.jobs.maxConcurrent, config.jobs.timeoutSeconds);
+    const version = await readPackageVersion();
+    const build = {
+        commit: process.env.GIT_DAEMON_BUILD_COMMIT,
+        date: process.env.GIT_DAEMON_BUILD_DATE,
+    };
+    return {
+        config,
+        configDir,
+        tokenStore,
+        pairingManager,
+        jobManager,
+        capabilities,
+        logger,
+        version,
+        build,
+    };
+};
+exports.createContext = createContext;

package/dist/daemon.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const context_1 = require("./context");
+const app_1 = require("./app");
+const start = async () => {
+    const ctx = await (0, context_1.createContext)();
+    const app = (0, app_1.createApp)(ctx);
+    const startupSummary = {
+        configDir: ctx.configDir,
+        host: ctx.config.server.host,
+        port: ctx.config.server.port,
+        workspaceRoot: ctx.config.workspaceRoot ?? "not configured",
+        originAllowlist: ctx.config.originAllowlist,
+    };
+    ctx.logger.info(startupSummary, "Git Daemon starting");
+    if (process.env.GIT_DAEMON_LOG_STDOUT !== "1") {
+        console.log(`[Git Daemon] config=${startupSummary.configDir} host=${startupSummary.host} port=${startupSummary.port}`);
+    }
+    app.listen(ctx.config.server.port, ctx.config.server.host, () => {
+        ctx.logger.info({
+            host: ctx.config.server.host,
+            port: ctx.config.server.port,
+        }, "Git Daemon listening");
+    });
+};
+start().catch((err) => {
+    console.error("Failed to start Git Daemon", err);
+    process.exit(1);
+});