kandev 0.2.0 → 0.4.0

package/dist/dev.js

@@ -37,17 +37,20 @@ async function runDev({ repoRoot, backendPort, webPort }) {
     supervisor.children.push(backendProc);
     (0, shared_1.attachBackendExitHandler)(backendProc, supervisor);
     const healthTimeoutMs = (0, health_1.resolveHealthTimeoutMs)(constants_1.HEALTH_TIMEOUT_MS_DEV);
+    console.log("[kandev] starting backend...");
     await (0, health_1.waitForHealth)(ports.backendUrl, backendProc, healthTimeoutMs);
     console.log(`[kandev] backend ready at ${ports.backendUrl}`);
     const webUrl = `http://localhost:${ports.webPort}`;
-    (0, web_1.launchWebApp)({
+    console.log("[kandev] starting web...");
+    const webProc = (0, web_1.launchWebApp)({
         command: "pnpm",
         args: ["-C", "apps", "--filter", "@kandev/web", "dev"],
         cwd: repoRoot,
         env: webEnv,
-        url: webUrl,
         supervisor,
         label: "web",
     });
+    await (0, health_1.waitForUrlReady)(webUrl, webProc, healthTimeoutMs);
     console.log(`[kandev] web ready at ${webUrl}`);
+    (0, web_1.openBrowser)(webUrl);
 }

package/dist/github.js

@@ -4,6 +4,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getRelease = getRelease;
+exports.readSha256 = readSha256;
 exports.ensureAsset = ensureAsset;
 const node_crypto_1 = __importDefault(require("node:crypto"));
 const node_fs_1 = __importDefault(require("node:fs"));
@@ -12,38 +13,99 @@ const node_path_1 = __importDefault(require("node:path"));
 // Allow overriding the GitHub repo for forks/testing.
 const OWNER = process.env.KANDEV_GITHUB_OWNER || "kdlbs";
 const REPO = process.env.KANDEV_GITHUB_REPO || "kandev";
-const API_BASE = `https://api.github.com/repos/${OWNER}/${REPO}`;
-function requestJson(url) {
+const WEB_BASE = `https://github.com/${OWNER}/${REPO}`;
+function authHeaders() {
+    if (process.env.KANDEV_GITHUB_TOKEN) {
+        return { Authorization: `Bearer ${process.env.KANDEV_GITHUB_TOKEN}` };
+    }
+    return {};
+}
+/**
+ * Resolve the latest release tag by following the redirect from
+ * github.com/{owner}/{repo}/releases/latest.
+ *
+ * Uses github.com (not api.github.com) so it is not subject to
+ * the REST API rate limit (60 req/hour per IP).
+ */
+function resolveLatestTag() {
+    const url = `${WEB_BASE}/releases/latest`;
     return new Promise((resolve, reject) => {
         const req = node_https_1.default.get(url, {
-            headers: {
-                "User-Agent": "kandev-npx",
-                Accept: "application/vnd.github+json",
-                ...(process.env.KANDEV_GITHUB_TOKEN
-                    ? { Authorization: `Bearer ${process.env.KANDEV_GITHUB_TOKEN}` }
-                    : {}),
-            },
+            headers: { "User-Agent": "kandev-npx", ...authHeaders() },
+            // Do not follow redirects — we just need the Location header.
+            followRedirect: false,
         }, (res) => {
-            if (res.statusCode !== 200) {
-                return reject(new Error(`HTTP ${res.statusCode} fetching ${url}`));
-            }
-            let body = "";
-            res.on("data", (chunk) => (body += chunk));
-            res.on("end", () => {
-                try {
-                    resolve(JSON.parse(body));
-                }
-                catch {
-                    reject(new Error(`Failed to parse JSON from ${url}`));
+            // Drain the response body to free the socket.
+            res.resume();
+            if ((res.statusCode === 301 || res.statusCode === 302) && res.headers.location) {
+                // Location: https://github.com/{owner}/{repo}/releases/tag/v0.2
+                const match = res.headers.location.match(/\/releases\/tag\/(.+)$/);
+                if (match) {
+                    return resolve(match[1]);
                 }
-            });
+                return reject(new Error(`Could not parse tag from redirect: ${res.headers.location}`));
+            }
+            // GitHub returns 200 if there's only one release (no redirect).
+            // In that case we need to parse the page — but this is uncommon.
+            // Fall back to a HEAD request on the resolved URL.
+            if (res.statusCode === 200 && res.headers.location) {
+                const match = res.headers.location.match(/\/releases\/tag\/(.+)$/);
+                if (match)
+                    return resolve(match[1]);
+            }
+            reject(new Error(`Failed to resolve latest release (HTTP ${res.statusCode})`));
         });
         req.setTimeout(5000, () => {
-            req.destroy(new Error(`Request timed out fetching ${url}`));
+            req.destroy(new Error("Request timed out resolving latest release"));
         });
         req.on("error", reject);
     });
 }
+/**
+ * Verify that a specific release tag exists.
+ */
+function verifyTagExists(tag) {
+    const url = `${WEB_BASE}/releases/tag/${tag}`;
+    return new Promise((resolve, reject) => {
+        const req = node_https_1.default.request(url, {
+            method: "HEAD",
+            headers: { "User-Agent": "kandev-npx", ...authHeaders() },
+        }, (res) => {
+            res.resume();
+            // GitHub returns 200 for the tag page, or 302 redirect to the tag page.
+            if (res.statusCode === 200 || res.statusCode === 301 || res.statusCode === 302) {
+                return resolve();
+            }
+            reject(new Error(`Release tag '${tag}' not found (HTTP ${res.statusCode})`));
+        });
+        req.setTimeout(5000, () => {
+            req.destroy(new Error(`Request timed out verifying tag '${tag}'`));
+        });
+        req.on("error", reject);
+        req.end();
+    });
+}
+/**
+ * Get release info. Uses github.com web URLs (not api.github.com)
+ * to avoid REST API rate limits.
+ */
+async function getRelease(version) {
+    if (version) {
+        await verifyTagExists(version);
+        return { tag_name: version };
+    }
+    const tag = await resolveLatestTag();
+    return { tag_name: tag };
+}
+// -- Asset downloading --------------------------------------------------------
+function readSha256(pathToSha) {
+    if (!node_fs_1.default.existsSync(pathToSha)) {
+        return null;
+    }
+    const content = node_fs_1.default.readFileSync(pathToSha, "utf8").trim();
+    const first = content.split(/\s+/)[0];
+    return first?.toLowerCase() || null;
+}
 function downloadFile(url, destPath, expectedSha256, onProgress) {
     const tempPath = `${destPath}.tmp`;
     return new Promise((resolve, reject) => {
@@ -56,7 +118,7 @@ function downloadFile(url, destPath, expectedSha256, onProgress) {
             catch { }
         };
         const handleResponse = (res) => {
-            // Follow redirects (GitHub API returns 302 to signed S3 URL).
+            // Follow redirects (GitHub returns 302 to signed S3/CDN URL).
             // Strip auth header on redirect to avoid S3 rejecting it.
             if ((res.statusCode === 301 || res.statusCode === 302) && res.headers.location) {
                 const redirectReq = node_https_1.default.get(res.headers.location, { headers: { "User-Agent": "kandev-npx" } }, handleResponse);
@@ -104,10 +166,7 @@ function downloadFile(url, destPath, expectedSha256, onProgress) {
         const req = node_https_1.default.get(url, {
             headers: {
                 "User-Agent": "kandev-npx",
-                Accept: "application/octet-stream",
-                ...(process.env.KANDEV_GITHUB_TOKEN
-                    ? { Authorization: `Bearer ${process.env.KANDEV_GITHUB_TOKEN}` }
-                    : {}),
+                ...authHeaders(),
             },
         }, handleResponse);
         req.setTimeout(30000, () => {
@@ -120,39 +179,29 @@ function downloadFile(url, destPath, expectedSha256, onProgress) {
         });
     });
 }
-function findAsset(release, name) {
-    return release.assets?.find((asset) => asset.name === name);
-}
-function readSha256(pathToSha) {
-    if (!node_fs_1.default.existsSync(pathToSha)) {
-        return null;
-    }
-    const content = node_fs_1.default.readFileSync(pathToSha, "utf8").trim();
-    const first = content.split(/\s+/)[0];
-    return first?.toLowerCase() || null;
-}
-async function getRelease(version) {
-    if (version) {
-        return requestJson(`${API_BASE}/releases/tags/${version}`);
-    }
-    return requestJson(`${API_BASE}/releases/latest`);
-}
-async function ensureAsset(release, assetName, cacheDir, onProgress) {
-    const asset = findAsset(release, assetName);
-    if (!asset) {
-        throw new Error(`Release asset not found: ${assetName}`);
-    }
+/**
+ * Ensure a release asset is downloaded and cached.
+ *
+ * Downloads directly from github.com/{owner}/{repo}/releases/download/{tag}/{asset}
+ * instead of the API, avoiding rate limits.
+ */
+async function ensureAsset(tag, assetName, cacheDir, onProgress) {
     node_fs_1.default.mkdirSync(cacheDir, { recursive: true });
     const destPath = node_path_1.default.join(cacheDir, assetName);
     const shaPath = `${destPath}.sha256`;
+    // Download sha256 checksum if not already cached.
     let expectedSha = readSha256(shaPath);
     if (!expectedSha) {
-        const shaAsset = findAsset(release, `${assetName}.sha256`);
-        if (shaAsset) {
-            await downloadFile(shaAsset.url, shaPath);
+        const shaUrl = `${WEB_BASE}/releases/download/${tag}/${assetName}.sha256`;
+        try {
+            await downloadFile(shaUrl, shaPath);
             expectedSha = readSha256(shaPath);
         }
+        catch {
+            // sha256 file may not exist for this release — continue without it.
+        }
     }
+    // Return cached tarball if it exists and checksum matches.
     if (node_fs_1.default.existsSync(destPath)) {
         if (!expectedSha) {
             return destPath;
@@ -165,6 +214,8 @@ async function ensureAsset(release, assetName, cacheDir, onProgress) {
         }
         node_fs_1.default.unlinkSync(destPath);
     }
-    await downloadFile(asset.url, destPath, expectedSha, onProgress);
+    // Download the asset.
+    const assetUrl = `${WEB_BASE}/releases/download/${tag}/${assetName}`;
+    await downloadFile(assetUrl, destPath, expectedSha, onProgress);
     return destPath;
 }

package/dist/health.js

@@ -3,6 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.delay = delay;
 exports.resolveHealthTimeoutMs = resolveHealthTimeoutMs;
 exports.waitForHealth = waitForHealth;
+exports.waitForUrlReady = waitForUrlReady;
 function delay(ms) {
     return new Promise((resolve) => setTimeout(resolve, ms));
 }
@@ -47,3 +48,20 @@ async function waitForHealth(baseUrl, proc, timeoutMs) {
     }
     throw new Error(`Backend healthcheck timed out after ${timeoutMs}ms`);
 }
+async function waitForUrlReady(url, proc, timeoutMs) {
+    const deadline = Date.now() + timeoutMs;
+    while (Date.now() < deadline) {
+        if (proc.exitCode !== null) {
+            throw new Error("Web process exited before URL became reachable");
+        }
+        try {
+            await fetch(url);
+            return;
+        }
+        catch {
+            // ignore until timeout
+        }
+        await delay(300);
+    }
+    throw new Error(`Web URL readiness timed out after ${timeoutMs}ms (${url})`);
+}

package/dist/run.js

@@ -3,6 +3,8 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.findCachedRelease = findCachedRelease;
+exports.cleanOldReleases = cleanOldReleases;
 exports.runRelease = runRelease;
 const node_child_process_1 = require("node:child_process");
 const node_fs_1 = __importDefault(require("node:fs"));
@@ -10,27 +12,103 @@ const node_path_1 = __importDefault(require("node:path"));
 const bundle_1 = require("./bundle");
 const constants_1 = require("./constants");
 const github_1 = require("./github");
-const constants_2 = require("./constants");
 const health_1 = require("./health");
 const platform_1 = require("./platform");
+const version_1 = require("./version");
 const ports_1 = require("./ports");
 const process_1 = require("./process");
 const shared_1 = require("./shared");
 const web_1 = require("./web");
+/**
+ * Find a cached release binary to use when GitHub is unreachable.
+ * If version is specified, checks that exact tag. Otherwise, picks
+ * the highest semver tag available in the cache.
+ */
+function findCachedRelease(platformDir, version) {
+    if (version) {
+        const cacheDir = node_path_1.default.join(constants_1.CACHE_DIR, version, platformDir);
+        const bundleDir = node_path_1.default.join(cacheDir, "kandev");
+        const backendBin = node_path_1.default.join(bundleDir, "bin", (0, platform_1.getBinaryName)("kandev"));
+        if (node_fs_1.default.existsSync(backendBin)) {
+            return { cacheDir, tag: version };
+        }
+        return null;
+    }
+    // No version specified — scan for cached tags and pick the latest.
+    if (!node_fs_1.default.existsSync(constants_1.CACHE_DIR))
+        return null;
+    const entries = node_fs_1.default.readdirSync(constants_1.CACHE_DIR).filter((d) => d.startsWith("v"));
+    if (entries.length === 0)
+        return null;
+    const sorted = (0, version_1.sortVersionsDesc)(entries);
+    for (const tag of sorted) {
+        const cacheDir = node_path_1.default.join(constants_1.CACHE_DIR, tag, platformDir);
+        const bundleDir = node_path_1.default.join(cacheDir, "kandev");
+        const backendBin = node_path_1.default.join(bundleDir, "bin", (0, platform_1.getBinaryName)("kandev"));
+        if (node_fs_1.default.existsSync(backendBin)) {
+            return { cacheDir, tag };
+        }
+    }
+    return null;
+}
+/**
+ * Remove old cached releases, keeping only the 2 most recent tags.
+ * Runs after a successful download so we don't accumulate stale versions.
+ * The previous version is kept as a fallback for offline use.
+ */
+function cleanOldReleases(currentTag) {
+    try {
+        if (!node_fs_1.default.existsSync(constants_1.CACHE_DIR))
+            return;
+        const entries = node_fs_1.default.readdirSync(constants_1.CACHE_DIR).filter((d) => d.startsWith("v"));
+        if (entries.length <= 2)
+            return;
+        const sorted = (0, version_1.sortVersionsDesc)(entries);
+        // Always keep currentTag + the next most recent.
+        const keep = new Set([currentTag, sorted[0], sorted[1]]);
+        for (const entry of entries) {
+            if (!keep.has(entry)) {
+                node_fs_1.default.rmSync(node_path_1.default.join(constants_1.CACHE_DIR, entry), { recursive: true, force: true });
+            }
+        }
+    }
+    catch {
+        // Non-critical — don't fail the launch if cleanup errors.
+    }
+}
 async function prepareReleaseBundle({ version, backendPort, webPort, }) {
     const platformDir = (0, platform_1.getPlatformDir)();
-    const release = await (0, github_1.getRelease)(version);
-    const tag = release.tag_name || "latest";
-    const assetName = `kandev-${platformDir}.tar.gz`;
-    const cacheDir = node_path_1.default.join(constants_2.CACHE_DIR, tag, platformDir);
-    const archivePath = await (0, github_1.ensureAsset)(release, assetName, cacheDir, (downloaded, total) => {
-        const percent = total ? Math.round((downloaded / total) * 100) : 0;
-        const mb = (downloaded / (1024 * 1024)).toFixed(1);
-        const totalMb = total ? (total / (1024 * 1024)).toFixed(1) : "?";
-        process.stderr.write(`\r   Downloading: ${mb}MB / ${totalMb}MB (${percent}%)`);
-    });
-    process.stderr.write("\n");
-    (0, bundle_1.ensureExtracted)(archivePath, cacheDir);
+    let tag;
+    let cacheDir;
+    try {
+        const release = await (0, github_1.getRelease)(version);
+        tag = release.tag_name;
+        const assetName = `kandev-${platformDir}.tar.gz`;
+        cacheDir = node_path_1.default.join(constants_1.CACHE_DIR, tag, platformDir);
+        const archivePath = await (0, github_1.ensureAsset)(tag, assetName, cacheDir, (downloaded, total) => {
+            const percent = total ? Math.round((downloaded / total) * 100) : 0;
+            const mb = (downloaded / (1024 * 1024)).toFixed(1);
+            const totalMb = total ? (total / (1024 * 1024)).toFixed(1) : "?";
+            process.stderr.write(`\r   Downloading: ${mb}MB / ${totalMb}MB (${percent}%)`);
+        });
+        process.stderr.write("\n");
+        (0, bundle_1.ensureExtracted)(archivePath, cacheDir);
+        cleanOldReleases(tag);
+    }
+    catch (err) {
+        // GitHub unreachable — try to launch from cache.
+        const cached = findCachedRelease(platformDir, version);
+        if (!cached) {
+            const target = version ? `version ${version}` : "latest version";
+            const reason = err instanceof Error ? err.message : String(err);
+            throw new Error(`Failed to fetch ${target} and no cached release found.\n` +
+                `  Reason: ${reason}\n` +
+                `  Run kandev once while online to cache a release for offline use.`);
+        }
+        tag = cached.tag;
+        cacheDir = cached.cacheDir;
+        process.stderr.write(`[kandev] GitHub unreachable — using cached release ${tag}\n`);
+    }
     const bundleDir = (0, bundle_1.findBundleRoot)(cacheDir);
     const backendBin = node_path_1.default.join(bundleDir, "bin", (0, platform_1.getBinaryName)("kandev"));
     if (!node_fs_1.default.existsSync(backendBin)) {
@@ -109,24 +187,27 @@ function launchReleaseApps(prepared) {
     if (!webServerPath) {
         throw new Error("Web server entry (server.js) not found in bundle");
     }
+    return { supervisor, backendProc, webServerPath };
+}
+async function runRelease({ version, backendPort, webPort }) {
+    const prepared = await prepareReleaseBundle({ version, backendPort, webPort });
+    const { supervisor, backendProc, webServerPath } = launchReleaseApps(prepared);
+    const healthTimeoutMs = (0, health_1.resolveHealthTimeoutMs)(constants_1.HEALTH_TIMEOUT_MS_RELEASE);
+    console.log("[kandev] starting backend...");
+    await (0, health_1.waitForHealth)(prepared.backendUrl, backendProc, healthTimeoutMs);
+    console.log(`[kandev] backend ready at ${prepared.backendUrl}`);
     const webUrl = `http://localhost:${prepared.webPort}`;
-    (0, web_1.launchWebApp)({
+    console.log("[kandev] starting web...");
+    const webProc = (0, web_1.launchWebApp)({
         command: "node",
         args: [webServerPath],
         cwd: node_path_1.default.dirname(webServerPath),
         env: prepared.webEnv,
-        url: webUrl,
         supervisor,
         label: "web",
+        quiet: true,
     });
-    return { supervisor, backendProc, webServerPath };
-}
-async function runRelease({ version, backendPort, webPort }) {
-    const prepared = await prepareReleaseBundle({ version, backendPort, webPort });
-    const { backendProc } = launchReleaseApps(prepared);
-    // Wait for backend before announcing the web URL.
-    const healthTimeoutMs = (0, health_1.resolveHealthTimeoutMs)(constants_1.HEALTH_TIMEOUT_MS_RELEASE);
-    await (0, health_1.waitForHealth)(prepared.backendUrl, backendProc, healthTimeoutMs);
-    console.log(`[kandev] backend ready at ${prepared.backendUrl}`);
-    console.log(`[kandev] web ready at http://localhost:${prepared.webPort}`);
+    await (0, health_1.waitForUrlReady)(webUrl, webProc, healthTimeoutMs);
+    console.log(`[kandev] web ready at ${webUrl}`);
+    (0, web_1.openBrowser)(webUrl);
 }

package/dist/start.js

@@ -107,19 +107,22 @@ async function runStart({ repoRoot, backendPort, webPort, verbose = false, debug
     }
     (0, shared_1.attachBackendExitHandler)(backendProc, supervisor);
     const healthTimeoutMs = (0, health_1.resolveHealthTimeoutMs)(constants_1.HEALTH_TIMEOUT_MS_RELEASE);
+    console.log("[kandev] starting backend...");
     await (0, health_1.waitForHealth)(ports.backendUrl, backendProc, healthTimeoutMs);
+    console.log(`[kandev] backend ready at ${ports.backendUrl}`);
     // Use standalone server.js directly (not pnpm start)
     const webUrl = `http://localhost:${ports.webPort}`;
-    (0, web_1.launchWebApp)({
+    console.log("[kandev] starting web...");
+    const webProc = (0, web_1.launchWebApp)({
         command: "node",
         args: [webServerPath],
         cwd: webStandaloneDir,
         env: webEnv,
-        url: webUrl,
         supervisor,
         label: "web",
         quiet: !showOutput,
     });
-    console.log(`[kandev] backend ready at ${ports.backendUrl}`);
+    await (0, health_1.waitForUrlReady)(webUrl, webProc, healthTimeoutMs);
     console.log(`[kandev] web ready at ${webUrl}`);
+    (0, web_1.openBrowser)(webUrl);
 }

package/dist/update.js

@@ -7,6 +7,7 @@ exports.maybePromptForUpdate = maybePromptForUpdate;
 const node_child_process_1 = require("node:child_process");
 const node_https_1 = __importDefault(require("node:https"));
 const node_readline_1 = __importDefault(require("node:readline"));
+const version_1 = require("./version");
 function requestJson(url) {
     return new Promise((resolve, reject) => {
         const req = node_https_1.default.get(url, { headers: { "User-Agent": "kandev-npx" } }, (res) => {
@@ -34,19 +35,6 @@ async function getLatestNpmVersion() {
     const data = await requestJson("https://registry.npmjs.org/kandev");
     return data?.["dist-tags"]?.latest;
 }
-function compareVersions(a, b) {
-    const pa = String(a).replace(/^v/, "").split(".").map(Number);
-    const pb = String(b).replace(/^v/, "").split(".").map(Number);
-    for (let i = 0; i < Math.max(pa.length, pb.length); i += 1) {
-        const av = pa[i] ?? 0;
-        const bv = pb[i] ?? 0;
-        if (av > bv)
-            return 1;
-        if (av < bv)
-            return -1;
-    }
-    return 0;
-}
 function promptYesNo(question, defaultYes = false) {
     return new Promise((resolve) => {
         if (!process.stdin.isTTY) {
@@ -80,7 +68,7 @@ async function maybePromptForUpdate(currentVersion, args) {
         const latest = await getLatestNpmVersion();
         if (!latest)
             return;
-        if (compareVersions(latest, currentVersion) <= 0)
+        if ((0, version_1.compareVersions)(latest, currentVersion) <= 0)
             return;
         const wantsUpdate = await promptYesNo(`Update available: ${currentVersion} -> ${latest}. Update now?`, false);
         if (!wantsUpdate)

package/dist/version.js

@@ -0,0 +1,57 @@
+"use strict";
+/**
+ * Centralized version parsing and comparison for the CLI.
+ *
+ * Version format: optional "v" prefix + dot-separated numeric segments.
+ * Examples: "v1.2", "0.3.0", "v2.0.1", "1"
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseVersion = parseVersion;
+exports.compareVersions = compareVersions;
+exports.sortVersionsDesc = sortVersionsDesc;
+/**
+ * Parse a version string into numeric segments.
+ * Strips leading "v" prefix if present.
+ *
+ * "v1.2.3" -> { raw: "v1.2.3", segments: [1, 2, 3] }
+ * "0.3"    -> { raw: "0.3",    segments: [0, 3] }
+ * "bad"    -> { raw: "bad",    segments: [] }
+ */
+function parseVersion(version) {
+    const cleaned = String(version).replace(/^v/, "");
+    const parts = cleaned.split(".");
+    const segments = [];
+    for (const part of parts) {
+        const n = parseInt(part, 10);
+        if (Number.isNaN(n))
+            return { raw: version, segments: [] };
+        segments.push(n);
+    }
+    return { raw: version, segments };
+}
+/**
+ * Compare two version strings.
+ * Returns 1 if a > b, -1 if a < b, 0 if equal.
+ * Missing segments are treated as 0 (e.g. "1.0" == "1.0.0").
+ */
+function compareVersions(a, b) {
+    const pa = parseVersion(a).segments;
+    const pb = parseVersion(b).segments;
+    const len = Math.max(pa.length, pb.length);
+    for (let i = 0; i < len; i++) {
+        const av = pa[i] ?? 0;
+        const bv = pb[i] ?? 0;
+        if (av > bv)
+            return 1;
+        if (av < bv)
+            return -1;
+    }
+    return 0;
+}
+/**
+ * Sort version strings in descending order (newest first).
+ * Non-parseable strings sort to the end.
+ */
+function sortVersionsDesc(versions) {
+    return [...versions].sort((a, b) => compareVersions(b, a));
+}

package/dist/web.js

@@ -32,7 +32,7 @@ function openBrowser(url) {
         // ignore browser launch errors
     }
 }
-function launchWebApp({ command, args, cwd, env, url, supervisor, label, quiet = false, }) {
+function launchWebApp({ command, args, cwd, env, supervisor, label, quiet = false, }) {
     const stdio = quiet ? ["ignore", "pipe", "pipe"] : "inherit";
     const proc = (0, node_child_process_1.spawn)(command, args, { cwd, env, stdio });
     supervisor.children.push(proc);
@@ -45,6 +45,5 @@ function launchWebApp({ command, args, cwd, env, url, supervisor, label, quiet =
         const exitCode = signal ? 0 : (code ?? 1);
         void supervisor.shutdown(`${label} exit`).then(() => process.exit(exitCode));
     });
-    openBrowser(url);
     return proc;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "kandev",
-  "version": "0.2.0",
+  "version": "0.4.0",
   "private": false,
   "description": "NPX launcher for Kandev",
   "license": "AGPL-3.0-only",
@@ -20,12 +20,14 @@
   "devDependencies": {
     "@types/node": "^20",
     "tsx": "^4.15.7",
-    "typescript": "^5"
+    "typescript": "^5",
+    "vitest": "^1.6.0"
   },
   "scripts": {
     "dev": "tsx src/cli.ts",
     "build": "tsc -p tsconfig.json",
     "start": "node dist/cli.js",
+    "test": "vitest run",
     "prepublishOnly": "pnpm build"
   }
 }