@hyperdrive.bot/paseo-cli 0.2.6

package/dist/output/with-output.d.ts

@@ -0,0 +1,41 @@
+/**
+ * Command wrapper for automatic output rendering.
+ *
+ * Wraps command handlers to automatically render results and handle errors.
+ */
+import type { Command } from "commander";
+import type { AnyCommandResult, OutputOptions } from "./types.js";
+/** Options that include output settings from global options */
+export interface CommandOptions extends Partial<OutputOptions> {
+    /** Daemon host target from --host option */
+    host?: string;
+    /** JSON output flag from --json option */
+    json?: boolean;
+    [key: string]: unknown;
+}
+/**
+ * Wrap a command handler to automatically render output.
+ *
+ * The wrapped handler should return a CommandResult. The wrapper will:
+ * 1. Call the handler
+ * 2. Render the result using the appropriate format
+ * 3. Write to stdout
+ * 4. Handle errors by rendering to stderr and exiting with code 1
+ *
+ * @example
+ * ```typescript
+ * program
+ *   .command('list')
+ *   .action(withOutput(async (options) => {
+ *     const data = await fetchData()
+ *     return { type: 'list', data, schema }
+ *   }))
+ * ```
+ */
+export declare function withOutput<T, Args extends unknown[]>(handler: (...args: [...Args, CommandOptions, Command]) => Promise<AnyCommandResult<T>>): (...args: [...Args, CommandOptions, Command]) => Promise<void>;
+/**
+ * Helper to create output options from partial input.
+ * Useful for testing or manual rendering.
+ */
+export declare function createOutputOptions(partial?: Partial<OutputOptions>): OutputOptions;
+//# sourceMappingURL=with-output.d.ts.map

package/dist/output/with-output.js

@@ -0,0 +1,87 @@
+/**
+ * Command wrapper for automatic output rendering.
+ *
+ * Wraps command handlers to automatically render results and handle errors.
+ */
+import { render, renderError, toCommandError, defaultOutputOptions } from "./render.js";
+function normalizeFormat(raw) {
+    const value = typeof raw === "string" ? raw.trim().toLowerCase() : "";
+    // Common user expectation: "cli" means "table/human"
+    if (value === "cli")
+        return "table";
+    if (value === "table" || value === "json" || value === "yaml")
+        return value;
+    const error = {
+        code: "INVALID_FORMAT",
+        message: `Unsupported output format: ${String(raw)}`,
+        details: "Supported formats: table, json, yaml",
+    };
+    throw error;
+}
+/** Extract output options from command options */
+function extractOutputOptions(options) {
+    const hasStructuredOutputSchema = typeof options.outputSchema === "string" && options.outputSchema.trim().length > 0;
+    if (hasStructuredOutputSchema) {
+        return {
+            format: "json",
+            quiet: false,
+            noHeaders: options.headers === false,
+            noColor: options.color === false,
+        };
+    }
+    return {
+        format: options.json ? "json" : normalizeFormat(options.format ?? defaultOutputOptions.format),
+        quiet: options.quiet ?? defaultOutputOptions.quiet,
+        noHeaders: options.headers === false, // Commander uses --no-headers -> headers: false
+        noColor: options.color === false, // Commander uses --no-color -> color: false
+    };
+}
+/**
+ * Wrap a command handler to automatically render output.
+ *
+ * The wrapped handler should return a CommandResult. The wrapper will:
+ * 1. Call the handler
+ * 2. Render the result using the appropriate format
+ * 3. Write to stdout
+ * 4. Handle errors by rendering to stderr and exiting with code 1
+ *
+ * @example
+ * ```typescript
+ * program
+ *   .command('list')
+ *   .action(withOutput(async (options) => {
+ *     const data = await fetchData()
+ *     return { type: 'list', data, schema }
+ *   }))
+ * ```
+ */
+export function withOutput(handler) {
+    return async (...args) => {
+        // Last two args are options and command
+        const command = args[args.length - 1];
+        // Use optsWithGlobals() to get both local and global options
+        const options = command.optsWithGlobals();
+        const outputOptions = extractOutputOptions(options);
+        try {
+            const result = await handler(...args);
+            const output = render(result, outputOptions);
+            if (output) {
+                process.stdout.write(output + "\n");
+            }
+        }
+        catch (error) {
+            const commandError = toCommandError(error);
+            const errorOutput = renderError(commandError, outputOptions);
+            process.stderr.write(errorOutput + "\n");
+            process.exit(1);
+        }
+    };
+}
+/**
+ * Helper to create output options from partial input.
+ * Useful for testing or manual rendering.
+ */
+export function createOutputOptions(partial = {}) {
+    return { ...defaultOutputOptions, ...partial };
+}
+//# sourceMappingURL=with-output.js.map

package/dist/output/yaml.d.ts

@@ -0,0 +1,11 @@
+/**
+ * YAML renderer for CLI output.
+ *
+ * Renders structured data as YAML for machine consumption and human readability.
+ */
+import type { AnyCommandResult, OutputOptions } from "./types.js";
+/** Render command result as YAML */
+export declare function renderYaml<T>(result: AnyCommandResult<T>, _options: OutputOptions): string;
+/** Render a single item as YAML document (for streaming) */
+export declare function renderYamlDoc<T>(item: T, serialize?: (data: T) => unknown): string;
+//# sourceMappingURL=yaml.d.ts.map

package/dist/output/yaml.js

@@ -0,0 +1,38 @@
+/**
+ * YAML renderer for CLI output.
+ *
+ * Renders structured data as YAML for machine consumption and human readability.
+ */
+import YAML from "yaml";
+/** Render command result as YAML */
+export function renderYaml(result, _options) {
+    const { schema } = result;
+    // Apply custom serializer if provided
+    if (schema.serialize) {
+        if (result.type === "list") {
+            // If all items serialize to the same object, return just one
+            // This handles the case where a list of key-value rows should serialize
+            // to a single structured object
+            const serialized = result.data.map((item) => schema.serialize(item));
+            if (serialized.length > 0) {
+                const first = JSON.stringify(serialized[0]);
+                const allSame = serialized.every((s) => JSON.stringify(s) === first);
+                if (allSame) {
+                    return YAML.stringify(serialized[0]);
+                }
+            }
+            return YAML.stringify(serialized);
+        }
+        else {
+            const serialized = schema.serialize(result.data);
+            return YAML.stringify(serialized);
+        }
+    }
+    return YAML.stringify(result.data);
+}
+/** Render a single item as YAML document (for streaming) */
+export function renderYamlDoc(item, serialize) {
+    const output = serialize ? serialize(item) : item;
+    return YAML.stringify(output);
+}
+//# sourceMappingURL=yaml.js.map

package/dist/run.d.ts

@@ -0,0 +1,14 @@
+export interface RunCliOptions {
+    cwd?: string;
+    nodeArgv?: [string, string];
+}
+export declare function createCliParseArgv(input: {
+    argv: string[];
+    cwd: string;
+    nodeArgv?: [string, string];
+}): string[] | {
+    kind: "open-project";
+    resolvedPath: string;
+};
+export declare function runCli(argv: string[], options?: RunCliOptions): Promise<number>;
+//# sourceMappingURL=run.d.ts.map

package/dist/run.js

@@ -0,0 +1,33 @@
+import { createCli } from "./cli.js";
+import { classifyInvocation } from "./classify.js";
+import { openDesktopWithProject } from "./commands/open.js";
+export function createCliParseArgv(input) {
+    const program = createCli();
+    const knownCommands = new Set(program.commands.map((command) => command.name()));
+    const invocation = classifyInvocation({
+        argv: input.argv,
+        knownCommands,
+        cwd: input.cwd,
+    });
+    if (invocation.kind === "open-project") {
+        return invocation;
+    }
+    const nodeArgv = input.nodeArgv ?? ["paseo", "paseo"];
+    const cliArgv = invocation.argv.length === 0 ? ["onboard"] : invocation.argv;
+    return [...nodeArgv, ...cliArgv];
+}
+export async function runCli(argv, options = {}) {
+    const parseArgv = createCliParseArgv({
+        argv,
+        cwd: options.cwd ?? process.cwd(),
+        nodeArgv: options.nodeArgv,
+    });
+    if (!Array.isArray(parseArgv)) {
+        await openDesktopWithProject(parseArgv.resolvedPath);
+        return typeof process.exitCode === "number" ? process.exitCode : 0;
+    }
+    const program = createCli();
+    await program.parseAsync(parseArgv, { from: "node" });
+    return typeof process.exitCode === "number" ? process.exitCode : 0;
+}
+//# sourceMappingURL=run.js.map

package/dist/utils/client-id.d.ts

@@ -0,0 +1,2 @@
+export declare function getOrCreateCliClientId(): Promise<string>;
+//# sourceMappingURL=client-id.d.ts.map

package/dist/utils/client-id.js

@@ -0,0 +1,37 @@
+import { mkdir, readFile, writeFile } from "node:fs/promises";
+import { randomUUID } from "node:crypto";
+import { dirname, join } from "node:path";
+import { homedir } from "node:os";
+const CLIENT_SESSION_KEY_FILE = join(process.env.PASEO_HOME ?? join(homedir(), ".paseo"), "cli-client-id");
+let cachedClientId = null;
+function normalizeClientId(value) {
+    const trimmed = value.trim();
+    return trimmed.length > 0 ? trimmed : null;
+}
+function generateClientId() {
+    return `cid_${randomUUID().replace(/-/g, "")}`;
+}
+export async function getOrCreateCliClientId() {
+    if (cachedClientId) {
+        return cachedClientId;
+    }
+    try {
+        const existing = normalizeClientId(await readFile(CLIENT_SESSION_KEY_FILE, "utf8"));
+        if (existing) {
+            cachedClientId = existing;
+            return existing;
+        }
+    }
+    catch (error) {
+        const code = error?.code;
+        if (code !== "ENOENT") {
+            throw error;
+        }
+    }
+    const nextValue = generateClientId();
+    await mkdir(dirname(CLIENT_SESSION_KEY_FILE), { recursive: true });
+    await writeFile(CLIENT_SESSION_KEY_FILE, nextValue, { mode: 0o600 });
+    cachedClientId = nextValue;
+    return nextValue;
+}
+//# sourceMappingURL=client-id.js.map

package/dist/utils/client.d.ts

@@ -0,0 +1,44 @@
+import { DaemonClient } from "@hyperdrive.bot/paseo-client/internal/daemon-client";
+export interface ConnectOptions {
+    host?: string;
+    timeout?: number;
+}
+type DaemonTarget = {
+    type: "tcp";
+    url: string;
+} | {
+    type: "ipc";
+    url: string;
+    socketPath: string;
+};
+/**
+ * Get the daemon host from environment or options
+ */
+export declare function getDaemonHost(options?: ConnectOptions): string;
+export declare function normalizeDaemonHost(raw: string): string | null;
+export declare function resolveDefaultDaemonHost(env?: NodeJS.ProcessEnv): string;
+export declare function resolveDefaultDaemonHosts(env?: NodeJS.ProcessEnv): string[];
+export declare function resolveDaemonTarget(host: string): DaemonTarget;
+export declare function resolveDaemonPassword(host: string): string | undefined;
+export declare function connectToDaemon(options?: ConnectOptions): Promise<DaemonClient>;
+/**
+ * Try to connect to the daemon, returns null if connection fails
+ */
+export declare function tryConnectToDaemon(options?: ConnectOptions): Promise<DaemonClient | null>;
+/** Minimal agent type for ID resolution */
+interface AgentLike {
+    id: string;
+    title?: string | null;
+}
+/**
+ * Resolve an agent ID from a partial ID or name.
+ * Supports:
+ * - Full ID match
+ * - Prefix match (first N characters)
+ * - Title/name match (case-insensitive)
+ *
+ * Returns the full agent ID if found, null otherwise.
+ */
+export declare function resolveAgentId(idOrName: string, agents: AgentLike[]): string | null;
+export {};
+//# sourceMappingURL=client.d.ts.map

package/dist/utils/client.js

@@ -0,0 +1,330 @@
+import { existsSync, readFileSync } from "node:fs";
+import { loadConfig, resolvePaseoHome } from "@hyperdrive.bot/paseo-server";
+import { buildDaemonWebSocketUrl, buildRelayWebSocketUrl, normalizeHostPort, parseConnectionUri, shouldUseTlsForDefaultHostedRelay, } from "@hyperdrive.bot/paseo-protocol/daemon-endpoints";
+import { parseConnectionOfferFromUrl, } from "@hyperdrive.bot/paseo-protocol/connection-offer";
+import { DaemonClient, } from "@hyperdrive.bot/paseo-client/internal/daemon-client";
+import path from "node:path";
+import { WebSocket } from "ws";
+import { getOrCreateCliClientId } from "./client-id.js";
+import { resolveCliVersion } from "../version.js";
+const DEFAULT_HOST = "localhost:6767";
+const DEFAULT_TIMEOUT = 15000;
+const PID_FILENAME = "paseo.pid";
+/**
+ * Get the daemon host from environment or options
+ */
+export function getDaemonHost(options) {
+    return resolveDaemonHostCandidates(options)[0] ?? DEFAULT_HOST;
+}
+export function normalizeDaemonHost(raw) {
+    const trimmed = raw.trim();
+    if (!trimmed) {
+        return null;
+    }
+    if (trimmed.startsWith("tcp://")) {
+        try {
+            const parsed = parseConnectionUri(trimmed);
+            const endpoint = normalizeHostPort(parsed.isIpv6 ? `[${parsed.host}]:${parsed.port}` : `${parsed.host}:${parsed.port}`);
+            const query = new URLSearchParams();
+            if (parsed.useTls) {
+                query.set("ssl", "true");
+            }
+            if (parsed.password) {
+                query.set("password", parsed.password);
+            }
+            const queryString = query.toString();
+            const suffix = queryString ? `?${queryString}` : "";
+            return `tcp://${endpoint}${suffix}`;
+        }
+        catch {
+            return null;
+        }
+    }
+    if (trimmed.startsWith("unix://") ||
+        trimmed.startsWith("pipe://") ||
+        trimmed.startsWith("\\\\.\\pipe\\")) {
+        return trimmed.startsWith("\\\\.\\pipe\\") ? `pipe://${trimmed}` : trimmed;
+    }
+    if (trimmed.startsWith("/") || trimmed.startsWith("~")) {
+        return `unix://${trimmed}`;
+    }
+    // Windows absolute paths (e.g. C:\Users\foo) are filesystem paths, not TCP or IPC targets.
+    if (/^[A-Za-z]:[/\\]/.test(trimmed)) {
+        return null;
+    }
+    if (/^\d+$/.test(trimmed)) {
+        return `127.0.0.1:${trimmed}`;
+    }
+    return trimmed.includes(":") ? trimmed : null;
+}
+export function resolveDefaultDaemonHost(env = process.env) {
+    return resolveDefaultDaemonHosts(env)[0] ?? DEFAULT_HOST;
+}
+function isIpcDaemonHost(host) {
+    return host !== null && (host.startsWith("unix://") || host.startsWith("pipe://"));
+}
+function isTcpDaemonHost(host) {
+    return host !== null && !isIpcDaemonHost(host);
+}
+function readPidSocketTarget(paseoHome) {
+    const pidPath = path.join(paseoHome, PID_FILENAME);
+    if (!existsSync(pidPath)) {
+        return null;
+    }
+    try {
+        const parsed = JSON.parse(readFileSync(pidPath, "utf-8"));
+        if (typeof parsed.listen === "string")
+            return parsed.listen;
+        if (typeof parsed.sockPath === "string")
+            return parsed.sockPath;
+        return null;
+    }
+    catch {
+        return null;
+    }
+}
+function resolveConfiguredIpcDaemonHost(env, paseoHome) {
+    const directEnvHost = normalizeDaemonHost(env.PASEO_LISTEN ?? "");
+    if (isIpcDaemonHost(directEnvHost)) {
+        return directEnvHost;
+    }
+    const pidHost = normalizeDaemonHost(readPidSocketTarget(paseoHome) ?? "");
+    if (isIpcDaemonHost(pidHost)) {
+        return pidHost;
+    }
+    const config = loadConfig(paseoHome, { env });
+    const configuredHost = normalizeDaemonHost(config.listen);
+    return isIpcDaemonHost(configuredHost) ? configuredHost : null;
+}
+function resolveConfiguredTcpDaemonHost(env, paseoHome) {
+    const configuredHost = normalizeDaemonHost(loadConfig(paseoHome, { env }).listen);
+    if (!isTcpDaemonHost(configuredHost)) {
+        return null;
+    }
+    return configuredHost === "127.0.0.1:6767" ? null : configuredHost;
+}
+export function resolveDefaultDaemonHosts(env = process.env) {
+    const paseoHome = resolvePaseoHome(env);
+    const candidates = [];
+    const configuredIpcHost = resolveConfiguredIpcDaemonHost(env, paseoHome);
+    if (configuredIpcHost) {
+        candidates.push(configuredIpcHost);
+    }
+    const configuredTcpHost = resolveConfiguredTcpDaemonHost(env, paseoHome);
+    if (configuredTcpHost) {
+        candidates.push(configuredTcpHost);
+    }
+    candidates.push(DEFAULT_HOST);
+    return Array.from(new Set(candidates));
+}
+function resolveDaemonHostCandidates(options) {
+    const explicitHost = options?.host ?? process.env.PASEO_HOST;
+    if (explicitHost) {
+        return [explicitHost];
+    }
+    return resolveDefaultDaemonHosts();
+}
+function stripIpcPrefix(trimmed) {
+    if (trimmed.startsWith("unix://"))
+        return trimmed.slice("unix://".length).trim();
+    if (trimmed.startsWith("pipe://"))
+        return trimmed.slice("pipe://".length).trim();
+    return trimmed;
+}
+export function resolveDaemonTarget(host) {
+    const trimmed = host.trim();
+    if (trimmed.startsWith("unix://") ||
+        trimmed.startsWith("pipe://") ||
+        trimmed.startsWith("\\\\.\\pipe\\")) {
+        const socketPath = stripIpcPrefix(trimmed);
+        if (!socketPath) {
+            throw new Error("Invalid IPC daemon target: missing socket path");
+        }
+        const isUnixSocket = trimmed.startsWith("unix://");
+        return {
+            type: "ipc",
+            url: isUnixSocket ? `ws+unix://${socketPath}:/ws` : "ws://localhost/ws",
+            socketPath,
+        };
+    }
+    if (trimmed.startsWith("tcp://")) {
+        const parsed = parseConnectionUri(trimmed);
+        const endpoint = normalizeHostPort(parsed.isIpv6 ? `[${parsed.host}]:${parsed.port}` : `${parsed.host}:${parsed.port}`);
+        return {
+            type: "tcp",
+            url: buildDaemonWebSocketUrl(endpoint, { useTls: parsed.useTls }),
+        };
+    }
+    return {
+        type: "tcp",
+        url: `ws://${trimmed}/ws`,
+    };
+}
+export function resolveDaemonPassword(host) {
+    const trimmed = host.trim();
+    if (trimmed.startsWith("tcp://")) {
+        const fromUri = parseConnectionUri(trimmed).password;
+        if (fromUri)
+            return fromUri;
+    }
+    const fromEnv = process.env.PASEO_PASSWORD;
+    return fromEnv && fromEnv.length > 0 ? fromEnv : undefined;
+}
+/**
+ * Create a WebSocket factory that works in Node.js
+ */
+function createNodeWebSocketFactory() {
+    return (url, options) => {
+        return new WebSocket(url, options?.protocols, {
+            headers: options?.headers,
+            ...(options?.socketPath ? { socketPath: options.socketPath } : {}),
+        });
+    };
+}
+/**
+ * Create and connect a daemon client
+ * Returns the connected client or throws if connection fails
+ */
+async function tryConnectHost(host, password, clientId, timeout, nodeWebSocketFactory) {
+    const target = resolveDaemonTarget(host);
+    const client = new DaemonClient({
+        url: target.url,
+        clientId,
+        clientType: "cli",
+        appVersion: resolveCliVersion(),
+        password,
+        connectTimeoutMs: timeout,
+        webSocketFactory: (url, config) => nodeWebSocketFactory(url, {
+            headers: config?.headers,
+            protocols: config?.protocols,
+            ...(target.type === "ipc" ? { socketPath: target.socketPath } : {}),
+        }),
+        reconnect: { enabled: false },
+    });
+    try {
+        await client.connect();
+        return { client };
+    }
+    catch (error) {
+        await client.close().catch(() => { });
+        return { error };
+    }
+}
+async function connectViaRelayOffer(offer, clientId, timeout, nodeWebSocketFactory) {
+    const url = buildRelayWebSocketUrl({
+        endpoint: offer.relay.endpoint,
+        serverId: offer.serverId,
+        role: "client",
+        useTls: offer.relay.useTls ?? shouldUseTlsForDefaultHostedRelay(offer.relay.endpoint),
+    });
+    const client = new DaemonClient({
+        url,
+        clientId,
+        clientType: "cli",
+        appVersion: resolveCliVersion(),
+        connectTimeoutMs: timeout,
+        webSocketFactory: (target, config) => nodeWebSocketFactory(target, { headers: config?.headers, protocols: config?.protocols }),
+        e2ee: { enabled: true, daemonPublicKeyB64: offer.daemonPublicKeyB64 },
+        reconnect: { enabled: false },
+    });
+    try {
+        await client.connect();
+        return client;
+    }
+    catch (error) {
+        await client.close().catch(() => { });
+        const message = error instanceof Error ? error.message : String(error);
+        const lastError = client.lastError ? ` (${client.lastError})` : "";
+        throw new Error(`Failed to connect via relay offer: ${message}${lastError}`, { cause: error });
+    }
+}
+function parseHostOfferOrNull(host) {
+    if (!host)
+        return null;
+    try {
+        return parseConnectionOfferFromUrl(host);
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        throw new Error(`Invalid pairing offer URL: ${message}`, { cause: error });
+    }
+}
+export async function connectToDaemon(options) {
+    const timeout = options?.timeout ?? DEFAULT_TIMEOUT;
+    const clientId = await getOrCreateCliClientId();
+    const nodeWebSocketFactory = createNodeWebSocketFactory();
+    const explicitHost = options?.host ?? process.env.PASEO_HOST;
+    const offer = parseHostOfferOrNull(explicitHost);
+    if (offer) {
+        return connectViaRelayOffer(offer, clientId, timeout, nodeWebSocketFactory);
+    }
+    const hosts = resolveDaemonHostCandidates(options);
+    async function tryNext(index, lastError) {
+        if (index >= hosts.length) {
+            if (lastError instanceof Error)
+                throw lastError;
+            throw new Error(`Unable to connect to Paseo daemon via ${hosts.join(", ")}`);
+        }
+        const host = hosts[index];
+        const password = resolveDaemonPassword(host);
+        const result = await tryConnectHost(host, password, clientId, timeout, nodeWebSocketFactory);
+        if ("client" in result) {
+            return result.client;
+        }
+        return tryNext(index + 1, result.error);
+    }
+    return tryNext(0, null);
+}
+/**
+ * Try to connect to the daemon, returns null if connection fails
+ */
+export async function tryConnectToDaemon(options) {
+    try {
+        return await connectToDaemon(options);
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Resolve an agent ID from a partial ID or name.
+ * Supports:
+ * - Full ID match
+ * - Prefix match (first N characters)
+ * - Title/name match (case-insensitive)
+ *
+ * Returns the full agent ID if found, null otherwise.
+ */
+export function resolveAgentId(idOrName, agents) {
+    if (!idOrName || agents.length === 0) {
+        return null;
+    }
+    const query = idOrName.toLowerCase();
+    // Try exact ID match first
+    const exactMatch = agents.find((a) => a.id === idOrName);
+    if (exactMatch) {
+        return exactMatch.id;
+    }
+    // Try ID prefix match
+    const prefixMatches = agents.filter((a) => a.id.toLowerCase().startsWith(query));
+    if (prefixMatches.length === 1 && prefixMatches[0]) {
+        return prefixMatches[0].id;
+    }
+    // Try title/name match (case-insensitive)
+    const titleMatches = agents.filter((a) => a.title?.toLowerCase() === query);
+    if (titleMatches.length === 1 && titleMatches[0]) {
+        return titleMatches[0].id;
+    }
+    // Try partial title match
+    const partialTitleMatches = agents.filter((a) => a.title?.toLowerCase().includes(query));
+    if (partialTitleMatches.length === 1 && partialTitleMatches[0]) {
+        return partialTitleMatches[0].id;
+    }
+    // If we have multiple prefix matches and no unique title match, return first prefix match
+    const firstPrefixMatch = prefixMatches[0];
+    if (firstPrefixMatch) {
+        return firstPrefixMatch.id;
+    }
+    return null;
+}
+//# sourceMappingURL=client.js.map

package/dist/utils/command-options.d.ts

@@ -0,0 +1,6 @@
+import type { Command } from "commander";
+export declare function collectMultiple(value: string, previous: string[]): string[];
+export declare function addJsonOption<T extends Command>(command: T): T;
+export declare function addDaemonHostOption<T extends Command>(command: T): T;
+export declare function addJsonAndDaemonHostOptions<T extends Command>(command: T): T;
+//# sourceMappingURL=command-options.d.ts.map

package/dist/utils/command-options.js

@@ -0,0 +1,17 @@
+const JSON_OPTION_DESCRIPTION = "Output in JSON format";
+const DAEMON_HOST_OPTION_DESCRIPTION = "Daemon host target: host:port or tcp://host:port?ssl=true&password=secret (default: local socket/pipe, then localhost:6767)";
+export function collectMultiple(value, previous) {
+    return previous.concat([value]);
+}
+export function addJsonOption(command) {
+    command.option("--json", JSON_OPTION_DESCRIPTION);
+    return command;
+}
+export function addDaemonHostOption(command) {
+    command.option("--host <host>", DAEMON_HOST_OPTION_DESCRIPTION);
+    return command;
+}
+export function addJsonAndDaemonHostOptions(command) {
+    return addDaemonHostOption(addJsonOption(command));
+}
+//# sourceMappingURL=command-options.js.map

package/dist/utils/duration.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Parse duration string to milliseconds.
+ * Supports formats like: 5m, 30s, 1h, 2h30m, 90, etc.
+ * If no unit is specified, assumes seconds.
+ */
+export declare function parseDuration(input: string): number;
+//# sourceMappingURL=duration.d.ts.map