shortcutxl 0.4.0 → 0.4.2

package/dist/startup/update-verification.d.ts

@@ -0,0 +1,87 @@
+/**
+ * Post-update check of the ShortcutXL that will actually run next (lyfegame/shortcut#14571).
+ *
+ * A package manager can exit 0 while the user's next `shortcut` still runs an old release: the
+ * update went to a different global prefix than the `shortcut` the terminal resolves first on
+ * PATH, or the configured registry served an older package. After the installer exits, the
+ * updater reads the updated installation back from disk, resolves `shortcut` on PATH the way each
+ * shell does, asks each of those for its version, and only then reports success.
+ */
+import { type ActiveInstallation, type UpdateInstallationDeps } from './update-installation.js';
+export interface ResolvedShortcutCommand {
+    /** A `shortcut` that a fresh shell runs first from PATH. */
+    path: string;
+    /** Package the command runs, when its shim can be followed. */
+    packageDir?: string;
+    /** Version the command runs. */
+    version?: string;
+    /** Whether the command runs the installation that was updated. */
+    runsInstallation: boolean;
+    /** `probe`: printed by `<path> --version`; `package`: read from the package it runs. */
+    versionSource?: 'package' | 'probe';
+}
+export type UpdateVerification = {
+    kind: 'verified';
+    /** Version a fresh `shortcut` runs (the installed version without one on PATH). */
+    version: string;
+    /** Version read back from the updated installation's package.json. */
+    installedVersion: string;
+    installation: ActiveInstallation;
+    command?: ResolvedShortcutCommand;
+} | {
+    /** The package manager exited 0 but the running installation is not the target release. */
+    kind: 'not-installed';
+    installedVersion?: string;
+    installation: ActiveInstallation;
+    command?: ResolvedShortcutCommand;
+} | {
+    /** The target was installed, but a fresh `shortcut` still runs an older release. */
+    kind: 'shadowed';
+    installedVersion: string;
+    installation: ActiveInstallation;
+    command: ResolvedShortcutCommand;
+    /**
+     * Set when cmd.exe already runs the update from this `shortcut`, but PowerShell skips its
+     * quoted Path entry and runs `command` instead.
+     */
+    activePath?: string;
+} | {
+    /**
+     * The target was installed, but a `shortcut` on PATH could neither report a version nor be
+     * followed to a package, so what a fresh invocation runs is unknown.
+     */
+    kind: 'unconfirmed';
+    installedVersion: string;
+    installation: ActiveInstallation;
+    command: ResolvedShortcutCommand;
+};
+export interface VerifyUpdateDeps extends UpdateInstallationDeps {
+    isFile?: (path: string) => boolean;
+    /** Version printed by `<path> --version`, or undefined when it can't be read. */
+    runVersion?: (path: string, env: NodeJS.ProcessEnv) => Promise<string | undefined>;
+}
+/**
+ * Verify that the target release is installed and is what every shell's fresh `shortcut` runs.
+ * Without a `shortcut` on PATH, the user runs the updated installation by path.
+ */
+export declare function verifyInstalledUpdate(targetVersion: string, installation: ActiveInstallation, deps?: VerifyUpdateDeps): Promise<UpdateVerification>;
+/**
+ * The `name` each terminal would run first from PATH (PATHEXT order on Windows), without
+ * duplicates. On Windows, cmd.exe unquotes a quoted PATH entry, while PowerShell and where.exe
+ * skip it, so the two can run different installs.
+ */
+export declare function resolveCommandCandidates(name: string, env: NodeJS.ProcessEnv, platform?: NodeJS.Platform, isFile?: (path: string) => boolean): string[];
+/** Strict major.minor.patch comparison; unparseable versions count as older. */
+export declare function isOlderVersion(version: string, minimum: string): boolean;
+/**
+ * The environment for `<path> --version`: the user's own, without the update check and without
+ * variables that would make the shim report the running installation instead of its own.
+ * Windows variable names are case-insensitive, so they are matched case-insensitively.
+ */
+export declare function versionProbeEnv(env: NodeJS.ProcessEnv): NodeJS.ProcessEnv;
+/**
+ * The last semver in `shortcut --version` output. Releases before 0.4.1 clear the screen before
+ * printing even when piped (`\x1b[2J\x1b[3J\x1b[H0.4.0`), so escape codes are removed first.
+ */
+export declare function parseVersionOutput(stdout: string): string | undefined;
+//# sourceMappingURL=update-verification.d.ts.map

package/dist/startup/update-verification.js

@@ -0,0 +1,204 @@
+/**
+ * Post-update check of the ShortcutXL that will actually run next (lyfegame/shortcut#14571).
+ *
+ * A package manager can exit 0 while the user's next `shortcut` still runs an old release: the
+ * update went to a different global prefix than the `shortcut` the terminal resolves first on
+ * PATH, or the configured registry served an older package. After the installer exits, the
+ * updater reads the updated installation back from disk, resolves `shortcut` on PATH the way each
+ * shell does, asks each of those for its version, and only then reports success.
+ */
+import { spawn } from 'child_process';
+import { statSync } from 'fs';
+import { posix, win32 } from 'path';
+import stripAnsi from 'strip-ansi';
+import { isSameInstallation, packageOfCommand, readInstalledVersion, updatedInstallationDir } from './update-installation.js';
+const COMMAND_NAME = 'shortcut';
+const VERSION_TIMEOUT_MS = 60_000;
+/**
+ * Variables that make a `shortcut` report another installation's version than its own:
+ * SHORTCUT_PACKAGE_DIR (config.ts getPackageDir) points every shim at the running package.
+ */
+const VERSION_REDIRECTING_ENV = new Set(['SHORTCUT_PACKAGE_DIR']);
+/**
+ * Verify that the target release is installed and is what every shell's fresh `shortcut` runs.
+ * Without a `shortcut` on PATH, the user runs the updated installation by path.
+ */
+export async function verifyInstalledUpdate(targetVersion, installation, deps = {}) {
+    const env = deps.env ?? process.env;
+    const platform = deps.platform ?? process.platform;
+    const installationDir = updatedInstallationDir(installation, deps);
+    const installedVersion = readInstalledVersion(installationDir, deps);
+    const candidates = resolveCommandCandidates(COMMAND_NAME, env, platform, deps.isFile);
+    const describe = (path) => describeCommand(path, installationDir, env, deps);
+    if (!installedVersion || isOlderVersion(installedVersion, targetVersion)) {
+        const [first] = candidates;
+        const command = first === undefined ? undefined : await describe(first);
+        return { kind: 'not-installed', installedVersion, installation, command };
+    }
+    // Every shell that could run `shortcut` next must get the new release.
+    let active;
+    let unconfirmed;
+    for (const path of candidates) {
+        const command = await describe(path);
+        if (command.version === undefined) {
+            unconfirmed ??= command;
+        }
+        else if (isOlderVersion(command.version, targetVersion)) {
+            return active
+                ? { kind: 'shadowed', installedVersion, installation, command, activePath: active.path }
+                : { kind: 'shadowed', installedVersion, installation, command };
+        }
+        else {
+            active ??= command;
+        }
+    }
+    if (unconfirmed) {
+        return { kind: 'unconfirmed', installedVersion, installation, command: unconfirmed };
+    }
+    return {
+        kind: 'verified',
+        version: active?.version ?? installedVersion,
+        installedVersion,
+        installation,
+        command: active
+    };
+}
+/**
+ * What one `shortcut` on PATH runs. Its own `--version` output is the version a fresh invocation
+ * prints; the package its shim names is the fallback when it cannot be run.
+ */
+async function describeCommand(path, installationDir, env, deps) {
+    const followed = packageOfCommand(path, deps);
+    const command = {
+        path,
+        runsInstallation: followed.packageDir !== undefined &&
+            isSameInstallation(followed.packageDir, installationDir, deps)
+    };
+    if (followed.packageDir)
+        command.packageDir = followed.packageDir;
+    const printed = await (deps.runVersion ?? runVersionCommand)(path, env).catch(() => undefined);
+    if (printed) {
+        command.version = printed;
+        command.versionSource = 'probe';
+    }
+    else if (followed.version) {
+        command.version = followed.version;
+        command.versionSource = 'package';
+    }
+    return command;
+}
+/**
+ * The `name` each terminal would run first from PATH (PATHEXT order on Windows), without
+ * duplicates. On Windows, cmd.exe unquotes a quoted PATH entry, while PowerShell and where.exe
+ * skip it, so the two can run different installs.
+ */
+export function resolveCommandCandidates(name, env, platform = process.platform, isFile = isExistingFile) {
+    const pathKey = Object.keys(env).find((key) => key.toLowerCase() === 'path') ?? 'PATH';
+    const entries = (env[pathKey] ?? '')
+        .split(platform === 'win32' ? win32.delimiter : posix.delimiter)
+        .map((entry) => entry.trim());
+    if (platform !== 'win32') {
+        const found = firstOnPath(name, entries, posix, [''], isFile);
+        return found ? [found] : [];
+    }
+    const pathExtKey = Object.keys(env).find((key) => key.toLowerCase() === 'pathext') ?? 'PATHEXT';
+    const extensions = (env[pathExtKey] ?? '.COM;.EXE;.BAT;.CMD')
+        .split(';')
+        .map((extension) => extension.trim().toLowerCase())
+        .filter(Boolean);
+    const isQuoted = (entry) => /^".*"$/.test(entry);
+    const cmd = firstOnPath(name, entries.map((entry) => (isQuoted(entry) ? entry.slice(1, -1) : entry)), win32, extensions, isFile);
+    const powershell = firstOnPath(name, entries.filter((entry) => !isQuoted(entry)), win32, extensions, isFile);
+    return [...new Set([cmd, powershell].filter((path) => path !== undefined))];
+}
+function firstOnPath(name, directories, paths, extensions, isFile) {
+    for (const directory of directories) {
+        if (!directory || !paths.isAbsolute(directory))
+            continue;
+        for (const extension of extensions) {
+            const candidate = paths.join(directory, `${name}${extension}`);
+            if (isFile(candidate))
+                return candidate;
+        }
+    }
+    return undefined;
+}
+/** Strict major.minor.patch comparison; unparseable versions count as older. */
+export function isOlderVersion(version, minimum) {
+    const parse = (value) => {
+        const parts = value.trim().split('-')[0].split('.').map(Number);
+        return parts.length === 3 && parts.every((part) => Number.isInteger(part) && part >= 0)
+            ? parts
+            : undefined;
+    };
+    const left = parse(version);
+    const right = parse(minimum);
+    if (!left || !right)
+        return true;
+    for (let index = 0; index < 3; index += 1) {
+        if (left[index] !== right[index])
+            return left[index] < right[index];
+    }
+    return false;
+}
+function isExistingFile(path) {
+    try {
+        return statSync(path).isFile();
+    }
+    catch {
+        return false;
+    }
+}
+/** Run `<path> --version` as the user's next terminal would, without an update check. */
+function runVersionCommand(path, env) {
+    const options = {
+        env: versionProbeEnv(env),
+        stdio: ['ignore', 'pipe', 'ignore'],
+        windowsHide: true
+    };
+    return new Promise((resolve) => {
+        // A .cmd/.bat shim needs a shell. Pass it one command line, not an args array, which
+        // Node 24 deprecates with shell: true (DEP0190).
+        const child = /\.(cmd|bat)$/i.test(path)
+            ? spawn(`"${path}" --version`, { ...options, shell: true })
+            : spawn(path, ['--version'], options);
+        let stdout = '';
+        const timer = setTimeout(() => {
+            child.kill();
+            resolve(undefined);
+        }, VERSION_TIMEOUT_MS);
+        child.stdout?.on('data', (chunk) => {
+            stdout += String(chunk);
+        });
+        child.once('error', () => {
+            clearTimeout(timer);
+            resolve(undefined);
+        });
+        child.once('close', (code) => {
+            clearTimeout(timer);
+            resolve(code === 0 ? parseVersionOutput(stdout) : undefined);
+        });
+    });
+}
+/**
+ * The environment for `<path> --version`: the user's own, without the update check and without
+ * variables that would make the shim report the running installation instead of its own.
+ * Windows variable names are case-insensitive, so they are matched case-insensitively.
+ */
+export function versionProbeEnv(env) {
+    const probeEnv = {};
+    for (const [key, value] of Object.entries(env)) {
+        if (!VERSION_REDIRECTING_ENV.has(key.toUpperCase()))
+            probeEnv[key] = value;
+    }
+    return { ...probeEnv, SHORTCUT_SKIP_VERSION_CHECK: '1' };
+}
+/**
+ * The last semver in `shortcut --version` output. Releases before 0.4.1 clear the screen before
+ * printing even when piped (`\x1b[2J\x1b[3J\x1b[H0.4.0`), so escape codes are removed first.
+ */
+export function parseVersionOutput(stdout) {
+    const versions = stripAnsi(stdout).match(/\b\d+\.\d+\.\d+(?:-[0-9A-Za-z.-]+)?\b/g);
+    return versions ? versions[versions.length - 1] : undefined;
+}
+//# sourceMappingURL=update-verification.js.map

package/dist/supported-models.generated.js

@@ -354,7 +354,7 @@ export const MODEL_CATALOG = {
                         control: 'adaptive-effort',
                         defaultLevel: 'medium',
                         levels: ['low', 'medium', 'high', 'xhigh', 'max'],
-                        supportsOff: true
+                        supportsOff: false
                     }
                 },
                 protocol: 'anthropic-messages'

package/native-app/main/chunks/{config-CwtqLhpn.js → config-DSoKsgPT.js}

@@ -1,6 +1,6 @@
 import { appendFileSync, mkdirSync, existsSync, readFileSync, writeFileSync } from "fs";
 import { join, dirname } from "path";
-import { g as getAgentDir } from "./setup-worker-protocol-QUVpcuEb.js";
+import { g as getAgentDir } from "./setup-worker-protocol-CHVmPxBP.js";
 import "node:process";
 import "node:os";
 import "node:tty";

package/native-app/main/chunks/{linux-C5J5oKJy.js → linux-TBGGGecs.js}

@@ -1,9 +1,9 @@
 import { existsSync } from "fs";
-import { e as ensureUv$1 } from "./shared-Q59yhreZ.js";
-import { a, b, c, s } from "./shared-Q59yhreZ.js";
+import { e as ensureUv$1 } from "./shared-BbAcLTbB.js";
+import { a, b, c, s } from "./shared-BbAcLTbB.js";
 import { h as header, o as ok, l as log } from "../setup-worker.js";
 import "path";
-import "./setup-worker-protocol-QUVpcuEb.js";
+import "./setup-worker-protocol-CHVmPxBP.js";
 import "node:process";
 import "node:os";
 import "node:tty";

package/native-app/main/chunks/{mac-Bt_bFwUg.js → mac-Dg93p_2s.js}

@@ -1,9 +1,9 @@
 import { existsSync } from "fs";
-import { e as ensureUv$1 } from "./shared-Q59yhreZ.js";
-import { a, b, c, s } from "./shared-Q59yhreZ.js";
+import { e as ensureUv$1 } from "./shared-BbAcLTbB.js";
+import { a, b, c, s } from "./shared-BbAcLTbB.js";
 import { h as header, o as ok, l as log } from "../setup-worker.js";
 import "path";
-import "./setup-worker-protocol-QUVpcuEb.js";
+import "./setup-worker-protocol-CHVmPxBP.js";
 import "node:process";
 import "node:os";
 import "node:tty";

package/native-app/main/chunks/{setup-worker-protocol-QUVpcuEb.js → setup-worker-protocol-CHVmPxBP.js}

@@ -508,33 +508,50 @@ function detectInstallMethod() {
 }
 function getUpdateInstruction(packageName) {
   const method = detectInstallMethod();
+  const suffix = process.platform === "win32" ? ".cmd" : "";
   switch (method) {
     case "pnpm":
       return `Run: pnpm add -g ${packageName}`;
     case "yarn":
       return `Run: yarn global add ${packageName}`;
     case "npm":
-      return `Run: npm install -g ${packageName}`;
+      return `Run: npm${suffix} install -g ${packageName}`;
     default:
-      return `Run: npm install -g ${packageName}`;
+      return `Run: npm${suffix} install -g ${packageName}`;
   }
 }
-function getUpdateCommand(packageName) {
-  const command = getUpdateLaunchCommand(packageName);
-  return [command.executable, ...command.args].join(" ");
+function getUpdateCommand(packageName, target = {}) {
+  const command = getUpdateLaunchCommand(packageName, target);
+  return [command.executable, ...command.args.map(quoteShellArgument)].join(" ");
 }
-function getUpdateLaunchCommand(packageName) {
+function getUpdateLaunchCommand(packageName, target = {}) {
+  const spec = target.version ? `${packageName}@${target.version}` : packageName;
   switch (detectInstallMethod()) {
     case "pnpm":
-      return { executable: "pnpm", args: ["add", "-g", packageName] };
+      return { executable: "pnpm", args: ["add", "-g", spec] };
     case "yarn":
-      return { executable: "yarn", args: ["global", "add", packageName] };
+      return { executable: "yarn", args: ["global", "add", spec] };
     case "npm":
     default:
-      return { executable: "npm", args: ["install", "-g", packageName] };
+      return {
+        executable: "npm",
+        args: [
+          "install",
+          "-g",
+          // Forward slashes keep Windows paths intact in both Git Bash and cmd.exe.
+          ...target.npmPrefix ? ["--prefix", target.npmPrefix.replaceAll("\\", "/")] : [],
+          spec
+        ]
+      };
   }
 }
+function quoteShellArgument(argument) {
+  return /^[\w@./:=+-]+$/.test(argument) ? argument : `"${argument.replaceAll('"', "")}"`;
+}
 function getPackageDir() {
+  return getPackageDirOverride() ?? getRuntimePackageDir();
+}
+function getPackageDirOverride() {
   const envDir = process.env.SHORTCUT_PACKAGE_DIR;
   if (envDir) {
     if (envDir === "~")
@@ -543,6 +560,9 @@ function getPackageDir() {
       return homedir() + envDir.slice(1);
     return envDir;
   }
+  return void 0;
+}
+function getRuntimePackageDir() {
   let dir = __dirname$1;
   while (dir !== dirname(dir)) {
     if (existsSync(join(dir, "package.json"))) {
@@ -550,7 +570,7 @@ function getPackageDir() {
     }
     dir = dirname(dir);
   }
-  return __dirname$1;
+  return getPackageDirOverride() ?? __dirname$1;
 }
 function isSourceCheckout() {
   return process.env.SHORTCUT_FORCE_SOURCE_CHECKOUT === "1";
@@ -589,9 +609,6 @@ function getExportTemplateDir() {
     "src/shell/export-html"
   ]);
 }
-function getPackageJsonPath() {
-  return join(getPackageDir(), "package.json");
-}
 function getDocsPath() {
   return resolve(join(getPackageDir(), "agent-docs", "docs"));
 }
@@ -601,7 +618,7 @@ function getUserDocsPath() {
 function getChangelogPath() {
   return resolve(join(getPackageDir(), "CHANGELOG.md"));
 }
-const pkg = JSON.parse(readFileSync(getPackageJsonPath(), "utf-8"));
+const pkg = JSON.parse(readFileSync(join(getRuntimePackageDir(), "package.json"), "utf-8"));
 const APP_NAME = pkg.shortcutConfig?.name || "shortcut";
 const CONFIG_DIR_NAME = pkg.shortcutConfig?.configDir || ".shortcut";
 const VERSION = pkg.version;
@@ -627,7 +644,7 @@ function isNewSheetEnabled() {
 }
 const NPM_REGISTRY_URL = process.env.SHORTCUT_NPM_REGISTRY_URL?.trim() || `https://registry.npmjs.org/${NPM_PACKAGE_NAME}/latest`;
 function resolveOwnBinary() {
-  const packageDir = getPackageDir();
+  const packageDir = getRuntimePackageDir();
   const currentScript = process.argv[1] ? resolve(process.argv[1]) : "";
   const preferSource = currentScript.endsWith(".ts");
   const candidates = preferSource ? [join(packageDir, "src/cli.ts"), join(packageDir, "dist/cli.js")] : [join(packageDir, "dist/cli.js"), join(packageDir, "src/cli.ts")];
@@ -793,6 +810,7 @@ const config = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProper
   getPowerPointBridgePath,
   getPromptsDir,
   getPythonPathDirs,
+  getRuntimePackageDir,
   getSessionsDir,
   getSettingsPath,
   getStableXllDir,
@@ -839,26 +857,27 @@ export {
   NPM_PACKAGE_NAME as N,
   VERSION as V,
   getPackageDir as a,
-  getUpdateCachePath as b,
+  getRuntimePackageDir as b,
   chalk as c,
-  NPM_REGISTRY_URL as d,
-  getUpdateLaunchCommand as e,
-  getUpdateCommand as f,
+  getUpdateCachePath as d,
+  NPM_REGISTRY_URL as e,
+  getUpdateLaunchCommand as f,
   getAgentDir as g,
-  getUpdateInstruction as h,
-  getBinDir as i,
-  isSetupWorkerMessage as j,
-  getStableXllDir as k,
-  getXllPath as l,
-  getEmbeddedPythonExe as m,
-  getWordBridgePath as n,
-  getPowerPointBridgePath as o,
-  isInstalled as p,
-  isSourceCheckout as q,
-  isSetupWorkerResponse as r,
-  getSettingsPath as s,
-  getUvBinPath as t,
-  getUvVenvDir as u,
-  getUvPythonDir as v,
-  config as w
+  getUpdateCommand as h,
+  getUpdateInstruction as i,
+  getBinDir as j,
+  isSetupWorkerMessage as k,
+  getStableXllDir as l,
+  getXllPath as m,
+  getEmbeddedPythonExe as n,
+  getWordBridgePath as o,
+  getPowerPointBridgePath as p,
+  isInstalled as q,
+  isSourceCheckout as r,
+  isSetupWorkerResponse as s,
+  getSettingsPath as t,
+  getUvBinPath as u,
+  getUvVenvDir as v,
+  getUvPythonDir as w,
+  config as x
 };

package/native-app/main/chunks/{shared-Q59yhreZ.js → shared-BbAcLTbB.js}

@@ -1,6 +1,6 @@
 import { readFileSync, writeFileSync, existsSync, mkdirSync, unlinkSync, chmodSync } from "fs";
 import { join, dirname } from "path";
-import { s as getSettingsPath, t as getUvBinPath, u as getUvVenvDir, V as VERSION, v as getUvPythonDir } from "./setup-worker-protocol-QUVpcuEb.js";
+import { t as getSettingsPath, u as getUvBinPath, v as getUvVenvDir, V as VERSION, w as getUvPythonDir } from "./setup-worker-protocol-CHVmPxBP.js";
 import { h as header, o as ok, l as log, n as note, r as runWithProgress, a as run } from "../setup-worker.js";
 const UV_VERSION = "0.7.2";
 const UV_PYTHON_VERSION = "3.13";