shmakk 1.2.0 → 1.2.2

package/README.md

@@ -33,10 +33,34 @@ export SHMAKK_API_KEY="your-api-key"
 export SHMAKK_MODEL="gpt-4o-mini"
 ```
 
-Or copy the template and fill it in:
+Or configure multiple native model providers in `~/.config/shmakk/endpoints.json`:
+
+```json
+{
+  "main": "gpt5-codex",
+  "models": {
+    "gpt5-codex": {
+      "provider": "codex",
+      "model": "gpt-5-codex",
+      "api_key": "OPENAI_API_KEY"
+    },
+    "local": {
+      "provider": "openai-compatible",
+      "base_url": "http://127.0.0.1:1234/v1",
+      "model": "qwen/qwen3.5-9b"
+    },
+    "claude": {
+      "provider": "anthropic",
+      "model": "claude-sonnet-4-5-20250929",
+      "api_key": "ANTHROPIC_API_KEY"
+    }
+  }
+}
+```
 
 ```bash
-cp node_modules/shmakk/.env.example .env
+shmakk --endpoint claude
+shmakk --model-recommendation
 ```
 
 ### 2. Launch
@@ -114,7 +138,9 @@ The coordinator system enables complex, multi-step task execution with plan-firs
 | `SHMAKK_BASE_URL` | OpenAI-compatible base URL |
 | `SHMAKK_API_KEY` | API key |
 | `SHMAKK_MODEL` | Default model |
+| `SHMAKK_PROVIDER` | `openai-compatible`, `codex`, or `anthropic` |
 | `SHMAKK_HEADERS` | Extra headers (k=v,k=v) |
+| `SHMAKK_MODEL_RECOMMENDATION` | Set to `1` to let the configured `main` model route each call |
 
 ## Useful commands
 
@@ -144,6 +170,46 @@ The coordinator system enables complex, multi-step task execution with plan-firs
 - Secrets (`.env`, keys, tokens) are never sent to the AI
 - Workspace root is enforced — tools can't access files outside it
 
+## Remote SSH
+
+The agent can run commands and transfer files on remote hosts via SSH. Configure hosts in `.shmakk/hosts.json` (per-project) or `~/.config/shmakk/hosts.json` (global):
+
+```json
+{
+  "hosts": {
+    "devbox": {
+      "host": "marcus@192.168.1.100",
+      "port": 22,
+      "auto_approve": false,
+      "timeout_sec": 30
+    },
+    "staging": {
+      "host": "deploy@10.0.0.5",
+      "port": 2247
+    }
+  },
+  "allow_ssh_config": false,
+  "default_timeout_sec": 30
+}
+```
+
+| Tool | Description |
+|------|-------------|
+| `ssh_run` | Run a shell command on a remote host |
+| `ssh_push` | Copy a local workspace file to a remote host |
+| `ssh_pull` | Copy a remote file into the local workspace |
+
+SSH key auth via `~/.ssh` is assumed. For persistent connections (avoid re-auth on every call), add to `~/.ssh/config`:
+
+```
+Host *
+  ControlMaster auto
+  ControlPath ~/.ssh/controlmasters/%r@%h:%p
+  ControlPersist 600
+```
+
+Then `mkdir -p ~/.ssh/controlmasters` once.
+
 ## How it works
 
 shmakk wraps your shell in a PTY (pseudo-terminal). Every command that fails is checked against a deterministic correction engine (no LLM, no API call). If a correction matches and the fixed command succeeds, shmakk feeds the agent your **original input** (not the fixed command) so the agent can address your full intent — not just the typo. You can also give task instructions in natural language — shmakk uses tools to read files, write code, list directories, and run commands, all constrained to your workspace.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "shmakk",
-  "version": "1.2.0",
+  "version": "1.2.2",
   "description": "AI-supervised terminal wrapper — command correction, tool-driven tasks, safety controls",
   "license": "MIT",
   "keywords": [
@@ -48,7 +48,7 @@
     "node": ">=18"
   },
   "dependencies": {
-    "node-pty": "^1.0.0",
+    "@lydell/node-pty": "^1.2.0-beta.12",
     "openai": "^4.77.0",
     "wavefile": "^11.0.0"
   },

package/scripts/demo/record.py

@@ -0,0 +1,196 @@
+#!/usr/bin/env python3
+"""
+shmakk demo recorder — uses Playwright to drive the demo HTML page
+while ffmpeg captures the Xvfb display.
+
+Usage: python3 scripts/demo/record.py [--out onlymakk.mp4]
+"""
+
+import subprocess, sys, os, time, argparse, shutil, shlex
+from pathlib import Path
+
+ROOT = Path(__file__).resolve().parents[2]
+SCENES_HTML = Path(__file__).resolve().parent / "scenes.html"
+
+FPS = 30
+WIDTH = 1920
+HEIGHT = 1080
+DISPLAY = ":99"
+
+
+def run(cmd, timeout=120, check=True):
+    if isinstance(cmd, str):
+        print(f"  $ {cmd[:120]}")
+    else:
+        print(f"  $ {' '.join(shlex.quote(str(x)) for x in cmd)[:120]}")
+    return subprocess.run(cmd, shell=isinstance(cmd, str),
+                          capture_output=True, text=True,
+                          timeout=timeout, check=check)
+
+
+def is_xvfb_running():
+    r = subprocess.run(["pgrep", "-f", f"Xvfb {DISPLAY}"], capture_output=True)
+    return r.returncode == 0
+
+
+def start_xvfb():
+    if is_xvfb_running():
+        print(f"Xvfb already running on {DISPLAY}")
+        return
+    print(f"Starting Xvfb on {DISPLAY}...")
+    subprocess.Popen(["Xvfb", DISPLAY, "-screen", "0", f"{WIDTH}x{HEIGHT}x24",
+                      "-ac", "+extension", "RANDR"],
+                     stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL)
+    time.sleep(1.5)
+    if not is_xvfb_running():
+        print("ERROR: Xvfb failed to start")
+        sys.exit(1)
+    print("Xvfb started.")
+
+
+def record(out_path: Path):
+    tmp_dir = ROOT / "tmp" / "demo"
+    tmp_dir.mkdir(parents=True, exist_ok=True)
+    raw_mp4 = tmp_dir / "raw.mp4"
+
+    # Clean up previous raw files
+    for f in list(tmp_dir.glob("*.webm")) + list(tmp_dir.glob("*.mp4")):
+        if f.name != "onlymakk.mp4":
+            f.unlink(missing_ok=True)
+
+    start_xvfb()
+
+    env = os.environ.copy()
+    env["DISPLAY"] = DISPLAY
+
+    scenes_url = SCENES_HTML.as_uri()
+
+    print(f"Source: {scenes_url}")
+    print(f"Output: {out_path}")
+
+    # Start ffmpeg recording in the background
+    ffmpeg_cmd = [
+        "ffmpeg", "-y",
+        "-f", "x11grab",
+        "-framerate", str(FPS),
+        "-video_size", f"{WIDTH}x{HEIGHT}",
+        "-i", f"{DISPLAY}+0,0",
+        "-c:v", "libx264",
+        "-preset", "ultrafast",
+        "-crf", "18",
+        "-pix_fmt", "yuv420p",
+        str(raw_mp4)
+    ]
+
+    print("Starting ffmpeg capture...")
+    ffmpeg_proc = subprocess.Popen(ffmpeg_cmd, env=env,
+                                   stdout=subprocess.DEVNULL,
+                                   stderr=subprocess.DEVNULL)
+    time.sleep(1)  # let ffmpeg initialize
+
+    if ffmpeg_proc.poll() is not None:
+        print("ERROR: ffmpeg exited immediately")
+        sys.exit(1)
+
+    # Now run Playwright to drive the demo
+    driver_js = f"""
+    const {{ chromium }} = require('playwright');
+
+    (async () => {{
+        const browser = await chromium.launch({{
+            headless: false,
+            args: ['--no-sandbox', '--disable-gpu', '--disable-setuid-sandbox',
+                   '--window-size={WIDTH},{HEIGHT}', '--window-position=0,0']
+        }});
+
+        // Make the browser window fill the screen
+        const context = await browser.newContext({{
+            viewport: {{ width: {WIDTH}, height: {HEIGHT} }},
+            deviceScaleFactor: 1,
+        }});
+        const page = await context.newPage();
+
+        await page.goto('{scenes_url}', {{ waitUntil: 'networkidle' }});
+
+        // Wait for DONE signal or timeout
+        const startTime = Date.now();
+        const maxDuration = 120_000;
+        while (true) {{
+            const title = await page.title();
+            if (title === 'DONE' || (Date.now() - startTime) > maxDuration) break;
+            await new Promise(r => setTimeout(r, 500));
+        }}
+
+        console.log('Demo finished. Title:', await page.title());
+        console.log('Elapsed:', (Date.now() - startTime) / 1000, 's');
+
+        // Hold the last frame briefly
+        await new Promise(r => setTimeout(r, 2000));
+
+        await browser.close();
+        console.log('Browser closed.');
+    }})();
+    """
+
+    driver_script = tmp_dir / "driver.js"
+    driver_script.write_text(driver_js)
+
+    print("Launching demo driver...")
+    result = subprocess.run(
+        ["node", str(driver_script)],
+        env=env,
+        capture_output=True, text=True,
+        timeout=150,
+        cwd=str(ROOT)
+    )
+    print(result.stdout)
+    if result.returncode != 0:
+        print("STDERR:", result.stderr)
+        ffmpeg_proc.terminate()
+        ffmpeg_proc.wait()
+        sys.exit(1)
+
+    # Give ffmpeg time to flush
+    time.sleep(2)
+    ffmpeg_proc.terminate()
+    try:
+        ffmpeg_proc.wait(timeout=10)
+    except subprocess.TimeoutExpired:
+        ffmpeg_proc.kill()
+        ffmpeg_proc.wait()
+
+    print(f"Raw capture: {raw_mp4.stat().st_size / 1024 / 1024:.1f} MB")
+
+    # Re-encode for optimal size and faststart
+    final_tmp = tmp_dir / "final.mp4"
+    run([
+        "ffmpeg", "-y",
+        "-i", str(raw_mp4),
+        "-c:v", "libx264",
+        "-preset", "medium",
+        "-crf", "20",
+        "-pix_fmt", "yuv420p",
+        "-movflags", "+faststart",
+        str(final_tmp)
+    ], timeout=300)
+
+    # Move to final destination
+    shutil.move(str(final_tmp), str(out_path))
+
+    # Cleanup
+    driver_script.unlink(missing_ok=True)
+    raw_mp4.unlink(missing_ok=True)
+
+    print(f"\nDone! -> {out_path} ({out_path.stat().st_size / 1024 / 1024:.1f} MB)")
+
+
+def main():
+    parser = argparse.ArgumentParser(description="Record shmakk product demo")
+    parser.add_argument("--out", default=str(ROOT / "onlymakk.mp4"),
+                        help="Output MP4 path")
+    args = parser.parse_args()
+    record(Path(args.out))
+
+
+if __name__ == "__main__":
+    main()