autonomous-flow-daemon 1.6.0 → 1.9.0

package/src/commands/sync.ts

@@ -1,8 +1,10 @@
 import { readFileSync, writeFileSync, existsSync, mkdirSync } from "fs";
 import { resolve, join } from "path";
-import { daemonRequest } from "../daemon/client";
+import { daemonRequest, getMeshPeers } from "../daemon/client";
 import { AFD_DIR } from "../constants";
 import { getSystemLanguage } from "../core/locale";
+import { resolveScope } from "../core/federation";
+import type { FederatedAntibody, FederatedPayload } from "../core/federation";
 
 interface SyncResponse {
   status: string;
@@ -10,26 +12,15 @@ interface SyncResponse {
   count: number;
 }
 
-interface VaccinePayload {
-  version: string;
-  generatedAt: string;
-  ecosystem: string;
-  antibodyCount: number;
-  antibodies: VaccineAntibody[];
-}
-
-interface VaccineAntibody {
-  id: string;
-  patternType: string;
-  fileTarget: string;
-  patches: { op: string; path: string; value?: string }[];
-  learnedAt: string;
-}
+// Re-export federated types under legacy names for local push/pull compatibility
+type VaccinePayload = FederatedPayload;
+type VaccineAntibody = FederatedAntibody;
 
 interface SyncOptions {
   push?: boolean;
   pull?: boolean;
   remote?: string;
+  localMesh?: boolean;
 }
 
 const msgs = {
@@ -53,6 +44,17 @@ const msgs = {
     pullHint: "Run `afd sync --push` first to create the shared store.",
     learnedVia: "Learned via pull",
     ready: "antibody(ies) ready for global federation.",
+    // Remote
+    remotePushTitle: "afd sync --push --remote",
+    remotePushSuccess: "Pushed to remote vaccine store",
+    remotePullTitle: "afd sync --pull --remote",
+    remotePullSuccess: "Pulled from remote vaccine store",
+    remoteSyncTitle: "afd sync --remote (bidirectional)",
+    remoteInvalidUrl: "Invalid URL. Must start with http:// or https://",
+    remoteTimeout: "Request timed out (10s)",
+    remoteNetworkError: "Network error",
+    remoteInvalidResponse: "Invalid response payload from remote",
+    remoteStatusError: "Remote returned error status",
   },
   ko: {
     title: "afd sync — 백신 네트워크",
@@ -74,6 +76,17 @@ const msgs = {
     pullHint: "`afd sync --push`를 먼저 실행하여 공유 저장소를 생성하세요.",
     learnedVia: "풀로 학습됨",
     ready: "개 항체가 글로벌 페더레이션 준비 완료.",
+    // 원격
+    remotePushTitle: "afd sync --push --remote",
+    remotePushSuccess: "원격 백신 저장소에 푸시 완료",
+    remotePullTitle: "afd sync --pull --remote",
+    remotePullSuccess: "원격 백신 저장소에서 풀 완료",
+    remoteSyncTitle: "afd sync --remote (양방향 동기화)",
+    remoteInvalidUrl: "올바르지 않은 URL입니다. http:// 또는 https://로 시작해야 합니다.",
+    remoteTimeout: "요청 시간 초과 (10초)",
+    remoteNetworkError: "네트워크 오류",
+    remoteInvalidResponse: "원격 서버의 응답 페이로드가 올바르지 않습니다.",
+    remoteStatusError: "원격 서버가 오류 상태를 반환했습니다.",
   },
 };
 
@@ -84,6 +97,27 @@ export async function syncCommand(opts: SyncOptions = {}) {
   const lang = getSystemLanguage();
   const m = msgs[lang];
 
+  if (opts.localMesh) {
+    await syncLocalMesh(m);
+    return;
+  }
+
+  if (opts.remote) {
+    const url = validateRemoteUrl(opts.remote, m);
+    if (!url) return;
+
+    if (opts.push && !opts.pull) {
+      await syncRemotePush(url, m);
+    } else if (opts.pull && !opts.push) {
+      await syncRemotePull(url, m);
+    } else {
+      // --remote alone (or both flags): bidirectional — pull first, then push
+      await syncRemotePull(url, m);
+      await syncRemotePush(url, m);
+    }
+    return;
+  }
+
   if (opts.push) {
     await syncPush(m);
     return;
@@ -98,6 +132,285 @@ export async function syncCommand(opts: SyncOptions = {}) {
   await syncExport(m);
 }
 
+// ─── Local mesh sync ─────────────────────────────────────────────────────────
+
+/**
+ * Bidirectional antibody sync across all live mesh peers (monorepo daemons).
+ * For each peer:
+ *   1. Pull their antibodies → POST to our /antibodies/learn
+ *   2. Push our antibodies  → POST to their /antibodies/learn
+ * Conflict arbitration is handled by shouldAcceptRemote() on each daemon's side.
+ */
+async function syncLocalMesh(m: typeof msgs.en) {
+  const BOX = { tl: "┌", tr: "┐", bl: "└", br: "┘", h: "─", v: "│", ml: "├", mr: "┤" };
+  const W = 60;
+  const hline = (l: string, r: string) => `${l}${BOX.h.repeat(W)}${r}`;
+  const row = (s: string) => `${BOX.v} ${s}${" ".repeat(Math.max(0, W - 2 - s.length))} ${BOX.v}`;
+
+  let peers: Awaited<ReturnType<typeof getMeshPeers>>;
+  try {
+    peers = await getMeshPeers();
+  } catch {
+    console.error("[afd sync] Daemon not running. Start with `afd start`.");
+    process.exit(1);
+  }
+
+  console.log(hline(BOX.tl, BOX.tr));
+  console.log(row(`🔗 afd sync --local-mesh`));
+  console.log(hline(BOX.ml, BOX.mr));
+
+  if (peers.length === 0) {
+    console.log(row("No live mesh peers found. Start daemons in other workspaces."));
+    console.log(hline(BOX.bl, BOX.br));
+    return;
+  }
+
+  // Fetch our own antibodies once
+  const ours = (await daemonRequest<{ antibodies: AntibodyRow[] }>("/antibodies")).antibodies;
+
+  let totalPulled = 0;
+  let totalPushed = 0;
+
+  for (const peer of peers) {
+    const baseUrl = `http://127.0.0.1:${peer.port}`;
+    console.log(row(`Peer: ${peer.workspace} (port ${peer.port})`));
+
+    // 1. Pull from peer
+    try {
+      const theirData = await fetchJson<{ antibodies: AntibodyRow[] }>(`${baseUrl}/antibodies`);
+      for (const ab of theirData.antibodies) {
+        await daemonRequest<unknown>("/antibodies/learn", "POST", {
+          id: ab.id,
+          patternType: ab.pattern_type,
+          fileTarget: ab.file_target,
+          patches: JSON.parse(ab.patch_op),
+          scope: ab.scope ?? "local",
+          version: ab.ab_version ?? 1,
+          updatedAt: ab.updated_at,
+        });
+        totalPulled++;
+      }
+    } catch {
+      console.log(row(`  ⚠ Pull failed (peer may be busy)`));
+    }
+
+    // 2. Push to peer
+    try {
+      for (const ab of ours) {
+        await fetchJson<unknown>(`${baseUrl}/antibodies/learn`, {
+          method: "POST",
+          body: JSON.stringify({
+            id: ab.id,
+            patternType: ab.pattern_type,
+            fileTarget: ab.file_target,
+            patches: JSON.parse(ab.patch_op),
+            scope: ab.scope ?? "local",
+            version: ab.ab_version ?? 1,
+            updatedAt: ab.updated_at,
+          }),
+          headers: { "Content-Type": "application/json" },
+        });
+        totalPushed++;
+      }
+    } catch {
+      console.log(row(`  ⚠ Push failed (peer may be busy)`));
+    }
+  }
+
+  console.log(hline(BOX.ml, BOX.mr));
+  console.log(row(`✅ Synced ${peers.length} peer(s) — pulled ${totalPulled}, pushed ${totalPushed}`));
+  console.log(hline(BOX.bl, BOX.br));
+}
+
+interface AntibodyRow {
+  id: string;
+  pattern_type: string;
+  file_target: string;
+  patch_op: string;
+  scope: string;
+  ab_version: number;
+  updated_at: string;
+}
+
+async function fetchJson<T>(url: string, init?: RequestInit): Promise<T> {
+  const res = await fetch(url, init);
+  if (!res.ok) throw new Error(`HTTP ${res.status}`);
+  return res.json() as T;
+}
+
+// ─── Remote helpers ───────────────────────────────────────────────────────────
+
+const REMOTE_TIMEOUT_MS = 10_000;
+
+function validateRemoteUrl(raw: string, m: typeof msgs.en): string | null {
+  try {
+    const u = new URL(raw);
+    if (u.protocol !== "http:" && u.protocol !== "https:") throw new Error();
+    return u.toString();
+  } catch {
+    console.error(`[afd sync] ${m.remoteInvalidUrl}: ${raw}`);
+    return null;
+  }
+}
+
+async function syncRemotePush(url: string, m: typeof msgs.en) {
+  // 1. Export latest local payload via daemon
+  let result: SyncResponse;
+  try {
+    result = await daemonRequest<SyncResponse>("/sync");
+  } catch (err: unknown) {
+    const msg = err instanceof Error ? err.message : String(err);
+    console.error(`[afd sync] ${msg}`);
+    process.exit(1);
+  }
+
+  if (result.count === 0) {
+    console.log(`[afd sync] ${m.noAntibodies}`);
+    return;
+  }
+
+  const localPayloadPath = resolve(AFD_DIR, "global-vaccine-payload.json");
+  const rawPayload: VaccinePayload = JSON.parse(readFileSync(localPayloadPath, "utf-8"));
+
+  // Stamp publisher scope on all antibodies before sending
+  const publisherScope = resolveScope();
+  const now = new Date().toISOString();
+  const payload: VaccinePayload = {
+    ...rawPayload,
+    version: "1.7",
+    scope: publisherScope,
+    antibodies: rawPayload.antibodies.map(ab => ({
+      ...ab,
+      scope: publisherScope,
+      fqid: `${publisherScope}/${ab.id}`,
+      version: ab.version ?? 1,
+      updatedAt: ab.updatedAt ?? ab.learnedAt ?? now,
+    })),
+  };
+
+  // 2. POST to remote
+  let res: Response;
+  try {
+    res = await fetch(url, {
+      method: "POST",
+      headers: { "Content-Type": "application/json", "User-Agent": "afd-sync/1.7" },
+      body: JSON.stringify(payload),
+      signal: AbortSignal.timeout(REMOTE_TIMEOUT_MS),
+    });
+  } catch (err: unknown) {
+    const isTimeout = err instanceof Error && err.name === "TimeoutError";
+    console.error(`[afd sync] ${isTimeout ? m.remoteTimeout : m.remoteNetworkError}: ${url}`);
+    process.exit(1);
+  }
+
+  if (!res.ok) {
+    console.error(`[afd sync] ${m.remoteStatusError} ${res.status} ${res.statusText}`);
+    process.exit(1);
+  }
+
+  const BOX = { tl: "┌", tr: "┐", bl: "└", br: "┘", h: "─", v: "│", ml: "├", mr: "┤" };
+  const W = 50;
+  const line = (l: string, r: string) => `${l}${BOX.h.repeat(W)}${r}`;
+  const row = (s: string) => `${BOX.v}  ${s}${" ".repeat(Math.max(0, W - 2 - s.length))}${BOX.v}`;
+
+  console.log(line(BOX.tl, BOX.tr));
+  console.log(row(`📤 ${m.remotePushTitle}`));
+  console.log(line(BOX.ml, BOX.mr));
+  console.log(row(`${m.antibodies}: ${payload.antibodyCount}`));
+  console.log(row(`URL: ${url}`));
+  console.log(line(BOX.ml, BOX.mr));
+  console.log(row(`✅ ${m.remotePushSuccess}`));
+  console.log(line(BOX.bl, BOX.br));
+}
+
+async function syncRemotePull(url: string, m: typeof msgs.en) {
+  // 1. GET payload from remote
+  let res: Response;
+  try {
+    res = await fetch(url, {
+      method: "GET",
+      headers: { "Accept": "application/json", "User-Agent": "afd-sync/1.7" },
+      signal: AbortSignal.timeout(REMOTE_TIMEOUT_MS),
+    });
+  } catch (err: unknown) {
+    const isTimeout = err instanceof Error && err.name === "TimeoutError";
+    console.error(`[afd sync] ${isTimeout ? m.remoteTimeout : m.remoteNetworkError}: ${url}`);
+    process.exit(1);
+  }
+
+  if (!res.ok) {
+    console.error(`[afd sync] ${m.remoteStatusError} ${res.status} ${res.statusText}`);
+    process.exit(1);
+  }
+
+  let remotePayload: VaccinePayload;
+  try {
+    const json = await res.json();
+    if (!json || !Array.isArray(json.antibodies)) throw new Error("missing antibodies array");
+    remotePayload = json as VaccinePayload;
+  } catch {
+    console.error(`[afd sync] ${m.remoteInvalidResponse}`);
+    process.exit(1);
+  }
+
+  // 2. Learn each antibody into the running daemon (same as local pull)
+  let newCount = 0;
+  let skippedCount = 0;
+  const results: { id: string; status: string }[] = [];
+
+  for (const ab of remotePayload.antibodies) {
+    try {
+      const learnRes = await fetch(
+        `http://127.0.0.1:${getDaemonPort()}/antibodies/learn`,
+        {
+          method: "POST",
+          headers: { "Content-Type": "application/json" },
+          body: JSON.stringify({
+            id: ab.id,
+            scope: ab.scope ?? remotePayload.scope ?? "remote",
+            version: ab.version ?? 1,
+            updatedAt: ab.updatedAt ?? ab.learnedAt,
+            patternType: ab.patternType,
+            fileTarget: ab.fileTarget,
+            patches: ab.patches,
+          }),
+          signal: AbortSignal.timeout(2000),
+        }
+      );
+      if (learnRes.ok) {
+        results.push({ id: ab.id, status: m.pullNew });
+        newCount++;
+      } else {
+        results.push({ id: ab.id, status: m.pullSkipped });
+        skippedCount++;
+      }
+    } catch {
+      results.push({ id: ab.id, status: m.pullSkipped });
+      skippedCount++;
+    }
+  }
+
+  const BOX = { tl: "┌", tr: "┐", bl: "└", br: "┘", h: "─", v: "│", ml: "├", mr: "┤" };
+  const W = 50;
+  const line = (l: string, r: string) => `${l}${BOX.h.repeat(W)}${r}`;
+  const row = (s: string) => `${BOX.v}  ${s}${" ".repeat(Math.max(0, W - 2 - s.length))}${BOX.v}`;
+
+  console.log(line(BOX.tl, BOX.tr));
+  console.log(row(`📥 ${m.remotePullTitle}`));
+  console.log(line(BOX.ml, BOX.mr));
+  console.log(row(`URL: ${url}`));
+  console.log(line(BOX.ml, BOX.mr));
+
+  for (const r of results) {
+    const icon = r.status === m.pullNew ? "✅" : "⏭️";
+    console.log(row(`${icon} ${r.id}: ${r.status}`));
+  }
+
+  console.log(line(BOX.ml, BOX.mr));
+  console.log(row(`✅ ${m.remotePullSuccess}: ${newCount} ${m.pullMerged}, ${skippedCount} ${m.pullSkipped}`));
+  console.log(line(BOX.bl, BOX.br));
+}
+
 async function syncExport(m: typeof msgs.en) {
   let result: SyncResponse;
   try {

package/src/constants.ts

@@ -1,32 +1,32 @@
-import { join } from "path";
-import { findWorkspaceRoot } from "./core/workspace";
-
-// Relative paths (used when cwd is already the workspace root)
-export const AFD_DIR = ".afd";
-export const PID_FILE = join(AFD_DIR, "daemon.pid");
-export const PORT_FILE = join(AFD_DIR, "daemon.port");
-export const DB_FILE = join(AFD_DIR, "antibodies.sqlite");
-export const LOG_FILE = join(AFD_DIR, "daemon.log");
-export const QUARANTINE_DIR = join(AFD_DIR, "quarantine");
-export const WATCH_TARGETS = [
-  ".claude/", "CLAUDE.md", ".cursorrules", ".claudeignore", ".gitignore",
-  ".windsurfrules", ".windsurf/", "codex.md", ".codex/",
-  ".cursorignore", ".windsurfignore", ".codexignore",
-];
-
-/**
- * Resolve all `.afd/` paths against the workspace root.
- * Works correctly even when CLI is invoked from a subdirectory.
- */
-export function resolveWorkspacePaths(from?: string) {
-  const root = findWorkspaceRoot(from);
-  return {
-    root,
-    afdDir: join(root, AFD_DIR),
-    pidFile: join(root, PID_FILE),
-    portFile: join(root, PORT_FILE),
-    dbFile: join(root, DB_FILE),
-    logFile: join(root, LOG_FILE),
-    quarantineDir: join(root, QUARANTINE_DIR),
-  };
-}
+import { join } from "path";
+import { findWorkspaceRoot } from "./core/workspace";
+
+// Relative paths (used when cwd is already the workspace root)
+export const AFD_DIR = ".afd";
+export const PID_FILE = join(AFD_DIR, "daemon.pid");
+export const PORT_FILE = join(AFD_DIR, "daemon.port");
+export const DB_FILE = join(AFD_DIR, "antibodies.sqlite");
+export const LOG_FILE = join(AFD_DIR, "daemon.log");
+export const QUARANTINE_DIR = join(AFD_DIR, "quarantine");
+export const WATCH_TARGETS = [
+  ".claude/", "CLAUDE.md", ".cursorrules", ".claudeignore", ".gitignore",
+  ".windsurfrules", ".windsurf/", "codex.md", ".codex/",
+  ".cursorignore", ".windsurfignore", ".codexignore",
+];
+
+/**
+ * Resolve all `.afd/` paths against the workspace root.
+ * Works correctly even when CLI is invoked from a subdirectory.
+ */
+export function resolveWorkspacePaths(from?: string) {
+  const root = findWorkspaceRoot(from);
+  return {
+    root,
+    afdDir: join(root, AFD_DIR),
+    pidFile: join(root, PID_FILE),
+    portFile: join(root, PORT_FILE),
+    dbFile: join(root, DB_FILE),
+    logFile: join(root, LOG_FILE),
+    quarantineDir: join(root, QUARANTINE_DIR),
+  };
+}