create-openclaw-bot 5.2.0 → 5.2.2

package/node_modules/@inquirer/select/node_modules/@inquirer/core/dist/esm/lib/pagination/lines.mjs

@@ -0,0 +1,59 @@
+import { breakLines } from '../utils.mjs';
+function split(content, width) {
+    return breakLines(content, width).split('\n');
+}
+/**
+ * Rotates an array of items by an integer number of positions.
+ * @param {number} count The number of positions to rotate by
+ * @param {T[]} items The items to rotate
+ */
+function rotate(count, items) {
+    const max = items.length;
+    const offset = ((count % max) + max) % max;
+    return [...items.slice(offset), ...items.slice(0, offset)];
+}
+/**
+ * Renders a page of items as lines that fit within the given width ensuring
+ * that the number of lines is not greater than the page size, and the active
+ * item renders at the provided position, while prioritizing that as many lines
+ * of the active item get rendered as possible.
+ */
+export function lines({ items, width, renderItem, active, position: requested, pageSize, }) {
+    const layouts = items.map((item, index) => ({
+        item,
+        index,
+        isActive: index === active,
+    }));
+    const layoutsInPage = rotate(active - requested, layouts).slice(0, pageSize);
+    const renderItemAt = (index) => layoutsInPage[index] == null ? [] : split(renderItem(layoutsInPage[index]), width);
+    // Create a blank array of lines for the page
+    const pageBuffer = Array.from({ length: pageSize });
+    // Render the active item to decide the position
+    const activeItem = renderItemAt(requested).slice(0, pageSize);
+    const position = requested + activeItem.length <= pageSize ? requested : pageSize - activeItem.length;
+    // Add the lines of the active item into the page
+    pageBuffer.splice(position, activeItem.length, ...activeItem);
+    // Fill the page under the active item
+    let bufferPointer = position + activeItem.length;
+    let layoutPointer = requested + 1;
+    while (bufferPointer < pageSize && layoutPointer < layoutsInPage.length) {
+        for (const line of renderItemAt(layoutPointer)) {
+            pageBuffer[bufferPointer++] = line;
+            if (bufferPointer >= pageSize)
+                break;
+        }
+        layoutPointer++;
+    }
+    // Fill the page over the active item
+    bufferPointer = position - 1;
+    layoutPointer = requested - 1;
+    while (bufferPointer >= 0 && layoutPointer >= 0) {
+        for (const line of renderItemAt(layoutPointer).reverse()) {
+            pageBuffer[bufferPointer--] = line;
+            if (bufferPointer < 0)
+                break;
+        }
+        layoutPointer--;
+    }
+    return pageBuffer.filter((line) => typeof line === 'string');
+}

package/node_modules/@inquirer/select/node_modules/@inquirer/core/dist/esm/lib/pagination/position.mjs

@@ -0,0 +1,27 @@
+/**
+ * Creates the next position for the active item considering a finite list of
+ * items to be rendered on a page.
+ */
+export function finite({ active, pageSize, total, }) {
+    const middle = Math.floor(pageSize / 2);
+    if (total <= pageSize || active < middle)
+        return active;
+    if (active >= total - middle)
+        return active + pageSize - total;
+    return middle;
+}
+/**
+ * Creates the next position for the active item considering an infinitely
+ * looping list of items to be rendered on the page.
+ */
+export function infinite({ active, lastActive, total, pageSize, pointer, }) {
+    if (total <= pageSize)
+        return active;
+    // Move the position only when the user moves down, and when the
+    // navigation fits within a single page
+    if (lastActive < active && active - lastActive < pageSize) {
+        // Limit it to the middle of the list
+        return Math.min(Math.floor(pageSize / 2), pointer + active - lastActive);
+    }
+    return pointer;
+}

package/node_modules/@inquirer/select/node_modules/@inquirer/core/dist/esm/lib/pagination/use-pagination.mjs

@@ -0,0 +1,30 @@
+import { useRef } from '../use-ref.mjs';
+import { readlineWidth } from '../utils.mjs';
+import { lines } from './lines.mjs';
+import { finite, infinite } from './position.mjs';
+export function usePagination({ items, active, renderItem, pageSize, loop = true, }) {
+    const state = useRef({ position: 0, lastActive: 0 });
+    const position = loop
+        ? infinite({
+            active,
+            lastActive: state.current.lastActive,
+            total: items.length,
+            pageSize,
+            pointer: state.current.position,
+        })
+        : finite({
+            active,
+            total: items.length,
+            pageSize,
+        });
+    state.current.position = position;
+    state.current.lastActive = active;
+    return lines({
+        items,
+        width: readlineWidth(),
+        renderItem,
+        active,
+        position,
+        pageSize,
+    }).join('\n');
+}

package/node_modules/@inquirer/select/node_modules/@inquirer/core/dist/esm/lib/promise-polyfill.mjs

@@ -0,0 +1,14 @@
+// TODO: Remove this class once Node 22 becomes the minimum supported version.
+export class PromisePolyfill extends Promise {
+    // Available starting from Node 22
+    // https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Promise/withResolvers
+    static withResolver() {
+        let resolve;
+        let reject;
+        const promise = new Promise((res, rej) => {
+            resolve = res;
+            reject = rej;
+        });
+        return { promise, resolve: resolve, reject: reject };
+    }
+}

package/node_modules/@inquirer/select/node_modules/@inquirer/core/dist/esm/lib/screen-manager.mjs

@@ -0,0 +1,85 @@
+import stripAnsi from 'strip-ansi';
+import ansiEscapes from 'ansi-escapes';
+import { breakLines, readlineWidth } from './utils.mjs';
+const height = (content) => content.split('\n').length;
+const lastLine = (content) => content.split('\n').pop() ?? '';
+function cursorDown(n) {
+    return n > 0 ? ansiEscapes.cursorDown(n) : '';
+}
+export default class ScreenManager {
+    rl;
+    // These variables are keeping information to allow correct prompt re-rendering
+    height = 0;
+    extraLinesUnderPrompt = 0;
+    cursorPos;
+    constructor(rl) {
+        this.rl = rl;
+        this.rl = rl;
+        this.cursorPos = rl.getCursorPos();
+    }
+    write(content) {
+        this.rl.output.unmute();
+        this.rl.output.write(content);
+        this.rl.output.mute();
+    }
+    render(content, bottomContent = '') {
+        // Write message to screen and setPrompt to control backspace
+        const promptLine = lastLine(content);
+        const rawPromptLine = stripAnsi(promptLine);
+        // Remove the rl.line from our prompt. We can't rely on the content of
+        // rl.line (mainly because of the password prompt), so just rely on it's
+        // length.
+        let prompt = rawPromptLine;
+        if (this.rl.line.length > 0) {
+            prompt = prompt.slice(0, -this.rl.line.length);
+        }
+        this.rl.setPrompt(prompt);
+        // SetPrompt will change cursor position, now we can get correct value
+        this.cursorPos = this.rl.getCursorPos();
+        const width = readlineWidth();
+        content = breakLines(content, width);
+        bottomContent = breakLines(bottomContent, width);
+        // Manually insert an extra line if we're at the end of the line.
+        // This prevent the cursor from appearing at the beginning of the
+        // current line.
+        if (rawPromptLine.length % width === 0) {
+            content += '\n';
+        }
+        let output = content + (bottomContent ? '\n' + bottomContent : '');
+        /**
+         * Re-adjust the cursor at the correct position.
+         */
+        // We need to consider parts of the prompt under the cursor as part of the bottom
+        // content in order to correctly cleanup and re-render.
+        const promptLineUpDiff = Math.floor(rawPromptLine.length / width) - this.cursorPos.rows;
+        const bottomContentHeight = promptLineUpDiff + (bottomContent ? height(bottomContent) : 0);
+        // Return cursor to the input position (on top of the bottomContent)
+        if (bottomContentHeight > 0)
+            output += ansiEscapes.cursorUp(bottomContentHeight);
+        // Return cursor to the initial left offset.
+        output += ansiEscapes.cursorTo(this.cursorPos.cols);
+        /**
+         * Render and store state for future re-rendering
+         */
+        this.write(cursorDown(this.extraLinesUnderPrompt) +
+            ansiEscapes.eraseLines(this.height) +
+            output);
+        this.extraLinesUnderPrompt = bottomContentHeight;
+        this.height = height(output);
+    }
+    checkCursorPos() {
+        const cursorPos = this.rl.getCursorPos();
+        if (cursorPos.cols !== this.cursorPos.cols) {
+            this.write(ansiEscapes.cursorTo(cursorPos.cols));
+            this.cursorPos = cursorPos;
+        }
+    }
+    done({ clearContent }) {
+        this.rl.setPrompt('');
+        let output = cursorDown(this.extraLinesUnderPrompt);
+        output += clearContent ? ansiEscapes.eraseLines(this.height) : '\n';
+        output += ansiEscapes.cursorShow;
+        this.write(output);
+        this.rl.close();
+    }
+}

package/node_modules/@inquirer/select/node_modules/@inquirer/core/dist/esm/lib/theme.mjs

@@ -0,0 +1,22 @@
+import colors from 'yoctocolors-cjs';
+import figures from '@inquirer/figures';
+export const defaultTheme = {
+    prefix: {
+        idle: colors.blue('?'),
+        // TODO: use figure
+        done: colors.green(figures.tick),
+    },
+    spinner: {
+        interval: 80,
+        frames: ['⠋', '⠙', '⠹', '⠸', '⠼', '⠴', '⠦', '⠧', '⠇', '⠏'].map((frame) => colors.yellow(frame)),
+    },
+    style: {
+        answer: colors.cyan,
+        message: colors.bold,
+        error: (text) => colors.red(`> ${text}`),
+        defaultAnswer: (text) => colors.dim(`(${text})`),
+        help: colors.dim,
+        highlight: colors.cyan,
+        key: (text) => colors.cyan(colors.bold(`<${text}>`)),
+    },
+};

package/node_modules/@inquirer/select/node_modules/@inquirer/core/dist/esm/lib/use-effect.mjs

@@ -0,0 +1,11 @@
+import { withPointer, effectScheduler } from './hook-engine.mjs';
+export function useEffect(cb, depArray) {
+    withPointer((pointer) => {
+        const oldDeps = pointer.get();
+        const hasChanged = !Array.isArray(oldDeps) || depArray.some((dep, i) => !Object.is(dep, oldDeps[i]));
+        if (hasChanged) {
+            effectScheduler.queue(cb);
+        }
+        pointer.set(depArray);
+    });
+}

package/node_modules/@inquirer/select/node_modules/@inquirer/core/dist/esm/lib/use-keypress.mjs

@@ -0,0 +1,20 @@
+import { useRef } from './use-ref.mjs';
+import { useEffect } from './use-effect.mjs';
+import { withUpdates } from './hook-engine.mjs';
+export function useKeypress(userHandler) {
+    const signal = useRef(userHandler);
+    signal.current = userHandler;
+    useEffect((rl) => {
+        let ignore = false;
+        const handler = withUpdates((_input, event) => {
+            if (ignore)
+                return;
+            void signal.current(event, rl);
+        });
+        rl.input.on('keypress', handler);
+        return () => {
+            ignore = true;
+            rl.input.removeListener('keypress', handler);
+        };
+    }, []);
+}

package/node_modules/@inquirer/select/node_modules/@inquirer/core/dist/esm/lib/use-memo.mjs

@@ -0,0 +1,14 @@
+import { withPointer } from './hook-engine.mjs';
+export function useMemo(fn, dependencies) {
+    return withPointer((pointer) => {
+        const prev = pointer.get();
+        if (!prev ||
+            prev.dependencies.length !== dependencies.length ||
+            prev.dependencies.some((dep, i) => dep !== dependencies[i])) {
+            const value = fn();
+            pointer.set({ value, dependencies });
+            return value;
+        }
+        return prev.value;
+    });
+}

package/node_modules/@inquirer/select/node_modules/@inquirer/core/dist/esm/lib/use-prefix.mjs

@@ -0,0 +1,36 @@
+import { AsyncResource } from 'node:async_hooks';
+import { useState } from './use-state.mjs';
+import { useEffect } from './use-effect.mjs';
+import { makeTheme } from './make-theme.mjs';
+export function usePrefix({ status = 'idle', theme, }) {
+    const [showLoader, setShowLoader] = useState(false);
+    const [tick, setTick] = useState(0);
+    const { prefix, spinner } = makeTheme(theme);
+    useEffect(() => {
+        if (status === 'loading') {
+            let tickInterval;
+            let inc = -1;
+            // Delay displaying spinner by 300ms, to avoid flickering
+            const delayTimeout = setTimeout(AsyncResource.bind(() => {
+                setShowLoader(true);
+                tickInterval = setInterval(AsyncResource.bind(() => {
+                    inc = inc + 1;
+                    setTick(inc % spinner.frames.length);
+                }), spinner.interval);
+            }), 300);
+            return () => {
+                clearTimeout(delayTimeout);
+                clearInterval(tickInterval);
+            };
+        }
+        else {
+            setShowLoader(false);
+        }
+    }, [status]);
+    if (showLoader) {
+        return spinner.frames[tick];
+    }
+    // There's a delay before we show the loader. So we want to ignore `loading` here, and pass idle instead.
+    const iconName = status === 'loading' ? 'idle' : status;
+    return typeof prefix === 'string' ? prefix : prefix[iconName];
+}

package/node_modules/@inquirer/select/node_modules/@inquirer/core/dist/esm/lib/use-ref.mjs

@@ -0,0 +1,4 @@
+import { useState } from './use-state.mjs';
+export function useRef(val) {
+    return useState({ current: val })[0];
+}

package/node_modules/@inquirer/select/node_modules/@inquirer/core/dist/esm/lib/use-state.mjs

@@ -0,0 +1,19 @@
+import { withPointer, handleChange } from './hook-engine.mjs';
+export function useState(defaultValue) {
+    return withPointer((pointer) => {
+        const setFn = (newValue) => {
+            // Noop if the value is still the same.
+            if (pointer.get() !== newValue) {
+                pointer.set(newValue);
+                // Trigger re-render
+                handleChange();
+            }
+        };
+        if (pointer.initialized) {
+            return [pointer.get(), setFn];
+        }
+        const value = typeof defaultValue === 'function' ? defaultValue() : defaultValue;
+        pointer.set(value);
+        return [value, setFn];
+    });
+}

package/node_modules/@inquirer/select/node_modules/@inquirer/core/dist/esm/lib/utils.mjs

@@ -0,0 +1,25 @@
+import cliWidth from 'cli-width';
+import wrapAnsi from 'wrap-ansi';
+import { readline } from './hook-engine.mjs';
+/**
+ * Force line returns at specific width. This function is ANSI code friendly and it'll
+ * ignore invisible codes during width calculation.
+ * @param {string} content
+ * @param {number} width
+ * @return {string}
+ */
+export function breakLines(content, width) {
+    return content
+        .split('\n')
+        .flatMap((line) => wrapAnsi(line, width, { trim: false, hard: true })
+        .split('\n')
+        .map((str) => str.trimEnd()))
+        .join('\n');
+}
+/**
+ * Returns the width of the active readline, or 80 as default value.
+ * @returns {number}
+ */
+export function readlineWidth() {
+    return cliWidth({ defaultWidth: 80, output: readline().output });
+}

package/node_modules/@inquirer/select/node_modules/@inquirer/core/dist/esm/types/index.d.mts

@@ -0,0 +1,13 @@
+export * from './lib/key.mjs';
+export * from './lib/errors.mjs';
+export { usePrefix } from './lib/use-prefix.mjs';
+export { useState } from './lib/use-state.mjs';
+export { useEffect } from './lib/use-effect.mjs';
+export { useMemo } from './lib/use-memo.mjs';
+export { useRef } from './lib/use-ref.mjs';
+export { useKeypress } from './lib/use-keypress.mjs';
+export { makeTheme } from './lib/make-theme.mjs';
+export type { Theme, Status } from './lib/theme.mjs';
+export { usePagination } from './lib/pagination/use-pagination.mjs';
+export { createPrompt } from './lib/create-prompt.mjs';
+export { Separator } from './lib/Separator.mjs';

package/node_modules/@inquirer/select/node_modules/@inquirer/core/dist/esm/types/lib/Separator.d.mts

@@ -0,0 +1,10 @@
+/**
+ * Separator object
+ * Used to space/separate choices group
+ */
+export declare class Separator {
+    readonly separator: string;
+    readonly type = "separator";
+    constructor(separator?: string);
+    static isSeparator(choice: unknown): choice is Separator;
+}

package/node_modules/@inquirer/select/node_modules/@inquirer/core/dist/esm/types/lib/create-prompt.d.mts

@@ -0,0 +1,4 @@
+import { type Prompt, type Prettify } from '@inquirer/type';
+type ViewFunction<Value, Config> = (config: Prettify<Config>, done: (value: Value) => void) => string | [string, string | undefined];
+export declare function createPrompt<Value, Config>(view: ViewFunction<Value, Config>): Prompt<Value, Config>;
+export {};

package/node_modules/@inquirer/select/node_modules/@inquirer/core/dist/esm/types/lib/errors.d.mts

@@ -0,0 +1,20 @@
+export declare class AbortPromptError extends Error {
+    name: string;
+    message: string;
+    constructor(options?: {
+        cause?: unknown;
+    });
+}
+export declare class CancelPromptError extends Error {
+    name: string;
+    message: string;
+}
+export declare class ExitPromptError extends Error {
+    name: string;
+}
+export declare class HookError extends Error {
+    name: string;
+}
+export declare class ValidationError extends Error {
+    name: string;
+}

package/node_modules/@inquirer/select/node_modules/@inquirer/core/dist/esm/types/lib/hook-engine.d.mts

@@ -0,0 +1,23 @@
+import type { InquirerReadline } from '@inquirer/type';
+export declare function withHooks<T>(rl: InquirerReadline, cb: (cycle: (render: () => void) => void) => T): T;
+export declare function readline(): InquirerReadline;
+export declare function withUpdates<R, T extends (...args: any[]) => R>(fn: T): (...args: Parameters<T>) => R;
+type SetPointer<Value> = {
+    get(): Value;
+    set(value: Value): void;
+    initialized: true;
+};
+type UnsetPointer<Value> = {
+    get(): void;
+    set(value: Value): void;
+    initialized: false;
+};
+type Pointer<Value> = SetPointer<Value> | UnsetPointer<Value>;
+export declare function withPointer<Value, ReturnValue>(cb: (pointer: Pointer<Value>) => ReturnValue): ReturnValue;
+export declare function handleChange(): void;
+export declare const effectScheduler: {
+    queue(cb: (readline: InquirerReadline) => void): void;
+    run(): void;
+    clearAll(): void;
+};
+export {};

package/node_modules/@inquirer/select/node_modules/@inquirer/core/dist/esm/types/lib/key.d.mts

@@ -0,0 +1,10 @@
+export type KeypressEvent = {
+    name: string;
+    ctrl: boolean;
+};
+export declare const isUpKey: (key: KeypressEvent) => boolean;
+export declare const isDownKey: (key: KeypressEvent) => boolean;
+export declare const isSpaceKey: (key: KeypressEvent) => boolean;
+export declare const isBackspaceKey: (key: KeypressEvent) => boolean;
+export declare const isNumberKey: (key: KeypressEvent) => boolean;
+export declare const isEnterKey: (key: KeypressEvent) => boolean;

package/node_modules/@inquirer/select/node_modules/@inquirer/core/dist/esm/types/lib/make-theme.d.mts

@@ -0,0 +1,3 @@
+import type { Prettify, PartialDeep } from '@inquirer/type';
+import { type Theme } from './theme.mjs';
+export declare function makeTheme<SpecificTheme extends object>(...themes: ReadonlyArray<undefined | PartialDeep<Theme<SpecificTheme>>>): Prettify<Theme<SpecificTheme>>;

package/node_modules/@inquirer/select/node_modules/@inquirer/core/dist/esm/types/lib/pagination/lines.d.mts

@@ -0,0 +1,26 @@
+import { type Prettify } from '@inquirer/type';
+/** Represents an item that's part of a layout, about to be rendered */
+export type Layout<T> = {
+    item: T;
+    index: number;
+    isActive: boolean;
+};
+/**
+ * Renders a page of items as lines that fit within the given width ensuring
+ * that the number of lines is not greater than the page size, and the active
+ * item renders at the provided position, while prioritizing that as many lines
+ * of the active item get rendered as possible.
+ */
+export declare function lines<T>({ items, width, renderItem, active, position: requested, pageSize, }: {
+    items: ReadonlyArray<T>;
+    /** The width of a rendered line in characters. */
+    width: number;
+    /** Renders an item as part of a page. */
+    renderItem: (layout: Prettify<Layout<T>>) => string;
+    /** The index of the active item in the list of items. */
+    active: number;
+    /** The position on the page at which to render the active item. */
+    position: number;
+    /** The number of lines to render per page. */
+    pageSize: number;
+}): string[];

package/node_modules/@inquirer/select/node_modules/@inquirer/core/dist/esm/types/lib/pagination/position.d.mts

@@ -0,0 +1,20 @@
+/**
+ * Creates the next position for the active item considering a finite list of
+ * items to be rendered on a page.
+ */
+export declare function finite({ active, pageSize, total, }: {
+    active: number;
+    pageSize: number;
+    total: number;
+}): number;
+/**
+ * Creates the next position for the active item considering an infinitely
+ * looping list of items to be rendered on the page.
+ */
+export declare function infinite({ active, lastActive, total, pageSize, pointer, }: {
+    active: number;
+    lastActive: number;
+    total: number;
+    pageSize: number;
+    pointer: number;
+}): number;

package/node_modules/@inquirer/select/node_modules/@inquirer/core/dist/esm/types/lib/pagination/use-pagination.d.mts

@@ -0,0 +1,15 @@
+import type { Prettify } from '@inquirer/type';
+import { type Theme } from '../theme.mjs';
+import { type Layout } from './lines.mjs';
+export declare function usePagination<T>({ items, active, renderItem, pageSize, loop, }: {
+    items: ReadonlyArray<T>;
+    /** The index of the active item. */
+    active: number;
+    /** Renders an item as part of a page. */
+    renderItem: (layout: Prettify<Layout<T>>) => string;
+    /** The size of the page. */
+    pageSize: number;
+    /** Allows creating an infinitely looping list. `true` if unspecified. */
+    loop?: boolean;
+    theme?: Theme;
+}): string;

package/node_modules/@inquirer/select/node_modules/@inquirer/core/dist/esm/types/lib/promise-polyfill.d.mts

@@ -0,0 +1,7 @@
+export declare class PromisePolyfill<T> extends Promise<T> {
+    static withResolver<T>(): {
+        promise: Promise<T>;
+        resolve: (value: T) => void;
+        reject: (error: unknown) => void;
+    };
+}

package/node_modules/@inquirer/select/node_modules/@inquirer/core/dist/esm/types/lib/screen-manager.d.mts

@@ -0,0 +1,14 @@
+import type { InquirerReadline } from '@inquirer/type';
+export default class ScreenManager {
+    private readonly rl;
+    private height;
+    private extraLinesUnderPrompt;
+    private cursorPos;
+    constructor(rl: InquirerReadline);
+    write(content: string): void;
+    render(content: string, bottomContent?: string): void;
+    checkCursorPos(): void;
+    done({ clearContent }: {
+        clearContent: boolean;
+    }): void;
+}