@ebowwa/channel-ssh 1.1.3 → 2.1.0

package/src/index.ts

@@ -1,101 +1,85 @@
-#!/usr/bin/env bun
 /**
- * SSH Channel for GLM Daemon
+ * @ebowwa/channel-ssh
  *
- * Provides AI chat via file-based IPC - works with systemd and tmux
+ * SSH channel adapter implementing ChannelConnector.
  *
- * Usage:
- *   Direct: bun run src/index.ts
- *   With tmux wrapper: tmux new-session -s ssh-chat "channel-ssh-interactive"
+ * This package handles:
+ * - File-based IPC (reads from ~/.ssh-chat/in, writes to ~/.ssh-chat/out)
+ * - Status tracking (~/.ssh-chat/status)
+ * - Message normalization to ChannelMessage format
  *
- * 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)
+ * Intelligence (GLM, tools, memory) can be provided by:
+ * 1. This package (standalone mode with built-in echo handler)
+ * 2. External daemon/consumer (adapter mode via onMessage handler)
  *
- * Features:
- * - 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.)
+ * Usage:
+ *   Write message: echo "your message" > ~/.ssh-chat/in
+ *   Read response: cat ~/.ssh-chat/out
+ *   Check status: cat ~/.ssh-chat/status
  */
 
-import { execSync } from 'child_process';
-import { existsSync, readFileSync, writeFileSync, mkdirSync, watch } from 'fs';
-import { homedir } from 'os';
-import { join } from 'path';
-
-// ====================================================================
-// 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);
+import { existsSync, readFileSync, watch, writeFileSync, mkdirSync } from "fs";
+import { homedir } from "os";
+import { join } from "path";
+
+import {
+  type ChannelId,
+  type ChannelMessage,
+  type ChannelResponse,
+  type ChannelCapabilities,
+  type MessageSender,
+  type MessageContext,
+  type MessageHandler,
+  createChannelId,
+} from "@ebowwa/channel-types";
+
+// ============================================================
+// CONFIG
+// ============================================================
+
+export interface SSHConfig {
+  /** Chat directory for IPC files (default: ~/.ssh-chat) */
+  chatDir?: string;
+  /** Polling interval in ms (default: 500) */
+  pollInterval?: number;
+  /** Memory limit - max messages to keep (default: 100) */
+  memoryLimit?: number;
+  /** Context limit for LLM (default: 20) */
+  contextLimit?: number;
 }
 
-function requireEnvFloat(name: string): number {
-  return parseFloat(requireEnv(name));
+export function createSSHConfigFromEnv(): SSHConfig {
+  return {
+    chatDir: process.env.SSH_CHAT_DIR,
+    pollInterval: process.env.SSH_POLL_INTERVAL
+      ? parseInt(process.env.SSH_POLL_INTERVAL, 10)
+      : undefined,
+    memoryLimit: process.env.SSH_MEMORY_LIMIT
+      ? parseInt(process.env.SSH_MEMORY_LIMIT, 10)
+      : undefined,
+    contextLimit: process.env.SSH_CONTEXT_LIMIT
+      ? parseInt(process.env.SSH_CONTEXT_LIMIT, 10)
+      : undefined,
+  };
 }
 
-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
+// ============================================================
 
-// ====================================================================
-// Conversation Memory (Separate from Telegram)
-// ====================================================================
-
-interface Message {
-  role: 'user' | 'assistant' | 'system';
+interface StoredMessage {
+  role: "user" | "assistant" | "system";
   content: string;
   timestamp: number;
 }
 
-class ConversationMemory {
-  private messages: Message[] = [];
+export class ConversationMemory {
+  private messages: StoredMessage[] = [];
   private maxMessages: number;
+  private file: string;
 
-  constructor(private file: string, maxMessages = CONFIG.memoryLimit) {
+  constructor(file: string, maxMessages = 100) {
+    this.file = file;
     this.maxMessages = maxMessages;
     this.load();
   }
@@ -103,7 +87,7 @@ class ConversationMemory {
   private load(): void {
     try {
       if (existsSync(this.file)) {
-        const data = JSON.parse(readFileSync(this.file, 'utf-8'));
+        const data = JSON.parse(readFileSync(this.file, "utf-8"));
         this.messages = data.messages || [];
       }
     } catch {
@@ -115,11 +99,11 @@ class ConversationMemory {
     try {
       writeFileSync(this.file, JSON.stringify({ messages: this.messages }, null, 2));
     } catch (e) {
-      console.error('Failed to save memory:', e);
+      console.error("Failed to save memory:", e);
     }
   }
 
-  add(role: 'user' | 'assistant' | 'system', content: string): void {
+  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);
@@ -127,7 +111,7 @@ class ConversationMemory {
     this.save();
   }
 
-  getContext(limit = 20): Message[] {
+  getContext(limit = 20): StoredMessage[] {
     return this.messages.slice(-limit);
   }
 
@@ -137,368 +121,319 @@ class ConversationMemory {
   }
 }
 
-// ====================================================================
-// 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']
+// ============================================================
+// SSH CHANNEL
+// ============================================================
+
+export class SSHChannel {
+  readonly id: ChannelId;
+  readonly label = "SSH";
+  readonly capabilities: ChannelCapabilities = {
+    supports: {
+      text: true,
+      media: false,
+      replies: false,
+      threads: false,
+      reactions: false,
+      editing: false,
+      streaming: false,
     },
-    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']
+    rateLimits: {
+      messagesPerMinute: 120,
+      charactersPerMessage: 100000,
     },
-    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}`;
-      }
-    }
+  };
+
+  private config: Required<SSHConfig>;
+  private memory: ConversationMemory;
+  private messageHandler?: MessageHandler;
+  private connected = false;
+  private watcher?: ReturnType<typeof watch>;
+  private pollInterval?: ReturnType<typeof setInterval>;
+  private lastContent = "";
+  private messageCounter = 0;
+
+  // File paths
+  private readonly IN_FILE: string;
+  private readonly OUT_FILE: string;
+  private readonly STATUS_FILE: string;
+  private readonly MEMORY_FILE: string;
+
+  constructor(config: SSHConfig = {}) {
+    this.config = {
+      chatDir: config.chatDir ?? join(homedir(), ".ssh-chat"),
+      pollInterval: config.pollInterval ?? 500,
+      memoryLimit: config.memoryLimit ?? 100,
+      contextLimit: config.contextLimit ?? 20,
+    };
+
+    this.id = createChannelId("ssh", "default");
+
+    this.IN_FILE = join(this.config.chatDir, "in");
+    this.OUT_FILE = join(this.config.chatDir, "out");
+    this.STATUS_FILE = join(this.config.chatDir, "status");
+    this.MEMORY_FILE = join(this.config.chatDir, "memory.json");
+
+    this.memory = new ConversationMemory(this.MEMORY_FILE, this.config.memoryLimit);
   }
-];
 
-function getGLMTools() {
-  return TOOLS.map(t => ({
-    type: 'function',
-    function: { name: t.name, description: t.description, parameters: t.parameters }
-  }));
-}
+  // ============================================================
+  // ChannelConnector Implementation
+  // ============================================================
 
-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}`;
-}
+  async start(): Promise<void> {
+    console.log("[SSHChannel] Starting...");
 
-// ====================================================================
-// GLM API Client (direct fetch with tools + retry logic)
-// ====================================================================
+    // Ensure directory exists
+    this.ensureDir();
 
-const GLM_API_ENDPOINT = 'https://api.z.ai/api/coding/paas/v4/chat/completions';
+    // Create empty files if they don't exist
+    if (!existsSync(this.IN_FILE)) writeFileSync(this.IN_FILE, "");
+    if (!existsSync(this.OUT_FILE)) writeFileSync(this.OUT_FILE, "Ready. Send a message.\n");
 
-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;
+    this.setStatus("idle");
 
-  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)];
+    // Setup file watcher
+    this.watcher = watch(this.config.chatDir, (eventType, filename) => {
+      if (filename === "in" && eventType === "change") {
+        this.processIncoming();
       }
-    } catch {}
-  }
-
-  throw new Error('No API key found. Set ZAI_API_KEY env var.');
-}
-
-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 controller = new AbortController();
-    const timeoutId = setTimeout(() => controller.abort(), CONFIG.timeout);
-
-    const response = await fetch(GLM_API_ENDPOINT, {
-      method: 'POST',
-      headers: {
-        'Content-Type': 'application/json',
-        'Authorization': `Bearer ${apiKey}`
-      },
-      signal: controller.signal,
-      body: JSON.stringify({
-        model: CONFIG.model,
-        messages: messages.map(m => ({ role: m.role, content: m.content })),
-        tools: getGLMTools(),
-        temperature: CONFIG.temperature,
-        max_tokens: CONFIG.maxTokens
-      })
     });
 
-    clearTimeout(timeoutId);
-
-    if (!response.ok) {
-      const text = await response.text();
+    // Setup polling as backup (watch can be unreliable)
+    this.pollInterval = setInterval(() => {
+      try {
+        const content = readFileSync(this.IN_FILE, "utf-8").trim();
+        if (content && content !== this.lastContent) {
+          this.processIncoming();
+        }
+      } catch {}
+    }, this.config.pollInterval);
+
+    this.connected = true;
+    console.log("[SSHChannel] Started");
+    console.log(`  IN_FILE:  ${this.IN_FILE}`);
+    console.log(`  OUT_FILE: ${this.OUT_FILE}`);
+    console.log(`  STATUS:   ${this.STATUS_FILE}`);
+  }
 
-      // 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);
-      }
+  async stop(): Promise<void> {
+    console.log("[SSHChannel] Stopping...");
 
-      throw new Error(`GLM API error: ${response.status} - ${text}`);
+    if (this.watcher) {
+      this.watcher.close();
+      this.watcher = undefined;
     }
 
-    const data = await response.json();
-    const choice = data.choices?.[0];
-
-    if (!choice) {
-      throw new Error('No response from GLM');
+    if (this.pollInterval) {
+      clearInterval(this.pollInterval);
+      this.pollInterval = undefined;
     }
 
-    // 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);
-    }
-
-    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;
+    this.connected = false;
+    console.log("[SSHChannel] Stopped");
   }
-}
 
-// ====================================================================
-// Process Message
-// ====================================================================
+  /**
+   * Set the message handler. The daemon/consumer provides intelligence.
+   */
+  onMessage(handler: MessageHandler): void {
+    this.messageHandler = handler;
+  }
 
-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
+  /**
+   * Send a response back to SSH channel (writes to OUT_FILE).
+   */
+  async send(response: ChannelResponse): Promise<void> {
+    const text = response.content.text;
+    const timestamp = new Date().toISOString();
+    writeFileSync(this.OUT_FILE, `[${timestamp}]\n${text}\n`);
 
-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.`;
+    // Store in memory
+    this.memory.add("assistant", text);
   }
 
-  // Regular message - get AI response
-  memory.add('user', input);
-  const messages = memory.getContext(CONFIG.contextLimit);
-  return await callGLM(messages);
-}
+  isConnected(): boolean {
+    return this.connected;
+  }
 
-// ====================================================================
-// Main Loop - File Watcher
-// ====================================================================
+  // ============================================================
+  // Public Helpers
+  // ============================================================
 
-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('');
-
-  // Ensure directories exist
-  ensureDir();
-
-  // Verify API key is configured
-  try {
-    getAPIKey();
-    console.log('GLM client initialized with retry support');
-  } catch (e) {
-    console.error('Failed to initialize GLM client:', (e as Error).message);
-    process.exit(1);
+  /**
+   * Get the conversation memory.
+   */
+  getMemory(): ConversationMemory {
+    return this.memory;
   }
 
-  // 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.`);
-
-  // 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');
+  /**
+   * Get the input file path.
+   */
+  getInFile(): string {
+    return this.IN_FILE;
+  }
 
-  setStatus('idle');
+  /**
+   * Get the output file path.
+   */
+  getOutFile(): string {
+    return this.OUT_FILE;
+  }
 
-  // Track last processed content
-  let lastContent = '';
+  /**
+   * Get the status file path.
+   */
+  getStatusFile(): string {
+    return this.STATUS_FILE;
+  }
 
-  console.log('Watching for messages...');
+  // ============================================================
+  // Internal Methods
+  // ============================================================
 
-  // Watch for file changes
-  const watcher = watch(CONFIG.chatDir, (eventType, filename) => {
-    if (filename === 'in' && eventType === 'change') {
-      processIncoming();
+  private ensureDir(): void {
+    if (!existsSync(this.config.chatDir)) {
+      mkdirSync(this.config.chatDir, { recursive: true });
     }
-  });
+  }
+
+  private setStatus(status: "idle" | "processing" | "error"): void {
+    writeFileSync(this.STATUS_FILE, JSON.stringify({ status, timestamp: Date.now() }));
+  }
 
-  async function processIncoming() {
+  private async processIncoming(): Promise<void> {
     try {
-      const content = readFileSync(IN_FILE, 'utf-8').trim();
+      const content = readFileSync(this.IN_FILE, "utf-8").trim();
 
       // Skip if same as last or empty
-      if (!content || content === lastContent) return;
+      if (!content || content === this.lastContent) return;
 
-      lastContent = content;
-      setStatus('processing');
+      this.lastContent = content;
+      this.setStatus("processing");
 
-      console.log(`[${new Date().toISOString()}] Processing: ${content.slice(0, 50)}...`);
+      console.log(`[SSHChannel] Processing: ${content.slice(0, 50)}...`);
 
       // Clear input file after reading
-      writeFileSync(IN_FILE, '');
-
-      // Process message
-      const response = await processMessage(content, memory);
-
-      // Write response
-      writeOutput(response);
-      memory.add('assistant', response);
+      writeFileSync(this.IN_FILE, "");
+
+      // Create normalized message
+      const message = this.createChannelMessage(content);
+
+      // Store in memory
+      this.memory.add("user", content);
+
+      // Route to handler if set
+      if (this.messageHandler) {
+        try {
+          const response = await this.messageHandler(message);
+          if (response) {
+            await this.send(response);
+          }
+        } catch (error) {
+          console.error("[SSHChannel] Handler error:", error);
+          writeFileSync(
+            this.OUT_FILE,
+            `[${new Date().toISOString()}]\nError: ${(error as Error).message}\n`
+          );
+          this.setStatus("error");
+          return;
+        }
+      } else {
+        // No handler - echo mode
+        await this.send({
+          content: { text: `Echo: ${content}` },
+          replyTo: { messageId: message.messageId, channelId: message.channelId },
+        });
+      }
 
-      setStatus('idle');
-      console.log(`[${new Date().toISOString()}] Response sent`);
+      this.setStatus("idle");
+      console.log("[SSHChannel] Response sent");
     } catch (error) {
-      console.error('Error:', error);
-      setStatus('error');
-      writeOutput(`Error: ${(error as Error).message}`);
+      console.error("[SSHChannel] Error:", error);
+      this.setStatus("error");
     }
   }
 
-  // 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);
+  /**
+   * Normalize SSH input to ChannelMessage format.
+   */
+  private createChannelMessage(text: string): ChannelMessage {
+    this.messageCounter++;
+    const messageId = `ssh-${Date.now()}-${this.messageCounter}`;
+
+    const sender: MessageSender = {
+      id: "ssh-user",
+      username: "ssh",
+      displayName: "SSH User",
+      isBot: false,
+    };
+
+    const context: MessageContext = {
+      isDM: true,
+      metadata: {
+        source: "file-ipc",
+        chatDir: this.config.chatDir,
+      },
+    };
+
+    return {
+      messageId,
+      channelId: this.id,
+      timestamp: new Date(),
+      sender,
+      text,
+      context,
+    };
+  }
+}
+
+// ============================================================
+// FACTORY
+// ============================================================
 
-  // Keep running
-  process.on('SIGINT', () => {
-    console.log('\nShutting down...');
-    watcher.close();
+export function createSSHChannel(config?: SSHConfig): SSHChannel {
+  return new SSHChannel(config);
+}
+
+// ============================================================
+// MAIN ENTRY POINT (for standalone testing)
+// ============================================================
+
+async function main() {
+  const config = createSSHConfigFromEnv();
+  const channel = createSSHChannel(config);
+
+  // Example: Echo handler for testing
+  channel.onMessage(async (msg) => {
+    console.log(`Received: ${msg.text}`);
+    return {
+      content: { text: `Echo: ${msg.text}` },
+      replyTo: { messageId: msg.messageId, channelId: msg.channelId },
+    };
+  });
+
+  process.on("SIGINT", async () => {
+    await channel.stop();
+    process.exit(0);
+  });
+
+  process.on("SIGTERM", async () => {
+    await channel.stop();
     process.exit(0);
   });
+
+  await channel.start();
 }
 
-main().catch(console.error);
+// Only run main when executed directly (not when imported)
+if (import.meta.main) {
+  main().catch(console.error);
+}
+
+// ============================================================
+// PLUGIN SYSTEM
+// ============================================================
+
+export { createSSHPlugin, sshPlugin, type ResolvedSSHAccount } from "./plugin.js";