ework-daemon 0.1.0

package/src/config.ts

@@ -0,0 +1,134 @@
+import { z } from "zod";
+import { join } from "path";
+import { tmpdir, homedir } from "os";
+
+export type DaemonEnv = "test" | "production";
+
+export function getEnv(): DaemonEnv {
+  const v = process.env.DAEMON_ENV;
+  if (v === "production" || v === "prod") return "production";
+  return "test"; // default
+}
+
+export const configSchema = z.object({
+  env: z.enum(["test", "production"]),
+  gitea: z.object({
+    url: z.string(),
+    token: z.string(),
+    webhookSecret: z.string().default(""),
+  }),
+  bot: z.object({
+    username: z.string(),
+    token: z.string(),
+  }),
+  daemon: z.object({
+    port: z.coerce.number().default(3101),
+    host: z.string().default("0.0.0.0"),
+  }),
+  opencode: z.object({
+    binary: z.string().default("opencode"),
+    baseWorkdir: z.string(),
+  }),
+  db: z.object({
+    path: z.string(),
+  }),
+  completionCheck: z.object({
+    apiKey: z.string(),
+    baseURL: z.string(),
+    model: z.string(),
+  }).optional(),
+  stuck: z.object({
+    thresholdMs: z.coerce.number().positive(),
+    maxNudges: z.coerce.number().int().nonnegative(),
+  }).optional(),
+});
+
+export type Config = z.infer<typeof configSchema>;
+
+const PRODUCTION_DB_DEFAULT = join(
+  process.env.XDG_DATA_HOME ?? join(homedir(), ".local", "share"),
+  "ework-daemon",
+  "ework-daemon.db"
+);
+
+const TEST_DEFAULTS = {
+  gitea: { url: "http://localhost:9999", token: "test-token", webhookSecret: "" },
+  bot: { username: "ework-daemon-test", token: "test-bot-token" },
+  daemon: { port: 3111, host: "0.0.0.0" },
+  opencode: { binary: "opencode", baseWorkdir: join(tmpdir(), "ework-daemon-test") },
+  db: { path: join(process.cwd(), "test", "ework-daemon-test.db") },
+};
+
+export function loadConfig(): Config {
+  const env = getEnv();
+
+  if (env === "test") {
+    // Test mode: use .env.test if present, otherwise defaults.
+    // Never fall through to .env (production values).
+    return configSchema.parse({
+      env,
+      gitea: {
+        url: process.env.GITEA_URL ?? TEST_DEFAULTS.gitea.url,
+        token: process.env.GITEA_TOKEN ?? TEST_DEFAULTS.gitea.token,
+        webhookSecret: process.env.GITEA_WEBHOOK_SECRET ?? "",
+      },
+      bot: {
+        username: process.env.BOT_USERNAME ?? TEST_DEFAULTS.bot.username,
+        token: process.env.BOT_TOKEN ?? TEST_DEFAULTS.bot.token,
+      },
+      daemon: {
+        port: process.env.DAEMON_PORT ?? TEST_DEFAULTS.daemon.port,
+        host: process.env.DAEMON_HOST ?? TEST_DEFAULTS.daemon.host,
+      },
+      opencode: {
+        binary: process.env.OPENCODE_BINARY ?? TEST_DEFAULTS.opencode.binary,
+        baseWorkdir: process.env.OPENCODE_BASE_WORKDIR ?? TEST_DEFAULTS.opencode.baseWorkdir,
+      },
+      db: {
+        path: process.env.DAEMON_DB_PATH ?? TEST_DEFAULTS.db.path,
+      },
+      completionCheck: process.env.COMPLETION_CHECK_API_KEY ? {
+        apiKey: process.env.COMPLETION_CHECK_API_KEY,
+        baseURL: process.env.COMPLETION_CHECK_BASE_URL ?? "",
+        model: process.env.COMPLETION_CHECK_MODEL ?? "",
+      } : undefined,
+      stuck: process.env.DAEMON_STUCK_THRESHOLD_MS || process.env.DAEMON_MAX_STUCK_NUDGES ? {
+        thresholdMs: Number(process.env.DAEMON_STUCK_THRESHOLD_MS) || 30 * 60 * 1000,
+        maxNudges: Number(process.env.DAEMON_MAX_STUCK_NUDGES) || 1,
+      } : undefined,
+    });
+  }
+
+  return configSchema.parse({
+    env,
+    gitea: {
+      url: process.env.GITEA_URL,
+      token: process.env.GITEA_TOKEN,
+      webhookSecret: process.env.GITEA_WEBHOOK_SECRET ?? "",
+    },
+    bot: {
+      username: process.env.BOT_USERNAME,
+      token: process.env.BOT_TOKEN,
+    },
+    daemon: {
+      port: process.env.DAEMON_PORT ?? 3101,
+      host: process.env.DAEMON_HOST ?? "0.0.0.0",
+    },
+    opencode: {
+      binary: process.env.OPENCODE_BINARY ?? "opencode",
+      baseWorkdir: process.env.OPENCODE_BASE_WORKDIR,
+    },
+    db: {
+      path: process.env.DAEMON_DB_PATH ?? PRODUCTION_DB_DEFAULT,
+    },
+    completionCheck: process.env.COMPLETION_CHECK_API_KEY ? {
+      apiKey: process.env.COMPLETION_CHECK_API_KEY,
+      baseURL: process.env.COMPLETION_CHECK_BASE_URL ?? "",
+      model: process.env.COMPLETION_CHECK_MODEL ?? "",
+    } : undefined,
+    stuck: process.env.DAEMON_STUCK_THRESHOLD_MS || process.env.DAEMON_MAX_STUCK_NUDGES ? {
+      thresholdMs: Number(process.env.DAEMON_STUCK_THRESHOLD_MS) || 30 * 60 * 1000,
+      maxNudges: Number(process.env.DAEMON_MAX_STUCK_NUDGES) || 1,
+    } : undefined,
+  });
+}

package/src/gitea.ts

@@ -0,0 +1,137 @@
+import type { Config } from "./config";
+
+export class GiteaClient {
+  private url: string;
+  private token: string;
+  private botToken: string;
+
+  constructor(cfg: Config["gitea"], botToken: string) {
+    this.url = cfg.url.replace(/\/$/, "");
+    this.token = cfg.token;
+    this.botToken = botToken;
+  }
+
+  private async request<T>(
+    method: string,
+    path: string,
+    body?: unknown,
+    useBotToken = false
+  ): Promise<T> {
+    const token = useBotToken ? this.botToken : this.token;
+    const res = await fetch(`${this.url}/api/v1${path}`, {
+      method,
+      headers: {
+        Authorization: `token ${token}`,
+        "Content-Type": "application/json",
+      },
+      body: body ? JSON.stringify(body) : undefined,
+    });
+
+    if (!res.ok) {
+      const text = await res.text();
+      throw new Error(`Gitea API ${method} ${path} → ${res.status}: ${text}`);
+    }
+
+    if (res.status === 204) return undefined as T;
+    return (await res.json()) as T;
+  }
+
+  async getIssue(owner: string, repo: string, number: number) {
+    return this.request<{
+      id: number;
+      number: number;
+      title: string;
+      body: string;
+      state: string;
+      html_url: string;
+      user: { login: string };
+    }>("GET", `/repos/${owner}/${repo}/issues/${number}`);
+  }
+
+  async createComment(
+    owner: string,
+    repo: string,
+    issueNumber: number,
+    body: string
+  ) {
+    return this.request<{
+      id: number;
+      body: string;
+      html_url: string;
+    }>("POST", `/repos/${owner}/${repo}/issues/${issueNumber}/comments`, {
+      body,
+    }, true);
+  }
+
+  async editComment(
+    owner: string,
+    repo: string,
+    commentId: number,
+    body: string
+  ) {
+    return this.request<{
+      id: number;
+      body: string;
+    }>("PATCH", `/repos/${owner}/${repo}/issues/comments/${commentId}`, {
+      body,
+    }, true);
+  }
+
+  async deleteComment(owner: string, repo: string, commentId: number) {
+    return this.request<void>(
+      "DELETE", `/repos/${owner}/${repo}/issues/comments/${commentId}`,
+      undefined, true
+    );
+  }
+
+  async listComments(owner: string, repo: string, issueNumber: number) {
+    return this.request<
+      Array<{ id: number; body: string; created_at: string; user: { login: string } }>
+    >("GET", `/repos/${owner}/${repo}/issues/${issueNumber}/comments`);
+  }
+
+  async closeIssue(owner: string, repo: string, issueNumber: number) {
+    return this.request<{
+      number: number;
+      state: string;
+    }>("PATCH", `/repos/${owner}/${repo}/issues/${issueNumber}`, {
+      state: "closed",
+    });
+  }
+
+  async addReaction(owner: string, repo: string, issueNumber: number, content: string) {
+    return this.request(
+      "POST",
+      `/repos/${owner}/${repo}/issues/${issueNumber}/reactions`,
+      { content },
+      true
+    );
+  }
+
+  async removeReaction(owner: string, repo: string, issueNumber: number, content: string) {
+    return this.request(
+      "DELETE",
+      `/repos/${owner}/${repo}/issues/${issueNumber}/reactions`,
+      { content },
+      true
+    );
+  }
+
+  async addCommentReaction(owner: string, repo: string, commentId: number, content: string) {
+    return this.request(
+      "POST",
+      `/repos/${owner}/${repo}/issues/comments/${commentId}/reactions`,
+      { content },
+      true
+    );
+  }
+
+  async removeCommentReaction(owner: string, repo: string, commentId: number, content: string) {
+    return this.request(
+      "DELETE",
+      `/repos/${owner}/${repo}/issues/comments/${commentId}/reactions`,
+      { content },
+      true
+    );
+  }
+}

package/src/index.ts

@@ -0,0 +1,48 @@
+import { loadConfig } from "./config";
+import { GiteaClient } from "./gitea";
+import { Store } from "./op";
+import { createServer } from "./server";
+import { Engine } from "./opencode";
+import { log } from "./logger";
+import { GiteaTracker } from "./trackers/gitea-tracker";
+import type { IssueTracker } from "./trackers/types";
+
+const config = loadConfig();
+const isTest = config.env === "test";
+
+log.info(`ework-daemon starting [${config.env}]...`);
+log.info(`  gitea: ${config.gitea.url}`);
+log.info(`  listen: ${config.daemon.host}:${config.daemon.port}`);
+log.info(`  opencode: ${config.opencode.binary}`);
+log.info(`  workdir: ${config.opencode.baseWorkdir}`);
+log.info(`  db: ${config.db.path}`);
+
+const giteaClient = new GiteaClient(config.gitea, config.bot.token);
+const giteaTracker = new GiteaTracker(
+  giteaClient,
+  config.gitea.url,
+  config.gitea.webhookSecret,
+  config.bot.username
+);
+
+const trackers = new Map<string, IssueTracker>();
+trackers.set("gitea", giteaTracker);
+
+const store = new Store(config.db.path);
+const engine = new Engine(config, store, trackers);
+
+const server = createServer(config, store, engine, trackers);
+
+async function shutdown(signal: string) {
+  log.info(`\n${signal} received, shutting down...`);
+  engine.destroy();
+  store.close();
+  process.exit(0);
+}
+
+process.on("SIGTERM", () => shutdown("SIGTERM"));
+process.on("SIGINT", () => shutdown("SIGINT"));
+
+log.info(`\n${isTest ? "🧪" : "✅"} ework-daemon ready at http://${server.hostname}:${server.port}/webhook`);
+log.info(`   Configure Gitea webhook to POST to /webhook/gitea`);
+log.info(`   Active issues: ${store.listActiveIssues().length}`);

package/src/logger.ts

@@ -0,0 +1,64 @@
+import { format } from "node:util"
+
+type Level = "debug" | "info" | "warn" | "error"
+
+const LEVELS: Record<Level, number> = { debug: 10, info: 20, warn: 30, error: 40 }
+
+function threshold(): number {
+  const configured = (process.env.WORK_LOG_LEVEL || "info").toLowerCase()
+  return LEVELS[configured as Level] ?? LEVELS.info
+}
+
+function encode(v: unknown): unknown {
+  if (v instanceof Error) return { name: v.name, message: v.message, stack: v.stack }
+  return v
+}
+
+function isPlainObject(v: unknown): v is Record<string, unknown> {
+  if (v === null || typeof v !== "object") return false
+  if (Array.isArray(v) || v instanceof Error) return false
+  return Object.getPrototypeOf(v) === Object.prototype || Object.getPrototypeOf(v) === null
+}
+
+function emit(level: Level, args: unknown[]): void {
+  if (LEVELS[level] < threshold()) return
+  const payload: Record<string, unknown> = { t: new Date().toISOString(), level }
+  if (args.length === 0) {
+    payload.msg = ""
+  } else if (args.length === 1 && args[0] instanceof Error) {
+    payload.msg = "error"
+    payload.err = encode(args[0])
+  } else {
+    const last = args[args.length - 1]
+    if (args.length >= 2 && typeof args[0] === "string" && isPlainObject(last)) {
+      const fields = args.pop() as Record<string, unknown>
+      payload.msg = args.length === 1 ? (args[0] as string) : format(...args)
+      for (const [k, v] of Object.entries(fields)) {
+        if (v !== undefined) payload[k] = encode(v)
+      }
+    } else {
+      payload.msg = format(...args)
+    }
+  }
+  const line = JSON.stringify(payload)
+  if (level === "error" || level === "warn") process.stderr.write(line + "\n")
+  else process.stdout.write(line + "\n")
+}
+
+export const log = {
+  debug: (...args: unknown[]) => emit("debug", args),
+  info: (...args: unknown[]) => emit("info", args),
+  warn: (...args: unknown[]) => emit("warn", args),
+  error: (...args: unknown[]) => emit("error", args),
+}
+
+export const startTime = Date.now()
+
+export function uptimeSeconds(): number {
+  return Math.floor((Date.now() - startTime) / 1000)
+}
+
+const VERSION = "0.1.0"
+export function version(): string {
+  return VERSION
+}