@techdigger/humanode-agentlink-cli 0.2.0

package/dist/commands/link.js

@@ -0,0 +1,82 @@
+import { buildEmbeddedHostedLinkUrl, createAgentLinkConsent, createLinkSession, } from '@techdigger/humanode-agentlink';
+import { CliError, NETWORKS, assertNoExtraPositionals, defaultDeadline, formatJson, parseFlags, parseFutureDeadline, parseRequiredAddress, resolveLinkerUrl, resolveNetwork, resolvePrivateKey, resolveRegistryAddress, resolveRpcUrl, openUrlInBrowser, } from '../lib/core.js';
+export function parseLinkOptions(argv, env, now, overrides = {}) {
+    const parsed = parseFlags(argv);
+    assertNoExtraPositionals('link', parsed.positionals);
+    return {
+        owner: parseRequiredAddress('owner', parsed.values.owner),
+        registry: resolveRegistryAddress(parsed.values.registry, env),
+        network: resolveNetwork(parsed.values.network, env),
+        deadline: parsed.values.deadline ? parseFutureDeadline(parsed.values.deadline, now) : defaultDeadline(now),
+        privateKey: resolvePrivateKey(parsed.values['private-key'], env, overrides.privateKey),
+        rpcUrl: resolveRpcUrl(parsed.values['rpc-url'], env),
+        linkerUrl: resolveLinkerUrl(parsed.values['linker-url'], env),
+        open: parsed.flags.has('open'),
+        json: parsed.flags.has('json'),
+    };
+}
+export async function runLink(options, deps = {}) {
+    const now = deps.now ?? new Date();
+    const createConsent = deps.createAgentLinkConsent ?? createAgentLinkConsent;
+    const createSession = deps.createLinkSession ?? createLinkSession;
+    const buildUrl = deps.buildLinkUrl ?? buildEmbeddedHostedLinkUrl;
+    const openUrl = deps.openUrl ?? openUrlInBrowser;
+    try {
+        const consent = await createConsent({
+            owner: options.owner,
+            registry: options.registry,
+            deadline: options.deadline,
+            network: options.network,
+            privateKey: options.privateKey,
+            rpcUrl: options.rpcUrl,
+        });
+        const session = await createSession({
+            platformAccountId: 'local-cli',
+            network: options.network,
+            registry: options.registry,
+            consent,
+            expiresAt: new Date(Number(options.deadline) * 1000).toISOString(),
+        }, { now });
+        const linkerUrl = buildUrl(options.linkerUrl, session);
+        let opened = false;
+        if (options.open) {
+            await openUrl(linkerUrl);
+            opened = true;
+        }
+        return {
+            agent: consent.agent,
+            owner: options.owner,
+            network: options.network,
+            registry: options.registry,
+            deadline: options.deadline.toString(),
+            linkerUrl,
+            opened,
+            consent,
+            session,
+        };
+    }
+    catch (error) {
+        throw new CliError(error instanceof Error ? error.message : String(error));
+    }
+}
+export function formatLinkOutput(result, json = false) {
+    if (json) {
+        return formatJson(result);
+    }
+    const lines = [
+        `Agent:      ${result.agent}`,
+        `Owner:      ${result.owner}`,
+        `Network:    ${NETWORKS[result.network].label}`,
+        `Registry:   ${result.registry}`,
+        `Deadline:   ${result.deadline}`,
+        '',
+        'Open this linker URL and connect the owner wallet to finish the on-chain link:',
+        result.linkerUrl,
+        '',
+        'The CLI does not submit linkAgent(...) itself. The owner still completes the transaction in the linker UI.',
+    ];
+    if (result.opened) {
+        lines.push('', 'The CLI asked your OS to open the linker in your default browser.');
+    }
+    return lines.join('\n');
+}

package/dist/commands/status.d.ts

@@ -0,0 +1,30 @@
+import type { Address } from 'viem';
+import { createBiomapperQueryClient } from '@techdigger/humanode-agentlink';
+import { type EnvSource, type NetworkName } from '../lib/core.js';
+export interface StatusOptions {
+    registry: Address;
+    agent: Address;
+    network: NetworkName;
+    rpcUrl?: string;
+    json: boolean;
+}
+export interface StatusOptionOverrides {
+    privateKey?: string;
+}
+export interface StatusResult {
+    agent: Address;
+    network: NetworkName;
+    registry: Address;
+    linked: boolean;
+    active: boolean;
+    owner: Address | null;
+    generationPtr: string | null;
+    message: string;
+    biomapperAppUrl: string;
+}
+export interface StatusDeps {
+    createBiomapperQueryClient: typeof createBiomapperQueryClient;
+}
+export declare function parseStatusOptions(argv: string[], env: EnvSource, overrides?: StatusOptionOverrides): StatusOptions;
+export declare function runStatus(options: StatusOptions, deps?: Partial<StatusDeps>): Promise<StatusResult>;
+export declare function formatStatusOutput(result: StatusResult, json?: boolean): string;

package/dist/commands/status.js

@@ -0,0 +1,68 @@
+import { createBiomapperQueryClient } from '@techdigger/humanode-agentlink';
+import { CliError, NETWORKS, assertNoExtraPositionals, deriveAgentAddress, formatJson, parseFlags, resolveAgentAddress, resolveNetwork, resolvePrivateKey, resolveRegistryAddress, resolveRpcUrl, } from '../lib/core.js';
+export function parseStatusOptions(argv, env, overrides = {}) {
+    const parsed = parseFlags(argv);
+    assertNoExtraPositionals('status', parsed.positionals);
+    let agent;
+    if (parsed.values.agent) {
+        agent = resolveAgentAddress(parsed.values.agent, undefined, env);
+    }
+    else {
+        const privateKey = resolvePrivateKey(parsed.values['private-key'], env, overrides.privateKey);
+        agent = deriveAgentAddress(privateKey);
+    }
+    return {
+        registry: resolveRegistryAddress(parsed.values.registry, env),
+        agent,
+        network: resolveNetwork(parsed.values.network, env),
+        rpcUrl: resolveRpcUrl(parsed.values['rpc-url'], env),
+        json: parsed.flags.has('json'),
+    };
+}
+export async function runStatus(options, deps = {}) {
+    const createQueryClient = deps.createBiomapperQueryClient ?? createBiomapperQueryClient;
+    try {
+        const queryClient = createQueryClient({
+            network: options.network,
+            registryAddress: options.registry,
+            rpcUrl: options.rpcUrl,
+        });
+        const result = await queryClient.checkAgentStatus({
+            agentAddress: options.agent,
+        });
+        return {
+            agent: options.agent,
+            network: options.network,
+            registry: options.registry,
+            linked: result.linked,
+            active: result.active,
+            owner: result.owner,
+            generationPtr: result.generationPtr,
+            message: result.message,
+            biomapperAppUrl: NETWORKS[options.network].biomapperAppUrl,
+        };
+    }
+    catch (error) {
+        throw new CliError(error instanceof Error ? error.message : String(error));
+    }
+}
+export function formatStatusOutput(result, json = false) {
+    if (json) {
+        return formatJson(result);
+    }
+    const lines = [
+        `Agent:      ${result.agent}`,
+        `Network:    ${NETWORKS[result.network].label}`,
+        `Registry:   ${result.registry}`,
+        '',
+    ];
+    if (!result.linked) {
+        lines.push('Status:     Not linked', '', 'This agent is not linked to any owner.', 'Run "agentlink link --owner 0xOwner --open" to generate a linker URL.');
+        return lines.join('\n');
+    }
+    lines.push(`Status:     ${result.active ? 'Active' : 'Inactive'}`, `Owner:      ${result.owner}`, `Generation: ${result.generationPtr ?? 'n/a'}`);
+    if (!result.active) {
+        lines.push('', 'This link is still stored, but the linked owner wallet is not biomapped in the current generation.', `If that same wallet becomes biomapped again at ${result.biomapperAppUrl}, the link becomes active again automatically.`, 'Then re-check with "agentlink status".');
+    }
+    return lines.join('\n');
+}

package/dist/help.d.ts

@@ -0,0 +1,5 @@
+export declare function getRootHelpText(): string;
+export declare function getAuthorizeLinkHelpText(): string;
+export declare function getStatusHelpText(): string;
+export declare function getLinkHelpText(): string;
+export declare function getInitHelpText(): string;

package/dist/help.js

@@ -0,0 +1,103 @@
+export function getRootHelpText() {
+    return `Usage: agentlink <command> [options]
+
+Commands:
+  init             Scaffold a Biomapper-ready agent starter
+  link             Generate consent and open a self-contained local/dev linker URL
+  authorize-link   Generate a one-time EIP-712 consent blob for manual linking
+  status           Check whether an agent is linked and active
+
+Run agentlink <command> --help for command-specific options.
+
+Environment:
+  AGENT_PRIVATE_KEY    Local/dev secret source; prefer stdin or secret managers in production
+  BIOMAPPER_NETWORK    Default network (base | base-sepolia)
+  BIOMAPPER_REGISTRY   Default BiomapperAgentRegistry address
+  BIOMAPPER_RPC_URL    Optional RPC URL override
+  BIOMAPPER_LINKER_URL Default linker URL (defaults to http://localhost:5173/)
+  AGENTLINK_TELEMETRY   Optional override for the saved CLI telemetry choice (on | off)
+  AGENTLINK_POSTHOG_KEY Optional PostHog API key for CLI telemetry
+  AGENTLINK_POSTHOG_HOST Optional PostHog host override (defaults to https://us.i.posthog.com)
+  AGENTLINK_SOURCE      Optional distribution source label for telemetry events
+  AGENTLINK_CAMPAIGN    Optional campaign label for telemetry events
+  AGENTLINK_CONTENT_ID  Optional content identifier for telemetry events
+`;
+}
+export function getAuthorizeLinkHelpText() {
+    return `Usage:
+  agentlink authorize-link --owner <address> [options]
+
+Description:
+  Generate a one-time EIP-712 consent blob that authorizes a biomapped owner wallet
+  to link an agent wallet in BiomapperAgentRegistry.
+
+Options:
+  --owner        Biomapped owner wallet that will call linkAgent
+  --registry     BiomapperAgentRegistry contract address (falls back to BIOMAPPER_REGISTRY)
+  --deadline     Unix timestamp in seconds for signature expiry
+  --network      base | base-sepolia (default: BIOMAPPER_NETWORK or base-sepolia)
+  --private-key  Insecure/dev-only: agent private key as 0x-prefixed hex. Falls back to AGENT_PRIVATE_KEY
+  --private-key-stdin  Read the agent private key from stdin instead of argv
+  --rpc-url      Optional RPC URL override for the selected network
+  --help         Show this help message
+`;
+}
+export function getStatusHelpText() {
+    return `Usage:
+  agentlink status [options]
+
+Description:
+  Query the BiomapperAgentRegistry to check if an agent is linked and whether
+  the link is currently active (owner is biomapped in the current generation).
+
+Options:
+  --registry     BiomapperAgentRegistry contract address (falls back to BIOMAPPER_REGISTRY)
+  --agent        Agent wallet address to check. If omitted, derived from the private key input
+  --network      base | base-sepolia (default: BIOMAPPER_NETWORK or base-sepolia)
+  --private-key  Insecure/dev-only: agent private key (used to derive agent address if --agent is omitted)
+  --private-key-stdin  Read the agent private key from stdin instead of argv
+  --rpc-url      Optional RPC URL override for the selected network
+  --json         Output raw JSON instead of human-readable text
+  --help         Show this help message
+`;
+}
+export function getLinkHelpText() {
+    return `Usage:
+  agentlink link --owner <address> [options]
+
+Description:
+  Generate agent consent, embed it in a self-contained local/dev linker URL, and optionally
+  open the browser so the owner can complete linking with their wallet.
+
+Options:
+  --owner        Biomapped owner wallet address
+  --registry     BiomapperAgentRegistry contract address (falls back to BIOMAPPER_REGISTRY)
+  --network      base | base-sepolia (default: BIOMAPPER_NETWORK or base-sepolia)
+  --deadline     Unix timestamp in seconds for signature and session expiry (default: 24 hours from now)
+  --private-key  Insecure/dev-only: agent private key as 0x-prefixed hex. Falls back to AGENT_PRIVATE_KEY
+  --private-key-stdin  Read the agent private key from stdin instead of argv
+  --rpc-url      Optional RPC URL override for the selected network
+  --linker-url   Linker base URL (default: BIOMAPPER_LINKER_URL or http://localhost:5173/)
+  --open         Open the generated linker URL in the default browser
+  --json         Output consent, session, and linker URL as JSON
+  --help         Show this help message
+`;
+}
+export function getInitHelpText() {
+    return `Usage:
+  agentlink init [dir] [options]
+
+Description:
+  Scaffold a Biomapper-ready TypeScript starter for LangChain, Vercel AI SDK, or MCP.
+
+Options:
+  --template         langchain | vercel-ai-sdk | mcp
+  --network          base | base-sepolia (default: BIOMAPPER_NETWORK or base-sepolia)
+  --registry         BiomapperAgentRegistry contract address (falls back to BIOMAPPER_REGISTRY)
+  --package-manager  npm | pnpm | yarn | bun (default: npm)
+  --package-source   npm | local (default: local when running from this repo, otherwise npm)
+  --install          Install dependencies after writing files
+  --yes              Use defaults and skip prompts
+  --help             Show this help message
+`;
+}

package/dist/index.d.ts

@@ -0,0 +1,16 @@
+#!/usr/bin/env node
+import { createAgentLinkConsent, createBiomapperQueryClient, createLinkSession } from '@techdigger/humanode-agentlink';
+export interface CliRuntime {
+    cwd: string;
+    env: Record<string, string | undefined>;
+    now: Date;
+    stdout: (text: string) => void;
+    stderr: (text: string) => void;
+    createAgentLinkConsent: typeof createAgentLinkConsent;
+    createBiomapperQueryClient: typeof createBiomapperQueryClient;
+    createLinkSession: typeof createLinkSession;
+    buildLinkUrl: (baseUrl: string, session: Awaited<ReturnType<typeof createLinkSession>>) => string;
+    openUrl: (url: string) => Promise<void>;
+    readStdin: () => Promise<string>;
+}
+export declare function runCli(argv?: string[], overrides?: Partial<CliRuntime>): Promise<number>;

package/dist/index.js

@@ -0,0 +1,185 @@
+#!/usr/bin/env node
+import { realpathSync } from 'node:fs';
+import { fileURLToPath } from 'node:url';
+import { captureCliTelemetry } from './lib/telemetry.js';
+import { formatInitOutput, parseInitOptions, runInit } from './commands/init.js';
+import { formatLinkOutput, parseLinkOptions, runLink } from './commands/link.js';
+import { formatStatusOutput, parseStatusOptions, runStatus } from './commands/status.js';
+import { parseAuthorizeLinkOptions, runAuthorizeLink } from './commands/authorize-link.js';
+import { CliError, formatJson, loadEnvFiles, openUrlInBrowser, parseFlags, readAllFromStdin } from './lib/core.js';
+import { getAuthorizeLinkHelpText, getInitHelpText, getLinkHelpText, getRootHelpText, getStatusHelpText, } from './help.js';
+import { buildEmbeddedHostedLinkUrl, createAgentLinkConsent, createBiomapperQueryClient, createLinkSession, } from '@techdigger/humanode-agentlink';
+function writeLine(write, text) {
+    write(text.endsWith('\n') ? text : `${text}\n`);
+}
+export async function runCli(argv = process.argv.slice(2), overrides = {}) {
+    const cwd = overrides.cwd ?? process.cwd();
+    const env = overrides.env ?? (await loadEnvFiles(cwd));
+    const now = overrides.now ?? new Date();
+    const stdout = overrides.stdout ?? (text => process.stdout.write(text));
+    const stderr = overrides.stderr ?? (text => process.stderr.write(text));
+    const runtime = {
+        cwd,
+        env,
+        now,
+        stdout,
+        stderr,
+        createAgentLinkConsent: overrides.createAgentLinkConsent ?? createAgentLinkConsent,
+        createBiomapperQueryClient: overrides.createBiomapperQueryClient ?? createBiomapperQueryClient,
+        createLinkSession: overrides.createLinkSession ?? createLinkSession,
+        buildLinkUrl: overrides.buildLinkUrl ?? buildEmbeddedHostedLinkUrl,
+        openUrl: overrides.openUrl ?? openUrlInBrowser,
+        readStdin: overrides.readStdin ?? readAllFromStdin,
+    };
+    const [command, ...args] = argv;
+    try {
+        if (!command || command === '--help' || command === '-h') {
+            writeLine(runtime.stdout, getRootHelpText());
+            return 0;
+        }
+        switch (command) {
+            case 'authorize-link':
+                if (args.includes('--help') || args.includes('-h')) {
+                    writeLine(runtime.stdout, getAuthorizeLinkHelpText());
+                    return 0;
+                }
+                const authorizePrivateKey = await readPrivateKeyFromStdin(args, runtime);
+                writeLine(runtime.stdout, formatJson(await runAuthorizeLink(parseAuthorizeLinkOptions(args, runtime.env, runtime.now, {
+                    privateKey: authorizePrivateKey,
+                }), {
+                    createAgentLinkConsent: runtime.createAgentLinkConsent,
+                })));
+                await captureCliTelemetry({
+                    eventName: 'agentlink_cli_command_completed',
+                    stage: 'consent-generated',
+                    contentId: 'cli:authorize-link',
+                    properties: {
+                        command: 'authorize-link',
+                    },
+                }, runtime.env);
+                return 0;
+            case 'status': {
+                if (args.includes('--help') || args.includes('-h')) {
+                    writeLine(runtime.stdout, getStatusHelpText());
+                    return 0;
+                }
+                const parsedArgs = parseFlags(args);
+                const statusPrivateKey = parsedArgs.values.agent
+                    ? undefined
+                    : await readPrivateKeyFromStdin(args, runtime);
+                const options = parseStatusOptions(args, runtime.env, {
+                    privateKey: statusPrivateKey,
+                });
+                const result = await runStatus(options, {
+                    createBiomapperQueryClient: runtime.createBiomapperQueryClient,
+                });
+                writeLine(runtime.stdout, formatStatusOutput(result, options.json));
+                await captureCliTelemetry({
+                    eventName: 'agentlink_cli_command_completed',
+                    stage: result.active
+                        ? 'active-status-confirmed'
+                        : result.linked
+                            ? 'linked-status-confirmed'
+                            : 'status-checked',
+                    network: result.network,
+                    contentId: 'cli:status',
+                    properties: {
+                        command: 'status',
+                        linked: result.linked,
+                        active: result.active,
+                    },
+                }, runtime.env);
+                return 0;
+            }
+            case 'link': {
+                if (args.includes('--help') || args.includes('-h')) {
+                    writeLine(runtime.stdout, getLinkHelpText());
+                    return 0;
+                }
+                const linkPrivateKey = await readPrivateKeyFromStdin(args, runtime);
+                const options = parseLinkOptions(args, runtime.env, runtime.now, {
+                    privateKey: linkPrivateKey,
+                });
+                const result = await runLink(options, {
+                    now: runtime.now,
+                    createAgentLinkConsent: runtime.createAgentLinkConsent,
+                    createLinkSession: runtime.createLinkSession,
+                    buildLinkUrl: runtime.buildLinkUrl,
+                    openUrl: runtime.openUrl,
+                });
+                writeLine(runtime.stdout, formatLinkOutput(result, options.json));
+                await captureCliTelemetry({
+                    eventName: 'agentlink_cli_command_completed',
+                    stage: 'link-generated',
+                    network: result.network,
+                    contentId: 'cli:link',
+                    properties: {
+                        command: 'link',
+                        opened: result.opened,
+                    },
+                }, runtime.env);
+                return 0;
+            }
+            case 'init': {
+                if (args.includes('--help') || args.includes('-h')) {
+                    writeLine(runtime.stdout, getInitHelpText());
+                    return 0;
+                }
+                const result = await runInit(parseInitOptions(args, runtime.env), {
+                    cwd: runtime.cwd,
+                    env: runtime.env,
+                });
+                writeLine(runtime.stdout, formatInitOutput(result, runtime.cwd));
+                await captureCliTelemetry({
+                    eventName: 'agentlink_cli_command_completed',
+                    stage: 'starter-generated',
+                    network: result.network,
+                    contentId: `cli:init:${result.template}`,
+                    properties: {
+                        command: 'init',
+                        template: result.template,
+                        packageManager: result.packageManager,
+                        packageSource: result.packageSource,
+                    },
+                }, runtime.env);
+                return 0;
+            }
+            default:
+                throw new CliError(`Unknown command "${command}". Run "agentlink --help" for available commands.`);
+        }
+    }
+    catch (error) {
+        writeLine(runtime.stderr, error instanceof Error ? error.message : String(error));
+        return 1;
+    }
+}
+async function readPrivateKeyFromStdin(argv, runtime) {
+    const parsed = parseFlags(argv);
+    if (!parsed.flags.has('private-key-stdin')) {
+        return undefined;
+    }
+    if (parsed.values['private-key']) {
+        throw new CliError('Pass either --private-key or --private-key-stdin, not both.');
+    }
+    const privateKey = (await runtime.readStdin()).trim();
+    if (!privateKey) {
+        throw new CliError('Missing agent private key on stdin. Pipe a 32-byte hex key into --private-key-stdin.');
+    }
+    return privateKey;
+}
+function isExecutedDirectly() {
+    if (!process.argv[1]) {
+        return false;
+    }
+    try {
+        return realpathSync(process.argv[1]) === realpathSync(fileURLToPath(import.meta.url));
+    }
+    catch {
+        return false;
+    }
+}
+if (isExecutedDirectly()) {
+    runCli().then(code => {
+        process.exitCode = code;
+    });
+}

package/dist/lib/core.d.ts

@@ -0,0 +1,92 @@
+import { type Address, type Hex } from 'viem';
+export declare const NETWORKS: {
+    readonly base: {
+        readonly label: "Base mainnet";
+        readonly biomapperAppUrl: string;
+    };
+    readonly 'base-sepolia': {
+        readonly label: "Base Sepolia";
+        readonly biomapperAppUrl: string;
+    };
+};
+export type NetworkName = keyof typeof NETWORKS;
+export declare const TEMPLATE_NAMES: readonly ["langchain", "vercel-ai-sdk", "mcp"];
+export type TemplateName = (typeof TEMPLATE_NAMES)[number];
+export declare const PACKAGE_MANAGERS: readonly ["npm", "pnpm", "yarn", "bun"];
+export type PackageManager = (typeof PACKAGE_MANAGERS)[number];
+export declare const PACKAGE_SOURCE_NAMES: readonly ["npm", "local"];
+export type PackageSourceName = (typeof PACKAGE_SOURCE_NAMES)[number];
+export interface EnvSource {
+    [key: string]: string | undefined;
+}
+export interface ParsedFlags {
+    positionals: string[];
+    values: Record<string, string>;
+    flags: Set<string>;
+}
+export interface Prompter {
+    text(input: {
+        message: string;
+        defaultValue?: string;
+        allowEmpty?: boolean;
+    }): Promise<string>;
+    select<T extends string>(input: {
+        message: string;
+        options: ReadonlyArray<{
+            value: T;
+            label: string;
+        }>;
+        defaultValue: T;
+    }): Promise<T>;
+    confirm(input: {
+        message: string;
+        defaultValue?: boolean;
+    }): Promise<boolean>;
+    close(): void;
+}
+export interface GeneratedFile {
+    path: string;
+    content: string;
+}
+export interface HumanodePackageSpecs {
+    agentlink: string;
+    langchain: string;
+    aiSdk: string;
+    mcp: string;
+    cli: string;
+}
+export declare class CliError extends Error {
+    constructor(message: string);
+}
+export declare function loadEnvFiles(cwd: string, baseEnv?: EnvSource): Promise<EnvSource>;
+export declare function parseFlags(argv: string[]): ParsedFlags;
+export declare function assertNoExtraPositionals(command: string, positionals: string[]): void;
+export declare function resolveNetwork(value: string | undefined, env: EnvSource): NetworkName;
+export declare function parseRequiredAddress(name: string, value: string | undefined): Address;
+export declare function parseAddressOrPlaceholder(name: string, value: string | undefined, fallback: string): string;
+export declare function resolveRegistryAddress(value: string | undefined, env: EnvSource): Address;
+export declare function resolveRpcUrl(value: string | undefined, env: EnvSource): string | undefined;
+export declare function resolveLinkerUrl(value: string | undefined, env: EnvSource): string;
+export declare function normalizePrivateKey(value: string | undefined): Hex;
+export declare function resolvePrivateKey(value: string | undefined, env: EnvSource, override?: string): Hex;
+export declare function deriveAgentAddress(privateKey: Hex): Address;
+export declare function resolveAgentAddress(agent: string | undefined, privateKey: string | undefined, env: EnvSource): Address;
+export declare function parseFutureDeadline(value: string | undefined, now: Date): bigint;
+export declare function defaultDeadline(now: Date, hours?: number): bigint;
+export declare function formatJson(value: unknown): string;
+export declare function getPackageManagerInstallCommand(packageManager: PackageManager): string;
+export declare function getPackageManagerRunCommand(packageManager: PackageManager, script: string): string;
+export declare function resolvePackageSource(value: string | undefined): PackageSourceName | undefined;
+export declare function resolveHumanodePackageSpecs(targetDir: string, requestedSource?: PackageSourceName): Promise<{
+    packageSource: PackageSourceName;
+    packages: HumanodePackageSpecs;
+}>;
+export declare function toPackageName(value: string): string;
+export declare function ensureTargetDirectoryIsWritable(targetDir: string): Promise<void>;
+export declare function writeGeneratedFiles(targetDir: string, files: GeneratedFile[]): Promise<void>;
+export declare function createConsolePrompter(): Prompter;
+export declare function openUrlInBrowser(url: string): Promise<void>;
+export declare function readAllFromStdin(): Promise<string>;
+export declare function installProjectDependencies(packageManager: PackageManager, cwd: string): Promise<void>;
+export declare function resolvePackageManager(value: string | undefined): PackageManager | undefined;
+export declare function resolveTemplateName(value: string | undefined): TemplateName | undefined;