shmakk 1.2.3 → 1.2.5

package/src/electron.js

@@ -0,0 +1,305 @@
+// Electron app automation via Chrome DevTools Protocol (CDP).
+// Connects to an Electron app running with --remote-debugging-port.
+// Plays the same role as browser.js but for Electron desktop apps.
+//
+// Usage: Launch the Electron app with:
+//   electron --remote-debugging-port=9222 path/to/app
+// Then the agent can use the `electron` tool to interact with it.
+
+const fs = require('fs');
+const path = require('path');
+
+let pw = null;
+let browser = null;
+let page = null;
+let _debugPort = 9222; // default CDP port
+
+const SCREENSHOT_DIR = '/tmp/shmakk-screenshots';
+
+function isAvailable() {
+  try { require.resolve('playwright'); return true; } catch { return false; }
+}
+
+async function ensurePage(args) {
+  const port = Number(args.debugPort) || _debugPort;
+  _debugPort = port;
+
+  if (page && !page.isClosed()) return page;
+
+  if (!pw) {
+    try {
+      pw = require('playwright');
+    } catch {
+      throw new Error(
+        'playwright not installed. Run:\n' +
+        '  npm install playwright\n' +
+        '  npx playwright install chromium',
+      );
+    }
+  }
+
+  if (!browser || !browser.isConnected()) {
+    const wsEndpoint = `http://127.0.0.1:${port}`;
+    try {
+      browser = await pw.chromium.connectOverCDP(wsEndpoint);
+    } catch (e) {
+      throw new Error(
+        `Cannot connect to Electron at port ${port}. Make sure the app is running with:\n` +
+        `  electron --remote-debugging-port=${port} path/to/app\n` +
+        `Details: ${e.message}`,
+      );
+    }
+  }
+
+  const contexts = browser.contexts();
+  const ctx = contexts[0];
+  const pages = ctx.pages();
+  page = pages[0] || await ctx.newPage();
+  return page;
+}
+
+// ── Commands ──────────────────────────────────────────────────────────────
+
+async function screenshot(args) {
+  const p = await ensurePage(args);
+  try {
+    const ts = Date.now();
+    if (!fs.existsSync(SCREENSHOT_DIR)) fs.mkdirSync(SCREENSHOT_DIR, { recursive: true });
+    const filePath = path.join(SCREENSHOT_DIR, `electron-${ts}.png`);
+    await p.screenshot({ path: filePath, fullPage: args.fullPage !== false });
+
+    const buf = fs.readFileSync(filePath);
+    const b64 = buf.toString('base64');
+
+    return {
+      ok: true,
+      path: filePath,
+      mimeType: 'image/png',
+      images: [{
+        mimeType: 'image/png',
+        data: b64,
+        dataLength: b64.length,
+        truncated: false,
+      }],
+    };
+  } catch (e) {
+    return { error: `screenshot failed: ${e.message}` };
+  }
+}
+
+async function navigate(args) {
+  const url = String(args.url || '').trim();
+  if (!url) return { error: 'url required' };
+
+  const p = await ensurePage(args);
+  try {
+    const resp = await p.goto(url, { waitUntil: 'domcontentloaded', timeout: 20000 });
+    return {
+      ok: true,
+      url: p.url(),
+      title: await p.title(),
+      status: resp ? resp.status() : null,
+    };
+  } catch (e) {
+    return { error: `navigate failed: ${e.message}` };
+  }
+}
+
+async function click(args) {
+  const sel = String(args.selector || '').trim();
+  if (!sel) return { error: 'selector required' };
+
+  const p = await ensurePage(args);
+  try {
+    await p.click(sel, { timeout: 5000 });
+    await p.waitForTimeout(500);
+    return { ok: true, clicked: sel, url: p.url(), title: await p.title() };
+  } catch (e) {
+    return { error: `click failed: ${e.message}` };
+  }
+}
+
+async function type(args) {
+  const sel = String(args.selector || '').trim();
+  const text = String(args.text || '');
+  if (!sel) return { error: 'selector required' };
+  if (!text) return { error: 'text required' };
+
+  const p = await ensurePage(args);
+  try {
+    await p.fill(sel, text, { timeout: 5000 });
+    return { ok: true, typed: text, selector: sel };
+  } catch (e) {
+    return { error: `type failed: ${e.message}` };
+  }
+}
+
+async function readPage(args) {
+  const p = await ensurePage(args);
+  try {
+    const title = await p.title();
+    const url = p.url();
+    const bodyText = await p.evaluate(() => document.body ? document.body.innerText : '');
+
+    const links = await p.evaluate(() => {
+      return Array.from(document.querySelectorAll('a[href]')).slice(0, 100).map(a => ({
+        text: (a.textContent || '').trim().slice(0, 200),
+        href: a.href,
+      }));
+    });
+
+    const forms = await p.evaluate(() => {
+      return Array.from(document.querySelectorAll('form')).slice(0, 20).map(f => ({
+        action: f.action,
+        method: f.method,
+        inputs: Array.from(f.querySelectorAll('input, select, textarea, button')).slice(0, 20).map(el => ({
+          tag: el.tagName.toLowerCase(),
+          type: el.type || '',
+          name: el.name || '',
+          placeholder: el.placeholder || '',
+          value: (el.value || '').slice(0, 100),
+        })),
+      }));
+    });
+
+    let content = `Title: ${title}\nURL: ${url}\n\n`;
+    content += bodyText.slice(0, 8000);
+
+    return {
+      ok: true,
+      title,
+      url,
+      content: content.slice(0, 12000),
+      links: links.slice(0, 50),
+      forms: forms.slice(0, 10),
+    };
+  } catch (e) {
+    return { error: `read_page failed: ${e.message}` };
+  }
+}
+
+async function evaluate(args) {
+  const code = String(args.code || '').trim();
+  if (!code) return { error: 'code required' };
+
+  const p = await ensurePage(args);
+  try {
+    const result = await p.evaluate(code);
+    return { ok: true, result: JSON.stringify(result).slice(0, 4000) };
+  } catch (e) {
+    return { error: `evaluate failed: ${e.message}` };
+  }
+}
+
+async function select(args) {
+  const sel = String(args.selector || '').trim();
+  const value = String(args.value || '');
+  if (!sel) return { error: 'selector required' };
+  if (!value) return { error: 'value required' };
+
+  const p = await ensurePage(args);
+  try {
+    await p.selectOption(sel, value, { timeout: 5000 });
+    return { ok: true, selected: value, selector: sel };
+  } catch (e) {
+    return { error: `select failed: ${e.message}` };
+  }
+}
+
+async function wait(args) {
+  const sel = args.selector ? String(args.selector).trim() : null;
+  const seconds = Number(args.seconds) || 1;
+
+  const p = await ensurePage(args);
+  try {
+    if (sel) {
+      await p.waitForSelector(sel, { timeout: Math.min(seconds * 1000, 30000) });
+    } else {
+      await p.waitForTimeout(Math.min(seconds * 1000, 30000));
+    }
+    return { ok: true, waited: seconds, selector: sel || 'timeout' };
+  } catch (e) {
+    return { error: `wait failed: ${e.message}` };
+  }
+}
+
+async function scroll(args) {
+  const direction = args.direction === 'up' ? 'up' : 'down';
+  const amount = Number(args.amount) || 300;
+
+  const p = await ensurePage(args);
+  try {
+    await p.evaluate(({ direction, amount }) => {
+      window.scrollBy(0, direction === 'down' ? amount : -amount);
+    }, { direction, amount });
+    await p.waitForTimeout(300);
+    return { ok: true, scrolled: direction, amount };
+  } catch (e) {
+    return { error: `scroll failed: ${e.message}` };
+  }
+}
+
+async function close(args) {
+  try {
+    if (browser) {
+      await browser.close();
+      browser = null;
+      page = null;
+    }
+    return { ok: true, closed: true };
+  } catch (e) {
+    browser = null;
+    page = null;
+    return { ok: true, closed: true, note: 'force closed' };
+  }
+}
+
+// Connect to a specific Electron debug port
+async function connect(args) {
+  const port = Number(args.debugPort) || 9222;
+  _debugPort = port;
+  try {
+    const p = await ensurePage(args);
+    return {
+      ok: true,
+      connected: true,
+      port,
+      url: p.url(),
+      title: await p.title(),
+    };
+  } catch (e) {
+    return { error: `connect failed: ${e.message}` };
+  }
+}
+
+// ── Dispatch ──────────────────────────────────────────────────────────────
+
+const COMMANDS = {
+  screenshot, navigate, click, type, read_page: readPage,
+  evaluate, select, wait, scroll, close, connect,
+};
+
+function classifyElectronCommand(args) {
+  const cmd = String(args.command || '');
+  if (cmd === 'screenshot' || cmd === 'read_page' || cmd === 'wait') return 'safe';
+  if (cmd === 'click' || cmd === 'type' || cmd === 'scroll' || cmd === 'evaluate' || cmd === 'select' || cmd === 'navigate') return 'uncertain';
+  if (cmd === 'close' || cmd === 'connect') return 'unsafe';
+  return 'uncertain';
+}
+
+async function dispatchElectron(args, signal) {
+  if (!isAvailable()) {
+    return { error: 'playwright not installed. Run: npm install playwright && npx playwright install chromium' };
+  }
+  const cmd = String(args.command || '');
+  const fn = COMMANDS[cmd];
+  if (!fn) return { error: `unknown electron command: ${cmd}. Available: ${Object.keys(COMMANDS).join(', ')}` };
+  try {
+    const result = await fn(args);
+    return result;
+  } catch (e) {
+    return { error: `electron ${cmd} failed: ${e.message}` };
+  }
+}
+
+module.exports = { dispatchElectron, classifyElectronCommand, isAvailable };

package/src/endpoints.js

@@ -5,12 +5,18 @@
 // Preferred format (~/.config/shmakk/endpoints.json):
 // {
 //   "main": "gpt-5",
+//   "fast": "gemini-flash",
 //   "models": {
 //     "gpt-5": {
 //       "provider": "codex",
 //       "model": "gpt-5-codex",
 //       "api_key": "sk-..."
 //     },
+//     "kimi": {
+//       "provider": "nvidia",
+//       "model": "moonshotai/kimi-k2.6",
+//       "api_key": "nvapi-..."
+//     },
 //     "claude": {
 //       "provider": "anthropic",
 //       "model": "claude-sonnet-4-5-20250929",
@@ -33,6 +39,13 @@ let currentEndpointConfig = null;
 let endpointsCwd = null;
 
 function configPath(cwd) {
+  // Check project-local endpoints first (cwd/endpoints.json), then global
+  const dir = cwd || process.cwd();
+  const localJson = path.join(dir, 'endpoints.json');
+  const localJs = path.join(dir, 'endpoints.js');
+  if (fs.existsSync(localJson)) return localJson;
+  if (fs.existsSync(localJs)) return localJs;
+
   const configDir = path.join(os.homedir(), '.config', 'shmakk');
   const jsonPath = path.join(configDir, 'endpoints.json');
   const jsPath = path.join(configDir, 'endpoints.js');
@@ -73,13 +86,14 @@ function normalizeModelConfig(name, cfg) {
     headers: cfg.headers || cfg.headears || null,
     registry: cfg.registry || null,
     main: !!cfg.main,
-    vision: !!cfg.vision,
+    fast: !!cfg.fast,
+    vision: _supportsVisionForConfig(cfg),
   };
 }
 
 function normalizeRegistry(raw) {
   if (!raw || typeof raw !== 'object') {
-    return { main: null, models: {} };
+    return { main: null, fast: null, models: {} };
   }
 
   const explicitModels = raw.models || raw.endpoints;
@@ -98,15 +112,23 @@ function normalizeRegistry(raw) {
   }
 
   let main = typeof raw.main === 'string' ? raw.main : null;
+  let fast = typeof raw.fast === 'string' ? raw.fast : null;
   if (!main) {
     const marked = Object.values(models).find((cfg) => cfg.main);
     if (marked) main = marked.name;
   }
+  if (!fast) {
+    const marked = Object.values(models).find((cfg) => cfg.fast);
+    if (marked) fast = marked.name;
+  }
   if (!main && Object.keys(models).length === 1) {
     main = Object.keys(models)[0];
   }
+  if (!fast && Object.keys(models).length === 1) {
+    fast = Object.keys(models)[0];
+  }
 
-  return { main, models };
+  return { main, fast, models };
 }
 
 function loadModelRegistry(cwd) {
@@ -115,7 +137,7 @@ function loadModelRegistry(cwd) {
 
 function applyEndpoint(name, cwd) {
   const registry = loadModelRegistry(cwd);
-  const selected = name === 'main' ? registry.main : name;
+  const selected = name === 'main' ? registry.main : name === 'fast' ? registry.fast : name;
   if (!selected || !registry.models[selected]) return false;
 
   const normalized = registry.models[selected];
@@ -144,8 +166,38 @@ function getCurrentEndpointName() {
   return currentEndpointName;
 }
 
+function _supportsVisionForConfig(cfg) {
+  if (!cfg) return false;
+
+  // Explicit config wins
+  if ('vision' in cfg) return !!cfg.vision;
+
+  // Auto-detect for known vision-capable providers
+  const provider = (cfg.provider || '').toLowerCase();
+  const model = (cfg.model || '').toLowerCase();
+
+  // Providers whose APIs always support image_url content blocks
+  const visionProviders = new Set([
+    'anthropic',  // Claude 3+
+    'google',     // Gemini
+    'codex',      // Codex / OpenAI
+    'openai',
+    'nvidia',     // NIM
+  ]);
+
+  if (visionProviders.has(provider)) return true;
+
+  // openai-compatible: check model name for vision hints
+  if (provider === 'openai-compatible') {
+    const visionPatterns = /vision|vl|multimodal|gpt-4o|gemini|claude|llava|minicpm|cogvlm|qwenvl|phi-3\.5-vision/i;
+    return visionPatterns.test(model);
+  }
+
+  return false;
+}
+
 function supportsVision() {
-  return !!(currentEndpointConfig && currentEndpointConfig.vision);
+  return _supportsVisionForConfig(currentEndpointConfig);
 }
 
 function listEndpoints(cwd) {
@@ -154,10 +206,20 @@ function listEndpoints(cwd) {
 
 function getModelRegistry(cwd) {
   const registry = loadModelRegistry(cwd || endpointsCwd || process.cwd());
-  return {
-    main: registry.main,
-    models: Object.fromEntries(Object.entries(registry.models).map(([name, cfg]) => [name, { ...cfg }])),
-  };
+  const models = Object.fromEntries(Object.entries(registry.models).map(([name, cfg]) => [name, { ...cfg }]));
+  // Include top-level visionSupport in the models map so findVisionClient() picks it up
+  const vs = getVisionSupport(cwd);
+  if (vs) models.visionSupport = vs;
+  return { main: registry.main, fast: registry.fast, models };
+}
+
+// Returns the visionSupport endpoint config if defined in endpoints.json.
+// This is a dedicated endpoint used only for describing images when the
+// active model doesn't support vision natively.
+function getVisionSupport(cwd) {
+  const raw = loadEndpoints(cwd || endpointsCwd || process.cwd());
+  if (!raw || !raw.visionSupport || typeof raw.visionSupport !== 'object') return null;
+  return normalizeModelConfig('visionSupport', raw.visionSupport);
 }
 
 module.exports = {
@@ -167,4 +229,7 @@ module.exports = {
   getCurrentEndpointName,
   supportsVision,
   getModelRegistry,
+  getVisionSupport,
+  _test: { normalizeRegistry, normalizeModelConfig },
+  _supportsVisionForConfig,
 };

package/src/index.js

@@ -24,6 +24,17 @@ function findGitRoot(cwd = process.cwd()) {
 async function main() {
   const opts = parseArgs(process.argv.slice(2));
 
+  if (opts.vimAi) {
+    const { runAi } = require('./vim');
+    process.exit(await runAi(opts.vimAi));
+  }
+
+  if (opts.vimEditor) {
+    const { runEditor } = require('./vim');
+    const realEditor = opts.vimReal || opts.vimEditor;
+    process.exit(runEditor(realEditor, opts.unknown));
+  }
+
   // Auto-detect git repo root as workspace if not explicitly set.
   // This keeps .shmakk state centralized at repo root instead of scattered.
   if (!opts.workspace) {
@@ -65,6 +76,15 @@ async function main() {
     opts.markdown = v === 'true';
   }
 
+  if (opts.browserDaemon) {
+    const { main: runBrowserDaemon } = require('./cli/browserDaemon');
+    process.exit(await runBrowserDaemon([
+      'browser-daemon',
+      ...(opts.browserDaemonPort ? ['--port', String(opts.browserDaemonPort)] : []),
+      ...(opts.help ? ['--help'] : []),
+    ]));
+  }
+
   if (opts.help) {
     process.stdout.write(resolveHelp(opts.helpCategory));
     process.exit(0);
@@ -95,6 +115,7 @@ async function main() {
       shell: process.env.SHELL,
       term: process.env.TERM,
       endpoint: activeEndpointName || opts.endpoint || null,
+      fastEndpoint: require('./endpoints').getModelRegistry(opts.workspace || process.cwd()).fast || null,
       baseUrl: activeEndpoint?.base_url || process.env.SHMAKK_BASE_URL || null,
       apiKey: activeEndpoint?.api_key ? (activeEndpoint.api_key.slice(0, 8) + '...' + activeEndpoint.api_key.slice(-4)) : null,
       model: activeEndpoint?.model || process.env.SHMAKK_MODEL || null,
@@ -106,6 +127,7 @@ async function main() {
       stt: opts.stt,
       tts: opts.tts,
       sts: opts.sts,
+      vim: opts.vim,
     };
     process.stdout.write(JSON.stringify(cfg, null, 2) + '\n');
     process.exit(0);
@@ -137,7 +159,7 @@ async function main() {
     process.exit(0);
   }
 
-  if (opts.status || opts.stats || opts.compact || opts.loadSkill || opts.installSkill || opts.listSkills || opts.skillStatus || opts.unloadSkill || opts.resumeStatus || opts.showPlan || opts.mcpStatus || opts.exitNow || opts.restart || opts.reset || opts.profileSet) {
+  if (opts.status || opts.stats || opts.compact || opts.loadSkill || opts.installSkill || opts.listSkills || opts.skillStatus || opts.unloadSkill || opts.resumeStatus || opts.showPlan || opts.mcpStatus || opts.consolidateWorkspace || opts.exitNow || opts.restart || opts.reset || opts.profileSet) {
     const ctl = require('./control');
     if (opts.status) process.exit(ctl.status());
     if (opts.stats) process.exit(ctl.stats());
@@ -150,6 +172,7 @@ async function main() {
     if (opts.resumeStatus) process.exit(ctl.resumeStatus());
     if (opts.showPlan) process.exit(ctl.showPlan());
     if (opts.mcpStatus) process.exit(ctl.mcpStatus());
+    if (opts.consolidateWorkspace) process.exit(ctl.consolidateWorkspace());
     if (opts.exitNow) process.exit(ctl.exitParent());
     if (opts.restart) process.exit(ctl.restartParent());
     if (opts.reset) process.exit(ctl.resetConversation());