@adriandmitroca/relay 0.0.2

package/src/api/middleware.ts

@@ -0,0 +1,14 @@
+import { cors } from "hono/cors";
+
+export const corsMiddleware = cors({
+  origin: (origin) => {
+    if (!origin) return origin;
+    try {
+      const url = new URL(origin);
+      if (url.hostname === "localhost" || url.hostname === "127.0.0.1") return origin;
+    } catch {}
+    return null;
+  },
+  allowMethods: ["GET", "POST", "PUT", "DELETE", "OPTIONS"],
+  allowHeaders: ["Content-Type"],
+});

package/src/api/router.ts

@@ -0,0 +1,31 @@
+import { Hono } from "hono";
+import { corsMiddleware } from "./middleware.ts";
+import { createIssueRoutes } from "./issues.ts";
+import { createConfigRoutes } from "./config.ts";
+import type { IssueDB, IssueRow, ConfigDB } from "../db.ts";
+import type { CallbackData } from "../constants.ts";
+
+type ActionHandler = (data: CallbackData) => Promise<{ ok: boolean; error?: string; issue?: IssueRow }>;
+type StatusProvider = () => Array<{ workspace: string; telegram: boolean; sources: string[] }>;
+
+export interface RouterDeps {
+  getDB: () => IssueDB;
+  getConfigDB: () => ConfigDB;
+  getActionHandler: () => ActionHandler | null;
+  getStatusProvider: () => StatusProvider | null;
+  onConfigChange: () => void;
+}
+
+export function createRouter(deps: RouterDeps): Hono {
+  const app = new Hono();
+
+  app.use("*", corsMiddleware);
+
+  const issueRoutes = createIssueRoutes(deps.getDB, deps.getActionHandler, deps.getStatusProvider);
+  const configRoutes = createConfigRoutes(deps.getConfigDB, deps.onConfigChange);
+
+  app.route("/", issueRoutes);
+  app.route("/", configRoutes);
+
+  return app;
+}

package/src/cli.ts

@@ -0,0 +1,184 @@
+#!/usr/bin/env bun
+
+import { Daemon } from "./daemon.ts";
+import { setLogLevel } from "./utils/logger.ts";
+import { join, dirname } from "node:path";
+import { unlinkSync } from "node:fs";
+import pkg from "../package.json" with { type: "json" };
+
+const VERSION = pkg.version;
+const NPM_PACKAGE = pkg.name; // "@adriandmitroca/relay"
+const BOLD = "\x1b[1m";
+const RESET = "\x1b[0m";
+const GREEN = "\x1b[32m";
+const YELLOW = "\x1b[33m";
+const RED = "\x1b[31m";
+const DIM = "\x1b[2m";
+
+function getFlag(name: string): string | undefined {
+  const idx = process.argv.indexOf(`--${name}`);
+  if (idx !== -1 && process.argv[idx + 1]) return process.argv[idx + 1]!;
+  return undefined;
+}
+
+function resolveConfigPath(): string {
+  return getFlag("config") ?? join(process.cwd(), "config.json");
+}
+
+function getCommand(): string {
+  const args = process.argv.slice(2).filter((a) => !a.startsWith("--"));
+  return args[0] ?? "help";
+}
+
+async function fetchLatestVersion(): Promise<string | null> {
+  try {
+    const res = await fetch(`https://registry.npmjs.org/${NPM_PACKAGE}/latest`, {
+      signal: AbortSignal.timeout(3000),
+    });
+    if (!res.ok) return null;
+    const data = await res.json() as { version: string };
+    return data.version ?? null;
+  } catch {
+    return null;
+  }
+}
+
+/** Silently check for updates and print a one-liner if a newer version is available. */
+async function checkForUpdates() {
+  const latest = await fetchLatestVersion();
+  if (latest && latest !== VERSION) {
+    console.log(`${DIM}relay v${latest} is available (you have v${VERSION}). Run: relay update${RESET}`);
+  }
+}
+
+async function cmdStart() {
+  const configPath = resolveConfigPath();
+  const pidFile = join(process.cwd(), "relay.pid");
+  const logLevel = getFlag("log-level");
+  if (logLevel) setLogLevel(logLevel as "debug" | "info" | "warn" | "error");
+
+  // Check for existing instance
+  const pid = Bun.file(pidFile);
+  if (await pid.exists()) {
+    const existingPid = (await pid.text()).trim();
+    const check = await Bun.$`kill -0 ${existingPid}`.quiet().nothrow();
+    if (check.exitCode === 0) {
+      console.error(`${RED}Daemon already running (PID ${existingPid}). Use 'relay stop' first.${RESET}`);
+      process.exit(1);
+    }
+  }
+
+  // Write PID
+  await Bun.write(pidFile, String(process.pid));
+
+  // Silent update check in background
+  checkForUpdates().catch(() => {});
+
+  const daemon = new Daemon(configPath);
+
+  const cleanup = () => {
+    try { unlinkSync(pidFile); } catch {}
+  };
+  process.on("exit", cleanup);
+
+  try {
+    await daemon.start();
+  } catch (err) {
+    console.error(`${RED}Failed to start: ${err}${RESET}`);
+    cleanup();
+    process.exit(1);
+  }
+}
+
+async function cmdStop() {
+  const pidFile = join(process.cwd(), "relay.pid");
+  const pid = Bun.file(pidFile);
+  if (!(await pid.exists())) {
+    console.log(`${YELLOW}No running daemon found.${RESET}`);
+    return;
+  }
+
+  const existingPid = (await pid.text()).trim();
+  const result = await Bun.$`kill ${existingPid}`.quiet().nothrow();
+  if (result.exitCode === 0) {
+    console.log(`${GREEN}Sent stop signal to daemon (PID ${existingPid}).${RESET}`);
+  } else {
+    console.log(`${YELLOW}Daemon not running. Cleaning up PID file.${RESET}`);
+  }
+  await Bun.$`rm -f ${pidFile}`.quiet().nothrow();
+}
+
+async function cmdUpdate() {
+  console.log(`Checking for updates...`);
+
+  const latest = await fetchLatestVersion();
+  if (!latest) {
+    console.error(`${RED}Could not reach npm registry. Check your connection.${RESET}`);
+    process.exit(1);
+  }
+
+  if (latest === VERSION) {
+    console.log(`${GREEN}Already on latest (v${VERSION}).${RESET}`);
+    return;
+  }
+
+  console.log(`Updating v${VERSION} → v${latest}...`);
+
+  // Try bun first (native for this tool), fall back to npm
+  const bunCheck = await Bun.$`which bun`.quiet().nothrow();
+  const installCmd = bunCheck.exitCode === 0
+    ? `bun install -g ${NPM_PACKAGE}@latest`
+    : `npm install -g ${NPM_PACKAGE}@latest`;
+
+  const result = await Bun.$`sh -c ${installCmd}`.nothrow();
+  if (result.exitCode === 0) {
+    console.log(`${GREEN}Updated to v${latest}. Restart relay for changes to take effect.${RESET}`);
+  } else {
+    console.error(`${RED}Update failed. Run manually: ${installCmd}${RESET}`);
+    process.exit(1);
+  }
+}
+
+function showHelp() {
+  console.log(`
+${BOLD}Relay${RESET} v${VERSION} — Autonomous SWE agent
+
+${BOLD}Usage:${RESET}
+  relay start     Start the daemon (opens dashboard at localhost:7842)
+  relay stop      Stop the daemon
+  relay update    Update to the latest version
+  relay version   Show version
+  relay help      Show this help
+
+${BOLD}Options:${RESET}
+  --config <path>        Path to config.json (default: ./config.json)
+  --log-level <level>    Override log level (debug/info/warn/error)
+
+${BOLD}Getting started:${RESET}
+  bunx relayd             Try without installing
+  bun install -g relayd   Install globally
+  relay start             Start — configure via the setup wizard at localhost:7842
+`);
+}
+
+// --- Main ---
+const cmd = getCommand();
+
+switch (cmd) {
+  case "start":
+    await cmdStart();
+    break;
+  case "stop":
+    await cmdStop();
+    break;
+  case "update":
+    await cmdUpdate();
+    break;
+  case "version":
+    console.log(`relay v${VERSION}`);
+    break;
+  case "help":
+  default:
+    showHelp();
+    break;
+}

package/src/config.ts

@@ -0,0 +1,195 @@
+import { logger } from "./utils/logger.ts";
+
+export interface SentrySourceConfig {
+  authToken: string;
+  org: string;
+  project: string;
+}
+
+export interface AsanaSourceConfig {
+  accessToken: string;
+  projectGid: string;
+  severityFieldGid?: string;
+}
+
+export interface LinearSourceConfig {
+  apiKey: string;
+  teamId: string;
+  projectId?: string;
+  statusFilter?: string[];
+  assigneeFilter?: string;
+  labelFilter?: string[];
+  priorityFilter?: number[];
+  onAcceptTransition?: boolean;
+}
+
+export interface JiraSourceConfig {
+  host: string;
+  email: string;
+  apiToken: string;
+  projectKey: string;
+  filterMode: "simple" | "jql";
+  statusFilter?: string[];
+  assigneeFilter?: string;
+  issueTypeFilter?: string[];
+  priorityFilter?: string[];
+  labelFilter?: string[];
+  jql?: string;
+  onAcceptTransition?: string;
+}
+
+export interface ProjectConfig {
+  key: string;
+  repoPath: string;
+  baseBranch: string;
+  testCommand?: string;
+  sources: {
+    sentry?: SentrySourceConfig;
+    asana?: AsanaSourceConfig;
+    linear?: LinearSourceConfig;
+    jira?: JiraSourceConfig;
+  };
+}
+
+export interface WorkspaceConfig {
+  key: string;
+  telegram?: { botToken: string; chatId: string };
+  projects: ProjectConfig[];
+}
+
+export interface Config {
+  workspaces: WorkspaceConfig[];
+  pollIntervalSeconds: number;
+  maxConcurrency: number;
+  claudeTimeout: number;
+  triageTimeout: number;
+  triage: boolean;
+  logLevel: "debug" | "info" | "warn" | "error";
+  allowedTools: string[];
+}
+
+const DEFAULTS = {
+  pollIntervalSeconds: 300,
+  maxConcurrency: 2,
+  claudeTimeout: 300_000,
+  triageTimeout: 120_000,
+  triage: true,
+  logLevel: "info" as const,
+  allowedTools: ["Read", "Write", "Edit", "Bash", "Glob", "Grep"],
+};
+
+export async function loadConfig(configPath: string): Promise<Config> {
+  const file = Bun.file(configPath);
+  if (!(await file.exists())) {
+    throw new Error(`Config not found at ${configPath}. Run 'relay init' to create one.`);
+  }
+
+  let raw: Record<string, unknown>;
+  try {
+    raw = await file.json();
+  } catch {
+    throw new Error(`Config at ${configPath} is not valid JSON. Check for syntax errors.`);
+  }
+
+  const config: Config = {
+    workspaces: (raw.workspaces as WorkspaceConfig[]) ?? [],
+    pollIntervalSeconds: (raw.pollIntervalSeconds as number) ?? DEFAULTS.pollIntervalSeconds,
+    maxConcurrency: (raw.maxConcurrency as number) ?? DEFAULTS.maxConcurrency,
+    claudeTimeout: (raw.claudeTimeout as number) ?? DEFAULTS.claudeTimeout,
+    triageTimeout: (raw.triageTimeout as number) ?? DEFAULTS.triageTimeout,
+    triage: (raw.triage as boolean) ?? DEFAULTS.triage,
+    logLevel: (raw.logLevel as Config["logLevel"]) ?? DEFAULTS.logLevel,
+    allowedTools: (raw.allowedTools as string[]) ?? DEFAULTS.allowedTools,
+  };
+
+  validate(config);
+  return config;
+}
+
+export function findProjectConfig(config: Config, projectKey: string): { workspace: WorkspaceConfig; project: ProjectConfig } | null {
+  for (const ws of config.workspaces) {
+    const project = ws.projects.find((p) => p.key === projectKey);
+    if (project) return { workspace: ws, project };
+  }
+  return null;
+}
+
+export function allProjects(config: Config): Array<{ workspace: WorkspaceConfig; project: ProjectConfig }> {
+  const result: Array<{ workspace: WorkspaceConfig; project: ProjectConfig }> = [];
+  for (const ws of config.workspaces) {
+    for (const p of ws.projects) {
+      result.push({ workspace: ws, project: p });
+    }
+  }
+  return result;
+}
+
+function validate(config: Config) {
+  if (!config.workspaces.length) {
+    throw new Error("Config: 'workspaces' must contain at least one workspace.");
+  }
+
+  const wsKeys = new Set<string>();
+  const projectKeys = new Set<string>();
+
+  for (const ws of config.workspaces) {
+    if (!ws.key) throw new Error("Config: each workspace must have a 'key'.");
+    if (wsKeys.has(ws.key)) throw new Error(`Config: duplicate workspace key '${ws.key}'.`);
+    wsKeys.add(ws.key);
+
+    if (ws.telegram) {
+      if (!ws.telegram.botToken) {
+        throw new Error(`Config: workspace '${ws.key}' telegram config must have 'botToken'.`);
+      }
+      if (!ws.telegram.chatId) {
+        throw new Error(`Config: workspace '${ws.key}' telegram config must have 'chatId'.`);
+      }
+    } else {
+      logger.info("Workspace has no Telegram config — web dashboard only", { workspace: ws.key });
+    }
+
+    if (!ws.projects.length) {
+      throw new Error(`Config: workspace '${ws.key}' must have at least one project.`);
+    }
+
+    for (const p of ws.projects) {
+      if (!p.key) throw new Error(`Config: each project must have a 'key'.`);
+      if (!p.repoPath) throw new Error(`Config: project '${p.key}' must have a 'repoPath'.`);
+      if (!p.baseBranch) throw new Error(`Config: project '${p.key}' must have a 'baseBranch'.`);
+      if (projectKeys.has(p.key)) throw new Error(`Config: duplicate project key '${p.key}'.`);
+      projectKeys.add(p.key);
+
+      if (!p.sources) {
+        p.sources = {};
+      }
+      if (p.sources.sentry) {
+        if (!p.sources.sentry.authToken) throw new Error(`Config: project '${p.key}' sentry source needs 'authToken'.`);
+        if (!p.sources.sentry.org || !p.sources.sentry.project) throw new Error(`Config: project '${p.key}' sentry source needs 'org' and 'project'.`);
+      }
+      if (p.sources.asana) {
+        if (!p.sources.asana.accessToken) throw new Error(`Config: project '${p.key}' asana source needs 'accessToken'.`);
+        if (!p.sources.asana.projectGid) throw new Error(`Config: project '${p.key}' asana source needs 'projectGid'.`);
+      }
+      if (p.sources.linear) {
+        if (!p.sources.linear.apiKey) throw new Error(`Config: project '${p.key}' linear source needs 'apiKey'.`);
+        if (!p.sources.linear.teamId) throw new Error(`Config: project '${p.key}' linear source needs 'teamId'.`);
+      }
+      if (p.sources.jira) {
+        if (!p.sources.jira.host) throw new Error(`Config: project '${p.key}' jira source needs 'host'.`);
+        if (!p.sources.jira.email) throw new Error(`Config: project '${p.key}' jira source needs 'email'.`);
+        if (!p.sources.jira.apiToken) throw new Error(`Config: project '${p.key}' jira source needs 'apiToken'.`);
+        if (!p.sources.jira.projectKey) throw new Error(`Config: project '${p.key}' jira source needs 'projectKey'.`);
+      }
+    }
+  }
+
+  if (config.pollIntervalSeconds <= 0) {
+    throw new Error("Config: 'pollIntervalSeconds' must be positive.");
+  }
+  if (config.maxConcurrency <= 0) {
+    throw new Error("Config: 'maxConcurrency' must be positive.");
+  }
+
+  const totalProjects = config.workspaces.reduce((n, ws) => n + ws.projects.length, 0);
+  logger.debug("Config loaded and validated", { workspaces: config.workspaces.length, projects: totalProjects });
+}

package/src/constants.ts

@@ -0,0 +1,21 @@
+export const FAILURE_HINTS: Record<string, string> = {
+  "triage:timeout": "Triage timed out. Try increasing triageTimeout in config.",
+  "triage:claude_failed": "Triage failed — Claude returned an unexpected response.",
+  "fix:timeout": "Task timed out. The issue may be too complex. Try a smaller scope or increase claudeTimeout.",
+  "fix:no_changes": "Claude finished but made no file changes. Add more context to the issue description and retry.",
+  "fix:tests_failed": "Changes were made but tests failed. Review the diff and retry.",
+  "fix:commit_failed": "Auto-commit failed. Check repo permissions and git config.",
+  "fix:claude_failed": "Claude exited with an error during implementation.",
+  "worktree:create_failed": "Failed to create a git worktree. Check repoPath and disk space.",
+  "accept:push_failed": "Branch push failed. Check remote permissions and run gh auth status.",
+  "accept:pr_failed": "Branch pushed but PR creation failed. Run gh auth status.",
+  "pipeline:unexpected": "An unexpected error occurred. Check relay logs for details.",
+};
+
+export type CallbackAction = "accept" | "discard" | "skip" | "fix" | "retry";
+
+export interface CallbackData {
+  action: CallbackAction;
+  source: string;
+  sourceId: string;
+}