@techdigger/humanode-agentlink-cli 0.2.0

package/README.md

@@ -0,0 +1,93 @@
+# @techdigger/humanode-agentlink-cli
+
+Scaffold, link, and inspect Biomapper-ready agent projects.
+
+`agentlink` is the default entrypoint for agent developers:
+
+- `agentlink init` scaffolds a starter for LangChain, Vercel AI SDK, or MCP
+- `agentlink link` generates agent consent, builds a self-contained local/dev linker URL, and can open it in your browser
+- `agentlink status` checks whether an agent is linked and active
+- `agentlink authorize-link` remains available for lower-level manual linking flows
+
+Generated starters also include local `link`, `status`, and `authorize-link` package scripts, so you can run them from inside the scaffolded project after installing dependencies.
+
+## Quick start
+
+```bash
+npx @techdigger/humanode-agentlink-cli init my-agent
+cd my-agent
+```
+
+Fill in `.env.local` for local development, then generate a linker URL for the owner wallet:
+
+```bash
+agentlink link --owner 0xOwner --open
+```
+
+After the owner completes linking in the browser, check the result:
+
+```bash
+agentlink status
+```
+
+## Commands
+
+### `agentlink init`
+
+Scaffold a TypeScript starter for:
+
+- `langchain`
+- `vercel-ai-sdk`
+- `mcp`
+
+Example:
+
+```bash
+agentlink init my-agent --template langchain --network base-sepolia --registry 0xRegistry
+```
+
+When you scaffold from this repo checkout, `init` automatically uses local `file:` dependencies for the Biomapper packages. Add `--package-source npm` to force npm package versions instead.
+
+### `agentlink link`
+
+Generate consent, create a self-contained local/dev linker URL, and optionally open it:
+
+```bash
+agentlink link --owner 0xOwner --registry 0xRegistry --network base-sepolia --open
+```
+
+The CLI does not submit `linkAgent(...)` itself. The owner still completes the on-chain transaction in the linker UI.
+
+`agentlink link` is the local/self-contained flow. Hosted production linkers should create and store sessions server-side with `buildHostedLinkUrl(...)` and the same-origin session lookup endpoint instead of embedding the full session in the URL.
+
+Prefer `--private-key-stdin` or an external secret manager for production secret handling. `AGENT_PRIVATE_KEY` and `.env.local` are convenient local/dev defaults. `--private-key` remains available for compatibility, but it is best treated as a dev-only shortcut because argv can leak into shell history and process inspection.
+
+### `agentlink status`
+
+Check whether the current agent is linked and active:
+
+```bash
+agentlink status --registry 0xRegistry --network base-sepolia
+```
+
+If `AGENT_PRIVATE_KEY` is set, the agent address is derived automatically. Otherwise, pass `--agent 0xAgent` or pipe the key with `--private-key-stdin`.
+
+### `agentlink authorize-link`
+
+Generate the raw one-time EIP-712 consent blob for manual or platform-managed flows:
+
+```bash
+agentlink authorize-link --owner 0xOwner --registry 0xRegistry --deadline 1735689600 --network base-sepolia
+```
+
+## Environment
+
+`agentlink` automatically loads `.env` and `.env.local`.
+
+- `AGENT_PRIVATE_KEY` for local/dev flows
+- `BIOMAPPER_NETWORK`
+- `BIOMAPPER_REGISTRY`
+- `BIOMAPPER_RPC_URL`
+- `BIOMAPPER_LINKER_URL`
+
+For the full flow, examples, and hosted-link details, see the [Agent Developer Guide](./REGISTRATION.md).

package/REGISTRATION.md

@@ -0,0 +1,302 @@
+# Biomapper Link — Agent Developer Guide
+
+Link your AI agent to a biomapped human and unlock free or discounted access to x402 APIs.
+
+## What linking does
+
+When your agent is linked to a biomapped owner, platforms using Biomapper Link can identify your agent as acting on behalf of a real human. This unlocks better pricing: free tiers, free trials, or discounts that are unavailable to unlinked agents.
+
+## Prerequisites
+
+- An agent EVM private key
+- A `BiomapperAgentRegistry` address on Base or Base Sepolia
+- An owner wallet that is biomapped, or can complete Biomapper in the linker flow
+- Node.js and npm, pnpm, yarn, or bun
+
+## Happy path
+
+### Step 1: Scaffold an agent starter
+
+Create a starter for LangChain, Vercel AI SDK, or MCP:
+
+```bash
+npx @techdigger/humanode-agentlink-cli init my-agent
+cd my-agent
+```
+
+Or choose a template explicitly:
+
+```bash
+agentlink init my-agent --template langchain
+agentlink init my-agent --template vercel-ai-sdk
+agentlink init my-agent --template mcp
+```
+
+The generated project includes `.env.local`, a runnable `src/index.ts`, and a README with template-specific instructions.
+It also includes local `link`, `status`, and `authorize-link` package scripts backed by `@techdigger/humanode-agentlink-cli`.
+
+### Step 2: Fill in `.env.local`
+
+The CLI and generated starters read these values automatically:
+
+```bash
+AGENT_PRIVATE_KEY=0x...
+BIOMAPPER_NETWORK=base-sepolia
+BIOMAPPER_REGISTRY=0xYourRegistry
+BIOMAPPER_LINKER_URL=http://localhost:5173/
+```
+
+LangChain and Vercel AI SDK starters also include `OPENAI_API_KEY`.
+
+This `.env.local` pattern is convenient for local development. For production operators, prefer stdin or an external secret manager over long-lived private keys in argv or checked-in deployment files.
+
+When you scaffold from this repo checkout, `agentlink init` automatically points the generated project at local `file:` dependencies for the Biomapper packages. Add `--package-source npm` if you want npm version ranges instead.
+
+### Step 3: Generate a linker URL
+
+Use the guided `link` command to generate agent consent and embed it in a self-contained local linker URL:
+
+```bash
+agentlink link --owner 0xOwner --open
+```
+
+By default, the CLI:
+
+- derives the agent address from `AGENT_PRIVATE_KEY`
+- uses `BIOMAPPER_NETWORK` or `base-sepolia`
+- uses `BIOMAPPER_REGISTRY`
+- uses `BIOMAPPER_LINKER_URL` or `http://localhost:5173/`
+- creates a consent and link session that expire in 24 hours
+
+Add `--json` if you want the raw consent, session payload, and final URL for automation.
+
+This CLI flow is intended for local/dev use. Hosted production linkers should create server-stored sessions and emit canonical `buildHostedLinkUrl(...)` URLs instead of embedding the full session payload in the URL.
+
+Important: the CLI does not submit `linkAgent(...)` itself. It prepares the agent-side consent and hands the owner off to the linker UI.
+
+### Step 4: Complete linking in the linker
+
+If you used `--open`, your browser opens automatically. Otherwise open the printed linker URL manually.
+
+In the linker:
+
+1. Connect the owner wallet
+2. Review the pre-filled network, registry, and agent details from the hosted link
+3. If needed, complete Biomapper verification for the current generation
+4. Approve `linkAgent(...)`
+
+If the owner is not biomapped in the current generation, the linker points them to the correct Biomapper app:
+
+- Base mainnet: `https://mainnet.biomapper.hmnd.app/`
+- Base Sepolia: `https://testnet5.biomapper.hmnd.app/`
+
+### Step 5: Verify status
+
+Check whether the agent is linked and currently active:
+
+```bash
+agentlink status
+```
+
+Or pass flags explicitly:
+
+```bash
+agentlink status --registry 0xRegistry --network base-sepolia --agent 0xAgent
+```
+
+Possible results:
+
+- `Not linked`: no owner is linked to the agent
+- `Inactive`: the agent is linked, but the owner is not biomapped in the current generation
+- `Active`: the agent is linked and the owner is biomapped in the current generation
+
+Use `--json` for machine-readable output.
+
+## Manual consent flow
+
+If you do not want the CLI to create a link session URL, use the lower-level `authorize-link` command:
+
+```bash
+agentlink authorize-link \
+  --owner 0xOwner \
+  --registry 0xRegistry \
+  --deadline 1735689600 \
+  --network base-sepolia
+```
+
+This outputs the raw EIP-712 consent blob:
+
+```json
+{
+  "type": "biomapper-agent-link",
+  "network": "base-sepolia",
+  "chainId": 84532,
+  "agent": "0xAgent",
+  "owner": "0xOwner",
+  "registry": "0xRegistry",
+  "nonce": "0",
+  "deadline": "1735689600",
+  "typedData": { "...": "..." },
+  "signature": "0x..."
+}
+```
+
+Use this for advanced or fully custom platform flows. The public linker no longer expects end users to paste this JSON manually.
+
+## Programmatic consent
+
+If your platform manages agent wallets, generate consent directly from code:
+
+```ts
+import { createAgentLinkConsent } from '@techdigger/humanode-agentlink';
+
+const consent = await createAgentLinkConsent({
+  owner: '0xOwner',
+  registry: '0xYourRegistry',
+  deadline: BigInt(Math.floor(Date.now() / 1000) + 3600),
+  network: 'base-sepolia',
+  privateKey: process.env.AGENT_PRIVATE_KEY as `0x${string}`,
+});
+```
+
+For production code, prefer injecting the signer secret from a secret manager or stdin-equivalent runtime input rather than normalizing long-lived keys in argv.
+
+The output matches the CLI JSON shape and can be passed into hosted link sessions.
+
+## Hosted link sessions
+
+Platforms can build pre-configured link URLs that skip manual setup:
+
+```ts
+import { buildHostedLinkUrl, createLinkSession, validateLinkSession } from '@techdigger/humanode-agentlink';
+
+const session = await createLinkSession(
+  {
+    platformAccountId: 'acct_123',
+    network: 'base-sepolia',
+    registry: '0xRegistry',
+    redirectUrl: 'https://platform.example.com/complete',
+    branding: { platformName: 'Atlas Cloud' },
+    consent,
+  },
+  { store }
+);
+
+const url = buildHostedLinkUrl('https://link.example.com/', session);
+```
+
+`buildHostedLinkUrl(...)` now emits a canonical `?sessionId=...` URL. Serve that session back to the hosted linker from the same origin with `GET /.well-known/agentlink/link-sessions/:sessionId`, returning `200 { session }` or `404/410 { error }`.
+
+Validate stored sessions before returning them:
+
+```ts
+const stored = await store.get(sessionId);
+const validated = validateLinkSession(stored, {
+  allowedRedirectOrigins: ['https://platform.example.com'],
+});
+```
+
+Use `buildHostedLinkUrl(...)` for hosted production linkers. For local static or demo flows, use `buildEmbeddedHostedLinkUrl(...)` instead so the full session stays self-contained in the URL.
+
+## Programmatic status checks
+
+For applications and agents, use the shared read-only query client:
+
+```ts
+import { createBiomapperQueryClient } from '@techdigger/humanode-agentlink';
+
+const biomapper = createBiomapperQueryClient({
+  network: 'base-sepolia',
+  registryAddress: '0xRegistry',
+});
+
+const status = await biomapper.checkAgentStatus({
+  agentAddress: '0xAgent',
+});
+```
+
+## Generation-aware behavior
+
+- Links persist across Biomapper generations
+- `active` is derived from the current generation at query time
+- If the same owner wallet becomes biomapped again later, the link reactivates automatically
+- If the owner switches wallets, a new link is required
+
+## CLI reference
+
+```text
+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
+```
+
+### `init`
+
+```text
+agentlink init [dir] [options]
+
+Options:
+  --template         langchain | vercel-ai-sdk | mcp
+  --network          base | base-sepolia (default: BIOMAPPER_NETWORK or base-sepolia)
+  --registry         BiomapperAgentRegistry 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 help
+```
+
+### `link`
+
+```text
+agentlink link --owner <address> [options]
+
+Options:
+  --owner        Biomapped owner wallet address
+  --registry     BiomapperAgentRegistry 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
+  --private-key  Insecure/dev-only agent private key (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
+  --linker-url   Linker base URL (default: BIOMAPPER_LINKER_URL or http://localhost:5173/)
+  --open         Open the linker URL in the default browser
+  --json         Output consent, session, and linker URL as JSON
+  --help         Show help
+```
+
+### `authorize-link`
+
+```text
+agentlink authorize-link --owner <address> [options]
+
+Options:
+  --owner        Biomapped owner wallet address
+  --registry     BiomapperAgentRegistry 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 (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
+  --help         Show help
+```
+
+### `status`
+
+```text
+agentlink status [options]
+
+Options:
+  --registry     BiomapperAgentRegistry address (falls back to BIOMAPPER_REGISTRY)
+  --agent        Agent wallet address. If omitted, derived from the provided private key input
+  --network      base | base-sepolia (default: BIOMAPPER_NETWORK or base-sepolia)
+  --private-key  Insecure/dev-only agent private key used to derive the agent address
+  --private-key-stdin  Read the agent private key from stdin instead of argv
+  --rpc-url      Optional RPC URL override
+  --json         Output JSON instead of human-readable text
+  --help         Show help
+```

package/dist/commands/authorize-link.d.ts

@@ -0,0 +1,19 @@
+import type { Address, Hex } from 'viem';
+import { createAgentLinkConsent, type AgentLinkConsentOutput } from '@techdigger/humanode-agentlink';
+import { type EnvSource, type NetworkName } from '../lib/core.js';
+export interface AuthorizeLinkOptions {
+    owner: Address;
+    registry: Address;
+    deadline: bigint;
+    network: NetworkName;
+    privateKey: Hex;
+    rpcUrl?: string;
+}
+export interface AuthorizeLinkOverrides {
+    privateKey?: string;
+}
+export interface AuthorizeLinkDeps {
+    createAgentLinkConsent: typeof createAgentLinkConsent;
+}
+export declare function parseAuthorizeLinkOptions(argv: string[], env: EnvSource, now: Date, overrides?: AuthorizeLinkOverrides): AuthorizeLinkOptions;
+export declare function runAuthorizeLink(options: AuthorizeLinkOptions, deps?: Partial<AuthorizeLinkDeps>): Promise<AgentLinkConsentOutput>;

package/dist/commands/authorize-link.js

@@ -0,0 +1,30 @@
+import { createAgentLinkConsent } from '@techdigger/humanode-agentlink';
+import { CliError, assertNoExtraPositionals, parseFlags, parseFutureDeadline, parseRequiredAddress, resolveNetwork, resolvePrivateKey, resolveRegistryAddress, resolveRpcUrl, } from '../lib/core.js';
+export function parseAuthorizeLinkOptions(argv, env, now, overrides = {}) {
+    const parsed = parseFlags(argv);
+    assertNoExtraPositionals('authorize-link', parsed.positionals);
+    return {
+        owner: parseRequiredAddress('owner', parsed.values.owner),
+        registry: resolveRegistryAddress(parsed.values.registry, env),
+        deadline: parseFutureDeadline(parsed.values.deadline, now),
+        network: resolveNetwork(parsed.values.network, env),
+        privateKey: resolvePrivateKey(parsed.values['private-key'], env, overrides.privateKey),
+        rpcUrl: resolveRpcUrl(parsed.values['rpc-url'], env),
+    };
+}
+export async function runAuthorizeLink(options, deps = {}) {
+    const createConsent = deps.createAgentLinkConsent ?? createAgentLinkConsent;
+    try {
+        return await createConsent({
+            owner: options.owner,
+            registry: options.registry,
+            deadline: options.deadline,
+            network: options.network,
+            privateKey: options.privateKey,
+            rpcUrl: options.rpcUrl,
+        });
+    }
+    catch (error) {
+        throw new CliError(error instanceof Error ? error.message : String(error));
+    }
+}

package/dist/commands/init.d.ts

@@ -0,0 +1,33 @@
+import { installProjectDependencies, type EnvSource, type GeneratedFile, type NetworkName, type PackageManager, type PackageSourceName, type Prompter, type TemplateName } from '../lib/core.js';
+export interface InitOptions {
+    directory?: string;
+    template?: TemplateName;
+    network?: NetworkName;
+    registry?: string;
+    packageManager?: PackageManager;
+    packageSource?: PackageSourceName;
+    install: boolean;
+    yes: boolean;
+}
+export interface InitResult {
+    targetDir: string;
+    projectName: string;
+    packageName: string;
+    template: TemplateName;
+    network: NetworkName;
+    registry: string;
+    packageManager: PackageManager;
+    packageSource: PackageSourceName;
+    install: boolean;
+    installed: boolean;
+    files: GeneratedFile[];
+}
+export interface InitDeps {
+    cwd: string;
+    env: EnvSource;
+    prompter: Prompter;
+    installProjectDependencies: typeof installProjectDependencies;
+}
+export declare function parseInitOptions(argv: string[], env: EnvSource): InitOptions;
+export declare function runInit(options: InitOptions, depsInput?: Partial<InitDeps>): Promise<InitResult>;
+export declare function formatInitOutput(result: InitResult, cwd: string): string;

package/dist/commands/init.js

@@ -0,0 +1,127 @@
+import path from 'node:path';
+import { buildTemplateFiles } from '../templates.js';
+import { CliError, PACKAGE_MANAGERS, TEMPLATE_NAMES, createConsolePrompter, ensureTargetDirectoryIsWritable, getPackageManagerInstallCommand, getPackageManagerRunCommand, installProjectDependencies, parseAddressOrPlaceholder, parseFlags, resolveHumanodePackageSpecs, resolveNetwork, resolvePackageManager, resolvePackageSource, resolveTemplateName, toPackageName, writeGeneratedFiles, } from '../lib/core.js';
+const DEFAULT_PROJECT_DIR = 'biomapper-agent';
+const DEFAULT_REGISTRY = '0xYourRegistryDeployment';
+export function parseInitOptions(argv, env) {
+    const parsed = parseFlags(argv);
+    if (parsed.positionals.length > 1) {
+        throw new CliError(`Unexpected arguments for init: ${parsed.positionals.slice(1).join(', ')}`);
+    }
+    return {
+        directory: parsed.positionals[0],
+        template: resolveTemplateName(parsed.values.template),
+        network: parsed.values.network ? resolveNetwork(parsed.values.network, env) : undefined,
+        registry: parsed.values.registry ?? env.BIOMAPPER_REGISTRY,
+        packageManager: resolvePackageManager(parsed.values['package-manager']),
+        packageSource: resolvePackageSource(parsed.values['package-source']),
+        install: parsed.flags.has('install'),
+        yes: parsed.flags.has('yes'),
+    };
+}
+async function resolveInteractiveValue(current, yes, resolveDefault, resolvePrompt) {
+    if (current !== undefined)
+        return current;
+    if (yes)
+        return resolveDefault();
+    return resolvePrompt();
+}
+export async function runInit(options, depsInput = {}) {
+    const cwd = depsInput.cwd ?? process.cwd();
+    const env = depsInput.env ?? process.env;
+    const installDependencies = depsInput.installProjectDependencies ?? installProjectDependencies;
+    const prompter = depsInput.prompter ?? createConsolePrompter();
+    try {
+        const rawDirectory = await resolveInteractiveValue(options.directory, options.yes, () => DEFAULT_PROJECT_DIR, () => prompter.text({
+            message: 'Project directory',
+            defaultValue: DEFAULT_PROJECT_DIR,
+        }));
+        const targetDir = path.resolve(cwd, rawDirectory);
+        await ensureTargetDirectoryIsWritable(targetDir);
+        const template = await resolveInteractiveValue(options.template, options.yes, () => 'langchain', () => prompter.select({
+            message: 'Starter template',
+            options: TEMPLATE_NAMES.map(value => ({ value, label: value })),
+            defaultValue: 'langchain',
+        }));
+        const network = await resolveInteractiveValue(options.network, options.yes, () => resolveNetwork(undefined, env), () => prompter.select({
+            message: 'Biomapper network',
+            options: [
+                { value: 'base-sepolia', label: 'base-sepolia' },
+                { value: 'base', label: 'base' },
+            ],
+            defaultValue: resolveNetwork(undefined, env),
+        }));
+        const registry = await resolveInteractiveValue(options.registry, options.yes, () => env.BIOMAPPER_REGISTRY ?? DEFAULT_REGISTRY, async () => parseAddressOrPlaceholder('registry', await prompter.text({
+            message: 'Biomapper registry address',
+            defaultValue: env.BIOMAPPER_REGISTRY ?? DEFAULT_REGISTRY,
+        }), DEFAULT_REGISTRY));
+        const packageManager = await resolveInteractiveValue(options.packageManager, options.yes, () => 'npm', () => prompter.select({
+            message: 'Package manager',
+            options: PACKAGE_MANAGERS.map(value => ({ value, label: value })),
+            defaultValue: 'npm',
+        }));
+        const packageSource = options.packageSource ?? (await resolveHumanodePackageSpecs(targetDir)).packageSource;
+        const shouldInstall = options.install
+            ? true
+            : options.yes
+                ? false
+                : await prompter.confirm({
+                    message: 'Install dependencies now',
+                    defaultValue: true,
+                });
+        const packageName = toPackageName(path.basename(targetDir));
+        const projectName = path.basename(targetDir);
+        const resolvedPackages = await resolveHumanodePackageSpecs(targetDir, packageSource);
+        const files = buildTemplateFiles({
+            projectName,
+            packageName,
+            template,
+            network,
+            registry,
+            packageManager,
+            packageSource: resolvedPackages.packageSource,
+            humanodePackages: resolvedPackages.packages,
+        });
+        await writeGeneratedFiles(targetDir, files);
+        if (shouldInstall) {
+            await installDependencies(packageManager, targetDir);
+        }
+        return {
+            targetDir,
+            projectName,
+            packageName,
+            template,
+            network,
+            registry,
+            packageManager,
+            packageSource: resolvedPackages.packageSource,
+            install: shouldInstall,
+            installed: shouldInstall,
+            files,
+        };
+    }
+    finally {
+        if (!depsInput.prompter) {
+            prompter?.close();
+        }
+    }
+}
+export function formatInitOutput(result, cwd) {
+    const relativeDir = path.relative(cwd, result.targetDir) || '.';
+    const lines = [
+        `Scaffolded ${result.template} starter in ${relativeDir}`,
+        `Network: ${result.network}`,
+        `Registry: ${result.registry}`,
+        `Package source: ${result.packageSource}`,
+        '',
+        'Next steps:',
+    ];
+    if (relativeDir !== '.') {
+        lines.push(`  cd ${relativeDir}`);
+    }
+    if (!result.installed) {
+        lines.push(`  ${getPackageManagerInstallCommand(result.packageManager)}`);
+    }
+    lines.push('  Fill in .env.local', `  ${getPackageManagerRunCommand(result.packageManager, 'dev')}`, `  ${getPackageManagerRunCommand(result.packageManager, 'link')} -- --owner 0xOwner --open`, `  ${getPackageManagerRunCommand(result.packageManager, 'status')}`);
+    return lines.join('\n');
+}

package/dist/commands/link.d.ts

@@ -0,0 +1,38 @@
+import type { Address, Hex } from 'viem';
+import { createAgentLinkConsent, createLinkSession, type AgentLinkConsentOutput, type AgentLinkSession } from '@techdigger/humanode-agentlink';
+import { type EnvSource, type NetworkName } from '../lib/core.js';
+export interface LinkOptions {
+    owner: Address;
+    registry: Address;
+    network: NetworkName;
+    deadline: bigint;
+    privateKey: Hex;
+    rpcUrl?: string;
+    linkerUrl: string;
+    open: boolean;
+    json: boolean;
+}
+export interface LinkOptionOverrides {
+    privateKey?: string;
+}
+export interface LinkResult {
+    agent: Address;
+    owner: Address;
+    network: NetworkName;
+    registry: Address;
+    deadline: string;
+    linkerUrl: string;
+    opened: boolean;
+    consent: AgentLinkConsentOutput;
+    session: AgentLinkSession;
+}
+export interface LinkDeps {
+    now: Date;
+    createAgentLinkConsent: typeof createAgentLinkConsent;
+    createLinkSession: typeof createLinkSession;
+    buildLinkUrl: (baseUrl: string, session: AgentLinkSession) => string;
+    openUrl: (url: string) => Promise<void>;
+}
+export declare function parseLinkOptions(argv: string[], env: EnvSource, now: Date, overrides?: LinkOptionOverrides): LinkOptions;
+export declare function runLink(options: LinkOptions, deps?: Partial<LinkDeps>): Promise<LinkResult>;
+export declare function formatLinkOutput(result: LinkResult, json?: boolean): string;