@nextclaw/service 0.1.1

package/dist/cli/commands/usage/services/llm-usage-query.service.js

@@ -0,0 +1,85 @@
+import { LlmUsageStore } from "@nextclaw/kernel";
+//#region src/cli/commands/usage/services/llm-usage-query.service.ts
+var LlmUsageQueryService = class {
+	store;
+	constructor(deps = {}) {
+		this.store = deps.store ?? new LlmUsageStore();
+	}
+	get snapshotPath() {
+		return this.store.snapshotPath;
+	}
+	get historyPath() {
+		return this.store.historyPath;
+	}
+	getSnapshot = () => {
+		return this.store.readSnapshot();
+	};
+	getHistory = (limit) => {
+		const records = this.store.listHistory();
+		const resolvedLimit = this.resolveLimit(limit);
+		return records.slice(-resolvedLimit).reverse();
+	};
+	getStats = () => {
+		const records = this.store.listHistory();
+		const sources = /* @__PURE__ */ new Map();
+		const models = /* @__PURE__ */ new Map();
+		let totalPromptTokens = 0;
+		let totalCompletionTokens = 0;
+		let totalTokens = 0;
+		let totalCachedTokens = 0;
+		let cacheHitRecords = 0;
+		let usageRecordCount = 0;
+		let promptTokenRecordCount = 0;
+		for (const record of records) {
+			if (Object.keys(record.usage).length > 0) usageRecordCount += 1;
+			totalPromptTokens += record.summary.promptTokens;
+			totalCompletionTokens += record.summary.completionTokens;
+			totalTokens += record.summary.totalTokens;
+			totalCachedTokens += record.summary.cachedTokens;
+			if (record.summary.promptTokens > 0) promptTokenRecordCount += 1;
+			if (record.summary.cacheHit) cacheHitRecords += 1;
+			this.bumpCounter(sources, record.source);
+			this.bumpCounter(models, record.model ?? "unknown");
+		}
+		return {
+			totalRecords: records.length,
+			usageRecordCount,
+			emptyUsageRecordCount: records.length - usageRecordCount,
+			promptTokenRecordCount,
+			oldestObservedAt: records[0]?.observedAt ?? null,
+			latestObservedAt: records.at(-1)?.observedAt ?? null,
+			totalPromptTokens,
+			totalCompletionTokens,
+			totalTokens,
+			totalCachedTokens,
+			cacheHitRecords,
+			cacheHitRate: promptTokenRecordCount > 0 ? cacheHitRecords / promptTokenRecordCount : 0,
+			tokenCacheRate: totalPromptTokens > 0 ? totalCachedTokens / totalPromptTokens : 0,
+			sources: this.toSortedCounts(sources),
+			models: this.toSortedCounts(models)
+		};
+	};
+	resolveLimit = (value) => {
+		if (typeof value === "number" && Number.isFinite(value) && value > 0) return Math.floor(value);
+		if (typeof value === "string" && value.trim().length > 0) {
+			const parsed = Number(value);
+			if (Number.isFinite(parsed) && parsed > 0) return Math.floor(parsed);
+		}
+		return 10;
+	};
+	bumpCounter = (map, value) => {
+		map.set(value, (map.get(value) ?? 0) + 1);
+	};
+	toSortedCounts = (map) => {
+		return [...map.entries()].map(([value, count]) => ({
+			value,
+			count
+		})).sort((left, right) => {
+			if (right.count !== left.count) return right.count - left.count;
+			return left.value.localeCompare(right.value);
+		});
+	};
+};
+const llmUsageQueryService = new LlmUsageQueryService();
+//#endregion
+export { LlmUsageQueryService, llmUsageQueryService };

package/dist/commands/channel/channel-config-view.d.ts

@@ -0,0 +1,7 @@
+import { Config } from "@nextclaw/core";
+import { PluginChannelBinding } from "@nextclaw/openclaw-compat";
+
+//#region src/commands/channel/channel-config-view.d.ts
+declare function resolveChannelConfigView(config: Config, bindings: PluginChannelBinding[]): Config;
+//#endregion
+export { resolveChannelConfigView };

package/dist/commands/channel/channel-config-view.js

@@ -0,0 +1,7 @@
+import { toPluginConfigView } from "@nextclaw/openclaw-compat";
+//#region src/commands/channel/channel-config-view.ts
+function resolveChannelConfigView(config, bindings) {
+	return toPluginConfigView(config, bindings);
+}
+//#endregion
+export { resolveChannelConfigView };

package/dist/commands/channel/index.d.ts

@@ -0,0 +1,28 @@
+import { ChannelsAddOptions, ChannelsLoginOptions, RequestRestartParams } from "../../shared/types/cli.types.js";
+import { resolveChannelConfigView } from "./channel-config-view.js";
+
+//#region src/commands/channel/index.d.ts
+declare class ChannelCommands {
+  private deps;
+  constructor(deps: {
+    logo: string;
+    getBridgeDir: () => string;
+    requestRestart: (params: RequestRestartParams) => Promise<void>;
+  });
+  status: () => void;
+  login: (opts?: ChannelsLoginOptions) => Promise<void>;
+  private runLegacyBridgeLogin;
+  private resolvePluginChannelContext;
+  private loginPluginChannel;
+  private clonePluginConfig;
+  private assertValidPluginLoginResult;
+  private buildNextConfigAfterChannelLogin;
+  private printPluginChannelLoginResult;
+  add: (opts: ChannelsAddOptions) => Promise<void>;
+  private requireChannelId;
+  private resolveRequiredChannelBinding;
+  private resolveRequiredChannelSetup;
+  private buildChannelSetupInput;
+}
+//#endregion
+export { ChannelCommands, resolveChannelConfigView };

package/dist/commands/channel/index.js

@@ -0,0 +1,224 @@
+import { resolveChannelConfigView } from "./channel-config-view.js";
+import { loadPluginRegistry, mergePluginConfigView, toPluginConfigView as toPluginConfigView$1 } from "../plugin/index.js";
+import { spawnSync } from "node:child_process";
+import { getWorkspacePath, loadConfig, saveConfig } from "@nextclaw/core";
+import { buildPluginStatusReport, enablePluginInConfig, getPluginChannelBindings } from "@nextclaw/openclaw-compat";
+import { BUILTIN_CHANNEL_PLUGIN_IDS, builtinProviderIds } from "@nextclaw/runtime";
+//#region src/commands/channel/index.ts
+const CHANNEL_LABELS = {
+	telegram: "Telegram",
+	whatsapp: "WhatsApp",
+	discord: "Discord",
+	feishu: "Feishu",
+	mochat: "Mochat",
+	dingtalk: "DingTalk",
+	wecom: "WeCom",
+	email: "Email",
+	slack: "Slack",
+	qq: "QQ",
+	weixin: "Weixin"
+};
+const RESERVED_PROVIDER_IDS = builtinProviderIds();
+function resolveChannelBindings(pluginRegistry) {
+	return getPluginChannelBindings(pluginRegistry);
+}
+var ChannelCommands = class {
+	constructor(deps) {
+		this.deps = deps;
+	}
+	status = () => {
+		const config = loadConfig();
+		const workspaceDir = getWorkspacePath(config.agents.defaults.workspace);
+		const channelConfig = resolveChannelConfigView(config, resolveChannelBindings(loadPluginRegistry(config, workspaceDir)));
+		console.log("Channel Status");
+		const channels = channelConfig.channels;
+		for (const channelId of BUILTIN_CHANNEL_PLUGIN_IDS) {
+			const label = CHANNEL_LABELS[channelId] ?? channelId;
+			const enabled = channels[channelId]?.enabled === true;
+			console.log(`${label}: ${enabled ? "✓" : "✗"}`);
+		}
+		const pluginChannels = buildPluginStatusReport({
+			config,
+			workspaceDir,
+			reservedChannelIds: [],
+			reservedProviderIds: RESERVED_PROVIDER_IDS
+		}).plugins.filter((plugin) => plugin.status === "loaded" && plugin.channelIds.length > 0);
+		if (pluginChannels.length > 0) {
+			console.log("Plugin Channels:");
+			for (const plugin of pluginChannels) {
+				const channels = plugin.channelIds.join(", ");
+				console.log(`- ${channels} (plugin: ${plugin.id})`);
+			}
+		}
+	};
+	login = async (opts = {}) => {
+		const channelId = opts.channel?.trim();
+		if (!channelId) {
+			this.runLegacyBridgeLogin();
+			return;
+		}
+		const config = loadConfig();
+		const channelContext = this.resolvePluginChannelContext(config, channelId);
+		if (!channelContext) {
+			console.error(`No plugin channel found for: ${channelId}`);
+			process.exit(1);
+		}
+		const result = await this.loginPluginChannel(config, channelContext, opts);
+		if (!result) return;
+		saveConfig(this.buildNextConfigAfterChannelLogin(config, channelContext.binding, result));
+		this.printPluginChannelLoginResult(channelContext.binding, result);
+		await this.deps.requestRestart({
+			mode: "notify",
+			reason: `channel login via plugin: ${channelContext.binding.pluginId}`,
+			manualMessage: "渠道配置已保存，等待你手动重启后生效。"
+		});
+	};
+	runLegacyBridgeLogin = () => {
+		const bridgeDir = this.deps.getBridgeDir();
+		console.log(`${this.deps.logo} Starting bridge...`);
+		console.log("Scan the QR code to connect.\n");
+		const result = spawnSync("npm", ["start"], {
+			cwd: bridgeDir,
+			stdio: "inherit"
+		});
+		if (result.status !== 0) console.error(`Bridge failed: ${result.status ?? 1}`);
+	};
+	resolvePluginChannelContext = (config, channelId) => {
+		const bindings = resolveChannelBindings(loadPluginRegistry(config, getWorkspacePath(config.agents.defaults.workspace)));
+		const binding = bindings.find((entry) => entry.channelId === channelId || entry.pluginId === channelId);
+		if (!binding) return null;
+		return {
+			binding,
+			bindings
+		};
+	};
+	loginPluginChannel = async (config, channelContext, opts) => {
+		const { binding, bindings } = channelContext;
+		const login = binding.channel.auth?.login;
+		if (!login) {
+			if (binding.channelId === "whatsapp") {
+				this.runLegacyBridgeLogin();
+				return null;
+			}
+			console.error(`Channel "${binding.channelId}" does not support login.`);
+			process.exit(1);
+		}
+		const configView = resolveChannelConfigView(config, bindings);
+		const result = await login({
+			cfg: configView,
+			pluginId: binding.pluginId,
+			channelId: binding.channelId,
+			pluginConfig: this.clonePluginConfig(configView.channels?.[binding.channelId]),
+			accountId: opts.account?.trim() || null,
+			baseUrl: opts.url?.trim() || opts.httpUrl?.trim() || null,
+			verbose: Boolean(opts.verbose)
+		});
+		this.assertValidPluginLoginResult(result);
+		return result;
+	};
+	clonePluginConfig = (value) => {
+		if (!value || typeof value !== "object" || Array.isArray(value)) return;
+		return JSON.parse(JSON.stringify(value));
+	};
+	assertValidPluginLoginResult = (result) => {
+		if (!result || typeof result !== "object" || Array.isArray(result)) {
+			console.error("Channel login returned an invalid result.");
+			process.exit(1);
+		}
+		const record = result;
+		if (!record.pluginConfig || typeof record.pluginConfig !== "object" || Array.isArray(record.pluginConfig)) {
+			console.error("Channel login returned an invalid plugin config.");
+			process.exit(1);
+		}
+	};
+	buildNextConfigAfterChannelLogin = (config, binding, result) => {
+		return enablePluginInConfig({
+			...config,
+			channels: {
+				...config.channels,
+				[binding.channelId]: result.pluginConfig
+			}
+		}, binding.pluginId);
+	};
+	printPluginChannelLoginResult = (binding, result) => {
+		console.log(`Logged into channel "${binding.channelId}" via plugin "${binding.pluginId}".`);
+		if (result.accountId) console.log(`Active account: ${result.accountId}`);
+		for (const note of result.notes ?? []) console.log(note);
+	};
+	add = async (opts) => {
+		const channelId = this.requireChannelId(opts);
+		const config = loadConfig();
+		const pluginRegistry = loadPluginRegistry(config, getWorkspacePath(config.agents.defaults.workspace));
+		const { binding, bindings } = this.resolveRequiredChannelBinding(pluginRegistry, channelId);
+		const setup = this.resolveRequiredChannelSetup(binding);
+		const input = this.buildChannelSetupInput(opts);
+		const currentView = toPluginConfigView$1(config, bindings);
+		const accountId = binding.channel.config?.defaultAccountId?.(currentView) ?? "default";
+		const validateError = setup.validateInput?.({
+			cfg: currentView,
+			input,
+			accountId
+		});
+		if (validateError) {
+			console.error(`Channel setup validation failed: ${validateError}`);
+			process.exit(1);
+		}
+		const nextView = setup.applyAccountConfig({
+			cfg: currentView,
+			input,
+			accountId
+		});
+		if (!nextView || typeof nextView !== "object" || Array.isArray(nextView)) {
+			console.error("Channel setup returned invalid config payload.");
+			process.exit(1);
+		}
+		let next = mergePluginConfigView(config, nextView, bindings);
+		next = enablePluginInConfig(next, binding.pluginId);
+		saveConfig(next);
+		console.log(`Configured channel "${binding.channelId}" via plugin "${binding.pluginId}".`);
+		await this.deps.requestRestart({
+			mode: "notify",
+			reason: `channel configured via plugin: ${binding.pluginId}`,
+			manualMessage: "渠道配置已保存，等待你手动重启后生效。"
+		});
+	};
+	requireChannelId = (opts) => {
+		const channelId = opts.channel?.trim();
+		if (!channelId) {
+			console.error("--channel is required");
+			process.exit(1);
+		}
+		return channelId;
+	};
+	resolveRequiredChannelBinding = (pluginRegistry, channelId) => {
+		const bindings = resolveChannelBindings(pluginRegistry);
+		const binding = bindings.find((entry) => entry.channelId === channelId || entry.pluginId === channelId);
+		if (!binding) {
+			console.error(`No plugin channel found for: ${channelId}`);
+			process.exit(1);
+		}
+		return {
+			binding,
+			bindings
+		};
+	};
+	resolveRequiredChannelSetup = (binding) => {
+		const setup = binding.channel.setup;
+		if (!setup?.applyAccountConfig) {
+			console.error(`Channel "${binding.channelId}" does not support setup.`);
+			process.exit(1);
+		}
+		return setup;
+	};
+	buildChannelSetupInput = (opts) => {
+		return {
+			name: opts.name,
+			token: opts.token,
+			code: opts.code,
+			url: opts.url,
+			httpUrl: opts.httpUrl
+		};
+	};
+};
+//#endregion
+export { ChannelCommands, resolveChannelConfigView };

package/dist/commands/platform-auth/index.d.ts

@@ -0,0 +1,2 @@
+import { PlatformAuthCommands, PlatformBrowserAuthPollResult, PlatformBrowserAuthStartResult, PlatformLoginResult, PlatformMeResult, PlatformUserView } from "./services/platform-auth-commands.service.js";
+export { PlatformAuthCommands, PlatformBrowserAuthPollResult, PlatformBrowserAuthStartResult, PlatformLoginResult, PlatformMeResult, PlatformUserView };

package/dist/commands/platform-auth/index.js

@@ -0,0 +1,2 @@
+import { PlatformAuthCommands } from "./services/platform-auth-commands.service.js";
+export { PlatformAuthCommands };

package/dist/commands/platform-auth/services/account-status.service.d.ts

@@ -0,0 +1,18 @@
+import { PlatformMeResult } from "./platform-auth-commands.service.js";
+//#region src/commands/platform-auth/services/account-status.service.d.ts
+type AccountStatusView = {
+  email: string;
+  role: string;
+  username: string | null;
+  platformBase: string;
+  v1Base: string;
+  publishReadiness: "ready" | "needs_username";
+  personalScope: string | null;
+  nextClawWebAccountUrl: string;
+  cliSetUsernameCommand: string;
+};
+declare function toAccountStatusView(result: PlatformMeResult): AccountStatusView;
+declare function printAccountStatus(view: AccountStatusView): void;
+declare function printUsernameUpdated(view: AccountStatusView): void;
+//#endregion
+export { AccountStatusView, printAccountStatus, printUsernameUpdated, toAccountStatusView };

package/dist/commands/platform-auth/services/account-status.service.js

@@ -0,0 +1,34 @@
+//#region src/commands/platform-auth/services/account-status.service.ts
+const NEXTCLAW_WEB_ACCOUNT_URL = "https://platform.nextclaw.io/account";
+const ACCOUNT_SET_USERNAME_HELP = "nextclaw account set-username <username>";
+function toAccountStatusView(result) {
+	const username = result.user.username?.trim() || null;
+	return {
+		email: result.user.email,
+		role: result.user.role,
+		username,
+		platformBase: result.platformBase,
+		v1Base: result.v1Base,
+		publishReadiness: username ? "ready" : "needs_username",
+		personalScope: username ? `@${username}/*` : null,
+		nextClawWebAccountUrl: NEXTCLAW_WEB_ACCOUNT_URL,
+		cliSetUsernameCommand: ACCOUNT_SET_USERNAME_HELP
+	};
+}
+function printAccountStatus(view) {
+	console.log("NextClaw account status");
+	console.log(`Email: ${view.email}`);
+	console.log(`Role: ${view.role}`);
+	console.log(`Username: ${view.username ?? "(not set)"}`);
+	console.log(`Publish readiness: ${view.publishReadiness === "ready" ? "ready" : "action required - username missing"}`);
+	console.log(`Personal scope: ${view.personalScope ?? "(blocked until username is set)"}`);
+	console.log(`NextClaw Web account settings: ${view.nextClawWebAccountUrl}`);
+	console.log(`CLI fallback: ${view.cliSetUsernameCommand}`);
+}
+function printUsernameUpdated(view) {
+	console.log(`✓ Username saved: ${view.username}`);
+	console.log(`✓ Personal publish scope: ${view.personalScope}`);
+	console.log(`✓ NextClaw Web account settings: ${view.nextClawWebAccountUrl}`);
+}
+//#endregion
+export { printAccountStatus, printUsernameUpdated, toAccountStatusView };

package/dist/commands/platform-auth/services/platform-auth-commands.service.d.ts

@@ -0,0 +1,77 @@
+import { AccountCommandOptions, AccountSetUsernameCommandOptions, LoginCommandOptions } from "../../../shared/types/cli.types.js";
+
+//#region src/commands/platform-auth/services/platform-auth-commands.service.d.ts
+type PlatformLoginResult = {
+  token: string;
+  role: string;
+  email: string;
+  platformBase: string;
+  v1Base: string;
+};
+type PlatformUserView = {
+  id: string;
+  email: string;
+  username: string | null;
+  role: string;
+};
+type PlatformMeResult = {
+  user: PlatformUserView;
+  token: string;
+  platformBase: string;
+  v1Base: string;
+};
+type PlatformBrowserAuthStartResult = {
+  sessionId: string;
+  verificationUri: string;
+  expiresAt: string;
+  intervalMs: number;
+  platformBase: string;
+  v1Base: string;
+};
+type PlatformBrowserAuthPollResult = {
+  status: "pending";
+  nextPollMs: number;
+} | {
+  status: "authorized";
+  token: string;
+  role: string;
+  email: string;
+  platformBase: string;
+  v1Base: string;
+} | {
+  status: "expired";
+  message: string;
+};
+declare class PlatformAuthCommands {
+  private shouldUseBrowserLogin;
+  private waitFor;
+  private formatLoginDeadline;
+  private printLoginSuccess;
+  private printBrowserLoginIntro;
+  private waitForBrowserLoginResult;
+  private loginWithBrowserResult;
+  private readStoredToken;
+  loginResult: (opts?: LoginCommandOptions) => Promise<PlatformLoginResult>;
+  startBrowserAuth: (opts?: Pick<LoginCommandOptions, "apiBase">) => Promise<PlatformBrowserAuthStartResult>;
+  pollBrowserAuth: (params: {
+    apiBase?: string;
+    sessionId: string;
+  }) => Promise<PlatformBrowserAuthPollResult>;
+  login: (opts?: LoginCommandOptions) => Promise<void>;
+  me: (params?: {
+    apiBase?: string;
+  }) => Promise<PlatformMeResult>;
+  updateProfile: (params: {
+    username: string;
+    apiBase?: string;
+  }) => Promise<PlatformMeResult>;
+  logout: () => {
+    cleared: boolean;
+  };
+  accountStatus: (opts?: AccountCommandOptions) => Promise<void>;
+  accountSetUsername: (opts: AccountSetUsernameCommandOptions & {
+    username: string;
+  }) => Promise<void>;
+}
+//#endregion
+export { PlatformAuthCommands, PlatformBrowserAuthPollResult, PlatformBrowserAuthStartResult, PlatformLoginResult, PlatformMeResult, PlatformUserView };