shmakk 1.2.1 → 1.2.3

package/src/ssh.js

@@ -0,0 +1,255 @@
+// SSH remote execution and file transfer for shmakk.
+//
+// Hosts are defined in .shmakk/hosts.json (project-local) or
+// ~/.config/shmakk/hosts.json (global). If a host config has
+// allow_ssh_config: true, ~/.ssh/config Host entries are also
+// available as targets.
+//
+// Schema (hosts.json):
+//   {
+//     "hosts": {
+//       "devbox": {
+//         "host": "user@192.168.1.100",
+//         "port": 22,
+//         "auto_approve": false,
+//         "timeout_sec": 30
+//       }
+//     },
+//     "allow_ssh_config": false,
+//     "default_timeout_sec": 30
+//   }
+
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+const { execFile } = require('child_process');
+
+// ── Config loading ─────────────────────────────────────────────────────
+
+function loadHostConfig(workspaceRoot) {
+  const candidates = [];
+  // Project-local config
+  if (workspaceRoot) {
+    candidates.push(path.join(workspaceRoot, '.shmakk', 'hosts.json'));
+  }
+  // Global config
+  candidates.push(path.join(os.homedir(), '.config', 'shmakk', 'hosts.json'));
+
+  let merged = { hosts: {}, allow_ssh_config: false, default_timeout_sec: 30 };
+
+  for (const p of candidates) {
+    try {
+      const raw = fs.readFileSync(p, 'utf8');
+      const cfg = JSON.parse(raw);
+      if (cfg.hosts && typeof cfg.hosts === 'object') {
+        Object.assign(merged.hosts, cfg.hosts);
+      }
+      if (typeof cfg.allow_ssh_config === 'boolean') {
+        merged.allow_ssh_config = merged.allow_ssh_config || cfg.allow_ssh_config;
+      }
+      if (typeof cfg.default_timeout_sec === 'number') {
+        merged.default_timeout_sec = cfg.default_timeout_sec;
+      }
+    } catch {
+      // Missing or malformed — skip
+    }
+  }
+
+  // Optionally import ~/.ssh/config hosts
+  if (merged.allow_ssh_config) {
+    const sshConfigHosts = parseSSHConfig();
+    for (const [name, entry] of Object.entries(sshConfigHosts)) {
+      if (!merged.hosts[name]) {
+        merged.hosts[name] = entry;
+      }
+    }
+  }
+
+  return merged;
+}
+
+function parseSSHConfig() {
+  const configPath = path.join(os.homedir(), '.ssh', 'config');
+  const hosts = {};
+  try {
+    const content = fs.readFileSync(configPath, 'utf8');
+    const lines = content.split(/\r?\n/);
+    let currentHost = null;
+    let currentEntry = null;
+
+    for (const raw of lines) {
+      const line = raw.trim();
+      if (!line || line.startsWith('#')) continue;
+
+      const m = line.match(/^(\S+)\s+(.+)$/);
+      if (!m) continue;
+
+      const key = m[1].toLowerCase();
+      const value = m[2].trim();
+
+      if (key === 'host') {
+        // Save previous entry
+        if (currentHost && currentEntry) {
+          currentEntry._aliases = currentHost.split(/\s+/);
+          for (const alias of currentEntry._aliases) {
+            if (alias !== '*') hosts[alias] = currentEntry;
+          }
+        }
+        currentHost = value;
+        currentEntry = { host: null, port: 22, auto_approve: false, _from_ssh_config: true };
+      } else if (currentEntry) {
+        if (key === 'hostname') currentEntry.host = value;
+        else if (key === 'port') currentEntry.port = parseInt(value, 10) || 22;
+        else if (key === 'user') {
+          // Merge user into the host string
+          const h = currentEntry.host || value;
+          currentEntry.host = `${value}@${h.replace(/^[^@]+@/, '')}`;
+        }
+      }
+    }
+    // Save last entry
+    if (currentHost && currentEntry) {
+      currentEntry._aliases = currentHost.split(/\s+/);
+      for (const alias of currentEntry._aliases) {
+        if (alias !== '*') hosts[alias] = currentEntry;
+      }
+    }
+  } catch {
+    // No config or unreadable
+  }
+  return hosts;
+}
+
+function resolveHost(cfg, name) {
+  const entry = cfg.hosts[name];
+  if (!entry) return null;
+  if (!entry.host) return null;
+  return entry;
+}
+
+// ── SSH command builder ─────────────────────────────────────────────────
+
+function buildSSHArgs(entry, cmd) {
+  const args = ['ssh'];
+  if (entry.port && entry.port !== 22) {
+    args.push('-p', String(entry.port));
+  }
+  // Common options for non-interactive remote execution
+  args.push('-o', 'BatchMode=yes');
+  args.push('-o', 'StrictHostKeyChecking=accept-new');
+  args.push('-o', 'ConnectTimeout=10');
+  args.push(entry.host);
+  args.push(cmd);
+  return args;
+}
+
+function buildSCPArgs(entry, src, dest, direction) {
+  // direction: 'push' → local src → remote dest
+  //            'pull' → remote src → local dest
+  const args = ['scp'];
+  if (entry.port && entry.port !== 22) {
+    args.push('-P', String(entry.port));
+  }
+  args.push('-o', 'BatchMode=yes');
+  args.push('-o', 'StrictHostKeyChecking=accept-new');
+  args.push('-o', 'ConnectTimeout=10');
+
+  if (direction === 'push') {
+    args.push(src, `${entry.host}:${dest}`);
+  } else {
+    args.push(`${entry.host}:${src}`, dest);
+  }
+  return args;
+}
+
+// ── Execution ───────────────────────────────────────────────────────────
+
+function sshRun(entry, cmd, signal) {
+  const timeout = (entry.timeout_sec || 30) * 1000;
+  const args = buildSSHArgs(entry, cmd);
+
+  return new Promise((resolve) => {
+    const child = execFile('ssh', args, {
+      timeout,
+      maxBuffer: 4 * 1024 * 1024,
+    }, (err, stdout, stderr) => {
+      if (err) {
+        const msg = (stderr || '').toString().trim() || err.message;
+        // Distinguish known SSH errors
+        if (err.killed) {
+          resolve({ error: `SSH timed out after ${timeout / 1000}s`, exitCode: null, stderr: msg });
+        } else {
+          resolve({
+            error: `SSH failed (exit ${err.code}): ${msg}`,
+            exitCode: err.code,
+            stderr: msg,
+            stdout: (stdout || '').toString().trim(),
+          });
+        }
+        return;
+      }
+      resolve({
+        ok: true,
+        stdout: (stdout || '').toString().trim(),
+        stderr: (stderr || '').toString().trim(),
+      });
+    });
+
+    if (signal) {
+      const onAbort = () => { try { child.kill('SIGINT'); } catch {} };
+      signal.addEventListener('abort', onAbort, { once: true });
+    }
+  });
+}
+
+function sshTransfer(entry, src, dest, direction, signal) {
+  const timeout = (entry.timeout_sec || 60) * 1000;
+  const args = buildSCPArgs(entry, src, dest, direction);
+
+  return new Promise((resolve) => {
+    const child = execFile('scp', args, {
+      timeout,
+      maxBuffer: 4 * 1024 * 1024,
+    }, (err, stdout, stderr) => {
+      if (err) {
+        const msg = (stderr || '').toString().trim() || err.message;
+        if (err.killed) {
+          resolve({ error: `SCP timed out after ${timeout / 1000}s`, stderr: msg });
+        } else {
+          resolve({
+            error: `SCP failed (exit ${err.code}): ${msg}`,
+            exitCode: err.code,
+            stderr: msg,
+          });
+        }
+        return;
+      }
+      resolve({ ok: true, stdout: (stdout || '').toString().trim() });
+    });
+
+    if (signal) {
+      const onAbort = () => { try { child.kill('SIGINT'); } catch {} };
+      signal.addEventListener('abort', onAbort, { once: true });
+    }
+  });
+}
+
+// ── Host listing ────────────────────────────────────────────────────────
+
+function listHosts(cfg) {
+  return Object.entries(cfg.hosts).map(([name, entry]) => ({
+    name,
+    host: entry.host,
+    port: entry.port || 22,
+    auto_approve: !!entry.auto_approve,
+    from_ssh_config: !!entry._from_ssh_config,
+  }));
+}
+
+module.exports = {
+  loadHostConfig,
+  resolveHost,
+  sshRun,
+  sshTransfer,
+  listHosts,
+};

package/src/system-prompt.js

@@ -15,6 +15,7 @@ function buildSystemPrompt({
   mcpToolHint = null,
   userRulesText = null,
   userMemoryText = null,
+  supportsVision = false,
 }) {
   return `You are an expert AI coding assistant running inside shmakk.
 
@@ -65,12 +66,13 @@ Tool Call Format:
 
 Available Tools:
 - list_dir: list files/directories
-- read_file: read file contents
+- read_file: read file contents (text or images)
 - write_file: create or overwrite a file
 - make_dir: create a directory
 - run: execute shell commands
 - web_search: search the web
 - fetch_url: fetch a URL
+${supportsVision ? '\nIf images are included in tool results (e.g. read_file on a PNG, or MCP tools that return visuals), you can describe and analyze what you see in them.\n' : ''}
 
 Path Rules:
 - Always use relative paths resolved against \`${roots[0]}\`.

package/src/tools.js

@@ -14,6 +14,14 @@ const https = require('https');
 const http = require('http');
 const os = require('os');
 
+// Lazy-load SSH (optional — only required when ssh_* tools are called).
+let _ssh = null;
+function _getSSH(roots) {
+  if (_ssh) return _ssh;
+  try { _ssh = require('./ssh'); } catch (e) { return null; }
+  return _ssh;
+}
+
 // Lazy-load TTS (kokoro-js is an optional dep; only required when
 // tts_generate is actually called).
 let _ttsGenerate = null;
@@ -73,7 +81,7 @@ function within(roots, p) {
 const TOOLS = [
   { type: 'function', function: {
     name: 'read_file',
-    description: 'Read a UTF-8 file inside the workspace. Supports compact partial reads.',
+    description: 'Read a file inside the workspace. Text files support partial reads (head, tail, grep, imports, exports, symbol). Image files (.png/.jpg/.gif/.webp/.bmp/.svg) are returned as base64 for vision analysis.',
     parameters: {
       type: 'object',
       required: ['path'],
@@ -229,6 +237,44 @@ const TOOLS = [
       },
     },
   }},
+  { type: 'function', function: {
+    name: 'ssh_run',
+    description: 'Run a shell command on a pre-configured remote host via SSH. Hosts are defined in .shmakk/hosts.json or ~/.config/shmakk/hosts.json. Output is captured.',
+    parameters: {
+      type: 'object',
+      required: ['host', 'cmd'],
+      properties: {
+        host: { type: 'string', description: 'Host alias as defined in hosts.json (e.g. "devbox")' },
+        cmd: { type: 'string', description: 'Shell command to run on the remote host' },
+      },
+    },
+  }},
+  { type: 'function', function: {
+    name: 'ssh_push',
+    description: 'Copy a file from the local workspace to a remote host via SCP. Hosts are defined in .shmakk/hosts.json.',
+    parameters: {
+      type: 'object',
+      required: ['host', 'src', 'dest'],
+      properties: {
+        host: { type: 'string', description: 'Host alias as defined in hosts.json' },
+        src: { type: 'string', description: 'Local file path (relative to workspace or absolute)' },
+        dest: { type: 'string', description: 'Remote destination path (absolute on remote host)' },
+      },
+    },
+  }},
+  { type: 'function', function: {
+    name: 'ssh_pull',
+    description: 'Copy a file from a remote host to the local workspace via SCP. Hosts are defined in .shmakk/hosts.json.',
+    parameters: {
+      type: 'object',
+      required: ['host', 'src', 'dest'],
+      properties: {
+        host: { type: 'string', description: 'Host alias as defined in hosts.json' },
+        src: { type: 'string', description: 'Remote source path (absolute on remote host)' },
+        dest: { type: 'string', description: 'Local destination path (relative to workspace or absolute)' },
+      },
+    },
+  }},
 ];
 
 // Tool safety classification.
@@ -258,6 +304,7 @@ function classifyTool(name, args, mcpManager) {
   if (name === 'tts_generate') return 'safe';       // local-only, no network
   if (name === 'video_probe') return 'safe';        // read-only local metadata
   if (name === 'video_compose') return 'safe';      // local ffmpeg, reads only workspace files
+  if (name === 'ssh_run' || name === 'ssh_push' || name === 'ssh_pull') return 'unsafe';
   return 'uncertain';
 }
 
@@ -287,6 +334,9 @@ function describeTool(name, args, mcpManager) {
   if (name === 'tts_generate') return `tts_generate: "${(args.text || '').slice(0, 80)}" (voice: ${args.voice || 'af_heart'})`;
   if (name === 'video_probe') return `video_probe ${args.path || ''}`;
   if (name === 'video_compose') return `video_compose ${(args.segments || []).length} segments → ${args.outputPath || ''}`;
+  if (name === 'ssh_run') return `ssh_run ${args.host || ''}: ${(args.cmd || '').slice(0, 100)}`;
+  if (name === 'ssh_push') return `ssh_push ${args.src || ''} → ${args.host || ''}:${args.dest || ''}`;
+  if (name === 'ssh_pull') return `ssh_pull ${args.host || ''}:${args.src || ''} → ${args.dest || ''}`;
   return `${name} ${JSON.stringify(args).slice(0, 80)}`;
 }
 
@@ -347,6 +397,31 @@ async function dispatchTool(name, args, roots, confirmTool, signal, mcpManager)
     if (!p) return { error: 'path outside workspace' };
     try {
       const buf = fs.readFileSync(p);
+      const ext = path.extname(p).toLowerCase();
+
+      // Image files: return as base64 for vision-capable providers.
+      // Mode-specific sub-reads don't apply to images — always return full.
+      const IMAGE_EXTS = new Set(['.png', '.jpg', '.jpeg', '.gif', '.webp', '.bmp', '.svg']);
+      const MIME_MAP = {
+        '.png': 'image/png', '.jpg': 'image/jpeg', '.jpeg': 'image/jpeg',
+        '.gif': 'image/gif', '.webp': 'image/webp', '.bmp': 'image/bmp',
+        '.svg': 'image/svg+xml',
+      };
+      if (IMAGE_EXTS.has(ext)) {
+        const maxImageBytes = 2 * 1024 * 1024; // 2 MB binary (~2.7 MB base64)
+        const slice = buf.length > maxImageBytes ? buf.subarray(0, maxImageBytes) : buf;
+        const b64 = slice.toString('base64');
+        return {
+          content: `[Image: ${path.basename(p)} — ${buf.length} bytes${buf.length > maxImageBytes ? ' (truncated to 2MB for display)' : ''}]`,
+          images: [{
+            mimeType: MIME_MAP[ext],
+            data: b64,
+            dataLength: b64.length,
+            truncated: buf.length > maxImageBytes,
+          }],
+        };
+      }
+
       const text = buf.slice(0, MAX_FILE_BYTES).toString('utf8');
       const lines = text.split(/\r?\n/);
       const mode = args.mode || 'full';
@@ -767,6 +842,35 @@ async function dispatchTool(name, args, roots, confirmTool, signal, mcpManager)
     });
     return composeResult;
   }
+  if (name === 'ssh_run') {
+    const ssh = _getSSH(roots);
+    if (!ssh) return { error: 'SSH module not available' };
+    const cfg = ssh.loadHostConfig(roots[0]);
+    const entry = ssh.resolveHost(cfg, args.host);
+    if (!entry) return { error: 'host not configured: ' + args.host + '. Define it in .shmakk/hosts.json or ~/.config/shmakk/hosts.json' };
+    return await ssh.sshRun(entry, args.cmd, signal);
+  }
+  if (name === 'ssh_push') {
+    const ssh = _getSSH(roots);
+    if (!ssh) return { error: 'SSH module not available' };
+    const cfg = ssh.loadHostConfig(roots[0]);
+    const entry = ssh.resolveHost(cfg, args.host);
+    if (!entry) return { error: 'host not configured: ' + args.host };
+    const p = within(roots, args.src);
+    if (!p) return { error: 'src path outside workspace' };
+    if (!fs.existsSync(p)) return { error: 'src not found: ' + args.src };
+    return await ssh.sshTransfer(entry, p, args.dest, 'push', signal);
+  }
+  if (name === 'ssh_pull') {
+    const ssh = _getSSH(roots);
+    if (!ssh) return { error: 'SSH module not available' };
+    const cfg = ssh.loadHostConfig(roots[0]);
+    const entry = ssh.resolveHost(cfg, args.host);
+    if (!entry) return { error: 'host not configured: ' + args.host };
+    const p = within(roots, args.dest);
+    if (!p) return { error: 'dest path outside workspace' };
+    return await ssh.sshTransfer(entry, args.src, p, 'pull', signal);
+  }
   return { error: `unknown tool: ${name}` };
 }