ework-web 0.4.5 → 0.5.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ework-web",
-  "version": "0.4.5",
+  "version": "0.5.1",
   "type": "module",
   "description": "ework-web — standalone multi-project issue tracker. Local SQLite-backed, no external API dependency. Bun + TypeScript + SSR HTML.",
   "license": "MIT",

package/src/coordination.ts

@@ -0,0 +1,32 @@
+import { getDB } from "./db";
+import { log } from "./logger";
+
+export interface DaemonInfo {
+  id: number;
+  displayName: string;
+  endpoint: string;
+}
+
+const HEARTBEAT_STALE_MS = 120_000;
+
+export async function getActiveDaemons(): Promise<DaemonInfo[]> {
+  const stale = new Date(Date.now() - HEARTBEAT_STALE_MS);
+  const staleStr = stale.toISOString().slice(0, 19).replace("T", " ");
+  try {
+    const rows = await getDB().all<{ id: number; display_name: string; internal_endpoint: string }>(
+      `SELECT id, display_name, internal_endpoint FROM {{d_daemons}} WHERE status = 'active' AND last_heartbeat > ?`,
+      [staleStr],
+    );
+    return rows
+      .filter((r): r is { id: number; display_name: string; internal_endpoint: string } =>
+        r.internal_endpoint !== null && r.internal_endpoint !== undefined && r.internal_endpoint !== "")
+      .map((r) => ({
+        id: r.id,
+        displayName: r.display_name ?? `daemon-${r.id}`,
+        endpoint: r.internal_endpoint,
+      }));
+  } catch (e) {
+    log.info(`coordination: query failed (${e instanceof Error ? e.message : String(e)}) — assuming single-machine`);
+    return [];
+  }
+}

package/src/index.ts

@@ -6,10 +6,11 @@ import { homedir } from "os";
 import { loadConfig, DB_OVERRIDABLE, parseOverride, resolveTtsBackend } from "./config";
 import type { Config } from "./config";
 import { setConfig, initDB } from "./db";
+import { getActiveDaemons } from "./coordination";
 import { testMysqlConnection, migrateSqliteToMysql, writeMysqlEnv, migrateMysqlToSqlite, writeSqliteEnv, migrateDaemonSqliteToMysql } from "./db-admin";
 import type { MysqlTargetOpts } from "./db-admin";
 import { checkAuth, makeAuthCookieHeader, clearAuthCookieHeader, loginHTML, sanitizeNext, ensureBootstrapAdmin, ensureBootstrapSystem, isReservedSystemLogin } from "./auth";
-import { OpencodeClient, OpencodeError } from "./opencode";
+import { OpencodeError, createOpencodeClient, MultiDaemonOpencodeClient, RemoteOpencodeClient, isLocalhost, type OpencodeClientInterface } from "./opencode";
 import { renderMarkdown } from "./render/markdown";
 import { log, uptimeSeconds, version } from "./logger";
 import { buildIssueThread, fetchIssuePage, fetchIssueSince, errorPage } from "./views/issueThread";
@@ -95,7 +96,24 @@ const STATIC_DIR = join(__dirname, "static");
 
 await initDB();
 const cfg: Config = await loadConfig();
-const opencode = new OpencodeClient(cfg);
+let opencode: OpencodeClientInterface = createOpencodeClient(cfg, cfg.daemonWebhookUrl);
+
+async function refreshOpencodeClient(): Promise<void> {
+  const daemons = await getActiveDaemons();
+  const remote = daemons.filter((d) => !isLocalhost(d.endpoint));
+  if (remote.length > 1) {
+    opencode = new MultiDaemonOpencodeClient(remote.map((d) => d.endpoint));
+    log.info(`opencode client: multi-daemon (${remote.length} remotes)`);
+  } else if (remote.length === 1) {
+    opencode = new RemoteOpencodeClient(remote[0]!.endpoint);
+    log.info(`opencode client: single remote (${remote[0]!.endpoint})`);
+  } else {
+    opencode = createOpencodeClient(cfg, cfg.daemonWebhookUrl);
+  }
+}
+
+await refreshOpencodeClient();
+setInterval(refreshOpencodeClient, 10_000);
 
 async function autoWireDaemon(projectId: number, origin: string): Promise<void> {
   if (!cfg.autowireActive) {
@@ -252,8 +270,12 @@ function daemonEnvPath(): string | null {
 function readDaemonSqlitePath(envPath: string): string | null {
   try {
     const content = readFileSync(envPath, "utf8");
-    const m = content.match(/^DAEMON_DB_PATH\s*=\s*(.+)$/m);
-    return m?.[1]?.trim() ?? null;
+    const m = content.match(/^(?:WORK_DB_PATH|DAEMON_DB_PATH)\s*=\s*(.+)$/m);
+    if (m?.[1]) return m[1].trim();
+    // Neither key in .env — replicate the daemon's PRODUCTION_DB_DEFAULT
+    // (config.ts:61) so we can find its SQLite DB for migration.
+    const xdg = process.env.XDG_DATA_HOME ?? join(homedir(), ".local", "share");
+    return join(xdg, "ework-daemon", "ework-daemon.db");
   } catch {
     return null;
   }

package/src/opencode.ts

@@ -250,6 +250,118 @@ export class OpencodeClient {
   }
 }
 
+export interface OpencodeClientInterface {
+  listSessions(limit: number): Promise<SessionListItem[]>;
+  exportSession(id: string): Promise<SessionExport>;
+  exportSessionRaw(id: string): Promise<string>;
+  listModels(): Promise<string[]>;
+}
+
+export class RemoteOpencodeClient implements OpencodeClientInterface {
+  private readonly base: string;
+
+  constructor(endpoint: string) {
+    this.base = endpoint.replace(/\/$/, "");
+  }
+
+  async listSessions(limit: number): Promise<SessionListItem[]> {
+    const res = await fetch(`${this.base}/api/opencode/sessions?limit=${limit}`);
+    if (!res.ok) throw new OpencodeError(`remote listSessions → ${res.status}`, res.status);
+    return (await res.json()) as SessionListItem[];
+  }
+
+  async exportSession(id: string): Promise<SessionExport> {
+    if (!/^[A-Za-z0-9_-]+$/.test(id)) throw new OpencodeError(`bad session id: ${id}`, 400);
+    const res = await fetch(`${this.base}/api/opencode/sessions/${id}/export`);
+    if (!res.ok) throw new OpencodeError(`remote exportSession → ${res.status}`, res.status);
+    const raw = await res.json();
+    const exp = parseSessionExport(raw);
+    if (!exp) throw new OpencodeError(`malformed remote export for ${id}`, 502);
+    return exp;
+  }
+
+  async exportSessionRaw(id: string): Promise<string> {
+    if (!/^[A-Za-z0-9_-]+$/.test(id)) throw new OpencodeError(`bad session id: ${id}`, 400);
+    const res = await fetch(`${this.base}/api/opencode/sessions/${id}/raw`);
+    if (!res.ok) throw new OpencodeError(`remote exportSessionRaw → ${res.status}`, res.status);
+    const data = (await res.json()) as { raw?: string };
+    return data.raw ?? "";
+  }
+
+  async listModels(): Promise<string[]> {
+    return [];
+  }
+}
+
+export function isLocalhost(endpoint: string): boolean {
+  const host = endpoint.replace(/^https?:\/\//, "").split(":")[0] ?? "";
+  return /^(127\.|localhost$|0\.0\.0\.0$|::1$|\[::1\]$)/.test(host);
+}
+
+export class MultiDaemonOpencodeClient implements OpencodeClientInterface {
+  private readonly clients: RemoteOpencodeClient[];
+
+  constructor(endpoints: string[]) {
+    this.clients = endpoints.map((ep) => new RemoteOpencodeClient(ep));
+  }
+
+  async listSessions(limit: number): Promise<SessionListItem[]> {
+    const results = await Promise.allSettled(
+      this.clients.map((c) => c.listSessions(limit)),
+    );
+    const all: SessionListItem[] = [];
+    const seen = new Set<string>();
+    for (const r of results) {
+      if (r.status === "fulfilled") {
+        for (const s of r.value) {
+          if (s.id && !seen.has(s.id)) {
+            seen.add(s.id);
+            all.push(s);
+          }
+        }
+      }
+    }
+    all.sort((a, b) => b.updated - a.updated);
+    return all.slice(0, limit);
+  }
+
+  async exportSession(id: string): Promise<SessionExport> {
+    try {
+      return await Promise.any(this.clients.map((c) => c.exportSession(id)));
+    } catch {
+      throw new OpencodeError(`session ${id} not found on any daemon`, 404);
+    }
+  }
+
+  async exportSessionRaw(id: string): Promise<string> {
+    try {
+      return await Promise.any(this.clients.map((c) => c.exportSessionRaw(id)));
+    } catch {
+      throw new OpencodeError(`session ${id} not found on any daemon`, 404);
+    }
+  }
+
+  async listModels(): Promise<string[]> {
+    const results = await Promise.allSettled(
+      this.clients.map((c) => c.listModels()),
+    );
+    const models = new Set<string>();
+    for (const r of results) {
+      if (r.status === "fulfilled") {
+        for (const m of r.value) models.add(m);
+      }
+    }
+    return [...models];
+  }
+}
+
+export function createOpencodeClient(cfg: Config, daemonEndpoint?: string): OpencodeClientInterface {
+  if (daemonEndpoint && !isLocalhost(daemonEndpoint)) {
+    return new RemoteOpencodeClient(daemonEndpoint);
+  }
+  return new OpencodeClient(cfg);
+}
+
 async function readCapped(stream: ReadableStream<Uint8Array> | null, maxBytes: number): Promise<string> {
   if (!stream) return "";
   const reader = stream.getReader();

package/src/views/sessionLog.ts

@@ -1,4 +1,4 @@
-import type { OpencodeClient, SessionListItem, SessionExport, SessionMessage, MessagePart, ToolState } from "../opencode";
+import type { OpencodeClientInterface, SessionListItem, SessionExport, SessionMessage, MessagePart, ToolState } from "../opencode";
 import { THEME_CSS, escapeHtml, escapeAttr, tabNavHTML } from "../render/layout";
 import { renderMarkdown, linkifySessionIDs, linkifyAbsPaths } from "../render/markdown";
 import { BUILD_ID } from "../build";
@@ -8,7 +8,7 @@ import { homedir } from "os";
 
 const LIST_LIMIT = 100;
 
-export async function buildSessionList(client: OpencodeClient, q: string): Promise<{ html: string }> {
+export async function buildSessionList(client: OpencodeClientInterface, q: string): Promise<{ html: string }> {
   let sessions = await client.listSessions(LIST_LIMIT);
   const needle = q.trim().toLowerCase();
   if (needle) {
@@ -57,7 +57,7 @@ function sessionRow(s: SessionListItem): string {
 </a>`;
 }
 
-export async function buildSessionView(client: OpencodeClient, id: string, desc: boolean, collapseLines: number, limit = 30, all = false): Promise<{ html: string }> {
+export async function buildSessionView(client: OpencodeClientInterface, id: string, desc: boolean, collapseLines: number, limit = 30, all = false): Promise<{ html: string }> {
   const data = await client.exportSession(id);
   const info = data.info;
   const title = info.title || id;