@neuvybe/jarvis 0.68.0 → 0.70.0

package/dist/assets/open-helper.ps1

@@ -0,0 +1,135 @@
+# Windows hand-off for the `open` tool (packages/core/src/tools/open-launch.ts).
+# One request per process: it reads one binary spec from standard input, asks the running
+# Explorer to open the target, and exits with a fixed code. Explorer creates the app as its own
+# child, with Explorer's environment, outside every Jarvis container. It writes nothing; its
+# exit code is all it tells the core. Operations: 0 open, 1 probe (is a desktop shell there?),
+# 2 check (the second look alone, no COM). Fixed codes: 0 opened (a probe: a shell is there; a
+# check: accepted), 0x6A560011 restricted language mode, 0x6A560012 the compile failed, 0x6A560013 the
+# spec was rejected, 0x6A560014 no desktop shell, 0x6A560015 Explorer refused, 0x6A560016 an
+# internal failure. With no desktop shell window it activates nothing, so it never starts
+# Explorer itself.
+$ErrorActionPreference = 'Stop'
+$ProgressPreference = 'SilentlyContinue'
+$PSModuleAutoLoadingPreference = 'None'
+# Restricted language mode blocks the compile below, so it exits with no output at all.
+if ($ExecutionContext.SessionState.LanguageMode -ne 'FullLanguage') { exit 0x6A560011 }
+$code = @'
+using System;
+using System.IO;
+using System.Runtime.InteropServices;
+using System.Text;
+
+public static class JarvisOpen {
+  const int Opened = 0;
+  const int Spec = 0x6A560013;
+  const int NoDesktop = 0x6A560014;
+  const int Refused = 0x6A560015;
+  const int Internal = 0x6A560016;
+  const int MaxSpec = 64 * 1024;
+  const int MaxField = 32 * 1024;
+
+  [DllImport("user32.dll")]
+  static extern IntPtr GetShellWindow();
+
+  public static int Run() {
+    try {
+      byte[] spec = ReadSpec();
+      if (spec == null || spec.Length < 5) return Spec;
+      if (spec[0] != (byte)'J' || spec[1] != (byte)'V' || spec[2] != (byte)'O' || spec[3] != (byte)'1') return Spec;
+      int op = spec[4];
+      int offset = 5;
+      string file = ReadField(spec, ref offset);
+      string args = ReadField(spec, ref offset);
+      if (file == null || args == null || offset != spec.Length) return Spec;
+      // A check runs only the second look below: no COM, nothing opened (tests, diagnostics).
+      if (op == 2) return Acceptable(file, args) ? Opened : Spec;
+      if (op == 1) return ShellApplication() == null ? NoDesktop : Opened;
+      if (op != 0 || !Acceptable(file, args)) return Spec;
+      object shell = ShellApplication();
+      if (shell == null) return NoDesktop;
+      try {
+        dynamic dispatch = shell;
+        dispatch.ShellExecute(file, args, "", "open", 1);
+      } catch {
+        return Refused;
+      }
+      return Opened;
+    } catch {
+      return Internal;
+    }
+  }
+
+  static byte[] ReadSpec() {
+    using (Stream input = Console.OpenStandardInput())
+    using (MemoryStream buffer = new MemoryStream()) {
+      byte[] chunk = new byte[4096];
+      int read;
+      while ((read = input.Read(chunk, 0, chunk.Length)) > 0) {
+        if (buffer.Length + read > MaxSpec) return null;
+        buffer.Write(chunk, 0, read);
+      }
+      return buffer.ToArray();
+    }
+  }
+
+  static string ReadField(byte[] spec, ref int offset) {
+    if (offset + 4 > spec.Length) return null;
+    int length = BitConverter.ToInt32(spec, offset);
+    offset += 4;
+    if (length < 0 || length > MaxField || length % 2 != 0 || offset + length > spec.Length) return null;
+    string text = Encoding.Unicode.GetString(spec, offset, length);
+    offset += length;
+    return text;
+  }
+
+  // The core checks every target first; this is the second, narrower look: a page, a drive
+  // path, or a vetted program with one quoted path as its argument. Nothing here is echoed.
+  static bool Acceptable(string file, string args) {
+    foreach (char c in file + args) if (c < ' ' || c == (char)127) return false;
+    if (args.Length == 0) return IsPage(file) || IsDrivePath(file);
+    if (!IsDrivePath(file) || !file.EndsWith(".exe", StringComparison.OrdinalIgnoreCase)) return false;
+    if (args.Length < 3 || args[0] != '"' || args[args.Length - 1] != '"') return false;
+    string inner = args.Substring(1, args.Length - 2);
+    return inner.IndexOf('"') < 0 && IsDrivePath(inner.TrimEnd('\\') + "\\");
+  }
+
+  static bool IsPage(string file) {
+    bool scheme = file.StartsWith("http://", StringComparison.Ordinal)
+      || file.StartsWith("https://", StringComparison.Ordinal);
+    return scheme && file.IndexOf('"') < 0 && file.IndexOf(' ') < 0 && file.IndexOf('\\') < 0;
+  }
+
+  static bool IsDrivePath(string path) {
+    if (path.Length < 3 || !char.IsLetter(path[0]) || path[1] != ':' || path[2] != '\\') return false;
+    if (path.IndexOf(':', 2) >= 0 || path.IndexOf('%') >= 0 || path.IndexOf('"') >= 0) return false;
+    if (path.IndexOf("shell:", StringComparison.OrdinalIgnoreCase) >= 0) return false;
+    return path.IndexOfAny(new char[] { '<', '>', '|', '?', '*' }) < 0;
+  }
+
+  // The running Explorer's shell automation object for the desktop, or null with no desktop
+  // shell. GetShellWindow comes first: with no shell window nothing is activated, so this
+  // never starts Explorer.
+  static object ShellApplication() {
+    if (GetShellWindow() == IntPtr.Zero) return null;
+    Type type = Type.GetTypeFromCLSID(new Guid("9BA05972-F6A8-11CF-A442-00A0C90A8F39"));
+    dynamic windows = Activator.CreateInstance(type);
+    object location = 0;
+    object root = null;
+    int hwnd;
+    dynamic desktop = windows.FindWindowSW(ref location, ref root, 8, out hwnd, 1);
+    if (desktop == null) return null;
+    dynamic view = desktop.Document;
+    if (view == null) return null;
+    return view.Application;
+  }
+}
+'@
+try {
+  # Add-Type lives in this one module. Importing it by path, with auto-loading off (as the host's
+  # privacy helper does), spares a new profile the analysis of every installed module.
+  Import-Module "$PSHOME\Modules\Microsoft.PowerShell.Utility\Microsoft.PowerShell.Utility.psd1"
+  Add-Type -TypeDefinition $code -Language CSharp -ReferencedAssemblies 'Microsoft.CSharp', 'System.Core'
+} catch {
+  exit 0x6A560012
+}
+exit [JarvisOpen]::Run()