/** Channel-level policy for which inbound messages should receive an ack reaction. */

import { toErrorObject } from "../infra/errors.js";

export type AckReactionScope = "all" | "direct" | "group-all" | "group-mentions" | "off" | "none";

/** WhatsApp group-mode policy; direct-message ack reactions are configured separately. */

sendPromise = params.send();

} catch (err) {

// Convert sync throws into the same Promise<boolean> flow used for async send failures.

sendPromise = Promise.reject(toLintErrorObject(err, "Non-Error rejection"));

sendPromise = Promise.reject(toErrorObject(err, "Non-Error rejection"));

}

return {

onError: params.onError,

});

}

function toLintErrorObject(value: unknown, fallbackMessage: string): Error {

if (value instanceof Error) {

return value;

}

if (typeof value === "string") {

return new Error(value);

}

const error = new Error(fallbackMessage, { cause: value });

if ((typeof value === "object" && value !== null) || typeof value === "function") {

Object.assign(error, value);

}

return error;

}

// Camera payload validation and artifact writers for node media commands.

import * as fs from "node:fs/promises";

import * as path from "node:path";

import { toErrorObject } from "../infra/errors.js";

import { fetchWithSsrFGuard } from "../infra/net/fetch-guard.js";

import { normalizeHostname } from "../infra/net/hostname.js";

import { parseStrictNonNegativeInteger } from "../infra/parse-finite-number.js";

if (thrown) {

await fs.unlink(filePath).catch(() => {});

throw toLintErrorObject(thrown, "Non-Error thrown");

throw toErrorObject(thrown, "Non-Error thrown");

}

} finally {

await release();

});

return filePath;

}

function toLintErrorObject(value: unknown, fallbackMessage: string): Error {

if (value instanceof Error) {

return value;

}

if (typeof value === "string") {

return new Error(value);

}

const error = new Error(fallbackMessage, { cause: value });

if ((typeof value === "object" && value !== null) || typeof value === "function") {

Object.assign(error, value);

}

return error;

}

import readline from "node:readline/promises";

import { normalizeLowercaseStringOrEmpty } from "@openclaw/normalization-core/string-coerce";

import { isVerbose, isYes } from "../globals.js";

import { toErrorObject } from "../infra/errors.js";

/** Signals that an interactive prompt lost stdin before a complete answer arrived. */

export class PromptInputClosedError extends Error {

rl.once("close", onClose);

void rl.question(question).then(

(answer) => finish(() => resolve(answer)),

(error: unknown) => finish(() => reject(toLintErrorObject(error, "Non-Error rejection"))),

(error: unknown) => finish(() => reject(toErrorObject(error, "Non-Error rejection"))),

);

});

}

}

return answer.startsWith("y");

}

function toLintErrorObject(value: unknown, fallbackMessage: string): Error {

if (value instanceof Error) {

return value;

}

if (typeof value === "string") {

return new Error(value);

}

const error = new Error(fallbackMessage, { cause: value });

if ((typeof value === "object" && value !== null) || typeof value === "function") {

Object.assign(error, value);

}

return error;

}

parseOAuthCallbackInput,

} from "../agents/chutes-oauth.js";

import { isLoopbackHost } from "../gateway/net.js";

import { toErrorObject } from "../infra/errors.js";

import type { OAuthCredentials } from "../llm/oauth.js";

type OAuthPrompt = {

clearTimeout(timeout);

}

server.close();

reject(toLintErrorObject(err, "Non-Error rejection"));

reject(toErrorObject(err, "Non-Error rejection"));

}

});

fetchFn: params.fetchFn,

});

}

function toLintErrorObject(value: unknown, fallbackMessage: string): Error {

if (value instanceof Error) {

return value;

}

if (typeof value === "string") {

return new Error(value);

}

const error = new Error(fallbackMessage, { cause: value });

if ((typeof value === "object" && value !== null) || typeof value === "function") {

Object.assign(error, value);

}

return error;

}

import type { CliDeps } from "../cli/deps.types.js";

import { resolveMainSessionKeyFromConfig } from "../config/sessions.js";

import { parseSessionThreadInfo } from "../config/sessions/thread-info.js";

import { formatErrorMessage } from "../infra/errors.js";

import { formatErrorMessage, toErrorObject } from "../infra/errors.js";

import { requestHeartbeat } from "../infra/heartbeat-wake.js";

import { ackDelivery, enqueueDelivery, failDelivery } from "../infra/outbound/delivery-queue.js";

import { buildOutboundSessionContext } from "../infra/outbound/session-context.js";

},

});

if (dispatchError) {

throw toLintErrorObject(dispatchError, "Non-Error thrown");

throw toErrorObject(dispatchError, "Non-Error thrown");

}

}

export function recordLatestUpdateRestartSentinel(payload: RestartSentinelPayload): void {

latestUpdateRestartSentinel = cloneRestartSentinelPayload(payload);

}

function toLintErrorObject(value: unknown, fallbackMessage: string): Error {

if (value instanceof Error) {

return value;

}

if (typeof value === "string") {

return new Error(value);

}

const error = new Error(fallbackMessage, { cause: value });

if ((typeof value === "object" && value !== null) || typeof value === "function") {

Object.assign(error, value);

}

return error;

}

} from "@openclaw/normalization-core/string-coerce";

import { resolveStateDir } from "../config/paths.js";

import type { DeviceIdentity } from "./device-identity.js";

import { formatErrorMessage } from "./errors.js";

import { formatErrorMessage, toErrorObject } from "./errors.js";

import { createAsyncLock, tryReadJson, writeJson } from "./json-files.js";

import {

APNS_HTTP2_CANCEL_CODE,

}

settled = true;

client.destroy();

reject(toLintErrorObject(err, "Non-Error rejection"));

reject(toErrorObject(err, "Non-Error rejection"));

};

const finish = (result: { status: number; apnsId?: string; body: string }) => {

if (settled) {

}

export { type ApnsRelayConfig, resolveApnsRelayConfigFromEnv };

function toLintErrorObject(value: unknown, fallbackMessage: string): Error {

if (value instanceof Error) {

return value;

}

if (typeof value === "string") {

return new Error(value);

}

const error = new Error(fallbackMessage, { cause: value });

if ((typeof value === "object" && value !== null) || typeof value === "function") {

Object.assign(error, value);

}

return error;

}