claude-use 0.2.2 → 0.2.4

package/dist/cli.cjs

@@ -221857,7 +221857,7 @@ var categories_default_default = {
 // package.json
 var package_default = {
   name: "claude-use",
-  version: "0.2.2",
+  version: "0.2.4",
   description: "A profile manager and launcher for Claude Code that lets one person run multiple logins from one machine while controlling what gets shared between them.",
   license: "Apache-2.0",
   author: "Joseph Mearman <joseph@mearman.co.uk>",
@@ -238480,6 +238480,7 @@ var import_node_child_process2 = require("node:child_process");
 var import_node_crypto3 = require("node:crypto");
 var import_node_fs3 = __toESM(require("node:fs"));
 var import_node_path12 = __toESM(require("node:path"));
+var import_node_sea = require("node:sea");
 
 // src/versionDiscovery.ts
 var import_node_os2 = __toESM(require("node:os"));
@@ -238709,14 +238710,33 @@ function listVersionsDir(dir) {
     };
   });
 }
-function findExecutableInDir(dir, name) {
+var WINDOWS_DEFAULT_PATHEXT = ".COM;.EXE;.BAT;.CMD;.VBS;.VBE;.JS;.JSE;.WSF;.WSH;.MSC;.PS1";
+function windowsPathExtensions(pathext) {
+  return (pathext ?? WINDOWS_DEFAULT_PATHEXT).split(";").map((ext) => ext.trim()).filter((ext) => ext.length > 0);
+}
+function resolveExecutableCandidate(dir, name, env) {
   const candidate = import_node_path12.default.join(dir, name);
-  try {
-    const stat = import_node_fs3.default.statSync(candidate);
-    if (stat.isFile() && (stat.mode & 73) !== 0) {
-      return candidate;
+  if (env.platform === "win32") {
+    const extensions = windowsPathExtensions(env.pathext);
+    const alreadyHasRecognisedExtension = extensions.some((ext) => candidate.toLowerCase().endsWith(ext.toLowerCase()));
+    if (alreadyHasRecognisedExtension) {
+      return env.statFileMode(candidate) !== void 0 ? candidate : void 0;
+    }
+    for (const ext of extensions) {
+      const withExt = candidate + ext;
+      if (env.statFileMode(withExt) !== void 0) {
+        return withExt;
+      }
     }
     return void 0;
+  }
+  const mode = env.statFileMode(candidate);
+  return mode !== void 0 && (mode & 73) !== 0 ? candidate : void 0;
+}
+function realStatFileMode(candidate) {
+  try {
+    const stat = import_node_fs3.default.statSync(candidate);
+    return stat.isFile() ? stat.mode : void 0;
   } catch (error51) {
     if (isEnoent2(error51)) {
       return void 0;
@@ -238724,6 +238744,13 @@ function findExecutableInDir(dir, name) {
     throw error51;
   }
 }
+function findExecutableInDir(dir, name) {
+  return resolveExecutableCandidate(dir, name, {
+    platform: process.platform,
+    pathext: process.env.PATHEXT,
+    statFileMode: realStatFileMode
+  });
+}
 function searchPathForExecutable(pathDirs, name, findExecutableInDir2) {
   for (const dir of pathDirs) {
     const found = findExecutableInDir2(dir, name);
@@ -238734,20 +238761,17 @@ function searchPathForExecutable(pathDirs, name, findExecutableInDir2) {
   return void 0;
 }
 function resolveOwnExecutablePath(env) {
-  if (env.argv1 === void 0) {
-    return env.execPath;
-  }
-  if (!env.argv1.includes("/") && !env.argv1.includes("\\")) {
+  if (env.argv1 !== void 0 && !env.argv1.includes("/") && !env.argv1.includes("\\")) {
     return searchPathForExecutable(env.pathDirs, env.argv1, env.findExecutableInDir) ?? env.execPath;
   }
-  const directCandidate = import_node_path12.default.resolve(env.cwd, env.argv1);
-  const directDir = import_node_path12.default.dirname(directCandidate);
-  const directDirOnPath = env.pathDirs.some((dir) => import_node_path12.default.resolve(dir) === directDir);
-  if (directDirOnPath) {
-    return directCandidate;
+  const candidate = env.argv1 === void 0 ? env.execPath : import_node_path12.default.resolve(env.cwd, env.argv1);
+  const candidateDir = import_node_path12.default.dirname(candidate);
+  const candidateDirOnPath = env.pathDirs.some((dir) => import_node_path12.default.resolve(dir) === candidateDir);
+  if (candidateDirOnPath) {
+    return candidate;
   }
-  const viaPath = searchPathForExecutable(env.pathDirs, import_node_path12.default.basename(directCandidate), env.findExecutableInDir);
-  return viaPath ?? directCandidate;
+  const viaPath = searchPathForExecutable(env.pathDirs, import_node_path12.default.basename(candidate), env.findExecutableInDir);
+  return viaPath ?? candidate;
 }
 function realOwnExecutablePath() {
   return resolveOwnExecutablePath({
@@ -238758,6 +238782,12 @@ function realOwnExecutablePath() {
     findExecutableInDir
   });
 }
+function resolveContentSourcePath(env) {
+  return env.isSea ? env.execPath : env.argv1 ?? env.execPath;
+}
+function realContentSourcePath() {
+  return resolveContentSourcePath({ isSea: (0, import_node_sea.isSea)(), execPath: process.execPath, argv1: process.argv[1] });
+}
 function realResolveClaudeBinary(ownInstallDirs) {
   return () => discoverClaudeBinary({
     listVersionsDir,
@@ -240915,14 +240945,14 @@ var ForeignClaudeEntryError = class extends Error {
   action;
 };
 var UnsupportedShimSourceError = class extends Error {
-  constructor(ownExecutablePath) {
+  constructor(contentSourcePath) {
     super(
-      `Cannot create a working \`claude\` command from ${ownExecutablePath} on Windows: an npm-installed claude-use running under Node.js has no .exe to hardlink/copy, and Windows has no shebang-based dispatch the way POSIX does. Install claude-use via Scoop instead (see README), which ships a real claude-use.exe this command can link from.`
+      `Cannot create a working \`claude\` command from ${contentSourcePath} on Windows: an npm-installed claude-use running under Node.js has no .exe to hardlink/copy, and Windows has no shebang-based dispatch the way POSIX does. Install claude-use via Scoop instead (see README), which ships a real claude-use.exe this command can link from.`
     );
-    this.ownExecutablePath = ownExecutablePath;
+    this.contentSourcePath = contentSourcePath;
     this.name = "UnsupportedShimSourceError";
   }
-  ownExecutablePath;
+  contentSourcePath;
 };
 function claudeTargetFilename(ownExecutablePath) {
   return ownExecutablePath.toLowerCase().endsWith(".exe") ? "claude.exe" : "claude";
@@ -240956,15 +240986,15 @@ function lstatOrUndefined(target) {
 }
 var nodeLinkFs = { link: import_node_fs7.default.linkSync, copyFile: import_node_fs7.default.copyFileSync, chmod: import_node_fs7.default.chmodSync };
 function enableClaudeShim(params, linkFs = nodeLinkFs) {
-  const realOwnPath = import_node_fs7.default.realpathSync(params.ownExecutablePath);
-  if (params.platform === "win32" && !realOwnPath.toLowerCase().endsWith(".exe")) {
-    throw new UnsupportedShimSourceError(realOwnPath);
+  const realContentPath = import_node_fs7.default.realpathSync(params.contentSourcePath);
+  if (params.platform === "win32" && !realContentPath.toLowerCase().endsWith(".exe")) {
+    throw new UnsupportedShimSourceError(realContentPath);
   }
   const targetPath = resolveClaudeTargetPath(params.ownExecutablePath, params.dir);
   import_node_fs7.default.mkdirSync(import_node_path17.default.dirname(targetPath), { recursive: true });
   const existing = lstatOrUndefined(targetPath);
   if (existing !== void 0) {
-    const ownStat = import_node_fs7.default.statSync(realOwnPath);
+    const ownStat = import_node_fs7.default.statSync(realContentPath);
     const state = readJson(params.paths.claudeShimFile, ClaudeShimStateSchema);
     const sameInode = existing.dev === ownStat.dev && existing.ino === ownStat.ino;
     const markerMatches = state !== void 0 && import_node_path17.default.resolve(state.targetPath) === targetPath;
@@ -240975,13 +241005,13 @@ function enableClaudeShim(params, linkFs = nodeLinkFs) {
   }
   let method;
   try {
-    linkFs.link(realOwnPath, targetPath);
+    linkFs.link(realContentPath, targetPath);
     method = "hardlink";
   } catch (error51) {
     if (!isCrossDeviceError(error51)) {
       throw error51;
     }
-    linkFs.copyFile(realOwnPath, targetPath);
+    linkFs.copyFile(realContentPath, targetPath);
     linkFs.chmod(targetPath, 493);
     method = "copy";
   }
@@ -240990,7 +241020,7 @@ function enableClaudeShim(params, linkFs = nodeLinkFs) {
   return { action: existing === void 0 ? "enabled" : "reenabled", targetPath, method };
 }
 function disableClaudeShim(params) {
-  const realOwnPath = import_node_fs7.default.realpathSync(params.ownExecutablePath);
+  const realContentPath = import_node_fs7.default.realpathSync(params.contentSourcePath);
   const state = readJson(params.paths.claudeShimFile, ClaudeShimStateSchema);
   const targetPath = params.dir !== void 0 ? import_node_path17.default.join(params.dir, claudeTargetFilename(params.ownExecutablePath)) : state?.targetPath ?? resolveClaudeTargetPath(params.ownExecutablePath);
   const existing = lstatOrUndefined(targetPath);
@@ -241000,7 +241030,7 @@ function disableClaudeShim(params) {
     }
     return { action: "not-enabled", targetPath };
   }
-  const ownStat = import_node_fs7.default.statSync(realOwnPath);
+  const ownStat = import_node_fs7.default.statSync(realContentPath);
   const sameInode = existing.dev === ownStat.dev && existing.ino === ownStat.ino;
   const markerMatches = state !== void 0 && import_node_path17.default.resolve(state.targetPath) === targetPath;
   if (!sameInode && !markerMatches && !params.force) {
@@ -241027,9 +241057,11 @@ function registerShimCommand(program2, paths) {
   );
   shim.command("enable").description("Create a `claude`-named copy of this same executable, alongside claude-use by default.").option("--dir <path>", "Enable into this directory instead of alongside the running claude-use executable.").option("--force", "Overwrite the target even if it doesn't look like claude-use's own doing.").action((options) => {
     const ownExecutablePath = realOwnExecutablePath();
+    const contentSourcePath = realContentSourcePath();
     const result = enableClaudeShim({
       paths,
       ownExecutablePath,
+      contentSourcePath,
       platform: process.platform,
       ...options.dir === void 0 ? {} : { dir: import_node_path17.default.resolve(options.dir) },
       force: options.force ?? false
@@ -241051,9 +241083,11 @@ function registerShimCommand(program2, paths) {
   });
   shim.command("disable").description("Remove the `claude` command shim `shim enable` previously created. A no-op, not an error, if none is enabled.").option("--dir <path>", "Look in this directory instead of trusting the recorded location.").option("--force", "Remove the target even if it doesn't look like claude-use's own doing.").action((options) => {
     const ownExecutablePath = realOwnExecutablePath();
+    const contentSourcePath = realContentSourcePath();
     const result = disableClaudeShim({
       paths,
       ownExecutablePath,
+      contentSourcePath,
       ...options.dir === void 0 ? {} : { dir: import_node_path17.default.resolve(options.dir) },
       force: options.force ?? false
     });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "claude-use",
-  "version": "0.2.2",
+  "version": "0.2.4",
   "description": "A profile manager and launcher for Claude Code that lets one person run multiple logins from one machine while controlling what gets shared between them.",
   "license": "Apache-2.0",
   "author": "Joseph Mearman <joseph@mearman.co.uk>",