@ebowwa/channel-ssh 1.0.1 → 1.1.0

package/dist/index.js

@@ -2,20 +2,58 @@
 // @bun
 
 // src/index.ts
-import { execSync } from "child_process";
-import { existsSync, readFileSync, writeFileSync } from "fs";
+import { existsSync, readFileSync, writeFileSync, mkdirSync, watch } from "fs";
 import { homedir } from "os";
 import { join } from "path";
-var SESSION_NAME = process.env.SSH_CHAT_SESSION || "ssh-chat";
-var GLM_API_ENDPOINT = "https://api.z.ai/api/coding/paas/v4/chat/completions";
-var MEMORY_FILE = process.env.SSH_MEMORY_FILE || join(homedir(), ".ssh-chat-memory.json");
-var PROMPTS_FILE = process.env.PROMPTS_FILE || join(homedir(), ".ssh-chat-prompts.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(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 = 50) {
+  constructor(file, maxMessages = CONFIG.memoryLimit) {
     this.file = file;
     this.maxMessages = maxMessages;
     this.load();
@@ -52,281 +90,129 @@ 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;
-      }
+var glmClient = null;
+function getClient() {
+  if (!glmClient) {
+    glmClient = new GLMClient;
+  }
+  return glmClient;
+}
+async function callGLM(messages) {
+  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.`);
     }
-  },
-  {
-    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}`;
-      }
+    if (error instanceof GLMTimeoutError) {
+      throw new Error(`Request timed out after ${CONFIG.maxRetries} retries.`);
     }
-  },
-  {
-    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}`;
-      }
+    if (error instanceof GLMNetworkError) {
+      throw new Error(`Network error after ${CONFIG.maxRetries} retries: ${error.message}`);
     }
+    throw error;
   }
-];
-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 {}
-  }
-  throw new Error("No API key found. Set ZAI_API_KEY or ZAI_API_KEYS env var.");
-}
-async function callGLM(messages, tools) {
-  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}`);
+async function processMessage(input, memory) {
+  if (input.startsWith("/")) {
+    if (input === "/clear") {
+      memory.clear();
+      return "Memory cleared.";
     }
-    messages.push({ role: "assistant", content: "", timestamp: Date.now() });
-    messages.push({ role: "user", content: `Tool results:
-${toolResults.join(`
-`)}`, timestamp: Date.now() });
-    return callGLM(messages, tools);
-  }
-  return choice.message?.content || "(no response)";
-}
-function tmux(args) {
-  try {
-    return execSync(`tmux ${args}`, { encoding: "utf-8" }).trim();
-  } catch (e) {
-    return e.stdout?.toString().trim() || "";
-  }
-}
-function sessionExists() {
-  const result = tmux(`has-session -t ${SESSION_NAME} 2>/dev/null`);
-  return !result.includes("no session");
-}
-function createSession() {
-  if (!sessionExists()) {
-    tmux(`new-session -d -s ${SESSION_NAME} -x 200 -y 50`);
-    tmux(`send-keys -t ${SESSION_NAME} '\uD83E\uDD16 SSH Chat Channel - Type your message and press Enter' Enter`);
-    tmux(`send-keys -t ${SESSION_NAME} '\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501' Enter`);
-    tmux(`send-keys -t ${SESSION_NAME} '' Enter`);
-    console.log(`Created tmux session: ${SESSION_NAME}`);
-  }
-}
-function getPaneContent() {
-  return tmux(`capture-pane -t ${SESSION_NAME} -p -S -100`);
-}
-function sendToPane(text) {
-  const lines = text.split(`
-`);
-  tmux(`send-keys -t ${SESSION_NAME} '' Enter`);
-  for (const line of lines) {
-    const escaped = line.replace(/["'$`\\]/g, "\\$&");
-    tmux(`send-keys -t ${SESSION_NAME} '${escaped}' Enter`);
-  }
-  tmux(`send-keys -t ${SESSION_NAME} '' Enter`);
-  tmux(`send-keys -t ${SESSION_NAME} '\uD83D\uDC64 You: '`);
-}
-var lastContent = "";
-function detectNewInput() {
-  const currentContent = getPaneContent();
-  if (currentContent === lastContent) {
-    return null;
-  }
-  const lastLines = lastContent.split(`
-`);
-  const currentLines = currentContent.split(`
-`);
-  const newLines = [];
-  let foundLast = false;
-  for (const line of currentLines) {
-    if (!foundLast) {
-      if (line === lastLines[lastLines.length - 1]) {
-        foundLast = true;
-      }
-    } else {
-      if (!line.includes("\uD83D\uDC64 You:") && line.trim()) {
-        newLines.push(line.trim());
-      }
+    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.`;
+    }
+    if (input === "/status") {
+      return `Status: running
+Memory file: ${MEMORY_FILE}
+Chat dir: ${CONFIG.chatDir}`;
     }
+    return `Unknown command: ${input}. Type /help for available commands.`;
   }
-  lastContent = currentContent;
-  const input = newLines.join(" ").trim();
-  return input || null;
+  memory.add("user", input);
+  const messages = memory.getContext(CONFIG.contextLimit);
+  return await callGLM(messages);
 }
 async function main() {
-  console.log("\uD83E\uDD16 SSH Chat Channel starting...");
-  console.log(`Session: ${SESSION_NAME}`);
+  console.log("SSH Chat Channel starting...");
+  console.log(`Chat dir: ${CONFIG.chatDir}`);
   console.log(`Memory: ${MEMORY_FILE}`);
-  createSession();
+  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 {
+    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 tmux session.
+  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.`);
-  console.log("Ready. Monitoring tmux session for input...");
-  console.log(`Attach with: tmux attach -t ${SESSION_NAME}`);
-  while (true) {
+  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 function processIncoming() {
     try {
-      const input = detectNewInput();
-      if (input && input.length > 0) {
-        if (input.startsWith("/")) {
-          if (input === "/clear") {
-            memory.clear();
-            sendToPane("\uD83D\uDDD1\uFE0F Memory cleared.");
-          } else if (input === "/exit" || input === "/quit") {
-            sendToPane("\uD83D\uDC4B Goodbye!");
-            break;
-          } else {
-            sendToPane(`Unknown command: ${input}`);
-          }
-          continue;
-        }
-        console.log(`[${new Date().toISOString()}] Input: ${input.slice(0, 50)}...`);
-        memory.add("user", input);
-        const messages = memory.getContext(20);
-        const response = await callGLM(messages, TOOLS);
-        memory.add("assistant", response);
-        sendToPane(`\uD83E\uDD16 AI: ${response}`);
-        console.log(`[${new Date().toISOString()}] Response sent`);
-      }
-      await new Promise((r) => setTimeout(r, 500));
+      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);
-      await new Promise((r) => setTimeout(r, 2000));
+      setStatus("error");
+      writeOutput(`Error: ${error.message}`);
     }
   }
-}
-process.on("SIGINT", () => {
-  console.log(`
+  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...`);
-  process.exit(0);
-});
+    watcher.close();
+    process.exit(0);
+  });
+}
 main().catch(console.error);

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@ebowwa/channel-ssh",
-  "version": "1.0.1",
-  "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

@@ -2,29 +2,85 @@
 /**
  * SSH Channel for GLM Daemon
  *
- * Provides AI chat via SSH tmux session - completely separate from Telegram
+ * Provides AI chat via file-based IPC - works with systemd and tmux
  *
  * Usage:
- *   bun run src/index.ts
+ *   Direct: bun run src/index.ts
+ *   With tmux wrapper: tmux new-session -s ssh-chat "channel-ssh-interactive"
+ *
+ * Communication:
+ *   IN_FILE: ~/.ssh-chat/in (user writes messages here)
+ *   OUT_FILE: ~/.ssh-chat/out (AI responses here)
+ *   STATUS_FILE: ~/.ssh-chat/status (processing/idle)
  *
  * Features:
- * - Creates/attaches to tmux session "ssh-chat"
- * - Monitors pane for user input (lines ending with Enter)
- * - GLM-4.7 AI responses
+ * - File-based IPC for systemd compatibility
+ * - 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, spawn } from 'child_process';
-import { existsSync, readFileSync, writeFileSync, appendFileSync } from 'fs';
-import { getStore } from '@ebowwa/structured-prompts';
+import { execSync } from 'child_process';
+import { existsSync, readFileSync, writeFileSync, mkdirSync, watch } from 'fs';
 import { homedir } from 'os';
 import { join } from 'path';
+import { GLMClient, GLMRateLimitError, GLMTimeoutError, GLMNetworkError } from '@ebowwa/ai';
+
+// ====================================================================
+// 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 SESSION_NAME = process.env.SSH_CHAT_SESSION || 'ssh-chat';
-const GLM_API_ENDPOINT = 'https://api.z.ai/api/coding/paas/v4/chat/completions';
-const MEMORY_FILE = process.env.SSH_MEMORY_FILE || join(homedir(), '.ssh-chat-memory.json');
-const PROMPTS_FILE = process.env.PROMPTS_FILE || join(homedir(), '.ssh-chat-prompts.json');
+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(CONFIG.chatDir)) {
+    mkdirSync(CONFIG.chatDir, { recursive: true });
+  }
+}
+
+function setStatus(status: 'idle' | 'processing' | 'error' | 'retrying'): void {
+  writeFileSync(STATUS_FILE, JSON.stringify({ status, timestamp: Date.now() }));
+}
+
+function writeOutput(text: string): void {
+  const timestamp = new Date().toISOString();
+  writeFileSync(OUT_FILE, `[${timestamp}]\n${text}\n`);
+}
 
 // ====================================================================
 // Conversation Memory (Separate from Telegram)
@@ -40,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();
   }
@@ -202,237 +258,179 @@ 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 {
-  // Try environment variable first
-  const envKey = process.env.ZAI_API_KEY || process.env.GLM_API_KEY;
-  if (envKey) return envKey;
+let glmClient: GLMClient | null = null;
 
-  // Try rolling keys
-  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 or ZAI_API_KEYS env var.');
+  return glmClient;
 }
 
-async function callGLM(messages: Message[], tools: typeof TOOLS): Promise<string> {
-  const apiKey = getAPIKey();
+async function callGLM(messages: Message[]): Promise<string> {
+  const client = getClient();
 
-  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];
+  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
+      }
+    );
 
-  if (!choice) {
-    throw new Error('No response from GLM');
+    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.`);
+    }
+    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;
   }
+}
 
-  // Handle tool calls
-  if (choice.message?.tool_calls) {
-    const toolResults: string[] = [];
-
-    for (const tc of choice.message.tool_calls) {
-      const toolName = tc.function?.name;
-      const toolArgs = tc.function?.arguments ? JSON.parse(tc.function.arguments) : {};
+// ====================================================================
+// Process Message
+// ====================================================================
 
-      const result = await executeTool(toolName, toolArgs);
-      toolResults.push(`[${toolName}]: ${result}`);
+async function processMessage(input: string, memory: ConversationMemory): Promise<string> {
+  // Handle commands
+  if (input.startsWith('/')) {
+    if (input === '/clear') {
+      memory.clear();
+      return 'Memory cleared.';
     }
+    if (input === '/help') {
+      return `Commands:
+/clear - Clear conversation memory
+/help - Show this help
+/status - Show system status
 
-    // Continue conversation with tool results
-    messages.push({ role: 'assistant', content: '', timestamp: Date.now() });
-    messages.push({ role: 'user', content: `Tool results:\n${toolResults.join('\n')}`, timestamp: Date.now() });
-
-    // Recursive call for final response
-    return callGLM(messages, tools);
+Just type a message to chat with AI.`;
+    }
+    if (input === '/status') {
+      return `Status: running
+Memory file: ${MEMORY_FILE}
+Chat dir: ${CONFIG.chatDir}`;
+    }
+    return `Unknown command: ${input}. Type /help for available commands.`;
   }
 
-  return choice.message?.content || '(no response)';
+  // Regular message - get AI response
+  memory.add('user', input);
+  const messages = memory.getContext(CONFIG.contextLimit);
+  return await callGLM(messages);
 }
 
 // ====================================================================
-// Tmux Interface
+// Main Loop - File Watcher
 // ====================================================================
 
-function tmux(args: string): string {
-  try {
-    return execSync(`tmux ${args}`, { encoding: 'utf-8' }).trim();
-  } catch (e: any) {
-    return e.stdout?.toString().trim() || '';
-  }
-}
-
-function sessionExists(): boolean {
-  const result = tmux(`has-session -t ${SESSION_NAME} 2>/dev/null`);
-  return !result.includes('no session');
-}
-
-function createSession(): void {
-  if (!sessionExists()) {
-    tmux(`new-session -d -s ${SESSION_NAME} -x 200 -y 50`);
-    tmux(`send-keys -t ${SESSION_NAME} '🤖 SSH Chat Channel - Type your message and press Enter' Enter`);
-    tmux(`send-keys -t ${SESSION_NAME} '━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━' Enter`);
-    tmux(`send-keys -t ${SESSION_NAME} '' Enter`);
-    console.log(`Created tmux session: ${SESSION_NAME}`);
-  }
-}
+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('');
 
-function getPaneContent(): string {
-  return tmux(`capture-pane -t ${SESSION_NAME} -p -S -100`);
-}
+  // Ensure directories exist
+  ensureDir();
 
-function sendToPane(text: string): void {
-  // Format and send response
-  const lines = text.split('\n');
-  tmux(`send-keys -t ${SESSION_NAME} '' Enter`);
-  for (const line of lines) {
-    // Escape special characters for tmux
-    const escaped = line.replace(/["'$`\\]/g, '\\$&');
-    tmux(`send-keys -t ${SESSION_NAME} '${escaped}' Enter`);
+  // 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);
   }
-  tmux(`send-keys -t ${SESSION_NAME} '' Enter`);
-  tmux(`send-keys -t ${SESSION_NAME} '👤 You: '`);
-}
 
-// Track last seen content to detect new input
-let lastContent = '';
+  // Initialize memory
+  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.`);
 
-function detectNewInput(): string | null {
-  const currentContent = getPaneContent();
+  // Create empty files if they don't exist
+  if (!existsSync(IN_FILE)) writeFileSync(IN_FILE, '');
+  if (!existsSync(OUT_FILE)) writeFileSync(OUT_FILE, 'Ready. Send a message.\n');
 
-  if (currentContent === lastContent) {
-    return null;
-  }
+  setStatus('idle');
 
-  // Find new lines
-  const lastLines = lastContent.split('\n');
-  const currentLines = currentContent.split('\n');
+  // Track last processed content
+  let lastContent = '';
 
-  // Get lines added after last check
-  const newLines: string[] = [];
-  let foundLast = false;
+  console.log('Watching for messages...');
 
-  for (const line of currentLines) {
-    if (!foundLast) {
-      if (line === lastLines[lastLines.length - 1]) {
-        foundLast = true;
-      }
-    } else {
-      // Skip prompt line
-      if (!line.includes('👤 You:') && line.trim()) {
-        newLines.push(line.trim());
-      }
+  // Watch for file changes
+  const watcher = watch(CONFIG.chatDir, (eventType, filename) => {
+    if (filename === 'in' && eventType === 'change') {
+      processIncoming();
     }
-  }
-
-  lastContent = currentContent;
-
-  // Combine new lines as input
-  const input = newLines.join(' ').trim();
-  return input || null;
-}
+  });
 
-// ====================================================================
-// Main Loop
-// ====================================================================
+  async function processIncoming() {
+    try {
+      const content = readFileSync(IN_FILE, 'utf-8').trim();
 
-async function main() {
-  console.log('🤖 SSH Chat Channel starting...');
-  console.log(`Session: ${SESSION_NAME}`);
-  console.log(`Memory: ${MEMORY_FILE}`);
+      // Skip if same as last or empty
+      if (!content || content === lastContent) return;
 
-  // Create tmux session
-  createSession();
+      lastContent = content;
+      setStatus('processing');
 
-  // Initialize memory (separate from Telegram)
-  const memory = new ConversationMemory(MEMORY_FILE);
+      console.log(`[${new Date().toISOString()}] Processing: ${content.slice(0, 50)}...`);
 
-  // Add system prompt
-  memory.add('system', `You are an AI assistant accessible via SSH tmux session.
-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.`);
+      // Clear input file after reading
+      writeFileSync(IN_FILE, '');
 
-  console.log('Ready. Monitoring tmux session for input...');
-  console.log(`Attach with: tmux attach -t ${SESSION_NAME}`);
+      // Process message
+      const response = await processMessage(content, memory);
 
-  // Main loop
-  while (true) {
-    try {
-      const input = detectNewInput();
-
-      if (input && input.length > 0) {
-        // Skip commands
-        if (input.startsWith('/')) {
-          if (input === '/clear') {
-            memory.clear();
-            sendToPane('🗑️ Memory cleared.');
-          } else if (input === '/exit' || input === '/quit') {
-            sendToPane('👋 Goodbye!');
-            break;
-          } else {
-            sendToPane(`Unknown command: ${input}`);
-          }
-          continue;
-        }
-
-        console.log(`[${new Date().toISOString()}] Input: ${input.slice(0, 50)}...`);
-
-        // Add user message to memory
-        memory.add('user', input);
-
-        // Get AI response
-        const messages = memory.getContext(20);
-        const response = await callGLM(messages, TOOLS);
-
-        // Add response to memory
-        memory.add('assistant', response);
-
-        // Send to tmux
-        sendToPane(`🤖 AI: ${response}`);
-
-        console.log(`[${new Date().toISOString()}] Response sent`);
-      }
+      // Write response
+      writeOutput(response);
+      memory.add('assistant', response);
 
-      // Poll every 500ms
-      await new Promise(r => setTimeout(r, 500));
+      setStatus('idle');
+      console.log(`[${new Date().toISOString()}] Response sent`);
     } catch (error) {
       console.error('Error:', error);
-      await new Promise(r => setTimeout(r, 2000));
+      setStatus('error');
+      writeOutput(`Error: ${(error as Error).message}`);
     }
   }
-}
 
-// Handle shutdown
-process.on('SIGINT', () => {
-  console.log('\nShutting down...');
-  process.exit(0);
-});
+  // Also poll as backup (watch can be unreliable)
+  setInterval(() => {
+    try {
+      const content = readFileSync(IN_FILE, 'utf-8').trim();
+      if (content && content !== lastContent) {
+        processIncoming();
+      }
+    } catch {}
+  }, CONFIG.pollInterval);
+
+  // Keep running
+  process.on('SIGINT', () => {
+    console.log('\nShutting down...');
+    watcher.close();
+    process.exit(0);
+  });
+}
 
 main().catch(console.error);