pi-landstrip 0.18.22 → 0.18.23

package/dist/index.ts

@@ -5425,6 +5425,118 @@ function createLandstripIntegration(options = {}) {
       writePaths: options2.writePaths ?? []
     });
   }
+  function createProviderBashOps() {
+    return {
+      async exec(command, cwd, { onData, signal, timeout, env }) {
+        if (!existsSync5(cwd))
+          throw new Error(`Working directory does not exist: ${cwd}`);
+        const provider = activeShellProvider();
+        let invocation;
+        try {
+          invocation = await provider.prepare({
+            command,
+            cwd,
+            env: shellEnvironment(env, cwd, null),
+            signal
+          });
+          if (!invocation.executable.trim()) {
+            throw new Error(`Shell provider "${provider.id}" returned an empty executable`);
+          }
+          if (signal?.aborted)
+            throw new Error("aborted");
+          const prepared = invocation;
+          return await new Promise((resolvePromise, reject) => {
+            let timeoutHandle;
+            let timedOut = false;
+            let settled = false;
+            let childExited = false;
+            let childExitCode = null;
+            let postExitTimer;
+            let stdoutEnded = false;
+            let stderrEnded = false;
+            const child = spawn2(prepared.executable, prepared.args, {
+              cwd,
+              env: createLandstripLauncherEnvironment(prepared.launcherEnv),
+              detached: true,
+              stdio: ["ignore", "pipe", "pipe"]
+            });
+            patchProcessGroupKill(child);
+            const cleanup = async () => {
+              if (timeoutHandle)
+                clearTimeout(timeoutHandle);
+              if (postExitTimer)
+                clearTimeout(postExitTimer);
+              signal?.removeEventListener("abort", onAbort);
+              const toDispose = invocation;
+              invocation = undefined;
+              await toDispose?.dispose?.();
+            };
+            const finish = (code) => {
+              if (settled)
+                return;
+              settled = true;
+              child.stdout?.destroy();
+              child.stderr?.destroy();
+              cleanup().then(() => {
+                if (signal?.aborted)
+                  reject(new Error("aborted"));
+                else if (timedOut)
+                  reject(new Error(`timeout:${timeout}`));
+                else
+                  resolvePromise({ exitCode: code });
+              }, reject);
+            };
+            const maybeFinishAfterExit = () => {
+              if (childExited && stdoutEnded && stderrEnded)
+                finish(childExitCode);
+            };
+            const killChild = () => {
+              child.kill("SIGKILL");
+            };
+            function onAbort() {
+              killChild();
+            }
+            child.stdout?.on("data", onData);
+            child.stderr?.on("data", onData);
+            child.stdout?.once("end", () => {
+              stdoutEnded = true;
+              maybeFinishAfterExit();
+            });
+            child.stderr?.once("end", () => {
+              stderrEnded = true;
+              maybeFinishAfterExit();
+            });
+            child.once("error", (error) => {
+              if (settled)
+                return;
+              settled = true;
+              cleanup().then(() => reject(error), reject);
+            });
+            child.once("exit", (code) => {
+              childExited = true;
+              childExitCode = code;
+              maybeFinishAfterExit();
+              if (!settled)
+                postExitTimer = setTimeout(() => finish(code), EXIT_STDIO_GRACE_MS);
+            });
+            child.once("close", (code) => finish(code));
+            if (timeout !== undefined && timeout > 0) {
+              timeoutHandle = setTimeout(() => {
+                timedOut = true;
+                killChild();
+              }, timeout * 1000);
+            }
+            signal?.addEventListener("abort", onAbort, { once: true });
+            if (signal?.aborted)
+              onAbort();
+          });
+        } catch (error) {
+          await invocation?.dispose?.();
+          throw error;
+        }
+      }
+    };
+  }
   function createLandstripBashOps(ctx, callbacks = {}, allowances = { domains: [], readPaths: [], writePaths: [], targets: [] }) {
     return {
       async exec(command, cwd, { onData, signal, timeout, env }) {
@@ -5920,9 +6032,16 @@ ${message}
         if (!ctx)
           throw new Error("Sandbox context is unavailable");
         if (!ensureSandboxState(ctx)) {
-          if (sandboxState === "unavailable") {
+          if (sandboxState === "unavailable" && externalShellProvider === undefined) {
             throw new Error("Sandbox is unavailable; refusing command");
           }
+          if (externalShellProvider !== undefined) {
+            const providerBash = createBashToolDefinition(ctx.cwd, {
+              operations: createProviderBashOps(),
+              shellPath: SettingsManager.create(ctx.cwd).getShellPath()
+            });
+            return providerBash.execute(id, params, signal, onUpdate, ctx);
+          }
           return localBash.execute(id, params, signal, onUpdate, ctx);
         }
         return runBashWithOptionalRetry(id, params, signal, onUpdate, ctx);
@@ -5942,9 +6061,12 @@ ${message}
       pi.registerTool(createBashTool(localCwd));
     pi.on("user_bash", async (_event, ctx) => {
       if (!ensureSandboxState(ctx)) {
-        if (sandboxState === "unavailable") {
+        if (sandboxState === "unavailable" && externalShellProvider === undefined) {
           throw new Error("Sandbox is unavailable; refusing command");
         }
+        if (externalShellProvider !== undefined) {
+          return { operations: createProviderBashOps() };
+        }
         return;
       }
       return { operations: createLandstripBashOps(ctx, { promptOnBlock: true }) };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-landstrip",
-  "version": "0.18.22",
+  "version": "0.18.23",
   "description": "Sandboxed Bash and process-backed agents for Pi",
   "keywords": [
     "landstrip",
@@ -39,7 +39,7 @@
     "ci:test": "npm run test"
   },
   "dependencies": {
-    "@landstrip/landstrip": "^0.18.22",
+    "@landstrip/landstrip": "^0.18.23",
     "jsonc-parser": "^3.3.1",
     "minimatch": "^10.2.5",
     "yaml": "^2.9.0"