@ebowwa/daemons 0.5.0 → 0.7.0

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;GAmBG;AAEH,sBAAsB;AACtB,OAAO,EACL,UAAU,GAMX,MAAM,WAAW,CAAC;AAEnB,QAAQ;AACR,cAAc,YAAY,CAAC"}

package/dist/types.d.ts

@@ -0,0 +1,36 @@
+/**
+ * Daemons - Core Types
+ *
+ * Minimal types for DaemonCore and VPSDaemon.
+ */
+export type DaemonStatus = "starting" | "running" | "stopping" | "stopped" | "error";
+export interface Channel {
+    id: string;
+    type: string;
+    start(): Promise<void>;
+    stop(): Promise<void>;
+    isRunning(): boolean;
+    send?(message: unknown): Promise<unknown>;
+    onMessage(handler: (msg: unknown) => Promise<void>): void;
+}
+export interface ChannelMessage {
+    id: string;
+    channelId: string;
+    type: "text" | "command" | "event";
+    content: string;
+    metadata?: Record<string, unknown>;
+    timestamp: string;
+}
+export interface HealthStatus {
+    status: "healthy" | "degraded" | "unhealthy";
+    uptime: number;
+    channels: Record<string, {
+        running: boolean;
+        error?: string;
+    }>;
+    checks: Record<string, {
+        passed: boolean;
+        message?: string;
+    }>;
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAMH,MAAM,MAAM,YAAY,GAAG,UAAU,GAAG,SAAS,GAAG,UAAU,GAAG,SAAS,GAAG,OAAO,CAAC;AAErF,MAAM,WAAW,OAAO;IACtB,EAAE,EAAE,MAAM,CAAC;IACX,IAAI,EAAE,MAAM,CAAC;IACb,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;IACvB,IAAI,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;IACtB,SAAS,IAAI,OAAO,CAAC;IACrB,IAAI,CAAC,CAAC,OAAO,EAAE,OAAO,GAAG,OAAO,CAAC,OAAO,CAAC,CAAC;IAC1C,SAAS,CAAC,OAAO,EAAE,CAAC,GAAG,EAAE,OAAO,KAAK,OAAO,CAAC,IAAI,CAAC,GAAG,IAAI,CAAC;CAC3D;AAED,MAAM,WAAW,cAAc;IAC7B,EAAE,EAAE,MAAM,CAAC;IACX,SAAS,EAAE,MAAM,CAAC;IAClB,IAAI,EAAE,MAAM,GAAG,SAAS,GAAG,OAAO,CAAC;IACnC,OAAO,EAAE,MAAM,CAAC;IAChB,QAAQ,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IACnC,SAAS,EAAE,MAAM,CAAC;CACnB;AAED,MAAM,WAAW,YAAY;IAC3B,MAAM,EAAE,SAAS,GAAG,UAAU,GAAG,WAAW,CAAC;IAC7C,MAAM,EAAE,MAAM,CAAC;IACf,QAAQ,EAAE,MAAM,CAAC,MAAM,EAAE;QAAE,OAAO,EAAE,OAAO,CAAC;QAAC,KAAK,CAAC,EAAE,MAAM,CAAA;KAAE,CAAC,CAAC;IAC/D,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE;QAAE,MAAM,EAAE,OAAO,CAAC;QAAC,OAAO,CAAC,EAAE,MAAM,CAAA;KAAE,CAAC,CAAC;CAC/D"}

package/dist/types.js

@@ -0,0 +1,7 @@
+/**
+ * Daemons - Core Types
+ *
+ * Minimal types for DaemonCore and VPSDaemon.
+ */
+export {};
+//# sourceMappingURL=types.js.map

package/dist/types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.js","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"AAAA;;;;GAIG"}

package/package.json

@@ -1,67 +1,27 @@
 {
   "name": "@ebowwa/daemons",
-  "version": "0.5.0",
-  "description": "Cross-platform daemon management and AI orchestration (systemd, launchd, schtasks)",
+  "version": "0.7.0",
+  "description": "Framework for building daemons - DaemonCore primitive with lifecycle, signals, channels, HTTP API",
   "type": "module",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",
-  "bin": {
-    "daemons-telegram": "./dist/bin/telegram-cli.js",
-    "daemons-discord": "./dist/bin/discord-cli.js",
-    "daemons-manager": "./dist/bin/manager.js"
-  },
   "exports": {
     ".": {
       "types": "./dist/index.d.ts",
       "import": "./dist/index.js"
     },
-    "./daemon": {
-      "types": "./dist/daemon.d.ts",
-      "import": "./dist/daemon.js"
-    },
-    "./agent": {
-      "types": "./dist/agent.d.ts",
-      "import": "./dist/agent.js"
-    },
-    "./hooks": {
-      "types": "./dist/hooks.d.ts",
-      "import": "./dist/hooks.js"
-    },
-    "./tools": {
-      "types": "./dist/tools.d.ts",
-      "import": "./dist/tools.js"
-    },
-    "./state": {
-      "types": "./dist/state.d.ts",
-      "import": "./dist/state.js"
-    },
-    "./channels": {
-      "types": "./dist/channels/index.d.ts",
-      "import": "./dist/channels/index.js"
+    "./core": {
+      "types": "./dist/core.d.ts",
+      "import": "./dist/core.js"
     }
   },
   "scripts": {
-    "build": "bun build ./src/index.ts --outdir ./dist --target bun --format esm && bun build ./bin/telegram-cli.ts --outdir ./dist/bin --target bun && bun build ./bin/discord-cli.ts --outdir ./dist/bin --target bun && bun build ./bin/manager.ts --outdir ./dist/bin --target bun",
-    "build:types": "tsc --emitDeclarationOnly --skipLibCheck",
+    "build": "tsc",
     "dev": "bun --watch src/index.ts",
     "test": "bun test",
-    "lint": "eslint src --ext .ts",
-    "clean": "rm -rf dist",
-    "telegram": "bun run dist/bin/telegram-cli.js",
-    "discord": "bun run dist/bin/discord-cli.js",
-    "manager": "bun run dist/bin/manager.js",
-    "status": "bun run dist/bin/manager.js status"
-  },
-  "dependencies": {
-    "@ebowwa/ai": "^0.3.0",
-    "@ebowwa/channel-telegram": "^1.13.0",
-    "@ebowwa/channel-types": "^0.1.1",
-    "@ebowwa/codespaces-types": "^1.4.5",
-    "@ebowwa/structured-prompts": "^0.3.2",
-    "@ebowwa/teammates": "^0.1.2",
-    "discord.js": "^14.16.3",
-    "zod": "^4.3.5"
+    "clean": "rm -rf dist"
   },
+  "dependencies": {},
   "devDependencies": {
     "@types/bun": "catalog:dev",
     "@types/node": "catalog:dev",
@@ -74,21 +34,17 @@
     "README.md"
   ],
   "keywords": [
-    "glm",
     "daemon",
-    "agent",
-    "autonomous",
-    "ai",
-    "telegram",
-    "discord",
-    "bot",
-    "chatbot",
-    "channels"
+    "framework",
+    "lifecycle",
+    "signals"
   ],
-  "peerDependencies": {
-    "@ebowwa/trajectory": ">=0.1.0"
-  },
-  "optionalDependencies": {
-    "@ebowwa/trajectory": "^0.1.0"
+  "author": "ebowwa",
+  "license": "MIT",
+  "ownership": {
+    "domain": "daemons",
+    "responsibilities": [
+      "daemon-framework"
+    ]
   }
-}
+}

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;