@ebowwa/stack 0.1.4 → 0.3.0

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@ebowwa/stack",
-  "version": "0.1.4",
-  "description": "Full-stack daemon orchestrator combining unified-router (cross-channel) and node-agent (Ralph orchestration)",
+  "version": "0.3.0",
+  "description": "Cross-channel AI stack with node-agent integration (SSH + Telegram + Ralph/Git)",
   "type": "module",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",
@@ -20,12 +20,14 @@
   },
   "keywords": [
     "stack",
-    "orchestrator",
-    "daemon",
-    "ralph",
+    "channel",
     "telegram",
     "ssh",
-    "ai"
+    "ai",
+    "cross-channel",
+    "memory",
+    "ralph",
+    "node-agent"
   ],
   "author": "Ebowwa Labs <labs@ebowwa.com>",
   "license": "MIT",
@@ -41,9 +43,7 @@
     "@ebowwa/channel-telegram": "^1.14.2",
     "@ebowwa/channel-types": "^0.2.1",
     "@ebowwa/codespaces-types": "^1.6.1",
-    "@ebowwa/daemons": "^0.5.0",
-    "@ebowwa/node-agent": "^0.6.4",
-    "@ebowwa/rolling-keys": "^0.1.1"
+    "@ebowwa/node-agent": "^0.6.5"
   },
   "devDependencies": {
     "@types/bun": "latest"

package/src/index.ts

@@ -1,17 +1,19 @@
 #!/usr/bin/env bun
 /**
- * @ebowwa/stack - Full-Stack Daemon Orchestrator
+ * @ebowwa/stack - Cross-Channel AI Stack with Node Agent
  *
- * Combines:
+ * Features:
  * - Unified Router: Cross-channel communication (SSH + Telegram)
- * - Node Agent: Ralph loop orchestration, worktrees, monitoring
+ * - Cross-channel memory with permission controls
+ * - AI-powered message handling
+ * - Node Agent: Ralph loops, Git, Monitoring (imported but disabled for now)
  *
  * Architecture:
  *   ┌──────────────────────────────────────────────────────────────┐
  *   │                         STACK                                │
  *   │  ┌────────────────┐  ┌────────────────┐  ┌────────────────┐ │
- *   │  │ Unified Router │  │  Node Agent    │  │   HTTP API     │ │
- *   │  │ (chat/messaging)│  │ (Ralph loops)  │  │   (:8911)      │ │
+ *   │  │  SSH Channel   │  │Telegram Channel│  │   HTTP API     │ │
+ *   │  │  (optional)    │  │  (optional)    │  │  (optional)    │ │
  *   │  └───────┬────────┘  └───────┬────────┘  └───────┬────────┘ │
  *   │          │                   │                   │          │
  *   │          └───────────────────┴───────────────────┘          │
@@ -19,7 +21,15 @@
  *   │                    ┌─────────▼─────────┐                    │
  *   │                    │   Shared Memory    │                    │
  *   │                    │  (Cross-Context)   │                    │
- *   │                    └───────────────────┘                    │
+ *   │                    └─────────┬─────────┘                    │
+ *   │                              │                               │
+ *   │          ┌───────────────────┴───────────────────┐          │
+ *   │          │                                       │          │
+ *   │  ┌───────▼───────┐                    ┌──────────▼───────┐ │
+ *   │  │   AI Brain    │                    │   Node Agent     │ │
+ *   │  │    (GLM)      │                    │ (Ralph/Git/...)  │ │
+ *   │  └───────────────┘                    │  [DISABLED]      │ │
+ *   │                                        └──────────────────┘ │
  *   └──────────────────────────────────────────────────────────────┘
  */
 
@@ -28,6 +38,15 @@ import type { ChannelConnector, ChannelMessage, ChannelResponse, ChannelId } fro
 import { GLMClient } from "@ebowwa/ai";
 import { ToolExecutor, BUILTIN_TOOLS } from "@ebowwa/ai/tools";
 
+// Node Agent imports (services available but disabled)
+import {
+  RalphService,
+  GitService,
+  ConsoleLoggerService,
+  initializeStateService,
+  getState,
+} from "@ebowwa/node-agent/lib";
+
 // ============================================================
 // Types
 // ============================================================
@@ -43,17 +62,11 @@ export interface StackConfig {
     botToken?: string;
     allowedChats?: number[];
   };
-  /** Enable HTTP API for Ralph management */
+  /** Enable HTTP API */
   api?: {
     port?: number;
     host?: string;
   };
-  /** Ralph loop configuration */
-  ralph?: {
-    worktreesDir: string;
-    repoUrl: string;
-    baseBranch?: string;
-  };
   /** AI configuration */
   ai?: {
     model?: string;
@@ -65,6 +78,8 @@ export interface StackConfig {
     name: string;
     hostname?: string;
   };
+  /** Enable Node Agent features (Ralph, Git, etc.) */
+  enableNodeAgent?: boolean;
 }
 
 export interface StackState {
@@ -77,16 +92,9 @@ export interface StackState {
     enabled: boolean;
     port?: number;
   };
-  ralphLoops: Map<string, RalphLoopInfo>;
-}
-
-interface RalphLoopInfo {
-  id: string;
-  worktree: string;
-  prompt: string;
-  status: "running" | "paused" | "completed" | "error";
-  iterations: number;
-  started: Date;
+  nodeAgent: {
+    enabled: boolean;
+  };
 }
 
 // ============================================================
@@ -103,25 +111,27 @@ export class Stack {
   private channels: Map<string, ChannelConnector> = new Map();
   private abortController: AbortController | null = null;
 
+  // Node Agent services (initialized but may not be used)
+  private ralphService: RalphService | null = null;
+  private gitService: GitService | null = null;
+  private consoleLogger: ConsoleLoggerService | null = null;
+
   constructor(config: StackConfig) {
-    // Only set defaults for non-channel config
     this.config = {
       ...config,
       api: config.api ?? { port: 8911 },
-      ralph: config.ralph ?? { worktreesDir: "/root/worktrees", repoUrl: "" },
       ai: config.ai ?? { model: "GLM-4.7", temperature: 0.7, maxTokens: 4096 },
       node: config.node ?? { name: "stack", hostname: "localhost" },
-      // ssh and telegram remain undefined if not provided
     };
 
     this.state = {
       started: new Date(),
       channels: { ssh: false, telegram: false },
       api: { enabled: !!this.config.api, port: this.config.api?.port },
-      ralphLoops: new Map(),
+      nodeAgent: { enabled: false },
     };
 
-    // Build memory channels dynamically based on enabled channels
+    // Build memory channels dynamically
     const memoryChannels: Record<string, { memoryFile: string; maxMessages: number }> = {};
     const permissions: Record<string, { canRead: string[] }> = {};
     const enabledChannels: string[] = [];
@@ -134,35 +144,32 @@ export class Stack {
       memoryChannels.telegram = { memoryFile: "/root/.telegram-memory.json", maxMessages: 50 };
       enabledChannels.push("telegram");
     }
-    if (this.config.api) {
-      memoryChannels.api = { memoryFile: "/root/.api-memory.json", maxMessages: 100 };
-      enabledChannels.push("api");
-    }
 
-    // Set up cross-channel permissions for enabled channels
     for (const channel of enabledChannels) {
       permissions[channel] = { canRead: enabledChannels.filter(c => c !== channel) };
     }
 
-    // Initialize shared memory (empty if no channels)
     this.memory = createPermissionMemory({
       channels: memoryChannels,
       permissions,
     });
 
-    // Initialize router
     this.router = createChannelRouter({
       announcement: {
         serverName: this.config.node.name,
         hostname: this.config.node.hostname,
         packageName: "@ebowwa/stack",
-        version: "0.1.1",
+        version: "0.3.0",
       },
     });
 
-    // Initialize AI
     this.client = new GLMClient();
     this.executor = new ToolExecutor(this.client, [...BUILTIN_TOOLS]);
+
+    // Initialize Node Agent services (but don't enable features yet)
+    this.ralphService = new RalphService();
+    this.gitService = new GitService();
+    this.consoleLogger = new ConsoleLoggerService();
   }
 
   // ============================================================
@@ -202,18 +209,42 @@ export class Stack {
     console.log("[Stack] Telegram registered");
   }
 
+  // ============================================================
+  // Node Agent Initialization
+  // ============================================================
+
+  private async initializeNodeAgent(): Promise<void> {
+    console.log("[Stack] Initializing Node Agent services...");
+
+    // Initialize state service
+    try {
+      await initializeStateService();
+      console.log("[Stack] State service initialized");
+    } catch (error) {
+      console.warn("[Stack] State service initialization failed (non-critical):", error);
+    }
+
+    // Ralph and Git services are instantiated but features are DISABLED
+    // TODO: Enable when ready
+    // this.ralphService?.startMonitoring();
+    // this.gitService?.initialize();
+
+    this.state.nodeAgent.enabled = true;
+    console.log("[Stack] Node Agent services ready (Ralph/Git DISABLED)");
+  }
+
   // ============================================================
   // Message Handler
   // ============================================================
 
   private async handleMessage(routed: { message: ChannelMessage; channelId: ChannelId }): Promise<ChannelResponse> {
     const { message, channelId } = routed;
-    const channel = channelId.platform as "ssh" | "telegram" | "api";
+    const channel = channelId.platform as "ssh" | "telegram";
     const text = message.text;
 
     console.log(`[${channel}] ${text.slice(0, 50)}...`);
 
-    // Start typing indicator for Telegram
+    // Typing indicator for Telegram
     const telegramChannel = this.channels.get("telegram") as { startTypingIndicator?: (chatId: string) => void; stopTypingIndicator?: (chatId: string) => void } | undefined;
     const chatId = channelId.metadata?.chatId as string | undefined;
     if (channel === "telegram" && telegramChannel?.startTypingIndicator && chatId) {
@@ -226,7 +257,7 @@ export class Stack {
       }
     };
 
-    // Check for memory commands
+    // Memory commands
     const cmdResult = parseMemoryCommand(this.memory, channel, text);
     if (cmdResult.handled) {
       stopTyping();
@@ -236,20 +267,28 @@ export class Stack {
       };
     }
 
-    // Check for Ralph commands
-    const ralphResult = await this.handleRalphCommand(channel, text);
-    if (ralphResult) {
+    // Status command
+    if (text.trim().toLowerCase() === "/status") {
       stopTyping();
       return {
-        content: { text: ralphResult },
+        content: { text: this.getStatus() },
         replyTo: { messageId: message.messageId, channelId: message.channelId },
       };
     }
 
-    // Add to shared memory
+    // Ralph commands (DISABLED for now)
+    // if (text.startsWith("/ralph")) {
+    //   stopTyping();
+    //   return {
+    //     content: { text: await this.handleRalphCommand(text) },
+    //     replyTo: { messageId: message.messageId, channelId: message.channelId },
+    //   };
+    // }
+
+    // Add to memory
     this.memory.addMessage(channel, { role: "user", content: text });
 
-    // Build messages with cross-channel context
+    // Build LLM messages
     const llmMessages = this.memory.buildLLMMessages(
       channel,
       this.buildSystemPrompt(),
@@ -284,100 +323,34 @@ export class Stack {
   }
 
   private buildSystemPrompt(): string {
-    return `You are **${this.config.node.name}** — a 24/7 AI stack running on this node.
+    const channelList = Object.entries(this.state.channels)
+      .filter(([, v]) => v)
+      .map(([k]) => k)
+      .join(", ") || "none";
+
+    return `You are **${this.config.node.name}** — a 24/7 AI assistant.
 
-## What You Manage
-- **Ralph Loops**: Autonomous AI agents running tasks
-- **Git Worktrees**: Isolated development environments
-- **Node Monitoring**: CPU, memory, disk usage
-- **Cross-Channel Memory**: Shared context between SSH, Telegram, and API
+## Capabilities
+- Cross-channel memory (shared context between channels)
+- Tool execution via MCP
+- Node monitoring and management
 
 ## Commands
-- \`/ralph start <prompt>\` — Start a Ralph loop
-- \`/ralph list\` — List running loops
-- \`/ralph stop <id>\` — Stop a loop
 - \`/status\` — Node status
 - \`/memory <cmd>\` — Memory management (grant, revoke, list, clear)
 
-## Stack Info
+## Info
 - Node: ${this.config.node.name}
-- Channels: ${Object.entries(this.state.channels).filter(([, v]) => v).map(([k]) => k).join(", ") || "none"}
+- Channels: ${channelList}
+- Node Agent: ${this.state.nodeAgent.enabled ? "ready (Ralph/Git disabled)" : "off"}
 - API: :${this.config.api?.port ?? 8911}`;
   }
 
-  // ============================================================
-  // Ralph Loop Management (delegates to node-agent)
-  // ============================================================
-
-  private async handleRalphCommand(channel: string, text: string): Promise<string | null> {
-    const parts = text.trim().split(/\s+/);
-    const cmd = parts[0].toLowerCase();
-
-    if (cmd === "/ralph" || cmd === "/ralph") {
-      const subCmd = parts[1]?.toLowerCase();
-
-      switch (subCmd) {
-        case "start": {
-          const prompt = parts.slice(2).join(" ");
-          if (!prompt) return "Usage: /ralph start <prompt>";
-          return await this.startRalphLoop(prompt);
-        }
-        case "list":
-          return this.listRalphLoops();
-        case "stop": {
-          const id = parts[2];
-          if (!id) return "Usage: /ralph stop <id>";
-          return await this.stopRalphLoop(id);
-        }
-        default:
-          return "Ralph commands: start, list, stop";
-      }
-    }
-
-    if (cmd === "/status") {
-      return this.getStatus();
-    }
-
-    return null;
-  }
-
-  private async startRalphLoop(prompt: string): Promise<string> {
-    // TODO: Delegate to @ebowwa/node-agent RalphService
-    const id = `ralph-${Date.now()}`;
-    this.state.ralphLoops.set(id, {
-      id,
-      worktree: `${this.config.ralph.worktreesDir}/${id}`,
-      prompt,
-      status: "running",
-      iterations: 0,
-      started: new Date(),
-    });
-    return `Started Ralph loop: ${id}\nPrompt: ${prompt.slice(0, 100)}...`;
-  }
-
-  private listRalphLoops(): string {
-    if (this.state.ralphLoops.size === 0) {
-      return "No Ralph loops running";
-    }
-    const lines = ["Ralph Loops:"];
-    for (const [id, info] of this.state.ralphLoops) {
-      lines.push(`  ${id}: ${info.status} (${info.iterations} iters)`);
-    }
-    return lines.join("\n");
-  }
-
-  private async stopRalphLoop(id: string): Promise<string> {
-    const info = this.state.ralphLoops.get(id);
-    if (!info) return `Ralph loop not found: ${id}`;
-    info.status = "paused";
-    return `Stopped Ralph loop: ${id}`;
-  }
-
   private getStatus(): string {
     const lines = [
       `**${this.config.node.name} Status**`,
       `Channels: SSH=${this.state.channels.ssh}, Telegram=${this.state.channels.telegram}`,
-      `Ralph Loops: ${this.state.ralphLoops.size}`,
+      `Node Agent: ${this.state.nodeAgent.enabled ? "ready (Ralph/Git disabled)" : "off"}`,
       `Uptime: ${Math.floor((Date.now() - this.state.started.getTime()) / 1000)}s`,
     ];
     return lines.join("\n");
@@ -393,17 +366,16 @@ export class Stack {
     const port = this.config.api.port ?? 8911;
     const host = this.config.api.host ?? "0.0.0.0";
 
-    const server = Bun.serve({
+    Bun.serve({
       port,
       host,
       fetch: async (req) => {
         const url = new URL(req.url);
         const path = url.pathname;
 
-        // CORS headers
         const corsHeaders = {
           "Access-Control-Allow-Origin": "*",
-          "Access-Control-Allow-Methods": "GET, POST, DELETE, OPTIONS",
+          "Access-Control-Allow-Methods": "GET, OPTIONS",
           "Access-Control-Allow-Headers": "Content-Type",
         };
 
@@ -411,69 +383,24 @@ export class Stack {
           return new Response(null, { headers: corsHeaders });
         }
 
-        try {
-          // GET /api/status
-          if (path === "/api/status" && req.method === "GET") {
-            return Response.json(this.getStatusJSON(), { headers: corsHeaders });
-          }
-
-          // GET /api/ralph-loops
-          if (path === "/api/ralph-loops" && req.method === "GET") {
-            return Response.json(this.listRalphLoopsJSON(), { headers: corsHeaders });
-          }
-
-          // POST /api/ralph-loops
-          if (path === "/api/ralph-loops" && req.method === "POST") {
-            const body = await req.json();
-            const prompt = body.prompt;
-            if (!prompt) {
-              return Response.json({ error: "Missing prompt" }, { status: 400, headers: corsHeaders });
-            }
-            const result = await this.startRalphLoop(prompt);
-            return Response.json({ message: result }, { headers: corsHeaders });
-          }
-
-          // DELETE /api/ralph-loops/:id
-          const match = path.match(/^\/api\/ralph-loops\/(.+)$/);
-          if (match && req.method === "DELETE") {
-            const result = await this.stopRalphLoop(match[1]);
-            return Response.json({ message: result }, { headers: corsHeaders });
-          }
-
-          // GET /health
-          if (path === "/health") {
-            return Response.json({ status: "ok" }, { headers: corsHeaders });
-          }
-
-          return Response.json({ error: "Not found" }, { status: 404, headers: corsHeaders });
-        } catch (error) {
-          const errorMsg = error instanceof Error ? error.message : String(error);
-          return Response.json({ error: errorMsg }, { status: 500, headers: corsHeaders });
+        if (path === "/api/status" && req.method === "GET") {
+          return Response.json({
+            node: this.config.node.name,
+            channels: this.state.channels,
+            nodeAgent: this.state.nodeAgent,
+            uptime: Math.floor((Date.now() - this.state.started.getTime()) / 1000),
+          }, { headers: corsHeaders });
         }
-      },
-    });
 
-    console.log(`[Stack] API running on http://${host}:${port}`);
-  }
+        if (path === "/health") {
+          return Response.json({ status: "ok" }, { headers: corsHeaders });
+        }
 
-  private getStatusJSON(): object {
-    return {
-      node: this.config.node.name,
-      channels: {
-        ssh: this.state.channels.ssh,
-        telegram: this.state.channels.telegram,
-      },
-      api: {
-        enabled: this.state.api.enabled,
-        port: this.state.api.port,
+        return Response.json({ error: "Not found" }, { status: 404, headers: corsHeaders });
       },
-      ralphLoops: this.state.ralphLoops.size,
-      uptime: Math.floor((Date.now() - this.state.started.getTime()) / 1000),
-    };
-  }
+    });
 
-  private listRalphLoopsJSON(): object[] {
-    return Array.from(this.state.ralphLoops.values());
+    console.log(`[Stack] API running on http://${host}:${port}`);
   }
 
   // ============================================================
@@ -485,17 +412,16 @@ export class Stack {
 
     this.abortController = new AbortController();
 
-    // Register channels (only if configured)
+    // Initialize Node Agent (services ready but features disabled)
+    await this.initializeNodeAgent();
+
+    // Register channels
     await this.registerSSH();
     await this.registerTelegram();
 
-    // Set handler
     this.router.setHandler((routed) => this.handleMessage(routed));
-
-    // Start router
     await this.router.start();
 
-    // Start API (optional)
     this.startAPI();
 
     console.log("[Stack] Running!");
@@ -508,10 +434,10 @@ export class Stack {
     if (this.state.api.enabled) {
       console.log(`  - API: :${this.state.api.port}`);
     }
-    console.log("  - Commands: /ralph start|list|stop, /status, /memory <cmd>");
+    console.log("  - Node Agent: ready (Ralph/Git disabled)");
+    console.log("  - Commands: /status, /memory <cmd>");
 
-    // Keep running
-    await new Promise(() => {}); // Run forever
+    await new Promise(() => {});
   }
 
   async stop(): Promise<void> {
@@ -519,7 +445,6 @@ export class Stack {
     this.abortController?.abort();
     await this.router.stop();
 
-    // Stop all channels
     for (const [name, channel] of this.channels) {
       console.log(`[Stack] Stopping ${name}...`);
       await channel.stop();
@@ -534,40 +459,32 @@ export class Stack {
 // ============================================================
 
 async function main() {
-  // Build config - only enable channels when explicitly configured
   const config: StackConfig = {
-    // SSH only enabled if SSH_CHAT_DIR is set
     ...(process.env.SSH_CHAT_DIR ? {
       ssh: {
         chatDir: process.env.SSH_CHAT_DIR,
         pollInterval: parseInt(process.env.SSH_POLL_INTERVAL || "500", 10),
       }
     } : {}),
-    // Telegram only enabled if bot token is set
     ...(process.env.TELEGRAM_BOT_TOKEN ? {
       telegram: {
         botToken: process.env.TELEGRAM_BOT_TOKEN,
         allowedChats: process.env.TELEGRAM_CHAT_ID ? [parseInt(process.env.TELEGRAM_CHAT_ID, 10)] : undefined,
       }
     } : {}),
-    // API enabled by default
     api: {
       port: parseInt(process.env.API_PORT || "8911", 10),
       host: process.env.API_HOST,
     },
-    ralph: {
-      worktreesDir: process.env.WORKTREES_DIR || "/root/worktrees",
-      repoUrl: process.env.REPO_URL || "",
-    },
     node: {
       name: process.env.NODE_NAME || "stack",
       hostname: process.env.HOSTNAME || "localhost",
     },
+    enableNodeAgent: process.env.ENABLE_NODE_AGENT !== "false",
   };
 
   const stack = new Stack(config);
 
-  // Handle shutdown
   process.on("SIGINT", async () => {
     await stack.stop();
     process.exit(0);
@@ -581,7 +498,6 @@ async function main() {
   await stack.start();
 }
 
-// Run if executed directly
 if (import.meta.main) {
   main().catch((error) => {
     console.error("[Stack] Fatal error:", error);