autokap 1.7.1 → 1.7.3

package/dist/cli-runner.js

@@ -223,6 +223,13 @@ export async function runCapture(options) {
     // AUT-149: collect structured logs + progress events for export on failure.
     const logCollector = new LogCollector();
     logCollector.start();
+    // Register this local run server-side so the dashboard shows an "En cours"
+    // badge on the preset while it captures. Best-effort + local-only: skip dry
+    // runs and cloud runs (AUTOKAP_RUN_ID is set on cloud runners, which own
+    // their own capture_runs row). A failure here must never block the capture.
+    if (!options.dryRun && !process.env.AUTOKAP_RUN_ID) {
+        await postRunStart(config, runId, program.presetId, program.variants.length, options.env);
+    }
     const runOptions = {
         recoveryChain,
         abortSignal: options.abortSignal,
@@ -664,6 +671,29 @@ function getProgramFetchRetryDelayMs(attempt) {
 function sleep(ms) {
     return new Promise((resolve) => setTimeout(resolve, ms));
 }
+// Best-effort registration of a local run at its start, so the dashboard can
+// surface an "En cours" badge on the preset while the capture is in flight.
+// Never throws — a registration failure must not abort the capture.
+async function postRunStart(config, runId, presetId, variantCount, env) {
+    try {
+        const response = await fetch(`${config.apiBaseUrl}/api/cli/runs`, {
+            method: 'POST',
+            headers: {
+                'Authorization': `Bearer ${config.apiKey}`,
+                'Content-Type': 'application/json',
+            },
+            body: JSON.stringify({ runId, presetId, variantCount, env }),
+            signal: AbortSignal.timeout(10_000),
+        });
+        if (!response.ok) {
+            logger.warn(`[capture] Run registration failed (HTTP ${response.status}); the dashboard "in progress" badge may not appear`);
+        }
+    }
+    catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        logger.warn(`[capture] Run registration error: ${message}`);
+    }
+}
 async function uploadResults(config, program, result, runId = randomUUID()) {
     const artifactJobs = result.variantResults.flatMap((variant) => {
         const variantSpec = program.variants.find((entry) => entry.id === variant.variantId);

package/dist/cli-updater.d.ts

@@ -0,0 +1 @@
+export declare function maybePromptUpdate(currentVersion: string): Promise<void>;

package/dist/cli-updater.js

@@ -0,0 +1,273 @@
+// Self-update prompt for the bundled `autokap` CLI.
+//
+// Runs once per command, before Commander parses argv. Best-effort and
+// fail-open: any error, network timeout, or unexpected state silently skips
+// the prompt — the user's command must never be blocked by this check.
+//
+// Behavior summary:
+// - Skipped entirely when stdin/stdout is not a TTY, CI=1 is set, the current
+//   version is a pre-release, the CLI was invoked via `npx` cache, or argv
+//   contains only --version/--help (read-only commands).
+// - Fetches the latest version from the npm registry with a 2s hard timeout.
+// - Caches the result for 24h in ~/.autokap/last-update-check.json to avoid
+//   spamming the registry. If the cache is fresh and reports a newer version,
+//   re-prompts without re-fetching.
+// - On user acceptance, runs `npm install -g autokap@<version>` then respawns
+//   `autokap` with the original argv so the user's intended command runs
+//   against the new binary.
+import { spawn } from 'node:child_process';
+import fs from 'node:fs/promises';
+import https from 'node:https';
+import path from 'node:path';
+import readline from 'node:readline';
+import { URL } from 'node:url';
+import chalk from 'chalk';
+import { logger } from './logger.js';
+import { getConfigDir } from './cli-config.js';
+const REGISTRY_URL = 'https://registry.npmjs.org/autokap/latest';
+const CACHE_FILE_NAME = 'last-update-check.json';
+const CACHE_TTL_MS = 24 * 60 * 60 * 1000;
+const FETCH_TIMEOUT_MS = 2000;
+const DISABLE_ENV_VAR = 'AUTOKAP_DISABLE_UPDATE_CHECK';
+function isInteractive() {
+    return Boolean(process.stdout.isTTY && process.stdin.isTTY && !process.env.CI);
+}
+function isDisabledByEnv() {
+    const raw = process.env[DISABLE_ENV_VAR]?.trim().toLowerCase();
+    return raw === '1' || raw === 'true';
+}
+function isPrerelease(version) {
+    return version.includes('-');
+}
+function isNpxExecution() {
+    const here = import.meta.url;
+    return here.includes('/_npx/') || here.includes('\\_npx\\');
+}
+function isReadOnlyOrEmptyCommand() {
+    const argv = process.argv.slice(2);
+    if (argv.length === 0)
+        return true;
+    return argv.some(a => a === '--version' || a === '-V' || a === '--help' || a === '-h');
+}
+function cachePath() {
+    return path.join(getConfigDir(), CACHE_FILE_NAME);
+}
+async function readUpdateCheckCache() {
+    try {
+        const raw = await fs.readFile(cachePath(), 'utf-8');
+        const parsed = JSON.parse(raw);
+        if (typeof parsed === 'object' &&
+            parsed !== null &&
+            typeof parsed.checkedAt === 'string' &&
+            typeof parsed.latestVersion === 'string') {
+            const obj = parsed;
+            return { checkedAt: obj.checkedAt, latestVersion: obj.latestVersion };
+        }
+        return null;
+    }
+    catch {
+        return null;
+    }
+}
+async function writeUpdateCheckCache(latestVersion) {
+    try {
+        await fs.mkdir(getConfigDir(), { recursive: true });
+        const data = {
+            checkedAt: new Date().toISOString(),
+            latestVersion,
+        };
+        await fs.writeFile(cachePath(), JSON.stringify(data, null, 2), 'utf-8');
+    }
+    catch {
+        // best-effort
+    }
+}
+function isCacheFresh(cache) {
+    const checkedAt = Date.parse(cache.checkedAt);
+    if (Number.isNaN(checkedAt))
+        return false;
+    return Date.now() - checkedAt < CACHE_TTL_MS;
+}
+function fetchLatestVersion(timeoutMs, currentVersion) {
+    return new Promise(resolve => {
+        let settled = false;
+        const settle = (v) => {
+            if (settled)
+                return;
+            settled = true;
+            resolve(v);
+        };
+        let req;
+        try {
+            const url = new URL(REGISTRY_URL);
+            req = https.get({
+                hostname: url.hostname,
+                path: url.pathname + url.search,
+                port: url.port ? Number(url.port) : 443,
+                headers: {
+                    Accept: 'application/json',
+                    'User-Agent': `autokap-cli/${currentVersion}`,
+                },
+            }, res => {
+                if (res.statusCode !== 200) {
+                    res.resume();
+                    settle(null);
+                    return;
+                }
+                const chunks = [];
+                res.on('data', chunk => chunks.push(chunk));
+                res.on('end', () => {
+                    try {
+                        const json = JSON.parse(Buffer.concat(chunks).toString('utf-8'));
+                        const version = json && typeof json === 'object' && typeof json.version === 'string'
+                            ? json.version
+                            : null;
+                        settle(version);
+                    }
+                    catch {
+                        settle(null);
+                    }
+                });
+                res.on('error', () => settle(null));
+            });
+        }
+        catch {
+            settle(null);
+            return;
+        }
+        req.on('error', () => settle(null));
+        req.setTimeout(timeoutMs, () => {
+            req.destroy();
+            settle(null);
+        });
+    });
+}
+function parseSemverCore(version) {
+    const stripped = version.replace(/^v/, '').split(/[-+]/)[0];
+    const parts = stripped.split('.');
+    if (parts.length !== 3)
+        return null;
+    const nums = parts.map(p => parseInt(p, 10));
+    if (nums.some(n => Number.isNaN(n) || n < 0))
+        return null;
+    return [nums[0], nums[1], nums[2]];
+}
+function compareSemver(a, b) {
+    const pa = parseSemverCore(a);
+    const pb = parseSemverCore(b);
+    if (!pa || !pb)
+        return 0;
+    for (let i = 0; i < 3; i++) {
+        if (pa[i] > pb[i])
+            return 1;
+        if (pa[i] < pb[i])
+            return -1;
+    }
+    return 0;
+}
+function promptYesNo(question, defaultValue) {
+    return new Promise(resolve => {
+        let resolved = false;
+        const safeResolve = (v) => {
+            if (resolved)
+                return;
+            resolved = true;
+            resolve(v);
+        };
+        const rl = readline.createInterface({
+            input: process.stdin,
+            output: process.stdout,
+        });
+        const suffix = defaultValue ? ' (Y/n) ' : ' (y/N) ';
+        rl.question(question + suffix, answer => {
+            rl.close();
+            const normalized = answer.trim().toLowerCase();
+            if (normalized === '') {
+                safeResolve(defaultValue);
+                return;
+            }
+            if (['y', 'yes', 'o', 'oui'].includes(normalized)) {
+                safeResolve(true);
+                return;
+            }
+            if (['n', 'no', 'non'].includes(normalized)) {
+                safeResolve(false);
+                return;
+            }
+            safeResolve(defaultValue);
+        });
+        rl.on('close', () => safeResolve(defaultValue));
+    });
+}
+function runNpmInstall(version) {
+    return new Promise(resolve => {
+        const child = spawn('npm', ['install', '-g', `autokap@${version}`], {
+            stdio: 'inherit',
+            shell: process.platform === 'win32',
+        });
+        child.on('error', () => resolve(false));
+        child.on('exit', code => resolve(code === 0));
+    });
+}
+function respawnCli() {
+    return new Promise(() => {
+        const args = process.argv.slice(2);
+        const child = spawn('autokap', args, {
+            stdio: 'inherit',
+            shell: process.platform === 'win32',
+        });
+        child.on('exit', code => {
+            process.exit(code ?? 0);
+        });
+        child.on('error', () => {
+            process.exit(0);
+        });
+    });
+}
+export async function maybePromptUpdate(currentVersion) {
+    if (isDisabledByEnv())
+        return;
+    if (!isInteractive())
+        return;
+    if (isPrerelease(currentVersion))
+        return;
+    if (isNpxExecution())
+        return;
+    if (isReadOnlyOrEmptyCommand())
+        return;
+    let latestVersion = null;
+    const cache = await readUpdateCheckCache();
+    if (cache && isCacheFresh(cache)) {
+        if (compareSemver(cache.latestVersion, currentVersion) <= 0) {
+            return;
+        }
+        latestVersion = cache.latestVersion;
+    }
+    if (!latestVersion) {
+        latestVersion = await fetchLatestVersion(FETCH_TIMEOUT_MS, currentVersion);
+        if (!latestVersion)
+            return;
+        await writeUpdateCheckCache(latestVersion);
+    }
+    if (compareSemver(latestVersion, currentVersion) <= 0)
+        return;
+    console.log('');
+    logger.info(`A new version of autokap is available: ${chalk.gray(currentVersion)} → ${chalk.cyan(latestVersion)}`);
+    const accepted = await promptYesNo(`Update to ${latestVersion}?`, true);
+    if (!accepted) {
+        console.log('');
+        return;
+    }
+    console.log('');
+    logger.info(`Running npm install -g autokap@${latestVersion}…`);
+    const installed = await runNpmInstall(latestVersion);
+    if (!installed) {
+        logger.error(`Update failed. Run manually: npm install -g autokap@${latestVersion}`);
+        console.log('');
+        return;
+    }
+    logger.success(`Updated to ${latestVersion}. Re-running your command…`);
+    console.log('');
+    await respawnCli();
+}
+//# sourceMappingURL=cli-updater.js.map

package/dist/cli.js

@@ -7,6 +7,7 @@ const require = createRequire(import.meta.url);
 const { version } = require('../package.json');
 import { logger } from './logger.js';
 import { writeConfig, requireConfig, getConfigPath, getDefaultApiBaseUrl, getDefaultWsUrl, LOCAL_API_BASE_URL, LOCAL_WS_URL, API_BASE_URL_ENV_VAR, WS_URL_ENV_VAR, } from './cli-config.js';
+import { maybePromptUpdate } from './cli-updater.js';
 // ── Program definition ──────────────────────────────────────────────
 export const program = new Command();
 program
@@ -523,6 +524,12 @@ const isDirectExecution = resolvedArgv && await resolvedArgv.then(p => {
     return base === 'cli.js' || base === 'cli.ts';
 });
 if (isDirectExecution) {
+    try {
+        await maybePromptUpdate(version);
+    }
+    catch {
+        // fail-open: a crash in the updater must never block the user's command.
+    }
     program.parseAsync().catch(async (err) => {
         logger.error(err.message);
         process.exit(1);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "autokap",
-  "version": "1.7.1",
+  "version": "1.7.3",
   "description": "AI-powered CLI tool for capturing clean screenshots of websites",
   "type": "module",
   "main": "./dist/index.js",