autonomous-flow-daemon 1.6.0 → 1.9.0

package/src/daemon/client.ts

@@ -1,65 +1,78 @@
-import { readFileSync, existsSync, unlinkSync } from "fs";
-import { resolveWorkspacePaths } from "../constants";
-
-export interface DaemonInfo {
-  pid: number;
-  port: number;
-  workspace: string;
-}
-
-/**
- * Read daemon PID/port from the workspace-local `.afd/` directory.
- * Walks up from cwd to find the workspace root, so CLI commands
- * work correctly even when invoked from subdirectories.
- *
- * If PID file exists but process is dead, cleans up stale files.
- */
-export function getDaemonInfo(): DaemonInfo | null {
-  const paths = resolveWorkspacePaths();
-  if (!existsSync(paths.pidFile) || !existsSync(paths.portFile)) return null;
-
-  const pid = parseInt(readFileSync(paths.pidFile, "utf-8").trim(), 10);
-  const port = parseInt(readFileSync(paths.portFile, "utf-8").trim(), 10);
-  if (isNaN(pid) || isNaN(port)) return null;
-
-  // Stale PID detection: check if process is alive at OS level
-  if (!isProcessAlive(pid)) {
-    try { unlinkSync(paths.pidFile); } catch {}
-    try { unlinkSync(paths.portFile); } catch {}
-    return null;
-  }
-
-  return { pid, port, workspace: paths.root };
-}
-
-/** Check if a process exists at OS level (does not verify it's afd) */
-function isProcessAlive(pid: number): boolean {
-  try {
-    process.kill(pid, 0); // signal 0 = existence check
-    return true;
-  } catch {
-    return false;
-  }
-}
-
-export async function isDaemonAlive(info: DaemonInfo): Promise<boolean> {
-  try {
-    const res = await fetch(`http://127.0.0.1:${info.port}/health`, {
-      signal: AbortSignal.timeout(2000),
-    });
-    const data = await res.json() as { status: string; pid: number };
-    return data.status === "alive" && data.pid === info.pid;
-  } catch {
-    return false;
-  }
-}
-
-export async function daemonRequest<T = unknown>(path: string): Promise<T> {
-  const info = getDaemonInfo();
-  if (!info) throw new Error("Daemon not running. Run `afd start` first.");
-  const res = await fetch(`http://127.0.0.1:${info.port}${path}`, {
-    signal: AbortSignal.timeout(5000),
-  });
-  if (!res.ok) throw new Error(`Daemon returned ${res.status}`);
-  return res.json() as T;
-}
+import { readFileSync, existsSync, unlinkSync } from "fs";
+import { resolveWorkspacePaths } from "../constants";
+import type { MeshEntry } from "./mesh";
+
+export interface DaemonInfo {
+  pid: number;
+  port: number;
+  workspace: string;
+}
+
+/**
+ * Read daemon PID/port from the workspace-local `.afd/` directory.
+ * Walks up from cwd to find the workspace root, so CLI commands
+ * work correctly even when invoked from subdirectories.
+ *
+ * If PID file exists but process is dead, cleans up stale files.
+ */
+export function getDaemonInfo(): DaemonInfo | null {
+  const paths = resolveWorkspacePaths();
+  if (!existsSync(paths.pidFile) || !existsSync(paths.portFile)) return null;
+
+  const pid = parseInt(readFileSync(paths.pidFile, "utf-8").trim(), 10);
+  const port = parseInt(readFileSync(paths.portFile, "utf-8").trim(), 10);
+  if (isNaN(pid) || isNaN(port)) return null;
+
+  // Stale PID detection: check if process is alive at OS level
+  if (!isProcessAlive(pid)) {
+    try { unlinkSync(paths.pidFile); } catch {}
+    try { unlinkSync(paths.portFile); } catch {}
+    return null;
+  }
+
+  return { pid, port, workspace: paths.root };
+}
+
+/** Check if a process exists at OS level (does not verify it's afd) */
+function isProcessAlive(pid: number): boolean {
+  try {
+    process.kill(pid, 0); // signal 0 = existence check
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+export async function isDaemonAlive(info: DaemonInfo): Promise<boolean> {
+  try {
+    const res = await fetch(`http://127.0.0.1:${info.port}/health`, {
+      signal: AbortSignal.timeout(2000),
+    });
+    const data = await res.json() as { status: string; pid: number };
+    return data.status === "alive" && data.pid === info.pid;
+  } catch {
+    return false;
+  }
+}
+
+export async function daemonRequest<T = unknown>(path: string, method?: "GET"): Promise<T>;
+export async function daemonRequest<T = unknown>(path: string, method: "POST", body: unknown): Promise<T>;
+export async function daemonRequest<T = unknown>(path: string, method: "GET" | "POST" = "GET", body?: unknown): Promise<T> {
+  const info = getDaemonInfo();
+  if (!info) throw new Error("Daemon not running. Run `afd start` first.");
+  const init: RequestInit = {
+    method,
+    signal: AbortSignal.timeout(5000),
+  };
+  if (method === "POST" && body !== undefined) {
+    init.body = JSON.stringify(body);
+    init.headers = { "Content-Type": "application/json" };
+  }
+  const res = await fetch(`http://127.0.0.1:${info.port}${path}`, init);
+  if (!res.ok) throw new Error(`Daemon returned ${res.status}`);
+  return res.json() as T;
+}
+
+export async function getMeshPeers(): Promise<MeshEntry[]> {
+  return daemonRequest<MeshEntry[]>("/mesh/peers");
+}

package/src/daemon/event-batcher.ts

@@ -1,108 +1,108 @@
-/**
- * EventBatcher — Adaptive debounce for file watcher events.
- *
- * Strategy:
- * - Immune file changes → fast-path (immediate, no debounce)
- * - All other events → 300ms debounce batch
- * - Deduplicates: same file multiple events → last event wins
- * - Cancels out: add + unlink on same file → removed from batch
- */
-
-export interface BatchedEvent {
-  event: string;
-  path: string;
-  timestamp: number;
-}
-
-export interface EventBatcherOptions {
-  /** Debounce window in ms (default: 300) */
-  debounceMs?: number;
-  /** Check if a path is an immune-protected file (fast-path) */
-  isImmunePath?: (path: string) => boolean;
-  /** Handler for fast-path (immediate) events */
-  onImmediate: (event: string, path: string) => void;
-  /** Handler for batched events (fired after debounce window) */
-  onBatch: (events: BatchedEvent[]) => void;
-}
-
-export class EventBatcher {
-  private readonly debounceMs: number;
-  private readonly isImmunePath: (path: string) => boolean;
-  private readonly onImmediate: (event: string, path: string) => void;
-  private readonly onBatch: (events: BatchedEvent[]) => void;
-
-  private pendingEvents = new Map<string, BatchedEvent>();
-  private timer: ReturnType<typeof setTimeout> | null = null;
-  private batchCount = 0;
-
-  constructor(options: EventBatcherOptions) {
-    this.debounceMs = options.debounceMs ?? 300;
-    this.isImmunePath = options.isImmunePath ?? (() => false);
-    this.onImmediate = options.onImmediate;
-    this.onBatch = options.onBatch;
-  }
-
-  /** Push a new file event. Returns true if handled immediately (fast-path). */
-  push(event: string, path: string): boolean {
-    // Fast-path: immune file change → immediate processing for auto-heal responsiveness
-    if (event === "change" && this.isImmunePath(path)) {
-      this.onImmediate(event, path);
-      return true;
-    }
-
-    const now = Date.now();
-    const existing = this.pendingEvents.get(path);
-
-    // Cancel out: add + unlink on same file
-    if (existing) {
-      if ((existing.event === "add" && event === "unlink") ||
-          (existing.event === "unlink" && event === "add")) {
-        this.pendingEvents.delete(path);
-        return false;
-      }
-    }
-
-    // Last event wins for same file
-    this.pendingEvents.set(path, { event, path, timestamp: now });
-
-    // Start/reset debounce timer
-    if (this.timer) clearTimeout(this.timer);
-    this.timer = setTimeout(() => this.flush(), this.debounceMs);
-
-    return false;
-  }
-
-  /** Flush all pending events immediately */
-  flush(): void {
-    if (this.timer) {
-      clearTimeout(this.timer);
-      this.timer = null;
-    }
-
-    if (this.pendingEvents.size === 0) return;
-
-    const events = [...this.pendingEvents.values()];
-    this.pendingEvents.clear();
-    this.batchCount++;
-    this.onBatch(events);
-  }
-
-  /** Get the number of batches processed */
-  get totalBatches(): number {
-    return this.batchCount;
-  }
-
-  /** Get the number of pending events */
-  get pendingCount(): number {
-    return this.pendingEvents.size;
-  }
-
-  /** Destroy the batcher, clearing any pending timers */
-  destroy(): void {
-    if (this.timer) {
-      clearTimeout(this.timer);
-      this.timer = null;
-    }
-    this.pendingEvents.clear();
-  }
-}
+/**
+ * EventBatcher — Adaptive debounce for file watcher events.
+ *
+ * Strategy:
+ * - Immune file changes → fast-path (immediate, no debounce)
+ * - All other events → 300ms debounce batch
+ * - Deduplicates: same file multiple events → last event wins
+ * - Cancels out: add + unlink on same file → removed from batch
+ */
+
+export interface BatchedEvent {
+  event: string;
+  path: string;
+  timestamp: number;
+}
+
+export interface EventBatcherOptions {
+  /** Debounce window in ms (default: 300) */
+  debounceMs?: number;
+  /** Check if a path is an immune-protected file (fast-path) */
+  isImmunePath?: (path: string) => boolean;
+  /** Handler for fast-path (immediate) events */
+  onImmediate: (event: string, path: string) => void;
+  /** Handler for batched events (fired after debounce window) */
+  onBatch: (events: BatchedEvent[]) => void;
+}
+
+export class EventBatcher {
+  private readonly debounceMs: number;
+  private readonly isImmunePath: (path: string) => boolean;
+  private readonly onImmediate: (event: string, path: string) => void;
+  private readonly onBatch: (events: BatchedEvent[]) => void;
+
+  private pendingEvents = new Map<string, BatchedEvent>();
+  private timer: ReturnType<typeof setTimeout> | null = null;
+  private batchCount = 0;
+
+  constructor(options: EventBatcherOptions) {
+    this.debounceMs = options.debounceMs ?? 300;
+    this.isImmunePath = options.isImmunePath ?? (() => false);
+    this.onImmediate = options.onImmediate;
+    this.onBatch = options.onBatch;
+  }
+
+  /** Push a new file event. Returns true if handled immediately (fast-path). */
+  push(event: string, path: string): boolean {
+    // Fast-path: immune file change → immediate processing for auto-heal responsiveness
+    if (event === "change" && this.isImmunePath(path)) {
+      this.onImmediate(event, path);
+      return true;
+    }
+
+    const now = Date.now();
+    const existing = this.pendingEvents.get(path);
+
+    // Cancel out: add + unlink on same file
+    if (existing) {
+      if ((existing.event === "add" && event === "unlink") ||
+          (existing.event === "unlink" && event === "add")) {
+        this.pendingEvents.delete(path);
+        return false;
+      }
+    }
+
+    // Last event wins for same file
+    this.pendingEvents.set(path, { event, path, timestamp: now });
+
+    // Start/reset debounce timer
+    if (this.timer) clearTimeout(this.timer);
+    this.timer = setTimeout(() => this.flush(), this.debounceMs);
+
+    return false;
+  }
+
+  /** Flush all pending events immediately */
+  flush(): void {
+    if (this.timer) {
+      clearTimeout(this.timer);
+      this.timer = null;
+    }
+
+    if (this.pendingEvents.size === 0) return;
+
+    const events = [...this.pendingEvents.values()];
+    this.pendingEvents.clear();
+    this.batchCount++;
+    this.onBatch(events);
+  }
+
+  /** Get the number of batches processed */
+  get totalBatches(): number {
+    return this.batchCount;
+  }
+
+  /** Get the number of pending events */
+  get pendingCount(): number {
+    return this.pendingEvents.size;
+  }
+
+  /** Destroy the batcher, clearing any pending timers */
+  destroy(): void {
+    if (this.timer) {
+      clearTimeout(this.timer);
+      this.timer = null;
+    }
+    this.pendingEvents.clear();
+  }
+}

package/src/daemon/guards.ts

@@ -1,13 +1,13 @@
-import { resolve } from "path";
-
-/**
- * Guard: reject resolved paths outside the workspace root.
- * Throws if absPath is not under wsRoot.
- */
-export function assertInsideWorkspace(absPath: string, wsRoot: string): void {
-  const normalizedPath = absPath.replace(/\\/g, "/").toLowerCase();
-  const normalizedRoot = resolve(wsRoot).replace(/\\/g, "/").toLowerCase();
-  if (!normalizedPath.startsWith(normalizedRoot + "/") && normalizedPath !== normalizedRoot) {
-    throw new Error("Access denied: path outside workspace");
-  }
-}
+import { resolve } from "path";
+
+/**
+ * Guard: reject resolved paths outside the workspace root.
+ * Throws if absPath is not under wsRoot.
+ */
+export function assertInsideWorkspace(absPath: string, wsRoot: string): void {
+  const normalizedPath = absPath.replace(/\\/g, "/").toLowerCase();
+  const normalizedRoot = resolve(wsRoot).replace(/\\/g, "/").toLowerCase();
+  if (!normalizedPath.startsWith(normalizedRoot + "/") && normalizedPath !== normalizedRoot) {
+    throw new Error("Access denied: path outside workspace");
+  }
+}