@capybara-hq/kernel 0.1.0-rc.26 → 0.1.0-rc.28

package/dist/git/run-end.js

@@ -0,0 +1,121 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __param = (this && this.__param) || function (paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
+};
+import { Inject, Injectable } from "@nestjs/common";
+import { audit } from "../identity/audit.js";
+import { KernelDb } from "../infra/database/kernel-db.js";
+import { KERNEL_LOGGER, REDIS } from "../infra/tokens.js";
+import { GitTickets } from "./tickets.js";
+/**
+ * What a run's end does for the git gateway (sandbox git credentials spec §9): revokes the run's
+ * tickets and writes the `git.fetch` summaries. `RunFinish` calls it in `afterCommit` of the
+ * transaction that set the terminal status (set first, then revoke: `GitTickets.resolve` already
+ * refuses a run that is not active, so revocation is cleanup and defense in depth).
+ */
+/** The Redis hash of a run's fetch counters: fields `<host>/<repo>|n` and `<host>/<repo>|bytes`. */
+export const gitFetchKey = (runId) => `git-fetch:${runId}`;
+/**
+ * Counters of a run that never ends cleanly (a lost end hook) expire after this. A fetch still in
+ * flight after the run ended writes a counter nobody summarises: it expires by this TTL too.
+ */
+export const FETCH_COUNTER_TTL_SECONDS = 24 * 60 * 60;
+/** Adds one fetch request and its bytes to the run's counters (atomic, with a TTL). */
+export async function recordGitFetch(redis, runId, host, repo, bytes, countRequest) {
+    const key = gitFetchKey(runId);
+    const field = `${host}/${repo}`;
+    const m = redis.multi();
+    if (countRequest)
+        m.hincrby(key, `${field}|n`, 1);
+    m.hincrby(key, `${field}|bytes`, Math.max(0, Math.round(bytes)));
+    await m.expire(key, FETCH_COUNTER_TTL_SECONDS).exec();
+}
+/** Reads and deletes a hash in one step, so a summary is written once. */
+const TAKE_HASH = `
+local all = redis.call('HGETALL', KEYS[1])
+redis.call('DEL', KEYS[1])
+return all
+`;
+let GitRunEnd = class GitRunEnd {
+    tickets;
+    db;
+    redis;
+    log;
+    constructor(tickets, db, redis, log) {
+        this.tickets = tickets;
+        this.db = db;
+        this.redis = redis;
+        this.log = log;
+    }
+    /** Run end: revokes the run's tickets and writes one `git.fetch` audit row per repository. */
+    async onRunFinished(runId) {
+        // both steps always run: a failing revocation must not lose the summaries, nor the reverse
+        const results = await Promise.allSettled([
+            this.tickets.revokeRun(runId),
+            this.writeFetchSummaries(runId),
+        ]);
+        for (const r of results) {
+            if (r.status === "rejected") {
+                this.log.warn("git run end failed", {
+                    runId,
+                    error: r.reason instanceof Error ? r.reason.name : "unknown",
+                });
+            }
+        }
+    }
+    async writeFetchSummaries(runId) {
+        const flat = (await this.redis.eval(TAKE_HASH, 1, gitFetchKey(runId)));
+        if (flat.length === 0)
+            return;
+        const perRepo = new Map();
+        for (let i = 0; i + 1 < flat.length; i += 2) {
+            const field = String(flat[i]);
+            const cut = field.lastIndexOf("|");
+            const target = field.slice(0, cut);
+            const entry = perRepo.get(target) ?? { count: 0, bytes: 0 };
+            if (field.slice(cut + 1) === "n")
+                entry.count = Number(flat[i + 1]);
+            else
+                entry.bytes = Number(flat[i + 1]);
+            perRepo.set(target, entry);
+        }
+        const run = await this.db.db
+            .selectFrom("runs")
+            .innerJoin("conversations", "conversations.id", "runs.conversation_id")
+            .select(["runs.conversation_id", "runs.trigger_account_id", "conversations.org_id"])
+            .where("runs.id", "=", runId)
+            .executeTakeFirst();
+        if (run === undefined)
+            return;
+        for (const [target, { count, bytes }] of perRepo) {
+            const slash = target.indexOf("/");
+            await audit(this.db.db, {
+                actorAccountId: run.trigger_account_id,
+                orgId: run.org_id,
+                action: "git.fetch",
+                target,
+                detail: {
+                    runId,
+                    conversationId: run.conversation_id,
+                    host: target.slice(0, slash),
+                    repo: target.slice(slash + 1),
+                    count,
+                    bytes,
+                },
+            });
+        }
+    }
+};
+GitRunEnd = __decorate([
+    Injectable(),
+    __param(0, Inject(GitTickets)),
+    __param(1, Inject(KernelDb)),
+    __param(2, Inject(REDIS)),
+    __param(3, Inject(KERNEL_LOGGER))
+], GitRunEnd);
+export { GitRunEnd };

package/dist/git/sources.d.ts

@@ -0,0 +1,42 @@
+import { KernelConfigService } from "../infra/config/kernel-config.service.js";
+import { KernelDb } from "../infra/database/kernel-db.js";
+import { Credentials } from "../tools/credentials.js";
+/**
+ * Git sources (sandbox git credentials spec §6): which connector's credential the git gateway
+ * presents to a git host for one actor. Everything is read live per call (no process memory).
+ */
+/** The source of one git host for one actor. */
+export interface GitSourceFor {
+    /** The git host (from the connector's `git_hosts`), e.g. `github.com`. */
+    host: string;
+    connectorId: string;
+    /** The basic username the host expects with a token password (GitHub: `x-access-token`). */
+    username: string;
+    /** An org connector an admin turned on for git: pushes are the bot's, not the person's. */
+    bot: boolean;
+}
+export declare class GitSources {
+    private readonly db;
+    private readonly credentials;
+    /** Read per call: `tools.git.enabled` is hot. */
+    private readonly config;
+    constructor(db: KernelDb, credentials: Pick<Credentials, "status">, 
+    /** Read per call: `tools.git.enabled` is hot. */
+    config: Pick<KernelConfigService, "get">);
+    /**
+     * The git sources of `accountId` in `orgId`, one per host (spec §6.2):
+     *
+     * - nothing while the gateway is off (`tools.git.enabled`, the org's `gitGateway.enabled`), for
+     *   an account that is not an active member of the live org, or for an anonymous channel guest;
+     * - one connector per host for the whole org ("never mixed"): the org's
+     *   `gitGateway.hostSources[host]` pick; without one, among the org's live, active connectors
+     *   declaring the host (personal-ownership ones, and org-credential ones only with
+     *   `use_for_git`): a personal one before a bot (a bot is the default only when no personal
+     *   connector declares the host), the authorization-code (`oauth_code`) one first, else the
+     *   oldest;
+     * - the account gets that connector only when it can use it: its own credential for a
+     *   personal one (never another account's), the org credential for a bot (`bot: true`);
+     *   otherwise no source for the host, never another connector.
+     */
+    sourcesFor(orgId: string, accountId: string): Promise<GitSourceFor[]>;
+}

package/dist/git/sources.js

@@ -0,0 +1,134 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __param = (this && this.__param) || function (paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
+};
+import { Inject, Injectable } from "@nestjs/common";
+import { KernelConfigService } from "../infra/config/kernel-config.service.js";
+import { KernelDb } from "../infra/database/kernel-db.js";
+import { isAnonymousGuest } from "../orgs/members.service.js";
+import { readOrgSettings } from "../orgs/settings.service.js";
+import { Credentials, isOAuth } from "../tools/credentials.js";
+/**
+ * The org-wide default among a host's candidates (no pick): personal-ownership connectors before
+ * `use_for_git` bots, then the authorization-code one, then the oldest, then the lowest id.
+ */
+function byDefault(a, b) {
+    return (Number(a.bot) - Number(b.bot) ||
+        Number(b.oauthCode) - Number(a.oauthCode) ||
+        a.createdAt.getTime() - b.createdAt.getTime() ||
+        a.connectorId.localeCompare(b.connectorId));
+}
+/** Auth types whose credential can be presented as a basic password (not `none` / `headers`). */
+const gitCapable = (auth) => auth.type === "bearer" || auth.type === "api_key" || auth.type === "basic" || isOAuth(auth);
+let GitSources = class GitSources {
+    db;
+    credentials;
+    config;
+    constructor(db, credentials, 
+    /** Read per call: `tools.git.enabled` is hot. */
+    config) {
+        this.db = db;
+        this.credentials = credentials;
+        this.config = config;
+    }
+    /**
+     * The git sources of `accountId` in `orgId`, one per host (spec §6.2):
+     *
+     * - nothing while the gateway is off (`tools.git.enabled`, the org's `gitGateway.enabled`), for
+     *   an account that is not an active member of the live org, or for an anonymous channel guest;
+     * - one connector per host for the whole org ("never mixed"): the org's
+     *   `gitGateway.hostSources[host]` pick; without one, among the org's live, active connectors
+     *   declaring the host (personal-ownership ones, and org-credential ones only with
+     *   `use_for_git`): a personal one before a bot (a bot is the default only when no personal
+     *   connector declares the host), the authorization-code (`oauth_code`) one first, else the
+     *   oldest;
+     * - the account gets that connector only when it can use it: its own credential for a
+     *   personal one (never another account's), the org credential for a bot (`bot: true`);
+     *   otherwise no source for the host, never another connector.
+     */
+    async sourcesFor(orgId, accountId) {
+        if (!this.config.get().tools.git.enabled)
+            return [];
+        const db = this.db.db;
+        const member = await db
+            .selectFrom("memberships as m")
+            .innerJoin("accounts as a", "a.id", "m.account_id")
+            .innerJoin("orgs as o", "o.id", "m.org_id")
+            .select("m.account_id")
+            .where("m.org_id", "=", orgId)
+            .where("m.account_id", "=", accountId)
+            .where("a.status", "=", "active")
+            .where("o.deleted_at", "is", null)
+            .executeTakeFirst();
+        if (member === undefined)
+            return [];
+        // anonymous channel guests never get a credential (spec §6.2)
+        if (await isAnonymousGuest(db, accountId))
+            return [];
+        const settings = await readOrgSettings(db, orgId);
+        if (settings.gitGateway?.enabled === false)
+            return [];
+        const rows = await db
+            .selectFrom("connectors")
+            .select(["id", "auth", "git_hosts", "use_for_git", "created_at"])
+            .where("org_id", "=", orgId)
+            .where("deleted_at", "is", null)
+            .where("status", "=", "active")
+            .where("git_hosts", "is not", null)
+            .execute();
+        const byHost = new Map();
+        for (const r of rows) {
+            const auth = r.auth;
+            if (!gitCapable(auth))
+                continue;
+            const bot = auth.ownership === "org";
+            if (bot && !r.use_for_git)
+                continue;
+            for (const h of (r.git_hosts ?? [])) {
+                const list = byHost.get(h.host) ?? [];
+                list.push({
+                    host: h.host,
+                    connectorId: r.id,
+                    username: h.username,
+                    bot,
+                    auth,
+                    oauthCode: auth.type === "oauth_code",
+                    createdAt: new Date(r.created_at),
+                });
+                byHost.set(h.host, list);
+            }
+        }
+        const picks = settings.gitGateway?.hostSources ?? {};
+        const out = [];
+        for (const [host, list] of [...byHost].sort(([a], [b]) => a.localeCompare(b))) {
+            const chosen = Object.hasOwn(picks, host)
+                ? list.find((c) => c.connectorId === picks[host])
+                : [...list].sort(byDefault)[0];
+            if (chosen === undefined)
+                continue;
+            // personal: this account's own credential; bot: the org's (status never decrypts)
+            const usable = await this.credentials.status(orgId, chosen.connectorId, chosen.auth, accountId);
+            if (usable !== "connected")
+                continue;
+            out.push({
+                host,
+                connectorId: chosen.connectorId,
+                username: chosen.username,
+                bot: chosen.bot,
+            });
+        }
+        return out;
+    }
+};
+GitSources = __decorate([
+    Injectable(),
+    __param(0, Inject(KernelDb)),
+    __param(1, Inject(Credentials)),
+    __param(2, Inject(KernelConfigService))
+], GitSources);
+export { GitSources };

package/dist/git/tickets.d.ts

@@ -0,0 +1,69 @@
+import type { Redis } from "ioredis";
+import type { KernelConfig } from "../config/schema.js";
+import { KernelConfigService } from "../infra/config/kernel-config.service.js";
+import { KernelDb } from "../infra/database/kernel-db.js";
+import type { KernelLogger } from "../log.js";
+/**
+ * Run tickets of the git gateway (sandbox git credentials spec §4, §5.1, §9): an opaque bearer
+ * value one exec gets in its environment, bound to one run and one person. Only the SHA-256 of
+ * the ticket is stored (Redis `git-ticket:<hash>` → the JSON binding, TTL
+ * `tools.git.ticketTtlSeconds`); the run's set `git-run-tickets:<runId>` lists the hashes for
+ * revocation. The raw ticket is never stored or logged: logs carry the first 8 hex characters of
+ * its hash. Every resolve re-checks the run, the membership and the switches live, so nothing is
+ * cached in process memory (any replica resolves what another issued).
+ */
+/** What a ticket is issued for. */
+export interface GitTicketRequest {
+    orgId: string;
+    /** The actor: the account the exec runs for (the run's trigger account). */
+    accountId: string;
+    runId: string;
+    execId: string;
+    /** The git hosts the ticket may reach (from the org's git sources), e.g. `github.com`. */
+    hosts: string[];
+    /** Optional repository allowlist (`owner/name`); absent = every repository on the hosts. */
+    repos?: string[];
+}
+/** A ticket's stored binding. */
+export interface GitTicketBinding extends GitTicketRequest {
+    /** When the ticket was issued (epoch ms). */
+    issuedAt: number;
+}
+/** The Redis key of a ticket's binding. */
+export declare const gitTicketKey: (hash: string) => string;
+/** The Redis set of a run's ticket hashes. */
+export declare const gitRunTicketsKey: (runId: string) => string;
+/** The SHA-256 (hex) of a raw ticket: the only form the kernel stores. */
+export declare const hashGitTicket: (raw: string) => string;
+/**
+ * The origin sandboxes reach the git gateway at: `tools.git.gatewayUrl`, else `http.publicUrl`;
+ * null when neither is set (the gateway cannot be offered).
+ */
+export declare function gitGatewayOrigin(config: Pick<KernelConfig, "tools" | "http">): string | null;
+export declare class GitTickets {
+    private readonly redis;
+    private readonly db;
+    /** Read per call: `tools.git.enabled` is hot. */
+    private readonly config;
+    private readonly log;
+    constructor(redis: Redis, db: KernelDb, 
+    /** Read per call: `tools.git.enabled` is hot. */
+    config: Pick<KernelConfigService, "get">, log: Pick<KernelLogger, "debug">);
+    /**
+     * Issues a ticket for one exec and returns the raw value (it goes only into that exec's
+     * environment). Stores the binding under the ticket's hash and adds the hash to the run's set,
+     * the ticket with the ticket TTL, the set with the longest TTL any of its tickets got.
+     */
+    issue(req: GitTicketRequest): Promise<string>;
+    /**
+     * The binding of a raw ticket, or null: unknown or expired, or no longer usable because the run
+     * is not active (or belongs to another org), the account is not an active member of the org, or
+     * the gateway is off (`tools.git.enabled`, the org's `gitGateway.enabled`). Every check is live.
+     */
+    resolve(raw: string): Promise<GitTicketBinding | null>;
+    /**
+     * Deletes every ticket of the run (run end, abort, offboarding) in one Lua script, so a ticket
+     * added concurrently is either deleted with the rest or left in a set that still lists it.
+     */
+    revokeRun(runId: string): Promise<void>;
+}

package/dist/git/tickets.js

@@ -0,0 +1,194 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __param = (this && this.__param) || function (paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
+};
+import { createHash, randomBytes } from "node:crypto";
+import { Inject, Injectable } from "@nestjs/common";
+import { z } from "zod";
+import { KernelConfigService } from "../infra/config/kernel-config.service.js";
+import { KernelDb } from "../infra/database/kernel-db.js";
+import { KERNEL_LOGGER, REDIS } from "../infra/tokens.js";
+import { readOrgSettings } from "../orgs/settings.service.js";
+const BindingSchema = z.object({
+    orgId: z.string().min(1),
+    accountId: z.string().min(1),
+    runId: z.string().min(1),
+    execId: z.string().min(1),
+    hosts: z.array(z.string()),
+    repos: z.array(z.string()).optional(),
+    issuedAt: z.number(),
+});
+/** Run statuses during which the run's tickets stay valid. */
+const ACTIVE_RUN_STATUSES = ["queued", "running", "waiting"];
+/** A raw ticket: 32 random bytes in base64url (43 characters, no padding). */
+const TICKET_SHAPE = /^[A-Za-z0-9_-]{43}$/;
+/** The Redis key of a ticket's binding. */
+export const gitTicketKey = (hash) => `git-ticket:${hash}`;
+/** The Redis set of a run's ticket hashes. */
+export const gitRunTicketsKey = (runId) => `git-run-tickets:${runId}`;
+/** The SHA-256 (hex) of a raw ticket: the only form the kernel stores. */
+export const hashGitTicket = (raw) => createHash("sha256").update(raw, "utf8").digest("hex");
+/**
+ * The origin sandboxes reach the git gateway at: `tools.git.gatewayUrl`, else `http.publicUrl`;
+ * null when neither is set (the gateway cannot be offered).
+ */
+export function gitGatewayOrigin(config) {
+    const url = config.tools.git.gatewayUrl ?? config.http.publicUrl;
+    if (url === undefined || !URL.canParse(url))
+        return null;
+    return new URL(url).origin;
+}
+let GitTickets = class GitTickets {
+    redis;
+    db;
+    config;
+    log;
+    constructor(redis, db, 
+    /** Read per call: `tools.git.enabled` is hot. */
+    config, log) {
+        this.redis = redis;
+        this.db = db;
+        this.config = config;
+        this.log = log;
+    }
+    /**
+     * Issues a ticket for one exec and returns the raw value (it goes only into that exec's
+     * environment). Stores the binding under the ticket's hash and adds the hash to the run's set,
+     * the ticket with the ticket TTL, the set with the longest TTL any of its tickets got.
+     */
+    async issue(req) {
+        const raw = randomBytes(32).toString("base64url");
+        const hash = hashGitTicket(raw);
+        const ttl = this.config.get().tools.git.ticketTtlSeconds;
+        const binding = {
+            orgId: req.orgId,
+            accountId: req.accountId,
+            runId: req.runId,
+            execId: req.execId,
+            hosts: [...req.hosts],
+            ...(req.repos !== undefined && { repos: [...req.repos] }),
+            issuedAt: Date.now(),
+        };
+        try {
+            await this.redis.eval(ISSUE, 2, gitTicketKey(hash), gitRunTicketsKey(req.runId), JSON.stringify(binding), String(ttl), hash);
+        }
+        catch {
+            // a ticket whose binding or revocation entry was not written must not be handed out
+            // (the script lists the ticket first, so a failure leaves no binding behind)
+            throw new Error("git ticket: storing the binding in Redis failed");
+        }
+        this.log.debug("git ticket issued", {
+            ticket: hash.slice(0, 8),
+            runId: req.runId,
+            execId: req.execId,
+        });
+        return raw;
+    }
+    /**
+     * The binding of a raw ticket, or null: unknown or expired, or no longer usable because the run
+     * is not active (or belongs to another org), the account is not an active member of the org, or
+     * the gateway is off (`tools.git.enabled`, the org's `gitGateway.enabled`). Every check is live.
+     */
+    async resolve(raw) {
+        if (!TICKET_SHAPE.test(raw))
+            return null;
+        const hash = hashGitTicket(raw);
+        const refuse = (reason) => {
+            this.log.debug("git ticket refused", { ticket: hash.slice(0, 8), reason });
+            return null;
+        };
+        if (!this.config.get().tools.git.enabled)
+            return refuse("gateway disabled");
+        const stored = await this.redis.get(gitTicketKey(hash));
+        if (stored === null)
+            return refuse("unknown or expired");
+        const binding = parseBinding(stored);
+        if (binding === null)
+            return refuse("invalid binding");
+        const run = await this.db
+            .selectFrom("runs")
+            .innerJoin("conversations", "conversations.id", "runs.conversation_id")
+            .innerJoin("orgs", "orgs.id", "conversations.org_id")
+            .select(["runs.status", "conversations.org_id"])
+            .where("runs.id", "=", binding.runId)
+            .where("orgs.deleted_at", "is", null)
+            .executeTakeFirst();
+        if (run === undefined || run.org_id !== binding.orgId)
+            return refuse("run not in org");
+        if (!ACTIVE_RUN_STATUSES.includes(run.status)) {
+            return refuse("run not active");
+        }
+        const member = await this.db
+            .selectFrom("memberships")
+            .innerJoin("accounts", "accounts.id", "memberships.account_id")
+            .select("memberships.account_id")
+            .where("memberships.org_id", "=", binding.orgId)
+            .where("memberships.account_id", "=", binding.accountId)
+            .where("accounts.status", "=", "active")
+            .executeTakeFirst();
+        if (member === undefined)
+            return refuse("not an active member");
+        const settings = await readOrgSettings(this.db.db, binding.orgId);
+        if (settings.gitGateway?.enabled === false)
+            return refuse("gateway off for the org");
+        return binding;
+    }
+    /**
+     * Deletes every ticket of the run (run end, abort, offboarding) in one Lua script, so a ticket
+     * added concurrently is either deleted with the rest or left in a set that still lists it.
+     */
+    async revokeRun(runId) {
+        const count = await this.redis.eval(REVOKE_RUN, 1, gitRunTicketsKey(runId), TICKET_KEY_PREFIX);
+        if (typeof count === "number" && count > 0) {
+            this.log.debug("git tickets revoked", { runId, count });
+        }
+    }
+};
+GitTickets = __decorate([
+    Injectable(),
+    __param(0, Inject(REDIS)),
+    __param(1, Inject(KernelDb)),
+    __param(2, Inject(KernelConfigService)),
+    __param(3, Inject(KERNEL_LOGGER))
+], GitTickets);
+export { GitTickets };
+/**
+ * Both scripts below build ticket keys from {@link TICKET_KEY_PREFIX} instead of declaring them in
+ * KEYS, so they assume a non-Cluster Redis / Valkey (one node, or Sentinel).
+ */
+const TICKET_KEY_PREFIX = "git-ticket:";
+/**
+ * Lists the ticket in the run's set, stores its binding with the TTL and gives the set a TTL that
+ * only grows (KEYS: ticket, run set; ARGV: binding, ttl, hash): lowering `ticketTtlSeconds` must
+ * not cut the set below a live ticket.
+ */
+const ISSUE = `
+redis.call('SADD', KEYS[2], ARGV[3])
+redis.call('SET', KEYS[1], ARGV[1], 'EX', ARGV[2])
+if redis.call('TTL', KEYS[2]) < tonumber(ARGV[2]) then redis.call('EXPIRE', KEYS[2], ARGV[2]) end
+return 1
+`;
+/** Reads the run's set, deletes every listed ticket and the set (KEYS[1]; ARGV[1] the ticket key prefix). */
+const REVOKE_RUN = `
+local hashes = redis.call('SMEMBERS', KEYS[1])
+for _, h in ipairs(hashes) do redis.call('DEL', ARGV[1] .. h) end
+redis.call('DEL', KEYS[1])
+return #hashes
+`;
+function parseBinding(stored) {
+    try {
+        const r = BindingSchema.safeParse(JSON.parse(stored));
+        if (!r.success)
+            return null;
+        const { repos, ...rest } = r.data;
+        return { ...rest, ...(repos !== undefined && { repos }) };
+    }
+    catch {
+        return null;
+    }
+}

package/dist/http/api.module.js

@@ -49,6 +49,7 @@ import { ExtensionsModule } from "../extensions/extensions.module.js";
 import { ExtensionPointDefaultsController } from "../extensions/point-defaults.controller.js";
 import { FilesModule } from "../files/files.module.js";
 import { FilePreviewersController } from "../files/previewers.controller.js";
+import { GitModule } from "../git/git.module.js";
 import { AuthController } from "../identity/auth.controller.js";
 import { AuthGuard } from "../identity/auth.guard.js";
 import { IdentityModule } from "../identity/identity.module.js";
@@ -211,6 +212,8 @@ ApiModule = __decorate([
             SetupModule,
             // scheduled tasks (the controller comes with the HTTP routes)
             SchedulesModule,
+            // the git gateway (run tickets; the gateway route comes with it)
+            GitModule,
         ],
         controllers: CONTROLLERS,
         providers: [{ provide: APP_GUARD, useClass: AuthGuard }],

package/dist/http/app.d.ts

@@ -3,6 +3,7 @@ import type { Logger } from "@capybara-hq/plugin-sdk";
 import type { NestFastifyApplication } from "@nestjs/platform-fastify";
 import type { InjectOptions, LightMyRequestResponse } from "fastify";
 import type { Route } from "../ctx/create-ctx.js";
+import type { GitGateway } from "../git/gateway.js";
 import { type GatewayRoutes } from "./gateway-routes.js";
 import { type PluginRouteTable } from "./plugin-dispatch.js";
 /** 内核 HTTP 的只读视图：进程内注入请求与列出路由（测试与元测试用）。 */
@@ -41,6 +42,11 @@ export interface CreateHttpAppOptions {
      * when `roles` includes `gateway` (`serveGateway`).
      */
     gateway?: GatewayRoutes;
+    /**
+     * The git gateway (`/git/v1/*`, a raw route outside Nest), registered only when given: the
+     * kernel passes it when `roles` includes `api`.
+     */
+    git?: Pick<GitGateway, "handle">;
     /** 副本标识（`http.replicaId`）：设置时每个响应带 `x-capybara-replica` 头。 */
     replicaId?: string | undefined;
     /**

package/dist/http/app.js

@@ -1,6 +1,7 @@
 import "reflect-metadata";
 import fastifyCookie from "@fastify/cookie";
 import { ApiError, errorBody } from "../errors.js";
+import { registerGitGatewayRoute } from "../git/gateway.route.js";
 import { AccountsService } from "../identity/accounts.js";
 import { ApiTokenService } from "../identity/api-tokens.js";
 import { authenticateOrgUploader, authorizeSuperAdmin, } from "../identity/auth.guard.js";
@@ -171,6 +172,8 @@ export async function createHttpApp(opts, app) {
         : undefined;
     if (opts.gateway)
         await registerGatewayRoutes(fastify, opts.gateway, opts.log);
+    if (opts.git)
+        await registerGitGatewayRoute(fastify, opts.git, opts.log);
     return {
         inject: (o) => fastify.inject(o),
         routes: () => [...routes],

package/dist/infra/config/kernel-config.service.js

@@ -28,6 +28,8 @@ const HOT_APPLIERS = {
     // Login methods and trusted identity sources are read on every request.
     "auth.loginSources": () => { },
     "auth.trustedIdentitySources": () => { },
+    // The git gateway reads tools.git.enabled through the config service on every request.
+    "tools.git.enabled": () => { },
     // The hook registry reads the time limit on every run.
     "hooks.timeoutMs": () => { },
     // The provider registry reads the list time limit at every listModels call.