@armstrongnate/april 0.0.1

package/dist/server.js

@@ -0,0 +1,58 @@
+import Fastify from "fastify";
+import { createLogger } from "./logger.js";
+import { parseWebhookEvent } from "./webhook.js";
+import { isIssueActive } from "./spawner.js";
+const log = createLogger("server");
+export async function startServer(config, onNewIssue) {
+    const app = Fastify({ logger: false });
+    // Debounce: track recently processed issue keys with 10s TTL
+    const recentlyProcessed = new Map();
+    function isRecentlyProcessed(key) {
+        const ts = recentlyProcessed.get(key);
+        if (ts && Date.now() - ts < 10_000) {
+            return true;
+        }
+        return false;
+    }
+    function markProcessed(key) {
+        recentlyProcessed.set(key, Date.now());
+        // Cleanup old entries
+        for (const [k, ts] of recentlyProcessed) {
+            if (Date.now() - ts >= 10_000) {
+                recentlyProcessed.delete(k);
+            }
+        }
+    }
+    app.post("/webhook/github", async (request, reply) => {
+        try {
+            const headers = request.headers;
+            const body = request.body;
+            const result = parseWebhookEvent(headers, body, config);
+            if (result) {
+                const key = `${result.repo.owner}/${result.repo.name}#${result.issue.number}`;
+                if (isIssueActive(result.repo, result.issue.number)) {
+                    log.debug(`Issue ${key} already active, ignoring webhook`);
+                }
+                else if (isRecentlyProcessed(key)) {
+                    log.debug(`Issue ${key} recently processed, debouncing`);
+                }
+                else {
+                    markProcessed(key);
+                    log.info(`Processing webhook for ${key}`);
+                    onNewIssue(result).catch((err) => {
+                        log.error(`Error handling new issue: ${err instanceof Error ? err.message : String(err)}`);
+                    });
+                }
+            }
+        }
+        catch (err) {
+            log.error(`Error processing webhook: ${err instanceof Error ? err.message : String(err)}`);
+        }
+        // Always return 200
+        return reply.code(200).send({ ok: true });
+    });
+    app.get("/health", async () => ({ status: "ok" }));
+    await app.listen({ port: config.port, host: "127.0.0.1" });
+    log.info(`Server listening on http://127.0.0.1:${config.port}`);
+    return app;
+}

package/dist/service/index.js

@@ -0,0 +1,11 @@
+import * as systemd from "./systemd.js";
+import * as launchd from "./launchd.js";
+const systemdBackend = { ...systemd, serviceFile: systemd.unitContents };
+const launchdBackend = { ...launchd, serviceFile: launchd.plistContents };
+export function backend() {
+    if (process.platform === "linux")
+        return systemdBackend;
+    if (process.platform === "darwin")
+        return launchdBackend;
+    throw new Error(`Unsupported platform: ${process.platform}. april service supports linux (systemd) and macOS (launchd) only.`);
+}

package/dist/service/launchd.js

@@ -0,0 +1,136 @@
+import { writeFileSync, mkdirSync, existsSync, unlinkSync } from "node:fs";
+import { execFileSync, spawnSync } from "node:child_process";
+import { dirname } from "node:path";
+import { homedir, userInfo } from "node:os";
+import { daemonEntryPath, nodeBinaryPath, launchdPlistPath, launchdLogPath, launchdLogDir, LAUNCHD_LABEL, } from "./paths.js";
+function escapeXml(s) {
+    return s
+        .replace(/&/g, "&")
+        .replace(/</g, "&lt;")
+        .replace(/>/g, "&gt;")
+        .replace(/"/g, "&quot;");
+}
+export function plistContents() {
+    const node = nodeBinaryPath();
+    const entry = daemonEntryPath();
+    const path = process.env.PATH ?? "/usr/local/bin:/usr/bin:/bin";
+    const log = launchdLogPath();
+    return `<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+    <key>Label</key>
+    <string>${escapeXml(LAUNCHD_LABEL)}</string>
+    <key>ProgramArguments</key>
+    <array>
+        <string>${escapeXml(node)}</string>
+        <string>${escapeXml(entry)}</string>
+    </array>
+    <key>RunAtLoad</key>
+    <true/>
+    <key>KeepAlive</key>
+    <dict>
+        <key>SuccessfulExit</key>
+        <false/>
+        <key>Crashed</key>
+        <true/>
+    </dict>
+    <key>WorkingDirectory</key>
+    <string>${escapeXml(homedir())}</string>
+    <key>EnvironmentVariables</key>
+    <dict>
+        <key>PATH</key>
+        <string>${escapeXml(path)}</string>
+        <key>NODE_ENV</key>
+        <string>production</string>
+        <key>HOME</key>
+        <string>${escapeXml(homedir())}</string>
+    </dict>
+    <key>StandardOutPath</key>
+    <string>${escapeXml(log)}</string>
+    <key>StandardErrorPath</key>
+    <string>${escapeXml(log)}</string>
+    <key>ProcessType</key>
+    <string>Background</string>
+</dict>
+</plist>
+`;
+}
+function ensureLaunchctl() {
+    try {
+        execFileSync("launchctl", ["help"], { stdio: "ignore" });
+    }
+    catch {
+        throw new Error("launchctl not found. april service install requires macOS launchd.");
+    }
+}
+function uid() {
+    return userInfo().uid;
+}
+function domain() {
+    return `gui/${uid()}`;
+}
+function serviceTarget() {
+    return `${domain()}/${LAUNCHD_LABEL}`;
+}
+export function install() {
+    ensureLaunchctl();
+    mkdirSync(launchdLogDir(), { recursive: true });
+    const path = launchdPlistPath();
+    mkdirSync(dirname(path), { recursive: true });
+    writeFileSync(path, plistContents(), "utf-8");
+    // bootout (ignore failure if not loaded), then bootstrap.
+    spawnSync("launchctl", ["bootout", serviceTarget()], { stdio: "ignore" });
+    const res = spawnSync("launchctl", ["bootstrap", domain(), path], { encoding: "utf-8" });
+    if ((res.status ?? 1) !== 0) {
+        throw new Error(`launchctl bootstrap failed: ${res.stderr ?? ""}`);
+    }
+    spawnSync("launchctl", ["enable", serviceTarget()], { stdio: "ignore" });
+    spawnSync("launchctl", ["kickstart", "-k", serviceTarget()], { stdio: "ignore" });
+    console.log(`✓ Installed ${path}`);
+    console.log(`✓ Service loaded and started`);
+    console.log(`  Logs: ${launchdLogPath()}`);
+}
+export function uninstall() {
+    ensureLaunchctl();
+    const path = launchdPlistPath();
+    spawnSync("launchctl", ["bootout", serviceTarget()], { stdio: "ignore" });
+    if (existsSync(path)) {
+        unlinkSync(path);
+        console.log(`✓ Removed ${path}`);
+    }
+    console.log(`✓ Service uninstalled`);
+}
+export function start() {
+    const res = spawnSync("launchctl", ["kickstart", serviceTarget()], { encoding: "utf-8" });
+    if ((res.status ?? 1) !== 0)
+        throw new Error(`launchctl kickstart failed: ${res.stderr ?? ""}`);
+}
+export function stop() {
+    // `kill` sends a signal to the running instance without unloading.
+    const res = spawnSync("launchctl", ["kill", "SIGTERM", serviceTarget()], { encoding: "utf-8" });
+    if ((res.status ?? 1) !== 0)
+        throw new Error(`launchctl kill failed: ${res.stderr ?? ""}`);
+}
+export function restart() {
+    const res = spawnSync("launchctl", ["kickstart", "-k", serviceTarget()], { encoding: "utf-8" });
+    if ((res.status ?? 1) !== 0)
+        throw new Error(`launchctl kickstart -k failed: ${res.stderr ?? ""}`);
+}
+export function status() {
+    const res = spawnSync("launchctl", ["print", serviceTarget()], { stdio: "inherit" });
+    return res.status ?? 1;
+}
+export function logs(follow, lines) {
+    const log = launchdLogPath();
+    if (!existsSync(log)) {
+        console.log(`(no log file at ${log} yet — service may not have started)`);
+        return 0;
+    }
+    const args = ["-n", String(lines)];
+    if (follow)
+        args.push("-f");
+    args.push(log);
+    const res = spawnSync("tail", args, { stdio: "inherit" });
+    return res.status ?? 1;
+}

package/dist/service/paths.js

@@ -0,0 +1,27 @@
+import { fileURLToPath } from "node:url";
+import { dirname, join, resolve } from "node:path";
+import { homedir } from "node:os";
+// Resolve the daemon entry point relative to this file's installed location.
+// When published to npm, both cli.js and index.js live in dist/ alongside service/.
+export function daemonEntryPath() {
+    const here = fileURLToPath(import.meta.url);
+    // dist/service/paths.js -> dist/index.js
+    return resolve(dirname(here), "..", "index.js");
+}
+export function nodeBinaryPath() {
+    return process.execPath;
+}
+export const SERVICE_NAME = "april";
+export const LAUNCHD_LABEL = "dev.april.daemon";
+export function systemdUnitPath() {
+    return join(homedir(), ".config", "systemd", "user", `${SERVICE_NAME}.service`);
+}
+export function launchdPlistPath() {
+    return join(homedir(), "Library", "LaunchAgents", `${LAUNCHD_LABEL}.plist`);
+}
+export function launchdLogPath() {
+    return join(homedir(), "Library", "Logs", "april", "april.log");
+}
+export function launchdLogDir() {
+    return join(homedir(), "Library", "Logs", "april");
+}

package/dist/service/systemd.js

@@ -0,0 +1,117 @@
+import { writeFileSync, mkdirSync, existsSync, unlinkSync } from "node:fs";
+import { execFileSync, spawnSync } from "node:child_process";
+import { dirname } from "node:path";
+import { homedir } from "node:os";
+import { daemonEntryPath, nodeBinaryPath, systemdUnitPath, SERVICE_NAME, } from "./paths.js";
+function runSystemctl(args) {
+    const res = spawnSync("systemctl", ["--user", ...args], { encoding: "utf-8" });
+    return {
+        status: res.status ?? 1,
+        stdout: res.stdout ?? "",
+        stderr: res.stderr ?? "",
+    };
+}
+export function unitContents() {
+    const node = nodeBinaryPath();
+    const entry = daemonEntryPath();
+    // Capture caller's PATH so child has access to gh, tmux, git, claude.
+    const path = process.env.PATH ?? "/usr/local/bin:/usr/bin:/bin";
+    return `[Unit]
+Description=april — issue worker
+After=network.target
+
+[Service]
+Type=simple
+ExecStart=${node} ${entry}
+Restart=on-failure
+RestartSec=5s
+WorkingDirectory=${homedir()}
+Environment=PATH=${path}
+Environment=NODE_ENV=production
+StandardOutput=journal
+StandardError=journal
+
+[Install]
+WantedBy=default.target
+`;
+}
+function ensureSystemctlPresent() {
+    try {
+        execFileSync("systemctl", ["--version"], { stdio: "ignore" });
+    }
+    catch {
+        throw new Error("systemctl not found on PATH. april service install requires systemd.");
+    }
+}
+function lingerEnabled() {
+    try {
+        const out = execFileSync("loginctl", ["show-user", process.env.USER ?? ""], {
+            encoding: "utf-8",
+            stdio: ["ignore", "pipe", "ignore"],
+        });
+        return /Linger=yes/i.test(out);
+    }
+    catch {
+        return false;
+    }
+}
+export function install() {
+    ensureSystemctlPresent();
+    const path = systemdUnitPath();
+    mkdirSync(dirname(path), { recursive: true });
+    writeFileSync(path, unitContents(), "utf-8");
+    let res = runSystemctl(["daemon-reload"]);
+    if (res.status !== 0)
+        throw new Error(`systemctl daemon-reload failed: ${res.stderr}`);
+    res = runSystemctl(["enable", "--now", SERVICE_NAME]);
+    if (res.status !== 0)
+        throw new Error(`systemctl enable --now ${SERVICE_NAME} failed: ${res.stderr}`);
+    console.log(`✓ Installed ${path}`);
+    console.log(`✓ Service enabled and started`);
+    if (!lingerEnabled()) {
+        console.log("");
+        console.log("⚠  Linger is not enabled for your user. Without it, april will stop when");
+        console.log("   you log out (e.g., end your SSH session). To keep it running:");
+        console.log("");
+        console.log(`     sudo loginctl enable-linger ${process.env.USER ?? "$USER"}`);
+        console.log("");
+    }
+}
+export function uninstall() {
+    ensureSystemctlPresent();
+    runSystemctl(["disable", "--now", SERVICE_NAME]);
+    const path = systemdUnitPath();
+    if (existsSync(path)) {
+        unlinkSync(path);
+        console.log(`✓ Removed ${path}`);
+    }
+    runSystemctl(["daemon-reload"]);
+    console.log(`✓ Service uninstalled`);
+}
+export function start() {
+    const res = runSystemctl(["start", SERVICE_NAME]);
+    if (res.status !== 0)
+        throw new Error(`systemctl start failed: ${res.stderr}`);
+}
+export function stop() {
+    const res = runSystemctl(["stop", SERVICE_NAME]);
+    if (res.status !== 0)
+        throw new Error(`systemctl stop failed: ${res.stderr}`);
+}
+export function restart() {
+    const res = runSystemctl(["restart", SERVICE_NAME]);
+    if (res.status !== 0)
+        throw new Error(`systemctl restart failed: ${res.stderr}`);
+}
+export function status() {
+    // Inherit stdio so the user sees colored systemctl output directly.
+    const res = spawnSync("systemctl", ["--user", "status", SERVICE_NAME], { stdio: "inherit" });
+    return res.status ?? 1;
+}
+export function logs(follow, lines) {
+    const args = ["--user", "-u", SERVICE_NAME, "-n", String(lines)];
+    if (follow)
+        args.push("-f");
+    const res = spawnSync("journalctl", args, { stdio: "inherit" });
+    return res.status ?? 1;
+}

package/dist/slug.js

@@ -0,0 +1,21 @@
+export function makeSlug(issueNumber, title) {
+    let slug = title
+        .toLowerCase()
+        .replace(/[^a-z0-9]+/g, "-")
+        .replace(/-{2,}/g, "-")
+        .replace(/^-+|-+$/g, "");
+    // Truncate to 40 chars at word boundary
+    if (slug.length > 40) {
+        slug = slug.substring(0, 40);
+        const lastHyphen = slug.lastIndexOf("-");
+        if (lastHyphen > 0) {
+            slug = slug.substring(0, lastHyphen);
+        }
+        slug = slug.replace(/-+$/, "");
+    }
+    // Fallback if empty
+    if (slug.length === 0) {
+        slug = "issue";
+    }
+    return `gh-${issueNumber}-${slug}`;
+}

package/dist/spawner.js

@@ -0,0 +1,242 @@
+import { execSync, execFileSync } from "node:child_process";
+import { existsSync, readFileSync, readdirSync } from "node:fs";
+import { join } from "node:path";
+import { createLogger } from "./logger.js";
+import { makeSlug } from "./slug.js";
+const log = createLogger("spawner");
+function checkWorktreesIgnored(repoPath) {
+    const gitignorePath = join(repoPath, ".gitignore");
+    if (!existsSync(gitignorePath)) {
+        log.warn(`${repoPath}: no .gitignore found. Consider adding ".worktrees" to it.`);
+        return;
+    }
+    try {
+        const content = readFileSync(gitignorePath, "utf-8");
+        const lines = content.split("\n").map((l) => l.trim());
+        if (!lines.some((l) => l === ".worktrees" || l === ".worktrees/" || l === "/.worktrees" || l === "/.worktrees/")) {
+            log.warn(`${repoPath}/.gitignore does not contain ".worktrees". Consider adding it to avoid committing worktrees.`);
+        }
+    }
+    catch {
+        // Non-critical, just skip
+    }
+}
+/**
+ * Check if an issue is already active by looking at the filesystem and tmux.
+ * Matches any worktree dir or tmux session starting with `gh-{issueNumber}-`.
+ */
+export function isIssueActive(repo, issueNumber) {
+    const prefix = `gh-${issueNumber}-`;
+    // Check worktrees on disk
+    const worktreesDir = join(repo.path, ".worktrees");
+    if (existsSync(worktreesDir)) {
+        const dirs = readdirSync(worktreesDir);
+        const match = dirs.find((d) => d.startsWith(prefix));
+        if (match) {
+            log.info(`Skipping issue #${issueNumber}: existing worktree found (${match})`);
+            return true;
+        }
+    }
+    // Check tmux sessions
+    try {
+        const output = execSync("tmux list-sessions -F '#{session_name}'", {
+            encoding: "utf-8",
+            stdio: ["pipe", "pipe", "pipe"],
+        });
+        const match = output.trim().split("\n").find((s) => s.startsWith(prefix));
+        if (match) {
+            log.info(`Skipping issue #${issueNumber}: existing tmux session found (${match})`);
+            return true;
+        }
+    }
+    catch {
+        // tmux not running or no sessions
+    }
+    return false;
+}
+/**
+ * Count active worktrees and tmux sessions across all configured repos.
+ */
+export function getActiveCounts(config) {
+    let worktrees = 0;
+    for (const repo of config.repos) {
+        const dir = join(repo.path, ".worktrees");
+        if (existsSync(dir)) {
+            worktrees += readdirSync(dir).filter((d) => d.startsWith("gh-")).length;
+        }
+    }
+    let sessions = 0;
+    try {
+        const output = execSync("tmux list-sessions -F '#{session_name}'", {
+            encoding: "utf-8",
+            stdio: ["pipe", "pipe", "pipe"],
+        });
+        sessions = output.trim().split("\n").filter((s) => s.startsWith("gh-")).length;
+    }
+    catch {
+        // tmux not running
+    }
+    return { worktrees, sessions };
+}
+export async function createWorktree(repo, branch) {
+    const worktreesDir = join(repo.path, ".worktrees");
+    const worktreePath = join(worktreesDir, branch);
+    if (existsSync(worktreePath)) {
+        log.info(`Worktree already exists: ${worktreePath}`);
+        return worktreePath;
+    }
+    checkWorktreesIgnored(repo.path);
+    // Ensure .worktrees directory exists
+    execSync(`mkdir -p ${JSON.stringify(worktreesDir)}`);
+    // Fetch origin defaultBranch
+    log.info(`Fetching origin/${repo.defaultBranch} for ${repo.owner}/${repo.name}`);
+    try {
+        execFileSync("git", ["-C", repo.path, "fetch", "origin", repo.defaultBranch], {
+            timeout: 60_000,
+            stdio: "pipe",
+        });
+    }
+    catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        throw new Error(`Failed to fetch origin/${repo.defaultBranch} in ${repo.path}: ${msg}`);
+    }
+    // Create worktree with new branch
+    log.info(`Creating worktree: ${worktreePath} (branch: ${branch})`);
+    try {
+        execFileSync("git", ["-C", repo.path, "worktree", "add", worktreePath, "-b", branch, `origin/${repo.defaultBranch}`], { timeout: 30_000, stdio: "pipe" });
+    }
+    catch {
+        // Branch may already exist — try without -b
+        log.debug(`Branch "${branch}" may already exist, retrying without -b`);
+        try {
+            execFileSync("git", ["-C", repo.path, "worktree", "add", worktreePath, branch], {
+                timeout: 30_000,
+                stdio: "pipe",
+            });
+        }
+        catch (err2) {
+            const msg = err2 instanceof Error ? err2.message : String(err2);
+            throw new Error(`Failed to create worktree for branch "${branch}": ${msg}`);
+        }
+    }
+    log.info(`Worktree created at ${worktreePath}`);
+    // Run post-worktree hook if configured
+    if (repo.postWorktreeHook) {
+        log.info(`Running post-worktree hook: ${repo.postWorktreeHook}`);
+        try {
+            execSync(repo.postWorktreeHook, {
+                cwd: worktreePath,
+                timeout: 300_000, // 5 min — installs can be slow
+                stdio: "pipe",
+            });
+            log.info("Post-worktree hook completed");
+        }
+        catch (err) {
+            const msg = err instanceof Error ? err.message : String(err);
+            log.warn(`Post-worktree hook failed: ${msg}`);
+        }
+    }
+    return worktreePath;
+}
+export function spawnClaude(config, repo, issue, worktreePath, sessionName) {
+    // Check if session already exists
+    try {
+        execSync(`tmux has-session -t ${JSON.stringify(sessionName)}`, { stdio: "pipe" });
+        log.info(`tmux session "${sessionName}" already exists, skipping`);
+        return;
+    }
+    catch {
+        // Session does not exist, proceed
+    }
+    const model = config.claudeModel || "opus";
+    const allowedTools = [
+        ...(config.claudeAllowedTools ?? ["Read", "Search", "Edit", "Write", "Bash(*)"]),
+        ...(repo.slackChannel ? ["mcp__plugin_slack_slack__*"] : []),
+    ];
+    const slackPart = repo.slackChannel ? ` Post the PR to Slack channel #${repo.slackChannel}.` : "";
+    const prompt = `/${config.claudeSkill} Read GitHub issue #${issue.number} on ${repo.owner}/${repo.name} using the gh CLI. Implement it and open a PR.${slackPart}`;
+    log.debug(`Prompt: ${prompt}`);
+    const allowedToolsArgs = allowedTools.map((t) => `--allowedTools '${t}'`).join(" ");
+    const claudeCommand = `claude --model ${model} ${allowedToolsArgs}`;
+    log.info(`Spawning tmux session "${sessionName}" with claude`);
+    execSync(`tmux new-session -d -s ${JSON.stringify(sessionName)} -c ${JSON.stringify(worktreePath)} ${JSON.stringify(claudeCommand)}`);
+    // Send the prompt via send-keys after Claude starts
+    const escapedPrompt = prompt.replace(/'/g, "'\\''");
+    const session = JSON.stringify(sessionName);
+    setTimeout(() => {
+        try {
+            // Send text first, then Enter after a short delay to ensure Claude's input is ready
+            execSync(`tmux send-keys -t ${session} '${escapedPrompt}'`, { stdio: "pipe" });
+            setTimeout(() => {
+                try {
+                    execSync(`tmux send-keys -t ${session} C-m`, { stdio: "pipe" });
+                    log.info(`Prompt sent to tmux session "${sessionName}"`);
+                }
+                catch (err) {
+                    log.warn(`Failed to send Enter to session "${sessionName}": ${err instanceof Error ? err.message : String(err)}`);
+                }
+            }, 1000);
+        }
+        catch (err) {
+            log.warn(`Failed to send prompt to session "${sessionName}": ${err instanceof Error ? err.message : String(err)}`);
+        }
+    }, 3000);
+    log.info(`tmux session "${sessionName}" started`);
+}
+export async function handleNewIssue(repo, issue, config) {
+    // Check if already active via filesystem/tmux
+    if (isIssueActive(repo, issue.number)) {
+        log.info(`Issue #${issue.number} already active in ${repo.owner}/${repo.name}, skipping`);
+        return;
+    }
+    const slug = makeSlug(issue.number, issue.title);
+    // Create worktree
+    let worktreePath;
+    try {
+        worktreePath = await createWorktree(repo, slug);
+    }
+    catch (err) {
+        log.error(`Failed to create worktree for #${issue.number}: ${err instanceof Error ? err.message : String(err)}`);
+        return;
+    }
+    // Spawn tmux + claude
+    try {
+        spawnClaude(config, repo, issue, worktreePath, slug);
+    }
+    catch (err) {
+        log.error(`Failed to spawn claude for #${issue.number}: ${err instanceof Error ? err.message : String(err)}`);
+        return;
+    }
+    // Apply label transition
+    try {
+        execFileSync("gh", [
+            "issue", "edit", String(issue.number),
+            "--repo", `${repo.owner}/${repo.name}`,
+            "--add-label", "agent:wip",
+            "--remove-label", "agent:todo",
+        ], { timeout: 15_000, stdio: "pipe" });
+        log.info(`Labels updated for #${issue.number}: agent:todo -> agent:wip`);
+    }
+    catch (err) {
+        log.warn(`Failed to update labels for #${issue.number}: ${err instanceof Error ? err.message : String(err)}`);
+    }
+    log.info(`Issue #${issue.number} (${repo.owner}/${repo.name}) is now active`);
+}
+export function fetchOpenIssues(repo, config) {
+    try {
+        const output = execFileSync("gh", [
+            "issue", "list",
+            "--repo", `${repo.owner}/${repo.name}`,
+            "--assignee", config.assignee,
+            "--label", config.label,
+            "--json", "number,title",
+            "--state", "open",
+        ], { timeout: 30_000, stdio: ["pipe", "pipe", "pipe"] });
+        const parsed = JSON.parse(output.toString("utf-8"));
+        return parsed.map((i) => ({ number: i.number, title: i.title }));
+    }
+    catch (err) {
+        log.error(`Failed to fetch issues for ${repo.owner}/${repo.name}: ${err instanceof Error ? err.message : String(err)}`);
+        return [];
+    }
+}

package/dist/types.js

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

package/dist/webhook.js

@@ -0,0 +1,52 @@
+import { createLogger } from "./logger.js";
+const log = createLogger("webhook");
+export function parseWebhookEvent(headers, body, config) {
+    const event = headers["x-github-event"];
+    if (event !== "issues") {
+        log.debug(`Ignoring non-issues event: ${event}`);
+        return null;
+    }
+    const action = body.action;
+    if (action !== "assigned" && action !== "labeled") {
+        log.debug(`Ignoring issues action: ${action}`);
+        return null;
+    }
+    const issue = body.issue;
+    if (!issue) {
+        log.debug("No issue payload found");
+        return null;
+    }
+    // Check assignees
+    const assignees = issue.assignees;
+    if (!assignees || !assignees.some((a) => a.login === config.assignee)) {
+        log.debug(`Issue not assigned to ${config.assignee}`);
+        return null;
+    }
+    // Check labels
+    const labels = issue.labels;
+    if (!labels || !labels.some((l) => l.name === config.label)) {
+        log.debug(`Issue does not have label "${config.label}"`);
+        return null;
+    }
+    // Match repo
+    const repository = body.repository;
+    if (!repository) {
+        log.debug("No repository payload found");
+        return null;
+    }
+    const repoOwner = repository.owner?.login;
+    const repoName = repository.name;
+    if (!repoOwner || !repoName) {
+        log.debug("Could not extract repo owner/name from payload");
+        return null;
+    }
+    const repo = config.repos.find((r) => r.owner.toLowerCase() === repoOwner.toLowerCase() && r.name.toLowerCase() === repoName.toLowerCase());
+    if (!repo) {
+        log.debug(`Repo ${repoOwner}/${repoName} not in config`);
+        return null;
+    }
+    const number = issue.number;
+    const title = issue.title;
+    log.info(`Matched webhook event: ${repo.owner}/${repo.name}#${number} (${action})`);
+    return { repo, issue: { number, title } };
+}