@ebowwa/channel-ssh 1.0.2 → 1.1.0

package/dist/index.js

@@ -2,19 +2,41 @@
 // @bun
 
 // src/index.ts
-import { execSync } from "child_process";
 import { existsSync, readFileSync, writeFileSync, mkdirSync, watch } from "fs";
 import { homedir } from "os";
 import { join } from "path";
-var GLM_API_ENDPOINT = "https://api.z.ai/api/coding/paas/v4/chat/completions";
-var CHAT_DIR = process.env.SSH_CHAT_DIR || join(homedir(), ".ssh-chat");
-var IN_FILE = join(CHAT_DIR, "in");
-var OUT_FILE = join(CHAT_DIR, "out");
-var STATUS_FILE = join(CHAT_DIR, "status");
-var MEMORY_FILE = join(CHAT_DIR, "memory.json");
+import { GLMClient, GLMRateLimitError, GLMTimeoutError, GLMNetworkError } from "@ebowwa/ai";
+function requireEnv(name) {
+  const value = process.env[name];
+  if (!value) {
+    throw new Error(`Missing required environment variable: ${name}`);
+  }
+  return value;
+}
+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(CHAT_DIR)) {
-    mkdirSync(CHAT_DIR, { recursive: true });
+  if (!existsSync(CONFIG.chatDir)) {
+    mkdirSync(CONFIG.chatDir, { recursive: true });
   }
 }
 function setStatus(status) {
@@ -31,7 +53,7 @@ class ConversationMemory {
   file;
   messages = [];
   maxMessages;
-  constructor(file, maxMessages = 50) {
+  constructor(file, maxMessages = CONFIG.memoryLimit) {
     this.file = file;
     this.maxMessages = maxMessages;
     this.load();
@@ -68,180 +90,42 @@ class ConversationMemory {
     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}`;
-      }
-    }
-  },
-  {
-    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}`;
-      }
-    }
-  },
-  {
-    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;
-      }
-    }
-  },
-  {
-    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}`;
-      }
-    }
-  },
-  {
-    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}`;
-      }
-    }
-  }
-];
-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}`;
-}
-function getAPIKey() {
-  const envKey = process.env.ZAI_API_KEY || process.env.GLM_API_KEY;
-  if (envKey)
-    return envKey;
-  const keysJson = process.env.ZAI_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 {}
+var glmClient = null;
+function getClient() {
+  if (!glmClient) {
+    glmClient = new GLMClient;
   }
-  throw new Error("No API key found. Set ZAI_API_KEY env var.");
+  return glmClient;
 }
 async function callGLM(messages) {
-  const apiKey = getAPIKey();
-  const response = await fetch(GLM_API_ENDPOINT, {
-    method: "POST",
-    headers: {
-      "Content-Type": "application/json",
-      Authorization: `Bearer ${apiKey}`
-    },
-    body: JSON.stringify({
-      model: "glm-4-plus",
-      messages: messages.map((m) => ({ role: m.role, content: m.content })),
-      tools: getGLMTools(),
-      temperature: 0.7,
-      max_tokens: 4096
-    })
-  });
-  if (!response.ok) {
-    const text = await response.text();
-    throw new Error(`GLM API error: ${response.status} - ${text}`);
-  }
-  const data = await response.json();
-  const choice = data.choices?.[0];
-  if (!choice) {
-    throw new Error("No response from GLM");
-  }
-  if (choice.message?.tool_calls) {
-    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 client = getClient();
+  try {
+    const response = await client.chatCompletion(messages.map((m) => ({ role: m.role, content: m.content })), {
+      model: CONFIG.model,
+      temperature: CONFIG.temperature,
+      maxTokens: CONFIG.maxTokens,
+      maxRetries: CONFIG.maxRetries,
+      timeout: CONFIG.timeout
+    });
+    return response.choices[0]?.message?.content || "(no response)";
+  } catch (error) {
+    if (error instanceof GLMRateLimitError) {
+      throw new Error(`Rate limit exceeded after ${CONFIG.maxRetries} retries. Please try again later or check API credits.`);
     }
-    messages.push({ role: "assistant", content: "", timestamp: Date.now() });
-    messages.push({ role: "user", content: `Tool results:
-${toolResults.join(`
-`)}`, timestamp: Date.now() });
-    return callGLM(messages);
+    if (error instanceof GLMTimeoutError) {
+      throw new Error(`Request timed out after ${CONFIG.maxRetries} retries.`);
+    }
+    if (error instanceof GLMNetworkError) {
+      throw new Error(`Network error after ${CONFIG.maxRetries} retries: ${error.message}`);
+    }
+    throw error;
   }
-  return choice.message?.content || "(no response)";
 }
 async function processMessage(input, memory) {
   if (input.startsWith("/")) {
     if (input === "/clear") {
       memory.clear();
-      return "\uD83D\uDDD1\uFE0F Memory cleared.";
+      return "Memory cleared.";
     }
     if (input === "/help") {
       return `Commands:
@@ -254,17 +138,17 @@ Just type a message to chat with AI.`;
     if (input === "/status") {
       return `Status: running
 Memory file: ${MEMORY_FILE}
-Chat dir: ${CHAT_DIR}`;
+Chat dir: ${CONFIG.chatDir}`;
     }
     return `Unknown command: ${input}. Type /help for available commands.`;
   }
   memory.add("user", input);
-  const messages = memory.getContext(20);
+  const messages = memory.getContext(CONFIG.contextLimit);
   return await callGLM(messages);
 }
 async function main() {
-  console.log("\uD83E\uDD16 SSH Chat Channel starting...");
-  console.log(`Chat dir: ${CHAT_DIR}`);
+  console.log("SSH Chat Channel starting...");
+  console.log(`Chat dir: ${CONFIG.chatDir}`);
   console.log(`Memory: ${MEMORY_FILE}`);
   console.log("");
   console.log("Usage:");
@@ -272,6 +156,13 @@ async function main() {
   console.log(`  Read response: cat ${OUT_FILE}`);
   console.log("");
   ensureDir();
+  try {
+    getClient();
+    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.
@@ -284,7 +175,7 @@ This is a private SSH channel separate from any Telegram or other chat interface
   setStatus("idle");
   let lastContent = "";
   console.log("Watching for messages...");
-  const watcher = watch(CHAT_DIR, (eventType, filename) => {
+  const watcher = watch(CONFIG.chatDir, (eventType, filename) => {
     if (filename === "in" && eventType === "change") {
       processIncoming();
     }
@@ -316,7 +207,7 @@ This is a private SSH channel separate from any Telegram or other chat interface
         processIncoming();
       }
     } catch {}
-  }, 500);
+  }, CONFIG.pollInterval);
   process.on("SIGINT", () => {
     console.log(`
 Shutting down...`);

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@ebowwa/channel-ssh",
-  "version": "1.0.2",
-  "description": "SSH tmux channel for GLM Daemon - separate from Telegram",
+  "version": "1.1.0",
+  "description": "SSH chat channel for GLM AI - configurable via environment variables",
   "type": "module",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",
@@ -9,13 +9,12 @@
     "channel-ssh": "./dist/index.js"
   },
   "scripts": {
-    "build": "bun build src/index.ts --outdir dist --target bun --external '@ebowwa/*' --external 'node-telegram-bot-api'",
+    "build": "bun build src/index.ts --outdir dist --target bun --external '@ebowwa/*'",
     "dev": "bun run src/index.ts",
     "prepublishOnly": "bun run build"
   },
   "dependencies": {
-    "@ebowwa/structured-prompts": "^0.3.2",
-    "@ebowwa/terminal": "^0.3.0"
+    "@ebowwa/ai": "^0.1.0"
   },
   "devDependencies": {
     "@types/bun": "latest",
@@ -23,7 +22,6 @@
   },
   "keywords": [
     "ssh",
-    "tmux",
     "channel",
     "glm",
     "ai"

package/src/index.ts

@@ -15,34 +15,65 @@
  *
  * Features:
  * - File-based IPC for systemd compatibility
- * - GLM-4.7 AI responses
+ * - GLM-4.7 AI responses with retry logic (via @ebowwa/ai)
  * - Separate conversation memory from Telegram
  * - Tool support (read_file, run_command, etc.)
  */
 
 import { execSync } from 'child_process';
-import { existsSync, readFileSync, writeFileSync, unlinkSync, mkdirSync, watch } from 'fs';
+import { existsSync, readFileSync, writeFileSync, mkdirSync, watch } from 'fs';
 import { homedir } from 'os';
-import { join, dirname } from 'path';
+import { join } from 'path';
+import { GLMClient, GLMRateLimitError, GLMTimeoutError, GLMNetworkError } from '@ebowwa/ai';
 
-const GLM_API_ENDPOINT = 'https://api.z.ai/api/coding/paas/v4/chat/completions';
-const CHAT_DIR = process.env.SSH_CHAT_DIR || join(homedir(), '.ssh-chat');
-const IN_FILE = join(CHAT_DIR, 'in');
-const OUT_FILE = join(CHAT_DIR, 'out');
-const STATUS_FILE = join(CHAT_DIR, 'status');
-const MEMORY_FILE = join(CHAT_DIR, 'memory.json');
+// ====================================================================
+// Configuration (all via environment variables - REQUIRED)
+// ====================================================================
+
+function requireEnv(name: string): string {
+  const value = process.env[name];
+  if (!value) {
+    throw new Error(`Missing required environment variable: ${name}`);
+  }
+  return value;
+}
+
+function requireEnvInt(name: string): number {
+  return parseInt(requireEnv(name), 10);
+}
+
+function requireEnvFloat(name: string): number {
+  return parseFloat(requireEnv(name));
+}
+
+const CONFIG = {
+  chatDir: process.env.SSH_CHAT_DIR ?? join(homedir(), '.ssh-chat'), // only optional one
+  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'),
+};
+
+const IN_FILE = join(CONFIG.chatDir, 'in');
+const OUT_FILE = join(CONFIG.chatDir, 'out');
+const STATUS_FILE = join(CONFIG.chatDir, 'status');
+const MEMORY_FILE = join(CONFIG.chatDir, 'memory.json');
 
 // ====================================================================
 // Setup
 // ====================================================================
 
 function ensureDir(): void {
-  if (!existsSync(CHAT_DIR)) {
-    mkdirSync(CHAT_DIR, { recursive: true });
+  if (!existsSync(CONFIG.chatDir)) {
+    mkdirSync(CONFIG.chatDir, { recursive: true });
   }
 }
 
-function setStatus(status: 'idle' | 'processing' | 'error'): void {
+function setStatus(status: 'idle' | 'processing' | 'error' | 'retrying'): void {
   writeFileSync(STATUS_FILE, JSON.stringify({ status, timestamp: Date.now() }));
 }
 
@@ -65,7 +96,7 @@ class ConversationMemory {
   private messages: Message[] = [];
   private maxMessages: number;
 
-  constructor(private file: string, maxMessages = 50) {
+  constructor(private file: string, maxMessages = CONFIG.memoryLimit) {
     this.maxMessages = maxMessages;
     this.load();
   }
@@ -227,74 +258,47 @@ async function executeTool(name: string, args: Record<string, unknown>): Promise
 }
 
 // ====================================================================
-// GLM API Client
+// GLM API Client (using @ebowwa/ai with retry logic)
 // ====================================================================
 
-function getAPIKey(): string {
-  const envKey = process.env.ZAI_API_KEY || process.env.GLM_API_KEY;
-  if (envKey) return envKey;
+let glmClient: GLMClient | null = null;
 
-  const keysJson = process.env.ZAI_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 {}
+function getClient(): GLMClient {
+  if (!glmClient) {
+    glmClient = new GLMClient();
   }
-
-  throw new Error('No API key found. Set ZAI_API_KEY env var.');
+  return glmClient;
 }
 
 async function callGLM(messages: Message[]): Promise<string> {
-  const apiKey = getAPIKey();
-
-  const response = await fetch(GLM_API_ENDPOINT, {
-    method: 'POST',
-    headers: {
-      'Content-Type': 'application/json',
-      'Authorization': `Bearer ${apiKey}`
-    },
-    body: JSON.stringify({
-      model: 'glm-4-plus',
-      messages: messages.map(m => ({ role: m.role, content: m.content })),
-      tools: getGLMTools(),
-      temperature: 0.7,
-      max_tokens: 4096
-    })
-  });
-
-  if (!response.ok) {
-    const text = await response.text();
-    throw new Error(`GLM API error: ${response.status} - ${text}`);
-  }
-
-  const data = await response.json();
-  const choice = data.choices?.[0];
-
-  if (!choice) {
-    throw new Error('No response from GLM');
-  }
-
-  // Handle tool calls
-  if (choice.message?.tool_calls) {
-    const toolResults: string[] = [];
+  const client = getClient();
+
+  try {
+    const response = await client.chatCompletion(
+      messages.map(m => ({ role: m.role, content: m.content })),
+      {
+        model: CONFIG.model,
+        temperature: CONFIG.temperature,
+        maxTokens: CONFIG.maxTokens,
+        maxRetries: CONFIG.maxRetries,
+        timeout: CONFIG.timeout
+      }
+    );
 
-    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}`);
+    return response.choices[0]?.message?.content || '(no response)';
+  } catch (error) {
+    // Provide better error messages based on error type
+    if (error instanceof GLMRateLimitError) {
+      throw new Error(`Rate limit exceeded after ${CONFIG.maxRetries} retries. Please try again later or check API credits.`);
     }
-
-    messages.push({ role: 'assistant', content: '', timestamp: Date.now() });
-    messages.push({ role: 'user', content: `Tool results:\n${toolResults.join('\n')}`, timestamp: Date.now() });
-
-    return callGLM(messages);
+    if (error instanceof GLMTimeoutError) {
+      throw new Error(`Request timed out after ${CONFIG.maxRetries} retries.`);
+    }
+    if (error instanceof GLMNetworkError) {
+      throw new Error(`Network error after ${CONFIG.maxRetries} retries: ${error.message}`);
+    }
+    throw error;
   }
-
-  return choice.message?.content || '(no response)';
 }
 
 // ====================================================================
@@ -306,7 +310,7 @@ async function processMessage(input: string, memory: ConversationMemory): Promis
   if (input.startsWith('/')) {
     if (input === '/clear') {
       memory.clear();
-      return '🗑️ Memory cleared.';
+      return 'Memory cleared.';
     }
     if (input === '/help') {
       return `Commands:
@@ -319,14 +323,14 @@ Just type a message to chat with AI.`;
     if (input === '/status') {
       return `Status: running
 Memory file: ${MEMORY_FILE}
-Chat dir: ${CHAT_DIR}`;
+Chat dir: ${CONFIG.chatDir}`;
     }
     return `Unknown command: ${input}. Type /help for available commands.`;
   }
 
   // Regular message - get AI response
   memory.add('user', input);
-  const messages = memory.getContext(20);
+  const messages = memory.getContext(CONFIG.contextLimit);
   return await callGLM(messages);
 }
 
@@ -335,8 +339,8 @@ Chat dir: ${CHAT_DIR}`;
 // ====================================================================
 
 async function main() {
-  console.log('🤖 SSH Chat Channel starting...');
-  console.log(`Chat dir: ${CHAT_DIR}`);
+  console.log('SSH Chat Channel starting...');
+  console.log(`Chat dir: ${CONFIG.chatDir}`);
   console.log(`Memory: ${MEMORY_FILE}`);
   console.log('');
   console.log('Usage:');
@@ -347,6 +351,15 @@ async function main() {
   // Ensure directories exist
   ensureDir();
 
+  // Initialize GLM client (will throw if no API key)
+  try {
+    getClient();
+    console.log('GLM client initialized with retry support');
+  } catch (e) {
+    console.error('Failed to initialize GLM client:', (e as Error).message);
+    process.exit(1);
+  }
+
   // Initialize memory
   const memory = new ConversationMemory(MEMORY_FILE);
   memory.add('system', `You are an AI assistant accessible via SSH.
@@ -365,7 +378,7 @@ This is a private SSH channel separate from any Telegram or other chat interface
   console.log('Watching for messages...');
 
   // Watch for file changes
-  const watcher = watch(CHAT_DIR, (eventType, filename) => {
+  const watcher = watch(CONFIG.chatDir, (eventType, filename) => {
     if (filename === 'in' && eventType === 'change') {
       processIncoming();
     }
@@ -410,7 +423,7 @@ This is a private SSH channel separate from any Telegram or other chat interface
         processIncoming();
       }
     } catch {}
-  }, 500);
+  }, CONFIG.pollInterval);
 
   // Keep running
   process.on('SIGINT', () => {