@ebowwa/stack 0.1.0

package/package.json

@@ -0,0 +1,51 @@
+{
+  "name": "@ebowwa/stack",
+  "version": "0.1.0",
+  "description": "Full-stack daemon orchestrator combining unified-router (cross-channel) and node-agent (Ralph orchestration)",
+  "type": "module",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "bin": {
+    "stack": "./dist/index.js"
+  },
+  "files": [
+    "dist",
+    "src",
+    "README.md"
+  ],
+  "scripts": {
+    "dev": "bun --hot run src/index.ts",
+    "start": "bun run src/index.ts",
+    "build": "bun build src/index.ts --target bun --outdir ./dist"
+  },
+  "keywords": [
+    "stack",
+    "orchestrator",
+    "daemon",
+    "ralph",
+    "telegram",
+    "ssh",
+    "ai"
+  ],
+  "author": "Ebowwa Labs <labs@ebowwa.com>",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/ebowwa/codespaces.git",
+    "directory": "packages/src/stack"
+  },
+  "dependencies": {
+    "@ebowwa/ai": "^0.3.3",
+    "@ebowwa/channel-core": "^1.3.0",
+    "@ebowwa/channel-ssh": "^2.1.1",
+    "@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"
+  },
+  "devDependencies": {
+    "@types/bun": "latest"
+  }
+}

package/src/index.ts

@@ -0,0 +1,467 @@
+#!/usr/bin/env bun
+/**
+ * @ebowwa/stack - Full-Stack Daemon Orchestrator
+ *
+ * Combines:
+ * - Unified Router: Cross-channel communication (SSH + Telegram)
+ * - Node Agent: Ralph loop orchestration, worktrees, monitoring
+ *
+ * Architecture:
+ *   ┌──────────────────────────────────────────────────────────────┐
+ *   │                         STACK                                │
+ *   │  ┌────────────────┐  ┌────────────────┐  ┌────────────────┐ │
+ *   │  │ Unified Router │  │  Node Agent    │  │   HTTP API     │ │
+ *   │  │ (chat/messaging)│  │ (Ralph loops)  │  │   (:8911)      │ │
+ *   │  └───────┬────────┘  └───────┬────────┘  └───────┬────────┘ │
+ *   │          │                   │                   │          │
+ *   │          └───────────────────┴───────────────────┘          │
+ *   │                              │                               │
+ *   │                    ┌─────────▼─────────┐                    │
+ *   │                    │   Shared Memory    │                    │
+ *   │                    │  (Cross-Context)   │                    │
+ *   │                    └───────────────────┘                    │
+ *   └──────────────────────────────────────────────────────────────┘
+ */
+
+import { createChannelRouter, createPermissionMemory, parseMemoryCommand } from "@ebowwa/channel-core";
+import type { ChannelConnector, ChannelMessage, ChannelResponse, ChannelId } from "@ebowwa/channel-types";
+import { GLMClient } from "@ebowwa/ai";
+import { ToolExecutor, BUILTIN_TOOLS } from "@ebowwa/ai/tools";
+
+// ============================================================
+// Types
+// ============================================================
+
+export interface StackConfig {
+  /** Enable SSH channel */
+  ssh?: {
+    chatDir: string;
+    pollInterval?: number;
+  };
+  /** Enable Telegram channel */
+  telegram?: {
+    botToken?: string;
+    allowedChats?: number[];
+  };
+  /** Enable HTTP API for Ralph management */
+  api?: {
+    port?: number;
+    host?: string;
+  };
+  /** Ralph loop configuration */
+  ralph?: {
+    worktreesDir: string;
+    repoUrl: string;
+    baseBranch?: string;
+  };
+  /** AI configuration */
+  ai?: {
+    model?: string;
+    temperature?: number;
+    maxTokens?: number;
+  };
+  /** Node identity */
+  node?: {
+    name: string;
+    hostname?: string;
+  };
+}
+
+export interface StackState {
+  started: Date;
+  channels: {
+    ssh: boolean;
+    telegram: boolean;
+  };
+  api: {
+    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;
+}
+
+// ============================================================
+// Stack Class
+// ============================================================
+
+export class Stack {
+  private config: Required<StackConfig>;
+  private state: StackState;
+  private router: ReturnType<typeof createChannelRouter>;
+  private memory: ReturnType<typeof createPermissionMemory>;
+  private client: GLMClient;
+  private executor: ToolExecutor;
+  private channels: Map<string, ChannelConnector> = new Map();
+  private abortController: AbortController | null = null;
+
+  constructor(config: StackConfig) {
+    this.config = {
+      ssh: config.ssh ?? { chatDir: "/root/.ssh-chat" },
+      telegram: config.telegram ?? {},
+      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" },
+    };
+
+    this.state = {
+      started: new Date(),
+      channels: { ssh: false, telegram: false },
+      api: { enabled: !!this.config.api },
+      ralphLoops: new Map(),
+    };
+
+    // Initialize shared memory
+    this.memory = createPermissionMemory({
+      channels: {
+        ssh: { memoryFile: `${this.config.ssh.chatDir}/memory.json`, maxMessages: 50 },
+        telegram: { memoryFile: "/root/.telegram-memory.json", maxMessages: 50 },
+        api: { memoryFile: "/root/.api-memory.json", maxMessages: 100 },
+      },
+      permissions: {
+        ssh: { canRead: ["telegram", "api"] },
+        telegram: { canRead: ["ssh", "api"] },
+        api: { canRead: ["ssh", "telegram"] },
+      },
+    });
+
+    // Initialize router
+    this.router = createChannelRouter({
+      announcement: {
+        serverName: this.config.node.name,
+        hostname: this.config.node.hostname,
+        packageName: "@ebowwa/stack",
+        version: "0.1.0",
+      },
+    });
+
+    // Initialize AI
+    this.client = new GLMClient();
+    this.executor = new ToolExecutor(this.client, [...BUILTIN_TOOLS]);
+  }
+
+  // ============================================================
+  // Channel Registration
+  // ============================================================
+
+  async registerSSH(): Promise<void> {
+    if (!this.config.ssh) return;
+
+    console.log("[Stack] Registering SSH channel...");
+    const { createSSHChannel } = await import("@ebowwa/channel-ssh");
+    const channel = createSSHChannel({
+      chatDir: this.config.ssh.chatDir,
+      pollInterval: this.config.ssh.pollInterval ?? 500,
+    });
+    this.channels.set("ssh", channel);
+    this.router.register(channel);
+    this.state.channels.ssh = true;
+    console.log("[Stack] SSH registered");
+  }
+
+  async registerTelegram(): Promise<void> {
+    if (!this.config.telegram?.botToken) {
+      console.log("[Stack] Telegram not configured");
+      return;
+    }
+
+    console.log("[Stack] Registering Telegram channel...");
+    const { TelegramChannel } = await import("@ebowwa/channel-telegram");
+    const channel = new TelegramChannel({
+      botToken: this.config.telegram.botToken,
+      allowedChats: this.config.telegram.allowedChats,
+    });
+    this.channels.set("telegram", channel);
+    this.router.register(channel);
+    this.state.channels.telegram = true;
+    console.log("[Stack] Telegram registered");
+  }
+
+  // ============================================================
+  // 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 text = message.text;
+
+    console.log(`[${channel}] ${text.slice(0, 50)}...`);
+
+    // Check for memory commands
+    const cmdResult = parseMemoryCommand(this.memory, channel, text);
+    if (cmdResult.handled) {
+      return {
+        content: { text: cmdResult.response || "Done" },
+        replyTo: { messageId: message.messageId, channelId: message.channelId },
+      };
+    }
+
+    // Check for Ralph commands
+    const ralphResult = await this.handleRalphCommand(channel, text);
+    if (ralphResult) {
+      return {
+        content: { text: ralphResult },
+        replyTo: { messageId: message.messageId, channelId: message.channelId },
+      };
+    }
+
+    // Add to shared memory
+    this.memory.addMessage(channel, { role: "user", content: text });
+
+    // Build messages with cross-channel context
+    const llmMessages = this.memory.buildLLMMessages(
+      channel,
+      this.buildSystemPrompt(),
+      text,
+      { crossChannelLimit: 10 }
+    );
+
+    // Execute with tools
+    try {
+      const result = await this.executor.executeWithTools(llmMessages, {
+        systemPrompt: this.buildSystemPrompt(),
+        maxIterations: 3,
+        temperature: this.config.ai.temperature,
+        maxTokens: this.config.ai.maxTokens,
+      });
+
+      this.memory.addMessage(channel, { role: "assistant", content: result.content });
+
+      return {
+        content: { text: result.content },
+        replyTo: { messageId: message.messageId, channelId: message.channelId },
+      };
+    } catch (error) {
+      const errorMsg = error instanceof Error ? error.message : String(error);
+      return {
+        content: { text: `Error: ${errorMsg}` },
+        replyTo: { messageId: message.messageId, channelId: message.channelId },
+      };
+    }
+  }
+
+  private buildSystemPrompt(): string {
+    return `You are **${this.config.node.name}** — a 24/7 AI stack running on this node.
+
+## 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
+
+## 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
+- Node: ${this.config.node.name}
+- Channels: ${Object.entries(this.state.channels).filter(([, v]) => v).map(([k]) => k).join(", ") || "none"}
+- 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}`,
+      `Uptime: ${Math.floor((Date.now() - this.state.started.getTime()) / 1000)}s`,
+    ];
+    return lines.join("\n");
+  }
+
+  // ============================================================
+  // HTTP API (optional, delegates to node-agent)
+  // ============================================================
+
+  private startAPI(): void {
+    if (!this.config.api) return;
+
+    const port = this.config.api.port ?? 8911;
+    console.log(`[Stack] API would start on :${port} (implement with Bun.serve)`);
+
+    // TODO: Start HTTP server with routes:
+    // GET /api/status - Stack status
+    // GET /api/ralph-loops - List Ralph loops
+    // POST /api/ralph-loops - Start Ralph loop
+    // DELETE /api/ralph-loops/:id - Stop Ralph loop
+  }
+
+  // ============================================================
+  // Lifecycle
+  // ============================================================
+
+  async start(): Promise<void> {
+    console.log(`[Stack] Starting ${this.config.node.name}...`);
+
+    this.abortController = new AbortController();
+
+    // 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!");
+    console.log(`  - SSH: echo 'msg' > ${this.config.ssh.chatDir}/in`);
+    if (this.state.channels.telegram) {
+      console.log("  - Telegram: enabled");
+    }
+    console.log("  - Commands: /ralph start|list|stop, /status, /memory <cmd>");
+
+    // Keep running
+    await new Promise(() => {}); // Run forever
+  }
+
+  async stop(): Promise<void> {
+    console.log("[Stack] Stopping...");
+    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();
+    }
+
+    console.log("[Stack] Stopped");
+  }
+}
+
+// ============================================================
+// CLI Entry Point
+// ============================================================
+
+async function main() {
+  const stack = new Stack({
+    ssh: {
+      chatDir: process.env.SSH_CHAT_DIR || "/root/.ssh-chat",
+      pollInterval: 500,
+    },
+    telegram: {
+      botToken: process.env.TELEGRAM_BOT_TOKEN,
+      allowedChats: process.env.TELEGRAM_CHAT_ID ? [parseInt(process.env.TELEGRAM_CHAT_ID, 10)] : undefined,
+    },
+    api: {
+      port: parseInt(process.env.API_PORT || "8911", 10),
+    },
+    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",
+    },
+  });
+
+  // Handle shutdown
+  process.on("SIGINT", async () => {
+    await stack.stop();
+    process.exit(0);
+  });
+
+  process.on("SIGTERM", async () => {
+    await stack.stop();
+    process.exit(0);
+  });
+
+  await stack.start();
+}
+
+// Run if executed directly
+if (import.meta.main) {
+  main().catch((error) => {
+    console.error("[Stack] Fatal error:", error);
+    process.exit(1);
+  });
+}
+
+export default Stack;