moshcode 0.51.0 → 0.52.0

package/README.md

@@ -1035,7 +1035,7 @@ chmod +x deploy.mosh
 | `ask(prompt)` | blocking gate — waits for human reply at moshcode.sh |
 | `say("…")` | print a line |
 | `sleep(ms)` | pause for N milliseconds (blocking) |
-| `shell(cmd)` | run a shell command (blocking, `$SHELL -c`); returns `{ ok, code }` |
+| `shell(cmd)` | run a shell command (blocking, `$SHELL -ic`, so your rc file loads); returns `{ ok, code }` |
 | `stop()` | end the loop (`alive = false`) |
 | `repeat()` | back to the top of the loop |
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "moshcode",
-  "version": "0.51.0",
+  "version": "0.52.0",
   "type": "module",
   "description": "moshcode — a metal wrapper for coding engines and native UGig/CoinPay workflow CLIs, with OpenPRD and moshscript",
   "repository": {

package/src/aliases.mjs

@@ -8,7 +8,7 @@
 // An alias is a name and a line. The line is a shell command unless it starts
 // with `/`, in which case it is a pit command:
 //
-//   /alias set gs "git status"       → /gs   runs `$SHELL -c "git status"`
+//   /alias set gs "git status"       → /gs   runs `$SHELL -ic "git status"`
 //   /alias set cc "/agents claude"   → /cc   opens claude autonomously
 //
 // Shell-by-default because that is what the prompt is mostly asked for, and the
@@ -148,7 +148,7 @@ export function removeAlias(name) {
  *
  * Appended rather than substituted, the way a shell alias behaves: `/gs -sb` is
  * `git status -sb`. `args` is the raw remainder of the typed line, not the
- * tokenized parts, so the user's own quoting survives into `$SHELL -c`.
+ * tokenized parts, so the user's own quoting survives into `$SHELL -ic`.
  *
  * The `!` is what routes a bare value to the shell — the pit already reads a
  * leading `!` as "run this in $SHELL", so an alias does not need a second path

package/src/commands.mjs

@@ -20,6 +20,7 @@ import { cliVerb, aiVerb } from "./cli.mjs";
 import { ingestApproval, pollApproval } from "./notify.mjs";
 import { capture, killSession, sendPrompt } from "./herd.mjs";
 import { herdStart, roster, waitFor } from "./herd-cli.mjs";
+import { shellInvocation } from "./shell.mjs";
 
 // The moshcoding pit-anthem playlist. mosh() blasts this URL and, on a desktop
 // with a GUI, tries to open it in the default browser.
@@ -190,9 +191,9 @@ const COMMANDS = [
 
   {
     name: "shell",
-    summary: "run a shell command (blocking, cmd.exe on Windows or $SHELL -c elsewhere)",
+    summary: "run a shell command (blocking, cmd.exe on Windows or $SHELL elsewhere)",
     usage: "shell(cmd)",
-    detail: "runs cmd in $SHELL; returns { ok, code, signal }",
+    detail: "runs cmd in $SHELL, loading your rc file where it can; returns { ok, code, signal }",
     // 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
@@ -202,15 +203,16 @@ const COMMANDS = [
       const cmd = args.join(" ");
       if (!cmd) throw new Error("moshscript: shell() requires a command string");
       if (ctx.dryRun) {
-        ctx.out(`  ▶ shell(${JSON.stringify(cmd)}) → would run: $SHELL -c ${JSON.stringify(cmd)}`);
+        ctx.out(`  ▶ shell(${JSON.stringify(cmd)}) → would run: $SHELL ${shellInvocation(cmd).flags} ${JSON.stringify(cmd)}`);
         // Same R8 contract as the comment above: `code` is always present, so a
         // script branching on the exit status behaves the same under --dry-run.
         return { ok: true, code: 0, dryRun: true };
       }
-      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];
+      // Same invocation the pit's own `!cmd` uses, so a command that works when
+      // typed works when scripted: interactive where a terminal is attached, so
+      // the user's rc file — and the aliases in it — are loaded. src/shell.mjs
+      // has the reasoning, including why a headless run stays non-interactive.
+      const { shell: sh, args: shArgs } = shellInvocation(cmd);
       ctx.out(`  ▶ shell: ${cmd}`);
       const res = spawnSync(sh, shArgs, { stdio: "inherit" });
       if (res.error) throw res.error;

package/src/shell.mjs

@@ -0,0 +1,96 @@
+// One answer to "how does the pit run a shell command".
+//
+// The pit is not a shell, so everything it runs on the user's behalf goes out
+// through $SHELL: `!cmd`, `/shell`, a shell-valued alias from /alias, and
+// moshscript's shell(). The obvious spelling is `$SHELL -c "<cmd>"`, and it is
+// wrong in a way that costs an afternoon to find. `zsh -c` and `bash -c` are
+// non-interactive shells, and a non-interactive shell does not read ~/.zshrc or
+// ~/.bashrc — so the aliases and functions defined there are simply not there:
+//
+//   /alias set prs gh-prs-all     → zsh -c gh-prs-all
+//                                 → zsh:1: command not found: gh-prs-all
+//
+// while the identical word works when typed at a prompt. That is a bug rather
+// than a footnote, because naming a shell command is most of what /alias is
+// for, and the shell commands people name are the ones they already named once
+// in ~/.zsh_aliases. An alias that resolves at the prompt and not in the pit
+// makes the pit look broken, and from the user's side it is.
+//
+// So we ask for an interactive shell. `-i` is the switch that makes bash and
+// zsh read their rc file, and the rc file is where the user's shell actually
+// lives. Anything already on PATH worked before and still works; what changes
+// is that aliases and functions now resolve too.
+
+/**
+ * Shells whose startup file is read only when the shell is interactive.
+ *
+ * Deliberately just bash and zsh. fish sources config.fish however it was
+ * started, so it needs nothing from us; plain sh/dash have no rc file to miss
+ * and `-i` would only buy them job-control machinery; and a shell we have not
+ * heard of is likelier to be harmed by an unexpected flag than helped by it.
+ * Being wrong here means running a command in a shell that cannot see the
+ * user's aliases, which is exactly where we started — so an unknown shell
+ * lands on the old behaviour rather than on a guess.
+ */
+const RC_ON_INTERACTIVE = new Set(["bash", "zsh"]);
+
+/** Set this to opt a session out of rc loading and get plain `-c` back. */
+export const NO_RC_ENV = "MOSHCODE_SHELL_NO_RC";
+
+/** Windows has no rc file in this sense; cmd.exe wants its own flag spelling. */
+const CMD_FLAGS = ["/d", "/s", "/c"];
+
+/** The shell the user runs, or the platform's fallback. */
+export function shellPath(env = process.env, platform = process.platform) {
+  if (platform === "win32") return env.COMSPEC || "cmd.exe";
+  return env.SHELL || "/bin/sh";
+}
+
+/**
+ * `zsh` from `/usr/bin/zsh`, `bash` from `C:\...\bash.exe`.
+ *
+ * Both separators by hand rather than path.basename, which is bound to the
+ * platform the code is running on: it would leave a Windows path intact when
+ * asked on Linux, and this function is also asked about the other platform —
+ * shellInvocation takes `platform` as an option so the Windows branch can be
+ * tested from anywhere.
+ */
+export function shellName(shell) {
+  const tail = String(shell || "").split(/[\\/]/).pop() || "";
+  return tail.replace(/\.exe$/i, "");
+}
+
+/**
+ * How to spawn `rawCmd`, as { shell, args, flags, interactive }.
+ *
+ * `rawCmd` empty means "a shell to sit in" — no args at all, which is already
+ * an interactive shell and already reads the rc file.
+ *
+ * `tty` is why this takes options rather than reading the world directly. An
+ * interactive bash with no terminal attached prints
+ *
+ *   bash: cannot set terminal process group (…): Inappropriate ioctl for device
+ *   bash: no job control in this shell
+ *
+ * on stderr before it runs a thing, which would turn every headless run — cron,
+ * CI, `moshcode run script.mosh` in a pipeline — into noise around the output
+ * someone is trying to read. With a terminal attached, both shells are silent.
+ * So the rc file is loaded where a person is watching, which is the case that
+ * wanted it, and a headless run keeps the old quiet behaviour. zsh alone would
+ * not need the guard; the guard is not worth splitting per shell for.
+ */
+export function shellInvocation(rawCmd, {
+  env = process.env,
+  platform = process.platform,
+  tty = Boolean(process.stdin?.isTTY && process.stdout?.isTTY),
+} = {}) {
+  const shell = shellPath(env, platform);
+  const name = shellName(shell);
+  if (!rawCmd) return { shell, args: [], flags: "", interactive: true, name };
+  if (platform === "win32") {
+    return { shell, args: [...CMD_FLAGS, rawCmd], flags: CMD_FLAGS.join(" "), interactive: false, name };
+  }
+  const interactive = tty && RC_ON_INTERACTIVE.has(name) && !env[NO_RC_ENV];
+  const flags = interactive ? "-ic" : "-c";
+  return { shell, args: [flags, rawCmd], flags, interactive, name };
+}

package/src/tui.mjs

@@ -25,6 +25,7 @@ import { stocksCommand } from "./advisor.mjs";
 import { cryptoCommand } from "./crypto.mjs";
 import { gamesCommand } from "./games.mjs";
 import { canOpenBrowser, openBrowser } from "./open-url.mjs";
+import { shellInvocation } from "./shell.mjs";
 import { banner, hr, acid, ash, bone, dim, ok, err, warn, info, moshcodeVersion } from "./ui.mjs";
 import { CORE_CLI_COMMAND_NAMES } from "./cli-schema.mjs";
 import { RENAMED_COMMANDS, findPitCommand, pitHelpModel, renderPitCommand, suggest, wantsHelp } from "./help.mjs";
@@ -128,7 +129,7 @@ export function splitCommandLine(line) {
 }
 
 // Everything after the first word of a command line, exactly as typed. `/shell`
-// hands this straight to `$SHELL -c`, the same way `!cmd` does: the shell does
+// hands this straight to `$SHELL -ic`, the same way `!cmd` does: the shell does
 // its own parsing, so re-joining the tokenized parts would strip the user's
 // quotes and escapes and silently split `-m "two words"` into two arguments.
 function commandRemainder(line, words = 1) {
@@ -148,7 +149,7 @@ function commandRemainder(line, words = 1) {
  * quotes there belong to the shell. Tokenizing tells the two apart: exactly one
  * token means the whole value was quoted, so use it with the quotes stripped;
  * anything else is a bare command line, and it goes through verbatim so the
- * user's own quoting survives into `$SHELL -c`.
+ * user's own quoting survives into `$SHELL -ic`.
  */
 export function aliasValue(line) {
   const raw = commandRemainder(line, 3); // past "/alias", "set", "<name>"
@@ -508,12 +509,12 @@ async function openWorkflowTool(key, tool, args) {
 
 // Spawn the user's shell with the terminal fully handed over (stdio inherit),
 // inheriting the current cwd + env. No args → an interactive shell; a raw
-// command string → `$SHELL -c "<cmd>"` (one-off). Resolves { ok, code, signal }.
+// command string → `$SHELL -ic "<cmd>"` (one-off). Interactive so the command
+// can see the aliases and functions in ~/.zshrc — see src/shell.mjs for why
+// that is not optional. Resolves { ok, code, signal }.
 function runShell(rawCmd) {
   return new Promise((resolve) => {
-    const shell = process.env.SHELL
-      || (process.platform === "win32" ? (process.env.COMSPEC || "cmd.exe") : "/bin/sh");
-    const args = rawCmd ? ["-c", rawCmd] : [];
+    const { shell, args } = shellInvocation(rawCmd);
     let child;
     try { child = spawn(shell, args, { stdio: "inherit" }); }
     catch (e) { resolve({ ok: false, error: e }); return; }
@@ -525,9 +526,12 @@ function runShell(rawCmd) {
 // vim `:sh` — drop into a shell and land back at the mosh prompt on exit, with
 // the whole TUI session (history, cwd) intact. `rawCmd` runs a one-off instead.
 async function openShell(rawCmd) {
-  const shellName = path.basename(process.env.SHELL || "sh");
+  // The flags come from the same place the spawn does, so the echoed line is
+  // what actually ran — a `-c` printed above an `-ic` invocation is the kind of
+  // small lie that sends someone debugging the wrong shell.
+  const { flags, name: shellName } = shellInvocation(rawCmd);
   console.log(info(rawCmd
-    ? `${bone(shellName)} ${ash("-c")} ${ash(rawCmd)}`
+    ? `${bone(shellName)} ${ash(flags)} ${ash(rawCmd)}`
     : `dropping to ${bone(shellName)} — ${ash("`exit` or Ctrl-D brings you back to the pit")}`));
   console.log(hr());
   const r = await runShell(rawCmd);