@gaodefa/daocore 2026.5.71 → 2026.5.72

package/dist/token-DvXj1Je6.js

@@ -0,0 +1,134 @@
+import { d as normalizeSecretInputString, h as resolveSecretInputString } from "./types.secrets-Ct1DNG7D.js";
+import { n as normalizeAccountId, t as DEFAULT_ACCOUNT_ID } from "./account-id-B32J-iNN.js";
+import { a as tryReadSecretFileSync } from "./secret-file-Yf6gWwVs.js";
+import { l as resolveDefaultSecretProviderAlias } from "./ref-contract-D77qqtrn.js";
+import { n as resolveNormalizedAccountEntry } from "./account-lookup-CQEoGO1F.js";
+import "./account-core-B_TIp73g.js";
+import "./channel-core-Cy34MoFj.js";
+import "./provider-auth-B-d9TlzW.js";
+import "./routing-AC-P99jg.js";
+import "./secret-input-s8BgZnEq.js";
+//#region extensions/telegram/src/token.ts
+function resolveEnvSecretRefValue(params) {
+	const providerConfig = params.cfg?.secrets?.providers?.[params.provider];
+	if (providerConfig) {
+		if (providerConfig.source !== "env") throw new Error(`Secret provider "${params.provider}" has source "${providerConfig.source}" but ref requests "env".`);
+		if (providerConfig.allowlist && !providerConfig.allowlist.includes(params.id)) throw new Error(`Environment variable "${params.id}" is not allowlisted in secrets.providers.${params.provider}.allowlist.`);
+	} else if (params.provider !== resolveDefaultSecretProviderAlias({ secrets: params.cfg?.secrets }, "env")) throw new Error(`Secret provider "${params.provider}" is not configured (ref: env:${params.provider}:${params.id}).`);
+	return normalizeSecretInputString((params.env ?? process.env)[params.id]);
+}
+function resolveRuntimeTokenValue(params) {
+	const resolved = resolveSecretInputString({
+		value: params.value,
+		path: params.path,
+		defaults: params.cfg?.secrets?.defaults,
+		mode: "inspect"
+	});
+	if (resolved.status === "available") return {
+		status: "available",
+		value: resolved.value
+	};
+	if (resolved.status === "missing") return { status: "missing" };
+	if (resolved.ref.source === "env") {
+		const envValue = resolveEnvSecretRefValue({
+			cfg: params.cfg,
+			provider: resolved.ref.provider,
+			id: resolved.ref.id
+		});
+		if (envValue) return {
+			status: "available",
+			value: envValue
+		};
+		return { status: "configured_unavailable" };
+	}
+	resolveSecretInputString({
+		value: params.value,
+		path: params.path,
+		defaults: params.cfg?.secrets?.defaults,
+		mode: "strict"
+	});
+	return { status: "configured_unavailable" };
+}
+function resolveTelegramToken(cfg, opts = {}) {
+	const accountId = normalizeAccountId(opts.accountId);
+	const telegramCfg = cfg?.channels?.telegram;
+	const resolveAccountCfg = (id) => {
+		const accounts = telegramCfg?.accounts;
+		return Array.isArray(accounts) ? void 0 : resolveNormalizedAccountEntry(accounts, id, normalizeAccountId);
+	};
+	const accountCfg = resolveAccountCfg(accountId !== "default" ? accountId : DEFAULT_ACCOUNT_ID);
+	if (accountId !== "default" && !accountCfg) {
+		const accounts = telegramCfg?.accounts;
+		if (!!accounts && typeof accounts === "object" && !Array.isArray(accounts) && Object.keys(accounts).length > 0) {
+			opts.logMissingFile?.(`channels.telegram.accounts: unknown accountId "${accountId}" — not found in config, refusing channel-level fallback`);
+			return {
+				token: "",
+				source: "none"
+			};
+		}
+	}
+	const accountTokenFile = accountCfg?.tokenFile?.trim();
+	if (accountTokenFile) {
+		const token = tryReadSecretFileSync(accountTokenFile, `channels.telegram.accounts.${accountId}.tokenFile`, { rejectSymlink: true });
+		if (token) return {
+			token,
+			source: "tokenFile"
+		};
+		opts.logMissingFile?.(`channels.telegram.accounts.${accountId}.tokenFile not found or unreadable: ${accountTokenFile}`);
+		return {
+			token: "",
+			source: "none"
+		};
+	}
+	const accountToken = resolveRuntimeTokenValue({
+		cfg,
+		value: accountCfg?.botToken,
+		path: `channels.telegram.accounts.${accountId}.botToken`
+	});
+	if (accountToken.status === "available") return {
+		token: accountToken.value,
+		source: "config"
+	};
+	if (accountToken.status === "configured_unavailable") return {
+		token: "",
+		source: "none"
+	};
+	const allowEnv = accountId === DEFAULT_ACCOUNT_ID;
+	const tokenFile = telegramCfg?.tokenFile?.trim();
+	if (tokenFile) {
+		const token = tryReadSecretFileSync(tokenFile, "channels.telegram.tokenFile", { rejectSymlink: true });
+		if (token) return {
+			token,
+			source: "tokenFile"
+		};
+		opts.logMissingFile?.(`channels.telegram.tokenFile not found or unreadable: ${tokenFile}`);
+		return {
+			token: "",
+			source: "none"
+		};
+	}
+	const configToken = resolveRuntimeTokenValue({
+		cfg,
+		value: telegramCfg?.botToken,
+		path: "channels.telegram.botToken"
+	});
+	if (configToken.status === "available") return {
+		token: configToken.value,
+		source: "config"
+	};
+	if (configToken.status === "configured_unavailable") return {
+		token: "",
+		source: "none"
+	};
+	const envToken = allowEnv ? (opts.envToken ?? process.env.TELEGRAM_BOT_TOKEN)?.trim() : "";
+	if (envToken) return {
+		token: envToken,
+		source: "env"
+	};
+	return {
+		token: "",
+		source: "none"
+	};
+}
+//#endregion
+export { resolveTelegramToken as t };

package/dist/tool-UueBFg-4.js

@@ -0,0 +1,139 @@
+import { n as resolvePreferredDaoCoreTmpDir } from "./tmp-daocore-dir-kDRsiZXM.js";
+import { c as jsonResult, g as readStringParam, s as imageResultFromFile } from "./common-vJyw6dD-.js";
+import { t as callGatewayTool } from "./gateway-Dyc7qEu3.js";
+import "./temp-path-CKL9wgHJ.js";
+import { i as resolveNodeIdFromList, t as listNodes } from "./nodes-utils-CIusEv3-.js";
+import "./agent-harness-runtime-A75qLmN7.js";
+import "./channel-actions-BEsMIO8Q.js";
+import { t as CanvasToolSchema } from "./tool-schema-BypT50EN.js";
+import { n as normalizeCanvasSnapshotFileExtension, r as parseCanvasSnapshotPayload } from "./cli-helpers-CcmxW8sC.js";
+import path from "node:path";
+import fs from "node:fs/promises";
+import { randomUUID } from "node:crypto";
+//#region extensions/canvas/src/tool.ts
+function readGatewayCallOptions(params) {
+	return {
+		gatewayUrl: readStringParam(params, "gatewayUrl", { trim: false }),
+		gatewayToken: readStringParam(params, "gatewayToken", { trim: false }),
+		timeoutMs: typeof params.timeoutMs === "number" ? params.timeoutMs : void 0
+	};
+}
+async function resolveNodeId(opts, query, allowDefault = false) {
+	return resolveNodeIdFromList(await listNodes(opts), query, allowDefault);
+}
+async function writeBase64ToTempFile(params) {
+	const dir = resolvePreferredDaoCoreTmpDir();
+	await fs.mkdir(dir, {
+		recursive: true,
+		mode: 448
+	});
+	const ext = `.${normalizeCanvasSnapshotFileExtension(params.ext)}`;
+	const filePath = path.join(dir, `daocore-canvas-snapshot-${randomUUID()}${ext}`);
+	await fs.writeFile(filePath, Buffer.from(params.base64, "base64"));
+	return filePath;
+}
+function isPathInsideRoot(root, candidate) {
+	const relative = path.relative(root, candidate);
+	return relative === "" || !!relative && !relative.startsWith("..") && !path.isAbsolute(relative);
+}
+async function readJsonlFromPath(jsonlPath, workspaceDir) {
+	const trimmed = jsonlPath.trim();
+	if (!trimmed) return "";
+	const workspaceRoot = path.resolve(workspaceDir ?? process.cwd());
+	const resolved = path.resolve(workspaceRoot, trimmed);
+	const [workspaceReal, resolvedReal] = await Promise.all([fs.realpath(workspaceRoot), fs.realpath(resolved)]);
+	if (!isPathInsideRoot(workspaceReal, resolvedReal)) throw new Error("jsonlPath outside workspace");
+	return await fs.readFile(resolvedReal, "utf8");
+}
+function resolveCanvasImageSanitizationLimits(config) {
+	const configured = config?.agents?.defaults?.imageMaxDimensionPx;
+	if (typeof configured !== "number" || !Number.isFinite(configured)) return {};
+	return { maxDimensionPx: Math.max(1, Math.floor(configured)) };
+}
+function createCanvasTool(options) {
+	const imageSanitization = resolveCanvasImageSanitizationLimits(options?.config);
+	return {
+		label: "Canvas",
+		name: "canvas",
+		description: "Control node canvases (present/hide/navigate/eval/snapshot/A2UI). Use snapshot to capture the rendered UI.",
+		parameters: CanvasToolSchema,
+		execute: async (_toolCallId, args) => {
+			const params = args;
+			const action = readStringParam(params, "action", { required: true });
+			const gatewayOpts = readGatewayCallOptions(params);
+			const nodeId = await resolveNodeId(gatewayOpts, readStringParam(params, "node", { trim: true }), true);
+			const invoke = async (command, invokeParams) => await callGatewayTool("node.invoke", gatewayOpts, {
+				nodeId,
+				command,
+				params: invokeParams,
+				idempotencyKey: randomUUID()
+			});
+			switch (action) {
+				case "present": {
+					const placement = {
+						x: typeof params.x === "number" ? params.x : void 0,
+						y: typeof params.y === "number" ? params.y : void 0,
+						width: typeof params.width === "number" ? params.width : void 0,
+						height: typeof params.height === "number" ? params.height : void 0
+					};
+					const invokeParams = {};
+					const presentTarget = readStringParam(params, "target", { trim: true }) ?? readStringParam(params, "url", { trim: true });
+					if (presentTarget) invokeParams.url = presentTarget;
+					if (Number.isFinite(placement.x) || Number.isFinite(placement.y) || Number.isFinite(placement.width) || Number.isFinite(placement.height)) invokeParams.placement = placement;
+					await invoke("canvas.present", invokeParams);
+					return jsonResult({ ok: true });
+				}
+				case "hide":
+					await invoke("canvas.hide", void 0);
+					return jsonResult({ ok: true });
+				case "navigate":
+					await invoke("canvas.navigate", { url: readStringParam(params, "url", { trim: true }) ?? readStringParam(params, "target", {
+						required: true,
+						trim: true,
+						label: "url"
+					}) });
+					return jsonResult({ ok: true });
+				case "eval": {
+					const result = (await invoke("canvas.eval", { javaScript: readStringParam(params, "javaScript", { required: true }) }))?.payload?.result;
+					if (result) return {
+						content: [{
+							type: "text",
+							text: result
+						}],
+						details: { result }
+					};
+					return jsonResult({ ok: true });
+				}
+				case "snapshot": {
+					const formatRaw = typeof params.outputFormat === "string" && params.outputFormat.trim() ? params.outputFormat.trim().toLowerCase() : "png";
+					const payload = parseCanvasSnapshotPayload((await invoke("canvas.snapshot", {
+						format: formatRaw === "jpg" || formatRaw === "jpeg" ? "jpeg" : "png",
+						maxWidth: typeof params.maxWidth === "number" && Number.isFinite(params.maxWidth) ? params.maxWidth : void 0,
+						quality: typeof params.quality === "number" && Number.isFinite(params.quality) ? params.quality : void 0
+					}))?.payload);
+					return await imageResultFromFile({
+						label: "canvas:snapshot",
+						path: await writeBase64ToTempFile({
+							base64: payload.base64,
+							ext: payload.format === "jpeg" ? "jpg" : payload.format
+						}),
+						details: { format: payload.format },
+						imageSanitization
+					});
+				}
+				case "a2ui_push": {
+					const jsonl = typeof params.jsonl === "string" && params.jsonl.trim() ? params.jsonl : typeof params.jsonlPath === "string" && params.jsonlPath.trim() ? await readJsonlFromPath(params.jsonlPath, options?.workspaceDir) : "";
+					if (!jsonl.trim()) throw new Error("jsonl or jsonlPath required");
+					await invoke("canvas.a2ui.pushJSONL", { jsonl });
+					return jsonResult({ ok: true });
+				}
+				case "a2ui_reset":
+					await invoke("canvas.a2ui.reset", void 0);
+					return jsonResult({ ok: true });
+				default: throw new Error(`Unknown action: ${action}`);
+			}
+		}
+	};
+}
+//#endregion
+export { createCanvasTool };