@openclaw/signal 0.0.0 → 2026.6.11

package/dist/channel.runtime-B0-YpkC4.js

@@ -0,0 +1,65 @@
+import { i as resolveSignalAccount, n as listSignalAccountIds } from "./accounts-hOCHbEhX.js";
+import { c as signalNumberTextInput, i as createSignalCliPathTextInput, o as signalCompletionNote, s as signalDmPolicy } from "./channel-LmY2UpOt.js";
+import { r as installSignalCli } from "./install-signal-cli-CXgTF3de.js";
+import { detectBinary } from "openclaw/plugin-sdk/setup-tools";
+import { createDetectedBinaryStatus, createSetupTranslator, setSetupChannelEnabled } from "openclaw/plugin-sdk/setup";
+//#region extensions/signal/src/setup-surface.ts
+const t = createSetupTranslator();
+const channel = "signal";
+//#endregion
+//#region extensions/signal/src/channel.runtime.ts
+const signalSetupWizard = {
+	channel,
+	status: createDetectedBinaryStatus({
+		channelLabel: "Signal",
+		binaryLabel: "signal-cli",
+		configuredLabel: t("wizard.channels.statusConfigured"),
+		unconfiguredLabel: t("wizard.channels.statusNeedsSetup"),
+		configuredHint: t("wizard.channels.statusSignalCliFound"),
+		unconfiguredHint: t("wizard.channels.statusSignalCliMissing"),
+		configuredScore: 1,
+		unconfiguredScore: 0,
+		resolveConfigured: ({ cfg, accountId }) => accountId ? resolveSignalAccount({
+			cfg,
+			accountId
+		}).configured : listSignalAccountIds(cfg).some((resolvedAccountId) => resolveSignalAccount({
+			cfg,
+			accountId: resolvedAccountId
+		}).configured),
+		resolveBinaryPath: ({ cfg, accountId }) => resolveSignalAccount({
+			cfg,
+			accountId
+		}).config.cliPath ?? "signal-cli",
+		detectBinary
+	}),
+	prepare: async ({ cfg, accountId, credentialValues, runtime, prompter, options }) => {
+		if (!options?.allowSignalInstall) return;
+		const cliDetected = await detectBinary((typeof credentialValues.cliPath === "string" ? credentialValues.cliPath : void 0) ?? resolveSignalAccount({
+			cfg,
+			accountId
+		}).config.cliPath ?? "signal-cli");
+		if (!await prompter.confirm({
+			message: cliDetected ? t("wizard.signal.reinstallPrompt") : t("wizard.signal.installPrompt"),
+			initialValue: !cliDetected
+		})) return;
+		try {
+			const result = await installSignalCli(runtime);
+			if (result.ok && result.cliPath) {
+				await prompter.note(`Installed signal-cli at ${result.cliPath}`, "Signal");
+				return { credentialValues: { cliPath: result.cliPath } };
+			}
+			if (!result.ok) await prompter.note(result.error ?? "signal-cli install failed.", "Signal");
+		} catch (error) {
+			await prompter.note(`signal-cli install failed: ${String(error)}`, "Signal");
+		}
+	},
+	credentials: [],
+	textInputs: [createSignalCliPathTextInput(async ({ currentValue }) => {
+		return !await detectBinary(currentValue ?? "signal-cli");
+	}), signalNumberTextInput],
+	completionNote: signalCompletionNote,
+	dmPolicy: signalDmPolicy,
+	disable: (cfg) => setSetupChannelEnabled(cfg, channel, false)
+};
+//#endregion
+export { signalSetupWizard };

package/dist/config-api-KS-qhQvD.js

@@ -0,0 +1,2 @@
+import { SignalConfigSchema, buildChannelConfigSchema } from "openclaw/plugin-sdk/bundled-channel-config-schema";
+export { buildChannelConfigSchema as n, SignalConfigSchema as t };

package/dist/config-schema-BiojLEsX.js

@@ -0,0 +1,27 @@
+import { n as buildChannelConfigSchema, t as SignalConfigSchema } from "./config-api-KS-qhQvD.js";
+//#endregion
+//#region extensions/signal/src/config-schema.ts
+const SignalChannelConfigSchema = buildChannelConfigSchema(SignalConfigSchema, { uiHints: {
+	"": {
+		label: "Signal",
+		help: "Signal channel provider configuration including account identity and DM policy behavior. Keep account mapping explicit so routing remains stable across multi-device setups."
+	},
+	dmPolicy: {
+		label: "Signal DM Policy",
+		help: "Direct message access control (\"pairing\" recommended). \"open\" requires channels.signal.allowFrom=[\"*\"]."
+	},
+	configWrites: {
+		label: "Signal Config Writes",
+		help: "Allow Signal to write config in response to channel events/commands (default: true)."
+	},
+	account: {
+		label: "Signal Account",
+		help: "Signal account identifier (phone/number handle) used to bind this channel config to a specific Signal identity. Keep this aligned with your linked device/session state."
+	},
+	configPath: {
+		label: "Signal CLI Config Path",
+		help: "Optional directory passed to signal-cli via --config when the service needs a non-default signal-cli data path."
+	}
+} });
+//#endregion
+export { SignalChannelConfigSchema as t };

package/dist/contract-api.js

@@ -0,0 +1,3 @@
+import { d as normalizeSignalMessagingTarget, i as isSignalSenderAllowed, u as looksLikeSignalTargetId } from "./identity-B6O4k8xg.js";
+import { a as looksLikeArchive, i as installSignalCliFromRelease, n as extractSignalCliArchive, o as pickAsset, r as installSignalCli, t as downloadToFile } from "./install-signal-cli-CXgTF3de.js";
+export { downloadToFile, extractSignalCliArchive, installSignalCli, installSignalCliFromRelease, isSignalSenderAllowed, looksLikeArchive, looksLikeSignalTargetId, normalizeSignalMessagingTarget, pickAsset };

package/dist/identity-B6O4k8xg.js

@@ -0,0 +1,130 @@
+import { normalizeLowercaseStringOrEmpty, normalizeStringEntries } from "openclaw/plugin-sdk/string-coerce-runtime";
+import { normalizeE164 } from "openclaw/plugin-sdk/text-utility-runtime";
+//#region extensions/signal/src/normalize.ts
+function normalizeSignalMessagingTarget(raw) {
+	const trimmed = raw.trim();
+	if (!trimmed) return;
+	let normalized = trimmed;
+	if (normalizeLowercaseStringOrEmpty(normalized).startsWith("signal:")) normalized = normalized.slice(7).trim();
+	if (!normalized) return;
+	const lower = normalizeLowercaseStringOrEmpty(normalized);
+	if (lower.startsWith("group:")) {
+		const id = normalized.slice(6).trim();
+		return id ? `group:${id}` : void 0;
+	}
+	if (lower.startsWith("username:")) {
+		const id = normalized.slice(9).trim();
+		return id ? normalizeLowercaseStringOrEmpty(`username:${id}`) : void 0;
+	}
+	if (lower.startsWith("u:")) {
+		const id = normalized.slice(2).trim();
+		return id ? normalizeLowercaseStringOrEmpty(`username:${id}`) : void 0;
+	}
+	if (lower.startsWith("uuid:")) {
+		const id = normalized.slice(5).trim();
+		return id ? normalizeLowercaseStringOrEmpty(id) : void 0;
+	}
+	return normalizeLowercaseStringOrEmpty(normalized);
+}
+const UUID_PATTERN = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+const UUID_COMPACT_PATTERN = /^[0-9a-f]{32}$/i;
+function looksLikeSignalTargetId(raw, normalized) {
+	const candidates = normalizeStringEntries([raw, normalized ?? ""]);
+	for (const candidate of candidates) {
+		if (/^(signal:)?(group:|username:|u:)/i.test(candidate)) return true;
+		if (/^(signal:)?uuid:/i.test(candidate)) {
+			const stripped = candidate.replace(/^signal:/i, "").replace(/^uuid:/i, "").trim();
+			if (!stripped) continue;
+			if (UUID_PATTERN.test(stripped) || UUID_COMPACT_PATTERN.test(stripped)) return true;
+			continue;
+		}
+		const withoutSignalPrefix = candidate.replace(/^signal:/i, "").trim();
+		if (UUID_PATTERN.test(withoutSignalPrefix) || UUID_COMPACT_PATTERN.test(withoutSignalPrefix)) return true;
+		if (/^\+?\d{3,}$/.test(withoutSignalPrefix)) return true;
+	}
+	return false;
+}
+//#endregion
+//#region extensions/signal/src/uuid.ts
+const UUID_HYPHENATED_RE = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+const UUID_COMPACT_RE = /^[0-9a-f]{32}$/i;
+function looksLikeUuid(value) {
+	if (UUID_HYPHENATED_RE.test(value) || UUID_COMPACT_RE.test(value)) return true;
+	const compact = value.replace(/-/g, "");
+	if (!/^[0-9a-f]+$/i.test(compact)) return false;
+	return /[a-f]/i.test(compact);
+}
+//#endregion
+//#region extensions/signal/src/identity.ts
+function stripSignalPrefix(value) {
+	return value.replace(/^signal:/i, "").trim();
+}
+function resolveSignalSender(params) {
+	const sourceNumber = params.sourceNumber?.trim();
+	if (sourceNumber) return {
+		kind: "phone",
+		raw: sourceNumber,
+		e164: normalizeE164(sourceNumber)
+	};
+	const sourceUuid = params.sourceUuid?.trim();
+	if (sourceUuid) return {
+		kind: "uuid",
+		raw: sourceUuid
+	};
+	return null;
+}
+function formatSignalSenderId(sender) {
+	return sender.kind === "phone" ? sender.e164 : `uuid:${sender.raw}`;
+}
+function formatSignalSenderDisplay(sender) {
+	return sender.kind === "phone" ? sender.e164 : `uuid:${sender.raw}`;
+}
+function formatSignalPairingIdLine(sender) {
+	if (sender.kind === "phone") return `Your Signal number: ${sender.e164}`;
+	return `Your Signal sender id: ${formatSignalSenderId(sender)}`;
+}
+function resolveSignalRecipient(sender) {
+	return sender.kind === "phone" ? sender.e164 : sender.raw;
+}
+function resolveSignalPeerId(sender) {
+	return sender.kind === "phone" ? sender.e164 : `uuid:${sender.raw}`;
+}
+function parseSignalAllowEntry(entry) {
+	const trimmed = entry.trim();
+	if (!trimmed) return null;
+	if (trimmed === "*") return { kind: "any" };
+	const stripped = stripSignalPrefix(trimmed);
+	if (normalizeLowercaseStringOrEmpty(stripped).startsWith("uuid:")) {
+		const raw = stripped.slice(5).trim();
+		if (!raw) return null;
+		return {
+			kind: "uuid",
+			raw
+		};
+	}
+	if (looksLikeUuid(stripped)) return {
+		kind: "uuid",
+		raw: stripped
+	};
+	return {
+		kind: "phone",
+		e164: normalizeE164(stripped)
+	};
+}
+function normalizeSignalAllowRecipient(entry) {
+	const parsed = parseSignalAllowEntry(entry);
+	if (!parsed || parsed.kind === "any") return;
+	return parsed.kind === "phone" ? parsed.e164 : parsed.raw;
+}
+function isSignalSenderAllowed(sender, allowFrom) {
+	if (allowFrom.length === 0) return false;
+	const parsed = allowFrom.map(parseSignalAllowEntry).filter((entry) => entry !== null);
+	if (parsed.some((entry) => entry.kind === "any")) return true;
+	return parsed.some((entry) => {
+		if (entry.kind === "phone" && sender.kind === "phone") return entry.e164 === sender.e164;
+		if (entry.kind === "uuid" && sender.kind === "uuid") return entry.raw === sender.raw;
+		return false;
+	});
+}
+//#endregion
+export { normalizeSignalAllowRecipient as a, resolveSignalSender as c, normalizeSignalMessagingTarget as d, isSignalSenderAllowed as i, looksLikeUuid as l, formatSignalSenderDisplay as n, resolveSignalPeerId as o, formatSignalSenderId as r, resolveSignalRecipient as s, formatSignalPairingIdLine as t, looksLikeSignalTargetId as u };

package/dist/index.js

@@ -0,0 +1,18 @@
+import { defineBundledChannelEntry } from "openclaw/plugin-sdk/channel-entry-contract";
+//#region extensions/signal/index.ts
+var signal_default = defineBundledChannelEntry({
+	id: "signal",
+	name: "Signal",
+	description: "Signal channel plugin",
+	importMetaUrl: import.meta.url,
+	plugin: {
+		specifier: "./channel-plugin-api.js",
+		exportName: "signalPlugin"
+	},
+	runtime: {
+		specifier: "./runtime-api.js",
+		exportName: "setSignalRuntime"
+	}
+});
+//#endregion
+export { signal_default as default };

package/dist/install-signal-cli-CXgTF3de.js

@@ -0,0 +1,243 @@
+import { normalizeLowercaseStringOrEmpty } from "openclaw/plugin-sdk/string-coerce-runtime";
+import fs from "node:fs/promises";
+import path from "node:path";
+import { formatErrorMessage } from "openclaw/plugin-sdk/error-runtime";
+import { CONFIG_DIR, extractArchive, resolveBrewExecutable } from "openclaw/plugin-sdk/setup-tools";
+import { createWriteStream } from "node:fs";
+import { Readable, Transform } from "node:stream";
+import { pipeline } from "node:stream/promises";
+import { runPluginCommandWithTimeout } from "openclaw/plugin-sdk/run-command";
+import { fetchWithSsrFGuard } from "openclaw/plugin-sdk/ssrf-runtime";
+import { resolvePreferredOpenClawTmpDir } from "openclaw/plugin-sdk/temp-path";
+//#region extensions/signal/src/install-signal-cli.ts
+const MAX_SIGNAL_CLI_ARCHIVE_BYTES = 256 * 1024 * 1024;
+const SIGNAL_CLI_DOWNLOAD_TIMEOUT_MS = 5 * 6e4;
+const SIGNAL_CLI_RELEASE_INFO_TIMEOUT_MS = 3e4;
+const CONTENT_LENGTH_RE = /^\d+$/;
+/** @internal Exported for testing. */
+async function extractSignalCliArchive(archivePath, installRoot, timeoutMs) {
+	await extractArchive({
+		archivePath,
+		destDir: installRoot,
+		timeoutMs
+	});
+}
+/** @internal Exported for testing. */
+function looksLikeArchive(name) {
+	return name.endsWith(".tar.gz") || name.endsWith(".tgz") || name.endsWith(".zip");
+}
+function isNodeReadableStream(value) {
+	return Boolean(value && typeof value.pipe === "function");
+}
+function chunkByteLength(chunk) {
+	if (typeof chunk === "string") return Buffer.byteLength(chunk);
+	if (chunk instanceof Uint8Array) return chunk.byteLength;
+	return Buffer.byteLength(String(chunk));
+}
+/**
+* Pick a native release asset from the official GitHub releases.
+*
+* The official signal-cli releases only publish native (GraalVM) binaries for
+* x86-64 Linux.  On architectures where no native asset is available this
+* returns `undefined` so the caller can fall back to a different install
+* strategy (e.g. Homebrew).
+*/
+/** @internal Exported for testing. */
+function pickAsset(assets, platform, arch) {
+	const archives = assets.filter((asset) => Boolean(asset.name && asset.browser_download_url)).filter((a) => looksLikeArchive(normalizeLowercaseStringOrEmpty(a.name)));
+	const byName = (pattern) => archives.find((asset) => pattern.test(normalizeLowercaseStringOrEmpty(asset.name)));
+	if (platform === "linux") {
+		if (arch === "x64") return byName(/linux-native/) || byName(/linux/) || archives[0];
+		return;
+	}
+	if (platform === "darwin") return byName(/macos|osx|darwin/) || archives[0];
+	if (platform === "win32") return byName(/windows|win/) || archives[0];
+	return archives[0];
+}
+/** @internal Exported for testing. */
+async function downloadToFile(url, dest, maxRedirects = 5, maxBytes = MAX_SIGNAL_CLI_ARCHIVE_BYTES) {
+	let completed = false;
+	const { response, release } = await fetchWithSsrFGuard({
+		url,
+		maxRedirects,
+		requireHttps: true,
+		timeoutMs: SIGNAL_CLI_DOWNLOAD_TIMEOUT_MS,
+		capture: false,
+		auditContext: "signal-cli-install-archive"
+	});
+	try {
+		if (!response.ok || !response.body) throw new Error(`HTTP ${response.status || "?"} downloading file`);
+		const rawLength = response.headers.get("content-length");
+		if (rawLength !== null) {
+			const trimmedLength = rawLength.trim();
+			const declaredLength = CONTENT_LENGTH_RE.test(trimmedLength) ? Number(trimmedLength) : NaN;
+			if (Number.isFinite(declaredLength) && declaredLength > maxBytes) throw new Error(`signal-cli archive exceeds the ${maxBytes}-byte download cap (declared ${declaredLength}).`);
+		}
+		let totalBytes = 0;
+		const body = response.body;
+		await pipeline(isNodeReadableStream(body) ? body : Readable.fromWeb(body), new Transform({ transform(chunk, _encoding, callback) {
+			totalBytes += chunkByteLength(chunk);
+			if (totalBytes > maxBytes) {
+				callback(/* @__PURE__ */ new Error(`signal-cli archive exceeded the ${maxBytes}-byte download cap.`));
+				return;
+			}
+			callback(null, chunk);
+		} }), createWriteStream(dest));
+		completed = true;
+	} finally {
+		await release();
+		if (!completed) await fs.rm(dest, { force: true }).catch(() => void 0);
+	}
+}
+async function findSignalCliBinary(root) {
+	const candidates = [];
+	const enqueue = async (dir, depth) => {
+		if (depth > 3) return;
+		const entries = await fs.readdir(dir, { withFileTypes: true }).catch(() => []);
+		for (const entry of entries) {
+			const full = path.join(dir, entry.name);
+			if (entry.isDirectory()) await enqueue(full, depth + 1);
+			else if (entry.isFile() && entry.name === "signal-cli") candidates.push(full);
+		}
+	};
+	await enqueue(root, 0);
+	return candidates[0] ?? null;
+}
+async function resolveBrewSignalCliPath(brewExe) {
+	try {
+		const result = await runPluginCommandWithTimeout({
+			argv: [
+				brewExe,
+				"--prefix",
+				"signal-cli"
+			],
+			timeoutMs: 1e4
+		});
+		if (result.code === 0 && result.stdout.trim()) {
+			const prefix = result.stdout.trim();
+			const candidate = path.join(prefix, "bin", "signal-cli");
+			try {
+				await fs.access(candidate);
+				return candidate;
+			} catch {
+				return findSignalCliBinary(prefix);
+			}
+		}
+	} catch {}
+	return null;
+}
+async function installSignalCliViaBrew(runtime) {
+	const brewExe = resolveBrewExecutable();
+	if (!brewExe) return {
+		ok: false,
+		error: `No native signal-cli build is available for ${process.arch}. Install Homebrew (https://brew.sh) and try again, or install signal-cli manually.`
+	};
+	runtime.log(`Installing signal-cli via Homebrew (${brewExe})…`);
+	const result = await runPluginCommandWithTimeout({
+		argv: [
+			brewExe,
+			"install",
+			"signal-cli"
+		],
+		timeoutMs: 15 * 6e4
+	});
+	if (result.code !== 0) return {
+		ok: false,
+		error: `brew install signal-cli failed (exit ${result.code}): ${result.stderr.trim().slice(0, 200)}`
+	};
+	const cliPath = await resolveBrewSignalCliPath(brewExe);
+	if (!cliPath) return {
+		ok: false,
+		error: "brew install succeeded but signal-cli binary was not found."
+	};
+	let version;
+	try {
+		version = (await runPluginCommandWithTimeout({
+			argv: [cliPath, "--version"],
+			timeoutMs: 1e4
+		})).stdout.trim().replace(/^signal-cli\s+/, "") || void 0;
+	} catch {}
+	return {
+		ok: true,
+		cliPath,
+		version
+	};
+}
+/** @internal Exported for testing. */
+async function installSignalCliFromRelease(runtime) {
+	const { response, release } = await fetchWithSsrFGuard({
+		url: "https://api.github.com/repos/AsamK/signal-cli/releases/latest",
+		maxRedirects: 5,
+		requireHttps: true,
+		timeoutMs: SIGNAL_CLI_RELEASE_INFO_TIMEOUT_MS,
+		capture: false,
+		auditContext: "signal-cli-release-info",
+		init: { headers: {
+			"User-Agent": "openclaw",
+			Accept: "application/vnd.github+json"
+		} }
+	});
+	let payload;
+	try {
+		if (!response.ok) return {
+			ok: false,
+			error: `Failed to fetch release info (${response.status})`
+		};
+		try {
+			payload = await response.json();
+		} catch {
+			return {
+				ok: false,
+				error: "Failed to parse signal-cli release info."
+			};
+		}
+	} finally {
+		await release();
+	}
+	const version = payload.tag_name?.replace(/^v/, "") ?? "unknown";
+	const asset = pickAsset(payload.assets ?? [], process.platform, process.arch);
+	if (!asset) return {
+		ok: false,
+		error: "No compatible release asset found for this platform."
+	};
+	const tmpDir = await fs.mkdtemp(path.join(resolvePreferredOpenClawTmpDir(), "openclaw-signal-"));
+	const archivePath = path.join(tmpDir, asset.name);
+	runtime.log(`Downloading signal-cli ${version} (${asset.name})…`);
+	await downloadToFile(asset.browser_download_url, archivePath);
+	const installRoot = path.join(CONFIG_DIR, "tools", "signal-cli", version);
+	await fs.mkdir(installRoot, { recursive: true });
+	if (!looksLikeArchive(normalizeLowercaseStringOrEmpty(asset.name))) return {
+		ok: false,
+		error: `Unsupported archive type: ${asset.name}`
+	};
+	try {
+		await extractSignalCliArchive(archivePath, installRoot, 6e4);
+	} catch (err) {
+		const message = formatErrorMessage(err);
+		return {
+			ok: false,
+			error: `Failed to extract ${asset.name}: ${message}`
+		};
+	}
+	const cliPath = await findSignalCliBinary(installRoot);
+	if (!cliPath) return {
+		ok: false,
+		error: `signal-cli binary not found after extracting ${asset.name}`
+	};
+	await fs.chmod(cliPath, 493).catch(() => {});
+	return {
+		ok: true,
+		cliPath,
+		version
+	};
+}
+async function installSignalCli(runtime) {
+	if (process.platform === "win32") return {
+		ok: false,
+		error: "Signal CLI auto-install is not supported on Windows yet."
+	};
+	if (process.platform !== "linux" || process.arch === "x64") return installSignalCliFromRelease(runtime);
+	return installSignalCliViaBrew(runtime);
+}
+//#endregion
+export { looksLikeArchive as a, installSignalCliFromRelease as i, extractSignalCliArchive as n, pickAsset as o, installSignalCli as r, downloadToFile as t };