@sema-agent/server 1.293.0 → 1.294.0

package/dist/hooks/hook-runner.js

@@ -1,8 +1,10 @@
 import { spawn } from "node:child_process";
+import { hostShell, resolveHostShell } from "../plugins/host-platform.js";
 import { HooksConfig, DEFAULT_HOOK_TIMEOUT_SECONDS, HOOK_EVENT_OWNER, } from "@sema-agent/registry-core/hooks";
 import { redactSecrets } from "../trace/redact.js";
 import { ccPromptSystemFor, wrapCondition, parseCcVerdict, CC_EVALUATOR_MAX_OUTPUT_TOKENS } from "./cc-stop-prompt.js";
 import { renderBranchTranscript } from "./branch-transcript.js";
+void resolveHostShell().catch(() => undefined);
 export const MAX_HOOK_ENTRIES_PER_EVENT = 32;
 export const MAX_HOOK_COMMAND_CHARS = 8_192;
 export const MAX_HOOK_TIMEOUT_SECONDS = 600;
@@ -144,7 +146,8 @@ function runCommandHook(entry, payload, ctx) {
         const timeoutMs = Math.min(entry.timeout ?? DEFAULT_HOOK_TIMEOUT_SECONDS, MAX_HOOK_TIMEOUT_SECONDS) * 1000;
         let child;
         try {
-            child = spawn("/bin/sh", ["-c", entry.command], {
+            const sh = hostShell();
+            child = spawn(sh.shell, [...sh.args, entry.command], {
                 cwd: ctx.cwd,
                 env: hookEnv(ctx),
                 stdio: ["pipe", "pipe", "pipe"],
@@ -203,7 +206,8 @@ function fireAsyncCommandHook(entry, payload, ctx, event) {
     try {
         const rewake = entry.asyncRewake === true;
         const timeoutMs = Math.min(entry.timeout ?? DEFAULT_HOOK_TIMEOUT_SECONDS, MAX_HOOK_TIMEOUT_SECONDS) * 1000;
-        const child = spawn("/bin/sh", ["-c", entry.command], {
+        const sh = hostShell();
+        const child = spawn(sh.shell, [...sh.args, entry.command], {
             cwd: ctx.cwd,
             env: hookEnv(ctx),
             stdio: ["pipe", "ignore", rewake ? "pipe" : "ignore"],

package/dist/plugins/host-platform.js

@@ -1,10 +1,16 @@
 import { getShellConfig, killProcessTree, signalProcessTree } from "@sema-agent/core";
 export const IS_WIN32 = process.platform === "win32";
-const POSIX_SHELL = { shell: "/bin/sh", args: ["-c"] };
+const POSIX_SH_FALLBACK = { shell: "/bin/sh", args: ["-c"] };
 let cachedWinShell;
+let cachedPosixShell;
 export async function resolveHostShell() {
-    if (!IS_WIN32)
-        return POSIX_SHELL;
+    if (!IS_WIN32) {
+        if (cachedPosixShell)
+            return cachedPosixShell;
+        const posixCfg = await getShellConfig(process.env.HOST_SHELL_PATH || undefined);
+        cachedPosixShell = posixCfg.ok ? { shell: posixCfg.value.shell, args: posixCfg.value.args } : POSIX_SH_FALLBACK;
+        return cachedPosixShell;
+    }
     if (cachedWinShell)
         return cachedWinShell;
     const custom = process.env.HOST_SHELL_PATH;
@@ -18,14 +24,16 @@ export async function resolveHostShell() {
     return cachedWinShell;
 }
 export function hostShell() {
-    if (!IS_WIN32)
-        return POSIX_SHELL;
+    if (!IS_WIN32) {
+        return cachedPosixShell ?? POSIX_SH_FALLBACK;
+    }
     if (!cachedWinShell)
         throw new Error("host shell not resolved yet — resolveHostShell() must settle before any spawn (shellReady ordering bug)");
     return cachedWinShell;
 }
 export function resetHostShellCacheForTest() {
     cachedWinShell = undefined;
+    cachedPosixShell = undefined;
 }
 export function spawnGroupOptions() {
     return IS_WIN32 ? { detached: false, windowsHide: true } : { detached: true };

package/dist/plugins/remote-env-local-docker.d.ts

@@ -114,6 +114,9 @@ export declare class RemoteLocalDockerExecutionEnv implements RemoteExecutionEnv
     private execArgv;
     private execRaw;
     private docker;
+    private containerShell;
+    private containerShellProbed;
+    private probeContainerShell;
     private ensureConnectedExec;
     private fsReady;
     private tempResult;

package/dist/plugins/remote-env-local-docker.js

@@ -480,7 +480,7 @@ export class RemoteLocalDockerExecutionEnv {
         const mergedEnv = { ...(this.cfg.env ?? {}), ...(env ?? {}) };
         for (const [k, v] of Object.entries(mergedEnv))
             args.push("-e", `${k}=${v}`);
-        args.push(this.containerName, "/bin/sh", "-c", command);
+        args.push(this.containerName, this.containerShell, "-c", command);
         return args;
     }
     execRaw(command) {
@@ -547,14 +547,31 @@ export class RemoteLocalDockerExecutionEnv {
             });
         });
     }
+    containerShell = "/bin/sh";
+    containerShellProbed = false;
+    async probeContainerShell() {
+        if (this.containerShellProbed)
+            return;
+        this.containerShellProbed = true;
+        try {
+            const r = await this.docker(this.withHostFlag(["exec", this.containerName, "/bin/sh", "-c", "command -v bash"]), { timeoutMs: this.cfg.controlTimeoutMs });
+            if (r.ok && r.value.exitCode === 0 && r.value.stdout.trim().length > 0)
+                this.containerShell = "bash";
+        }
+        catch {
+        }
+    }
     async ensureConnectedExec() {
         if (this.destroyed)
             return { ok: false, error: new ExecutionError("shell_unavailable", "execution env already destroyed") };
-        if (this.containerId)
+        if (this.containerId) {
+            await this.probeContainerShell();
             return ok(undefined);
+        }
         const c = await this.connect();
         if (!c.ok)
             return { ok: false, error: new ExecutionError("shell_unavailable", `local-docker connect failed: ${c.error.message}`, c.error) };
+        await this.probeContainerShell();
         return ok(undefined);
     }
     async fsReady(p) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sema-agent/server",
-  "version": "1.293.0",
+  "version": "1.294.0",
   "description": "Sema Server — the server/API implementation layer for Sema, wiring core, registry, model providers, and cloud agent execution. Built on @sema-agent/core.",
   "type": "module",
   "license": "BUSL-1.1",