Merge remote-tracking branch 'origin/main'

# Conflicts:
#	.github/workflows/ci.yml

Author: ralyodio

.github/workflows/ci.yml

@@ -1,33 +1,43 @@
+# Managed by sh1pt Actions Fleet
+# pack: node-pnpm-ci@1.2.0
+# install: sh1pt-actions-store
+# hash: sha256:4c5b9b88dee99de5f463194b4784ab267b400789a6d0f1aaf5b5dede9236376f
 name: CI
 
 on:
   push:
-    branches: [main]
+    branches: [main, master]
   pull_request:
 
 permissions:
   contents: read
 
 concurrency:
-  group: ci-${{ github.ref }}
+  group: ci-${{ github.workflow }}-${{ github.ref }}
   cancel-in-progress: true
 
 jobs:
-  test:
+  build:
     runs-on: ubuntu-latest
     timeout-minutes: 15
-    strategy:
-      matrix:
-        node-version: [22, 24]
     steps:
       - uses: actions/checkout@v4
 
+      # pnpm version is read from the "packageManager" field in package.json.
+      # Do not pin a version here — it conflicts with packageManager and fails
+      # with ERR_PNPM_BAD_PM_VERSION.
+      - uses: pnpm/action-setup@v4
+
       - uses: actions/setup-node@v4
         with:
-          node-version: ${{ matrix.node-version }}
+          node-version: '22'
+          cache: pnpm
+
+      - run: pnpm install --frozen-lockfile
 
-      - run: npm install --no-audit --no-fund
+      # typecheck / test default to `pnpm run --if-present <script>` so a repo
+      # that hasn't defined these scripts yet gets a green workflow instead of
+      # failing on the first step. Once the scripts exist they run normally.
+      - run: pnpm run --if-present typecheck
 
-      - run: npm test
-        env:
-          CI: true
+      - run: pnpm run --if-present test

.github/workflows/test.yml

@@ -0,0 +1,39 @@
+# Managed by sh1pt Actions Fleet
+# pack: node-pnpm-test@1.2.0
+# install: sh1pt-actions-store
+# hash: sha256:53499e840c5023f2235444afd4f6a36d2c0bf8a40c52cfdf84615b17624de69b
+name: test
+
+on:
+  pull_request:
+  push:
+    branches: [master]
+
+permissions:
+  contents: read
+
+jobs:
+  test:
+    runs-on: ubuntu-latest
+    timeout-minutes: 15
+    steps:
+      - uses: actions/checkout@v4
+
+      # pnpm version is read from the "packageManager" field in package.json.
+      # Do not pin a version here — it conflicts with packageManager and fails
+      # with ERR_PNPM_BAD_PM_VERSION.
+      - uses: pnpm/action-setup@v4
+
+      - uses: actions/setup-node@v4
+        with:
+          node-version: 22
+          cache: pnpm
+
+      - run: pnpm install --frozen-lockfile
+
+      # test defaults to `pnpm run --if-present test` so a repo that hasn't
+      # defined a test script yet gets a green workflow instead of failing on
+      # the first step. Once the script exists it runs normally.
+      - run: pnpm run --if-present test
+        env:
+          CI: true

bin/moshcode.mjs

@@ -1,6 +1,5 @@
 #!/usr/bin/env node
 import fs from "node:fs";
-import { spawn } from "node:child_process";
 import { fileURLToPath } from "node:url";
 import path from "node:path";
 import { runScript } from "../src/runtime.mjs";
@@ -12,6 +11,7 @@ import {
   engineStatus,
   resolveEngine,
   openSession,
+  runCmd,
 } from "../src/engines.mjs";
 import { TOOLS, toolList, toolStatus, resolveTool, openTool } from "../src/tools.mjs";
 import { runUpgrade } from "../src/upgrade.mjs";
@@ -20,6 +20,7 @@ import { locate, tilde } from "../src/pwd.mjs";
 import { createPrd, listPrds, authoringPrompt } from "../src/prd.mjs";
 import { login, loginDevice, whoami, logout } from "../src/auth.mjs";
 import { tui } from "../src/tui.mjs";
+import { moshcodeVersion } from "../src/ui.mjs";
 
 const HERE = path.dirname(fileURLToPath(import.meta.url));
 const EXAMPLE = path.join(HERE, "..", "examples", "alive.mosh");
@@ -171,6 +172,11 @@ async function main() {
   // No args → open the interactive TUI shell (/agents <engine>, etc.).
   if (cmd === undefined) return tui();
 
+  if (cmd === "--version" || cmd === "-v" || cmd === "version") {
+    console.log(moshcodeVersion() || "unknown");
+    return;
+  }
+
   if (cmd === "engines") {
     printEngineStatus();
     return;
@@ -222,13 +228,14 @@ async function main() {
     }
     const { install, desc, bin } = entry;
     console.log(`🎸 installing ${target} — ${desc}\n$ ${install.cmd} ${install.args.join(" ")}\n`);
-    const child = spawn(install.cmd, install.args, { stdio: "inherit" });
-    child.on("error", (e) => { console.error(`install failed: ${e.message}`); process.exit(1); });
-    child.on("exit", (code) => {
-      if (code === 0) console.log(`\n✓ ${target} installed. run it with \`${bin}\`. 🤘`);
-      backToPit(`install ${target}`, code);
-    });
-    return;
+    const result = await runCmd(install.cmd, install.args);
+    if (!result.ok) {
+      console.error(`install failed: ${result.error?.message || result.error || "unknown error"}`);
+      process.exitCode = 1;
+      return;
+    }
+    if (result.code === 0) console.log(`\n✓ ${target} installed. run it with \`${bin}\`. 🤘`);
+    return backToPit(`install ${target}`, result.code);
   }
   if (cmd === "upgrade" || cmd === "update") {
     console.log("🎸 moshcode upgrade — updating moshcode + installed engines/tools 🤘");

package.json

@@ -2,7 +2,7 @@
   "name": "moshcode",
   "version": "0.11.0",
   "type": "module",
-  "description": "moshcode — a metal wrapper for coding engines and native UGig/CoinPay workflow CLIs, with OpenPRD and moshscript",
+  "description": "moshcode \u2014 a metal wrapper for coding engines and native UGig/CoinPay workflow CLIs, with OpenPRD and moshscript",
   "bin": {
     "moshcode": "./bin/moshcode.mjs",
     "moshscript": "./bin/moshscript.mjs"
@@ -20,5 +20,6 @@
     "install.sh",
     "README.md"
   ],
-  "license": "MIT"
+  "license": "MIT",
+  "packageManager": "pnpm@10.32.1"
 }

pnpm-lock.yaml

@@ -158,7 +158,7 @@ const COMMANDS = [
 
   {
     name: "shell",
-    summary: "run a shell command (blocking, spawnSync $SHELL -c)",
+    summary: "run a shell command (blocking, cmd.exe on Windows or $SHELL -c elsewhere)",
     // The moshscript system verb for arbitrary shell commands. Blocking
     // (spawnSync + inherited stdio) so it runs inline in the no-`await` style,
     // and the child owns the terminal for interactive commands. Returns
@@ -171,10 +171,12 @@ const COMMANDS = [
         ctx.out(`  ▶ shell(${JSON.stringify(cmd)}) → would run: $SHELL -c ${JSON.stringify(cmd)}`);
         return { ok: true, dryRun: true };
       }
-      const sh = process.env.SHELL
-        || (process.platform === "win32" ? (process.env.COMSPEC || "cmd.exe") : "/bin/sh");
+      const sh = process.platform === "win32"
+        ? (process.env.COMSPEC || "cmd.exe")
+        : (process.env.SHELL || "/bin/sh");
+      const shArgs = process.platform === "win32" ? ["/d", "/s", "/c", cmd] : ["-c", cmd];
       ctx.out(`  ▶ shell: ${cmd}`);
-      const res = spawnSync(sh, ["-c", cmd], { stdio: "inherit" });
+      const res = spawnSync(sh, shArgs, { stdio: "inherit" });
       if (res.error) throw res.error;
       const code = res.status ?? 1;
       if (code !== 0) {

src/commands.mjs

@@ -11,7 +11,7 @@
 // `agentsView` fall back to `agentArgs` — an autonomous session with native
 // approvals bypassed/auto-approved.
 import { spawn } from "node:child_process";
-import { existsSync, statSync } from "node:fs";
+import { existsSync, readFileSync, statSync } from "node:fs";
 import path from "node:path";
 
 export const ENGINES = {
@@ -82,15 +82,54 @@ export function resolveEngine(token) {
   return key ? [key, ENGINES[key]] : null;
 }
 
-/** Is `bin` an executable on PATH? (cross-platform-ish) */
-export function isInstalled(bin) {
-  const exts = process.platform === "win32" ? (process.env.PATHEXT || ".EXE;.CMD;.BAT").split(";") : [""];
-  for (const dir of (process.env.PATH || "").split(path.delimiter).filter(Boolean)) {
+function executableCandidates(bin) {
+  const exts = process.platform === "win32" ? ["", ...(process.env.PATHEXT || ".EXE;.CMD;.BAT").split(";")] : [""];
+  const dirs = path.isAbsolute(bin) || bin.includes(path.sep) ? [""] : (process.env.PATH || "").split(path.delimiter).filter(Boolean);
+  const seen = new Set();
+  const candidates = [];
+  for (const dir of dirs) {
     for (const ext of exts) {
-      try { if (existsSync(path.join(dir, bin + ext)) && statSync(path.join(dir, bin + ext)).isFile()) return true; } catch { /* keep looking */ }
+      const candidate = dir ? path.join(dir, bin + ext) : bin + ext;
+      const key = candidate.toLowerCase();
+      if (!seen.has(key)) {
+        seen.add(key);
+        candidates.push(candidate);
+      }
     }
   }
-  return false;
+  return candidates;
+}
+
+function resolveExecutable(bin) {
+  for (const candidate of executableCandidates(bin)) {
+    try {
+      if (existsSync(candidate) && statSync(candidate).isFile()) return candidate;
+    } catch { /* keep looking */ }
+  }
+  return null;
+}
+
+function nodeShebang(file) {
+  try {
+    const head = readFileSync(file, "utf8").slice(0, 80);
+    return /^#!.*\bnode(?:\.exe)?\b/.test(head);
+  } catch {
+    return false;
+  }
+}
+
+function spawnSpec(bin, args = []) {
+  const resolved = resolveExecutable(bin);
+  if (!resolved) return { cmd: bin, args };
+  if (process.platform === "win32" && path.extname(resolved) === "" && nodeShebang(resolved)) {
+    return { cmd: process.execPath, args: [resolved, ...args] };
+  }
+  return { cmd: resolved, args };
+}
+
+/** Is `bin` an executable on PATH? (cross-platform-ish) */
+export function isInstalled(bin) {
+  return Boolean(resolveExecutable(bin));
 }
 
 // Headless "run one prompt, print the answer, exit" invocation per engine — the
@@ -147,7 +186,8 @@ export function agentLaunchArgs(engine, args = []) {
 export function runCmd(cmd, args = []) {
   return new Promise((resolve) => {
     let child;
-    try { child = spawn(cmd, args, { stdio: "inherit" }); }
+    const spec = spawnSpec(cmd, args);
+    try { child = spawn(spec.cmd, spec.args, { stdio: "inherit" }); }
     catch (e) { resolve({ ok: false, error: e }); return; }
     child.on("error", (e) => resolve({ ok: false, error: e }));
     child.on("exit", (code, signal) => resolve({ ok: true, code, signal }));
@@ -168,7 +208,8 @@ export function openPassthrough(target, args = []) {
       for (const k of target.stripEnv) delete env[k];
     }
     let child;
-    try { child = spawn(target.bin, args, { stdio: "inherit", env }); }
+    const spec = spawnSpec(target.bin, args);
+    try { child = spawn(spec.cmd, spec.args, { stdio: "inherit", env }); }
     catch (e) { resolve({ ok: false, error: e }); return; }
     child.on("error", (e) => resolve({ ok: false, error: e }));
     child.on("exit", (code, signal) => resolve({ ok: true, code, signal }));

src/engines.mjs

@@ -65,3 +65,66 @@ export function toolUpgradeSpec(tool) {
 export function openTool(tool, args = []) {
   return openPassthrough(tool, args);
 }
+
+// Generic utilities used by the app/package surface.
+
+/**
+ * Format a number as currency
+ */
+export function formatCurrency(amount, currency = 'USD') {
+  return new Intl.NumberFormat('en-US', {
+    style: 'currency',
+    currency
+  }).format(amount);
+}
+
+/**
+ * Generate a random ID
+ */
+export function generateId(length = 8) {
+  const chars = 'abcdefghijklmnopqrstuvwxyz0123456789';
+  let result = '';
+  for (let i = 0; i < length; i++) {
+    result += chars.charAt(Math.floor(Math.random() * chars.length));
+  }
+  return result;
+}
+
+/**
+ * Debounce function calls
+ */
+export function debounce(fn, delay = 300) {
+  let timeoutId;
+  return function (...args) {
+    clearTimeout(timeoutId);
+    timeoutId = setTimeout(() => fn.apply(this, args), delay);
+  };
+}
+
+/**
+ * Deep clone an object
+ */
+export function deepClone(obj) {
+  return JSON.parse(JSON.stringify(obj));
+}
+
+/**
+ * Sleep for ms milliseconds
+ */
+export function sleep(ms) {
+  return new Promise(resolve => setTimeout(resolve, ms));
+}
+
+/**
+ * Retry a function with exponential backoff
+ */
+export async function retry(fn, maxAttempts = 3, baseDelay = 1000) {
+  for (let attempt = 1; attempt <= maxAttempts; attempt++) {
+    try {
+      return await fn();
+    } catch (error) {
+      if (attempt === maxAttempts) throw error;
+      await sleep(baseDelay * Math.pow(2, attempt - 1));
+    }
+  }
+}