@ebowwa/channel-ssh 1.1.1 → 1.1.2

package/dist/index.js

@@ -2,10 +2,10 @@
 // @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";
-import { GLMClient, GLMRateLimitError, GLMTimeoutError, GLMNetworkError } from "@ebowwa/ai";
 function requireEnv(name) {
   const value = process.env[name];
   if (!value) {
@@ -90,33 +90,201 @@ class ConversationMemory {
     this.save();
   }
 }
-var glmClient = null;
-function getClient() {
-  if (!glmClient) {
-    glmClient = new GLMClient;
+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}`;
+}
+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 {}
   }
-  return glmClient;
+  throw new Error("No API key found. Set ZAI_API_KEY env var.");
+}
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
 }
-async function callGLM(messages) {
-  const client = getClient();
+function calculateBackoff(retryCount) {
+  return Math.min(1000 * Math.pow(2, retryCount), 1e4);
+}
+async function callGLM(messages, retryCount = 0) {
+  const apiKey = getAPIKey();
   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
+    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
+      })
     });
-    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.`);
+    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}`);
     }
-    if (error instanceof GLMTimeoutError) {
-      throw new Error(`Request timed out after ${CONFIG.maxRetries} retries.`);
+    const data = await response.json();
+    const choice = data.choices?.[0];
+    if (!choice) {
+      throw new Error("No response from GLM");
     }
-    if (error instanceof GLMNetworkError) {
-      throw new Error(`Network error after ${CONFIG.maxRetries} retries: ${error.message}`);
+    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);
+    }
+    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);
     }
     throw error;
   }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ebowwa/channel-ssh",
-  "version": "1.1.1",
+  "version": "1.1.2",
   "description": "SSH chat channel for GLM AI - configurable via environment variables",
   "type": "module",
   "main": "./dist/index.js",

package/src/index.ts

@@ -24,7 +24,6 @@ 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)
@@ -258,44 +257,113 @@ async function executeTool(name: string, args: Record<string, unknown>): Promise
 }
 
 // ====================================================================
-// GLM API Client (using @ebowwa/ai with retry logic)
+// GLM API Client (direct fetch with tools + retry logic)
 // ====================================================================
 
-let glmClient: GLMClient | null = null;
+const GLM_API_ENDPOINT = 'https://api.z.ai/api/coding/paas/v4/chat/completions';
 
-function getClient(): GLMClient {
-  if (!glmClient) {
-    glmClient = new GLMClient();
+function getAPIKey(): string {
+  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 {}
   }
-  return glmClient;
+
+  throw new Error('No API key found. Set ZAI_API_KEY env var.');
 }
 
-async function callGLM(messages: Message[]): Promise<string> {
-  const client = getClient();
+function sleep(ms: number): Promise<void> {
+  return new Promise(resolve => setTimeout(resolve, ms));
+}
+
+function calculateBackoff(retryCount: number): number {
+  return Math.min(1000 * Math.pow(2, retryCount), 10000);
+}
+
+async function callGLM(messages: Message[], retryCount = 0): Promise<string> {
+  const apiKey = getAPIKey();
 
   try {
-    const response = await client.chatCompletion(
-      messages.map(m => ({ role: m.role, content: m.content })),
-      {
+    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,
-        maxTokens: CONFIG.maxTokens,
-        maxRetries: CONFIG.maxRetries,
-        timeout: CONFIG.timeout
+        max_tokens: CONFIG.maxTokens
+      })
+    });
+
+    clearTimeout(timeoutId);
+
+    if (!response.ok) {
+      const text = await response.text();
+
+      // Retry on 429 (rate limit) or 5xx errors
+      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);
       }
-    );
 
-    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.`);
+      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 (error instanceof GLMTimeoutError) {
-      throw new Error(`Request timed out after ${CONFIG.maxRetries} retries.`);
+
+    // Handle tool calls
+    if (choice.message?.tool_calls && choice.message.tool_calls.length > 0) {
+      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) : {};
+        const result = await executeTool(toolName, toolArgs);
+        toolResults.push(`[${toolName}]: ${result}`);
+      }
+
+      // Add assistant message with tool calls and user message with results
+      const updatedMessages = [
+        ...messages,
+        { role: 'assistant' as const, content: choice.message.content || '', timestamp: Date.now() },
+        { role: 'user' as const, content: `Tool results:\n${toolResults.join('\n')}`, timestamp: Date.now() }
+      ];
+
+      // Continue conversation with tool results
+      return callGLM(updatedMessages, 0);
     }
-    if (error instanceof GLMNetworkError) {
-      throw new Error(`Network error after ${CONFIG.maxRetries} retries: ${error.message}`);
+
+    return choice.message?.content || '(no response)';
+
+  } catch (error) {
+    // Retry on network errors or timeout
+    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);
     }
     throw error;
   }