ework-daemon 0.1.0

package/src/server.ts

@@ -0,0 +1,160 @@
+import type { Config } from "./config";
+import type { Store } from "./op";
+import type { Engine } from "./opencode";
+import type { IssueTracker, TrackerEvent } from "./trackers/types";
+import { log, uptimeSeconds, version } from "./logger";
+
+type TrackerMap = Map<string, IssueTracker>;
+
+function json(data: unknown, status = 200) {
+  return new Response(JSON.stringify(data, null, 2), {
+    status,
+    headers: { "Content-Type": "application/json" },
+  });
+}
+
+export function createServer(
+  cfg: Config,
+  store: Store,
+  engine: Engine,
+  trackers: TrackerMap
+) {
+  async function handleWebhook(req: Request, tracker: IssueTracker): Promise<Response> {
+    const rawBody = await req.text();
+    const headers: Record<string, string | null> = {};
+    req.headers.forEach((v, k) => { headers[k] = v; });
+
+    if (!tracker.verifyWebhookSignature(rawBody, headers)) {
+      log.warn("webhook: invalid signature");
+      return new Response("invalid signature", { status: 403 });
+    }
+
+    const event = tracker.parseWebhookEvent(rawBody);
+    if (!event) {
+      return new Response("unrecognized event", { status: 400 });
+    }
+
+    log.info(
+      `webhook: type=${event.type} ref=${event.ref.trackerType}:${event.ref.scope.owner ?? ""}/${event.ref.scope.repo ?? ""}#${event.ref.issueId}`
+    );
+
+    engine.handleEvent(event).catch((err) => {
+      log.error("webhook: handler error:", err);
+    });
+
+    return new Response("ok", { status: 200 });
+  }
+
+  async function handleApi(req: Request, pathname: string): Promise<Response> {
+    if (pathname === "/api/status") {
+      const status = engine.getStatus();
+      return json({
+        env: cfg.env,
+        daemon: { host: cfg.daemon.host, port: cfg.daemon.port },
+        db: cfg.db.path,
+        running: status.runningCount,
+        pending: status.pendingCount,
+        processes: status.processCount,
+        observedIssues: status.observedIssues,
+        issues: store.listAllIssues().length,
+        sessions: store.listAllSessions().length,
+      });
+    }
+
+    if (pathname === "/api/issues") {
+      return json(store.listAllIssues());
+    }
+
+    if (pathname === "/api/sessions") {
+      return json(store.listAllSessions());
+    }
+
+    const issueIdMatch = pathname.match(/^\/api\/issues\/([0-9a-f-]+)$/);
+    if (issueIdMatch) {
+      const issue = store.getIssue(issueIdMatch[1]!);
+      if (!issue) return json({ error: "not found" }, 404);
+      const sessions = store.getSessionsForIssue(issue.id);
+      return json({ ...issue, sessions });
+    }
+
+    const sessionIdMatch = pathname.match(/^\/api\/sessions\/([0-9a-f-]+)$/);
+    if (sessionIdMatch) {
+      const session = store.getSession(sessionIdMatch[1]!);
+      if (!session) return json({ error: "not found" }, 404);
+      return json(session);
+    }
+
+    if (pathname === "/api/queue") {
+      return json(engine.getQueue());
+    }
+
+    if (pathname === "/api/processes") {
+      return json(engine.getProcesses());
+    }
+
+    const sessionMsgsMatch = pathname.match(/^\/api\/sessions\/([0-9a-f-]+)\/messages$/);
+    if (sessionMsgsMatch) {
+      const session = store.getSession(sessionMsgsMatch[1]!);
+      if (!session) return json({ error: "not found" }, 404);
+      return json(store.getMessagesForSession(session.id));
+    }
+
+    const msgRetryMatch = pathname.match(/^\/api\/messages\/([0-9a-f-]+)\/retry$/);
+    if (msgRetryMatch && req.method === "PATCH") {
+      const result = engine.retryMessage(msgRetryMatch[1]!);
+      if (!result) {
+        const msg = store.getMessage(msgRetryMatch[1]!);
+        if (!msg) return json({ error: "not found" }, 404);
+        if (msg.status !== "failed") return json({ error: "only failed messages can be retried" }, 400);
+      }
+      return json({ ok: true, id: msgRetryMatch[1] });
+    }
+
+    const forceStopMatch = pathname.match(/^\/api\/processes\/(.+)$/);
+    if (forceStopMatch && req.method === "DELETE") {
+      const key = decodeURIComponent(forceStopMatch[1]!);
+      log.warn(`api: DELETE /api/processes/${key} (force-stop request)`);
+      const wasKilled = engine.forceStop(key);
+      return json({ ok: true, stopped: wasKilled });
+    }
+
+    return json({ error: "not found" }, 404);
+  }
+
+  const server = Bun.serve({
+    port: cfg.daemon.port,
+    hostname: cfg.daemon.host,
+    async fetch(req) {
+      const url = new URL(req.url);
+      const pathname = url.pathname;
+
+      if (pathname === "/healthz") {
+        return new Response(
+          JSON.stringify({ ok: true, version: version(), uptime: uptimeSeconds() }),
+          { status: 200, headers: { "content-type": "application/json", "cache-control": "no-store" } },
+        );
+      }
+
+      if (req.method === "POST") {
+        if (pathname === "/webhook/gitea" || pathname === "/webhook") {
+          const tracker = trackers.get("gitea");
+          if (!tracker) return json({ error: "gitea tracker not configured" }, 500);
+          return handleWebhook(req, tracker);
+        }
+        if (pathname === "/webhook/plane") {
+          const tracker = trackers.get("plane");
+          if (!tracker) return json({ error: "plane tracker not configured" }, 500);
+          return handleWebhook(req, tracker);
+        }
+      }
+
+      if (pathname.startsWith("/api/")) {
+        return handleApi(req, pathname);
+      }
+
+      return new Response("not found", { status: 404 });
+    },
+  });
+
+  return server;
+}

package/src/trackers/gitea-tracker.ts

@@ -0,0 +1,181 @@
+import { createHmac, timingSafeEqual } from "crypto";
+import type { GiteaClient } from "../gitea";
+import type {
+  IssueTracker,
+  TrackerRef,
+  TrackerEvent,
+  TrackerComment,
+  TrackerInstructions,
+} from "./types";
+
+export class GiteaTracker implements IssueTracker {
+  readonly type = "gitea";
+
+  private client: GiteaClient;
+  private url: string;
+  private webhookSecret: string;
+  private botUsername: string;
+
+  constructor(client: GiteaClient, url: string, webhookSecret: string, botUsername: string) {
+    this.client = client;
+    this.url = url.replace(/\/$/, "");
+    this.webhookSecret = webhookSecret;
+    this.botUsername = botUsername;
+  }
+
+  formatScopeKey(scope: Record<string, string>): string {
+    return `${scope.owner}/${scope.repo}`;
+  }
+
+  private owner(ref: TrackerRef) { return ref.scope["owner"]!; }
+  private repo(ref: TrackerRef) { return ref.scope["repo"]!; }
+
+  createComment(ref: TrackerRef, body: string) {
+    return this.client.createComment(
+      this.owner(ref), this.repo(ref), Number(ref.issueId), body
+    ).then(r => ({ id: String(r.id) }));
+  }
+
+  async editComment(ref: TrackerRef, commentId: string, body: string) {
+    await this.client.editComment(
+      this.owner(ref), this.repo(ref), Number(commentId), body
+    );
+  }
+
+  async deleteComment(ref: TrackerRef, commentId: string) {
+    await this.client.deleteComment(
+      this.owner(ref), this.repo(ref), Number(commentId)
+    );
+  }
+
+  listComments(ref: TrackerRef): Promise<TrackerComment[]> {
+    return this.client.listComments(
+      this.owner(ref), this.repo(ref), Number(ref.issueId)
+    ).then(comments => comments.map(c => ({
+      id: String(c.id),
+      body: c.body,
+      author: c.user.login,
+      createdAt: c.created_at,
+    })));
+  }
+
+  async closeIssue(ref: TrackerRef) {
+    await this.client.closeIssue(
+      this.owner(ref), this.repo(ref), Number(ref.issueId)
+    );
+  }
+
+  async setReaction(ref: TrackerRef, commentId: string, content: string, remove = false) {
+    if (remove) {
+      await this.client.removeCommentReaction(
+        this.owner(ref), this.repo(ref), Number(commentId), content
+      );
+    } else {
+      await this.client.addCommentReaction(
+        this.owner(ref), this.repo(ref), Number(commentId), content
+      );
+    }
+  }
+
+  getTrackerInstructions(ref: TrackerRef): TrackerInstructions {
+    const owner = this.owner(ref);
+    const repo = this.repo(ref);
+    const num = ref.issueId;
+    return {
+      clone: `git clone ${this.url}/${owner}/${repo}.git .`,
+      issueRef: `${owner}/${repo}#${num}`,
+      closeIssue: `tea issues close ${num} --repo ${owner}/${repo}`,
+    };
+  }
+
+  verifyWebhookSignature(rawBody: string, headers: Record<string, string | null>): boolean {
+    const signature = headers["x-gitea-signature"];
+    if (!this.webhookSecret) return true;
+    if (!signature) return false;
+
+    const expected = createHmac("sha256", this.webhookSecret).update(rawBody).digest("hex");
+    if (expected.length !== signature.length) return false;
+    return timingSafeEqual(Buffer.from(expected), Buffer.from(signature));
+  }
+
+  parseWebhookEvent(rawBody: string): TrackerEvent | null {
+    let payload: Record<string, unknown>;
+    try {
+      payload = JSON.parse(rawBody);
+    } catch {
+      return null;
+    }
+
+    const action = payload.action;
+    const issue = payload.issue as Record<string, unknown> | undefined;
+    const comment = payload.comment as Record<string, unknown> | undefined;
+    const repository = payload.repository as Record<string, unknown> | undefined;
+    if (typeof action !== "string") return null;
+    if (!repository || typeof repository !== "object") return null;
+    if (!issue || typeof issue !== "object") return null;
+    if (issue.number == null) return null;
+
+    const repoOwner = (repository.owner as Record<string, string>)?.login;
+    const repoName = repository.name as string;
+    if (!repoOwner || !repoName) return null;
+
+    const ref: TrackerRef = {
+      trackerType: "gitea",
+      scope: { owner: repoOwner, repo: repoName },
+      issueId: String(issue.number),
+    };
+
+    const issueUser = issue.user as Record<string, string>;
+
+    if (action === "opened" || action === "reopened") {
+      return {
+        type: "issue_opened",
+        ref,
+        issue: {
+          title: issue.title as string,
+          body: (issue.body as string) ?? "",
+          state: (issue.state as string) ?? "open",
+          author: issueUser?.login ?? "",
+        },
+      };
+    }
+
+    if (action === "created" && comment) {
+      const commentUser = comment.user as Record<string, string>;
+      return {
+        type: "comment_created",
+        ref,
+        issue: {
+          title: issue.title as string,
+          body: (issue.body as string) ?? "",
+          state: (issue.state as string) ?? "open",
+          author: issueUser?.login ?? "",
+        },
+        comment: {
+          id: String(comment.id),
+          body: comment.body as string,
+          author: commentUser?.login ?? "",
+        },
+      };
+    }
+
+    if (action === "closed") {
+      return {
+        type: "issue_closed",
+        ref,
+        issue: {
+          title: issue.title as string,
+          body: (issue.body as string) ?? "",
+          state: "closed",
+          author: issueUser?.login ?? "",
+        },
+      };
+    }
+
+    return null;
+  }
+
+  isBotUser(userIdentifier: string): boolean {
+    return userIdentifier === this.botUsername;
+  }
+}

package/src/trackers/types.ts

@@ -0,0 +1,155 @@
+/**
+ * Issue Tracker Abstraction Layer.
+ * Three-entity model: Issue → OpSession → Process
+ */
+
+// ─── Core Data Types ───
+
+/** Tracker-agnostic issue reference */
+export interface TrackerRef {
+  trackerType: string;
+  scope: Record<string, string>;
+  issueId: string;
+}
+
+/** Parsed, tracker-agnostic webhook event */
+export type TrackerEventType = "issue_opened" | "comment_created" | "issue_closed";
+
+export interface TrackerEvent {
+  type: TrackerEventType;
+  ref: TrackerRef;
+  issue: {
+    title: string;
+    body: string;
+    state: string;
+    author: string;
+  };
+  comment?: {
+    id: string;
+    body: string;
+    author: string;
+  };
+}
+
+/** Tracker-agnostic comment */
+export interface TrackerComment {
+  id: string;
+  body: string;
+  author: string;
+  createdAt?: string; // ISO timestamp
+}
+
+/** Context injected into opencode prompts */
+export interface TrackerInstructions {
+  clone: string;
+  issueRef: string;
+  closeIssue?: string;
+}
+
+// ─── Three-Entity Model ───
+
+export type IssueState = "created" | "active" | "closed";
+
+/** Issue = tracker resource with cyclic lifecycle (created → active → closed → active) */
+export interface Issue {
+  id: string;
+  trackerType: string;
+  trackerScope: Record<string, string>;
+  trackerScopeKey: string;
+  trackerIssueId: string;
+  state: IssueState;
+  title: string;
+  createdAt: Date;
+  updatedAt: Date;
+}
+
+export type SessionState = "idle" | "running";
+
+/** OpSession = persistent agent binding to one issue. Never destroyed. */
+export interface OpSession {
+  id: string;
+  issueId: string;
+  name: string;
+  state: SessionState;
+  opencodeSessionId?: string;
+  opencodePid?: number;
+  workdir?: string;
+  createdAt: Date;
+  // Runtime state (persisted for crash recovery)
+  startedAt?: number;
+  progressCommentId?: string;
+  reactionCommentId?: string;
+  currentPrompt?: string;
+}
+
+/** Message = a prompt enqueued for a session */
+export interface Message {
+  id: string;
+  sessionId: string;
+  content: string;
+  sourceCommentId?: string;
+  reactionCommentId?: string;
+  status: "pending" | "running" | "done" | "failed" | "interrupted";
+  attempts: number;
+  error?: string;
+  createdAt: Date;
+  updatedAt: Date;
+}
+
+// ─── Adapter Interface ───
+
+export interface IssueTracker {
+  readonly type: string;
+
+  formatScopeKey(scope: Record<string, string>): string;
+
+  createComment(ref: TrackerRef, body: string): Promise<{ id: string }>;
+  editComment(ref: TrackerRef, commentId: string, body: string): Promise<void>;
+  deleteComment(ref: TrackerRef, commentId: string): Promise<void>;
+  listComments(ref: TrackerRef): Promise<TrackerComment[]>;
+  closeIssue(ref: TrackerRef): Promise<void>;
+
+  setReaction(ref: TrackerRef, commentId: string, content: string, remove?: boolean): Promise<void>;
+
+  getTrackerInstructions(ref: TrackerRef): TrackerInstructions;
+
+  verifyWebhookSignature(rawBody: string, headers: Record<string, string | null>): boolean;
+  parseWebhookEvent(rawBody: string): TrackerEvent | null;
+
+  isBotUser(userIdentifier: string): boolean;
+}
+
+// ─── Runtime Key Format ───
+
+/**
+ * Runtime key: `trackerType:scopeKey#issueId@sessionName`
+ *   gitea:owner/repo#123@ework-daemon
+ *   plane:test-ws/proj-uuid#wi-456@ework-daemon
+ * Keys are NEVER stored in DB — purely runtime Map/Set indices.
+ */
+export function formatKey(trackerType: string, scopeKey: string, issueId: string, sessionName: string): string {
+  return `${trackerType}:${scopeKey}#${issueId}@${sessionName}`;
+}
+
+export interface ParsedKey {
+  trackerType: string;
+  scopeKey: string;
+  issueId: string;
+  sessionName: string;
+}
+
+export function parseKey(k: string): ParsedKey | null {
+  const colonIdx = k.indexOf(":");
+  const hashIdx = k.lastIndexOf("#");
+  const atIdx = k.lastIndexOf("@");
+  if (colonIdx < 0 || hashIdx < 0 || atIdx < 0) return null;
+  if (colonIdx > hashIdx || hashIdx > atIdx) return null;
+
+  const trackerType = k.slice(0, colonIdx);
+  const scopeKey = k.slice(colonIdx + 1, hashIdx);
+  const issueId = k.slice(hashIdx + 1, atIdx);
+  const sessionName = k.slice(atIdx + 1);
+
+  if (!trackerType || !scopeKey || !issueId || !sessionName) return null;
+  return { trackerType, scopeKey, issueId, sessionName };
+}