@gaodefa/daocore 2026.5.48 → 2026.5.51

package/dist/tui-backend-BOAgkU7O.js

@@ -0,0 +1,256 @@
+import { r as buildAgentMainSessionKey } from "./session-key-Bte0mmcq.js";
+import { i as isPersistentCrestodianOperation, n as executeCrestodianOperation } from "./operations-CePwJ_bf.js";
+import { n as formatCrestodianStartupMessage, r as loadCrestodianOverview } from "./overview-D2tJdx4_.js";
+import { n as isYes, r as resolveCrestodianOperation, t as approvalQuestion } from "./dialogue-BQcF-xHi.js";
+import { y as runTui } from "./tui-ChmyCc_c.js";
+import { randomUUID } from "node:crypto";
+//#region src/crestodian/tui-backend.ts
+const CRESTODIAN_AGENT_ID = "crestodian";
+const CRESTODIAN_SESSION_KEY = buildAgentMainSessionKey({ agentId: CRESTODIAN_AGENT_ID });
+function createCaptureRuntime() {
+	const lines = [];
+	return {
+		log: (...args) => lines.push(args.join(" ")),
+		error: (...args) => lines.push(args.join(" ")),
+		exit: (code) => {
+			throw new Error(`Crestodian operation exited with code ${String(code)}`);
+		},
+		read: () => lines.join("\n").trim()
+	};
+}
+async function loadOverviewForTui(opts) {
+	if (opts.deps?.loadOverview) return await opts.deps.loadOverview();
+	return await loadCrestodianOverview();
+}
+function message(role, text) {
+	return {
+		role,
+		content: [{
+			type: "text",
+			text
+		}],
+		timestamp: Date.now()
+	};
+}
+function splitModelRef(ref) {
+	const trimmed = ref?.trim();
+	if (!trimmed) return {};
+	const slash = trimmed.indexOf("/");
+	if (slash <= 0 || slash >= trimmed.length - 1) return { model: trimmed };
+	return {
+		provider: trimmed.slice(0, slash),
+		model: trimmed.slice(slash + 1)
+	};
+}
+var CrestodianTuiBackend = class {
+	constructor(opts, welcome) {
+		this.opts = opts;
+		this.connection = { url: "crestodian local" };
+		this.seq = 0;
+		this.pending = null;
+		this.handoff = null;
+		this.requestExit = null;
+		this.messages = [];
+		this.messages.push(message("assistant", welcome));
+	}
+	setRequestExitHandler(handler) {
+		this.requestExit = handler;
+	}
+	consumeHandoff() {
+		const handoff = this.handoff;
+		this.handoff = null;
+		return handoff;
+	}
+	start() {
+		queueMicrotask(() => {
+			this.onConnected?.();
+		});
+	}
+	stop() {}
+	async sendChat(opts) {
+		const runId = opts.runId ?? randomUUID();
+		const text = opts.message.trim();
+		this.messages.push(message("user", opts.message));
+		this.respond(runId, opts.sessionKey, text);
+		return { runId };
+	}
+	async abortChat() {
+		return {
+			ok: true,
+			aborted: false
+		};
+	}
+	async loadHistory() {
+		return {
+			sessionId: "crestodian",
+			messages: this.messages,
+			thinkingLevel: "off",
+			verboseLevel: "off"
+		};
+	}
+	async listSessions() {
+		const model = splitModelRef((await loadOverviewForTui(this.opts)).defaultModel);
+		return {
+			ts: Date.now(),
+			path: "crestodian",
+			count: 1,
+			defaults: {
+				model: model.model ?? null,
+				modelProvider: model.provider ?? null,
+				contextTokens: null
+			},
+			sessions: [{
+				key: CRESTODIAN_SESSION_KEY,
+				sessionId: "crestodian",
+				displayName: "Crestodian",
+				updatedAt: Date.now(),
+				thinkingLevel: "off",
+				verboseLevel: "off",
+				model: model.model,
+				modelProvider: model.provider
+			}]
+		};
+	}
+	async listAgents() {
+		return {
+			defaultId: CRESTODIAN_AGENT_ID,
+			mainKey: "main",
+			scope: "per-sender",
+			agents: [{
+				id: CRESTODIAN_AGENT_ID,
+				name: "Crestodian"
+			}]
+		};
+	}
+	async patchSession(opts) {
+		const model = splitModelRef(typeof opts.model === "string" ? opts.model : void 0);
+		return {
+			ok: true,
+			path: "crestodian",
+			key: CRESTODIAN_SESSION_KEY,
+			entry: {
+				sessionId: "crestodian",
+				displayName: "Crestodian",
+				updatedAt: Date.now(),
+				...model.model ? { model: model.model } : {},
+				...model.provider ? { modelProvider: model.provider } : {}
+			},
+			resolved: {
+				modelProvider: model.provider,
+				model: model.model
+			}
+		};
+	}
+	async resetSession() {
+		this.pending = null;
+		const overview = await loadOverviewForTui(this.opts);
+		this.messages.splice(0, this.messages.length, message("assistant", formatCrestodianStartupMessage(overview)));
+		return { ok: true };
+	}
+	async getGatewayStatus() {
+		return (await loadOverviewForTui(this.opts)).gateway.reachable ? "Gateway reachable" : "Gateway unreachable";
+	}
+	async listModels() {
+		return [];
+	}
+	nextSeq() {
+		this.seq += 1;
+		return this.seq;
+	}
+	emit(event, payload) {
+		this.onEvent?.({
+			event,
+			payload,
+			seq: this.nextSeq()
+		});
+	}
+	emitFinal(runId, sessionKey, text) {
+		const assistant = message("assistant", text || "Crestodian listened and found nothing to change.");
+		this.messages.push(assistant);
+		this.emit("chat", {
+			runId,
+			sessionKey,
+			state: "final",
+			message: assistant
+		});
+	}
+	emitError(runId, sessionKey, error) {
+		const errorMessage = error instanceof Error ? error.message : String(error);
+		this.emit("chat", {
+			runId,
+			sessionKey,
+			state: "error",
+			errorMessage
+		});
+	}
+	async respond(runId, sessionKey, text) {
+		try {
+			const reply = await this.resolveReply(text);
+			this.emitFinal(runId, sessionKey, reply);
+		} catch (error) {
+			this.emitError(runId, sessionKey, error);
+		}
+	}
+	async resolveReply(text) {
+		if (this.pending) {
+			if (isYes(text)) {
+				const pending = this.pending;
+				this.pending = null;
+				const capture = createCaptureRuntime();
+				await executeCrestodianOperation(pending, capture, {
+					approved: true,
+					deps: this.opts.deps
+				});
+				return capture.read() || "Applied. Audit entry written.";
+			}
+			this.pending = null;
+			return "Skipped. No barnacles on config today.";
+		}
+		const capture = createCaptureRuntime();
+		const operation = await resolveCrestodianOperation(text, capture, this.opts);
+		if (operation.kind === "open-tui") {
+			this.handoff = operation;
+			queueMicrotask(() => this.requestExit?.());
+			return "Opening your normal agent TUI. Use /crestodian there to come back.";
+		}
+		if (isPersistentCrestodianOperation(operation) && !this.opts.yes) {
+			this.pending = operation;
+			await executeCrestodianOperation(operation, capture, {
+				approved: false,
+				deps: this.opts.deps
+			});
+			return [capture.read(), approvalQuestion(operation)].filter(Boolean).join("\n\n");
+		}
+		await executeCrestodianOperation(operation, capture, {
+			approved: this.opts.yes === true || !isPersistentCrestodianOperation(operation),
+			deps: this.opts.deps
+		});
+		const reply = capture.read();
+		if (operation.kind === "none" && reply.includes("Bye.")) queueMicrotask(() => this.requestExit?.());
+		return reply;
+	}
+};
+async function runCrestodianTui(opts, runtime) {
+	let nextInput;
+	for (;;) {
+		const backend = new CrestodianTuiBackend(opts, formatCrestodianStartupMessage(await loadOverviewForTui(opts)));
+		await (opts.runTui ?? runTui)({
+			local: true,
+			session: CRESTODIAN_SESSION_KEY,
+			historyLimit: 200,
+			backend,
+			config: {},
+			title: "daocore crestodian",
+			...nextInput ? { message: nextInput } : {}
+		});
+		const handoff = backend.consumeHandoff();
+		if (!handoff) return;
+		nextInput = (await executeCrestodianOperation(handoff, runtime, {
+			approved: true,
+			deps: opts.deps
+		})).nextInput;
+		if (!nextInput?.trim()) return;
+	}
+}
+//#endregion
+export { runCrestodianTui };

package/dist/tui-cli-C_1WxXuf.js

@@ -0,0 +1,37 @@
+import { t as formatDocsLink } from "./links-CM5vg8_V.js";
+import { r as theme } from "./theme-D58JpUfy.js";
+import { n as defaultRuntime } from "./runtime-E_A14BX_.js";
+import { t as parseTimeoutMs } from "./parse-timeout-91AFhn8L.js";
+//#region src/cli/tui-cli.ts
+function registerTuiCli(program) {
+	program.command("tui").alias("terminal").alias("chat").description("Open a terminal UI connected to the Gateway").option("--local", "Run against the local embedded agent runtime", false).option("--url <url>", "Gateway WebSocket URL (defaults to gateway.remote.url when configured)").option("--token <token>", "Gateway token (if required)").option("--password <password>", "Gateway password (if required)").option("--session <key>", "Session key (default: \"main\", or \"global\" when scope is global)").option("--deliver", "Deliver assistant replies", false).option("--thinking <level>", "Thinking level override").option("--message <text>", "Send an initial message after connecting").option("--timeout-ms <ms>", "Agent timeout in ms (defaults to agents.defaults.timeoutSeconds)").option("--history-limit <n>", "History entries to load", "200").addHelpText("after", () => `\n${theme.muted("Docs:")} ${formatDocsLink("/cli/tui", "docs.openclaw.ai/cli/tui")}\n`).action(async (opts, cmd) => {
+		try {
+			const invokedSubcommand = cmd.parent?.args[0];
+			const invokedAsLocalAlias = invokedSubcommand === "terminal" || invokedSubcommand === "chat";
+			const isLocal = Boolean(opts.local) || invokedAsLocalAlias;
+			if (isLocal && (opts.url || opts.token || opts.password)) throw new Error("--local cannot be combined with --url, --token, or --password");
+			const timeoutMs = parseTimeoutMs(opts.timeoutMs);
+			if (opts.timeoutMs !== void 0 && timeoutMs === void 0) defaultRuntime.error(`warning: invalid --timeout-ms "${String(opts.timeoutMs)}"; ignoring`);
+			const historyLimit = Number.parseInt(String(opts.historyLimit ?? "200"), 10);
+			const { runTui } = await import("./tui-BcRfXYtK.js");
+			await runTui({
+				local: isLocal,
+				url: opts.url,
+				token: opts.token,
+				password: opts.password,
+				session: opts.session,
+				deliver: Boolean(opts.deliver),
+				thinking: opts.thinking,
+				message: opts.message,
+				timeoutMs,
+				historyLimit: Number.isNaN(historyLimit) ? void 0 : historyLimit,
+				forceProcessExitOnReturn: true
+			});
+		} catch (err) {
+			defaultRuntime.error(String(err));
+			defaultRuntime.exit(1);
+		}
+	});
+}
+//#endregion
+export { registerTuiCli };

package/dist/update-check-Dvp_oog_.js

@@ -0,0 +1,387 @@
+import { t as compareDaoCoreReleaseVersions } from "./npm-registry-spec-D1a7Iic0.js";
+import { r as runCommandWithTimeout } from "./exec-PI-gh7wQ.js";
+import { i as parseComparableSemver, t as compareComparableSemver } from "./semver-compare-BoMHoO1q.js";
+import { r as fetchWithTimeout } from "./fetch-timeout-Ba3aWhoN.js";
+import { r as channelToNpmTag } from "./update-channels-f-ieRme5.js";
+import { t as readPackageManagerSpec } from "./package-json-CIZcDaQ6.js";
+import path from "node:path";
+import fs from "node:fs/promises";
+//#region src/infra/detect-package-manager.ts
+async function detectPackageManager$1(root) {
+	const pm = (await readPackageManagerSpec(root))?.split("@")[0]?.trim();
+	if (pm === "pnpm" || pm === "bun" || pm === "npm") return pm;
+	const files = await fs.readdir(root).catch(() => []);
+	if (files.includes("pnpm-lock.yaml")) return "pnpm";
+	if (files.includes("bun.lock") || files.includes("bun.lockb")) return "bun";
+	if (files.includes("package-lock.json")) return "npm";
+	return null;
+}
+//#endregion
+//#region src/infra/update-check.ts
+function formatGitInstallLabel(update) {
+	if (update.installKind !== "git") return null;
+	const shortSha = update.git?.sha ? update.git.sha.slice(0, 8) : null;
+	const branch = update.git?.branch && update.git.branch !== "HEAD" ? update.git.branch : null;
+	const tag = update.git?.tag ?? null;
+	return [
+		branch ?? (tag ? "detached" : "git"),
+		tag ? `tag ${tag}` : null,
+		shortSha ? `@ ${shortSha}` : null
+	].filter(Boolean).join(" · ");
+}
+async function exists(p) {
+	try {
+		await fs.access(p);
+		return true;
+	} catch {
+		return false;
+	}
+}
+async function detectPackageManager(root) {
+	return await detectPackageManager$1(root) ?? "unknown";
+}
+async function detectGitRoot(root) {
+	const res = await runCommandWithTimeout([
+		"git",
+		"-C",
+		root,
+		"rev-parse",
+		"--show-toplevel"
+	], { timeoutMs: 4e3 }).catch(() => null);
+	if (!res || res.code !== 0) return null;
+	const top = res.stdout.trim();
+	return top ? path.resolve(top) : null;
+}
+async function checkGitUpdateStatus(params) {
+	const timeoutMs = params.timeoutMs ?? 6e3;
+	const root = path.resolve(params.root);
+	const base = {
+		root,
+		sha: null,
+		tag: null,
+		branch: null,
+		upstream: null,
+		dirty: null,
+		ahead: null,
+		behind: null,
+		fetchOk: null
+	};
+	const [branchRes, shaRes, tagRes, upstreamRes, dirtyRes] = await Promise.all([
+		runCommandWithTimeout([
+			"git",
+			"-C",
+			root,
+			"rev-parse",
+			"--abbrev-ref",
+			"HEAD"
+		], { timeoutMs }).catch(() => null),
+		runCommandWithTimeout([
+			"git",
+			"-C",
+			root,
+			"rev-parse",
+			"HEAD"
+		], { timeoutMs }).catch(() => null),
+		runCommandWithTimeout([
+			"git",
+			"-C",
+			root,
+			"describe",
+			"--tags",
+			"--exact-match"
+		], { timeoutMs }).catch(() => null),
+		runCommandWithTimeout([
+			"git",
+			"-C",
+			root,
+			"rev-parse",
+			"--abbrev-ref",
+			"@{upstream}"
+		], { timeoutMs }).catch(() => null),
+		runCommandWithTimeout([
+			"git",
+			"-C",
+			root,
+			"status",
+			"--porcelain",
+			"--",
+			":!dist/control-ui/"
+		], { timeoutMs }).catch(() => null)
+	]);
+	if (!branchRes || branchRes.code !== 0) return {
+		...base,
+		error: branchRes?.stderr?.trim() || "git unavailable"
+	};
+	const branch = branchRes.stdout.trim() || null;
+	const sha = shaRes && shaRes.code === 0 ? shaRes.stdout.trim() : null;
+	const tag = tagRes && tagRes.code === 0 ? tagRes.stdout.trim() : null;
+	const upstream = upstreamRes && upstreamRes.code === 0 ? upstreamRes.stdout.trim() : null;
+	const dirty = dirtyRes && dirtyRes.code === 0 ? dirtyRes.stdout.trim().length > 0 : null;
+	const fetchOk = params.fetch ? await runCommandWithTimeout([
+		"git",
+		"-C",
+		root,
+		"fetch",
+		"--quiet",
+		"--prune"
+	], { timeoutMs }).then((r) => r.code === 0).catch(() => false) : null;
+	const counts = upstream && upstream.length > 0 ? await runCommandWithTimeout([
+		"git",
+		"-C",
+		root,
+		"rev-list",
+		"--left-right",
+		"--count",
+		`HEAD...${upstream}`
+	], { timeoutMs }).catch(() => null) : null;
+	const parseCounts = (raw) => {
+		const parts = raw.trim().split(/\s+/);
+		if (parts.length < 2) return null;
+		const ahead = Number.parseInt(parts[0] ?? "", 10);
+		const behind = Number.parseInt(parts[1] ?? "", 10);
+		if (!Number.isFinite(ahead) || !Number.isFinite(behind)) return null;
+		return {
+			ahead,
+			behind
+		};
+	};
+	const parsed = counts && counts.code === 0 ? parseCounts(counts.stdout) : null;
+	return {
+		root,
+		sha,
+		tag,
+		branch,
+		upstream,
+		dirty,
+		ahead: parsed?.ahead ?? null,
+		behind: parsed?.behind ?? null,
+		fetchOk
+	};
+}
+async function statMtimeMs(p) {
+	try {
+		return (await fs.stat(p)).mtimeMs;
+	} catch {
+		return null;
+	}
+}
+function resolveDepsMarker(params) {
+	const root = params.root;
+	if (params.manager === "pnpm") return {
+		lockfilePath: path.join(root, "pnpm-lock.yaml"),
+		markerPath: path.join(root, "node_modules", ".modules.yaml")
+	};
+	if (params.manager === "bun") return {
+		lockfilePath: path.join(root, "bun.lockb"),
+		markerPath: path.join(root, "node_modules")
+	};
+	if (params.manager === "npm") return {
+		lockfilePath: path.join(root, "package-lock.json"),
+		markerPath: path.join(root, "node_modules")
+	};
+	return {
+		lockfilePath: null,
+		markerPath: null
+	};
+}
+async function checkDepsStatus(params) {
+	const { lockfilePath, markerPath } = resolveDepsMarker({
+		root: path.resolve(params.root),
+		manager: params.manager
+	});
+	if (!lockfilePath || !markerPath) return {
+		manager: params.manager,
+		status: "unknown",
+		lockfilePath,
+		markerPath,
+		reason: "unknown package manager"
+	};
+	const lockExists = await exists(lockfilePath);
+	const markerExists = await exists(markerPath);
+	if (!lockExists) return {
+		manager: params.manager,
+		status: "unknown",
+		lockfilePath,
+		markerPath,
+		reason: "lockfile missing"
+	};
+	if (!markerExists) return {
+		manager: params.manager,
+		status: "missing",
+		lockfilePath,
+		markerPath,
+		reason: "node_modules marker missing"
+	};
+	const lockMtime = await statMtimeMs(lockfilePath);
+	const markerMtime = await statMtimeMs(markerPath);
+	if (!lockMtime || !markerMtime) return {
+		manager: params.manager,
+		status: "unknown",
+		lockfilePath,
+		markerPath
+	};
+	if (lockMtime > markerMtime + 1e3) return {
+		manager: params.manager,
+		status: "stale",
+		lockfilePath,
+		markerPath,
+		reason: "lockfile newer than install marker"
+	};
+	return {
+		manager: params.manager,
+		status: "ok",
+		lockfilePath,
+		markerPath
+	};
+}
+async function fetchNpmLatestVersion(params) {
+	const res = await fetchNpmTagVersion({
+		tag: "latest",
+		timeoutMs: params?.timeoutMs
+	});
+	return {
+		latestVersion: res.version,
+		error: res.error
+	};
+}
+async function fetchNpmRegistryVersionForChannel(params) {
+	const res = await resolveNpmChannelTag({
+		channel: params.channel,
+		timeoutMs: params.timeoutMs
+	});
+	return {
+		latestVersion: res.version,
+		tag: res.tag
+	};
+}
+async function fetchNpmPackageTargetStatus(params) {
+	const timeoutMs = params.timeoutMs ?? 3500;
+	const target = params.target;
+	try {
+		const res = await fetchWithTimeout(`https://registry.npmjs.org/@gaodefa/daocore/${encodeURIComponent(target)}`, {}, Math.max(250, timeoutMs));
+		if (!res.ok) return {
+			target,
+			version: null,
+			nodeEngine: null,
+			error: `HTTP ${res.status}`
+		};
+		const json = await res.json();
+		return {
+			target,
+			version: typeof json?.version === "string" ? json.version : null,
+			nodeEngine: typeof json?.engines?.node === "string" ? json.engines.node : null
+		};
+	} catch (err) {
+		try {
+			const output = (await import("node:child_process")).execSync("npm view @gaodefa/daocore version", {
+				timeout: Math.max(2e3, timeoutMs),
+				encoding: "utf-8",
+				env: {
+					...process.env,
+					PATH: `${process.env.HOME}/.npm-global/bin:/opt/homebrew/bin:/usr/local/bin:${process.env.PATH || ""}`
+				}
+			}).trim();
+			if (output) return {
+				target,
+				version: output,
+				nodeEngine: null
+			};
+		} catch {}
+		return {
+			target,
+			version: null,
+			nodeEngine: null,
+			error: String(err)
+		};
+	}
+}
+async function fetchNpmTagVersion(params) {
+	const res = await fetchNpmPackageTargetStatus({
+		target: params.tag,
+		timeoutMs: params.timeoutMs
+	});
+	return {
+		tag: params.tag,
+		version: res.version,
+		error: res.error
+	};
+}
+async function resolveNpmChannelTag(params) {
+	const channelTag = channelToNpmTag(params.channel);
+	const channelStatus = await fetchNpmTagVersion({
+		tag: channelTag,
+		timeoutMs: params.timeoutMs
+	});
+	if (params.channel !== "beta") return {
+		tag: channelTag,
+		version: channelStatus.version
+	};
+	const latestStatus = await fetchNpmTagVersion({
+		tag: "latest",
+		timeoutMs: params.timeoutMs
+	});
+	if (!latestStatus.version) return {
+		tag: channelTag,
+		version: channelStatus.version
+	};
+	if (!channelStatus.version) return {
+		tag: "latest",
+		version: latestStatus.version
+	};
+	const cmp = compareSemverStrings(channelStatus.version, latestStatus.version);
+	if (cmp != null && cmp < 0) return {
+		tag: "latest",
+		version: latestStatus.version
+	};
+	return {
+		tag: channelTag,
+		version: channelStatus.version
+	};
+}
+function compareSemverStrings(a, b) {
+	if (a && b) {
+		const openClawReleaseCmp = compareDaoCoreReleaseVersions(a, b);
+		if (openClawReleaseCmp != null) return openClawReleaseCmp;
+	}
+	return compareComparableSemver(parseComparableSemver(a, { normalizeLegacyDotBeta: true }), parseComparableSemver(b, { normalizeLegacyDotBeta: true }));
+}
+async function checkUpdateStatus(params) {
+	const timeoutMs = params.timeoutMs ?? 6e3;
+	const fetchRegistry = () => params.registryChannel ? fetchNpmRegistryVersionForChannel({
+		channel: params.registryChannel,
+		timeoutMs
+	}) : fetchNpmLatestVersion({ timeoutMs });
+	const root = params.root ? path.resolve(params.root) : null;
+	if (!root) return {
+		root: null,
+		installKind: "unknown",
+		packageManager: "unknown",
+		registry: params.includeRegistry ? await fetchRegistry() : void 0
+	};
+	const rootRealpath = await fs.realpath(root).catch(() => root);
+	const [pm, gitRoot, registry] = await Promise.all([
+		detectPackageManager(root),
+		detectGitRoot(root),
+		params.includeRegistry ? fetchRegistry() : Promise.resolve(void 0)
+	]);
+	const isGit = gitRoot && path.resolve(gitRoot) === path.resolve(rootRealpath);
+	const installKind = isGit ? "git" : "package";
+	const [git, deps] = await Promise.all([isGit ? checkGitUpdateStatus({
+		root,
+		timeoutMs,
+		fetch: Boolean(params.fetchGit)
+	}) : Promise.resolve(void 0), checkDepsStatus({
+		root,
+		manager: pm
+	})]);
+	return {
+		root,
+		installKind,
+		packageManager: pm,
+		git,
+		deps,
+		registry
+	};
+}
+//#endregion
+export { formatGitInstallLabel as a, fetchNpmTagVersion as i, compareSemverStrings as n, resolveNpmChannelTag as o, fetchNpmPackageTargetStatus as r, detectPackageManager$1 as s, checkUpdateStatus as t };