browse 0.8.5 → 0.9.0

package/dist/commands/screenshot.js

@@ -1,13 +1,17 @@
+import { closeSync, openSync, statSync, unlinkSync } from "node:fs";
+import { resolve } from "node:path";
 import { Flags } from "@oclif/core";
 import { BrowseCommand } from "../base.js";
 import { driverCommandFlags, parseClip, runDriverCommandFromFlags, } from "../lib/driver/command-cli.js";
 export default class Screenshot extends BrowseCommand {
     static description = "Capture a screenshot of the active browser page.";
     static examples = [
+        "browse screenshot",
         "browse screenshot --path page.png",
-        "browse screenshot --full-page --path page.png",
+        "browse screenshot --full-page",
         "browse screenshot --type jpeg --quality 80",
         "browse screenshot --clip 0,0,800,600 --path clipped.png",
+        "browse screenshot --base64",
     ];
     static flags = {
         ...driverCommandFlags,
@@ -15,6 +19,10 @@ export default class Screenshot extends BrowseCommand {
             description: "Whether CSS animations run during capture.",
             options: ["allow", "disabled"],
         }),
+        base64: Flags.boolean({
+            description: "Print base64 to stdout instead of writing a file (legacy default).",
+            exclusive: ["path"],
+        }),
         caret: Flags.string({
             description: "Whether text caret is hidden during capture.",
             options: ["hide", "initial"],
@@ -28,7 +36,7 @@ export default class Screenshot extends BrowseCommand {
         }),
         path: Flags.string({
             char: "p",
-            description: "Write the screenshot to a file. Without this flag, base64 is printed.",
+            description: "Write the screenshot to this file. Defaults to screenshot-<timestamp>.png (or .jpeg with --type jpeg) in the current directory.",
             helpValue: "<path>",
         }),
         quality: Flags.integer({
@@ -42,14 +50,77 @@ export default class Screenshot extends BrowseCommand {
     };
     async run() {
         const { flags } = await this.parse(Screenshot);
-        await runDriverCommandFromFlags("screenshot", {
-            animations: flags.animations,
-            caret: flags.caret,
-            clip: parseClip(flags.clip),
-            fullPage: flags["full-page"],
-            path: flags.path,
-            quality: flags.quality,
-            type: flags.type,
-        }, flags);
+        const defaultPath = getDefaultPathFromFlags(flags);
+        try {
+            await runDriverCommandFromFlags("screenshot", {
+                animations: flags.animations,
+                caret: flags.caret,
+                clip: parseClip(flags.clip),
+                fullPage: flags["full-page"],
+                path: flags.path ?? defaultPath,
+                quality: flags.quality,
+                type: flags.type,
+            }, flags);
+        }
+        catch (error) {
+            if (defaultPath)
+                removeIfEmpty(defaultPath);
+            throw error;
+        }
+    }
+}
+// Generous upper bound on filename-collision retries; far beyond any real
+// same-second burst, it just guarantees the loop below always terminates.
+const MAX_RESERVE_ATTEMPTS = 1000;
+/**
+ * Resolves the file the screenshot should be written to, or undefined when the
+ * driver should return base64 (explicit --path is handled separately; --base64
+ * opts out of a file entirely).
+ */
+function getDefaultPathFromFlags(flags) {
+    if (flags.path || flags.base64)
+        return undefined;
+    return reserveDefaultScreenshotPath(flags.type);
+}
+/**
+ * Picks the next free screenshot-<timestamp>[-<counter>].<type> name in the
+ * current directory and reserves it. "Reserve" = create the file with an
+ * exclusive open (`wx` → O_CREAT|O_EXCL), which atomically fails with EEXIST if
+ * the name already exists, so two concurrent runs can never claim the same
+ * file. On EEXIST we advance the counter and try the next name.
+ */
+function reserveDefaultScreenshotPath(type) {
+    const now = new Date();
+    const pad = (value) => String(value).padStart(2, "0");
+    const stamp = `${now.getFullYear()}${pad(now.getMonth() + 1)}${pad(now.getDate())}` +
+        `-${pad(now.getHours())}${pad(now.getMinutes())}${pad(now.getSeconds())}`;
+    const extension = type === "jpeg" ? "jpeg" : "png";
+    for (let counter = 1; counter <= MAX_RESERVE_ATTEMPTS; counter += 1) {
+        const suffix = counter === 1 ? "" : `-${counter}`;
+        const candidate = resolve(`screenshot-${stamp}${suffix}.${extension}`);
+        try {
+            // Exclusive create reserves the name; close immediately since the driver
+            // (re)writes the file. The empty placeholder is cleaned up on failure.
+            closeSync(openSync(candidate, "wx"));
+            return candidate;
+        }
+        catch (error) {
+            if (error.code !== "EEXIST")
+                throw error;
+        }
+    }
+    throw new Error(`Could not reserve a screenshot filename after ${MAX_RESERVE_ATTEMPTS} attempts; pass --path to choose one.`);
+}
+// Removes the reserved placeholder when the screenshot failed before the driver
+// wrote to it. `path` is always a file we created via openSync above, so the
+// isFile guard is just defensive against an unexpected directory/symlink.
+function removeIfEmpty(path) {
+    try {
+        const stats = statSync(path);
+        if (stats.isFile() && stats.size === 0)
+            unlinkSync(path);
+    }
+    catch {
+        // Best effort: leave the placeholder behind rather than mask the error.
     }
 }

package/dist/lib/skills/install.js

@@ -13,6 +13,18 @@ const domainPattern = /^[A-Za-z0-9](?:[A-Za-z0-9.-]*[A-Za-z0-9])?$/;
 const taskPattern = /^[A-Za-z0-9](?:[A-Za-z0-9._-]*[A-Za-z0-9])?$/;
 const maxSkillFiles = 100;
 const maxCapturedOutputBytes = 2048;
+const defaultInstallTimeoutMs = 180_000;
+const defaultFetchTimeoutMs = 10_000;
+function envTimeoutMs(name, fallback) {
+    const value = Number(process.env[name]);
+    return Number.isFinite(value) && value > 0 ? value : fallback;
+}
+function installTimeoutMs() {
+    return envTimeoutMs("BROWSE_SKILLS_INSTALL_TIMEOUT_MS", defaultInstallTimeoutMs);
+}
+function fetchTimeoutSignal() {
+    return AbortSignal.timeout(envTimeoutMs("BROWSE_SKILLS_FETCH_TIMEOUT_MS", defaultFetchTimeoutMs));
+}
 export function parseSkillId(rawSkillId) {
     const parts = rawSkillId.split("/");
     if (parts.length !== 2) {
@@ -103,10 +115,14 @@ export async function installBundledCliSkill() {
 // message (including a tail of the child's output) when the child exits nonzero
 // so the failure is recorded in telemetry instead of an opaque exit code.
 async function runSkillsInstall(npxPath, args) {
-    const result = await spawnPassthrough(npxPath, args);
-    if (result.exitCode === 0) {
+    const timeoutMs = installTimeoutMs();
+    const result = await spawnPassthrough(npxPath, args, timeoutMs);
+    if (result.exitCode === 0 && !result.timedOut) {
         return;
     }
+    if (result.timedOut) {
+        fail(`Skill install timed out after ${Math.round(timeoutMs / 1000)}s waiting for \`npx skills add\`. Check your network connection and rerun \`browse skills add\`.`, 1, { resultCode: "skill_install_timeout" });
+    }
     const detail = result.output.trim();
     const reason = detail
         ? `: ${detail}`
@@ -188,9 +204,11 @@ async function fetchSkillFilesFromApi(skillId) {
     const url = skillFilesApiUrl(skillId);
     let response;
     try {
-        response = await fetch(url);
+        response = await fetch(url, { signal: fetchTimeoutSignal() });
     }
     catch {
+        // Network failures and timeouts both mean the catalog is unavailable;
+        // callers fall back (or fail cleanly) exactly as before.
         return { status: "unavailable" };
     }
     if (response.status === 404) {
@@ -219,6 +237,7 @@ async function directBlobSkillExists(skillId) {
     try {
         response = await fetch(skillBlobUrl(skillId, "SKILL.md"), {
             method: "HEAD",
+            signal: fetchTimeoutSignal(),
         });
     }
     catch {
@@ -294,7 +313,7 @@ async function fetchSkillFile(url, label) {
 async function fetchFromUrl(url, label) {
     let response;
     try {
-        response = await fetch(url);
+        response = await fetch(url, { signal: fetchTimeoutSignal() });
     }
     catch (error) {
         fail(`Could not download ${label}: ${error.message}`);
@@ -347,15 +366,43 @@ async function findExecutable(command) {
     }
     return null;
 }
+// Quotes a single token for the command line Node hands to cmd.exe when
+// `shell: true`. Node joins command+args UNQUOTED into `cmd.exe /d /s /c
+// "..."`, so an unquoted `C:\Program Files\nodejs\npx.cmd` splits at the
+// space and cmd runs `C:\Program`. Wrapping tokens that contain whitespace,
+// quotes, or cmd metacharacters in double quotes (with embedded quotes
+// doubled) keeps them intact; `/s` makes cmd strip only the outer quotes.
+export function quoteForCmdShell(token) {
+    if (token === "") {
+        return '""';
+    }
+    return /[\s"^&|<>]/.test(token) ? `"${token.replaceAll('"', '""')}"` : token;
+}
 // Like `stdio: "inherit"` for the human watching, but the child's stdout/stderr
 // are also buffered (tail only) so a nonzero exit can surface a real reason to
-// telemetry instead of a bare exit code.
-async function spawnPassthrough(command, args) {
+// telemetry instead of a bare exit code. The child is killed after `timeoutMs`
+// (SIGTERM, then SIGKILL) so a hung `npx` cannot stall the install forever.
+// Exported for tests.
+export async function spawnPassthrough(command, args, timeoutMs = installTimeoutMs()) {
+    const useWindowsShell = shouldUseWindowsShell(command);
+    const spawnCommand = useWindowsShell ? quoteForCmdShell(command) : command;
+    const spawnArgs = useWindowsShell ? args.map(quoteForCmdShell) : args;
     return await new Promise((resolvePromise) => {
-        const child = spawn(command, args, {
+        const child = spawn(spawnCommand, spawnArgs, {
             stdio: ["inherit", "pipe", "pipe"],
-            shell: shouldUseWindowsShell(command),
+            shell: useWindowsShell,
         });
+        let timedOut = false;
+        let killTimer;
+        const deadline = setTimeout(() => {
+            timedOut = true;
+            child.kill("SIGTERM");
+            killTimer = setTimeout(() => child.kill("SIGKILL"), 5_000);
+        }, timeoutMs);
+        const clearTimers = () => {
+            clearTimeout(deadline);
+            clearTimeout(killTimer);
+        };
         let captured = "";
         const capture = (chunk) => {
             captured += chunk.toString();
@@ -375,16 +422,20 @@ async function spawnPassthrough(command, args) {
         // `skill_install_failed` by runSkillsInstall instead of escaping as an
         // unclassified runtime error.
         child.on("error", (error) => {
+            clearTimers();
             const message = error instanceof Error ? error.message : String(error);
             resolvePromise({
                 exitCode: 1,
                 output: captured ? `${captured}\n${message}` : message,
+                timedOut,
             });
         });
         child.on("close", (exitCode, signal) => {
+            clearTimers();
             resolvePromise({
                 exitCode: signal ? 1 : (exitCode ?? 0),
                 output: captured,
+                timedOut,
             });
         });
     });