@keyueclaw/web-sdk 0.1.84 → 0.1.85

package/dist/src/infra/fs-safe.d.ts

@@ -0,0 +1,87 @@
+import type { Stats } from "node:fs";
+import type { FileHandle } from "node:fs/promises";
+export type SafeOpenErrorCode = "invalid-path" | "not-found" | "outside-workspace" | "symlink" | "not-file" | "path-mismatch" | "too-large";
+export declare class SafeOpenError extends Error {
+    code: SafeOpenErrorCode;
+    constructor(code: SafeOpenErrorCode, message: string, options?: ErrorOptions);
+}
+export type SafeOpenResult = {
+    handle: FileHandle;
+    realPath: string;
+    stat: Stats;
+};
+export type SafeLocalReadResult = {
+    buffer: Buffer;
+    realPath: string;
+    stat: Stats;
+};
+export declare function openFileWithinRoot(params: {
+    rootDir: string;
+    relativePath: string;
+    rejectHardlinks?: boolean;
+}): Promise<SafeOpenResult>;
+export declare function readFileWithinRoot(params: {
+    rootDir: string;
+    relativePath: string;
+    rejectHardlinks?: boolean;
+    maxBytes?: number;
+}): Promise<SafeLocalReadResult>;
+export declare function readPathWithinRoot(params: {
+    rootDir: string;
+    filePath: string;
+    rejectHardlinks?: boolean;
+    maxBytes?: number;
+}): Promise<SafeLocalReadResult>;
+export declare function createRootScopedReadFile(params: {
+    rootDir: string;
+    rejectHardlinks?: boolean;
+    maxBytes?: number;
+}): (filePath: string) => Promise<Buffer>;
+export declare function readLocalFileSafely(params: {
+    filePath: string;
+    maxBytes?: number;
+}): Promise<SafeLocalReadResult>;
+export type SafeWritableOpenResult = {
+    handle: FileHandle;
+    createdForWrite: boolean;
+    openedRealPath: string;
+    openedStat: Stats;
+};
+export declare function resolveOpenedFileRealPathForHandle(handle: FileHandle, ioPath: string): Promise<string>;
+export declare function openWritableFileWithinRoot(params: {
+    rootDir: string;
+    relativePath: string;
+    mkdir?: boolean;
+    mode?: number;
+    truncateExisting?: boolean;
+    append?: boolean;
+}): Promise<SafeWritableOpenResult>;
+export declare function appendFileWithinRoot(params: {
+    rootDir: string;
+    relativePath: string;
+    data: string | Buffer;
+    encoding?: BufferEncoding;
+    mkdir?: boolean;
+    prependNewlineIfNeeded?: boolean;
+}): Promise<void>;
+export declare function writeFileWithinRoot(params: {
+    rootDir: string;
+    relativePath: string;
+    data: string | Buffer;
+    encoding?: BufferEncoding;
+    mkdir?: boolean;
+}): Promise<void>;
+export declare function copyFileWithinRoot(params: {
+    sourcePath: string;
+    rootDir: string;
+    relativePath: string;
+    maxBytes?: number;
+    mkdir?: boolean;
+    rejectSourceHardlinks?: boolean;
+}): Promise<void>;
+export declare function writeFileFromPathWithinRoot(params: {
+    rootDir: string;
+    relativePath: string;
+    sourcePath: string;
+    mkdir?: boolean;
+}): Promise<void>;

package/dist/src/infra/gemini-auth.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Shared Gemini authentication utilities.
+ *
+ * Supports both traditional API keys and OAuth JSON format.
+ */
+/**
+ * Parse Gemini API key and return appropriate auth headers.
+ *
+ * OAuth format: `{"token": "...", "projectId": "..."}`
+ *
+ * @param apiKey - Either a traditional API key string or OAuth JSON
+ * @returns Headers object with appropriate authentication
+ */
+export declare function parseGeminiAuth(apiKey: string): {
+    headers: Record<string, string>;
+};

package/dist/src/infra/git-commit.d.ts

@@ -0,0 +1,14 @@
+export type CommitMetadataReaders = {
+    readGitCommit?: (searchDir: string, packageRoot: string | null) => string | null | undefined;
+    readBuildInfoCommit?: () => string | null;
+    readPackageJsonCommit?: () => string | null;
+};
+export declare const resolveCommitHash: (options?: {
+    cwd?: string;
+    env?: NodeJS.ProcessEnv;
+    moduleUrl?: string;
+    readers?: CommitMetadataReaders;
+}) => string | null;
+export declare const __testing: {
+    clearCachedGitCommits: () => void;
+};

package/dist/src/infra/git-root.d.ts

@@ -0,0 +1,7 @@
+export declare const DEFAULT_GIT_DISCOVERY_MAX_DEPTH = 12;
+export declare function findGitRoot(startDir: string, opts?: {
+    maxDepth?: number;
+}): string | null;
+export declare function resolveGitHeadPath(startDir: string, opts?: {
+    maxDepth?: number;
+}): string | null;

package/dist/src/infra/hardlink-guards.d.ts

@@ -0,0 +1,6 @@
+export declare function assertNoHardlinkedFinalPath(params: {
+    filePath: string;
+    root: string;
+    boundaryLabel: string;
+    allowFinalHardlinkForUnlink?: boolean;
+}): Promise<void>;

package/dist/src/infra/heartbeat-reason.d.ts

@@ -0,0 +1,5 @@
+export type HeartbeatReasonKind = "retry" | "interval" | "manual" | "exec-event" | "wake" | "cron" | "hook" | "other";
+export declare function normalizeHeartbeatWakeReason(reason?: string): string;
+export declare function resolveHeartbeatReasonKind(reason?: string): HeartbeatReasonKind;
+export declare function isHeartbeatEventDrivenReason(reason?: string): boolean;
+export declare function isHeartbeatActionWakeReason(reason?: string): boolean;

package/dist/src/infra/heartbeat-summary.d.ts

@@ -0,0 +1,16 @@
+import type { OpenClawConfig } from "../config/config.js";
+import type { AgentDefaultsConfig } from "../config/types.agent-defaults.js";
+type HeartbeatConfig = AgentDefaultsConfig["heartbeat"];
+export type HeartbeatSummary = {
+    enabled: boolean;
+    every: string;
+    everyMs: number | null;
+    prompt: string;
+    target: string;
+    model?: string;
+    ackMaxChars: number;
+};
+export declare function isHeartbeatEnabledForAgent(cfg: OpenClawConfig, agentId?: string): boolean;
+export declare function resolveHeartbeatIntervalMs(cfg: OpenClawConfig, overrideEvery?: string, heartbeat?: HeartbeatConfig): number | null;
+export declare function resolveHeartbeatSummaryForAgent(cfg: OpenClawConfig, agentId?: string): HeartbeatSummary;
+export {};

package/dist/src/infra/heartbeat-visibility.d.ts

@@ -0,0 +1,17 @@
+import type { OpenClawConfig } from "../config/config.js";
+import type { GatewayMessageChannel } from "../utils/message-channel.js";
+export type ResolvedHeartbeatVisibility = {
+    showOk: boolean;
+    showAlerts: boolean;
+    useIndicator: boolean;
+};
+/**
+ * Resolve heartbeat visibility settings for a channel.
+ * Supports both deliverable channels (telegram, signal, etc.) and webchat.
+ * For webchat, uses channels.defaults.heartbeat since webchat doesn't have per-channel config.
+ */
+export declare function resolveHeartbeatVisibility(params: {
+    cfg: OpenClawConfig;
+    channel: GatewayMessageChannel;
+    accountId?: string;
+}): ResolvedHeartbeatVisibility;

package/dist/src/infra/heartbeat-wake.d.ts

@@ -0,0 +1,33 @@
+export type HeartbeatRunResult = {
+    status: "ran";
+    durationMs: number;
+} | {
+    status: "skipped";
+    reason: string;
+} | {
+    status: "failed";
+    reason: string;
+};
+export type HeartbeatWakeHandler = (opts: {
+    reason?: string;
+    agentId?: string;
+    sessionKey?: string;
+}) => Promise<HeartbeatRunResult>;
+export declare function setHeartbeatsEnabled(enabled: boolean): void;
+export declare function areHeartbeatsEnabled(): boolean;
+/**
+ * Register (or clear) the heartbeat wake handler.
+ * Returns a disposer function that clears this specific registration.
+ * Stale disposers (from previous registrations) are no-ops, preventing
+ * a race where an old runner's cleanup clears a newer runner's handler.
+ */
+export declare function setHeartbeatWakeHandler(next: HeartbeatWakeHandler | null): () => void;
+export declare function requestHeartbeatNow(opts?: {
+    reason?: string;
+    coalesceMs?: number;
+    agentId?: string;
+    sessionKey?: string;
+}): void;
+export declare function hasHeartbeatWakeHandler(): boolean;
+export declare function hasPendingHeartbeatWake(): boolean;
+export declare function resetHeartbeatWakeStateForTests(): void;

package/dist/src/infra/home-dir.d.ts

@@ -0,0 +1,11 @@
+export declare function resolveEffectiveHomeDir(env?: NodeJS.ProcessEnv, homedir?: () => string): string | undefined;
+export declare function resolveRequiredHomeDir(env?: NodeJS.ProcessEnv, homedir?: () => string): string;
+export declare function expandHomePrefix(input: string, opts?: {
+    home?: string;
+    env?: NodeJS.ProcessEnv;
+    homedir?: () => string;
+}): string;
+export declare function resolveHomeRelativePath(input: string, opts?: {
+    env?: NodeJS.ProcessEnv;
+    homedir?: () => string;
+}): string;

package/dist/src/infra/host-env-security.d.ts

@@ -0,0 +1,22 @@
+export declare const HOST_DANGEROUS_ENV_KEY_VALUES: readonly string[];
+export declare const HOST_DANGEROUS_ENV_PREFIXES: readonly string[];
+export declare const HOST_DANGEROUS_OVERRIDE_ENV_KEY_VALUES: readonly string[];
+export declare const HOST_DANGEROUS_OVERRIDE_ENV_PREFIXES: readonly string[];
+export declare const HOST_SHELL_WRAPPER_ALLOWED_OVERRIDE_ENV_KEY_VALUES: readonly string[];
+export declare const HOST_DANGEROUS_ENV_KEYS: Set<string>;
+export declare const HOST_DANGEROUS_OVERRIDE_ENV_KEYS: Set<string>;
+export declare const HOST_SHELL_WRAPPER_ALLOWED_OVERRIDE_ENV_KEYS: Set<string>;
+export declare function normalizeEnvVarKey(rawKey: string, options?: {
+    portable?: boolean;
+}): string | null;
+export declare function isDangerousHostEnvVarName(rawKey: string): boolean;
+export declare function isDangerousHostEnvOverrideVarName(rawKey: string): boolean;
+export declare function sanitizeHostExecEnv(params?: {
+    baseEnv?: Record<string, string | undefined>;
+    overrides?: Record<string, string> | null;
+    blockPathOverrides?: boolean;
+}): Record<string, string>;
+export declare function sanitizeSystemRunEnvOverrides(params?: {
+    overrides?: Record<string, string> | null;
+    shellWrapper?: boolean;
+}): Record<string, string> | undefined;

package/dist/src/infra/http-body.d.ts

@@ -0,0 +1,46 @@
+import type { IncomingMessage, ServerResponse } from "node:http";
+export declare const DEFAULT_WEBHOOK_MAX_BODY_BYTES: number;
+export declare const DEFAULT_WEBHOOK_BODY_TIMEOUT_MS = 30000;
+export type RequestBodyLimitErrorCode = "PAYLOAD_TOO_LARGE" | "REQUEST_BODY_TIMEOUT" | "CONNECTION_CLOSED";
+type RequestBodyLimitErrorInit = {
+    code: RequestBodyLimitErrorCode;
+    message?: string;
+};
+export declare class RequestBodyLimitError extends Error {
+    readonly code: RequestBodyLimitErrorCode;
+    readonly statusCode: number;
+    constructor(init: RequestBodyLimitErrorInit);
+}
+export declare function isRequestBodyLimitError(error: unknown, code?: RequestBodyLimitErrorCode): error is RequestBodyLimitError;
+export declare function requestBodyErrorToText(code: RequestBodyLimitErrorCode): string;
+export type ReadRequestBodyOptions = {
+    maxBytes: number;
+    timeoutMs?: number;
+    encoding?: BufferEncoding;
+};
+export declare function readRequestBodyWithLimit(req: IncomingMessage, options: ReadRequestBodyOptions): Promise<string>;
+export type ReadJsonBodyResult = {
+    ok: true;
+    value: unknown;
+} | {
+    ok: false;
+    error: string;
+    code: RequestBodyLimitErrorCode | "INVALID_JSON";
+};
+export type ReadJsonBodyOptions = ReadRequestBodyOptions & {
+    emptyObjectOnEmpty?: boolean;
+};
+export declare function readJsonBodyWithLimit(req: IncomingMessage, options: ReadJsonBodyOptions): Promise<ReadJsonBodyResult>;
+export type RequestBodyLimitGuard = {
+    dispose: () => void;
+    isTripped: () => boolean;
+    code: () => RequestBodyLimitErrorCode | null;
+};
+export type RequestBodyLimitGuardOptions = {
+    maxBytes: number;
+    timeoutMs?: number;
+    responseFormat?: "json" | "text";
+    responseText?: Partial<Record<RequestBodyLimitErrorCode, string>>;
+};
+export declare function installRequestBodyLimitGuard(req: IncomingMessage, res: ServerResponse, options: RequestBodyLimitGuardOptions): RequestBodyLimitGuard;
+export {};

package/dist/src/infra/json-file.d.ts

@@ -0,0 +1,2 @@
+export declare function loadJsonFile(pathname: string): unknown;
+export declare function saveJsonFile(pathname: string, data: unknown): void;

package/dist/src/infra/json-files.d.ts

@@ -0,0 +1,12 @@
+export declare function readJsonFile<T>(filePath: string): Promise<T | null>;
+export declare function writeJsonAtomic(filePath: string, value: unknown, options?: {
+    mode?: number;
+    trailingNewline?: boolean;
+    ensureDirMode?: number;
+}): Promise<void>;
+export declare function writeTextAtomic(filePath: string, content: string, options?: {
+    mode?: number;
+    ensureDirMode?: number;
+    appendTrailingNewline?: boolean;
+}): Promise<void>;
+export declare function createAsyncLock(): <T>(fn: () => Promise<T>) => Promise<T>;

package/dist/src/infra/json-utf8-bytes.d.ts

@@ -0,0 +1 @@
+export declare function jsonUtf8Bytes(value: unknown): number;

package/dist/src/infra/jsonl-socket.d.ts

@@ -0,0 +1,6 @@
+export declare function requestJsonlSocket<T>(params: {
+    socketPath: string;
+    payload: string;
+    timeoutMs: number;
+    accept: (msg: unknown) => T | null | undefined;
+}): Promise<T | null>;

package/dist/src/infra/machine-name.d.ts

@@ -0,0 +1 @@
+export declare function getMachineDisplayName(): Promise<string>;

package/dist/src/infra/map-size.d.ts

@@ -0,0 +1 @@
+export declare function pruneMapToMaxSize<K, V>(map: Map<K, V>, maxSize: number): void;

package/dist/src/infra/net/fetch-guard.d.ts

@@ -0,0 +1,37 @@
+import { type LookupFn, type PinnedDispatcherPolicy, type SsrFPolicy } from "./ssrf.js";
+type FetchLike = (input: RequestInfo | URL, init?: RequestInit) => Promise<Response>;
+export declare const GUARDED_FETCH_MODE: {
+    readonly STRICT: "strict";
+    readonly TRUSTED_ENV_PROXY: "trusted_env_proxy";
+};
+export type GuardedFetchMode = (typeof GUARDED_FETCH_MODE)[keyof typeof GUARDED_FETCH_MODE];
+export type GuardedFetchOptions = {
+    url: string;
+    fetchImpl?: FetchLike;
+    init?: RequestInit;
+    maxRedirects?: number;
+    timeoutMs?: number;
+    signal?: AbortSignal;
+    policy?: SsrFPolicy;
+    lookupFn?: LookupFn;
+    dispatcherPolicy?: PinnedDispatcherPolicy;
+    mode?: GuardedFetchMode;
+    pinDns?: boolean;
+    /** @deprecated use `mode: "trusted_env_proxy"` for trusted/operator-controlled URLs. */
+    proxy?: "env";
+    /**
+     * @deprecated use `mode: "trusted_env_proxy"` instead.
+     */
+    dangerouslyAllowEnvProxyWithoutPinnedDns?: boolean;
+    auditContext?: string;
+};
+export type GuardedFetchResult = {
+    response: Response;
+    finalUrl: string;
+    release: () => Promise<void>;
+};
+type GuardedFetchPresetOptions = Omit<GuardedFetchOptions, "mode" | "proxy" | "dangerouslyAllowEnvProxyWithoutPinnedDns">;
+export declare function withStrictGuardedFetchMode(params: GuardedFetchPresetOptions): GuardedFetchOptions;
+export declare function withTrustedEnvProxyGuardedFetchMode(params: GuardedFetchPresetOptions): GuardedFetchOptions;
+export declare function fetchWithSsrFGuard(params: GuardedFetchOptions): Promise<GuardedFetchResult>;
+export {};

package/dist/src/infra/net/hostname.d.ts

@@ -0,0 +1 @@
+export declare function normalizeHostname(hostname: string): string;

package/dist/src/infra/net/proxy-env.d.ts

@@ -0,0 +1,10 @@
+export declare const PROXY_ENV_KEYS: readonly ["HTTP_PROXY", "HTTPS_PROXY", "ALL_PROXY", "http_proxy", "https_proxy", "all_proxy"];
+export declare function hasProxyEnvConfigured(env?: NodeJS.ProcessEnv): boolean;
+/**
+ * Match undici EnvHttpProxyAgent semantics for env-based HTTP/S proxy selection:
+ * - lower-case vars take precedence over upper-case
+ * - HTTPS requests prefer https_proxy/HTTPS_PROXY, then fall back to http_proxy/HTTP_PROXY
+ * - ALL_PROXY is ignored by EnvHttpProxyAgent
+ */
+export declare function resolveEnvHttpProxyUrl(protocol: "http" | "https", env?: NodeJS.ProcessEnv): string | undefined;
+export declare function hasEnvHttpProxyConfigured(protocol?: "http" | "https", env?: NodeJS.ProcessEnv): boolean;

package/dist/src/infra/net/proxy-fetch.d.ts

@@ -0,0 +1,15 @@
+export declare const PROXY_FETCH_PROXY_URL: unique symbol;
+/**
+ * Create a fetch function that routes requests through the given HTTP proxy.
+ * Uses undici's ProxyAgent under the hood.
+ */
+export declare function makeProxyFetch(proxyUrl: string): typeof fetch;
+export declare function getProxyUrlFromFetch(fetchImpl?: typeof fetch): string | undefined;
+/**
+ * Resolve a proxy-aware fetch from standard environment variables
+ * (HTTPS_PROXY, HTTP_PROXY, https_proxy, http_proxy).
+ * Respects NO_PROXY / no_proxy exclusions via undici's EnvHttpProxyAgent.
+ * Returns undefined when no proxy is configured.
+ * Gracefully returns undefined if the proxy URL is malformed.
+ */
+export declare function resolveProxyFetchFromEnv(env?: NodeJS.ProcessEnv): typeof fetch | undefined;

package/dist/src/infra/net/ssrf.d.ts

@@ -0,0 +1,48 @@
+import { lookup as dnsLookupCb } from "node:dns";
+import { lookup as dnsLookup } from "node:dns/promises";
+import { type Dispatcher } from "undici";
+export declare class SsrFBlockedError extends Error {
+    constructor(message: string);
+}
+export type LookupFn = typeof dnsLookup;
+export type SsrFPolicy = {
+    allowPrivateNetwork?: boolean;
+    dangerouslyAllowPrivateNetwork?: boolean;
+    allowRfc2544BenchmarkRange?: boolean;
+    allowedHostnames?: string[];
+    hostnameAllowlist?: string[];
+};
+export declare function isPrivateNetworkAllowedByPolicy(policy?: SsrFPolicy): boolean;
+export declare function isPrivateIpAddress(address: string, policy?: SsrFPolicy): boolean;
+export declare function isBlockedHostname(hostname: string): boolean;
+export declare function isBlockedHostnameOrIp(hostname: string, policy?: SsrFPolicy): boolean;
+export declare function createPinnedLookup(params: {
+    hostname: string;
+    addresses: string[];
+    fallback?: typeof dnsLookupCb;
+}): typeof dnsLookupCb;
+export type PinnedHostname = {
+    hostname: string;
+    addresses: string[];
+    lookup: typeof dnsLookupCb;
+};
+export type PinnedDispatcherPolicy = {
+    mode: "direct";
+    connect?: Record<string, unknown>;
+} | {
+    mode: "env-proxy";
+    connect?: Record<string, unknown>;
+    proxyTls?: Record<string, unknown>;
+} | {
+    mode: "explicit-proxy";
+    proxyUrl: string;
+    proxyTls?: Record<string, unknown>;
+};
+export declare function resolvePinnedHostnameWithPolicy(hostname: string, params?: {
+    lookupFn?: LookupFn;
+    policy?: SsrFPolicy;
+}): Promise<PinnedHostname>;
+export declare function resolvePinnedHostname(hostname: string, lookupFn?: LookupFn): Promise<PinnedHostname>;
+export declare function createPinnedDispatcher(pinned: PinnedHostname, policy?: PinnedDispatcherPolicy): Dispatcher;
+export declare function closeDispatcher(dispatcher?: Dispatcher | null): Promise<void>;
+export declare function assertPublicHostname(hostname: string, lookupFn?: LookupFn): Promise<void>;

package/dist/src/infra/net/undici-global-dispatcher.d.ts

@@ -0,0 +1,6 @@
+export declare const DEFAULT_UNDICI_STREAM_TIMEOUT_MS: number;
+export declare function ensureGlobalUndiciEnvProxyDispatcher(): void;
+export declare function ensureGlobalUndiciStreamTimeouts(opts?: {
+    timeoutMs?: number;
+}): void;
+export declare function resetGlobalUndiciStreamTimeoutsForTests(): void;

package/dist/src/infra/node-pairing.d.ts

@@ -0,0 +1,53 @@
+type NodePairingNodeMetadata = {
+    nodeId: string;
+    displayName?: string;
+    platform?: string;
+    version?: string;
+    coreVersion?: string;
+    uiVersion?: string;
+    deviceFamily?: string;
+    modelIdentifier?: string;
+    caps?: string[];
+    commands?: string[];
+    permissions?: Record<string, boolean>;
+    remoteIp?: string;
+};
+export type NodePairingPendingRequest = NodePairingNodeMetadata & {
+    requestId: string;
+    silent?: boolean;
+    isRepair?: boolean;
+    ts: number;
+};
+export type NodePairingPairedNode = Omit<NodePairingNodeMetadata, "requestId"> & {
+    token: string;
+    bins?: string[];
+    createdAtMs: number;
+    approvedAtMs: number;
+    lastConnectedAtMs?: number;
+};
+export type NodePairingList = {
+    pending: NodePairingPendingRequest[];
+    paired: NodePairingPairedNode[];
+};
+export declare function listNodePairing(baseDir?: string): Promise<NodePairingList>;
+export declare function getPairedNode(nodeId: string, baseDir?: string): Promise<NodePairingPairedNode | null>;
+export declare function requestNodePairing(req: Omit<NodePairingPendingRequest, "requestId" | "ts" | "isRepair">, baseDir?: string): Promise<{
+    status: "pending";
+    request: NodePairingPendingRequest;
+    created: boolean;
+}>;
+export declare function approveNodePairing(requestId: string, baseDir?: string): Promise<{
+    requestId: string;
+    node: NodePairingPairedNode;
+} | null>;
+export declare function rejectNodePairing(requestId: string, baseDir?: string): Promise<{
+    requestId: string;
+    nodeId: string;
+} | null>;
+export declare function verifyNodeToken(nodeId: string, token: string, baseDir?: string): Promise<{
+    ok: boolean;
+    node?: NodePairingPairedNode;
+}>;
+export declare function updatePairedNodeMetadata(nodeId: string, patch: Partial<Omit<NodePairingPairedNode, "nodeId" | "token" | "createdAtMs" | "approvedAtMs">>, baseDir?: string): Promise<void>;
+export declare function renamePairedNode(nodeId: string, displayName: string, baseDir?: string): Promise<NodePairingPairedNode | null>;
+export {};

package/dist/src/infra/node-shell.d.ts

@@ -0,0 +1 @@
+export declare function buildNodeShellCommand(command: string, platform?: string | null): string[];

package/dist/src/infra/npm-registry-spec.d.ts

@@ -0,0 +1,19 @@
+export type ParsedRegistryNpmSpec = {
+    name: string;
+    raw: string;
+    selector?: string;
+    selectorKind: "none" | "exact-version" | "tag";
+    selectorIsPrerelease: boolean;
+};
+export declare function parseRegistryNpmSpec(rawSpec: string): ParsedRegistryNpmSpec | null;
+export declare function validateRegistryNpmSpec(rawSpec: string): string | null;
+export declare function isExactSemverVersion(value: string): boolean;
+export declare function isPrereleaseSemverVersion(value: string): boolean;
+export declare function isPrereleaseResolutionAllowed(params: {
+    spec: ParsedRegistryNpmSpec;
+    resolvedVersion?: string;
+}): boolean;
+export declare function formatPrereleaseResolutionError(params: {
+    spec: ParsedRegistryNpmSpec;
+    resolvedVersion: string;
+}): string;

package/dist/src/infra/openclaw-exec-env.d.ts

@@ -0,0 +1,4 @@
+export declare const OPENCLAW_CLI_ENV_VAR = "OPENCLAW_CLI";
+export declare const OPENCLAW_CLI_ENV_VALUE = "1";
+export declare function markOpenClawExecEnv<T extends Record<string, string | undefined>>(env: T): T;
+export declare function ensureOpenClawExecMarkerOnProcess(env?: NodeJS.ProcessEnv): NodeJS.ProcessEnv;

package/dist/src/infra/openclaw-root.d.ts

@@ -0,0 +1,10 @@
+export declare function resolveOpenClawPackageRoot(opts: {
+    cwd?: string;
+    argv1?: string;
+    moduleUrl?: string;
+}): Promise<string | null>;
+export declare function resolveOpenClawPackageRootSync(opts: {
+    cwd?: string;
+    argv1?: string;
+    moduleUrl?: string;
+}): string | null;

package/dist/src/infra/outbound/abort.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Utility for checking AbortSignal state and throwing a standard AbortError.
+ */
+/**
+ * Throws an AbortError if the given signal has been aborted.
+ * Use at async checkpoints to support cancellation.
+ */
+export declare function throwIfAborted(abortSignal?: AbortSignal): void;

package/dist/src/infra/outbound/base-session-key.d.ts

@@ -0,0 +1,9 @@
+import type { OpenClawConfig } from "../../config/config.js";
+import { type RoutePeer } from "../../routing/resolve-route.js";
+export declare function buildOutboundBaseSessionKey(params: {
+    cfg: OpenClawConfig;
+    agentId: string;
+    channel: string;
+    accountId?: string | null;
+    peer: RoutePeer;
+}): string;

package/dist/src/infra/outbound/bound-delivery-router.d.ts

@@ -0,0 +1,16 @@
+import { type ConversationRef, type SessionBindingRecord, type SessionBindingService } from "./session-binding-service.js";
+export type BoundDeliveryRouterInput = {
+    eventKind: "task_completion";
+    targetSessionKey: string;
+    requester?: ConversationRef;
+    failClosed: boolean;
+};
+export type BoundDeliveryRouterResult = {
+    binding: SessionBindingRecord | null;
+    mode: "bound" | "fallback";
+    reason: string;
+};
+export type BoundDeliveryRouter = {
+    resolveDestination: (input: BoundDeliveryRouterInput) => BoundDeliveryRouterResult;
+};
+export declare function createBoundDeliveryRouter(service?: SessionBindingService): BoundDeliveryRouter;

package/dist/src/infra/outbound/channel-adapters.d.ts

@@ -0,0 +1,15 @@
+import type { TopLevelComponents } from "@buape/carbon";
+import type { ChannelId } from "../../channels/plugins/types.js";
+import type { OpenClawConfig } from "../../config/config.js";
+export type CrossContextComponentsBuilder = (message: string) => TopLevelComponents[];
+export type CrossContextComponentsFactory = (params: {
+    originLabel: string;
+    message: string;
+    cfg: OpenClawConfig;
+    accountId?: string | null;
+}) => TopLevelComponents[];
+export type ChannelMessageAdapter = {
+    supportsComponentsV2: boolean;
+    buildCrossContextComponents?: CrossContextComponentsFactory;
+};
+export declare function getChannelMessageAdapter(channel: ChannelId): ChannelMessageAdapter;

package/dist/src/infra/outbound/channel-resolution.d.ts

@@ -0,0 +1,8 @@
+import type { ChannelPlugin } from "../../channels/plugins/types.js";
+import type { OpenClawConfig } from "../../config/config.js";
+import { type DeliverableMessageChannel } from "../../utils/message-channel.js";
+export declare function normalizeDeliverableOutboundChannel(raw?: string | null): DeliverableMessageChannel | undefined;
+export declare function resolveOutboundChannelPlugin(params: {
+    channel: string;
+    cfg?: OpenClawConfig;
+}): ChannelPlugin | undefined;

package/dist/src/infra/outbound/channel-selection.d.ts

@@ -0,0 +1,17 @@
+import type { OpenClawConfig } from "../../config/config.js";
+import { type DeliverableMessageChannel } from "../../utils/message-channel.js";
+export type MessageChannelId = DeliverableMessageChannel;
+export type MessageChannelSelectionSource = "explicit" | "tool-context-fallback" | "single-configured";
+export declare function listConfiguredMessageChannels(cfg: OpenClawConfig): Promise<MessageChannelId[]>;
+export declare function resolveMessageChannelSelection(params: {
+    cfg: OpenClawConfig;
+    channel?: string | null;
+    fallbackChannel?: string | null;
+}): Promise<{
+    channel: MessageChannelId;
+    configured: MessageChannelId[];
+    source: MessageChannelSelectionSource;
+}>;
+export declare const __testing: {
+    resetLoggedChannelSelectionErrors(): void;
+};

package/dist/src/infra/outbound/channel-target.d.ts

@@ -0,0 +1,6 @@
+export declare const CHANNEL_TARGET_DESCRIPTION = "Recipient/channel: E.164 for WhatsApp/Signal, Telegram chat id/@username, Discord/Slack channel/user, or iMessage handle/chat_id";
+export declare const CHANNEL_TARGETS_DESCRIPTION = "Recipient/channel targets (same format as --target); accepts ids or names when the directory is available.";
+export declare function applyTargetToParams(params: {
+    action: string;
+    args: Record<string, unknown>;
+}): void;

package/dist/src/infra/outbound/conversation-id.d.ts

@@ -0,0 +1,4 @@
+export declare function resolveConversationIdFromTargets(params: {
+    threadId?: string | number;
+    targets: Array<string | undefined | null>;
+}): string | undefined;