@dotobokuri/fleet-console 1.5.1 → 1.5.3

package/dist/cli-bin.mjs

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 import { execFile, spawn, execSync } from 'child_process';
 import * as fs4 from 'fs';
-import fs4__default, { realpathSync, lstatSync } from 'fs';
+import fs4__default, { existsSync, realpathSync, lstatSync } from 'fs';
 import * as path9 from 'path';
 import path9__default, { join, resolve, relative, dirname } from 'path';
 import process4 from 'process';
@@ -21349,6 +21349,75 @@ function assertNoAuthorizationHeader(config2) {
     throw new Error(`Builtin external MCP server "${config2.name}" must not define headers.`);
   }
 }
+var DEFAULT_WINDOWS_PATHEXT = ".COM;.EXE;.BAT;.CMD";
+var WINDOWS_PATH_SEPARATOR = ";";
+var WINDOWS_SHIM_EXTENSIONS = /* @__PURE__ */ new Set([".cmd", ".bat"]);
+var CMD_EXPANSION_SENSITIVE_PATTERN = /[%^]/;
+function resolvePathBinary(command2, env, options = {}) {
+  const platform = options.platform ?? process.platform;
+  const isWindows2 = platform === "win32";
+  const pathValue = isWindows2 ? env.Path ?? env.PATH ?? "" : env.PATH ?? "";
+  const pathExts = isWindows2 ? parsePathExt(env.PATHEXT) : [""];
+  const resolved = findOnPath(command2, pathValue, pathExts, platform);
+  return resolved ? wrapWindowsShim(resolved, env, platform) : void 0;
+}
+function wrapWindowsShim(resolved, env, platform) {
+  if (platform !== "win32" || !WINDOWS_SHIM_EXTENSIONS.has(path9__default.extname(resolved).toLowerCase())) {
+    return { bin: resolved, prefixArgs: [] };
+  }
+  rejectCmdExpansionSensitiveShim(resolved);
+  return {
+    bin: env.ComSpec ?? "cmd.exe",
+    prefixArgs: ["/d", "/s", "/c", "call", forceWindowsArgQuoting(resolved)]
+  };
+}
+function rejectCmdExpansionSensitiveShim(resolved) {
+  if (CMD_EXPANSION_SENSITIVE_PATTERN.test(resolved)) {
+    throw new Error(`Refusing to run Windows shim path with cmd.exe expansion-sensitive characters (% or ^): ${resolved}`);
+  }
+}
+function forceWindowsArgQuoting(value) {
+  return `${value} `;
+}
+function findOnPath(bin, pathValue, pathExts, platform) {
+  const pathSeparator = platform === "win32" ? WINDOWS_PATH_SEPARATOR : path9__default.delimiter;
+  if (hasPathSeparator(bin, platform) || path9__default.isAbsolute(bin)) {
+    return resolveWithExtensions(bin, pathExts, platform);
+  }
+  for (const entry of pathValue.split(pathSeparator)) {
+    const searchDir = entry.length === 0 ? "." : entry;
+    const candidate = resolveWithExtensions(path9__default.join(searchDir, bin), pathExts, platform);
+    if (candidate) {
+      return candidate;
+    }
+  }
+  return void 0;
+}
+function resolveWithExtensions(candidate, pathExts, platform) {
+  if (platform !== "win32" || path9__default.extname(candidate).length > 0) {
+    return existsSync(candidate) ? candidate : void 0;
+  }
+  for (const ext of pathExts) {
+    if (ext.length === 0) {
+      continue;
+    }
+    const withExt = `${candidate}${ext}`;
+    if (existsSync(withExt)) {
+      return withExt;
+    }
+  }
+  return existsSync(candidate) ? candidate : void 0;
+}
+function hasPathSeparator(value, platform) {
+  if (value.includes("/")) {
+    return true;
+  }
+  return platform === "win32" && value.includes("\\");
+}
+function parsePathExt(pathExt) {
+  const raw = pathExt && pathExt.trim().length > 0 ? pathExt : DEFAULT_WINDOWS_PATHEXT;
+  return raw.split(WINDOWS_PATH_SEPARATOR).map((entry) => entry.trim()).filter((entry) => entry.length > 0);
+}
 var DEAD_SESSION_PATTERNS = [
   /session not found/i,
   /unknown session/i,
@@ -22060,6 +22129,146 @@ async function disconnect(poolKey) {
 async function executeWithPool(opts) {
   return engineExecuteWithPool(opts);
 }
+var NPM_REGISTRY_BASE_URL = "https://registry.npmjs.org/";
+var REGISTRY_TIMEOUT_MS = 3e3;
+var MAX_REGISTRY_RESPONSE_BYTES = 1024 * 1024;
+var VERSION_PATTERN = /^v?(\d+)\.(\d+)\.(\d+)(?:-([0-9A-Za-z.-]+))?$/;
+async function fetchLatestVersion(packageName, channel) {
+  const controller = new AbortController();
+  const timer = setTimeout(() => controller.abort(), REGISTRY_TIMEOUT_MS);
+  timer.unref?.();
+  try {
+    const response = await fetch(`${NPM_REGISTRY_BASE_URL}${encodeNpmPackageName(packageName)}`, {
+      headers: {
+        Accept: "application/vnd.npm.install-v1+json"
+      },
+      signal: controller.signal
+    });
+    if (!response.ok) {
+      return void 0;
+    }
+    const metadata = await readJsonWithByteLimit(response, controller);
+    if (metadata === void 0) {
+      return void 0;
+    }
+    const latest = metadata["dist-tags"]?.[channel ?? "latest"];
+    return typeof latest === "string" && latest.length > 0 ? latest : void 0;
+  } catch {
+    return void 0;
+  } finally {
+    clearTimeout(timer);
+  }
+}
+function isVersionGreater(left, right) {
+  const leftVersion = parseVersion(left);
+  const rightVersion = parseVersion(right);
+  if (leftVersion === void 0 || rightVersion === void 0) {
+    return false;
+  }
+  return compareVersions(leftVersion, rightVersion) > 0;
+}
+function encodeNpmPackageName(packageName) {
+  if (!packageName.startsWith("@")) {
+    return encodeURIComponent(packageName);
+  }
+  const separatorIndex = packageName.indexOf("/");
+  if (separatorIndex === -1) {
+    return encodeURIComponent(packageName);
+  }
+  const scope = packageName.slice(1, separatorIndex);
+  const name = packageName.slice(separatorIndex + 1);
+  return `@${encodeURIComponent(scope)}%2f${encodeURIComponent(name)}`;
+}
+async function readJsonWithByteLimit(response, controller) {
+  const body = response.body;
+  if (body === null) {
+    return void 0;
+  }
+  const reader = body.getReader();
+  const chunks = [];
+  let totalBytes = 0;
+  try {
+    while (true) {
+      const { done, value } = await reader.read();
+      if (done) {
+        break;
+      }
+      totalBytes += value.byteLength;
+      if (totalBytes > MAX_REGISTRY_RESPONSE_BYTES) {
+        controller.abort();
+        return void 0;
+      }
+      chunks.push(value);
+    }
+    return JSON.parse(new TextDecoder().decode(joinChunks(chunks, totalBytes)));
+  } catch {
+    return void 0;
+  } finally {
+    reader.releaseLock();
+  }
+}
+function joinChunks(chunks, totalBytes) {
+  const joined = new Uint8Array(totalBytes);
+  let offset = 0;
+  for (const chunk of chunks) {
+    joined.set(chunk, offset);
+    offset += chunk.byteLength;
+  }
+  return joined;
+}
+function parseVersion(version2) {
+  const match = VERSION_PATTERN.exec(version2.trim());
+  if (match === null) {
+    return void 0;
+  }
+  return {
+    major: Number(match[1]),
+    minor: Number(match[2]),
+    patch: Number(match[3]),
+    pre: match[4]?.split(".") ?? []
+  };
+}
+function compareVersions(left, right) {
+  const base = compareNumbers(left.major, right.major) || compareNumbers(left.minor, right.minor) || compareNumbers(left.patch, right.patch);
+  if (base !== 0) {
+    return base;
+  }
+  if (left.pre.length === 0 || right.pre.length === 0) {
+    return compareNumbers(right.pre.length, left.pre.length);
+  }
+  for (let index = 0; index < Math.max(left.pre.length, right.pre.length); index += 1) {
+    const leftPart = left.pre[index];
+    const rightPart = right.pre[index];
+    if (leftPart === void 0 || rightPart === void 0) {
+      return compareNumbers(left.pre.length, right.pre.length);
+    }
+    const compared = comparePrereleasePart(leftPart, rightPart);
+    if (compared !== 0) {
+      return compared;
+    }
+  }
+  return 0;
+}
+function comparePrereleasePart(left, right) {
+  const leftNumber = parseNumericPart(left);
+  const rightNumber = parseNumericPart(right);
+  if (leftNumber !== void 0 && rightNumber !== void 0) {
+    return compareNumbers(leftNumber, rightNumber);
+  }
+  if (leftNumber !== void 0) {
+    return -1;
+  }
+  if (rightNumber !== void 0) {
+    return 1;
+  }
+  return left.localeCompare(right);
+}
+function parseNumericPart(value) {
+  return /^\d+$/.test(value) ? Number(value) : void 0;
+}
+function compareNumbers(left, right) {
+  return left === right ? 0 : left > right ? 1 : -1;
+}
 var SECURE_DIR_MODE = 448;
 var SECURE_FILE_MODE = 384;
 var NOFOLLOW_FLAG = fs4.constants.O_NOFOLLOW ?? 0;
@@ -34209,16 +34418,25 @@ function createDefaultTerminalLaunchResolver(deps = {}) {
   const execPath = deps.execPath ?? process4.execPath;
   const homedir2 = deps.homedir ?? DEFAULT_TERMINAL_CWD_FALLBACK;
   const exists = deps.exists ?? fs4__default.existsSync;
+  const platform = deps.platform ?? process4.platform;
   const release = deps.release ?? readFleetConsoleRelease();
   return (selectedCwd, context) => {
     const cwd = selectedCwd || baseCwd || homedir2();
     if (context?.kind === "shell") {
-      return { bin: resolveUserShell(env), args: [], cwd, env: buildShellLaunchEnv(env) };
+      const shell = resolveWindowsLaunchBinary(resolveUserShell(env, platform), [], env, platform, "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,
+        platform,
+        "FLEET_TERMINAL_CMD"
+      );
+      return { ...resolvedOverride, cwd, env: launchEnv };
     }
     if (release.channel === "local") {
       const localCli = resolveSiblingFleetCliEntry(release.packageRoot, exists);
@@ -34229,7 +34447,14 @@ 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,
+      platform,
+      "fleet stable terminal binary"
+    );
+    return { ...stableFleet, cwd, env: launchEnv };
   };
 }
 function startTerminalShell(launch, size) {
@@ -34242,11 +34467,21 @@ function startTerminalShell(launch, size) {
     name: TERMINAL_TERM
   });
 }
-function resolveUserShell(env) {
+function resolveUserShell(env, platform) {
   if (env.SHELL) return env.SHELL;
-  if (process4.platform === "win32") return env.ComSpec || "powershell.exe";
+  if (platform === "win32") return env.ComSpec || "powershell.exe";
   return "/bin/bash";
 }
+function resolveWindowsLaunchBinary(bin, args, env, platform, label) {
+  if (platform !== "win32") {
+    return { bin, args };
+  }
+  const resolved = resolvePathBinary(bin, env, { platform });
+  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;
@@ -34508,6 +34743,59 @@ var TheaterRegistry = class {
   }
 };
 
+// src/update-check.ts
+var FLEET_CONSOLE_PACKAGE_NAME = "@dotobokuri/fleet-console";
+var UPDATE_CHECK_TTL_MS = 60 * 60 * 1e3;
+var NO_UPDATE_STATUS = { updateAvailable: false };
+function createConsoleUpdateCheckService(deps = {}) {
+  const readRelease = deps.readRelease ?? readFleetConsoleRelease;
+  const fetchLatest = deps.fetchLatest ?? fetchLatestVersion;
+  const isGreater = deps.isGreater ?? isVersionGreater;
+  const now = deps.now ?? Date.now;
+  const ttlMs = deps.ttlMs ?? UPDATE_CHECK_TTL_MS;
+  let cached2 = null;
+  let inFlight = null;
+  const getStatus = () => {
+    const current = cached2;
+    if (current && now() - current.checkedAt < ttlMs) {
+      return current.status;
+    }
+    void refresh();
+    return current?.status ?? NO_UPDATE_STATUS;
+  };
+  const refresh = async () => {
+    const current = cached2;
+    if (current && now() - current.checkedAt < ttlMs) {
+      return current.status;
+    }
+    if (inFlight) {
+      return inFlight;
+    }
+    inFlight = resolveUpdateStatus().then((status) => {
+      cached2 = { status, checkedAt: now() };
+      return status;
+    }).catch(() => {
+      cached2 = { status: NO_UPDATE_STATUS, checkedAt: now() };
+      return NO_UPDATE_STATUS;
+    }).finally(() => {
+      inFlight = null;
+    });
+    return inFlight;
+  };
+  const resolveUpdateStatus = async () => {
+    const release = readRelease();
+    if (release.channel === "local") {
+      return NO_UPDATE_STATUS;
+    }
+    const latestVersion = await fetchLatest(FLEET_CONSOLE_PACKAGE_NAME);
+    if (!latestVersion || !isGreater(latestVersion, release.version)) {
+      return NO_UPDATE_STATUS;
+    }
+    return { updateAvailable: true, latestVersion };
+  };
+  return { getStatus, refresh };
+}
+
 // src/server.ts
 var DEFAULT_HOST = "127.0.0.1";
 var DEFAULT_PORT = 0;
@@ -34524,6 +34812,7 @@ function createConsoleServer(deps = {}) {
   registerDefaultCarriers(carrierRegistry);
   const lock = createConsoleLock({ hostname: () => host });
   const observability = createConsoleObservabilityStore();
+  const updateCheck = deps.updateCheck ?? createConsoleUpdateCheckService();
   const theaters = new TheaterRegistry();
   const terminalTickets = createTerminalTicketRegistry();
   const folderGrants = createFolderGrantStore();
@@ -34891,6 +35180,7 @@ function createConsoleServer(deps = {}) {
       jobs: observability.listWorkspaces().reduce((count, workspace) => count + observability.listJobs(workspace.tenantId).length, 0),
       version: version2,
       channel,
+      ...updateCheck.getStatus(),
       port: lockHandle?.payload.port ?? port,
       wikiServerStatus: resolveWikiServerStatus(theaterId)
     };
@@ -35007,6 +35297,7 @@ function createConsoleServer(deps = {}) {
         });
       });
       if (!activeEndpoint) throw new Error("Console endpoint unavailable");
+      void updateCheck.refresh();
       return activeEndpoint;
     },
     async stop() {