sparkecoder 0.1.113 → 0.1.115

package/dist/cli.js

@@ -8278,6 +8278,8 @@ ${JSON.stringify(outputSchema, null, 2)}
 `;
 }
 function buildOrchestratorPromptAddendum() {
+  const platform3 = process.platform === "darwin" ? "darwin" : "other";
+  const computerUseAvailable = platform3 === "darwin";
   return `
 ## Orchestrator Mode
 
@@ -8350,9 +8352,63 @@ If the user asks "add the GitHub MCP" or "remember that I prefer Python", load t
 ### Typical flow
 
 1. Inbound event arrives (any channel).
-2. You decompose, \`spawn\` one or more workers with explicit goals.
+2. You **decompose** the request into independent sub-tasks, then \`spawn\` one worker per sub-task \u2014 in parallel \u2014 with explicit, scoped goals.
 3. Workers run autonomously. They wake you via SYSTEM events when done / failed / blocked.
 4. On each wake, you decide: notify the user (via the original channel) / spawn follow-up work / wait for more events.
+
+### Decomposition rule
+
+If a single user message contains **multiple independent asks** that don't share state, spawn **one worker per ask, all in the same turn** (parallel \`spawn\` calls). They run concurrently and finish faster. Examples of when to split:
+
+- *"Take a screenshot of the desktop AND open Calculator"*
+  \u2192 spawn \`screenshot\` worker + spawn \`open-calculator\` worker (independent).
+- *"Run the tests and also tell me what changed since yesterday"*
+  \u2192 spawn \`run-tests\` worker + spawn \`git-diff-since-yesterday\` worker.
+- *"Fix the typo in README and bump the version"*
+  \u2192 spawn \`fix-readme-typo\` worker + spawn \`bump-version\` worker.
+
+When NOT to split (keep as one worker):
+
+- The asks share state (one's output feeds the other).
+- The asks are tightly coupled (e.g. *"refactor X and run its tests"* \u2014 the tests depend on the refactor).
+- The asks are trivially small (one or two tool calls each); spawning overhead exceeds the parallelism win.
+
+### Prefer headless tools
+
+When spawning a worker, push it toward the *cheapest tool that gets the job done*:
+
+1. **Bash / file tools** for anything with a CLI (git, npm, brew, builds, tests, file editing, HTTP via curl, scripting).
+2. **agent-browser** (\`load_skill browser\`) for *anything* in a web browser \u2014 refs from \`snapshot -i\` are deterministic, ~100\xD7 cheaper in tokens than pixel coordinates, work cross-platform, and don't need any host permissions.${computerUseAvailable ? `
+3. **Computer use** is the last resort \u2014 only when the task genuinely requires a native macOS GUI app with no CLI / API equivalent (System Settings, Calculator, Finder operations that don't have CLI flags, complex cross-app drag/drop, demos where the user wants to *see* the screen).
+
+A common anti-pattern: a worker reaches for computer use because the user phrased the request visually ("open the website and click the button"). Almost always wrong \u2014 that's a job for the browser skill, not the desktop. Coach the worker in its goal text: *"Use the browser skill (\`load_skill browser\` + \`agent-browser\` with refs from \`snapshot -i\`) to open the site and click the button. Don't use computer use for browser work."*
+
+### Serialize desktop / computer-use tasks
+
+There is exactly **one** desktop, mouse, and keyboard on the host. If two or more workers both need the **\`computer\` tool** (clicking, typing, taking desktop screenshots, opening apps, switching windows), they will **fight over the same screen** \u2014 windows will steal focus from each other, screenshots will catch the wrong app, mouse clicks will land on the wrong target.
+
+**Rule**: when spawning workers, look at each one's goal:
+
+- Does it require **GUI interaction** (open an app, click, type in a window, screenshot the desktop, navigate the OS, drive a real browser/terminal window)? \u2192 mark it as a **desktop task**.
+- Does it only need **headless tools** (bash, file edits, web fetches, code analysis, git, builds, tests run non-interactively)? \u2192 it's a **headless task**.
+
+Then:
+
+- **Spawn ALL headless tasks in parallel** (in the same turn).
+- **Run desktop tasks one at a time**, even if there are multiple of them. Either:
+  - Spawn the first one now, wait for its \`worker.completed\`, then spawn the next; OR
+  - Tell the user the desktop tasks will run sequentially and pick the most important one first.
+
+Example: *"Take a screenshot of Calculator AND run the test suite AND open System Settings"*:
+- \u2713 \`screenshot-calculator\` (desktop) \u2014 spawn now
+- \u2713 \`run-tests\` (headless) \u2014 spawn now, in parallel
+- \u23F3 \`open-system-settings\` (desktop) \u2014 wait until \`screenshot-calculator\` completes, THEN spawn.
+
+Headless workers never interfere with desktop workers (they don't touch the screen), so they always run in parallel.
+
+When you spawn a **desktop worker**, include a one-liner in the goal asking it to **record the session by default** (\`screencapture -v -V <seconds> -C\` on macOS) and return the recording path in its result, *unless* the task is long-running / boring / contains sensitive content. The recording lets you (and the user) replay what actually happened on screen. When the worker reports back, mention the recording path in your reply via the original channel.` : ""}
+
+Default bias: **when in doubt, decompose**. Two workers running in parallel and reporting independently is almost always better UX than one worker doing things sequentially.
 `;
 }
 function createSummaryPrompt(conversationHistory) {
@@ -16366,7 +16422,7 @@ function generateOpenAPISpec() {
 init_config();
 init_semantic();
 init_db();
-import { writeFileSync as writeFileSync6, readFileSync as readFileSync10, existsSync as existsSync21 } from "fs";
+import { mkdirSync as mkdirSync10, writeFileSync as writeFileSync6, readFileSync as readFileSync10, existsSync as existsSync21, statSync as statSync3 } from "fs";
 import { resolve as resolve12, join as join16 } from "path";
 function getCliVersion() {
   const here = dirname8(fileURLToPath5(import.meta.url));
@@ -17970,5 +18026,160 @@ program.command("request-permissions").description("Request macOS permissions fo
   }
   console.log();
 });
+{
+  let stateFilePath = function() {
+    return join16(ensureAppDataDirectory(), "recordings.json");
+  }, readState = function() {
+    const p = stateFilePath();
+    if (!existsSync21(p)) return [];
+    try {
+      return JSON.parse(readFileSync10(p, "utf-8"));
+    } catch {
+      return [];
+    }
+  }, writeState = function(rows) {
+    writeFileSync6(stateFilePath(), JSON.stringify(rows, null, 2), { mode: 384 });
+  }, isAlive = function(pid) {
+    try {
+      process.kill(pid, 0);
+      return true;
+    } catch {
+      return false;
+    }
+  }, pruneDead = function(rows) {
+    return rows.filter((r) => isAlive(r.pid));
+  };
+  stateFilePath2 = stateFilePath, readState2 = readState, writeState2 = writeState, isAlive2 = isAlive, pruneDead2 = pruneDead;
+  const record = program.command("record").description("Start/stop screen recordings");
+  record.command("start").description("Start a screen recording (returns id, path, pid as JSON)").option("--name <slug>", "Optional human-readable label for the recording").option("--dir <path>", "Output directory (default: ~/recordings)").action(async (opts) => {
+    const { spawn: spawn3 } = await import("child_process");
+    const { homedir: homedir2, platform: osPlatform } = await import("os");
+    const outDir = opts.dir ? resolve12(opts.dir.replace(/^~/, homedir2())) : join16(homedir2(), "recordings");
+    mkdirSync10(outDir, { recursive: true });
+    const id = `rec-${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 6)}`;
+    const ext = osPlatform() === "darwin" ? "mov" : "mp4";
+    const filename = `${id}${opts.name ? `-${String(opts.name).replace(/[^a-z0-9-]+/gi, "-").toLowerCase()}` : ""}.${ext}`;
+    const path = join16(outDir, filename);
+    let cmd;
+    let args;
+    if (osPlatform() === "darwin") {
+      cmd = "screencapture";
+      args = ["-v", "-C", "-k", path];
+    } else if (osPlatform() === "linux") {
+      const display = process.env.DISPLAY || ":0.0";
+      const size = process.env.SPARKECODER_RECORD_SIZE || "1920x1080";
+      cmd = "ffmpeg";
+      args = [
+        "-y",
+        "-f",
+        "x11grab",
+        "-framerate",
+        "25",
+        "-video_size",
+        size,
+        "-i",
+        display,
+        "-c:v",
+        "libx264",
+        "-preset",
+        "veryfast",
+        "-pix_fmt",
+        "yuv420p",
+        path
+      ];
+    } else {
+      console.error(JSON.stringify({ error: `Unsupported platform: ${osPlatform()}` }));
+      process.exit(1);
+    }
+    const child = spawn3(cmd, args, { detached: true, stdio: "ignore" });
+    child.unref();
+    if (!child.pid) {
+      console.error(JSON.stringify({ error: `Failed to spawn ${cmd}` }));
+      process.exit(1);
+    }
+    const row = {
+      id,
+      name: opts.name,
+      path,
+      pid: child.pid,
+      startedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      platform: osPlatform()
+    };
+    const rows = pruneDead(readState());
+    rows.push(row);
+    writeState(rows);
+    console.log(JSON.stringify({ id, path, pid: child.pid, platform: osPlatform() }));
+  });
+  record.command("stop <id>").description("Stop a recording started by `sparkecoder record start`").action(async (id) => {
+    const rows = readState();
+    const row = rows.find((r) => r.id === id);
+    if (!row) {
+      console.error(JSON.stringify({ error: `No recording found with id ${id}` }));
+      process.exit(1);
+    }
+    const startedAt = new Date(row.startedAt).getTime();
+    if (isAlive(row.pid)) {
+      try {
+        process.kill(row.pid, "SIGINT");
+      } catch {
+      }
+      for (let i = 0; i < 40; i++) {
+        if (!isAlive(row.pid)) break;
+        await new Promise((r) => setTimeout(r, 200));
+      }
+      if (isAlive(row.pid)) {
+        try {
+          process.kill(row.pid, "SIGTERM");
+        } catch {
+        }
+      }
+    }
+    writeState(rows.filter((r) => r.id !== id));
+    const fileExists = existsSync21(row.path);
+    const sizeMb = fileExists ? Math.round(statSync3(row.path).size / (1024 * 1024) * 10) / 10 : 0;
+    console.log(JSON.stringify({
+      id,
+      path: row.path,
+      durationSec: Math.round((Date.now() - startedAt) / 1e3),
+      sizeMb,
+      ok: fileExists
+    }));
+  });
+  record.command("list").description("List active recordings").action(() => {
+    const rows = pruneDead(readState());
+    writeState(rows);
+    console.log(JSON.stringify(rows, null, 2));
+  });
+  record.command("stop-all").description("Stop every active recording").action(async () => {
+    const rows = readState();
+    const stopped = [];
+    for (const r of rows) {
+      if (isAlive(r.pid)) {
+        try {
+          process.kill(r.pid, "SIGINT");
+        } catch {
+        }
+        for (let i = 0; i < 30; i++) {
+          if (!isAlive(r.pid)) break;
+          await new Promise((res) => setTimeout(res, 200));
+        }
+        if (isAlive(r.pid)) {
+          try {
+            process.kill(r.pid, "SIGTERM");
+          } catch {
+          }
+        }
+      }
+      stopped.push({ id: r.id, path: r.path, ok: existsSync21(r.path) });
+    }
+    writeState([]);
+    console.log(JSON.stringify({ stopped }));
+  });
+}
+var stateFilePath2;
+var readState2;
+var writeState2;
+var isAlive2;
+var pruneDead2;
 program.parse();
 //# sourceMappingURL=cli.js.map