@event4u/agent-switch 1.0.2 → 1.3.0

package/dist/gui-launch.js

@@ -1,91 +1,128 @@
 /**
  * `agent-switch gui` — launch the desktop tray GUI.
  *
- * The GUI is a native (Tauri) binary, so it can't run "as JS". Instead the
- * prebuilt binary ships as a per-platform optional-dependency npm package
- * (`@event4u/agent-switch-<platform>`, the esbuild pattern), installed
- * automatically alongside the CLI. Because it arrives via npm — not a
- * browser-downloaded DMG/exe — it carries no quarantine flag, so it launches
- * without the Gatekeeper / SmartScreen "unverified developer" block.
+ * The GUI is a native (Tauri) binary. Rather than ship it through npm, this
+ * downloads the prebuilt artifact from the matching GitHub Release on first
+ * use, caches it under ~/.agent-switch/gui/<version>/, and launches it. A
+ * release-downloaded, cached binary avoids the browser-download Gatekeeper
+ * quarantine, and reuses the artifacts the release already publishes.
  *
- * The platform→package / artifact / launch-argv resolution is pure and tested;
- * only {@link launchGui} touches the filesystem and spawns a process.
+ * Per platform the release carries a runnable artifact:
+ *   - macOS: `*.app.tar.gz` (the .app bundle) → extract, `open`.
+ *   - Linux: `*.AppImage`                     → chmod +x, run.
+ *   - Windows: `*-setup.exe` (NSIS installer) → run (installs; no portable exe).
+ *
+ * The platform→asset resolution is pure and tested; download/extract/launch
+ * touch the filesystem + network.
  */
-import { spawn } from "node:child_process";
-import { createRequire } from "node:module";
+import { spawn, spawnSync } from "node:child_process";
 import * as fs from "node:fs";
+import * as os from "node:os";
 import * as path from "node:path";
-const require = createRequire(import.meta.url);
-/** The optional-dependency package carrying the GUI binary for a platform+arch,
- *  or null when the platform is unsupported. macOS ships a universal binary, so
- *  one darwin package serves both arches. Pure. */
-export function guiPackageFor(platform = process.platform, arch = process.arch) {
+import { fileURLToPath } from "node:url";
+/** The repo whose GitHub Releases carry the GUI artifacts. */
+const UPDATE_REPO = "event4u-app/agent-switch";
+const CACHE_ROOT = path.join(os.homedir(), ".agent-switch", "gui");
+/** The running CLI's version, from the package's own package.json. */
+function currentVersion() {
+    try {
+        const pkg = path.join(path.dirname(fileURLToPath(import.meta.url)), "..", "package.json");
+        return JSON.parse(fs.readFileSync(pkg, "utf8")).version ?? "0.0.0";
+    }
+    catch {
+        return "0.0.0";
+    }
+}
+/** The release-asset pattern + handling for the host platform+arch, or null
+ *  when unsupported. Pure. */
+export function guiAssetSpec(platform = process.platform, arch = process.arch) {
     if (platform === "darwin")
-        return "@event4u/agent-switch-darwin";
-    if (platform === "win32" && arch === "x64")
-        return "@event4u/agent-switch-win32-x64";
+        return { match: /\.app\.tar\.gz$/, kind: "app" };
     if (platform === "linux" && arch === "x64")
-        return "@event4u/agent-switch-linux-x64";
+        return { match: /\.AppImage$/i, kind: "appimage" };
+    if (platform === "win32" && arch === "x64")
+        return { match: /-setup\.exe$/i, kind: "win-setup" };
     return null;
 }
-/** The artifact file name inside a platform package. macOS ships the `.app`
- *  bundle (launched via `open`), Windows the `.exe`, Linux the raw binary. Pure. */
-export function guiArtifactName(platform = process.platform) {
-    if (platform === "darwin")
-        return "agent-switch.app";
-    if (platform === "win32")
-        return "agent-switch.exe";
-    if (platform === "linux")
-        return "agent-switch";
+/** Program + args to launch a prepared artifact. Pure. */
+export function guiLaunchArgv(kind, target) {
+    if (kind === "app")
+        return { program: "open", args: ["-n", target] };
+    return { program: target, args: [] }; // AppImage runs directly; win-setup runs the installer
+}
+/** Find a matching GUI asset on the release for `version`, falling back to the
+ *  latest release. Returns null when neither has one. */
+async function findAsset(version, match) {
+    const headers = { Accept: "application/vnd.github+json", "User-Agent": "@event4u/agent-switch gui-launch" };
+    for (const ref of [`tags/${version}`, "latest"]) {
+        let res;
+        try {
+            res = await fetch(`https://api.github.com/repos/${UPDATE_REPO}/releases/${ref}`, { headers });
+        }
+        catch {
+            continue;
+        }
+        if (!res.ok)
+            continue;
+        const rel = (await res.json());
+        const a = (rel.assets ?? []).find((x) => match.test(x.name));
+        if (a)
+            return { name: a.name, url: a.browser_download_url };
+    }
     return null;
 }
-/** Program + args to launch the artifact at `artifactPath`. macOS uses `open`
- *  (the artifact is an .app bundle); elsewhere the binary is executed directly.
- *  Pure — the launch convention split out for testing. */
-export function guiLaunchArgv(platform, artifactPath) {
-    if (platform === "darwin")
-        return { program: "open", args: ["-n", artifactPath] };
-    return { program: artifactPath, args: [] };
+/** Download `url` to `dest` (follows redirects via global fetch). */
+async function download(url, dest) {
+    const res = await fetch(url, { headers: { "User-Agent": "@event4u/agent-switch gui-launch" } });
+    if (!res.ok)
+        throw new Error(`download failed: ${res.status} ${url}`);
+    const buf = Buffer.from(await res.arrayBuffer());
+    fs.writeFileSync(dest, buf);
 }
-/** Absolute path to the GUI artifact for the host, or null when the platform
- *  package isn't installed / the artifact is missing. */
-export function resolveGuiArtifact(platform = process.platform, arch = process.arch) {
-    const pkg = guiPackageFor(platform, arch);
-    const artifact = guiArtifactName(platform);
-    if (!pkg || !artifact)
-        return null;
-    let pkgDir;
-    try {
-        pkgDir = path.dirname(require.resolve(`${pkg}/package.json`));
+/** Ensure the GUI artifact for the host is downloaded + prepared under the
+ *  version cache, and return the path to launch. */
+async function ensureGuiArtifact(spec) {
+    const version = currentVersion();
+    const dir = path.join(CACHE_ROOT, version);
+    const launchName = spec.kind === "app" ? "agent-switch.app" : spec.kind === "appimage" ? "agent-switch.AppImage" : "agent-switch-setup.exe";
+    const launchPath = path.join(dir, launchName);
+    if (fs.existsSync(launchPath))
+        return launchPath; // already cached
+    const asset = await findAsset(version, spec.match);
+    if (!asset) {
+        throw new Error(`no GUI artifact for ${process.platform}/${process.arch} on the ${version} (or latest) release.\n` +
+            `Download an installer from https://github.com/${UPDATE_REPO}/releases instead.`);
     }
-    catch {
-        return null; // optional dependency not installed for this platform
+    fs.mkdirSync(dir, { recursive: true });
+    console.log(`Downloading the GUI (${asset.name})…`);
+    if (spec.kind === "app") {
+        const tgz = path.join(dir, "app.tar.gz");
+        await download(asset.url, tgz);
+        // Extract the .app bundle, then locate it (the tarball name may vary).
+        const r = spawnSync("tar", ["-xzf", tgz, "-C", dir], { encoding: "utf8" });
+        if (r.status !== 0)
+            throw new Error(`extract failed: ${r.stderr || r.status}`);
+        fs.rmSync(tgz, { force: true });
+        const appDir = fs.readdirSync(dir).find((n) => n.endsWith(".app"));
+        if (!appDir)
+            throw new Error("extracted archive contained no .app bundle");
+        if (appDir !== launchName)
+            fs.renameSync(path.join(dir, appDir), launchPath);
+        return launchPath;
     }
-    const p = path.join(pkgDir, "bin", artifact);
-    return fs.existsSync(p) ? p : null;
+    await download(asset.url, launchPath);
+    if (spec.kind === "appimage")
+        fs.chmodSync(launchPath, 0o755);
+    return launchPath;
 }
-/** Launch the desktop GUI, detached so the CLI returns immediately. Throws a
- *  helpful error when the platform is unsupported or the package is absent. */
-export function launchGui() {
-    const pkg = guiPackageFor();
-    if (!pkg) {
-        throw new Error(`the desktop GUI has no prebuilt binary for ${process.platform}/${process.arch} — build it from source with \`task gui:build\`.`);
-    }
-    const artifact = resolveGuiArtifact();
-    if (!artifact) {
-        throw new Error(`GUI binary not found — the platform package "${pkg}" is not installed.\n` +
-            `Reinstall the CLI so npm pulls it: \`npm install -g @event4u/agent-switch\`.`);
-    }
-    // On POSIX the raw binary needs the executable bit (npm can drop it).
-    if (process.platform !== "win32" && process.platform !== "darwin") {
-        try {
-            fs.chmodSync(artifact, 0o755);
-        }
-        catch {
-            /* best-effort */
-        }
+/** Launch the desktop GUI (downloading + caching it on first use). */
+export async function launchGui() {
+    const spec = guiAssetSpec();
+    if (!spec) {
+        throw new Error(`the desktop GUI has no prebuilt artifact for ${process.platform}/${process.arch} — build it from source with \`task gui:build\`.`);
     }
-    const { program, args } = guiLaunchArgv(process.platform, artifact);
+    const target = await ensureGuiArtifact(spec);
+    const { program, args } = guiLaunchArgv(spec.kind, target);
     const child = spawn(program, args, { detached: true, stdio: "ignore" });
     child.unref();
 }

package/dist/index.js

@@ -24,6 +24,7 @@ import { applySharing, removeSharing, syncSharing, sharedLinkHealth } from "./sh
 import { detectShell, shellenvScript } from "./shellenv.js";
 import { runDoctor } from "./doctor.js";
 import { launchGui } from "./gui-launch.js";
+import { checkForUpdate, selfUpdate } from "./updates.js";
 import { mappingRows, pruneMappings, removeMapping, resolveMapping, setMapping, } from "./mappings.js";
 import { accessTokenOf, checkAuth, fetchProfile, fetchUsage, liveSessionPids, readProfileCredential, } from "./api.js";
 import { formatSnapshot, parseUsage } from "./usage.js";
@@ -1525,17 +1526,53 @@ function cmdNotifications(sub, json = false) {
 }
 /** Launch a registered GUI app on a profile, isolated (macOS). Profile: an
  *  explicit positional name, else the active profile for the app's provider. */
-function cmdGui() {
-    // Launch the tray/menubar GUI (its prebuilt binary ships as a per-platform
-    // optional-dependency package; see gui-launch.ts).
+async function cmdGui() {
+    // Launch the tray/menubar GUI — downloads its prebuilt artifact from the
+    // matching GitHub Release on first use, then caches it (see gui-launch.ts).
     try {
-        launchGui();
+        await launchGui();
         console.log("Launched the agent-switch GUI.");
     }
     catch (err) {
         die(String(err?.message ?? err));
     }
 }
+/** `agent-switch check-update` — compare the running version against the latest
+ *  GitHub release (read-only; the same check the GUI runs). */
+async function cmdCheckUpdate(json = false) {
+    const c = await checkForUpdate();
+    if (json) {
+        console.log(JSON.stringify(c));
+        return;
+    }
+    switch (c.kind) {
+        case "uptodate":
+            console.log(`agent-switch ${c.current} — up to date (latest ${c.latest}).`);
+            break;
+        case "available":
+            console.log(`Update available: ${c.current} → ${c.release.tag}\n  ${c.release.url}\n  Run \`agent-switch update\` to install it.`);
+            break;
+        case "no-releases":
+            console.log(`agent-switch ${c.current} — no releases published yet.`);
+            break;
+        case "error":
+            console.log(`agent-switch ${c.current} — update check failed: ${c.message}`);
+            break;
+    }
+}
+/** `agent-switch update` — self-update to the latest published version via npm. */
+async function cmdUpdate() {
+    const c = await checkForUpdate();
+    if (c.kind === "uptodate")
+        return void console.log(`Already on the latest version (${c.current}).`);
+    if (c.kind === "no-releases")
+        return void console.log("No releases published yet — nothing to update to.");
+    if (c.kind === "available")
+        console.log(`Updating ${c.current} → ${c.release.tag} via npm…`);
+    else
+        console.log(`Update check failed (${c.message}); attempting \`npm install\` anyway…`);
+    process.exit(selfUpdate());
+}
 function cmdOpen(appId, name) {
     if (!appId)
         die("usage: agent-switch open <app> [profile]   (see `agent-switch apps`)");
@@ -1599,6 +1636,8 @@ Provider defaults to claude; pass --provider codex|antigravity for the others.
   agent-switch rename <old> <new> [--provider P]                               rename a profile (name & keep its tag)
   agent-switch providers enable|disable|status [--provider P] [--surface cli|ui]   enable/disable a provider (default: Claude + Codex)
   agent-switch gui                             launch the tray/menubar GUI (bundled via npm)
+  agent-switch check-update [--json]           check GitHub Releases for a newer version
+  agent-switch update                          self-update to the latest version (via npm)
   agent-switch apps                            list launchable GUI apps (macOS)
   agent-switch open <app> [profile]            launch a GUI app on a profile, isolated (macOS)
   agent-switch shellenv [--shell zsh|bash|fish|powershell]   shell integration
@@ -1643,6 +1682,10 @@ async function main() {
         case "rename": return cmdRename(providerId, positional[0], positional[1]);
         case "providers": return cmdProviders(providerId, providerExplicit, positional[0], flags);
         case "gui": return cmdGui();
+        case "update":
+        case "upgrade": return cmdUpdate();
+        case "check-update":
+        case "check-updates": return cmdCheckUpdate(!!flags.json);
         case "open": return cmdOpen(positional[0], positional[1]);
         case "apps": return cmdApps(!!flags.json);
         case "notify": return cmdNotify(flags);

package/dist/updates.js

@@ -0,0 +1,110 @@
+/**
+ * CLI update check + self-update.
+ *
+ * Mirrors the GUI's update logic (gui/src/updates.ts): the same version math
+ * and GitHub `/releases/latest` parsing, but for the CLI — the running version
+ * comes from the package's own package.json, the fetch uses Node's global
+ * `fetch`, and `selfUpdate` reinstalls the npm package.
+ *
+ * The version/parse helpers are pure and unit-tested; only currentVersion,
+ * fetchLatestRelease, and selfUpdate touch the outside world.
+ */
+import { spawnSync } from "node:child_process";
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { fileURLToPath } from "node:url";
+/** The published npm package + the repo whose GitHub Releases are the update source. */
+export const PACKAGE_NAME = "@event4u/agent-switch";
+export const UPDATE_REPO = "event4u-app/agent-switch";
+/** Parse a version tag (`v1.2.3`, `1.2.3`, `1.2`) into numeric components. A
+ *  leading `v`/`V` and any pre-release/build suffix are stripped; non-numeric
+ *  components collapse to 0 so a malformed tag can never throw. */
+export function parseVersion(tag) {
+    const core = String(tag).trim().replace(/^[vV]/, "").split(/[-+]/, 1)[0];
+    return core.split(".").map((p) => {
+        const n = Number.parseInt(p, 10);
+        return Number.isFinite(n) ? n : 0;
+    });
+}
+/** Compare two version tags: -1 (a<b), 0 (equal), 1 (a>b). */
+export function compareVersions(a, b) {
+    const pa = parseVersion(a);
+    const pb = parseVersion(b);
+    const len = Math.max(pa.length, pb.length);
+    for (let i = 0; i < len; i++) {
+        const x = pa[i] ?? 0;
+        const y = pb[i] ?? 0;
+        if (x > y)
+            return 1;
+        if (x < y)
+            return -1;
+    }
+    return 0;
+}
+/** True when `latest` is strictly newer than `current`. */
+export function isNewer(latest, current) {
+    return compareVersions(latest, current) > 0;
+}
+/** Reshape a raw GitHub `releases/latest` payload into {@link ReleaseInfo}, or
+ *  null for a draft/prerelease or a payload without a tag. Pure — no network. */
+export function parseRelease(raw) {
+    if (!raw || typeof raw !== "object")
+        return null;
+    const r = raw;
+    if (r.draft === true || r.prerelease === true)
+        return null;
+    const tag = typeof r.tag_name === "string" ? r.tag_name : "";
+    if (!tag)
+        return null;
+    return {
+        tag,
+        name: typeof r.name === "string" && r.name ? r.name : tag,
+        url: typeof r.html_url === "string" ? r.html_url : `https://github.com/${UPDATE_REPO}/releases`,
+        notes: typeof r.body === "string" ? r.body : "",
+        publishedAt: typeof r.published_at === "string" ? r.published_at : "",
+    };
+}
+/** The running CLI's version, from the package's own package.json (one level up
+ *  from the compiled dist/). "0.0.0" if unreadable so callers never crash. */
+export function currentVersion() {
+    try {
+        const pkg = path.join(path.dirname(fileURLToPath(import.meta.url)), "..", "package.json");
+        return JSON.parse(fs.readFileSync(pkg, "utf8")).version ?? "0.0.0";
+    }
+    catch {
+        return "0.0.0";
+    }
+}
+/** Latest published release, or null when the repo has none yet (404). Throws
+ *  on other network/HTTP failures so the caller can surface them. */
+export async function fetchLatestRelease(repo = UPDATE_REPO) {
+    const res = await fetch(`https://api.github.com/repos/${repo}/releases/latest`, {
+        headers: { Accept: "application/vnd.github+json", "User-Agent": `${PACKAGE_NAME} cli-updater` },
+    });
+    if (res.status === 404)
+        return null;
+    if (!res.ok)
+        throw new Error(`GitHub API returned ${res.status}`);
+    return parseRelease(await res.json());
+}
+/** Read the current version, fetch the latest release, classify. Never throws. */
+export async function checkForUpdate(repo = UPDATE_REPO) {
+    const current = currentVersion();
+    try {
+        const release = await fetchLatestRelease(repo);
+        if (!release)
+            return { kind: "no-releases", current };
+        if (isNewer(release.tag, current))
+            return { kind: "available", current, release };
+        return { kind: "uptodate", current, latest: release.tag };
+    }
+    catch (e) {
+        return { kind: "error", current, message: e instanceof Error ? e.message : String(e) };
+    }
+}
+/** Self-update: reinstall the npm package at @latest (global). Streams npm's
+ *  own output; returns its exit code (0 = success). */
+export function selfUpdate() {
+    const r = spawnSync("npm", ["install", "-g", `${PACKAGE_NAME}@latest`], { stdio: "inherit" });
+    return r.status ?? 1;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@event4u/agent-switch",
-  "version": "1.0.2",
+  "version": "1.3.0",
   "description": "Switch between multiple Claude Code accounts on macOS, Linux, and Windows via isolated CLAUDE_CONFIG_DIR profiles",
   "repository": {
     "type": "git",
@@ -31,9 +31,6 @@
     "typescript": "^5.9.3"
   },
   "optionalDependencies": {
-    "playwright": "^1.49.0",
-    "@event4u/agent-switch-darwin": "1.0.2",
-    "@event4u/agent-switch-linux-x64": "1.0.2",
-    "@event4u/agent-switch-win32-x64": "1.0.2"
+    "playwright": "^1.49.0"
   }
 }