@ebowwa/channel-ssh 1.0.1

package/dist/index.js

@@ -0,0 +1,332 @@
+#!/usr/bin/env bun
+// @bun
+
+// src/index.ts
+import { execSync } from "child_process";
+import { existsSync, readFileSync, writeFileSync } 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");
+
+class ConversationMemory {
+  file;
+  messages = [];
+  maxMessages;
+  constructor(file, maxMessages = 50) {
+    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);
+    }
+  }
+  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();
+  }
+}
+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 {}
+  }
+  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}`);
+    }
+    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());
+      }
+    }
+  }
+  lastContent = currentContent;
+  const input = newLines.join(" ").trim();
+  return input || null;
+}
+async function main() {
+  console.log("\uD83E\uDD16 SSH Chat Channel starting...");
+  console.log(`Session: ${SESSION_NAME}`);
+  console.log(`Memory: ${MEMORY_FILE}`);
+  createSession();
+  const memory = new ConversationMemory(MEMORY_FILE);
+  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.`);
+  console.log("Ready. Monitoring tmux session for input...");
+  console.log(`Attach with: tmux attach -t ${SESSION_NAME}`);
+  while (true) {
+    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));
+    } catch (error) {
+      console.error("Error:", error);
+      await new Promise((r) => setTimeout(r, 2000));
+    }
+  }
+}
+process.on("SIGINT", () => {
+  console.log(`
+Shutting down...`);
+  process.exit(0);
+});
+main().catch(console.error);

package/package.json

@@ -0,0 +1,36 @@
+{
+  "name": "@ebowwa/channel-ssh",
+  "version": "1.0.1",
+  "description": "SSH tmux channel for GLM Daemon - separate from Telegram",
+  "type": "module",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "bin": {
+    "channel-ssh": "./dist/index.js"
+  },
+  "scripts": {
+    "build": "bun build src/index.ts --outdir dist --target bun --external '@ebowwa/*' --external 'node-telegram-bot-api'",
+    "dev": "bun run src/index.ts",
+    "prepublishOnly": "bun run build"
+  },
+  "dependencies": {
+    "@ebowwa/structured-prompts": "^0.3.2",
+    "@ebowwa/terminal": "^0.3.0"
+  },
+  "devDependencies": {
+    "@types/bun": "latest",
+    "typescript": "^5.9.3"
+  },
+  "keywords": [
+    "ssh",
+    "tmux",
+    "channel",
+    "glm",
+    "ai"
+  ],
+  "author": "Ebowwa Labs <labs@ebowwa.com>",
+  "license": "MIT",
+  "engines": {
+    "node": ">=18.0.0"
+  }
+}

package/src/index.ts

@@ -0,0 +1,438 @@
+#!/usr/bin/env bun
+/**
+ * SSH Channel for GLM Daemon
+ *
+ * Provides AI chat via SSH tmux session - completely separate from Telegram
+ *
+ * Usage:
+ *   bun run src/index.ts
+ *
+ * Features:
+ * - Creates/attaches to tmux session "ssh-chat"
+ * - Monitors pane for user input (lines ending with Enter)
+ * - GLM-4.7 AI responses
+ * - 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 { homedir } from 'os';
+import { join } from 'path';
+
+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');
+
+// ====================================================================
+// Conversation Memory (Separate from Telegram)
+// ====================================================================
+
+interface Message {
+  role: 'user' | 'assistant' | 'system';
+  content: string;
+  timestamp: number;
+}
+
+class ConversationMemory {
+  private messages: Message[] = [];
+  private maxMessages: number;
+
+  constructor(private file: string, maxMessages = 50) {
+    this.maxMessages = maxMessages;
+    this.load();
+  }
+
+  private load(): void {
+    try {
+      if (existsSync(this.file)) {
+        const data = JSON.parse(readFileSync(this.file, 'utf-8'));
+        this.messages = data.messages || [];
+      }
+    } catch {
+      this.messages = [];
+    }
+  }
+
+  private save(): void {
+    try {
+      writeFileSync(this.file, JSON.stringify({ messages: this.messages }, null, 2));
+    } catch (e) {
+      console.error('Failed to save memory:', e);
+    }
+  }
+
+  add(role: 'user' | 'assistant' | 'system', content: string): void {
+    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): Message[] {
+    return this.messages.slice(-limit);
+  }
+
+  clear(): void {
+    this.messages = [];
+    this.save();
+  }
+}
+
+// ====================================================================
+// Tool Definitions
+// ====================================================================
+
+interface Tool {
+  name: string;
+  description: string;
+  parameters: Record<string, unknown>;
+  handler: (args: Record<string, unknown>) => Promise<string>;
+}
+
+const TOOLS: Tool[] = [
+  {
+    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 as string;
+      try {
+        if (!existsSync(path)) return `File not found: ${path}`;
+        const content = readFileSync(path, 'utf-8');
+        return content.length > 4000 ? content.slice(0, 4000) + '\n...[truncated]' : content;
+      } catch (e) {
+        return `Error: ${(e as Error).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 as string, args.content as string);
+        return `Wrote ${(args.content as string).length} bytes to ${args.path}`;
+      } catch (e) {
+        return `Error: ${(e as Error).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 as string;
+      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: 10000, cwd: args.cwd as string || process.cwd() });
+        return result.toString() || '(no output)';
+      } catch (e: any) {
+        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 as string) || 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}\n\n${status}`;
+      } catch (e) {
+        return `Error: ${(e as Error).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\nMemory: ${mem}\nDisk: ${disk}`;
+      } catch (e) {
+        return `Error: ${(e as Error).message}`;
+      }
+    }
+  }
+];
+
+function getGLMTools() {
+  return TOOLS.map(t => ({
+    type: 'function',
+    function: { name: t.name, description: t.description, parameters: t.parameters }
+  }));
+}
+
+async function executeTool(name: string, args: Record<string, unknown>): Promise<string> {
+  const tool = TOOLS.find(t => t.name === name);
+  if (tool) return tool.handler(args);
+  return `Unknown tool: ${name}`;
+}
+
+// ====================================================================
+// GLM API Client
+// ====================================================================
+
+function getAPIKey(): string {
+  // Try environment variable first
+  const envKey = process.env.ZAI_API_KEY || process.env.GLM_API_KEY;
+  if (envKey) return envKey;
+
+  // 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 {}
+  }
+
+  throw new Error('No API key found. Set ZAI_API_KEY or ZAI_API_KEYS env var.');
+}
+
+async function callGLM(messages: Message[], tools: typeof TOOLS): 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[] = [];
+
+    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}`);
+    }
+
+    // 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);
+  }
+
+  return choice.message?.content || '(no response)';
+}
+
+// ====================================================================
+// Tmux Interface
+// ====================================================================
+
+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}`);
+  }
+}
+
+function getPaneContent(): string {
+  return tmux(`capture-pane -t ${SESSION_NAME} -p -S -100`);
+}
+
+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`);
+  }
+  tmux(`send-keys -t ${SESSION_NAME} '' Enter`);
+  tmux(`send-keys -t ${SESSION_NAME} '👤 You: '`);
+}
+
+// Track last seen content to detect new input
+let lastContent = '';
+
+function detectNewInput(): string | null {
+  const currentContent = getPaneContent();
+
+  if (currentContent === lastContent) {
+    return null;
+  }
+
+  // Find new lines
+  const lastLines = lastContent.split('\n');
+  const currentLines = currentContent.split('\n');
+
+  // Get lines added after last check
+  const newLines: string[] = [];
+  let foundLast = false;
+
+  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());
+      }
+    }
+  }
+
+  lastContent = currentContent;
+
+  // Combine new lines as input
+  const input = newLines.join(' ').trim();
+  return input || null;
+}
+
+// ====================================================================
+// Main Loop
+// ====================================================================
+
+async function main() {
+  console.log('🤖 SSH Chat Channel starting...');
+  console.log(`Session: ${SESSION_NAME}`);
+  console.log(`Memory: ${MEMORY_FILE}`);
+
+  // Create tmux session
+  createSession();
+
+  // Initialize memory (separate from Telegram)
+  const memory = new ConversationMemory(MEMORY_FILE);
+
+  // 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.`);
+
+  console.log('Ready. Monitoring tmux session for input...');
+  console.log(`Attach with: tmux attach -t ${SESSION_NAME}`);
+
+  // 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`);
+      }
+
+      // Poll every 500ms
+      await new Promise(r => setTimeout(r, 500));
+    } catch (error) {
+      console.error('Error:', error);
+      await new Promise(r => setTimeout(r, 2000));
+    }
+  }
+}
+
+// Handle shutdown
+process.on('SIGINT', () => {
+  console.log('\nShutting down...');
+  process.exit(0);
+});
+
+main().catch(console.error);