@dotobokuri/fleet-cli 1.5.1 → 1.5.2

package/dist/index.js

@@ -141,8 +141,8 @@ var init_resolve_bin = __esm({
 // src/release.ts
 import { createRequire as createRequire2 } from "module";
 function readFleetCliRelease() {
-  const requireFromHere = createRequire2(import.meta.url);
-  const pkg = requireFromHere("../package.json");
+  const requireFromHere2 = createRequire2(import.meta.url);
+  const pkg = requireFromHere2("../package.json");
   const version3 = pkg.version ?? "";
   if (pkg.private === true) {
     return { channel: "local", version: version3 };
@@ -374,16 +374,58 @@ var init_check = __esm({
   }
 });
 
+// src/update/stop-console.ts
+import { spawn as spawn4 } from "child_process";
+import { createRequire as createRequire3 } from "module";
+async function stopRunningConsoleBeforeUpdate(io) {
+  let cliPath;
+  try {
+    cliPath = requireFromHere.resolve(CONSOLE_CLI_SPECIFIER);
+  } catch {
+    return;
+  }
+  io.stdout.write("Stopping the running Fleet Console to release file locks before update...\n");
+  await runConsoleStop2(cliPath, io);
+}
+function runConsoleStop2(cliPath, io) {
+  return new Promise((resolve2) => {
+    let settled = false;
+    const child = spawn4(process.execPath, [cliPath, "stop"], { stdio: "ignore" });
+    const timer = setTimeout(() => {
+      io.stderr.write("Fleet Console did not stop within the timeout; continuing with the update.\n");
+      child.kill();
+      finish();
+    }, STOP_TIMEOUT_MS);
+    const finish = () => {
+      if (settled) return;
+      settled = true;
+      clearTimeout(timer);
+      resolve2();
+    };
+    child.on("error", finish);
+    child.on("exit", finish);
+  });
+}
+var CONSOLE_CLI_SPECIFIER, STOP_TIMEOUT_MS, requireFromHere;
+var init_stop_console = __esm({
+  "src/update/stop-console.ts"() {
+    "use strict";
+    CONSOLE_CLI_SPECIFIER = "@dotobokuri/fleet-console/cli";
+    STOP_TIMEOUT_MS = 15e3;
+    requireFromHere = createRequire3(import.meta.url);
+  }
+});
+
 // src/update/installer.ts
 var installer_exports = {};
 __export(installer_exports, {
   __installerTestHooks: () => __installerTestHooks,
   runFleetUpdate: () => runFleetUpdate
 });
-import { spawn as spawn4 } from "child_process";
+import { spawn as spawn5 } from "child_process";
 import { execFileSync } from "child_process";
 import { accessSync, constants as constants10, realpathSync as realpathSync8 } from "fs";
-import { createRequire as createRequire3 } from "module";
+import { createRequire as createRequire4 } from "module";
 import path25 from "path";
 async function runFleetUpdate(io) {
   const release2 = readFleetCliRelease();
@@ -412,6 +454,7 @@ async function runFleetUpdate(io) {
     io.stdout.write(`Updating Fleet packages with ${target.manager.command} (${versionOrChannel})...
 `);
   }
+  await stopRunningConsoleBeforeUpdate(io);
   const status = await installFleetPackages(target.manager, versionOrChannel, io);
   if (status !== 0) {
     io.stderr.write(`Fleet update did not complete. You can run this manually:
@@ -469,11 +512,11 @@ function detectGlobalRoot(command3, packageRoot, io) {
   return void 0;
 }
 function getCurrentPackageRoot() {
-  const requireFromHere = createRequire3(import.meta.url);
+  const requireFromHere2 = createRequire4(import.meta.url);
   for (const candidate of PACKAGE_JSON_CANDIDATES) {
     try {
-      const packageJsonPath = requireFromHere.resolve(candidate);
-      const pkg = requireFromHere(packageJsonPath);
+      const packageJsonPath = requireFromHere2.resolve(candidate);
+      const pkg = requireFromHere2(packageJsonPath);
       if (pkg.name === FLEET_CLI_PACKAGE_NAME) {
         return normalizePath(realpathSync8(path25.dirname(packageJsonPath)));
       }
@@ -483,7 +526,7 @@ function getCurrentPackageRoot() {
   return void 0;
 }
 function installFleetPackages(manager, versionOrChannel, io) {
-  const child = spawn4(manager.resolved.bin, [...manager.resolved.prefixArgs, "i", "-g", ...PACKAGE_NAMES.map((name) => `${name}@${versionOrChannel}`)], {
+  const child = spawn5(manager.resolved.bin, [...manager.resolved.prefixArgs, "i", "-g", "--force", ...PACKAGE_NAMES.map((name) => `${name}@${versionOrChannel}`)], {
     stdio: "inherit"
   });
   return new Promise((resolve2) => {
@@ -577,6 +620,7 @@ var init_installer = __esm({
     init_resolve_bin();
     init_release();
     init_check();
+    init_stop_console();
     PACKAGE_NAMES = ["@dotobokuri/fleet-cli", "@dotobokuri/fleet-console"];
     FLEET_CLI_PACKAGE_NAME = "@dotobokuri/fleet-cli";
     PACKAGE_JSON_CANDIDATES = ["../package.json", "../../package.json"];
@@ -588,10 +632,10 @@ var init_installer = __esm({
 });
 
 // src/index.ts
-import { spawn as spawn5 } from "child_process";
+import { spawn as spawn6 } from "child_process";
 import path26, { dirname as dirname6 } from "path";
 import { fileURLToPath as fileURLToPath2 } from "url";
-import { createRequire as createRequire4 } from "module";
+import { createRequire as createRequire5 } from "module";
 
 // ../../packages/fleet-infra/dist/chunk-IUYHSUHV.js
 init_chunk_UH3Q34DS();
@@ -39165,9 +39209,9 @@ function createConsoleLock(deps = {}) {
   return { ensureLockDir, readLock, writeLock, removeLock, assertLockModes, assertTrustedLock };
 }
 function readFleetConsoleRelease() {
-  const requireFromHere = createRequire(import.meta.url);
-  const packageJsonPath = requireFromHere.resolve("../package.json");
-  const pkg = requireFromHere(packageJsonPath);
+  const requireFromHere2 = createRequire(import.meta.url);
+  const packageJsonPath = requireFromHere2.resolve("../package.json");
+  const pkg = requireFromHere2(packageJsonPath);
   const packageRoot = path9__default.dirname(packageJsonPath);
   const version22 = pkg.version ?? "";
   if (pkg.private === true) {
@@ -39942,10 +39986,10 @@ function mergeDefs2(...defs) {
 function cloneDef2(schema) {
   return mergeDefs2(schema._zod.def);
 }
-function getElementAtPath2(obj, path182) {
-  if (!path182)
+function getElementAtPath2(obj, path192) {
+  if (!path192)
     return obj;
-  return path182.reduce((acc, key) => acc?.[key], obj);
+  return path192.reduce((acc, key) => acc?.[key], obj);
 }
 function promiseAllObject2(promisesObj) {
   const keys = Object.keys(promisesObj);
@@ -40354,11 +40398,11 @@ function explicitlyAborted2(x, startIndex = 0) {
   }
   return false;
 }
-function prefixIssues2(path182, issues) {
+function prefixIssues2(path192, issues) {
   return issues.map((iss) => {
     var _a32;
     (_a32 = iss).path ?? (_a32.path = []);
-    iss.path.unshift(path182);
+    iss.path.unshift(path192);
     return iss;
   });
 }
@@ -40503,16 +40547,16 @@ function flattenError2(error512, mapper = (issue22) => issue22.message) {
 }
 function formatError3(error512, mapper = (issue22) => issue22.message) {
   const fieldErrors = { _errors: [] };
-  const processError = (error522, path182 = []) => {
+  const processError = (error522, path192 = []) => {
     for (const issue22 of error522.issues) {
       if (issue22.code === "invalid_union" && issue22.errors.length) {
-        issue22.errors.map((issues) => processError({ issues }, [...path182, ...issue22.path]));
+        issue22.errors.map((issues) => processError({ issues }, [...path192, ...issue22.path]));
       } else if (issue22.code === "invalid_key") {
-        processError({ issues: issue22.issues }, [...path182, ...issue22.path]);
+        processError({ issues: issue22.issues }, [...path192, ...issue22.path]);
       } else if (issue22.code === "invalid_element") {
-        processError({ issues: issue22.issues }, [...path182, ...issue22.path]);
+        processError({ issues: issue22.issues }, [...path192, ...issue22.path]);
       } else {
-        const fullpath = [...path182, ...issue22.path];
+        const fullpath = [...path192, ...issue22.path];
         if (fullpath.length === 0) {
           fieldErrors._errors.push(mapper(issue22));
         } else {
@@ -40539,17 +40583,17 @@ function formatError3(error512, mapper = (issue22) => issue22.message) {
 }
 function treeifyError2(error512, mapper = (issue22) => issue22.message) {
   const result = { errors: [] };
-  const processError = (error522, path182 = []) => {
+  const processError = (error522, path192 = []) => {
     var _a32, _b;
     for (const issue22 of error522.issues) {
       if (issue22.code === "invalid_union" && issue22.errors.length) {
-        issue22.errors.map((issues) => processError({ issues }, [...path182, ...issue22.path]));
+        issue22.errors.map((issues) => processError({ issues }, [...path192, ...issue22.path]));
       } else if (issue22.code === "invalid_key") {
-        processError({ issues: issue22.issues }, [...path182, ...issue22.path]);
+        processError({ issues: issue22.issues }, [...path192, ...issue22.path]);
       } else if (issue22.code === "invalid_element") {
-        processError({ issues: issue22.issues }, [...path182, ...issue22.path]);
+        processError({ issues: issue22.issues }, [...path192, ...issue22.path]);
       } else {
-        const fullpath = [...path182, ...issue22.path];
+        const fullpath = [...path192, ...issue22.path];
         if (fullpath.length === 0) {
           result.errors.push(mapper(issue22));
           continue;
@@ -40581,8 +40625,8 @@ function treeifyError2(error512, mapper = (issue22) => issue22.message) {
 }
 function toDotPath2(_path) {
   const segs = [];
-  const path182 = _path.map((seg) => typeof seg === "object" ? seg.key : seg);
-  for (const seg of path182) {
+  const path192 = _path.map((seg) => typeof seg === "object" ? seg.key : seg);
+  for (const seg of path192) {
     if (typeof seg === "number")
       segs.push(`[${seg}]`);
     else if (typeof seg === "symbol")
@@ -53103,13 +53147,13 @@ function resolveRef2(ref, ctx) {
   if (!ref.startsWith("#")) {
     throw new Error("External $ref is not supported, only local refs (#/...) are allowed");
   }
-  const path182 = ref.slice(1).split("/").filter(Boolean);
-  if (path182.length === 0) {
+  const path192 = ref.slice(1).split("/").filter(Boolean);
+  if (path192.length === 0) {
     return ctx.rootSchema;
   }
   const defsKey = ctx.version === "draft-2020-12" ? "$defs" : "definitions";
-  if (path182[0] === defsKey) {
-    const key = path182[1];
+  if (path192[0] === defsKey) {
+    const key = path192[1];
     if (!key || !ctx.defs[key]) {
       throw new Error(`Reference not found: ${ref}`);
     }
@@ -72323,6 +72367,75 @@ async function runNativeCommand(bin, args) {
   const result = await execFileAsync(bin, [...args], { timeout: DIALOG_TIMEOUT_MS });
   return { stdout: result.stdout, stderr: result.stderr };
 }
+var DEFAULT_WINDOWS_PATHEXT2 = ".COM;.EXE;.BAT;.CMD";
+var WINDOWS_PATH_SEPARATOR2 = ";";
+var WINDOWS_SHIM_EXTENSIONS2 = /* @__PURE__ */ new Set([".cmd", ".bat"]);
+var CMD_EXPANSION_SENSITIVE_PATTERN2 = /[%^]/;
+function resolvePathBinary2(command22, env, options2 = {}) {
+  const platform2 = options2.platform ?? process.platform;
+  const isWindows22 = platform2 === "win32";
+  const pathValue = isWindows22 ? env.Path ?? env.PATH ?? "" : env.PATH ?? "";
+  const pathExts = isWindows22 ? parsePathExt2(env.PATHEXT) : [""];
+  const resolved = findOnPath2(command22, pathValue, pathExts, platform2, options2.exists ?? fs4__default.existsSync);
+  return resolved ? wrapWindowsShim2(resolved, env, platform2) : void 0;
+}
+function wrapWindowsShim2(resolved, env, platform2) {
+  if (platform2 !== "win32" || !WINDOWS_SHIM_EXTENSIONS2.has(path9__default.extname(resolved).toLowerCase())) {
+    return { bin: resolved, prefixArgs: [] };
+  }
+  rejectCmdExpansionSensitiveShim2(resolved);
+  return {
+    bin: env.ComSpec ?? "cmd.exe",
+    prefixArgs: ["/d", "/s", "/c", "call", forceWindowsArgQuoting2(resolved)]
+  };
+}
+function rejectCmdExpansionSensitiveShim2(resolved) {
+  if (CMD_EXPANSION_SENSITIVE_PATTERN2.test(resolved)) {
+    throw new Error(`Refusing to run Windows shim path with cmd.exe expansion-sensitive characters (% or ^): ${resolved}`);
+  }
+}
+function forceWindowsArgQuoting2(value) {
+  return `${value} `;
+}
+function findOnPath2(bin, pathValue, pathExts, platform2, exists) {
+  const pathSeparator = platform2 === "win32" ? WINDOWS_PATH_SEPARATOR2 : path9__default.delimiter;
+  if (hasPathSeparator2(bin, platform2) || path9__default.isAbsolute(bin)) {
+    return resolveWithExtensions2(bin, pathExts, platform2, exists);
+  }
+  for (const entry of pathValue.split(pathSeparator)) {
+    const searchDir = entry.length === 0 ? "." : entry;
+    const candidate = resolveWithExtensions2(path9__default.join(searchDir, bin), pathExts, platform2, exists);
+    if (candidate) {
+      return candidate;
+    }
+  }
+  return void 0;
+}
+function resolveWithExtensions2(candidate, pathExts, platform2, exists) {
+  if (platform2 !== "win32" || path9__default.extname(candidate).length > 0) {
+    return exists(candidate) ? candidate : void 0;
+  }
+  for (const ext of pathExts) {
+    if (ext.length === 0) {
+      continue;
+    }
+    const withExt = `${candidate}${ext}`;
+    if (exists(withExt)) {
+      return withExt;
+    }
+  }
+  return exists(candidate) ? candidate : void 0;
+}
+function hasPathSeparator2(value, platform2) {
+  if (value.includes("/")) {
+    return true;
+  }
+  return platform2 === "win32" && value.includes("\\");
+}
+function parsePathExt2(pathExt) {
+  const raw = pathExt && pathExt.trim().length > 0 ? pathExt : DEFAULT_WINDOWS_PATHEXT2;
+  return raw.split(WINDOWS_PATH_SEPARATOR2).map((entry) => entry.trim()).filter((entry) => entry.length > 0);
+}
 var DEFAULT_TERMINAL_CWD_FALLBACK = os22__default.homedir;
 var TERMINAL_TERM = "xterm-256color";
 var FLEET_HEADLESS_NATIVE_FLAGS = ["--headless", "--native"];
@@ -72333,16 +72446,26 @@ function createDefaultTerminalLaunchResolver(deps = {}) {
   const execPath = deps.execPath ?? process4.execPath;
   const homedir22 = deps.homedir ?? DEFAULT_TERMINAL_CWD_FALLBACK;
   const exists = deps.exists ?? fs4__default.existsSync;
+  const platform2 = deps.platform ?? process4.platform;
   const release2 = deps.release ?? readFleetConsoleRelease();
   return (selectedCwd, context) => {
     const cwd = selectedCwd || baseCwd || homedir22();
     if (context?.kind === "shell") {
-      return { bin: resolveUserShell(env), args: [], cwd, env: buildShellLaunchEnv(env) };
+      const shell = resolveWindowsLaunchBinary(resolveUserShell(env, platform2), [], env, exists, platform2, "user shell");
+      return { bin: shell.bin, args: shell.args, cwd, env: buildShellLaunchEnv(env) };
     }
     const launchEnv = buildLaunchEnv(env, cwd, context?.sessionId);
     const override = parseTerminalCommand(env.FLEET_TERMINAL_CMD);
     if (override) {
-      return { ...override, cwd, env: launchEnv };
+      const resolvedOverride = resolveWindowsLaunchBinary(
+        override.bin,
+        override.args,
+        env,
+        exists,
+        platform2,
+        "FLEET_TERMINAL_CMD"
+      );
+      return { ...resolvedOverride, cwd, env: launchEnv };
     }
     if (release2.channel === "local") {
       const localCli = resolveSiblingFleetCliEntry(release2.packageRoot, exists);
@@ -72353,7 +72476,15 @@ function createDefaultTerminalLaunchResolver(deps = {}) {
       }
       return { bin: execPath, args: [localCli, ...FLEET_HEADLESS_NATIVE_FLAGS], cwd, env: launchEnv };
     }
-    return { bin: "fleet", args: [...FLEET_HEADLESS_NATIVE_FLAGS], cwd, env: launchEnv };
+    const stableFleet = resolveWindowsLaunchBinary(
+      "fleet",
+      [...FLEET_HEADLESS_NATIVE_FLAGS],
+      env,
+      exists,
+      platform2,
+      "fleet stable terminal binary"
+    );
+    return { ...stableFleet, cwd, env: launchEnv };
   };
 }
 function startTerminalShell(launch, size) {
@@ -72366,11 +72497,21 @@ function startTerminalShell(launch, size) {
     name: TERMINAL_TERM
   });
 }
-function resolveUserShell(env) {
+function resolveUserShell(env, platform2) {
   if (env.SHELL) return env.SHELL;
-  if (process4.platform === "win32") return env.ComSpec || "powershell.exe";
+  if (platform2 === "win32") return env.ComSpec || "powershell.exe";
   return "/bin/bash";
 }
+function resolveWindowsLaunchBinary(bin, args, env, exists, platform2, label) {
+  if (platform2 !== "win32") {
+    return { bin, args };
+  }
+  const resolved = resolvePathBinary2(bin, env, { exists, platform: platform2 });
+  if (!resolved) {
+    throw new Error(`${label} "${bin}" was not found on PATH; provide an absolute path or install it before launching a terminal session.`);
+  }
+  return { bin: resolved.bin, args: [...resolved.prefixArgs, ...args] };
+}
 function resolveSiblingFleetCliEntry(consolePackageRoot, exists = fs4__default.existsSync) {
   const candidate = expectedSiblingFleetCliEntry(consolePackageRoot);
   return exists(candidate) ? candidate : null;
@@ -83150,7 +83291,7 @@ async function dispatchUpdateCommand(argv2, io) {
 
 // src/index.ts
 var HELP_HINT2 = "Run 'fleet --help' for usage.";
-var require4 = createRequire4(import.meta.url);
+var require4 = createRequire5(import.meta.url);
 var FLEET_ENTRY_PATH = fileURLToPath2(import.meta.url);
 var PLUGIN_ASSETS_DIR = path26.join(dirname6(dirname6(FLEET_ENTRY_PATH)), "assets");
 var PLUGIN_TSX_LOADER_PATH = resolveOptionalPackage("tsx");
@@ -83242,7 +83383,7 @@ function resolveOptionalPackage(id) {
 }
 async function relayToPackageCli(specifier, args) {
   const cliPath = require4.resolve(specifier);
-  const child = spawn5(process.execPath, [cliPath, ...args], {
+  const child = spawn6(process.execPath, [cliPath, ...args], {
     stdio: "inherit",
     cwd: process.env.INIT_CWD || process.cwd()
   });