@tiny-fish/cli 0.21.1-next.195 → 0.21.1-next.196

package/README.md

@@ -80,6 +80,9 @@ Brings both halves of an install current: the global `@tiny-fish/cli` package an
 `use-tinyfish` skill. Use this rather than remembering `npm i -g @tiny-fish/cli@latest` and
 `skills update -g` separately.
 
+Successful steps are summarised in one line each. Add `--verbose` to see the full npm and skills
+output; a failing step prints its output either way.
+
 The skill step refreshes only the TinyFish skill, and only for the agents you ran
 `tinyfish connect` against. Other global skills, and agents you never connected, are left alone.
 The refresh overwrites your copy of the skill, including any local edits to it. Restart your

package/dist/commands/connect.js

@@ -144,7 +144,8 @@ function connectedLine(client, signInDeferred) {
 function runPostInstallSteps(client, options, state, telemetry, signInDeferred) {
     try {
         state.stage = "cli_install";
-        installTinyFishCli();
+        // Verbose on purpose: first-run setup must not go silent.
+        installTinyFishCli({ verbose: true });
         telemetry.track("checkpoint", { phase: "cli_installed" });
         state.stage = "skill_install";
         installWebSkill(client);
@@ -207,7 +208,7 @@ export async function connectOpenClaw(options) {
         telemetry.track("checkpoint", { phase: "prerequisite_ok" });
         if (options.installCli !== false) {
             state.stage = "cli_install";
-            installTinyFishCli();
+            installTinyFishCli({ verbose: true });
             telemetry.track("checkpoint", { phase: "cli_installed" });
         }
         state.stage = "skill_install";

package/dist/commands/upgrade.d.ts

@@ -1,6 +1,6 @@
 import { Command } from "commander";
 /** Returns the version now installed, so the caller reports exactly what the user was told. */
-export declare function runUpgrade(): string | null;
+export declare function runUpgrade(verbose?: boolean): string | null;
 /** `runUpgrade` plus its outcome telemetry, which must never change what the upgrade does. */
-export declare function runUpgradeCommand(): Promise<void>;
+export declare function runUpgradeCommand(verbose?: boolean): Promise<void>;
 export declare function registerUpgrade(program: Command): void;

package/dist/commands/upgrade.js

@@ -26,13 +26,16 @@ function attempt(label, run) {
     }
 }
 /** Returns the version now installed, so the caller reports exactly what the user was told. */
-export function runUpgrade() {
+export function runUpgrade(verbose = false) {
     errLine("Upgrading TinyFish...");
+    let refreshed = false;
     try {
         // Both steps always run: neither artifact should stay stale because the other failed.
         const failures = [
-            attempt("update the TinyFish CLI", installTinyFishCli),
-            attempt("refresh the TinyFish web skill", updateWebSkill),
+            attempt("update the TinyFish CLI", () => installTinyFishCli({ verbose })),
+            attempt("refresh the TinyFish web skill", () => {
+                refreshed = updateWebSkill({ verbose });
+            }),
         ].filter((failure) => failure !== undefined);
         if (failures.length > 0)
             throw new Error(`tinyfish upgrade failed: ${failures.join("; ")}`);
@@ -45,9 +48,9 @@ export function runUpgrade() {
         return null;
     }
     const version = installedCliVersion();
-    errLine(version
-        ? `TinyFish CLI ${version} is up to date. Restart your agent to pick up the refreshed skill.`
-        : "TinyFish is up to date. Restart your agent to pick up the refreshed skill.");
+    const upToDate = version ? `TinyFish CLI ${version} is up to date.` : "TinyFish is up to date.";
+    // Only a rewritten skill needs an agent restart.
+    errLine(refreshed ? `${upToDate} Restart your agent to pick up the refreshed skill.` : upToDate);
     return version;
 }
 /** The version now on disk. Only the upgrade's own npm call knows what "latest" resolved to. */
@@ -67,7 +70,7 @@ function globalCliVersion() {
     }
 }
 /** `runUpgrade` plus its outcome telemetry, which must never change what the upgrade does. */
-export async function runUpgradeCommand() {
+export async function runUpgradeCommand(verbose = false) {
     // This command is the upgrade, so a trailing "an update is available" would be noise.
     suppressNotice();
     let reported = false;
@@ -90,7 +93,7 @@ export async function runUpgradeCommand() {
     });
     let outcome = "updated";
     try {
-        printedVersion = runUpgrade();
+        printedVersion = runUpgrade(verbose);
         if (process.exitCode === SIGNAL_EXIT_CODES.SIGINT)
             outcome = "interrupted";
     }
@@ -108,7 +111,8 @@ export function registerUpgrade(program) {
     program
         .command("upgrade")
         .description("Update the TinyFish CLI and the use-tinyfish skill to the latest versions")
-        .action(async () => {
-        await runUpgradeCommand();
+        .option("--verbose", "Print the full npm and skills output instead of only on failure")
+        .action(async (options) => {
+        await runUpgradeCommand(Boolean(options.verbose));
     });
 }

package/dist/lib/connect-install.d.ts

@@ -3,7 +3,11 @@ import { type AgentClient } from "./connect-runtime.js";
 export declare const SKILL_INSTALL_TIMEOUT_MS = 120000;
 export declare const TINYFISH_CLI_NOT_FOUND_MESSAGE = "TinyFish CLI installed but is not available on PATH. Open a new terminal and retry.";
 export declare const UPGRADE_HINT = "Run `tinyfish upgrade` any time to update the CLI and skill.";
-export declare function installTinyFishCli(): void;
+/** Quiet captures subprocess output and replays it only on failure. */
+export type InstallOptions = {
+    verbose: boolean;
+};
+export declare function installTinyFishCli({ verbose }: InstallOptions): void;
 export declare function installWebSkill(client: NativeMcpClient): void;
 /**
  * Refresh the skill we installed, for the harnesses we installed it in.
@@ -12,6 +16,8 @@ export declare function installWebSkill(client: NativeMcpClient): void;
  * only in prose, it repairs a copy whose lock entry lost its hash, and it cannot spread the
  * skill to agents the user never connected (`update` re-adds with no --agent, which targets
  * every agent on the machine).
+ *
+ * Returns whether a skill was actually rewritten.
  */
-export declare function updateWebSkill(): void;
+export declare function updateWebSkill({ verbose }: InstallOptions): boolean;
 export declare function ensureCliAuthenticated(source: AgentClient, apiKey?: string): void;

package/dist/lib/connect-install.js

@@ -14,17 +14,37 @@ export const UPGRADE_HINT = "Run `tinyfish upgrade` any time to update the CLI a
 const SKILLS_CLI_PACKAGE = "skills@1.5.15";
 const TINYFISH_WEB_SKILL_SOURCE = "tinyfish-io/tinyfish-cookbook";
 const TINYFISH_WEB_SKILL = "use-tinyfish";
-export function installTinyFishCli() {
-    errLine("Installing the TinyFish CLI...");
+// spawnSync caps piped output at 1 MiB by default.
+const STEP_MAX_BUFFER = 10 * 1024 * 1024;
+function captureStdio(verbose) {
+    return verbose
+        ? { stdio: "inherit", timeout: SKILL_INSTALL_TIMEOUT_MS }
+        : { encoding: "utf8", maxBuffer: STEP_MAX_BUFFER, timeout: SKILL_INSTALL_TIMEOUT_MS };
+}
+/** Inherited stdio leaves these null; only piped runs yield text. */
+function capturedOutput(result) {
+    return `${asText(result.stdout)}${asText(result.stderr)}`;
+}
+function asText(stream) {
+    return typeof stream === "string" ? stream : "";
+}
+/** A verbose run captured nothing, so this is a no-op. */
+function replay(output) {
+    if (output.trim())
+        errLine(output.trimEnd());
+}
+export function installTinyFishCli({ verbose }) {
+    if (verbose)
+        errLine("Installing the TinyFish CLI...");
     // Without the prefix, a curl install upgrades npm's global tree and never the PATH binary.
     const root = installRoot();
     const prefixArgs = root ? ["--prefix", root.prefix] : [];
-    const result = spawn.sync("npm", ["install", "--global", ...prefixArgs, TINYFISH_CLI_INSTALL_SPEC], {
-        stdio: "inherit",
-        timeout: SKILL_INSTALL_TIMEOUT_MS,
-    });
+    const result = spawn.sync("npm", ["install", "--global", ...prefixArgs, TINYFISH_CLI_INSTALL_SPEC], captureStdio(verbose));
     if (result.error || result.status !== 0) {
-        throw spawnStepError("Could not install the TinyFish CLI", result);
+        // Built first: it runs the interrupt check, and abandonment must not replay.
+        const error = spawnStepError("Could not install the TinyFish CLI", result);
+        replay(capturedOutput(result));
+        throw error;
     }
 }
 /** `skills add` is an unconditional overwrite, so it doubles as the refresh path. */
@@ -53,6 +73,8 @@ function skillSpawnEnv() {
 // Safe to match on because SKILLS_CLI_PACKAGE is pinned.
 const SKILL_UPDATE_FAILURE_PATTERN = /Failed to (?:update|check|fetch)/;
 const SKILL_NOT_INSTALLED_PATTERN = /No installed skills found matching/;
+// Nothing was rewritten, so nothing needs an agent restart.
+const SKILL_ALREADY_CURRENT_PATTERN = /All global skills are up to date/;
 // A lock entry with no recorded hash is untrackable, so `skills` reports it as skipped rather
 // than failed. Left undetected that reads as "up to date" while nothing was refreshed.
 const SKILL_UNCHECKABLE_PATTERN = /cannot be checked automatically/;
@@ -65,6 +87,7 @@ export function installWebSkill(client) {
     const result = spawn.sync("npx", skillAddArgs([client.skillAgent]), {
         encoding: "utf8",
         env: skillSpawnEnv(),
+        maxBuffer: STEP_MAX_BUFFER,
         timeout: SKILL_INSTALL_TIMEOUT_MS,
     });
     const output = `${result.stdout ?? ""}${result.stderr ?? ""}`;
@@ -81,8 +104,10 @@ export function installWebSkill(client) {
  * only in prose, it repairs a copy whose lock entry lost its hash, and it cannot spread the
  * skill to agents the user never connected (`update` re-adds with no --agent, which targets
  * every agent on the machine).
+ *
+ * Returns whether a skill was actually rewritten.
  */
-export function updateWebSkill() {
+export function updateWebSkill({ verbose }) {
     // One entry per `tinyfish connect <client>`, persisted by PF-3169.
     const connected = loadConfig().connect ?? {};
     const skillAgents = NATIVE_MCP_CLIENTS
@@ -90,71 +115,82 @@ export function updateWebSkill() {
         .map((client) => client.skillAgent);
     const hasOpenClaw = Boolean(connected["openclaw"]);
     // Installs predating PF-3169 recorded nothing; ask `skills` to refresh what it tracks.
-    if (skillAgents.length === 0 && !hasOpenClaw) {
-        refreshWebSkillByHash();
-        return;
+    if (skillAgents.length === 0 && !hasOpenClaw)
+        return refreshWebSkillByHash(verbose);
+    let refreshed = false;
+    if (skillAgents.length > 0) {
+        reinstallWebSkill(skillAgents, verbose);
+        refreshed = true;
     }
-    if (skillAgents.length > 0)
-        reinstallWebSkill(skillAgents);
     // OpenClaw keeps its skill under its own CLI, so it needs its own refresh.
     if (hasOpenClaw)
-        reinstallOpenClawSkill();
+        refreshed = reinstallOpenClawSkill(verbose) || refreshed;
+    return refreshed;
 }
-function reinstallOpenClawSkill() {
-    errLine("Refreshing the TinyFish skill in OpenClaw...");
-    const result = spawn.sync("openclaw", OPENCLAW_SKILL_INSTALL_ARGS, {
-        stdio: "inherit",
-        timeout: SKILL_INSTALL_TIMEOUT_MS,
-    });
+function reinstallOpenClawSkill(verbose) {
+    if (verbose)
+        errLine("Refreshing the TinyFish skill in OpenClaw...");
+    const result = spawn.sync("openclaw", OPENCLAW_SKILL_INSTALL_ARGS, captureStdio(verbose));
     // OpenClaw may have been removed since connect; a stale context entry must not fail an
     // upgrade that otherwise succeeded.
     if (commandNotFound(result.error)) {
         errLine("OpenClaw is not on PATH, so its TinyFish skill was left unchanged.");
-        return;
+        return false;
     }
     if (result.error || result.status !== 0) {
         throwIfInterrupted(result);
+        replay(capturedOutput(result));
         throw new Error("Could not refresh the TinyFish skill in OpenClaw", { cause: result.error });
     }
+    return true;
 }
-function reinstallWebSkill(skillAgents) {
-    errLine(`Refreshing the TinyFish web skill for ${skillAgents.join(", ")}...`);
+function reinstallWebSkill(skillAgents, verbose) {
+    if (verbose)
+        errLine(`Refreshing the TinyFish web skill for ${skillAgents.join(", ")}...`);
     const result = spawn.sync("npx", skillAddArgs(skillAgents), {
         encoding: "utf8",
         env: skillSpawnEnv(),
+        maxBuffer: STEP_MAX_BUFFER,
         timeout: SKILL_INSTALL_TIMEOUT_MS,
     });
-    const output = `${result.stdout ?? ""}${result.stderr ?? ""}`;
-    if (output.trim())
-        errLine(output.trimEnd());
-    if (result.error || result.status !== 0 || SKILL_INSTALL_FAILURE_PATTERN.test(output)) {
+    const output = capturedOutput(result);
+    const failed = Boolean(result.error) || result.status !== 0 || SKILL_INSTALL_FAILURE_PATTERN.test(output);
+    if (failed)
         throwIfInterrupted(result);
+    if (verbose || failed)
+        replay(output);
+    if (failed)
         throw new Error("Could not refresh the TinyFish web skill", { cause: result.error });
-    }
 }
 /** Fallback when no harness is recorded: ask `skills` to refresh whatever it tracks. */
-function refreshWebSkillByHash() {
-    errLine("Refreshing the TinyFish web skill...");
+function refreshWebSkillByHash(verbose) {
+    if (verbose)
+        errLine("Refreshing the TinyFish web skill...");
     const result = spawn.sync("npx", ["-y", SKILLS_CLI_PACKAGE, "update", TINYFISH_WEB_SKILL, "--global", "--yes"], {
         encoding: "utf8",
         env: skillSpawnEnv(),
+        maxBuffer: STEP_MAX_BUFFER,
         timeout: SKILL_INSTALL_TIMEOUT_MS,
     });
-    // Piped rather than inherited so the output can be inspected; echoed back for the user.
-    const output = `${result.stdout ?? ""}${result.stderr ?? ""}`;
-    if (output.trim())
-        errLine(output.trimEnd());
-    if (result.error || result.status !== 0 || SKILL_UPDATE_FAILURE_PATTERN.test(output)) {
+    // Piped so prose-only failures can be matched; skills exits 0 anyway.
+    const output = capturedOutput(result);
+    const unchecked = SKILL_UNCHECKABLE_PATTERN.test(output);
+    const failed = Boolean(result.error) || result.status !== 0 || SKILL_UPDATE_FAILURE_PATTERN.test(output);
+    if (failed)
         throwIfInterrupted(result);
+    if (verbose || failed || unchecked)
+        replay(output);
+    if (failed)
         throw new Error("Could not refresh the TinyFish web skill", { cause: result.error });
-    }
-    if (SKILL_UNCHECKABLE_PATTERN.test(output)) {
+    if (unchecked) {
         errLine("Run `tinyfish connect <client>` to reinstall the skill and restore update tracking.");
         throw new Error("The TinyFish web skill cannot be checked for updates");
     }
     if (SKILL_NOT_INSTALLED_PATTERN.test(output)) {
         errLine("No use-tinyfish skill installed. Run `tinyfish connect <client>` to add it.");
+        return false;
     }
+    return !SKILL_ALREADY_CURRENT_PATTERN.test(output);
 }
 export function ensureCliAuthenticated(source, apiKey) {
     const envKey = apiKey ?? process.env["TINYFISH_API_KEY"];

package/dist/lib/connect-runtime.js

@@ -33,10 +33,13 @@ export class ConnectStepError extends Error {
 }
 class PrerequisiteError extends ConnectStepError {
 }
+// A maxBuffer overflow is also killed with SIGTERM, and is a failure too.
+const NOT_INTERRUPTIONS = new Set(["ETIMEDOUT", "ENOBUFS"]);
 export function throwIfInterrupted(result) {
     // spawn.sync kills a timed-out child with SIGTERM, so signal alone would misread a slow
     // network as the user walking away. A timeout is a failure and must report as one.
-    if (result.error?.code === "ETIMEDOUT")
+    const code = result.error?.code;
+    if (code && NOT_INTERRUPTIONS.has(code))
         return;
     if (result.signal === "SIGINT" || result.signal === "SIGTERM") {
         throw new ConnectInterruptedError("Setup interrupted");

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tiny-fish/cli",
-  "version": "0.21.1-next.195",
+  "version": "0.21.1-next.196",
   "description": "TinyFish CLI — run web automations from your terminal",
   "type": "module",
   "bin": {