@neuvybe/jarvis 0.74.0 → 0.76.0

package/dist/assets/open-helper.ps1

@@ -1,13 +1,15 @@
 # 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.
+# Explorer to open the target or start the app, 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 a target, 1 probe
+# (is a desktop shell there?), 2 check (the second look alone, no COM), 3 launch an app by its
+# name or path, alone or with one quoted target, 4 resolve an app without launching it. Fixed
+# codes: 0 opened (a probe: a shell is there; a check: accepted; a resolve: found), 0x6A560011
+# restricted language mode, 0x6A560012 the compile failed, 0x6A560013 the spec was rejected,
+# 0x6A560014 no desktop shell, 0x6A560015 Explorer refused, 0x6A560016 an internal failure,
+# 0x6A560017 no app of that name or path. With no desktop shell window it activates nothing,
+# so it never starts Explorer itself.
 $ErrorActionPreference = 'Stop'
 $ProgressPreference = 'SilentlyContinue'
 $PSModuleAutoLoadingPreference = 'None'
@@ -18,6 +20,7 @@ using System;
 using System.IO;
 using System.Runtime.InteropServices;
 using System.Text;
+using Microsoft.Win32;
 
 public static class JarvisOpen {
   const int Opened = 0;
@@ -25,8 +28,10 @@ public static class JarvisOpen {
   const int NoDesktop = 0x6A560014;
   const int Refused = 0x6A560015;
   const int Internal = 0x6A560016;
+  const int NotFound = 0x6A560017;
   const int MaxSpec = 64 * 1024;
   const int MaxField = 32 * 1024;
+  const int MaxDepth = 8;
 
   [DllImport("user32.dll")]
   static extern IntPtr GetShellWindow();
@@ -44,12 +49,25 @@ public static class JarvisOpen {
       // 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;
+      // A resolve answers whether the app is found, launching nothing (tests, diagnostics).
+      if (op == 4) {
+        if (!Acceptable(file, args) || args.Length != 0) return Spec;
+        return Resolve(file, false, null) == null ? NotFound : Opened;
+      }
+      // A target alone travels with no arguments; an app may take one quoted target.
+      if ((op != 0 && op != 3) || !Acceptable(file, args)) return Spec;
+      if (op == 0 && args.Length != 0) return Spec;
       object shell = ShellApplication();
       if (shell == null) return NoDesktop;
+      string launch = file;
+      if (op == 3) {
+        launch = Resolve(file, args.Length != 0, shell);
+        // A Store app is there but takes no target this way: the hand-off is refused, not missing.
+        if (launch == null) return args.Length != 0 && StoreApp(file, shell) != null ? Refused : NotFound;
+      }
       try {
         dynamic dispatch = shell;
-        dispatch.ShellExecute(file, args, "", "open", 1);
+        dispatch.ShellExecute(launch, args, "", "open", 1);
       } catch {
         return Refused;
       }
@@ -82,28 +100,138 @@ public static class JarvisOpen {
     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.
+  // The core checks every request first; this is the helper's own second look, at the form
+  // only - what may be opened is not its question: something to hand on, no control
+  // character, no leading dash, and the arguments empty or exactly one quoted value.
   static bool Acceptable(string file, string args) {
+    if (file.Length == 0 || file[0] == '-') return false;
     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('\\') + "\\");
+    if (args.Length == 0) return true;
+    return args.Length >= 3 && args[0] == '"' && args.IndexOf('"', 1) == args.Length - 1;
   }
 
-  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 IsAbsolute(string path) {
+    return path.StartsWith("\\\\", StringComparison.Ordinal)
+      || (path.Length >= 3 && char.IsLetter(path[0]) && path[1] == ':' && path[2] == '\\');
+  }
+
+  // Finds an app as the user knows it, in this order: its absolute path; a Start-menu shortcut
+  // of exactly that name (the user's, then all users'); an App Paths entry for <name>.exe (the
+  // user's, then the machine's); and, to start it by itself only, a Store app of that name in
+  // the Start menu's app list. With a target to hand it (needProgram), the answer must be a
+  // program the target can be passed to. Null when none is found.
+  static string Resolve(string app, bool needProgram, object shell) {
+    if (IsAbsolute(app)) return File.Exists(app) ? app : null;
+    if (app.IndexOf('\\') >= 0 || app.IndexOf('/') >= 0) return null;
+    string shortcut = StartMenuShortcut(app);
+    if (shortcut != null) {
+      if (!needProgram) return shortcut;
+      string program = ShortcutProgram(shortcut);
+      if (program != null) return program;
+    }
+    string registered = AppPath(app);
+    if (registered != null) return registered;
+    return needProgram || shell == null ? null : StoreApp(app, shell);
   }
 
-  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;
+  static string StartMenuShortcut(string name) {
+    string fileName = name + ".lnk";
+    foreach (Environment.SpecialFolder root in new Environment.SpecialFolder[] {
+        Environment.SpecialFolder.Programs, Environment.SpecialFolder.CommonPrograms }) {
+      string folder = Environment.GetFolderPath(root);
+      if (folder.Length == 0) continue;
+      string found = FindShortcut(folder, fileName, 0);
+      if (found != null) return found;
+    }
+    return null;
+  }
+
+  // Depth first: a folder's own shortcuts before its subfolders', and subfolders in name order,
+  // so a top-level match wins over any nested one. A folder that cannot be read is skipped.
+  static string FindShortcut(string folder, string fileName, int depth) {
+    if (depth > MaxDepth) return null;
+    string[] files;
+    string[] folders;
+    try {
+      files = Directory.GetFiles(folder);
+      folders = Directory.GetDirectories(folder);
+    } catch {
+      return null;
+    }
+    Array.Sort(files, StringComparer.OrdinalIgnoreCase);
+    foreach (string file in files) {
+      if (string.Equals(Path.GetFileName(file), fileName, StringComparison.OrdinalIgnoreCase)) return file;
+    }
+    Array.Sort(folders, StringComparer.OrdinalIgnoreCase);
+    foreach (string sub in folders) {
+      string found = FindShortcut(sub, fileName, depth + 1);
+      if (found != null) return found;
+    }
+    return null;
+  }
+
+  // The program a shortcut starts, to hand a target to, only when the shortcut is that program
+  // alone: a plain .exe on disk and no arguments of its own. A launcher stub (Squirrel's
+  // Update.exe --processStart, a browser profile or web-app shortcut) adds arguments, and an
+  // installer's advertised shortcut points into the Windows Installer cache; both fall through
+  // to App Paths.
+  static string ShortcutProgram(string shortcut) {
+    try {
+      dynamic shell = Activator.CreateInstance(Type.GetTypeFromProgID("WScript.Shell"));
+      dynamic link = shell.CreateShortcut(shortcut);
+      string target = link.TargetPath;
+      string arguments = link.Arguments;
+      if (string.IsNullOrEmpty(target) || !string.IsNullOrEmpty(arguments)) return null;
+      string installer = Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.Windows), "Installer") + "\\";
+      if (target.StartsWith(installer, StringComparison.OrdinalIgnoreCase)) return null;
+      if (target.EndsWith(".exe", StringComparison.OrdinalIgnoreCase) && File.Exists(target)) return target;
+    } catch {
+    }
+    return null;
+  }
+
+  static string AppPath(string name) {
+    string key = name.EndsWith(".exe", StringComparison.OrdinalIgnoreCase) ? name : name + ".exe";
+    foreach (RegistryKey hive in new RegistryKey[] { Registry.CurrentUser, Registry.LocalMachine }) {
+      try {
+        using (RegistryKey entry = hive.OpenSubKey("SOFTWARE\\Microsoft\\Windows\\CurrentVersion\\App Paths\\" + key)) {
+          if (entry == null) continue;
+          string value = entry.GetValue("") as string;
+          if (value == null) continue;
+          value = Environment.ExpandEnvironmentVariables(value).Trim().Trim('"');
+          if (IsAbsolute(value) && File.Exists(value)) return value;
+        }
+      } catch {
+      }
+    }
+    return null;
+  }
+
+  // A Store app of exactly that name in the Start menu's app list, as a shell:AppsFolder
+  // location, which starts it with no arguments. An item that cannot be read is skipped.
+  static string StoreApp(string name, object shell) {
+    dynamic items;
+    int count;
+    try {
+      dynamic dispatch = shell;
+      dynamic folder = dispatch.NameSpace("shell:AppsFolder");
+      if (folder == null) return null;
+      items = folder.Items();
+      count = items.Count;
+    } catch {
+      return null;
+    }
+    for (int i = 0; i < count; i++) {
+      try {
+        dynamic item = items.Item(i);
+        string label = item.Name;
+        if (!string.Equals(label, name, StringComparison.OrdinalIgnoreCase)) continue;
+        string id = item.Path;
+        if (!string.IsNullOrEmpty(id)) return "shell:AppsFolder\\" + id;
+      } catch {
+      }
+    }
+    return null;
   }
 
   // The running Explorer's shell automation object for the desktop, or null with no desktop