@ebowwa/channel-ssh 1.1.3 → 2.1.0

package/dist/index.js

@@ -1,386 +1,346 @@
-#!/usr/bin/env bun
-// @bun
-
-// src/index.ts
-import { execSync } from "child_process";
-import { existsSync, readFileSync, writeFileSync, mkdirSync, watch } from "fs";
+/**
+ * @ebowwa/channel-ssh
+ *
+ * SSH channel adapter implementing ChannelConnector.
+ *
+ * This package handles:
+ * - File-based IPC (reads from ~/.ssh-chat/in, writes to ~/.ssh-chat/out)
+ * - Status tracking (~/.ssh-chat/status)
+ * - Message normalization to ChannelMessage format
+ *
+ * Intelligence (GLM, tools, memory) can be provided by:
+ * 1. This package (standalone mode with built-in echo handler)
+ * 2. External daemon/consumer (adapter mode via onMessage handler)
+ *
+ * Usage:
+ *   Write message: echo "your message" > ~/.ssh-chat/in
+ *   Read response: cat ~/.ssh-chat/out
+ *   Check status: cat ~/.ssh-chat/status
+ */
+import { existsSync, readFileSync, watch, writeFileSync, mkdirSync } from "fs";
 import { homedir } from "os";
 import { join } from "path";
-function requireEnv(name) {
-  const value = process.env[name];
-  if (!value) {
-    throw new Error(`Missing required environment variable: ${name}`);
-  }
-  return value;
+import { createChannelId, } from "@ebowwa/channel-types";
+export function createSSHConfigFromEnv() {
+    return {
+        chatDir: process.env.SSH_CHAT_DIR,
+        pollInterval: process.env.SSH_POLL_INTERVAL
+            ? parseInt(process.env.SSH_POLL_INTERVAL, 10)
+            : undefined,
+        memoryLimit: process.env.SSH_MEMORY_LIMIT
+            ? parseInt(process.env.SSH_MEMORY_LIMIT, 10)
+            : undefined,
+        contextLimit: process.env.SSH_CONTEXT_LIMIT
+            ? parseInt(process.env.SSH_CONTEXT_LIMIT, 10)
+            : undefined,
+    };
 }
-function requireEnvInt(name) {
-  return parseInt(requireEnv(name), 10);
-}
-function requireEnvFloat(name) {
-  return parseFloat(requireEnv(name));
-}
-var CONFIG = {
-  chatDir: process.env.SSH_CHAT_DIR ?? join(homedir(), ".ssh-chat"),
-  model: requireEnv("GLM_MODEL"),
-  maxRetries: requireEnvInt("GLM_MAX_RETRIES"),
-  timeout: requireEnvInt("GLM_TIMEOUT_MS"),
-  temperature: requireEnvFloat("GLM_TEMPERATURE"),
-  maxTokens: requireEnvInt("GLM_MAX_TOKENS"),
-  pollInterval: requireEnvInt("SSH_CHAT_POLL_MS"),
-  memoryLimit: requireEnvInt("SSH_CHAT_MEMORY_LIMIT"),
-  contextLimit: requireEnvInt("SSH_CHAT_CONTEXT_LIMIT")
-};
-var IN_FILE = join(CONFIG.chatDir, "in");
-var OUT_FILE = join(CONFIG.chatDir, "out");
-var STATUS_FILE = join(CONFIG.chatDir, "status");
-var MEMORY_FILE = join(CONFIG.chatDir, "memory.json");
-function ensureDir() {
-  if (!existsSync(CONFIG.chatDir)) {
-    mkdirSync(CONFIG.chatDir, { recursive: true });
-  }
-}
-function setStatus(status) {
-  writeFileSync(STATUS_FILE, JSON.stringify({ status, timestamp: Date.now() }));
-}
-function writeOutput(text) {
-  const timestamp = new Date().toISOString();
-  writeFileSync(OUT_FILE, `[${timestamp}]
-${text}
-`);
-}
-
-class ConversationMemory {
-  file;
-  messages = [];
-  maxMessages;
-  constructor(file, maxMessages = CONFIG.memoryLimit) {
-    this.file = file;
-    this.maxMessages = maxMessages;
-    this.load();
-  }
-  load() {
-    try {
-      if (existsSync(this.file)) {
-        const data = JSON.parse(readFileSync(this.file, "utf-8"));
-        this.messages = data.messages || [];
-      }
-    } catch {
-      this.messages = [];
+export class ConversationMemory {
+    messages = [];
+    maxMessages;
+    file;
+    constructor(file, maxMessages = 100) {
+        this.file = file;
+        this.maxMessages = maxMessages;
+        this.load();
+    }
+    load() {
+        try {
+            if (existsSync(this.file)) {
+                const data = JSON.parse(readFileSync(this.file, "utf-8"));
+                this.messages = data.messages || [];
+            }
+        }
+        catch {
+            this.messages = [];
+        }
     }
-  }
-  save() {
-    try {
-      writeFileSync(this.file, JSON.stringify({ messages: this.messages }, null, 2));
-    } catch (e) {
-      console.error("Failed to save memory:", e);
+    save() {
+        try {
+            writeFileSync(this.file, JSON.stringify({ messages: this.messages }, null, 2));
+        }
+        catch (e) {
+            console.error("Failed to save memory:", e);
+        }
     }
-  }
-  add(role, content) {
-    this.messages.push({ role, content, timestamp: Date.now() });
-    if (this.messages.length > this.maxMessages) {
-      this.messages = this.messages.slice(-this.maxMessages);
+    add(role, content) {
+        this.messages.push({ role, content, timestamp: Date.now() });
+        if (this.messages.length > this.maxMessages) {
+            this.messages = this.messages.slice(-this.maxMessages);
+        }
+        this.save();
+    }
+    getContext(limit = 20) {
+        return this.messages.slice(-limit);
+    }
+    clear() {
+        this.messages = [];
+        this.save();
     }
-    this.save();
-  }
-  getContext(limit = 20) {
-    return this.messages.slice(-limit);
-  }
-  clear() {
-    this.messages = [];
-    this.save();
-  }
 }
-var TOOLS = [
-  {
-    name: "read_file",
-    description: "Read a file from the filesystem.",
-    parameters: {
-      type: "object",
-      properties: { path: { type: "string", description: "File path to read" } },
-      required: ["path"]
-    },
-    handler: async (args) => {
-      const path = args.path;
-      try {
-        if (!existsSync(path))
-          return `File not found: ${path}`;
-        const content = readFileSync(path, "utf-8");
-        return content.length > 4000 ? content.slice(0, 4000) + `
-...[truncated]` : content;
-      } catch (e) {
-        return `Error: ${e.message}`;
-      }
+// ============================================================
+// SSH CHANNEL
+// ============================================================
+export class SSHChannel {
+    id;
+    label = "SSH";
+    capabilities = {
+        supports: {
+            text: true,
+            media: false,
+            replies: false,
+            threads: false,
+            reactions: false,
+            editing: false,
+            streaming: false,
+        },
+        rateLimits: {
+            messagesPerMinute: 120,
+            charactersPerMessage: 100000,
+        },
+    };
+    config;
+    memory;
+    messageHandler;
+    connected = false;
+    watcher;
+    pollInterval;
+    lastContent = "";
+    messageCounter = 0;
+    // File paths
+    IN_FILE;
+    OUT_FILE;
+    STATUS_FILE;
+    MEMORY_FILE;
+    constructor(config = {}) {
+        this.config = {
+            chatDir: config.chatDir ?? join(homedir(), ".ssh-chat"),
+            pollInterval: config.pollInterval ?? 500,
+            memoryLimit: config.memoryLimit ?? 100,
+            contextLimit: config.contextLimit ?? 20,
+        };
+        this.id = createChannelId("ssh", "default");
+        this.IN_FILE = join(this.config.chatDir, "in");
+        this.OUT_FILE = join(this.config.chatDir, "out");
+        this.STATUS_FILE = join(this.config.chatDir, "status");
+        this.MEMORY_FILE = join(this.config.chatDir, "memory.json");
+        this.memory = new ConversationMemory(this.MEMORY_FILE, this.config.memoryLimit);
     }
-  },
-  {
-    name: "write_file",
-    description: "Write content to a file.",
-    parameters: {
-      type: "object",
-      properties: {
-        path: { type: "string" },
-        content: { type: "string" }
-      },
-      required: ["path", "content"]
-    },
-    handler: async (args) => {
-      try {
-        writeFileSync(args.path, args.content);
-        return `Wrote ${args.content.length} bytes to ${args.path}`;
-      } catch (e) {
-        return `Error: ${e.message}`;
-      }
+    // ============================================================
+    // ChannelConnector Implementation
+    // ============================================================
+    async start() {
+        console.log("[SSHChannel] Starting...");
+        // Ensure directory exists
+        this.ensureDir();
+        // Create empty files if they don't exist
+        if (!existsSync(this.IN_FILE))
+            writeFileSync(this.IN_FILE, "");
+        if (!existsSync(this.OUT_FILE))
+            writeFileSync(this.OUT_FILE, "Ready. Send a message.\n");
+        this.setStatus("idle");
+        // Setup file watcher
+        this.watcher = watch(this.config.chatDir, (eventType, filename) => {
+            if (filename === "in" && eventType === "change") {
+                this.processIncoming();
+            }
+        });
+        // Setup polling as backup (watch can be unreliable)
+        this.pollInterval = setInterval(() => {
+            try {
+                const content = readFileSync(this.IN_FILE, "utf-8").trim();
+                if (content && content !== this.lastContent) {
+                    this.processIncoming();
+                }
+            }
+            catch { }
+        }, this.config.pollInterval);
+        this.connected = true;
+        console.log("[SSHChannel] Started");
+        console.log(`  IN_FILE:  ${this.IN_FILE}`);
+        console.log(`  OUT_FILE: ${this.OUT_FILE}`);
+        console.log(`  STATUS:   ${this.STATUS_FILE}`);
     }
-  },
-  {
-    name: "run_command",
-    description: "Execute a shell command.",
-    parameters: {
-      type: "object",
-      properties: {
-        command: { type: "string" },
-        cwd: { type: "string" }
-      },
-      required: ["command"]
-    },
-    handler: async (args) => {
-      const cmd = args.command;
-      const blocked = ["rm -rf", "mkfs", "dd if=", "> /dev/"];
-      if (blocked.some((b) => cmd.includes(b)))
-        return "Blocked: dangerous command";
-      try {
-        const result = execSync(cmd, { timeout: 1e4, cwd: args.cwd || process.cwd() });
-        return result.toString() || "(no output)";
-      } catch (e) {
-        return e.stdout?.toString() || e.message;
-      }
+    async stop() {
+        console.log("[SSHChannel] Stopping...");
+        if (this.watcher) {
+            this.watcher.close();
+            this.watcher = undefined;
+        }
+        if (this.pollInterval) {
+            clearInterval(this.pollInterval);
+            this.pollInterval = undefined;
+        }
+        this.connected = false;
+        console.log("[SSHChannel] Stopped");
     }
-  },
-  {
-    name: "git_status",
-    description: "Check git repository status.",
-    parameters: { type: "object", properties: { cwd: { type: "string" } } },
-    handler: async (args) => {
-      const cwd = args.cwd || process.cwd();
-      try {
-        const status = execSync("git status 2>&1", { cwd }).toString();
-        const branch = execSync("git branch --show-current 2>&1", { cwd }).toString();
-        return `Branch: ${branch}
-
-${status}`;
-      } catch (e) {
-        return `Error: ${e.message}`;
-      }
+    /**
+     * Set the message handler. The daemon/consumer provides intelligence.
+     */
+    onMessage(handler) {
+        this.messageHandler = handler;
     }
-  },
-  {
-    name: "system_info",
-    description: "Get system resource info.",
-    parameters: { type: "object", properties: {} },
-    handler: async () => {
-      try {
-        const cpu = execSync('nproc 2>/dev/null || echo "unknown"').toString().trim();
-        const mem = execSync('free -h 2>/dev/null | grep Mem || echo "unknown"').toString().trim();
-        const disk = execSync('df -h / 2>/dev/null | tail -1 || echo "unknown"').toString().trim();
-        return `CPU: ${cpu} cores
-Memory: ${mem}
-Disk: ${disk}`;
-      } catch (e) {
-        return `Error: ${e.message}`;
-      }
+    /**
+     * Send a response back to SSH channel (writes to OUT_FILE).
+     */
+    async send(response) {
+        const text = response.content.text;
+        const timestamp = new Date().toISOString();
+        writeFileSync(this.OUT_FILE, `[${timestamp}]\n${text}\n`);
+        // Store in memory
+        this.memory.add("assistant", text);
     }
-  }
-];
-function getGLMTools() {
-  return TOOLS.map((t) => ({
-    type: "function",
-    function: { name: t.name, description: t.description, parameters: t.parameters }
-  }));
-}
-async function executeTool(name, args) {
-  const tool = TOOLS.find((t) => t.name === name);
-  if (tool)
-    return tool.handler(args);
-  return `Unknown tool: ${name}`;
-}
-var GLM_API_ENDPOINT = "https://api.z.ai/api/coding/paas/v4/chat/completions";
-function getAPIKey() {
-  const envKey = process.env.ZAI_API_KEY || process.env.Z_AI_API_KEY || process.env.GLM_API_KEY;
-  if (envKey)
-    return envKey;
-  const keysJson = process.env.ZAI_API_KEYS || process.env.Z_AI_API_KEYS;
-  if (keysJson) {
-    try {
-      const keys = JSON.parse(keysJson);
-      if (Array.isArray(keys) && keys.length > 0) {
-        return keys[Math.floor(Math.random() * keys.length)];
-      }
-    } catch {}
-  }
-  throw new Error("No API key found. Set ZAI_API_KEY env var.");
-}
-function sleep(ms) {
-  return new Promise((resolve) => setTimeout(resolve, ms));
-}
-function calculateBackoff(retryCount) {
-  return Math.min(1000 * Math.pow(2, retryCount), 1e4);
-}
-async function callGLM(messages, retryCount = 0) {
-  const apiKey = getAPIKey();
-  try {
-    const controller = new AbortController;
-    const timeoutId = setTimeout(() => controller.abort(), CONFIG.timeout);
-    const response = await fetch(GLM_API_ENDPOINT, {
-      method: "POST",
-      headers: {
-        "Content-Type": "application/json",
-        Authorization: `Bearer ${apiKey}`
-      },
-      signal: controller.signal,
-      body: JSON.stringify({
-        model: CONFIG.model,
-        messages: messages.map((m) => ({ role: m.role, content: m.content })),
-        tools: getGLMTools(),
-        temperature: CONFIG.temperature,
-        max_tokens: CONFIG.maxTokens
-      })
-    });
-    clearTimeout(timeoutId);
-    if (!response.ok) {
-      const text = await response.text();
-      if ((response.status === 429 || response.status >= 500) && retryCount < CONFIG.maxRetries) {
-        const backoff = calculateBackoff(retryCount);
-        console.log(`GLM API error ${response.status}, retrying in ${backoff}ms (${retryCount + 1}/${CONFIG.maxRetries})`);
-        await sleep(backoff);
-        return callGLM(messages, retryCount + 1);
-      }
-      throw new Error(`GLM API error: ${response.status} - ${text}`);
+    isConnected() {
+        return this.connected;
     }
-    const data = await response.json();
-    const choice = data.choices?.[0];
-    if (!choice) {
-      throw new Error("No response from GLM");
+    // ============================================================
+    // Public Helpers
+    // ============================================================
+    /**
+     * Get the conversation memory.
+     */
+    getMemory() {
+        return this.memory;
     }
-    if (choice.message?.tool_calls && choice.message.tool_calls.length > 0) {
-      const toolResults = [];
-      for (const tc of choice.message.tool_calls) {
-        const toolName = tc.function?.name;
-        const toolArgs = tc.function?.arguments ? JSON.parse(tc.function.arguments) : {};
-        const result = await executeTool(toolName, toolArgs);
-        toolResults.push(`[${toolName}]: ${result}`);
-      }
-      const updatedMessages = [
-        ...messages,
-        { role: "assistant", content: choice.message.content || "", timestamp: Date.now() },
-        { role: "user", content: `Tool results:
-${toolResults.join(`
-`)}`, timestamp: Date.now() }
-      ];
-      return callGLM(updatedMessages, 0);
+    /**
+     * Get the input file path.
+     */
+    getInFile() {
+        return this.IN_FILE;
     }
-    return choice.message?.content || "(no response)";
-  } catch (error) {
-    if (error instanceof Error && (error.name === "AbortError" || error.message.includes("fetch")) && retryCount < CONFIG.maxRetries) {
-      const backoff = calculateBackoff(retryCount);
-      console.log(`Network error, retrying in ${backoff}ms (${retryCount + 1}/${CONFIG.maxRetries})`);
-      await sleep(backoff);
-      return callGLM(messages, retryCount + 1);
+    /**
+     * Get the output file path.
+     */
+    getOutFile() {
+        return this.OUT_FILE;
     }
-    throw error;
-  }
-}
-async function processMessage(input, memory) {
-  if (input.startsWith("/")) {
-    if (input === "/clear") {
-      memory.clear();
-      return "Memory cleared.";
+    /**
+     * Get the status file path.
+     */
+    getStatusFile() {
+        return this.STATUS_FILE;
     }
-    if (input === "/help") {
-      return `Commands:
-/clear - Clear conversation memory
-/help - Show this help
-/status - Show system status
-
-Just type a message to chat with AI.`;
+    // ============================================================
+    // Internal Methods
+    // ============================================================
+    ensureDir() {
+        if (!existsSync(this.config.chatDir)) {
+            mkdirSync(this.config.chatDir, { recursive: true });
+        }
     }
-    if (input === "/status") {
-      return `Status: running
-Memory file: ${MEMORY_FILE}
-Chat dir: ${CONFIG.chatDir}`;
+    setStatus(status) {
+        writeFileSync(this.STATUS_FILE, JSON.stringify({ status, timestamp: Date.now() }));
     }
-    return `Unknown command: ${input}. Type /help for available commands.`;
-  }
-  memory.add("user", input);
-  const messages = memory.getContext(CONFIG.contextLimit);
-  return await callGLM(messages);
-}
-async function main() {
-  console.log("SSH Chat Channel starting...");
-  console.log(`Chat dir: ${CONFIG.chatDir}`);
-  console.log(`Memory: ${MEMORY_FILE}`);
-  console.log("");
-  console.log("Usage:");
-  console.log(`  Write message: echo "your message" > ${IN_FILE}`);
-  console.log(`  Read response: cat ${OUT_FILE}`);
-  console.log("");
-  ensureDir();
-  try {
-    getAPIKey();
-    console.log("GLM client initialized with retry support");
-  } catch (e) {
-    console.error("Failed to initialize GLM client:", e.message);
-    process.exit(1);
-  }
-  const memory = new ConversationMemory(MEMORY_FILE);
-  memory.add("system", `You are an AI assistant accessible via SSH.
-You are helpful, concise, and can execute tools to help the user.
-This is a private SSH channel separate from any Telegram or other chat interfaces.`);
-  if (!existsSync(IN_FILE))
-    writeFileSync(IN_FILE, "");
-  if (!existsSync(OUT_FILE))
-    writeFileSync(OUT_FILE, `Ready. Send a message.
-`);
-  setStatus("idle");
-  let lastContent = "";
-  console.log("Watching for messages...");
-  const watcher = watch(CONFIG.chatDir, (eventType, filename) => {
-    if (filename === "in" && eventType === "change") {
-      processIncoming();
+    async processIncoming() {
+        try {
+            const content = readFileSync(this.IN_FILE, "utf-8").trim();
+            // Skip if same as last or empty
+            if (!content || content === this.lastContent)
+                return;
+            this.lastContent = content;
+            this.setStatus("processing");
+            console.log(`[SSHChannel] Processing: ${content.slice(0, 50)}...`);
+            // Clear input file after reading
+            writeFileSync(this.IN_FILE, "");
+            // Create normalized message
+            const message = this.createChannelMessage(content);
+            // Store in memory
+            this.memory.add("user", content);
+            // Route to handler if set
+            if (this.messageHandler) {
+                try {
+                    const response = await this.messageHandler(message);
+                    if (response) {
+                        await this.send(response);
+                    }
+                }
+                catch (error) {
+                    console.error("[SSHChannel] Handler error:", error);
+                    writeFileSync(this.OUT_FILE, `[${new Date().toISOString()}]\nError: ${error.message}\n`);
+                    this.setStatus("error");
+                    return;
+                }
+            }
+            else {
+                // No handler - echo mode
+                await this.send({
+                    content: { text: `Echo: ${content}` },
+                    replyTo: { messageId: message.messageId, channelId: message.channelId },
+                });
+            }
+            this.setStatus("idle");
+            console.log("[SSHChannel] Response sent");
+        }
+        catch (error) {
+            console.error("[SSHChannel] Error:", error);
+            this.setStatus("error");
+        }
     }
-  });
-  async function processIncoming() {
-    try {
-      const content = readFileSync(IN_FILE, "utf-8").trim();
-      if (!content || content === lastContent)
-        return;
-      lastContent = content;
-      setStatus("processing");
-      console.log(`[${new Date().toISOString()}] Processing: ${content.slice(0, 50)}...`);
-      writeFileSync(IN_FILE, "");
-      const response = await processMessage(content, memory);
-      writeOutput(response);
-      memory.add("assistant", response);
-      setStatus("idle");
-      console.log(`[${new Date().toISOString()}] Response sent`);
-    } catch (error) {
-      console.error("Error:", error);
-      setStatus("error");
-      writeOutput(`Error: ${error.message}`);
+    /**
+     * Normalize SSH input to ChannelMessage format.
+     */
+    createChannelMessage(text) {
+        this.messageCounter++;
+        const messageId = `ssh-${Date.now()}-${this.messageCounter}`;
+        const sender = {
+            id: "ssh-user",
+            username: "ssh",
+            displayName: "SSH User",
+            isBot: false,
+        };
+        const context = {
+            isDM: true,
+            metadata: {
+                source: "file-ipc",
+                chatDir: this.config.chatDir,
+            },
+        };
+        return {
+            messageId,
+            channelId: this.id,
+            timestamp: new Date(),
+            sender,
+            text,
+            context,
+        };
     }
-  }
-  setInterval(() => {
-    try {
-      const content = readFileSync(IN_FILE, "utf-8").trim();
-      if (content && content !== lastContent) {
-        processIncoming();
-      }
-    } catch {}
-  }, CONFIG.pollInterval);
-  process.on("SIGINT", () => {
-    console.log(`
-Shutting down...`);
-    watcher.close();
-    process.exit(0);
-  });
 }
-main().catch(console.error);
+// ============================================================
+// FACTORY
+// ============================================================
+export function createSSHChannel(config) {
+    return new SSHChannel(config);
+}
+// ============================================================
+// MAIN ENTRY POINT (for standalone testing)
+// ============================================================
+async function main() {
+    const config = createSSHConfigFromEnv();
+    const channel = createSSHChannel(config);
+    // Example: Echo handler for testing
+    channel.onMessage(async (msg) => {
+        console.log(`Received: ${msg.text}`);
+        return {
+            content: { text: `Echo: ${msg.text}` },
+            replyTo: { messageId: msg.messageId, channelId: msg.channelId },
+        };
+    });
+    process.on("SIGINT", async () => {
+        await channel.stop();
+        process.exit(0);
+    });
+    process.on("SIGTERM", async () => {
+        await channel.stop();
+        process.exit(0);
+    });
+    await channel.start();
+}
+// Only run main when executed directly (not when imported)
+if (import.meta.main) {
+    main().catch(console.error);
+}
+// ============================================================
+// PLUGIN SYSTEM
+// ============================================================
+export { createSSHPlugin, sshPlugin } from "./plugin.js";
+//# sourceMappingURL=index.js.map