nextclaw 0.42.2 → 0.42.3

package/dist/cli/app/index.js

@@ -3,7 +3,7 @@ import { t as createNextclawDistribution } from "../../nextclaw-distribution.uti
 import { NextclawDistributionService } from "@nextclaw/service";
 //#region src/cli/app/index.ts
 NextclawDistributionService.configureRuntime(createNextclawDistribution(import.meta.url));
-await import("../../nextclaw-cli-app-68oDx3B5.js");
+await import("../../nextclaw-cli-app-BeKFODGS.js");
 //#endregion
 export {};
 

package/dist/{nextclaw-cli-app-68oDx3B5.js → nextclaw-cli-app-BeKFODGS.js}

@@ -10,8 +10,8 @@ import { tmpdir } from "node:os";
 import "@nextclaw/server";
 import { access, mkdtemp, readFile, rm, stat } from "node:fs/promises";
 import { AppBundleService, AppHomeService, AppInstanceInventoryService, AppInstanceStorageService, AppPlatformTargetService, AppPublishService, AppPublishValidationService } from "@nextclaw/app-runtime";
-import { McpServiceAppRuntimeService, buildServiceActionId, getServiceAppManifestPath, mergeServiceAppRuntimeActions, readServiceAppManifest } from "@nextclaw/kernel";
-import { promisify } from "node:util";
+import { McpServiceAppRuntimeService, NextclawHarnessError, buildServiceActionId, getServiceAppManifestPath, mergeServiceAppRuntimeActions, readServiceAppManifest } from "@nextclaw/kernel";
+import { format, promisify } from "node:util";
 var __commonJSMin = (cb, mod) => () => (mod || cb((mod = { exports: {} }).exports, mod), mod.exports);
 var __require = /* @__PURE__ */ createRequire(import.meta.url);
 //#endregion
@@ -4915,6 +4915,182 @@ function registerSessionCommands(program, nextclaw) {
 	sessions.command("clear-project <session-id>").description("Clear a session project binding").option("--json", "Output JSON", false).action((sessionId, options) => commands.clearProject(sessionId, options));
 }
 //#endregion
+//#region src/cli/app/controllers/exec-command.controller.ts
+const EXEC_SCHEMA_VERSION = "nextclaw.exec/v1";
+function write(stream, value) {
+	stream.write(value);
+}
+function redirectConsoleToStderr(stderr) {
+	const methods = [
+		"debug",
+		"error",
+		"info",
+		"log",
+		"warn"
+	];
+	const originals = /* @__PURE__ */ new Map();
+	for (const method of methods) {
+		const original = console[method];
+		originals.set(method, original);
+		console[method] = (...args) => write(stderr, `${format(...args)}\n`);
+	}
+	return () => {
+		for (const method of methods) {
+			const original = originals.get(method);
+			if (original) console[method] = original;
+		}
+	};
+}
+async function readPipedStdin(stdin) {
+	if (stdin.isTTY === true) return "";
+	const chunks = [];
+	for await (const chunk of stdin) chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(String(chunk)));
+	return Buffer.concat(chunks).toString("utf8");
+}
+function resolveFormat(value) {
+	const resolved = value ?? "text";
+	if (resolved !== "text" && resolved !== "json" && resolved !== "jsonl") throw new NextclawHarnessError("invalid_input", "--format must be text, json, or jsonl.");
+	return resolved;
+}
+async function resolveInput(stdin, promptParts) {
+	const stdinText = (await readPipedStdin(stdin)).trim();
+	const prompt = promptParts.join(" ").trim();
+	const input = [prompt, stdinText].filter(Boolean).join(prompt && stdinText ? "\n" : "");
+	if (!input) throw new NextclawHarnessError("invalid_input", "A prompt argument or piped stdin is required.");
+	return input;
+}
+function resolveTimeout(value) {
+	if (value === void 0 || value === "") return;
+	const timeout = typeof value === "number" ? value : Number(value);
+	if (!Number.isSafeInteger(timeout) || timeout <= 0) throw new NextclawHarnessError("invalid_input", "--timeout must be a positive integer in milliseconds.");
+	return timeout;
+}
+function classifyExitCode(code) {
+	if (code === "invalid_input") return 2;
+	if (code === "cancelled") return 130;
+	return 1;
+}
+function toPublicError(error) {
+	if (error instanceof NextclawHarnessError) return error;
+	return new NextclawHarnessError("runtime_failure", error instanceof Error ? error.message : String(error ?? "Unknown error"), error);
+}
+function createCancellationScope(timeout) {
+	const controller = new AbortController();
+	let reason;
+	const abort = (nextReason) => {
+		if (reason) return;
+		reason = nextReason;
+		controller.abort();
+	};
+	const onSigint = () => abort("interrupted");
+	const timeoutHandle = timeout === void 0 ? void 0 : setTimeout(() => abort("timed_out"), timeout);
+	process.once("SIGINT", onSigint);
+	return {
+		signal: controller.signal,
+		getReason: () => reason,
+		dispose: () => {
+			if (timeoutHandle) clearTimeout(timeoutHandle);
+			process.removeListener("SIGINT", onSigint);
+		}
+	};
+}
+function resolvePublicError(error, cancellationReason) {
+	const caughtError = toPublicError(error);
+	if (!cancellationReason) return caughtError;
+	return new NextclawHarnessError("cancelled", cancellationReason === "timed_out" ? "Task timed out." : "Task interrupted.", caughtError);
+}
+function writeMachineError(format, error, stdout) {
+	const payload = {
+		schemaVersion: EXEC_SCHEMA_VERSION,
+		status: "error",
+		error: {
+			code: error.code,
+			message: error.message
+		}
+	};
+	write(stdout, format === "json" ? `${JSON.stringify(payload)}\n` : `${JSON.stringify({
+		...payload,
+		type: "error"
+	})}\n`);
+}
+function createEventHandler(outputFormat, stdout) {
+	if (outputFormat !== "jsonl") return;
+	return (event) => write(stdout, `${JSON.stringify({
+		schemaVersion: EXEC_SCHEMA_VERSION,
+		type: "event",
+		event
+	})}\n`);
+}
+async function runTaskWithDiagnostics(params) {
+	const { input, options, outputFormat, runtime, signal, stderr, stdout } = params;
+	const restoreConsole = redirectConsoleToStderr(stderr);
+	try {
+		return await runtime.runTask({
+			agentId: options.agent,
+			input,
+			model: options.model,
+			onEvent: createEventHandler(outputFormat, stdout),
+			sessionId: options.session,
+			signal
+		});
+	} finally {
+		restoreConsole();
+	}
+}
+function writeResult(outputFormat, result, stdout) {
+	if (outputFormat === "text") {
+		write(stdout, `${result.text}\n`);
+		return;
+	}
+	write(stdout, `${JSON.stringify(outputFormat === "json" ? {
+		schemaVersion: EXEC_SCHEMA_VERSION,
+		status: "completed",
+		result
+	} : {
+		schemaVersion: EXEC_SCHEMA_VERSION,
+		type: "result",
+		status: "completed",
+		result
+	})}\n`);
+}
+function writeFailure(requestedFormat, error, stdout, stderr) {
+	if (requestedFormat === "json" || requestedFormat === "jsonl") writeMachineError(requestedFormat, error, stdout);
+	else write(stderr, `Error: ${error.message}\n`);
+	return classifyExitCode(error.code);
+}
+async function executeExecCommand(runtime, promptParts = [], options = {}, io = {}) {
+	const stdin = io.stdin ?? process.stdin;
+	const stdout = io.stdout ?? process.stdout;
+	const stderr = io.stderr ?? process.stderr;
+	const requestedFormat = options.format ?? "text";
+	let cancellationScope;
+	try {
+		const outputFormat = resolveFormat(options.format);
+		cancellationScope = createCancellationScope(resolveTimeout(options.timeout));
+		writeResult(outputFormat, await runTaskWithDiagnostics({
+			runtime,
+			input: await resolveInput(stdin, promptParts),
+			options,
+			outputFormat,
+			signal: cancellationScope.signal,
+			stdout,
+			stderr
+		}), stdout);
+		return 0;
+	} catch (error) {
+		return writeFailure(requestedFormat, resolvePublicError(error, cancellationScope?.getReason()), stdout, stderr);
+	} finally {
+		cancellationScope?.dispose();
+	}
+}
+//#endregion
+//#region src/cli/app/exec-command-registration.utils.ts
+function registerExecCommand(program, nextclaw) {
+	program.command("exec [prompt...]").description("Run one non-interactive agent task").option("--agent <id>", "Agent id").option("--session <id>", "Session id to resume").option("--model <model>", "Session model override").option("--format <format>", "Output format: text, json, or jsonl", "text").option("--timeout <ms>", "Cancel after this many milliseconds").action(async (prompt, options) => {
+		process.exitCode = await executeExecCommand(nextclaw, prompt ?? [], options);
+	});
+}
+//#endregion
 //#region src/cli/app/nextclaw-cli-app.ts
 const LOGO = "🤖";
 const program = new Command();
@@ -4947,6 +5123,7 @@ registerSkillsCommands(program, runtime);
 registerAgentsCommands(program, runtime);
 registerProjectCommands(program, runtime);
 registerSessionCommands(program, runtime);
+registerExecCommand(program, runtime);
 registerAppCommands(program);
 const config = program.command("config").description("Manage config values");
 config.command("get <path>").description("Get a config value by dot path").option("--json", "Output JSON", false).action((path, opts) => runtime.commands.config.get(path, opts));
@@ -4988,4 +5165,4 @@ await program.parseAsync(process.argv);
 //#endregion
 export {};
 
-//# sourceMappingURL=nextclaw-cli-app-68oDx3B5.js.map
+//# sourceMappingURL=nextclaw-cli-app-BeKFODGS.js.map