@ebowwa/daemons 0.5.1 → 0.7.0

package/src/core.ts

@@ -0,0 +1,476 @@
+/**
+ * Daemon Core - Generic Daemon Primitive
+ *
+ * Base class for all daemons. Provides:
+ * - Lifecycle management (start/stop)
+ * - Signal handling (SIGINT, SIGTERM, SIGHUP)
+ * - Channel registration and routing
+ * - HTTP health/status API
+ * - State persistence
+ * - Hook system
+ *
+ * @module @ebowwa/daemons/core
+ */
+
+import { promises as fs } from "fs";
+import type {
+  Channel,
+  ChannelMessage,
+  HealthStatus,
+  DaemonStatus,
+} from "./types.js";
+
+// ============================================================
+// Core Types
+// ============================================================
+
+export interface DaemonCoreConfig {
+  /** Unique daemon identifier */
+  id: string;
+  /** Human-readable name */
+  name: string;
+  /** HTTP API config */
+  api?: {
+    port?: number;
+    host?: string;
+    enabled?: boolean;
+  };
+  /** State persistence */
+  state?: {
+    path?: string;
+    autoSave?: boolean;
+    saveInterval?: number;
+  };
+  /** Graceful shutdown timeout (ms) */
+  shutdownTimeout?: number;
+}
+
+export interface DaemonCoreState {
+  status: DaemonStatus;
+  startedAt: string | null;
+  stoppedAt: string | null;
+  error: string | null;
+  metadata: Record<string, unknown>;
+}
+
+export type CoreHookName =
+  | "onStart"
+  | "onStop"
+  | "onError"
+  | "onChannelRegister"
+  | "onChannelStart"
+  | "onChannelStop"
+  | "onMessage"
+  | "onHealthCheck";
+
+export type CoreHookCallback<P = unknown, R = void> = (payload: P) => Promise<R> | R;
+
+export interface DaemonPlugin {
+  id: string;
+  name: string;
+  init(daemon: DaemonCore): Promise<void>;
+  destroy?(): Promise<void>;
+}
+
+// ============================================================
+// Daemon Core Class
+// ============================================================
+
+const DEFAULT_STATE_PATH = ".daemon-state.json";
+const DEFAULT_SHUTDOWN_TIMEOUT = 10000;
+
+export class DaemonCore {
+  protected config: DaemonCoreConfig;
+  protected state: DaemonCoreState;
+  protected channels: Map<string, Channel> = new Map();
+  private hooks: Map<CoreHookName, Set<CoreHookCallback>> = new Map();
+  private plugins: Map<string, DaemonPlugin> = new Map();
+  private messageHandler: ((msg: ChannelMessage) => Promise<void>) | null = null;
+  private httpServer: ReturnType<typeof Bun.serve> | null = null;
+  private stateSaveInterval: Timer | null = null;
+  protected shuttingDown = false;
+
+  constructor(config: DaemonCoreConfig) {
+    this.config = {
+      ...config,
+      api: config.api ?? { enabled: false },
+      state: config.state ?? { autoSave: false },
+      shutdownTimeout: config.shutdownTimeout ?? DEFAULT_SHUTDOWN_TIMEOUT,
+    };
+
+    this.state = {
+      status: "stopped",
+      startedAt: null,
+      stoppedAt: null,
+      error: null,
+      metadata: {},
+    };
+
+    this.setupSignalHandlers();
+  }
+
+  // ============================================================
+  // Lifecycle
+  // ============================================================
+
+  async start(): Promise<void> {
+    if (this.state.status === "running") {
+      throw new Error("Daemon already running");
+    }
+
+    this.state.status = "starting";
+    this.log("Starting...");
+
+    try {
+      await this.loadState();
+      await this.executeHooks("onStart", this.state);
+
+      for (const [id, channel] of this.channels) {
+        await this.startChannel(id, channel);
+      }
+
+      if (this.config.api?.enabled !== false && this.config.api?.port) {
+        this.startHTTP();
+      }
+
+      if (this.config.state?.autoSave && this.config.state.saveInterval) {
+        this.stateSaveInterval = setInterval(
+          () => this.saveState(),
+          this.config.state.saveInterval
+        );
+      }
+
+      this.state.status = "running";
+      this.state.startedAt = new Date().toISOString();
+      this.state.error = null;
+
+      this.log("Running");
+    } catch (error) {
+      this.state.status = "error";
+      this.state.error = error instanceof Error ? error.message : String(error);
+      await this.executeHooks("onError", error);
+      throw error;
+    }
+  }
+
+  async stop(): Promise<void> {
+    if (this.state.status !== "running") return;
+    if (this.shuttingDown) return;
+
+    this.shuttingDown = true;
+    this.state.status = "stopping";
+    this.log("Stopping...");
+
+    const timeout = this.config.shutdownTimeout!;
+
+    try {
+      if (this.stateSaveInterval) {
+        clearInterval(this.stateSaveInterval);
+        this.stateSaveInterval = null;
+      }
+
+      await Promise.race([
+        this.stopAllChannels(),
+        new Promise((_, reject) =>
+          setTimeout(() => reject(new Error("Channel stop timeout")), timeout / 2)
+        ),
+      ]);
+
+      if (this.httpServer) {
+        this.httpServer.stop();
+        this.httpServer = null;
+      }
+
+      await this.executeHooks("onStop", this.state);
+
+      for (const plugin of this.plugins.values()) {
+        await plugin.destroy?.();
+      }
+
+      await this.saveState();
+
+      this.state.status = "stopped";
+      this.state.stoppedAt = new Date().toISOString();
+      this.log("Stopped");
+    } catch (error) {
+      this.state.status = "error";
+      this.state.error = error instanceof Error ? error.message : String(error);
+      this.log(`Stop error: ${error}`);
+    } finally {
+      this.shuttingDown = false;
+    }
+  }
+
+  async restart(): Promise<void> {
+    await this.stop();
+    await this.start();
+  }
+
+  // ============================================================
+  // Status & Health
+  // ============================================================
+
+  getStatus(): DaemonStatus {
+    return this.state.status;
+  }
+
+  getState(): Readonly<DaemonCoreState> {
+    return { ...this.state };
+  }
+
+  async getHealth(): Promise<HealthStatus> {
+    const channelStatus: Record<string, { running: boolean; error?: string }> = {};
+
+    for (const [id, channel] of this.channels) {
+      channelStatus[id] = { running: channel.isRunning() };
+    }
+
+    const hookResults = await this.executeHooks("onHealthCheck", null) as unknown[];
+    const checks: Record<string, { passed: boolean; message?: string }> = {};
+
+    hookResults.forEach((result, i) => {
+      if (result && typeof result === "object" && "passed" in result) {
+        checks[`check-${i}`] = result as { passed: boolean; message?: string };
+      }
+    });
+
+    const allChannelsRunning = Object.values(channelStatus).every(c => c.running);
+    const allChecksPassed = Object.values(checks).every(c => c.passed);
+
+    let status: "healthy" | "degraded" | "unhealthy";
+    if (!allChannelsRunning) status = "unhealthy";
+    else if (!allChecksPassed) status = "degraded";
+    else status = "healthy";
+
+    return {
+      status,
+      uptime: this.state.startedAt ? Date.now() - new Date(this.state.startedAt).getTime() : 0,
+      channels: channelStatus,
+      checks,
+    };
+  }
+
+  // ============================================================
+  // Channels
+  // ============================================================
+
+  registerChannel(channel: Channel): void {
+    if (this.channels.has(channel.id)) {
+      throw new Error(`Channel already registered: ${channel.id}`);
+    }
+
+    this.channels.set(channel.id, channel);
+    channel.onMessage((msg) => this.handleChannelMessage(channel.id, msg));
+
+    this.executeHooks("onChannelRegister", channel);
+    this.log(`Channel registered: ${channel.id}`);
+  }
+
+  getChannel(id: string): Channel | undefined {
+    return this.channels.get(id);
+  }
+
+  getChannels(): Channel[] {
+    return Array.from(this.channels.values());
+  }
+
+  private async startChannel(id: string, channel: Channel): Promise<void> {
+    await channel.start();
+    await this.executeHooks("onChannelStart", { id, channel });
+    this.log(`Channel started: ${id}`);
+  }
+
+  private async stopAllChannels(): Promise<void> {
+    const stops = Array.from(this.channels.entries()).map(async ([id, channel]) => {
+      try {
+        await channel.stop();
+        await this.executeHooks("onChannelStop", { id, channel });
+      } catch (error) {
+        this.log(`Channel stop failed: ${id}`);
+      }
+    });
+
+    await Promise.allSettled(stops);
+  }
+
+  private async handleChannelMessage(channelId: string, msg: unknown): Promise<void> {
+    const message = msg as ChannelMessage;
+    await this.executeHooks("onMessage", { channelId, message });
+
+    if (this.messageHandler) {
+      try {
+        await this.messageHandler(message);
+      } catch (error) {
+        this.log(`Message handler error: ${error}`);
+      }
+    }
+  }
+
+  // ============================================================
+  // Message Handler
+  // ============================================================
+
+  onMessage(handler: (msg: ChannelMessage) => Promise<void>): void {
+    this.messageHandler = handler;
+  }
+
+  // ============================================================
+  // Hooks
+  // ============================================================
+
+  registerHook(name: CoreHookName, callback: CoreHookCallback): void {
+    if (!this.hooks.has(name)) this.hooks.set(name, new Set());
+    this.hooks.get(name)!.add(callback);
+  }
+
+  onStart(cb: CoreHookCallback): void { this.registerHook("onStart", cb); }
+  onStop(cb: CoreHookCallback): void { this.registerHook("onStop", cb); }
+  onError(cb: CoreHookCallback): void { this.registerHook("onError", cb); }
+  onHealthCheck(cb: CoreHookCallback): void { this.registerHook("onHealthCheck", cb); }
+
+  protected async executeHooks(name: CoreHookName, payload: unknown): Promise<unknown[]> {
+    const callbacks = this.hooks.get(name);
+    if (!callbacks) return [];
+
+    const results = [];
+    for (const cb of callbacks) {
+      try {
+        results.push(await cb(payload));
+      } catch (error) {
+        this.log(`Hook ${name} error: ${error}`);
+      }
+    }
+    return results;
+  }
+
+  // ============================================================
+  // Plugins
+  // ============================================================
+
+  async use(plugin: DaemonPlugin): Promise<void> {
+    if (this.plugins.has(plugin.id)) {
+      throw new Error(`Plugin already registered: ${plugin.id}`);
+    }
+    await plugin.init(this);
+    this.plugins.set(plugin.id, plugin);
+    this.log(`Plugin loaded: ${plugin.name}`);
+  }
+
+  // ============================================================
+  // State Persistence
+  // ============================================================
+
+  updateState(updates: Partial<DaemonCoreState["metadata"]>): void {
+    this.state.metadata = { ...this.state.metadata, ...updates };
+  }
+
+  private async loadState(): Promise<void> {
+    const path = this.config.state?.path ?? DEFAULT_STATE_PATH;
+    try {
+      const data = await fs.readFile(path, "utf-8");
+      const saved = JSON.parse(data);
+      this.state.metadata = saved.metadata ?? {};
+    } catch {
+      // No saved state
+    }
+  }
+
+  private async saveState(): Promise<void> {
+    const path = this.config.state?.path ?? DEFAULT_STATE_PATH;
+    try {
+      await fs.writeFile(path, JSON.stringify({
+        status: this.state.status,
+        metadata: this.state.metadata,
+        savedAt: new Date().toISOString(),
+      }, null, 2));
+    } catch (error) {
+      this.log(`State save failed: ${error}`);
+    }
+  }
+
+  // ============================================================
+  // HTTP API
+  // ============================================================
+
+  private startHTTP(): void {
+    const port = this.config.api?.port ?? 8911;
+    const hostname = this.config.api?.host ?? "0.0.0.0";
+
+    this.httpServer = Bun.serve({
+      port,
+      hostname,
+      fetch: async (req) => {
+        const url = new URL(req.url);
+        const path = url.pathname;
+
+        const corsHeaders = {
+          "Access-Control-Allow-Origin": "*",
+          "Access-Control-Allow-Methods": "GET, OPTIONS",
+          "Access-Control-Allow-Headers": "Content-Type",
+        };
+
+        if (req.method === "OPTIONS") {
+          return new Response(null, { headers: corsHeaders });
+        }
+
+        if (path === "/health") {
+          const health = await this.getHealth();
+          return Response.json(health, { headers: corsHeaders });
+        }
+
+        if (path === "/api/status" || path === "/status") {
+          return Response.json({
+            id: this.config.id,
+            name: this.config.name,
+            status: this.state.status,
+            startedAt: this.state.startedAt,
+            channels: Object.fromEntries(
+              Array.from(this.channels.entries()).map(([id, ch]) => [id, ch.isRunning()])
+            ),
+          }, { headers: corsHeaders });
+        }
+
+        if (path === "/api/channels") {
+          return Response.json(
+            this.getChannels().map(ch => ({ id: ch.id, type: ch.type, running: ch.isRunning() })),
+            { headers: corsHeaders }
+          );
+        }
+
+        return Response.json({ error: "Not found" }, { status: 404, headers: corsHeaders });
+      },
+    });
+
+    this.log(`API: http://${hostname}:${port}`);
+  }
+
+  // ============================================================
+  // Signal Handlers
+  // ============================================================
+
+  private setupSignalHandlers(): void {
+    const handleSignal = async (signal: string) => {
+      this.log(`Received ${signal}`);
+      await this.stop();
+      process.exit(0);
+    };
+
+    process.on("SIGINT", () => handleSignal("SIGINT"));
+    process.on("SIGTERM", () => handleSignal("SIGTERM"));
+
+    process.on("SIGHUP", async () => {
+      this.log("Received SIGHUP - saving state");
+      await this.saveState();
+    });
+  }
+
+  // ============================================================
+  // Logging
+  // ============================================================
+
+  protected log(message: string): void {
+    console.log(`[${this.config.name}] ${message}`);
+  }
+}
+
+export default DaemonCore;

package/src/index.ts

@@ -1,111 +1,33 @@
 /**
- * Daemons - Autonomous Agent Daemon Framework
+ * @ebowwa/daemons
  *
- * A daemon framework for autonomous AI agents.
- * Implements SLAM pattern (State → Loop → Action → Memory).
- * Supports hooks, tools via MCP, multi-agent coordination, and communication channels.
+ * Framework for building daemons.
+ * Provides DaemonCore primitive with lifecycle, signals, channels, HTTP API, state persistence.
+ *
+ * @example
+ * ```ts
+ * import { DaemonCore } from "@ebowwa/daemons";
+ *
+ * class MyDaemon extends DaemonCore {
+ *   async start() {
+ *     // Register channels, set up handlers
+ *     await super.start();
+ *   }
+ * }
+ * ```
  *
  * @module @ebowwa/daemons
  */
 
-// Main daemon class
-export { GLMDaemon, type GLMDaemonConfigWithWorkflow } from "./daemon.js";
-
-// Agent class
-export { GLMAgent } from "./agent.js";
-
-// Supporting systems
-export { HookSystem } from "./hooks.js";
-export { ToolBridge } from "./tools.js";
-export { StateManager } from "./state.js";
-
-// Workflow system
-export {
-  // Classes
-  BaseWorkflow,
-  WorkflowRegistry,
-  workflowRegistry,
-  // Functions
-  initializeWorkflows,
-  getWorkflow,
-  getDefaultWorkflow,
-  // Built-in workflows
-  CodingWorkflow,
-  codingWorkflow,
-  CODING_PHASES,
-  CODING_TRANSITIONS,
-  CODING_WORKFLOW_CONFIG,
-  TradingWorkflow,
-  tradingWorkflow,
-  TRADING_PHASES,
-  TRADING_TRANSITIONS,
-  TRADING_WORKFLOW_CONFIG,
-  // Types
-  type GLMWorkflowPhase,
-  type GLMWorkflowContext,
-  type GLMWorkflowPhaseResult,
-  type GLMWorkflowTransition,
-  type GLMWorkflowConfig,
-  type GLMWorkflowExecutor,
-  type CodingPhase,
-  type TradingPhase,
-} from "./workflows/index.js";
-
-// Built-in tools - re-exported from @ebowwa/ai/tools for convenience
+// Generic daemon core
 export {
-  BUILTIN_TOOLS,
-  getBuiltinTool,
-  getBuiltinToolNames,
-  toGLMFormat,
-  executeBuiltinTool,
-  ToolExecutor,
-  type ToolDefinition,
-  type ToolCall,
-  type ToolExecutorOptions,
-  type ToolExecutionResult,
-} from "@ebowwa/ai/tools";
-
-// Memory systems
-export {
-  ConversationMemory,
-  NumericConversationMemory,
-  StringConversationMemory,
-  type ConversationMessage,
-  type ConversationMemoryConfig,
-} from "./memory.js";
-
-// Communication channels
-export {
-  BaseChannel,
-  TelegramChannel,
-  DiscordChannel,
-  ChannelRegistry,
-  type BaseChannelConfig,
-  type TelegramChannelConfig,
-  type DiscordChannelConfig,
-  type MessageContext,
-  type RouteResult,
-  type MessageClassification,
-} from "./channels/index.js";
+  DaemonCore,
+  type DaemonCoreConfig,
+  type DaemonCoreState,
+  type CoreHookName,
+  type CoreHookCallback,
+  type DaemonPlugin,
+} from "./core.js";
 
 // Types
 export * from "./types.js";
-
-// Convenience function to create and start a daemon
-import { GLMDaemon } from "./daemon.js";
-import type { GLMDaemonConfig } from "./types.js";
-
-export async function createGLMDaemon(
-  config: GLMDaemonConfig
-): Promise<GLMDaemon> {
-  const daemon = new GLMDaemon(config);
-  return daemon;
-}
-
-export async function startGLMDaemon(
-  config: GLMDaemonConfig,
-  prompt: string
-): Promise<string> {
-  const daemon = new GLMDaemon(config);
-  return await daemon.start(prompt);
-}