shmakk 1.2.0 → 1.2.2

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/subagent.js

@@ -1,8 +1,19 @@
+const { modelFor } = require('./llm');
+
 // Auto-subagent planning pass. Runs short read-only sub-calls before the
 // main agent loop to scope work, identify risks, and outline a plan.
 // Extracted from agent.js.
+//
+// Force triggers: phrases like "use agent team", "team mode", "pm mode",
+// "agent mode", "multi-agent", or "subagent mode" always enable subagents
+// regardless of heuristics or SHMAKK_AUTO_SUBAGENTS=0.
 
 function shouldUseAutoSubagents(input, roots) {
+  // Force team/PM mode when the user explicitly requests it, regardless of
+  // auto-detection heuristics or SHMAKK_AUTO_SUBAGENTS env override.
+  if (/(\buse\s+agent\s+team\b|\bteam\s+mode\b|\bpm\s+mode\b|\bagent\s+mode\b|\bmulti.?agent\b|\bsub.?agent\s+mode\b)/i.test(String(input || ''))) {
+    return true;
+  }
   if (String(process.env.SHMAKK_AUTO_SUBAGENTS || '1') === '0') return false;
   const minLen = Math.max(40, Number(process.env.SHMAKK_AUTO_SUBAGENTS_MIN_INPUT_LEN) || 140);
   const maxRoots = Math.max(1, Number(process.env.SHMAKK_AUTO_SUBAGENTS_MAX_ROOTS) || 2);
@@ -26,7 +37,7 @@ async function runAutoSubagents({ client, input, roots, signal }) {
   for (let i = 0; i < focuses.length; i++) {
     try {
       const r = await client.chat.completions.create({
-        model: process.env.SHMAKK_MODEL || 'gpt-4o-mini',
+        model: modelFor('subagent-planning'),
         temperature: 0,
         stream: false,
         tool_choice: 'none',

package/src/taskClassifier.js

@@ -1,4 +1,4 @@
-// Task classifier — matches makkorch's classification to ensure consistent routing.
+// Task classifier — keeps routing consistent across model providers.
 // Analyzes message content to detect task type (architecture, implementation, debugging, etc).
 
 function normalizeContent(content) {
@@ -64,7 +64,7 @@ function makeProfile(taskType, scope, reasoning, urgency, risk) {
   };
 }
 
-// Classify task type from messages (matches makkorch's classifyTask.ts)
+// Classify task type from messages.
 function classifyTask(messages) {
   const text = messagesToText(messages);
 

package/src/team.js

@@ -21,6 +21,7 @@ const os = require('os');
 const { makeClient, modelFor, isConfigured } = require('./llm');
 const { runAgent } = require('./agent');
 const { matchWorkflow, expandWorkflow } = require('./workflows');
+const agentOverview = require('./agent-overview');
 
 // Role → preferred skill name mapping. Most agents can be powered by a real
 // skill file from ~/.config/shmakk/skills/. When a skill file exists, its
@@ -422,6 +423,16 @@ async function runSubAgent({
   // Step 2: try to load the skill content from the catalog.
   const loaded = loadSkillContent(wantedSkill, roots);
 
+  // Register agent in the overview tracker.
+  const agentId = agentOverview.register(null, {
+    role,
+    skill: wantedSkill,
+    skillSource: loaded ? loaded.source : null,
+    task,
+    fileScope: fileScope || null,
+    topology,
+  });
+
   // Step 3: fall back to AGENT_ROSTER if no skill file found.
   const roster = AGENT_ROSTER[role];
   if (!loaded && !roster) {
@@ -512,6 +523,7 @@ async function runSubAgent({
   };
 
   try {
+    agentOverview.markRunning(agentId);
     await runOnce(subInput);
 
     // Retry once if the agent produced 0 tool calls — it likely got stuck in
@@ -540,6 +552,13 @@ async function runSubAgent({
       await runOnce(retryInput, { hintOverride: retryHint, requireTool: true });
     }
 
+    agentOverview.markDone(agentId, {
+      toolCount,
+      output: lines.join(''),
+      skill: loaded ? wantedSkill : null,
+      skillSource: loaded ? loaded.source : null,
+    });
+
     return {
       role, task,
       output: lines.join(''),
@@ -548,6 +567,7 @@ async function runSubAgent({
       skillUsed: loaded ? wantedSkill : null,
     };
   } catch (e) {
+    agentOverview.markError(agentId, e.message);
     return {
       role, task,
       output: lines.join(''),
@@ -735,6 +755,7 @@ async function runTeam({ input, roots, write, signal, mcpManager }) {
   write('\r\n');
 
   // Phase 2: Execute based on topology
+  agentOverview.startTeamRun(`team-${Date.now()}`);
   const agentResults = topology === 'pipeline'
     ? await runPipelineAgents({ agents, overallInput: input, roots, signal, mcpManager, write })
     : await runParallelAgents({ agents, overallInput: input, roots, signal, mcpManager, write });
@@ -746,6 +767,7 @@ async function runTeam({ input, roots, write, signal, mcpManager }) {
   const summary = await synthesizeResults({ overallInput: input, agentResults, client, signal });
   write(summary + '\r\n');
 
+  agentOverview.endTeamRun();
   return true;
 }