@promptbook/cli 0.114.0-13 → 0.114.0-14

package/src/version.ts

@@ -16,11 +16,11 @@ export const BOOK_LANGUAGE_VERSION: string_semantic_version = '2.0.0';
  * @generated
  * @see https://github.com/webgptorg/promptbook
  */
-export const PROMPTBOOK_ENGINE_VERSION: string_promptbook_version = '0.114.0-13';
+export const PROMPTBOOK_ENGINE_VERSION: string_promptbook_version = '0.114.0-14';
 
 /**
  * Represents the version string of the Promptbook engine.
- * It follows semantic versioning (e.g., `0.114.0-12`).
+ * It follows semantic versioning (e.g., `0.114.0-13`).
  *
  * @generated
  */

package/src/versions.txt

@@ -1189,3 +1189,4 @@
 0.114.0-10
 0.114.0-12
 0.114.0-13
+0.114.0-14

package/umd/index.umd.js

@@ -58,7 +58,7 @@
      * @generated
      * @see https://github.com/webgptorg/promptbook
      */
-    const PROMPTBOOK_ENGINE_VERSION = '0.114.0-13';
+    const PROMPTBOOK_ENGINE_VERSION = '0.114.0-14';
     /**
      * TODO: string_promptbook_version should be constrained to the all versions of Promptbook engine
      * Note: [💞] Ignore a discrepancy between file name and entity name
@@ -42457,6 +42457,52 @@
     // Note: [🟡] Code for CLI command [init](src/cli/cli-commands/coder/init.ts) should never be published outside of `@promptbook/cli`
     // Note: [💞] Ignore a discrepancy between file name and entity name
 
+    /**
+     * Default wait duration applied before retrying a prompt round after an error (10 minutes).
+     *
+     * @private internal constant of `ptbk coder` wait handling
+     */
+    const DEFAULT_WAIT_AFTER_ERROR_MS$1 = 10 * 60 * 1000;
+    /**
+     * Parses an optional Commander duration string and returns the resolved milliseconds.
+     *
+     * Returns `defaultMs` when the flag was not provided or was provided without a non-empty value.
+     *
+     * @private internal utility of `ptbk coder` wait handling
+     */
+    function parseOptionalWaitDuration(value, defaultMs) {
+        if (typeof value !== 'string' || value === '') {
+            return defaultMs;
+        }
+        return parseDuration(value);
+    }
+    /**
+     * Parses an optional Commander period duration string and returns the resolved milliseconds.
+     *
+     * Returns `undefined` when the flag was not provided or was provided without a non-empty value,
+     * which means the command runs only once instead of repeating itself.
+     *
+     * @throws {NotAllowed} When the duration is not a positive one, because a non-positive period
+     *                      would repeat the command without ever pausing between two rounds
+     *
+     * @private internal utility of `ptbk coder` wait handling
+     */
+    function parseOptionalPeriodDuration(optionName, value) {
+        if (typeof value !== 'string' || value === '') {
+            return undefined;
+        }
+        const periodMs = parseDuration(value);
+        if (periodMs <= 0) {
+            throw new NotAllowed(_spaceTrim.spaceTrim(`
+                Invalid value for \`${optionName}\`: \`${value}\`.
+
+                Use a **positive** duration like \`5h\`, \`30m\` or \`1h30m\`.
+            `));
+        }
+        return periodMs;
+    }
+    // Note: [💞] Ignore a discrepancy between file name and entity name
+
     /**
      * Initializes `coder ping` command for Promptbook CLI utilities
      *
@@ -42475,6 +42521,7 @@
             - Verifies that the selected harness, model, thinking level and authentication really work
             - Reports the answer of the harness, the response time and the reported usage
             - Starts the hourly/weekly quota window before you need it, so it is already refreshing when you do
+            - Optional --period keeps the quota window refreshing by pinging once per period until stopped
             - Leaves the project exactly as it was — nothing is read, written, changed or committed
             - Checks that the selected harness is installed globally and up to date unless --no-harness-update is used
             - Use --no-ui to stream the raw harness output instead of only the compact result
@@ -42482,21 +42529,34 @@
         addPromptRunnerSelectionOptions(command);
         addHarnessUpdateOption(command);
         addPromptRunnerRuntimeOptions(command);
+        command.option('--period <duration>', _spaceTrim.spaceTrim(`
+            Keep pinging once per period instead of pinging only once.
+            Accepts durations like 5h, 30m, 1h30m and repeats until it is stopped with CTRL+C.
+        `));
         command.action(handleActionErrors(async (cliOptions) => {
+            const { period: periodValue } = cliOptions;
             const runnerOptions = normalizePromptRunnerSelectionCliOptions(cliOptions, { isAgentRequired: true });
             const { isHarnessUpdateCheckEnabled } = normalizeHarnessUpdateCliOptions(cliOptions);
+            // Note: The period is validated before the harness installation check, so a mistyped duration fails fast
+            const periodMs = parseOptionalPeriodDuration('--period', periodValue);
             await $ensureHarnessInstallations([runnerOptions.agentName], isHarnessUpdateCheckEnabled);
-            // Note: Import the ping dynamically to avoid loading heavy dependencies until needed
-            const { pingCoderHarness } = await Promise.resolve().then(function () { return pingCoderHarness$1; });
-            const { printCoderPingResult } = await Promise.resolve().then(function () { return printCoderPingResult$1; });
-            const result = await pingCoderHarness({
+            const pingOptions = {
                 agentName: runnerOptions.agentName,
                 model: runnerOptions.model,
                 thinkingLevel: runnerOptions.thinkingLevel,
                 allowCredits: runnerOptions.allowCredits,
                 shouldPrintLiveOutput: runnerOptions.noUi,
-            });
-            printCoderPingResult(result);
+            };
+            // Note: Import the ping dynamically to avoid loading heavy dependencies until needed
+            if (periodMs !== undefined) {
+                const { pingCoderHarnessPeriodically } = await Promise.resolve().then(function () { return pingCoderHarnessPeriodically$1; });
+                // Note: This never returns - it keeps pinging until the user stops the process
+                await pingCoderHarnessPeriodically({ ...pingOptions, periodMs });
+                return;
+            }
+            const { pingCoderHarness } = await Promise.resolve().then(function () { return pingCoderHarness$1; });
+            const { printCoderPingResult } = await Promise.resolve().then(function () { return printCoderPingResult$1; });
+            printCoderPingResult(await pingCoderHarness(pingOptions));
         }));
     }
     // Note: [🟡] Code for CLI command [ping](src/cli/cli-commands/coder/ping.ts) should never be published outside of `@promptbook/cli`
@@ -42933,27 +42993,6 @@
         return TEST_BEFORE_MODE_VALUES.includes(value);
     }
 
-    /**
-     * Default wait duration applied before retrying a prompt round after an error (10 minutes).
-     *
-     * @private internal constant of `ptbk coder` wait handling
-     */
-    const DEFAULT_WAIT_AFTER_ERROR_MS$1 = 10 * 60 * 1000;
-    /**
-     * Parses an optional Commander duration string and returns the resolved milliseconds.
-     *
-     * Returns `defaultMs` when the flag was not provided or was provided without a non-empty value.
-     *
-     * @private internal utility of `ptbk coder` wait handling
-     */
-    function parseOptionalWaitDuration(value, defaultMs) {
-        if (typeof value !== 'string' || value === '') {
-            return defaultMs;
-        }
-        return parseDuration(value);
-    }
-    // Note: [💞] Ignore a discrepancy between file name and entity name
-
     /**
      * Initializes `coder run` command for Promptbook CLI utilities
      *
@@ -72692,6 +72731,23 @@
         findUnwrittenPrompts: findUnwrittenPrompts
     });
 
+    /**
+     * Formats one unknown error-like value into its readable message without the stack trace.
+     *
+     * Use this instead of `formatUnknownErrorDetails` whenever the text is shown to the user, for example
+     * inside a branded error, where the stack of the wrapped error would only bury the actual cause.
+     */
+    function formatUnknownErrorMessage(error) {
+        if (error instanceof Error) {
+            return error.message;
+        }
+        if (typeof error === 'string') {
+            return error;
+        }
+        const serializedError = JSON.stringify(error, null, 2);
+        return serializedError !== null && serializedError !== void 0 ? serializedError : String(error);
+    }
+
     /**
      * Builds a normalized temporary shell script path for prompt runners.
      */
@@ -72929,6 +72985,60 @@
         printCoderPingResult: printCoderPingResult
     });
 
+    /**
+     * How often the countdown to the next periodic ping is reported to the console (30 minutes).
+     *
+     * A period like `5h` is meant to be left running unattended, so the countdown is deliberately
+     * coarse — it is a sign of life, not a progress bar.
+     */
+    const CODER_PING_COUNTDOWN_UPDATE_INTERVAL_MS = 30 * 60 * 1000;
+    /**
+     * Pings the selected harness and model once per period until the process is stopped.
+     *
+     * This keeps the quota window of the harness refreshing without any real work, so the window is
+     * always open by the time you need it. The loop never ends on its own — it is stopped with `CTRL+C`
+     * or by killing the process — therefore a failing ping is reported and the next period is started
+     * instead of tearing the whole loop down.
+     */
+    async function pingCoderHarnessPeriodically(options) {
+        const { periodMs, ...pingOptions } = options;
+        console.info(colors__default["default"].gray(`🏓 Pinging every ${formatDurationMs(periodMs)} until stopped with CTRL+C`));
+        // Note: The loop is intentionally endless - only `CTRL+C` or killing the process ends it
+        for (;;) {
+            const nextPingTimeMs = Date.now() + periodMs;
+            await reportOneCoderPing(pingOptions);
+            await waitUntilNextCoderPing(nextPingTimeMs);
+        }
+    }
+    /**
+     * Sends and reports one ping of the endless loop, keeping the loop alive when the harness fails.
+     */
+    async function reportOneCoderPing(options) {
+        try {
+            printCoderPingResult(await pingCoderHarness(options));
+        }
+        catch (error) {
+            console.error(colors__default["default"].red(`🏓 Ping failed: ${formatUnknownErrorMessage(error)}`));
+        }
+    }
+    /**
+     * Waits until the wall-clock time of the next ping, reporting how much of the period is left.
+     */
+    async function waitUntilNextCoderPing(nextPingTimeMs) {
+        await waitUntilWorldTimeDeadline({
+            deadlineTimeMs: nextPingTimeMs,
+            pollIntervalMs: CODER_PING_COUNTDOWN_UPDATE_INTERVAL_MS,
+            onTick(remainingDurationMs) {
+                console.info(colors__default["default"].gray(`   Next ping in ${formatDurationMs(remainingDurationMs)}`));
+            },
+        });
+    }
+
+    var pingCoderHarnessPeriodically$1 = /*#__PURE__*/Object.freeze({
+        __proto__: null,
+        pingCoderHarnessPeriodically: pingCoderHarnessPeriodically
+    });
+
     /**
      * Default wait duration applied before retrying a failed prompt round.
      */
@@ -75762,23 +75872,6 @@
         return getPromptbookTemporaryPath(CODER_ISOLATION_WORKTREES_DIRECTORY_NAME, taskName);
     }
 
-    /**
-     * Formats one unknown error-like value into its readable message without the stack trace.
-     *
-     * Use this instead of `formatUnknownErrorDetails` whenever the text is shown to the user, for example
-     * inside a branded error, where the stack of the wrapped error would only bury the actual cause.
-     */
-    function formatUnknownErrorMessage(error) {
-        if (error instanceof Error) {
-            return error.message;
-        }
-        if (typeof error === 'string') {
-            return error;
-        }
-        const serializedError = JSON.stringify(error, null, 2);
-        return serializedError !== null && serializedError !== void 0 ? serializedError : String(error);
-    }
-
     /**
      * Git configuration key which lets Git read, write and delete files whose absolute path is longer than
      * the Windows `MAX_PATH` limit of 260 characters.