git-daemon 0.1.1 → 0.1.3

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,34 @@
+"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] Startup");
+        console.log(`  config: ${startupSummary.configDir}`);
+        console.log(`  host: ${startupSummary.host}`);
+        console.log(`  port: ${startupSummary.port}`);
+        console.log(`  workspace: ${startupSummary.workspaceRoot}`);
+        console.log(`  allowlist: ${startupSummary.originAllowlist.join(", ") || "none"}`);
+    }
+    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);
+});

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;