pzero-operator 0.1.6 → 0.1.8

package/dist/utils/shell.js

@@ -2,17 +2,15 @@ import { existsSync } from "node:fs";
 import { delimiter } from "node:path";
 import { spawn, spawnSync } from "child_process";
 import { getBinDir } from "../config.js";
-/**
- * Find bash executable on PATH (cross-platform)
- */
-function findBashOnPath() {
-    if (process.platform === "win32") {
-        // Windows: Use 'where' and verify file exists (where can return non-existent paths)
+function findExecutableOnPath(candidates) {
+    const commands = Array.isArray(candidates) ? candidates : [candidates];
+    const lookupCommand = process.platform === "win32" ? "where" : "which";
+    for (const candidate of commands) {
         try {
-            const result = spawnSync("where", ["bash.exe"], { encoding: "utf-8", timeout: 5000 });
+            const result = spawnSync(lookupCommand, [candidate], { encoding: "utf-8", timeout: 5000 });
             if (result.status === 0 && result.stdout) {
                 const firstMatch = result.stdout.trim().split(/\r?\n/)[0];
-                if (firstMatch && existsSync(firstMatch)) {
+                if (firstMatch && (process.platform !== "win32" || existsSync(firstMatch))) {
                     return firstMatch;
                 }
             }
@@ -20,74 +18,107 @@ function findBashOnPath() {
         catch {
             // Ignore errors
         }
-        return null;
     }
-    // Unix: Use 'which' and trust its output (handles Termux and special filesystems)
-    try {
-        const result = spawnSync("which", ["bash"], { encoding: "utf-8", timeout: 5000 });
-        if (result.status === 0 && result.stdout) {
-            const firstMatch = result.stdout.trim().split(/\r?\n/)[0];
-            if (firstMatch) {
-                return firstMatch;
-            }
+    return null;
+}
+function getShellConfigForExecutable(shellPath) {
+    const normalized = shellPath.toLowerCase();
+    if (process.platform === "win32") {
+        if (normalized.endsWith("pwsh.exe") || normalized.endsWith("\\pwsh")) {
+            return {
+                shell: shellPath,
+                args: ["-NoLogo", "-NoProfile", "-NonInteractive", "-Command"],
+                kind: "powershell",
+                displayName: "PowerShell",
+            };
+        }
+        if (normalized.endsWith("powershell.exe") || normalized.endsWith("\\powershell")) {
+            return {
+                shell: shellPath,
+                args: ["-NoLogo", "-NoProfile", "-NonInteractive", "-Command"],
+                kind: "powershell",
+                displayName: "Windows PowerShell",
+            };
         }
     }
-    catch {
-        // Ignore errors
-    }
-    return null;
+    return {
+        shell: shellPath,
+        args: ["-c"],
+        kind: "bash",
+        displayName: process.platform === "win32" ? "Bash" : "Shell",
+    };
+}
+/**
+ * Find bash executable on PATH (cross-platform)
+ */
+function findBashOnPath() {
+    return process.platform === "win32" ? findExecutableOnPath("bash.exe") : findExecutableOnPath("bash");
 }
 /**
  * Resolve shell configuration based on platform and an optional explicit shell path.
  * Resolution order:
  * 1. User-specified shellPath
- * 2. On Windows: Git Bash in known locations, then bash on PATH
+ * 2. On Windows: PowerShell Core, Windows PowerShell, Git Bash, then bash on PATH
  * 3. On Unix: /bin/bash, then bash on PATH, then fallback to sh
  */
 export function getShellConfig(customShellPath) {
     // 1. Check user-specified shell path
     if (customShellPath) {
         if (existsSync(customShellPath)) {
-            return { shell: customShellPath, args: ["-c"] };
+            return getShellConfigForExecutable(customShellPath);
         }
         throw new Error(`Custom shell path not found: ${customShellPath}`);
     }
     if (process.platform === "win32") {
-        // 2. Try Git Bash in known locations
-        const paths = [];
+        // 2. Prefer native PowerShell shells on Windows.
+        const pwshOnPath = findExecutableOnPath(["pwsh.exe", "pwsh"]);
+        if (pwshOnPath) {
+            return getShellConfigForExecutable(pwshOnPath);
+        }
+        const powershellPaths = [];
         const programFiles = process.env.ProgramFiles;
         if (programFiles) {
-            paths.push(`${programFiles}\\Git\\bin\\bash.exe`);
+            powershellPaths.push(`${programFiles}\\PowerShell\\7\\pwsh.exe`);
+            powershellPaths.push(`${programFiles}\\Git\\bin\\bash.exe`);
         }
         const programFilesX86 = process.env["ProgramFiles(x86)"];
         if (programFilesX86) {
-            paths.push(`${programFilesX86}\\Git\\bin\\bash.exe`);
+            powershellPaths.push(`${programFilesX86}\\Git\\bin\\bash.exe`);
         }
-        for (const path of paths) {
+        const systemRoot = process.env.SystemRoot;
+        if (systemRoot) {
+            powershellPaths.push(`${systemRoot}\\System32\\WindowsPowerShell\\v1.0\\powershell.exe`);
+        }
+        for (const path of powershellPaths) {
             if (existsSync(path)) {
-                return { shell: path, args: ["-c"] };
+                return getShellConfigForExecutable(path);
             }
         }
+        const powershellOnPath = findExecutableOnPath(["powershell.exe", "powershell"]);
+        if (powershellOnPath) {
+            return getShellConfigForExecutable(powershellOnPath);
+        }
         // 3. Fallback: search bash.exe on PATH (Cygwin, MSYS2, WSL, etc.)
         const bashOnPath = findBashOnPath();
         if (bashOnPath) {
-            return { shell: bashOnPath, args: ["-c"] };
+            return getShellConfigForExecutable(bashOnPath);
         }
-        throw new Error(`No bash shell found. Options:\n` +
-            `  1. Install Git for Windows: https://git-scm.com/download/win\n` +
-            `  2. Add your bash to PATH (Cygwin, MSYS2, etc.)\n` +
-            "  3. Set shellPath in settings.json\n\n" +
-            `Searched Git Bash in:\n${paths.map((p) => `  ${p}`).join("\n")}`);
+        throw new Error(`No supported shell found on Windows. Options:\n` +
+            `  1. Install PowerShell 7: https://github.com/PowerShell/PowerShell\n` +
+            `  2. Use built-in Windows PowerShell\n` +
+            `  3. Install Git for Windows: https://git-scm.com/download/win\n` +
+            "  4. Set shellPath in settings.json\n\n" +
+            `Searched common paths:\n${powershellPaths.map((p) => `  ${p}`).join("\n")}`);
     }
     // Unix: try /bin/bash, then bash on PATH, then fallback to sh
     if (existsSync("/bin/bash")) {
-        return { shell: "/bin/bash", args: ["-c"] };
+        return getShellConfigForExecutable("/bin/bash");
     }
     const bashOnPath = findBashOnPath();
     if (bashOnPath) {
-        return { shell: bashOnPath, args: ["-c"] };
+        return getShellConfigForExecutable(bashOnPath);
     }
-    return { shell: "sh", args: ["-c"] };
+    return { shell: "sh", args: ["-c"], kind: "sh", displayName: "Shell" };
 }
 export function getShellEnv() {
     const binDir = getBinDir();
@@ -187,4 +218,4 @@ export function killProcessTree(pid) {
         }
     }
 }
-//# sourceMappingURL=shell.js.map
+//# sourceMappingURL=shell.js.map

package/node_modules/@operator/ai/dist/providers/openai-completions.js

@@ -396,6 +396,11 @@ function buildParams(model, context, options, compat = getCompat(model), cacheRe
     else if (options?.reasoningEffort && model.reasoning && compat.supportsReasoningEffort) {
         // OpenAI-style reasoning_effort
         params.reasoning_effort = mapReasoningEffort(options.reasoningEffort, compat.reasoningEffortMap);
+        // LiteLLM proxies may reject OpenAI-only params unless they are explicitly allow-listed.
+        // Alem AI Plus sits behind LiteLLM and returns UnsupportedParamsError without this field.
+        if (model.baseUrl.includes("llm.alem.ai")) {
+            params.allowed_openai_params = ["reasoning_effort"];
+        }
     }
     // OpenRouter provider routing preferences
     if (model.baseUrl.includes("openrouter.ai") && model.compat?.openRouterRouting) {
@@ -851,4 +856,4 @@ function getCompat(model) {
         sendSessionAffinityHeaders: model.compat.sendSessionAffinityHeaders ?? detected.sendSessionAffinityHeaders,
     };
 }
-//# sourceMappingURL=openai-completions.js.map
+//# sourceMappingURL=openai-completions.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pzero-operator",
-  "version": "0.1.6",
+  "version": "0.1.8",
   "private": false,
   "type": "module",
   "description": "Operator is a coding-first terminal AI agent from ProjectZero for software development, shell execution, local project workflows, and broader device-level operator control.",