@prsense/daemon 0.1.0

package/src/bootstrap.ts

@@ -0,0 +1,32 @@
+// apps/daemon/src/bootstrap.ts
+import type { CredentialContext, ResolvedConfig } from "@prsense/config";
+import { resolveEnvironment } from "@prsense/config";
+
+type DaemonContext = {
+  config: ResolvedConfig;
+  credentials: CredentialContext;
+};
+export function bootstrapDaemon(): DaemonContext {
+  const cwd = process.cwd();
+
+  const env = resolveEnvironment("daemon", {
+    root: cwd,
+    provider: "filesystem",
+  });
+
+  // 1️⃣ Load global-only user config
+  const errors = env.issues.filter((i) => i.level === "error");
+
+  if (errors.length > 0) {
+    console.error("❌ PRSense daemon configuration invalid:\n");
+    for (const err of errors) {
+      console.error(`- ${err.message}`);
+    }
+    process.exit(1);
+  }
+
+  return {
+    config: env.config,
+    credentials: env.credentials,
+  };
+}

package/src/http/health.ts

@@ -0,0 +1,32 @@
+import type { FastifyInstance } from "fastify";
+import type { Logger } from "@prsense/logging";
+import type { ResolvedConfig } from "@prsense/config";
+import pg from "pg";
+
+export function registerHealthRoutes(
+  app: FastifyInstance,
+  logger: Logger,
+  config: ResolvedConfig,
+) {
+  app.get("/health", async () => {
+    logger.debug("health.check");
+    return { status: "ok" };
+  });
+
+  app.get("/ready", async (_, reply) => {
+    try {
+      const client = new pg.Client({
+        connectionString: config.database.url,
+      });
+
+      await client.connect();
+      await client.end();
+
+      return { ready: true };
+    } catch (err) {
+      logger.error("readiness.failed", { err });
+      reply.status(503);
+      return { ready: false };
+    }
+  });
+}

package/src/http/jobs.ts

@@ -0,0 +1,108 @@
+import { randomUUID } from "crypto";
+import type { FastifyInstance } from "fastify";
+
+import type { JobStore } from "../jobs/store.js";
+import type { ResolvedConfig, CredentialContext } from "@prsense/config";
+import type { Logger } from "@prsense/logging";
+
+import { runJob } from "../jobs/runJob.js";
+import { runIndexJob } from "../jobs/index/runIndexJob.js";
+import { runReviewJob } from "../jobs/review/runReviewJob.js";
+
+export function registerJobRoutes(
+  app: FastifyInstance,
+  store: JobStore,
+  config: ResolvedConfig,
+  credentials: CredentialContext,
+  logger: Logger,
+) {
+  /* ----------------------------- */
+  /* INDEX JOB                     */
+  /* ----------------------------- */
+
+  app.post("/jobs/index", async (req, reply) => {
+    const body = req.body as {
+      target: string;
+      force?: boolean;
+      dryRun?: boolean;
+    };
+
+    if (!body?.target) {
+      reply.status(400);
+      return { error: "target is required" };
+    }
+
+    const jobId = randomUUID();
+
+    store.create({
+      id: jobId,
+      type: "index",
+      state: "queued",
+      input: body,
+      createdAt: Date.now(),
+    });
+
+    runJob(store, logger, jobId, async () =>
+      runIndexJob(body, config, credentials, logger),
+    );
+
+    return { jobId };
+  });
+
+  /* ----------------------------- */
+  /* REVIEW JOB                    */
+  /* ----------------------------- */
+
+  app.post("/jobs/review", async (req, reply) => {
+    const body = req.body as {
+      target: string;
+      baseBranch?: string;
+    };
+
+    if (!body?.target) {
+      reply.status(400);
+      return { error: "target is required" };
+    }
+
+    const jobId = randomUUID();
+
+    store.create({
+      id: jobId,
+      type: "review",
+      state: "queued",
+      input: body,
+      createdAt: Date.now(),
+    });
+
+    runJob(store, logger, jobId, async () =>
+      runReviewJob(body, config, credentials, logger),
+    );
+
+    return { jobId };
+  });
+
+  /* ----------------------------- */
+  /* JOB STATUS                    */
+  /* ----------------------------- */
+
+  app.get("/jobs/:id", async (req, reply) => {
+    const id = (req.params as any).id;
+
+    const job = store.get(id);
+
+    if (!job) {
+      reply.status(404);
+      return { error: "Job not found" };
+    }
+
+    return job;
+  });
+
+  /* ----------------------------- */
+  /* LIST JOBS                     */
+  /* ----------------------------- */
+
+  app.get("/jobs", async () => {
+    return store.list();
+  });
+}

package/src/http/webhooks/github.ts

@@ -0,0 +1,106 @@
+//apps/daemon/src/http/webhooks/github.ts
+import crypto from "node:crypto";
+import type { FastifyInstance } from "fastify";
+import type { JobStore } from "../../jobs/store.js";
+import { randomUUID } from "node:crypto";
+import { runJob } from "../../jobs/runJob.js";
+import { runReviewJob } from "../../jobs/review/runReviewJob.js";
+import type { ResolvedConfig, CredentialContext } from "@prsense/config";
+import type { Logger } from "@prsense/logging";
+import { createDeliveryRegistry } from "../../idempotency/deliveryRegistry.js";
+
+type DeliveryRegistry = ReturnType<typeof createDeliveryRegistry>;
+
+export function registerGitHubWebhook(
+  app: FastifyInstance,
+  store: JobStore,
+  config: ResolvedConfig,
+  credentials: CredentialContext,
+  logger: Logger,
+  deliveryRegistry: DeliveryRegistry,
+) {
+  app.post(
+    "/webhooks/github",
+    { config: { rawBody: true } },
+    async (req, reply) => {
+      const secret = credentials.github?.webhookSecret;
+      if (!secret) {
+        reply.status(500).send({ error: "Webhook not configured" });
+        return;
+      }
+
+      const signature = req.headers["x-hub-signature-256"] as string;
+      const rawBody = (req as any).rawBody as Buffer;
+
+      if (!signature || !rawBody) {
+        reply.status(400).send({ error: "Invalid request" });
+        return;
+      }
+
+      const expected =
+        "sha256=" +
+        crypto.createHmac("sha256", secret).update(rawBody).digest("hex");
+
+      if (
+        !crypto.timingSafeEqual(Buffer.from(expected), Buffer.from(signature))
+      ) {
+        logger.warn("github.webhook.invalid_signature");
+        reply.status(401).send({ error: "Invalid signature" });
+        return;
+      }
+
+      const deliveryId = req.headers["x-github-delivery"] as string;
+
+      if (!deliveryId) {
+        reply.status(400).send({ error: "Missing delivery id" });
+        return;
+      }
+
+      if (deliveryRegistry.has(deliveryId)) {
+        logger.info("github.webhook.duplicate", { deliveryId });
+        reply.status(200).send({ duplicate: true });
+        return;
+      }
+
+      deliveryRegistry.register(deliveryId);
+
+      const event = req.headers["x-github-event"];
+
+      if (event !== "pull_request") {
+        reply.status(200).send({ ignored: true });
+        return;
+      }
+
+      const payload = req.body as any;
+
+      if (payload.action !== "opened" && payload.action !== "synchronize") {
+        reply.status(200).send({ ignored: true });
+        return;
+      }
+
+      const prUrl = payload.pull_request?.html_url;
+      if (!prUrl) {
+        reply.status(400).send({ error: "Malformed PR event" });
+        return;
+      }
+
+      const jobId = randomUUID();
+
+      store.create({
+        id: jobId,
+        type: "review",
+        state: "queued",
+        input: { target: prUrl },
+        createdAt: Date.now(),
+      });
+
+      runJob(store, logger, jobId, async () =>
+        runReviewJob({ target: prUrl }, config, credentials, logger),
+      );
+
+      logger.info("github.webhook.job_created", { jobId, prUrl });
+
+      reply.send({ jobId });
+    },
+  );
+}

package/src/http/webhooks/gitlab.ts

@@ -0,0 +1,91 @@
+//apps/daemon/src/http/webhooks/gitlab.ts
+import type { FastifyInstance } from "fastify";
+import type { JobStore } from "../../jobs/store.js";
+import { randomUUID } from "node:crypto";
+import { runJob } from "../../jobs/runJob.js";
+import { runReviewJob } from "../../jobs/review/runReviewJob.js";
+import type { ResolvedConfig, CredentialContext } from "@prsense/config";
+import type { Logger } from "@prsense/logging";
+import { createDeliveryRegistry } from "../../idempotency/deliveryRegistry.js";
+
+type DeliveryRegistry = ReturnType<typeof createDeliveryRegistry>;
+
+export function registerGitLabWebhook(
+  app: FastifyInstance,
+  store: JobStore,
+  config: ResolvedConfig,
+  credentials: CredentialContext,
+  logger: Logger,
+  deliveryRegistry: DeliveryRegistry,
+) {
+  app.post("/webhooks/gitlab", async (req, reply) => {
+    const secret = credentials.gitlab?.webhookSecret;
+    if (!secret) {
+      reply.status(500).send({ error: "Webhook not configured" });
+      return;
+    }
+
+    const token = req.headers["x-gitlab-token"];
+
+    if (token !== secret) {
+      logger.warn("gitlab.webhook.invalid_token");
+      reply.status(401).send({ error: "Invalid token" });
+      return;
+    }
+
+    const deliveryId =
+      (req.headers["x-gitlab-event-uuid"] as string) ?? undefined;
+
+    if (!deliveryId) {
+      reply.status(400).send({ error: "Missing delivery UUID" });
+      return;
+    }
+
+    if (deliveryRegistry.has(deliveryId)) {
+      logger.info("gitlab.webhook.duplicate", { deliveryId });
+      reply.status(200).send({ duplicate: true });
+      return;
+    }
+
+    deliveryRegistry.register(deliveryId);
+
+    const payload = req.body as any;
+
+    if (payload.object_kind !== "merge_request") {
+      reply.status(200).send({ ignored: true });
+      return;
+    }
+
+    if (
+      payload.object_attributes?.action !== "open" &&
+      payload.object_attributes?.action !== "update"
+    ) {
+      reply.status(200).send({ ignored: true });
+      return;
+    }
+
+    const mrUrl = payload.object_attributes?.url;
+    if (!mrUrl) {
+      reply.status(400).send({ error: "Malformed MR event" });
+      return;
+    }
+
+    const jobId = randomUUID();
+
+    store.create({
+      id: jobId,
+      type: "review",
+      state: "queued",
+      input: { target: mrUrl },
+      createdAt: Date.now(),
+    });
+
+    runJob(store, logger, jobId, async () =>
+      runReviewJob({ target: mrUrl }, config, credentials, logger),
+    );
+
+    logger.info("gitlab.webhook.job_created", { jobId, mrUrl });
+
+    reply.send({ jobId });
+  });
+}

package/src/idempotency/deliveryRegistry.ts

@@ -0,0 +1,31 @@
+type DeliveryEntry = {
+  id: string;
+  timestamp: number;
+};
+
+export function createDeliveryRegistry(ttlMs = 60 * 60 * 1000) {
+  const deliveries = new Map<string, DeliveryEntry>();
+
+  function cleanup() {
+    const now = Date.now();
+    for (const [key, entry] of deliveries) {
+      if (now - entry.timestamp > ttlMs) {
+        deliveries.delete(key);
+      }
+    }
+  }
+
+  return {
+    has(id: string): boolean {
+      cleanup();
+      return deliveries.has(id);
+    },
+
+    register(id: string): void {
+      deliveries.set(id, {
+        id,
+        timestamp: Date.now(),
+      });
+    },
+  };
+}

package/src/index.ts

@@ -0,0 +1,75 @@
+import Fastify from "fastify";
+import fastifyRawBody from "fastify-raw-body";
+
+import { bootstrapDaemon } from "./bootstrap.js";
+import { createDaemonLogger } from "./logger.js";
+import { createJobStore } from "./jobs/store.js";
+import { registerJobRoutes } from "./http/jobs.js";
+import { registerHealthRoutes } from "./http/health.js";
+import { setupGracefulShutdown } from "./shutdown.js";
+import { registerGitHubWebhook } from "./http/webhooks/github.js";
+import { registerGitLabWebhook } from "./http/webhooks/gitlab.js";
+import { createDeliveryRegistry } from "./idempotency/deliveryRegistry.js";
+
+const deliveryRegistry = createDeliveryRegistry();
+
+async function main() {
+  const logger = createDaemonLogger();
+  const { config, credentials } = bootstrapDaemon();
+
+  logger.info("daemon.starting", {
+    mode: config.mode,
+    llm: config.llm.provider,
+    embeddings: config.embeddings.provider,
+  });
+
+  const app = Fastify({ logger: false, bodyLimit: 10 * 1024 * 1024 }); // use our logger instead
+
+  await app.register(fastifyRawBody, {
+    field: "rawBody",
+    global: false,
+    encoding: false,
+  });
+
+  const jobStore = createJobStore(logger);
+
+  setupGracefulShutdown({
+    closeHttp: async () => {
+      logger.info("daemon.http.closing");
+      await app.close();
+    },
+    onShutdown: async () => {
+      logger.info("daemon.draining.jobs");
+      await jobStore.drain();
+    },
+  });
+
+  registerHealthRoutes(app, logger, config);
+  registerJobRoutes(app, jobStore, config, credentials, logger);
+  registerGitHubWebhook(
+    app,
+    jobStore,
+    config,
+    credentials,
+    logger,
+    deliveryRegistry,
+  );
+  registerGitLabWebhook(
+    app,
+    jobStore,
+    config,
+    credentials,
+    logger,
+    deliveryRegistry,
+  );
+
+  const port = parseInt(process.env.PRSENSE_DAEMON_PORT ?? "11000");
+  await app.listen({ port: port });
+
+  logger.info("daemon.started", { port });
+}
+
+main().catch((err) => {
+  console.error("Daemon startup failed:", err);
+  process.exit(1);
+});

package/src/jobs/index/runIndexJob.ts

@@ -0,0 +1,29 @@
+import { runIndexWorkflow } from "@prsense/workflows";
+import { createEventBus, PRSENSE_VERSION } from "@prsense/core";
+import type { ResolvedConfig, CredentialContext } from "@prsense/config";
+import type { Logger } from "@prsense/logging";
+import type { IndexJobInput } from "./types.js";
+
+export async function runIndexJob(
+  input: IndexJobInput,
+  config: ResolvedConfig,
+  credentials: CredentialContext,
+  logger: Logger,
+) {
+  const eventBus = createEventBus((event) => {
+    logger.info("domain.event", {
+      event: event.event,
+      fields: event.fields,
+    });
+  });
+
+  return runIndexWorkflow({
+    config,
+    credentials,
+    target: input.target,
+    ...(input.force !== undefined ? { force: input.force } : {}),
+    ...(input.dryRun !== undefined ? { dryRun: input.dryRun } : {}),
+    eventBus,
+    version: PRSENSE_VERSION,
+  });
+}

package/src/jobs/index/types.ts

@@ -0,0 +1,6 @@
+// apps/daemon/src/jobs/index/types.ts
+export type IndexJobInput = {
+  target: string;
+  force?: boolean;
+  dryRun?: boolean;
+};

package/src/jobs/review/runReviewJob.ts

@@ -0,0 +1,126 @@
+// apps/daemon/src/jobs/review/runReviewJob.ts
+import { runReviewWorkflow } from "@prsense/workflows";
+import { createEventBus } from "@prsense/core";
+import {
+  LocalGitDiffProvider,
+  GitHubPrDiffProvider,
+  GitLabMrDiffProvider,
+} from "@prsense/context";
+import type { ResolvedConfig, CredentialContext } from "@prsense/config";
+import type { Logger } from "@prsense/logging";
+import type { ReviewJobInput } from "./types.js";
+import { createReporter } from "@prsense/reporters";
+
+export async function runReviewJob(
+  input: ReviewJobInput,
+  config: ResolvedConfig,
+  credentials: CredentialContext,
+  logger: Logger,
+) {
+  const eventBus = createEventBus((event) => {
+    logger.info("domain.event", {
+      event: event.event,
+      fields: event.fields,
+    });
+  });
+
+  let diffProvider;
+
+  // -------------------------------------------------
+  // Determine Provider
+  // -------------------------------------------------
+
+  const githubMatch = input.target.match(
+    /github\.com\/([^\/]+)\/([^\/]+)\/pull\/(\d+)/,
+  );
+
+  if (githubMatch) {
+    const owner = githubMatch[1];
+    const repo = githubMatch[2];
+    const pr = githubMatch[3];
+
+    if (!owner || !repo || !pr) {
+      throw new Error("Invalid GitHub PR URL");
+    }
+
+    diffProvider = new GitHubPrDiffProvider(
+      owner,
+      repo.replace(".git", ""),
+      pr,
+    );
+  } else {
+    const gitlabMatch = input.target.match(
+      /gitlab\.com\/([^\/]+)\/([^\/]+)\/-\/merge_requests\/(\d+)/,
+    );
+
+    if (gitlabMatch) {
+      const group = gitlabMatch[1];
+      const project = gitlabMatch[2];
+      const mr = gitlabMatch[3];
+
+      if (!group || !project || !mr) {
+        throw new Error("Invalid GitLab MR URL");
+      }
+
+      diffProvider = new GitLabMrDiffProvider(
+        group,
+        project.replace(".git", ""),
+        mr,
+      );
+    } else {
+      // Fallback: local repository
+      diffProvider = new LocalGitDiffProvider(input.target, input.baseBranch);
+    }
+  }
+
+  // -------------------------------------------------
+  // Execute Review Workflow
+  // -------------------------------------------------
+
+  const result = await runReviewWorkflow({
+    config,
+    credentials,
+    diffProvider,
+    eventBus,
+  });
+
+  // -------------------------------------------------
+  // Delivery (Daemon Mode Only)
+  // -------------------------------------------------
+
+  if (
+    result.outcome === "success" &&
+    config.mode === "daemon" &&
+    "delivery" in config &&
+    result.payload.signals.length > 0
+  ) {
+    const platform = config.delivery.platform;
+
+    const reporter = createReporter(platform, credentials);
+
+    if (!reporter) {
+      logger.warn("delivery.reporter_not_available", {
+        provider: platform,
+      });
+    } else {
+      try {
+        await reporter.deliver(result.payload.signals, {
+          targetUrl: input.target,
+          repositoryProvider: platform,
+        });
+
+        logger.info("delivery.completed", {
+          provider: platform,
+          signalCount: result.payload.signals.length,
+        });
+      } catch (err) {
+        logger.error("delivery.failed", {
+          provider: platform,
+          error: err instanceof Error ? err.message : String(err),
+        });
+      }
+    }
+  }
+
+  return result;
+}

package/src/jobs/review/types.ts

@@ -0,0 +1,5 @@
+// apps/daemon/src/jobs/review/types.ts
+export type ReviewJobInput = {
+  target: string; // local path OR PR/MR URL
+  baseBranch?: string;
+};

package/src/jobs/runJob.ts

@@ -0,0 +1,47 @@
+import type { JobStore } from "./store.js";
+import type { Logger } from "@prsense/logging";
+
+export async function runJob<TResult>(
+  store: JobStore,
+  logger: Logger,
+  jobId: string,
+  fn: () => Promise<TResult>,
+) {
+  const promise = (async () => {
+    logger.info("job.execution.started", { jobId });
+    store.update(jobId, {
+      state: "running",
+      startedAt: Date.now(),
+    });
+
+    try {
+      const result = await fn();
+
+      store.update(jobId, {
+        state: "completed",
+        result,
+        finishedAt: Date.now(),
+      });
+
+      logger.info("job.execution.completed", { jobId });
+      return result;
+    } catch (err) {
+      const message = err instanceof Error ? err.message : "Unknown error";
+
+      store.update(jobId, {
+        state: "failed",
+        error: message,
+        finishedAt: Date.now(),
+      });
+
+      logger.error("job.execution.failed", {
+        jobId,
+        error: message,
+      });
+
+      throw err;
+    }
+  })();
+
+  return store.track(jobId, promise);
+}