@jagit/shared 0.0.1

package/dist/events.d.ts

@@ -0,0 +1,13 @@
+import { Redis } from "ioredis";
+import type { ControlSignal } from "./types.js";
+/** Channel name for live job event streaming (dashboard SSE) */
+export declare const jobChannel: (jobId: string) => string;
+/** Channel name for worker control signals (stop/pause/resume/approval) */
+export declare const controlChannel: (jobId: string) => string;
+/** Channel name for global approval events (SSE + worker graph) */
+export declare const approvalsChannel = "approvals";
+export declare function makeRedis(url: string): Redis;
+/** Publish any JSON-serialisable payload to a channel */
+export declare function publishEvent(url: string, channel: string, data: unknown): Promise<void>;
+/** Publish a control signal to the worker monitoring the given job */
+export declare function publishControl(url: string, signal: ControlSignal): Promise<void>;

package/dist/events.js

@@ -0,0 +1,24 @@
+import { Redis } from "ioredis";
+/** Channel name for live job event streaming (dashboard SSE) */
+export const jobChannel = (jobId) => `job:${jobId}`;
+/** Channel name for worker control signals (stop/pause/resume/approval) */
+export const controlChannel = (jobId) => `control:${jobId}`;
+/** Channel name for global approval events (SSE + worker graph) */
+export const approvalsChannel = "approvals";
+export function makeRedis(url) {
+    return new Redis(url, { maxRetriesPerRequest: null, lazyConnect: false });
+}
+/** Publish any JSON-serialisable payload to a channel */
+export async function publishEvent(url, channel, data) {
+    const client = makeRedis(url);
+    try {
+        await client.publish(channel, JSON.stringify(data));
+    }
+    finally {
+        await client.quit();
+    }
+}
+/** Publish a control signal to the worker monitoring the given job */
+export async function publishControl(url, signal) {
+    return publishEvent(url, controlChannel(signal.jobId), signal);
+}

package/dist/git-worktree.d.ts

@@ -0,0 +1,2 @@
+/** Best-effort removal of a git worktree directory. */
+export declare function removeWorktree(worktreePath: string): Promise<void>;

package/dist/git-worktree.js

@@ -0,0 +1,14 @@
+import { execFile } from "node:child_process";
+import { promisify } from "node:util";
+const execFileAsync = promisify(execFile);
+/** Best-effort removal of a git worktree directory. */
+export async function removeWorktree(worktreePath) {
+    if (!worktreePath)
+        return;
+    try {
+        await execFileAsync("git", ["worktree", "remove", "--force", worktreePath]);
+    }
+    catch {
+        // already removed or path invalid
+    }
+}

package/dist/index.d.ts

@@ -0,0 +1,15 @@
+export * from "./config.js";
+export * from "./crypto.js";
+export { CredentialKindSchema, JiraCredentialSchema, GitLabCredentialSchema, AnthropicCredentialSchema, TelegramCredentialSchema, credentialSecretKeys, validateCredential, mergeSecrets, } from "./credentials.js";
+export type { CredentialKind } from "./credentials.js";
+export * from "./prisma.js";
+export * from "./branch.js";
+export * from "./retry.js";
+export * from "./queue.js";
+export * from "./events.js";
+export * from "./types.js";
+export * from "./git-worktree.js";
+export * from "./seed.js";
+export * from "./mcp-config.js";
+export * from "./mcp-servers.js";
+export * from "./approval-bridge.js";

package/dist/index.js

@@ -0,0 +1,14 @@
+export * from "./config.js";
+export * from "./crypto.js";
+export { CredentialKindSchema, JiraCredentialSchema, GitLabCredentialSchema, AnthropicCredentialSchema, TelegramCredentialSchema, credentialSecretKeys, validateCredential, mergeSecrets, } from "./credentials.js";
+export * from "./prisma.js";
+export * from "./branch.js";
+export * from "./retry.js";
+export * from "./queue.js";
+export * from "./events.js";
+export * from "./types.js";
+export * from "./git-worktree.js";
+export * from "./seed.js";
+export * from "./mcp-config.js";
+export * from "./mcp-servers.js";
+export * from "./approval-bridge.js";

package/dist/mcp-config.d.ts

@@ -0,0 +1,77 @@
+import { z } from "zod";
+import { CredentialKindSchema } from "./credentials.js";
+export declare const McpTransportSchema: z.ZodEnum<{
+    stdio: "stdio";
+    http: "http";
+}>;
+export declare const McpEnvCredentialRefSchema: z.ZodObject<{
+    type: z.ZodLiteral<"credential">;
+    kind: z.ZodEnum<{
+        jira: "jira";
+        gitlab: "gitlab";
+        telegram: "telegram";
+        anthropic: "anthropic";
+    }>;
+    name: z.ZodString;
+    secretKey: z.ZodString;
+}, z.core.$strip>;
+export declare const McpEnvValueSchema: z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+    type: z.ZodLiteral<"credential">;
+    kind: z.ZodEnum<{
+        jira: "jira";
+        gitlab: "gitlab";
+        telegram: "telegram";
+        anthropic: "anthropic";
+    }>;
+    name: z.ZodString;
+    secretKey: z.ZodString;
+}, z.core.$strip>]>;
+export declare const McpServerConfigBodySchema: z.ZodObject<{
+    name: z.ZodString;
+    transport: z.ZodDefault<z.ZodEnum<{
+        stdio: "stdio";
+        http: "http";
+    }>>;
+    enabled: z.ZodDefault<z.ZodBoolean>;
+    command: z.ZodOptional<z.ZodString>;
+    args: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    env: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+        type: z.ZodLiteral<"credential">;
+        kind: z.ZodEnum<{
+            jira: "jira";
+            gitlab: "gitlab";
+            telegram: "telegram";
+            anthropic: "anthropic";
+        }>;
+        name: z.ZodString;
+        secretKey: z.ZodString;
+    }, z.core.$strip>]>>>;
+    url: z.ZodOptional<z.ZodString>;
+    headers: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+        type: z.ZodLiteral<"credential">;
+        kind: z.ZodEnum<{
+            jira: "jira";
+            gitlab: "gitlab";
+            telegram: "telegram";
+            anthropic: "anthropic";
+        }>;
+        name: z.ZodString;
+        secretKey: z.ZodString;
+    }, z.core.$strip>]>>>;
+}, z.core.$strip>;
+export type McpServerConfigBody = z.infer<typeof McpServerConfigBodySchema>;
+export type McpTransport = z.infer<typeof McpTransportSchema>;
+export type McpEnvValue = z.infer<typeof McpEnvValueSchema>;
+export type McpEnvCredentialRef = z.infer<typeof McpEnvCredentialRefSchema>;
+export type CredentialResolver = (kind: z.infer<typeof CredentialKindSchema>, name: string) => Promise<Record<string, string>>;
+/** Resolve MCP env/header map to plain string values. */
+export declare function resolveMcpEnv(env: Record<string, McpEnvValue>, resolveCredential: CredentialResolver): Promise<Record<string, string>>;
+/** Whether a chosen approval option counts as human approval for commit guard. */
+export declare function isApproveOptionId(optionId: string): boolean;
+export declare const DEFAULT_REVIEW_OPTIONS: readonly [{
+    readonly optionId: "approve";
+    readonly name: "Approve";
+}, {
+    readonly optionId: "reject";
+    readonly name: "Request changes";
+}];

package/dist/mcp-config.js

@@ -0,0 +1,71 @@
+import { z } from "zod";
+import { CredentialKindSchema } from "./credentials.js";
+export const McpTransportSchema = z.enum(["stdio", "http"]);
+export const McpEnvCredentialRefSchema = z.object({
+    type: z.literal("credential"),
+    kind: CredentialKindSchema,
+    name: z.string().min(1),
+    secretKey: z.string().min(1),
+});
+export const McpEnvValueSchema = z.union([z.string(), McpEnvCredentialRefSchema]);
+const mcpKeyValues = z.record(z.string(), McpEnvValueSchema).default({});
+export const McpServerConfigBodySchema = z
+    .object({
+    name: z.string().min(1),
+    transport: McpTransportSchema.default("stdio"),
+    enabled: z.boolean().default(true),
+    // stdio
+    command: z.string().optional(),
+    args: z.array(z.string()).default([]),
+    env: mcpKeyValues,
+    // http
+    url: z.string().url().optional(),
+    headers: mcpKeyValues,
+})
+    .superRefine((data, ctx) => {
+    if (data.transport === "stdio") {
+        if (!data.command?.trim()) {
+            ctx.addIssue({
+                code: z.ZodIssueCode.custom,
+                message: "command is required for stdio transport",
+                path: ["command"],
+            });
+        }
+    }
+    if (data.transport === "http") {
+        if (!data.url?.trim()) {
+            ctx.addIssue({
+                code: z.ZodIssueCode.custom,
+                message: "url is required for http transport",
+                path: ["url"],
+            });
+        }
+    }
+});
+/** Resolve MCP env/header map to plain string values. */
+export async function resolveMcpEnv(env, resolveCredential) {
+    const out = {};
+    for (const [key, value] of Object.entries(env)) {
+        if (typeof value === "string") {
+            out[key] = value;
+            continue;
+        }
+        const secrets = await resolveCredential(value.kind, value.name);
+        const secret = secrets[value.secretKey];
+        if (!secret) {
+            throw new Error(`Credential ${value.kind}/${value.name} missing secret key "${value.secretKey}"`);
+        }
+        out[key] = secret;
+    }
+    return out;
+}
+/** Whether a chosen approval option counts as human approval for commit guard. */
+export function isApproveOptionId(optionId) {
+    if (optionId.startsWith("deny") || optionId === "reject")
+        return false;
+    return optionId === "approve" || optionId === "allow" || optionId.startsWith("allow");
+}
+export const DEFAULT_REVIEW_OPTIONS = [
+    { optionId: "approve", name: "Approve" },
+    { optionId: "reject", name: "Request changes" },
+];

package/dist/mcp-servers.d.ts

@@ -0,0 +1,54 @@
+import { type CredentialResolver } from "./mcp-config.js";
+export interface AcpMcpServerStdio {
+    name: string;
+    command: string;
+    args: string[];
+    env: {
+        name: string;
+        value: string;
+    }[];
+}
+export interface AcpMcpServerHttp {
+    type: "http";
+    name: string;
+    url: string;
+    headers: {
+        name: string;
+        value: string;
+    }[];
+}
+export type AcpMcpServer = AcpMcpServerStdio | AcpMcpServerHttp;
+export declare function isAcpMcpServerHttp(server: AcpMcpServer): server is AcpMcpServerHttp;
+export interface McpServerConfigRow {
+    id: string;
+    name: string;
+    transport: string;
+    command: string;
+    args: unknown;
+    env: unknown;
+    url: string | null;
+    headers: unknown;
+    enabled: boolean;
+}
+export interface BuildAcpMcpServersOpts {
+    template: {
+        mcpServerIds: string[];
+        requireReviewBeforeCommit: boolean;
+    };
+    dbConfigs: McpServerConfigRow[];
+    jobContext: {
+        jobId: string;
+        redisUrl: string;
+        publicBaseUrl: string;
+        dashboardApiToken: string;
+        jagitServerPath: string;
+        approvalTimeoutMs: number;
+    };
+    resolveCredential: CredentialResolver;
+}
+/** Build ACP session/new mcpServers: built-in jagit + template-linked configs. */
+export declare function buildAcpMcpServers(opts: BuildAcpMcpServersOpts): Promise<AcpMcpServer[]>;
+/** Instruction appended to agent prompt when review before commit is required. */
+export declare function buildReviewInstruction(): string;
+/** Instruction appended to every agent prompt so its final message can be relayed as the job's status report. */
+export declare function buildReportInstruction(): string;

package/dist/mcp-servers.js

@@ -0,0 +1,73 @@
+import { resolveMcpEnv } from "./mcp-config.js";
+export function isAcpMcpServerHttp(server) {
+    return "type" in server && server.type === "http";
+}
+function toKeyValueArray(map) {
+    return Object.entries(map).map(([name, value]) => ({ name, value }));
+}
+function parseKeyValues(raw) {
+    if (raw && typeof raw === "object" && !Array.isArray(raw)) {
+        return raw;
+    }
+    return {};
+}
+function buildJagitServer(opts) {
+    const { jobContext } = opts;
+    return {
+        name: "jagit",
+        command: "node",
+        args: [jobContext.jagitServerPath],
+        env: toKeyValueArray({
+            JAGIT_JOB_ID: jobContext.jobId,
+            REDIS_URL: jobContext.redisUrl,
+            PUBLIC_BASE_URL: jobContext.publicBaseUrl,
+            DASHBOARD_API_TOKEN: jobContext.dashboardApiToken,
+            APPROVAL_TIMEOUT_MS: String(jobContext.approvalTimeoutMs),
+        }),
+    };
+}
+/** Build ACP session/new mcpServers: built-in jagit + template-linked configs. */
+export async function buildAcpMcpServers(opts) {
+    const servers = [buildJagitServer(opts)];
+    const idSet = new Set(opts.template.mcpServerIds);
+    const selected = opts.dbConfigs.filter((c) => idSet.has(c.id) && c.enabled);
+    for (const config of selected) {
+        const transport = config.transport === "http" ? "http" : "stdio";
+        if (transport === "http") {
+            if (!config.url)
+                continue;
+            const resolvedHeaders = await resolveMcpEnv(parseKeyValues(config.headers), opts.resolveCredential);
+            servers.push({
+                type: "http",
+                name: config.name,
+                url: config.url,
+                headers: toKeyValueArray(resolvedHeaders),
+            });
+            continue;
+        }
+        const args = Array.isArray(config.args) ? config.args : [];
+        const resolvedEnv = await resolveMcpEnv(parseKeyValues(config.env), opts.resolveCredential);
+        servers.push({
+            name: config.name,
+            command: config.command,
+            args,
+            env: toKeyValueArray(resolvedEnv),
+        });
+    }
+    return servers;
+}
+/** Instruction appended to agent prompt when review before commit is required. */
+export function buildReviewInstruction() {
+    return [
+        "Before you finish your work, you MUST call the MCP tool `jagit_request_review`",
+        "with a summary of your changes and wait for human approval.",
+        "Do not consider the task complete until review is approved.",
+    ].join(" ");
+}
+/** Instruction appended to every agent prompt so its final message can be relayed as the job's status report. */
+export function buildReportInstruction() {
+    return [
+        "End your final message with a concise 2-4 sentence summary of what you changed",
+        "and why, written for a non-technical reader — it will be relayed to them directly.",
+    ].join(" ");
+}

package/dist/prisma.d.ts

@@ -0,0 +1,3 @@
+import { PrismaClient } from "@prisma/client";
+export declare const prisma: PrismaClient<import("@prisma/client").Prisma.PrismaClientOptions, never, import("@prisma/client/runtime/client").DefaultArgs>;
+export * from "@prisma/client";

package/dist/prisma.js

@@ -0,0 +1,20 @@
+import { PrismaClient } from "@prisma/client";
+import { PrismaPg } from "@prisma/adapter-pg";
+function createPrismaClient() {
+    // Allow empty string so the module loads without DATABASE_URL set.
+    // Actual queries will fail at connect time, letting test skipIf guards act.
+    const connectionString = process.env.DATABASE_URL ?? "";
+    const adapter = new PrismaPg({ connectionString });
+    return new PrismaClient({
+        adapter,
+        log: process.env.NODE_ENV === "development" ? ["query", "error", "warn"] : ["error"],
+    });
+}
+// Singleton: one client per process.
+// In tests that set DATABASE_URL, this connects to the real DB.
+const globalForPrisma = global;
+export const prisma = globalForPrisma.prisma ?? createPrismaClient();
+if (process.env.NODE_ENV !== "production") {
+    globalForPrisma.prisma = prisma;
+}
+export * from "@prisma/client";

package/dist/prisma.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/prisma.test.js

@@ -0,0 +1,16 @@
+import { describe, it, expect, afterAll } from "vitest";
+import { prisma } from "./prisma.js";
+describe.skipIf(!process.env.DATABASE_URL)("prisma smoke", () => {
+    afterAll(async () => {
+        await prisma.$disconnect();
+    });
+    it("connects and counts jobs", async () => {
+        const count = await prisma.job.count();
+        expect(typeof count).toBe("number");
+    });
+    it("can read all enum values for JobStatus", async () => {
+        // If the enum is wrong the Prisma client won't even compile.
+        const jobs = await prisma.job.findMany({ take: 1 });
+        expect(Array.isArray(jobs)).toBe(true);
+    });
+});

package/dist/queue.d.ts

@@ -0,0 +1,10 @@
+import { Queue, Worker, type Processor } from "bullmq";
+/** Creates the BullMQ queue used by the API to enqueue jobs */
+export declare const createQueue: (redisUrl: string) => Queue<{
+    jobId: string;
+}, any, string, {
+    jobId: string;
+}, any, string>;
+/** Creates the BullMQ worker consumed by the worker service */
+export declare const createWorker: <T = unknown>(redisUrl: string, processor: Processor<T>, concurrency: number) => Worker<T, any, string>;
+export type { JagitJobData } from "./types.js";

package/dist/queue.js

@@ -0,0 +1,7 @@
+import { Queue, Worker } from "bullmq";
+import { JOB_QUEUE } from "./types.js";
+const connection = (url) => ({ connection: { url } });
+/** Creates the BullMQ queue used by the API to enqueue jobs */
+export const createQueue = (redisUrl) => new Queue(JOB_QUEUE, connection(redisUrl));
+/** Creates the BullMQ worker consumed by the worker service */
+export const createWorker = (redisUrl, processor, concurrency) => new Worker(JOB_QUEUE, processor, { ...connection(redisUrl), concurrency });

package/dist/retry.d.ts

@@ -0,0 +1,5 @@
+export interface RetryOpts {
+    maxRetries: number;
+    baseDelayMs: number;
+}
+export declare function withRetry<T>(fn: () => Promise<T>, opts: RetryOpts): Promise<T>;

package/dist/retry.js

@@ -0,0 +1,16 @@
+const sleep = (ms) => new Promise((r) => setTimeout(r, ms));
+export async function withRetry(fn, opts) {
+    let lastError;
+    for (let attempt = 0; attempt <= opts.maxRetries; attempt++) {
+        try {
+            return await fn();
+        }
+        catch (err) {
+            lastError = err;
+            if (attempt < opts.maxRetries) {
+                await sleep(opts.baseDelayMs * 2 ** attempt);
+            }
+        }
+    }
+    throw lastError;
+}

package/dist/retry.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/retry.test.js

@@ -0,0 +1,24 @@
+import { describe, it, expect, vi } from "vitest";
+import { withRetry } from "./retry.js";
+describe("withRetry", () => {
+    it("returns immediately on first success", async () => {
+        const fn = vi.fn(async () => "ok");
+        expect(await withRetry(fn, { maxRetries: 3, baseDelayMs: 0 })).toBe("ok");
+        expect(fn).toHaveBeenCalledTimes(1);
+    });
+    it("retries until success", async () => {
+        let n = 0;
+        const fn = vi.fn(async () => {
+            if (++n < 3)
+                throw new Error("not yet");
+            return "ok";
+        });
+        expect(await withRetry(fn, { maxRetries: 3, baseDelayMs: 0 })).toBe("ok");
+        expect(fn).toHaveBeenCalledTimes(3);
+    });
+    it("throws after maxRetries + 1 attempts", async () => {
+        const fn = vi.fn(async () => { throw new Error("nope"); });
+        await expect(withRetry(fn, { maxRetries: 2, baseDelayMs: 0 })).rejects.toThrow("nope");
+        expect(fn).toHaveBeenCalledTimes(3); // 1 initial + 2 retries
+    });
+});

package/dist/seed.d.ts

@@ -0,0 +1,99 @@
+import { z } from "zod";
+declare const CredentialKindSchema: z.ZodEnum<{
+    jira: "jira";
+    gitlab: "gitlab";
+    telegram: "telegram";
+    anthropic: "anthropic";
+}>;
+export declare const SeedDataSchema: z.ZodObject<{
+    agentTemplate: z.ZodObject<{
+        name: z.ZodString;
+        model: z.ZodString;
+        systemPrompt: z.ZodString;
+        maxConcurrent: z.ZodNumber;
+        allowedTools: z.ZodArray<z.ZodString>;
+        skills: z.ZodArray<z.ZodString>;
+    }, z.core.$strip>;
+    credentials: z.ZodArray<z.ZodObject<{
+        kind: z.ZodEnum<{
+            jira: "jira";
+            gitlab: "gitlab";
+            telegram: "telegram";
+            anthropic: "anthropic";
+        }>;
+        name: z.ZodString;
+        secrets: z.ZodRecord<z.ZodString, z.ZodString>;
+        meta: z.ZodRecord<z.ZodString, z.ZodString>;
+    }, z.core.$strip>>;
+    repoMapping: z.ZodObject<{
+        jiraProjectKey: z.ZodString;
+        gitlabProjectId: z.ZodString;
+        defaultBaseBranch: z.ZodString;
+        branchPrefixRules: z.ZodRecord<z.ZodString, z.ZodString>;
+        agentTemplateName: z.ZodString;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+export type SeedData = z.infer<typeof SeedDataSchema>;
+export type SeedCredentialKind = z.infer<typeof CredentialKindSchema>;
+export interface SeedPrismaClient {
+    agentTemplate: {
+        upsert(args: {
+            where: {
+                name: string;
+            };
+            create: SeedData["agentTemplate"];
+            update: Omit<SeedData["agentTemplate"], "name">;
+        }): Promise<{
+            id: string;
+        }>;
+    };
+    credential: {
+        upsert(args: {
+            where: {
+                kind_name: {
+                    kind: SeedCredentialKind;
+                    name: string;
+                };
+            };
+            create: {
+                kind: SeedCredentialKind;
+                name: string;
+                secrets: {
+                    encrypted: string;
+                };
+                meta: Record<string, string>;
+            };
+            update: {
+                secrets: {
+                    encrypted: string;
+                };
+                meta: Record<string, string>;
+            };
+        }): Promise<unknown>;
+    };
+    repoMapping: {
+        upsert(args: {
+            where: {
+                jiraProjectKey: string;
+            };
+            create: {
+                jiraProjectKey: string;
+                gitlabProjectId: string;
+                defaultBaseBranch: string;
+                branchPrefixRules: Record<string, string>;
+                agentTemplateId: string;
+            };
+            update: {
+                gitlabProjectId: string;
+                defaultBaseBranch: string;
+                branchPrefixRules: Record<string, string>;
+                agentTemplateId: string;
+            };
+        }): Promise<unknown>;
+    };
+}
+export declare function buildSeedData(input: {
+    anthropicApiKey: string;
+}): SeedData;
+export declare function seedDatabase(client: SeedPrismaClient, seedData: SeedData, encryptionKey: string): Promise<void>;
+export {};