@moxt-ai/mobius 0.0.336 → 0.0.337

package/dist/util/process/executable.js

@@ -1,30 +1,17 @@
 // src/util/process/executable.ts
 import { spawn } from "node:child_process";
 import { stat as stat2 } from "node:fs/promises";
-import { join as join6, resolve as resolve2 } from "node:path";
+import { join as join3, resolve as resolve2 } from "node:path";
 
-// src/util/platform/linux.ts
+// src/util/process/platform/linux.ts
 import { constants as constants2, readdirSync, readFileSync } from "node:fs";
 import { access as access2, readdir, readFile, realpath as realpath2, stat } from "node:fs/promises";
-import { isAbsolute, join as join2 } from "node:path";
+import { join } from "node:path";
 
-// src/util/platform/posix.ts
+// src/util/process/platform/posix.ts
 import { execFile } from "node:child_process";
 import { constants } from "node:fs";
-import { access, chmod, lstat, realpath, unlink } from "node:fs/promises";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
-
-// src/util/filesystem/path-error.ts
-var LocalPathError = class extends Error {
-  code = "unsafe_local_path";
-  constructor(message, options = {}) {
-    super(message, options);
-    this.name = "LocalPathError";
-  }
-};
-
-// src/util/platform/posix.ts
+import { access, realpath } from "node:fs/promises";
 var PROCESS_TABLE_TIMEOUT_MILLISECONDS = 1e3;
 var PROCESS_TABLE_OUTPUT_LIMIT_BYTES = 1024 * 1024;
 function parseProcessTable(output) {
@@ -104,22 +91,7 @@ function terminateProcess(child, signal) {
   }
   child.kill(signal);
 }
-async function removeControlSocket(path) {
-  try {
-    await unlink(path);
-  } catch (cause) {
-    if (!(cause instanceof Error) || !("code" in cause) || cause.code !== "ENOENT") {
-      throw cause;
-    }
-  }
-}
 var posixOperations = {
-  controlSocketPath: (installationHash) => join(tmpdir(), `mobius-${installationHash}.sock`),
-  prepareControlSocket: removeControlSocket,
-  secureControlSocket: async (path) => {
-    await chmod(path, 384);
-  },
-  removeControlSocket,
   pathDelimiter: ":",
   environmentValue: (environment, name) => environment[name],
   executableExtensions: () => [""],
@@ -131,21 +103,10 @@ var posixOperations = {
   executableLaunch: (command, args) => ({ command, arguments: args }),
   spawnOptions: { detached: true, windowsHide: true },
   signalCapturedProcesses,
-  terminateProcess,
-  validatePathPermissions: async (path, directory, privateAccess, signal) => {
-    signal.throwIfAborted();
-    const metadata = await lstat(path);
-    if (process.getuid === void 0 || metadata.uid !== process.getuid()) {
-      throw new LocalPathError("Path is not user-owned");
-    }
-    if (privateAccess) {
-      await chmod(path, directory ? 448 : 384);
-    }
-    signal.throwIfAborted();
-  }
+  terminateProcess
 };
 
-// src/util/platform/linux.ts
+// src/util/process/platform/linux.ts
 function appendLinuxProcessTableEntry(entries, processId, encoded) {
   const closingParenthesis = encoded.lastIndexOf(")");
   if (!encoded.startsWith(`${processId.toString()} (`) || closingParenthesis < 0) {
@@ -175,7 +136,7 @@ async function readLinuxProcessTable() {
         appendLinuxProcessTableEntry(
           entries,
           processId,
-          await readFile(join2("/proc", directory.name, "stat"), "utf8")
+          await readFile(join("/proc", directory.name, "stat"), "utf8")
         );
       } catch {
       }
@@ -200,7 +161,7 @@ function readLinuxProcessTableSynchronously() {
         appendLinuxProcessTableEntry(
           entries,
           processId,
-          readFileSync(join2("/proc", directory.name, "stat"), "utf8")
+          readFileSync(join("/proc", directory.name, "stat"), "utf8")
         );
       } catch {
       }
@@ -233,7 +194,7 @@ async function readLinuxProcessTableWithFallback() {
 }
 function processExists2(processId) {
   try {
-    const encoded = readFileSync(join2("/proc", processId.toString(), "stat"), "utf8");
+    const encoded = readFileSync(join("/proc", processId.toString(), "stat"), "utf8");
     const closingParenthesis = encoded.lastIndexOf(")");
     if (closingParenthesis >= 0) {
       const processState = encoded.slice(closingParenthesis + 1).trimStart().charAt(0);
@@ -245,80 +206,25 @@ function processExists2(processId) {
   }
   return processExists(processId);
 }
-var linuxPlatform = {
+var linuxProcessPlatform = {
   ...posixOperations,
   readProcessTable: readLinuxProcessTableWithFallback,
   readProcessTableSynchronously: readLinuxProcessTableSynchronously,
-  processExists: processExists2,
-  claudeCodeExecutablePaths: (environment) => {
-    const homeDirectory = environment["HOME"];
-    return homeDirectory !== void 0 && isAbsolute(homeDirectory) ? [join2(homeDirectory, ".local", "bin", "claude")] : [];
-  }
+  processExists: processExists2
 };
 
-// src/util/platform/macos.ts
-import { isAbsolute as isAbsolute2, join as join4 } from "node:path";
-
-// src/util/platform/claude-desktop.ts
-import { readdirSync as readdirSync2 } from "node:fs";
-import { join as join3 } from "node:path";
-function installedDirectories(directory) {
-  try {
-    return readdirSync2(directory, { withFileTypes: true }).filter((entry) => entry.isDirectory()).map((entry) => entry.name);
-  } catch (cause) {
-    if (cause instanceof Error && "code" in cause && (cause.code === "ENOENT" || cause.code === "ENOTDIR" || cause.code === "EACCES")) {
-      return [];
-    }
-    throw cause;
-  }
-}
-function claudeDesktopExecutablePaths(roots, executablePaths) {
-  const paths = [];
-  for (const root of roots) {
-    const versions = installedDirectories(root).filter((version) => /^\d+\.\d+\.\d+$/.test(version)).toSorted((left, right) => right.localeCompare(left, "en", { numeric: true }));
-    for (const version of versions) {
-      const directory = join3(root, version);
-      const installations = [
-        directory,
-        ...installedDirectories(directory).map((build) => join3(directory, build))
-      ];
-      for (const installation of installations) {
-        for (const executablePath of executablePaths) {
-          paths.push(join3(installation, ...executablePath));
-        }
-      }
-    }
-  }
-  return paths;
-}
-
-// src/util/platform/macos.ts
-var macosPlatform = {
+// src/util/process/platform/macos.ts
+var macosProcessPlatform = {
   ...posixOperations,
   readProcessTable: () => readProcessTableWithPs("/bin/ps"),
   readProcessTableSynchronously: () => [],
-  processExists,
-  claudeCodeExecutablePaths: (environment) => {
-    const paths = ["/opt/homebrew/bin/claude", "/usr/local/bin/claude"];
-    const homeDirectory = environment["HOME"];
-    if (homeDirectory !== void 0 && isAbsolute2(homeDirectory)) {
-      paths.unshift(join4(homeDirectory, ".local", "bin", "claude"));
-      paths.push(
-        ...claudeDesktopExecutablePaths(
-          [join4(homeDirectory, "Library", "Application Support", "Claude", "claude-code")],
-          [["claude.app", "Contents", "MacOS", "claude"], ["claude"]]
-        )
-      );
-    }
-    return paths;
-  }
+  processExists
 };
 
-// src/util/platform/windows.ts
+// src/util/process/platform/windows.ts
 import { execFile as execFile2 } from "node:child_process";
 import { readFile as readFile2, realpath as realpath3 } from "node:fs/promises";
-import { dirname, extname, isAbsolute as isAbsolute3, join as join5, resolve } from "node:path";
-import { promisify } from "node:util";
+import { dirname, extname, join as join2, resolve } from "node:path";
 
 // src/util/process/process-error.ts
 var ProcessExecutionError = class extends Error {
@@ -330,28 +236,10 @@ var ProcessExecutionError = class extends Error {
   }
 };
 
-// src/util/platform/windows.ts
-var execute = promisify(execFile2);
+// src/util/process/platform/windows.ts
 function environmentValue(environment, name) {
   return Object.entries(environment).find(([key]) => key.toUpperCase() === name.toUpperCase())?.[1];
 }
-function desktopClaudeExecutablePaths(environment) {
-  const roots = [];
-  const localAppData = environmentValue(environment, "LOCALAPPDATA");
-  if (localAppData !== void 0 && isAbsolute3(localAppData)) {
-    const dataDirectory = join5(localAppData, "Claude-Data");
-    for (const installation of installedDirectories(dataDirectory)) {
-      if (installation.startsWith("claude_")) {
-        roots.push(join5(dataDirectory, installation, "claude-code"));
-      }
-    }
-  }
-  const appData = environmentValue(environment, "APPDATA");
-  if (appData !== void 0 && isAbsolute3(appData)) {
-    roots.push(join5(appData, "Claude", "claude-code"));
-  }
-  return claudeDesktopExecutablePaths(roots, [["claude.exe"]]);
-}
 function executableExtensions(executableName, environment) {
   if (/\.[a-zA-Z0-9]+$/.test(executableName)) {
     return [""];
@@ -410,7 +298,7 @@ function readProcessTable() {
   }
   return new Promise((resolveTable) => {
     execFile2(
-      join5(systemRoot, "System32", "WindowsPowerShell", "v1.0", "powershell.exe"),
+      join2(systemRoot, "System32", "WindowsPowerShell", "v1.0", "powershell.exe"),
       [
         "-NoLogo",
         "-NoProfile",
@@ -443,71 +331,7 @@ function terminateProcess2(child, signal) {
   }
   child.kill(signal);
 }
-var windowsPermissions = `
-$ErrorActionPreference = 'Stop'
-$ProgressPreference = 'SilentlyContinue'
-$item = Get-Item -LiteralPath $env:MOBIUS_PERMISSION_PATH -Force
-if (($item.Attributes -band [IO.FileAttributes]::ReparsePoint) -ne 0) { throw 'Unsafe path' }
-$sid = [Security.Principal.WindowsIdentity]::GetCurrent().User
-$acl = $item.GetAccessControl()
-$owner = $acl.GetOwner([Security.Principal.SecurityIdentifier])
-if ($owner -ne $sid -and -not ($owner.Value -eq 'S-1-5-32-544' -and ([Security.Principal.WindowsPrincipal][Security.Principal.WindowsIdentity]::GetCurrent()).IsInRole([Security.Principal.WindowsBuiltInRole]::Administrator))) { throw 'Path is not user-owned' }
-if ($env:MOBIUS_PERMISSION_PRIVATE -eq '1') {
-    if ($item.PSIsContainer) {
-        $private = New-Object Security.AccessControl.DirectorySecurity
-        $rule = New-Object Security.AccessControl.FileSystemAccessRule($sid, 'FullControl', 'ContainerInherit,ObjectInherit', 'None', 'Allow')
-    } else {
-        $private = New-Object Security.AccessControl.FileSecurity
-        $rule = New-Object Security.AccessControl.FileSystemAccessRule($sid, 'FullControl', 'Allow')
-    }
-    $private.SetOwner($sid)
-    $private.SetAccessRuleProtection($true, $false)
-    $private.AddAccessRule($rule)
-    $item.SetAccessControl($private)
-}
-`;
-var windowsPermissionsTimeoutMs = 3e4;
-async function validatePathPermissions(path, _directory, privateAccess, signal) {
-  signal.throwIfAborted();
-  const systemRoot = environmentValue(process.env, "SystemRoot");
-  if (systemRoot === void 0) {
-    throw new LocalPathError("Windows system directory is unavailable");
-  }
-  try {
-    await execute(
-      join5(systemRoot, "System32", "WindowsPowerShell", "v1.0", "powershell.exe"),
-      [
-        "-NoLogo",
-        "-NoProfile",
-        "-NonInteractive",
-        "-EncodedCommand",
-        Buffer.from(windowsPermissions, "utf16le").toString("base64")
-      ],
-      {
-        env: {
-          ...process.env,
-          MOBIUS_PERMISSION_PATH: path,
-          MOBIUS_PERMISSION_PRIVATE: privateAccess ? "1" : "0"
-        },
-        windowsHide: true,
-        signal: AbortSignal.any([signal, AbortSignal.timeout(windowsPermissionsTimeoutMs)]),
-        timeout: windowsPermissionsTimeoutMs,
-        maxBuffer: 16384
-      }
-    );
-  } catch (cause) {
-    signal.throwIfAborted();
-    throw new LocalPathError("The local path permissions could not be secured", { cause });
-  }
-}
-var windowsPlatform = {
-  controlSocketPath: (installationHash) => `\\\\.\\pipe\\mobius-${installationHash}`,
-  prepareControlSocket: async () => {
-  },
-  secureControlSocket: async () => {
-  },
-  removeControlSocket: async () => {
-  },
+var windowsProcessPlatform = {
   pathDelimiter: ";",
   environmentValue,
   executableExtensions,
@@ -516,44 +340,29 @@ var windowsPlatform = {
   spawnOptions: { detached: false, windowsHide: true },
   signalCapturedProcesses: signalCapturedProcesses2,
   terminateProcess: terminateProcess2,
-  validatePathPermissions,
   readProcessTable,
   readProcessTableSynchronously: () => [],
-  processExists,
-  claudeCodeExecutablePaths: (environment) => {
-    const paths = [];
-    const userProfile = environmentValue(environment, "USERPROFILE");
-    if (userProfile !== void 0 && isAbsolute3(userProfile)) {
-      paths.push(join5(userProfile, ".local", "bin", "claude.exe"));
-    }
-    const localAppData = environmentValue(environment, "LOCALAPPDATA");
-    if (localAppData !== void 0 && isAbsolute3(localAppData)) {
-      paths.push(join5(localAppData, "Microsoft", "WinGet", "Links", "claude.exe"));
-    }
-    paths.push(...desktopClaudeExecutablePaths(environment));
-    return paths;
-  }
+  processExists
 };
 
-// src/util/platform/index.ts
+// src/util/process/platform/index.ts
 var fallbackPlatform = {
   ...posixOperations,
   readProcessTable: () => readProcessTableWithPs("/usr/bin/ps"),
   readProcessTableSynchronously: () => [],
-  processExists,
-  claudeCodeExecutablePaths: () => []
+  processExists
 };
 var platforms = /* @__PURE__ */ new Map([
-  ["linux", linuxPlatform],
-  ["darwin", macosPlatform],
-  ["win32", windowsPlatform]
+  ["linux", linuxProcessPlatform],
+  ["darwin", macosProcessPlatform],
+  ["win32", windowsProcessPlatform]
 ]);
-function platformSupportFor(platform) {
+function processPlatformSupportFor(platform) {
   return platforms.get(platform) ?? fallbackPlatform;
 }
 
 // src/util/process/executable.ts
-var hostPlatform = platformSupportFor(process.platform);
+var hostPlatform = processPlatformSupportFor(process.platform);
 var DEFAULT_OUTPUT_LIMIT_BYTES = 16 * 1024;
 var PROCESS_GRACEFUL_STOP_TIMEOUT_MILLISECONDS = 1e3;
 var PROCESS_FORCED_STOP_TIMEOUT_MILLISECONDS = 5e3;
@@ -596,7 +405,7 @@ var ProcessResult = class {
 async function resolveExecutablePath(requestedPath, platform = process.platform) {
   const absoluteRequestedPath = resolve2(requestedPath);
   try {
-    const resolvedPath = await platformSupportFor(platform).resolveExecutableTarget(absoluteRequestedPath);
+    const resolvedPath = await processPlatformSupportFor(platform).resolveExecutableTarget(absoluteRequestedPath);
     const metadata = await stat2(resolvedPath);
     if (!metadata.isFile()) {
       return null;
@@ -616,7 +425,7 @@ async function resolveExecutablePath(requestedPath, platform = process.platform)
   }
 }
 async function findExecutableOnPath(executableName, environment, platform = process.platform) {
-  const support = platformSupportFor(platform);
+  const support = processPlatformSupportFor(platform);
   const encodedPath = support.environmentValue(environment, "PATH") ?? "";
   const separator = support.pathDelimiter;
   const extensions = support.executableExtensions(executableName, environment);
@@ -625,7 +434,7 @@ async function findExecutableOnPath(executableName, environment, platform = proc
       continue;
     }
     for (const extension of extensions) {
-      const requestedPath = resolve2(join6(entry, `${executableName}${extension}`));
+      const requestedPath = resolve2(join3(entry, `${executableName}${extension}`));
       const executable = await resolveExecutablePath(requestedPath, platform);
       if (executable !== null) {
         return executable;