@nextclaw/service 0.1.11 → 0.1.12

package/dist/shared/services/extensions/extension-lifecycle.service.js

@@ -1,174 +0,0 @@
-import { readFileSync, readdirSync } from "node:fs";
-import { dirname, join } from "node:path";
-import { spawn } from "node:child_process";
-import { readFile, readdir } from "node:fs/promises";
-//#region src/shared/services/extensions/extension-lifecycle.service.ts
-const EXTENSION_MANIFEST_FILE = "nextclaw.extension.json";
-function readString(value) {
-	return typeof value === "string" && value.trim() ? value.trim() : void 0;
-}
-function readStringArray(value) {
-	if (!Array.isArray(value)) return;
-	return value.every((item) => typeof item === "string") ? value : void 0;
-}
-function readStringRecord(value) {
-	if (!value || typeof value !== "object" || Array.isArray(value)) return;
-	const entries = Object.entries(value);
-	if (!entries.every(([, item]) => typeof item === "string")) return;
-	return Object.fromEntries(entries);
-}
-function sanitizeExtensionNodeOptions(value) {
-	if (!value?.trim()) return;
-	const tokens = value.split(/\s+/).filter(Boolean);
-	const sanitized = [];
-	for (let index = 0; index < tokens.length; index += 1) {
-		const token = tokens[index];
-		if (token === "--conditions=development" || token === "-C=development") continue;
-		if ((token === "--conditions" || token === "-C") && tokens[index + 1] === "development") {
-			index += 1;
-			continue;
-		}
-		sanitized.push(token);
-	}
-	return sanitized.length > 0 ? sanitized.join(" ") : void 0;
-}
-function toManifest(value, rootDir) {
-	if (!value || typeof value !== "object" || Array.isArray(value)) throw new Error("extension manifest must be an object");
-	const record = value;
-	const server = record.server;
-	if (!server || typeof server !== "object" || Array.isArray(server)) throw new Error("extension manifest server is required");
-	const serverRecord = server;
-	const id = readString(record.id);
-	const command = readString(serverRecord.command);
-	if (!id) throw new Error("extension manifest id is required");
-	if (serverRecord.type !== "stdio") throw new Error("extension server.type must be stdio");
-	if (!command) throw new Error("extension server.command is required");
-	return {
-		id,
-		rootDir,
-		...readString(record.name) ? { name: readString(record.name) } : {},
-		...readString(record.version) ? { version: readString(record.version) } : {},
-		server: {
-			type: "stdio",
-			command,
-			...readStringArray(serverRecord.args) ? { args: readStringArray(serverRecord.args) } : {},
-			...readStringRecord(serverRecord.env) ? { env: readStringRecord(serverRecord.env) } : {}
-		},
-		...record.contributes && typeof record.contributes === "object" && !Array.isArray(record.contributes) ? { contributes: record.contributes } : {}
-	};
-}
-var ExtensionManifestDiscoveryService = class {
-	discover = async (roots) => {
-		const manifests = [];
-		for (const root of roots) manifests.push(...await this.discoverRoot(root));
-		return manifests;
-	};
-	discoverSync = (roots) => {
-		const manifests = [];
-		for (const root of roots) manifests.push(...this.discoverRootSync(root));
-		return manifests;
-	};
-	discoverRoot = async (root) => {
-		const directManifest = await this.readManifestIfExists(join(root, EXTENSION_MANIFEST_FILE));
-		if (directManifest) return [directManifest];
-		const entries = await readdir(root, { withFileTypes: true }).catch(() => []);
-		return (await Promise.all(entries.filter((entry) => entry.isDirectory()).map((entry) => this.readManifestIfExists(join(root, entry.name, EXTENSION_MANIFEST_FILE))))).filter((manifest) => Boolean(manifest));
-	};
-	discoverRootSync = (root) => {
-		const directManifest = this.readManifestIfExistsSync(join(root, EXTENSION_MANIFEST_FILE));
-		if (directManifest) return [directManifest];
-		return this.readDirectoriesSync(root).map((entry) => this.readManifestIfExistsSync(join(root, entry, EXTENSION_MANIFEST_FILE))).filter((manifest) => Boolean(manifest));
-	};
-	readManifestIfExists = async (path) => {
-		try {
-			return toManifest(JSON.parse(await readFile(path, "utf-8")), dirname(path));
-		} catch (error) {
-			if (error.code === "ENOENT") return null;
-			throw error;
-		}
-	};
-	readManifestIfExistsSync = (path) => {
-		try {
-			return toManifest(JSON.parse(readFileSync(path, "utf-8")), dirname(path));
-		} catch (error) {
-			if (error.code === "ENOENT") return null;
-			throw error;
-		}
-	};
-	readDirectoriesSync = (root) => {
-		try {
-			return readdirSync(root, { withFileTypes: true }).filter((entry) => entry.isDirectory()).map((entry) => entry.name);
-		} catch {
-			return [];
-		}
-	};
-};
-var ExtensionLifecycleService = class {
-	processes = /* @__PURE__ */ new Map();
-	spawnProcess;
-	logger;
-	constructor(options) {
-		this.options = options;
-		this.spawnProcess = options.spawnProcess ?? spawn;
-		this.logger = options.logger ?? console;
-	}
-	startAll = async (manifests) => {
-		const started = [];
-		for (const manifest of manifests) try {
-			started.push(this.start(manifest));
-		} catch (error) {
-			this.logger.warn(`Extension ${manifest.id} failed to start: ${error instanceof Error ? error.message : String(error)}`);
-		}
-		return started;
-	};
-	start = (manifest) => {
-		const existing = this.processes.get(manifest.id);
-		if (existing) return existing;
-		const child = this.spawnProcess(manifest.server.command === "node" || manifest.server.command === "node.exe" ? process.execPath : manifest.server.command, manifest.server.args ?? [], {
-			cwd: manifest.rootDir,
-			env: {
-				...process.env,
-				NODE_OPTIONS: sanitizeExtensionNodeOptions(process.env.NODE_OPTIONS),
-				...manifest.server.env,
-				NEXTCLAW_EXTENSION_ID: manifest.id,
-				NEXTCLAW_EXTENSION_ENDPOINT: this.options.endpoint,
-				NEXTCLAW_EXTENSION_TOKEN: this.options.token
-			},
-			stdio: [
-				"ignore",
-				"ignore",
-				"inherit"
-			],
-			windowsHide: true
-		});
-		const running = {
-			manifest,
-			process: child
-		};
-		this.processes.set(manifest.id, running);
-		child.once("exit", () => {
-			if (this.processes.get(manifest.id)?.process === child) this.processes.delete(manifest.id);
-			this.logger.warn(`Extension ${manifest.id} exited.`);
-		});
-		child.once("error", (error) => {
-			this.logger.warn(`Extension ${manifest.id} failed: ${error.message}`);
-		});
-		return running;
-	};
-	stopAll = async () => {
-		const running = Array.from(this.processes.values());
-		this.processes.clear();
-		await Promise.all(running.map((entry) => this.stopProcess(entry.process)));
-	};
-	list = () => Array.from(this.processes.values());
-	stopProcess = async (child) => {
-		if (child.exitCode !== null || child.signalCode !== null) return;
-		await new Promise((resolve) => {
-			child.once("exit", () => resolve());
-			child.kill();
-			setTimeout(resolve, 1e3).unref();
-		});
-	};
-};
-//#endregion
-export { ExtensionLifecycleService, ExtensionManifestDiscoveryService };

package/dist/shared/services/extensions/service-extension-runtime.service.d.ts

@@ -1,52 +0,0 @@
-import { ExtensionLifecycleService, ExtensionManifestDiscoveryService, RunningExtensionProcess } from "./extension-lifecycle.service.js";
-import { NextclawGatewayRuntime } from "../gateway/nextclaw-gateway-runtime.service.js";
-import * as NextclawCore from "@nextclaw/core";
-import { PluginChannelBinding, PluginUiMetadata } from "@nextclaw/openclaw-compat";
-import { Ingress } from "@nextclaw/shared";
-
-//#region src/shared/services/extensions/service-extension-runtime.service.d.ts
-type Config$1 = NextclawCore.Config;
-type ExtensionRuntimeContributions = {
-  channelBindings: PluginChannelBinding[];
-  uiMetadata: PluginUiMetadata[];
-};
-declare function resolveBuiltinExtensionManifestRoots(): string[];
-declare function resolveExtensionManifestRoots(params: {
-  config: Config$1;
-  workspace: string;
-}): string[];
-declare function startDiscoveredExtensions(params: {
-  config: Config$1;
-  workspace: string;
-  endpoint: string;
-  token: string;
-  discovery?: ExtensionManifestDiscoveryService;
-  lifecycle?: ExtensionLifecycleService;
-}): Promise<{
-  lifecycle: ExtensionLifecycleService;
-  running: RunningExtensionProcess[];
-}>;
-declare class ServiceExtensionRuntime {
-  private readonly gateway;
-  readonly token: `${string}-${string}-${string}-${string}-${string}`;
-  private lifecycle;
-  private manifests;
-  private readonly pendingRequests;
-  constructor(gateway: NextclawGatewayRuntime);
-  readonly registerIngressHandlers: (ingress: Ingress) => void;
-  readonly loadContributions: () => Promise<ExtensionRuntimeContributions>;
-  readonly start: () => Promise<void>;
-  readonly stop: () => Promise<void>;
-  private readonly handleChannelConfigGet;
-  private readonly handleChannelMessageSubmit;
-  private readonly handleExtensionResponse;
-  private readonly discoverManifests;
-  private readonly toContributions;
-  private readonly readConfigUiHints;
-  private readonly createChannelAuth;
-  private readonly createChannelOutbound;
-  private readonly requestExtension;
-  private readonly assertAuthorized;
-}
-//#endregion
-export { ServiceExtensionRuntime, resolveBuiltinExtensionManifestRoots, resolveExtensionManifestRoots, startDiscoveredExtensions };

package/dist/shared/services/extensions/service-extension-runtime.service.js

@@ -1,325 +0,0 @@
-import { resolveDevFirstPartyPluginDir } from "../../../commands/plugin/development-source/first-party-plugin-load-paths.utils.js";
-import { ExtensionLifecycleService, ExtensionManifestDiscoveryService } from "./extension-lifecycle.service.js";
-import { createRequire } from "node:module";
-import { getDataPath } from "@nextclaw/core";
-import { existsSync, readFileSync } from "node:fs";
-import { dirname, join, resolve } from "node:path";
-import { fileURLToPath } from "node:url";
-import { randomUUID } from "node:crypto";
-//#region src/shared/services/extensions/service-extension-runtime.service.ts
-const EXTENSION_CONFIG_GET_INGRESS_TYPE = "extension.channel.config.get";
-const EXTENSION_MESSAGE_SUBMIT_INGRESS_TYPE = "extension.channel.message.submit";
-const EXTENSION_REQUEST_EVENT_TYPE = "extension.request";
-const EXTENSION_RESPONSE_INGRESS_TYPE = "extension.response";
-const serviceRequire = createRequire(import.meta.url);
-const EXTENSION_REQUEST_TIMEOUT_MS = 6e4;
-var ExtensionChannelClient = class {
-	constructor(params) {
-		this.params = params;
-	}
-	login = async ({ accountId, baseUrl, verbose }) => await this.params.request({
-		extensionId: this.params.extensionId,
-		kind: "channel.auth.login",
-		payload: {
-			channelId: this.params.channelId,
-			accountId,
-			baseUrl,
-			verbose
-		}
-	});
-	start = async (params) => await this.params.request({
-		extensionId: this.params.extensionId,
-		kind: "channel.auth.start",
-		payload: {
-			channelId: this.params.channelId,
-			accountId: params.accountId,
-			baseUrl: params.baseUrl,
-			domain: params.domain
-		}
-	});
-	poll = async ({ sessionId }) => await this.params.request({
-		extensionId: this.params.extensionId,
-		kind: "channel.auth.poll",
-		payload: {
-			channelId: this.params.channelId,
-			sessionId
-		}
-	});
-	sendText = async ({ to, text, accountId }) => await this.params.request({
-		extensionId: this.params.extensionId,
-		kind: "channel.outbound.sendText",
-		payload: {
-			channelId: this.params.channelId,
-			to,
-			text,
-			accountId
-		}
-	});
-};
-function uniquePaths(paths) {
-	const seen = /* @__PURE__ */ new Set();
-	const unique = [];
-	for (const path of paths) {
-		const normalized = resolve(path);
-		if (seen.has(normalized)) continue;
-		seen.add(normalized);
-		unique.push(normalized);
-	}
-	return unique;
-}
-function findExtensionManifestRoot(startPath) {
-	let current = resolve(startPath);
-	while (true) {
-		if (existsSync(join(current, "nextclaw.extension.json"))) return current;
-		const parent = dirname(current);
-		if (parent === current) return;
-		current = parent;
-	}
-}
-function readBuiltinExtensionPackages() {
-	if (process.env.NEXTCLAW_DISABLE_BUILTIN_EXTENSIONS === "1") return [];
-	const packageJsonPath = resolve(dirname(fileURLToPath(import.meta.url)), "../../../..", "package.json");
-	try {
-		const packages = JSON.parse(readFileSync(packageJsonPath, "utf-8")).nextclaw?.builtinExtensions;
-		return Array.isArray(packages) ? packages.filter((entry) => typeof entry === "string" && entry.trim().length > 0) : [];
-	} catch {
-		return [];
-	}
-}
-function resolveBuiltinExtensionManifestRoots() {
-	const roots = [];
-	for (const packageName of readBuiltinExtensionPackages()) try {
-		const root = findExtensionManifestRoot(dirname(serviceRequire.resolve(packageName)));
-		if (root) roots.push(root);
-	} catch {}
-	return uniquePaths(roots);
-}
-function readRecord(value) {
-	return value && typeof value === "object" && !Array.isArray(value) ? value : {};
-}
-function readRequiredString(value, name) {
-	if (typeof value !== "string" || !value.trim()) throw new Error(`${name} is required`);
-	return value.trim();
-}
-function readTextContent(value) {
-	const content = readRecord(value);
-	if (content.type !== "text" || typeof content.text !== "string") throw new Error("only text channel messages are supported by the first ingress bridge");
-	return content.text;
-}
-function readOptionalString(value) {
-	if (typeof value !== "string") return;
-	return value.trim() || void 0;
-}
-function readOptionalNumber(value) {
-	return typeof value === "number" && Number.isFinite(value) ? value : void 0;
-}
-function readInboundAttachments(value) {
-	if (!Array.isArray(value)) return [];
-	return value.filter((entry) => Boolean(entry && typeof entry === "object" && !Array.isArray(entry))).map((entry) => ({
-		...readOptionalString(entry.id) ? { id: readOptionalString(entry.id) } : {},
-		...readOptionalString(entry.name) ? { name: readOptionalString(entry.name) } : {},
-		...readOptionalString(entry.path) ? { path: readOptionalString(entry.path) } : {},
-		...readOptionalString(entry.url) ? { url: readOptionalString(entry.url) } : {},
-		...readOptionalString(entry.assetUri) ? { assetUri: readOptionalString(entry.assetUri) } : {},
-		...readOptionalString(entry.mimeType) ? { mimeType: readOptionalString(entry.mimeType) } : {},
-		...readOptionalNumber(entry.size) !== void 0 ? { size: readOptionalNumber(entry.size) } : {},
-		...readOptionalString(entry.source) ? { source: readOptionalString(entry.source) } : {},
-		...entry.status === "ready" || entry.status === "remote-only" ? { status: entry.status } : {},
-		...readOptionalString(entry.errorCode) ? { errorCode: readOptionalString(entry.errorCode) } : {}
-	}));
-}
-function toInboundMessage(payload) {
-	const metadata = readRecord(payload.metadata);
-	return {
-		channel: readRequiredString(payload.channelId, "channelId"),
-		chatId: readRequiredString(payload.conversationId, "conversationId"),
-		senderId: readRequiredString(payload.senderId, "senderId"),
-		content: readTextContent(payload.content),
-		timestamp: /* @__PURE__ */ new Date(),
-		attachments: readInboundAttachments(payload.attachments),
-		metadata
-	};
-}
-function resolveExtensionManifestRoots(params) {
-	const devExtensionsDir = resolveDevFirstPartyPluginDir(process.env.NEXTCLAW_DEV_FIRST_PARTY_PLUGIN_DIR);
-	return uniquePaths([
-		join(getDataPath(), "extensions"),
-		join(params.workspace, ".nextclaw", "extensions"),
-		...devExtensionsDir ? [devExtensionsDir] : [],
-		...resolveBuiltinExtensionManifestRoots(),
-		...params.config.plugins.load?.paths ?? []
-	]);
-}
-async function startDiscoveredExtensions(params) {
-	const { config, discovery: providedDiscovery, endpoint, lifecycle: providedLifecycle, token, workspace } = params;
-	const discovery = providedDiscovery ?? new ExtensionManifestDiscoveryService();
-	const lifecycle = providedLifecycle ?? new ExtensionLifecycleService({
-		endpoint,
-		token
-	});
-	const manifests = await discovery.discover(resolveExtensionManifestRoots({
-		config,
-		workspace
-	}));
-	return {
-		lifecycle,
-		running: await lifecycle.startAll(manifests)
-	};
-}
-var ServiceExtensionRuntime = class {
-	token = randomUUID();
-	lifecycle = null;
-	manifests = [];
-	pendingRequests = /* @__PURE__ */ new Map();
-	constructor(gateway) {
-		this.gateway = gateway;
-	}
-	registerIngressHandlers = (ingress) => {
-		ingress.addHandler(EXTENSION_CONFIG_GET_INGRESS_TYPE, this.handleChannelConfigGet);
-		ingress.addHandler(EXTENSION_MESSAGE_SUBMIT_INGRESS_TYPE, this.handleChannelMessageSubmit);
-		ingress.addHandler(EXTENSION_RESPONSE_INGRESS_TYPE, this.handleExtensionResponse);
-	};
-	loadContributions = async () => {
-		this.manifests = await this.discoverManifests();
-		return this.toContributions(this.manifests);
-	};
-	start = async () => {
-		const endpoint = this.gateway.uiStartup.endpoint || null;
-		if (!endpoint) return;
-		const lifecycle = this.lifecycle ?? new ExtensionLifecycleService({
-			endpoint,
-			token: this.token
-		});
-		const manifests = this.manifests.length > 0 ? this.manifests : await this.discoverManifests();
-		const running = await lifecycle.startAll(manifests);
-		this.lifecycle = lifecycle;
-		if (running.length > 0) console.log(`✓ Extensions started: ${running.map((entry) => entry.manifest.id).join(", ")}`);
-	};
-	stop = async () => {
-		await this.lifecycle?.stopAll();
-		this.lifecycle = null;
-		for (const [requestId, request] of this.pendingRequests) {
-			clearTimeout(request.timeout);
-			request.reject(/* @__PURE__ */ new Error(`Extension request cancelled: ${requestId}`));
-		}
-		this.pendingRequests.clear();
-	};
-	handleChannelConfigGet = (envelope, context) => {
-		this.assertAuthorized(context);
-		const channelId = readRequiredString(readRecord(envelope.payload).channelId, "channelId");
-		return { config: this.gateway.configManager.loadConfig().channels[channelId] ?? {} };
-	};
-	handleChannelMessageSubmit = async (envelope, context) => {
-		this.assertAuthorized(context);
-		await this.gateway.messageBus.publishInbound(toInboundMessage(readRecord(envelope.payload)));
-		return { accepted: true };
-	};
-	handleExtensionResponse = (envelope, context) => {
-		this.assertAuthorized(context);
-		const payload = readRecord(envelope.payload);
-		const requestId = readRequiredString(payload.requestId, "requestId");
-		const pending = this.pendingRequests.get(requestId);
-		if (!pending) return { accepted: false };
-		this.pendingRequests.delete(requestId);
-		clearTimeout(pending.timeout);
-		if (payload.ok === false) {
-			const error = readRecord(payload.error);
-			const message = typeof error.message === "string" && error.message.trim() ? error.message.trim() : "Extension request failed";
-			pending.reject(new Error(message));
-			return { accepted: true };
-		}
-		pending.resolve(payload.data);
-		return { accepted: true };
-	};
-	discoverManifests = async () => {
-		return await new ExtensionManifestDiscoveryService().discover(resolveExtensionManifestRoots({
-			config: this.gateway.configManager.loadConfig(),
-			workspace: this.gateway.workspace
-		}));
-	};
-	toContributions = (manifests) => {
-		const channelBindings = [];
-		const uiMetadata = [];
-		for (const manifest of manifests) {
-			const channels = manifest.contributes?.channels ?? [];
-			for (const channel of channels) {
-				const channelId = readOptionalString(channel.id);
-				if (!channelId) continue;
-				const configUiHints = this.readConfigUiHints(channel.configUiHints);
-				channelBindings.push({
-					pluginId: manifest.id,
-					channelId,
-					channel: {
-						id: channelId,
-						meta: {
-							label: channel.name ?? channelId,
-							selectionLabel: channel.name ?? channelId,
-							...channel.description ? { blurb: channel.description } : {},
-							...channel.meta ?? {}
-						},
-						...channel.configSchema ? { configSchema: {
-							schema: channel.configSchema,
-							...configUiHints ? { uiHints: configUiHints } : {}
-						} } : {},
-						...channel.auth ? { auth: this.createChannelAuth(manifest.id, channelId) } : {},
-						...channel.outbound?.text ? { outbound: this.createChannelOutbound(manifest.id, channelId) } : {}
-					}
-				});
-				uiMetadata.push({
-					id: manifest.id,
-					configSchema: channel.configSchema,
-					...configUiHints ? { configUiHints } : {}
-				});
-			}
-		}
-		return {
-			channelBindings,
-			uiMetadata
-		};
-	};
-	readConfigUiHints = (value) => {
-		if (!value || typeof value !== "object" || Array.isArray(value)) return;
-		return value;
-	};
-	createChannelAuth = (extensionId, channelId) => new ExtensionChannelClient({
-		extensionId,
-		channelId,
-		request: this.requestExtension
-	});
-	createChannelOutbound = (extensionId, channelId) => new ExtensionChannelClient({
-		extensionId,
-		channelId,
-		request: this.requestExtension
-	});
-	requestExtension = async (params) => {
-		const requestId = randomUUID();
-		const result = new Promise((resolvePromise, rejectPromise) => {
-			const timeout = setTimeout(() => {
-				this.pendingRequests.delete(requestId);
-				rejectPromise(/* @__PURE__ */ new Error(`Extension request timed out: ${params.kind}`));
-			}, EXTENSION_REQUEST_TIMEOUT_MS);
-			this.pendingRequests.set(requestId, {
-				resolve: (value) => resolvePromise(value),
-				reject: rejectPromise,
-				timeout
-			});
-		});
-		this.gateway.appEventBus.emitEnvelope({
-			type: EXTENSION_REQUEST_EVENT_TYPE,
-			payload: {
-				requestId,
-				extensionId: params.extensionId,
-				kind: params.kind,
-				payload: params.payload
-			},
-			emittedAt: (/* @__PURE__ */ new Date()).toISOString(),
-			source: "backend"
-		});
-		return await result;
-	};
-	assertAuthorized = (context) => {
-		if (context.token !== this.token) throw new Error("Unauthorized ingress token");
-	};
-};
-//#endregion
-export { ServiceExtensionRuntime, resolveBuiltinExtensionManifestRoots, resolveExtensionManifestRoots, startDiscoveredExtensions };

package/dist/shared/services/gateway/cron-job-handler.service.js

@@ -1,100 +0,0 @@
-import { NcpEventType } from "@nextclaw/ncp";
-//#region src/shared/services/gateway/cron-job-handler.service.ts
-function normalizeOptionalString(value) {
-	if (typeof value !== "string") return;
-	return value.trim() || void 0;
-}
-function buildCronSessionMetadata(params) {
-	const { job, agentId, accountId } = params;
-	const channel = normalizeOptionalString(job.payload.channel) ?? "cli";
-	const chatId = normalizeOptionalString(job.payload.to) ?? "direct";
-	const metadata = {
-		agentId,
-		agent_id: agentId,
-		channel,
-		chatId,
-		chat_id: chatId,
-		label: job.name,
-		cron_job_id: job.id,
-		cron_job_name: job.name,
-		session_origin: "cron"
-	};
-	if (accountId) {
-		metadata.accountId = accountId;
-		metadata.account_id = accountId;
-	}
-	return metadata;
-}
-function buildCronUserMessage(params) {
-	const { sessionId, content, metadata } = params;
-	const timestamp = (/* @__PURE__ */ new Date()).toISOString();
-	return {
-		id: `${sessionId}:user:cron:${timestamp}`,
-		sessionId,
-		role: "user",
-		status: "final",
-		timestamp,
-		parts: [{
-			type: "text",
-			text: content
-		}],
-		metadata: structuredClone(metadata)
-	};
-}
-function extractMessageText(message) {
-	return message.parts.flatMap((part) => {
-		if (part.type === "text" || part.type === "rich-text") return [part.text];
-		return [];
-	}).map((text) => text.trim()).filter((text) => text.length > 0).join("\n\n");
-}
-async function runJobOverNcp(params) {
-	const { agent, sessionId, message, metadata, missingCompletedMessageError, runErrorMessage } = params;
-	let completedMessage;
-	for await (const event of agent.runApi.send({
-		sessionId,
-		message,
-		metadata
-	})) {
-		if (event.type === NcpEventType.MessageFailed) throw new Error(event.payload.error.message);
-		if (event.type === NcpEventType.RunError) throw new Error(event.payload.error ?? runErrorMessage);
-		if (event.type === NcpEventType.MessageCompleted) completedMessage = event.payload.message;
-	}
-	if (!completedMessage) throw new Error(missingCompletedMessageError);
-	return extractMessageText(completedMessage);
-}
-function createCronJobHandler(params) {
-	return async (job) => {
-		const ncpAgent = params.resolveNcpAgent();
-		if (!ncpAgent) throw new Error("NCP agent is not ready for cron execution.");
-		const accountId = normalizeOptionalString(job.payload.accountId);
-		const agentId = normalizeOptionalString(job.payload.agentId) ?? "main";
-		const sessionId = normalizeOptionalString(job.payload.sessionId) ?? `cron:${job.id}`;
-		const metadata = buildCronSessionMetadata({
-			job,
-			agentId,
-			accountId
-		});
-		const response = await runJobOverNcp({
-			agent: ncpAgent,
-			sessionId,
-			message: buildCronUserMessage({
-				sessionId,
-				content: job.payload.message,
-				metadata
-			}),
-			metadata,
-			missingCompletedMessageError: "cron job completed without a final assistant message",
-			runErrorMessage: "cron job failed"
-		});
-		if (job.payload.deliver && job.payload.to) await params.bus.publishOutbound({
-			channel: job.payload.channel ?? "cli",
-			chatId: job.payload.to,
-			content: response,
-			media: [],
-			metadata
-		});
-		return response;
-	};
-}
-//#endregion
-export { createCronJobHandler };

package/dist/shared/services/runtime/utils/skills-loader.utils.d.ts

@@ -1,12 +0,0 @@
-//#region src/shared/services/runtime/utils/skills-loader.utils.d.ts
-type SkillInfo = {
-  name: string;
-  path: string;
-  source: "workspace" | "builtin";
-};
-type SkillsLoaderInstance = {
-  listSkills: (filterUnavailable?: boolean) => SkillInfo[];
-};
-declare function createSkillsLoader(workspace: string): SkillsLoaderInstance | null;
-//#endregion
-export { createSkillsLoader };

package/dist/shared/services/runtime/utils/skills-loader.utils.js

@@ -1,9 +0,0 @@
-import * as NextclawCore from "@nextclaw/core";
-//#region src/shared/services/runtime/utils/skills-loader.utils.ts
-function createSkillsLoader(workspace) {
-	const ctor = NextclawCore.SkillsLoader;
-	if (!ctor) return null;
-	return new ctor(workspace);
-}
-//#endregion
-export { createSkillsLoader };

package/dist/shared/services/session/service-deferred-ncp-agent.service.d.ts

@@ -1,14 +0,0 @@
-import { AgentRuntimeHandle } from "@nextclaw/kernel";
-import { UiNcpAgent } from "@nextclaw/server";
-
-//#region src/shared/services/session/service-deferred-ncp-agent.service.d.ts
-type DeferredUiNcpAgentController = {
-  agent: UiNcpAgent;
-  activate: (agent: AgentRuntimeHandle) => void;
-  clear: () => void;
-  close: () => Promise<void>;
-  isReady: () => boolean;
-};
-declare function createDeferredUiNcpAgent(basePath?: string): DeferredUiNcpAgentController;
-//#endregion
-export { DeferredUiNcpAgentController, createDeferredUiNcpAgent };