remoteclaw 0.1.0-next.87fb2cd → 0.1.0-next.9f7caba

package/dist/extensionAPI.js

@@ -15,14 +15,6 @@ import AjvPkg from "ajv";
 import { z } from "zod";
 import { createInterface } from "node:readline";
 
-//#region src/config/model-input.ts
-function resolveAgentModelPrimaryValue(model) {
-	if (typeof model === "string") return model.trim() || void 0;
-	if (!model || typeof model !== "object") return;
-	return model.primary?.trim() || void 0;
-}
-
-//#endregion
 //#region src/infra/home-dir.ts
 function normalize(value) {
 	const trimmed = value?.trim();
@@ -1096,6 +1088,11 @@ function resolveAgentWorkspaceDir(cfg, agentId) {
 	if (configured) return stripNullBytes(resolveUserPath(configured));
 	throw new Error(`agent '${id}' has no workspace configured — set agents.list[].workspace in remoteclaw.json`);
 }
+function resolveAgentWorkspaceDirOrNull(cfg, agentId) {
+	const configured = resolveAgentConfig(cfg, normalizeAgentId(agentId))?.workspace?.trim();
+	if (configured) return stripNullBytes(resolveUserPath(configured));
+	return null;
+}
 function resolveAgentDir(cfg, agentId) {
 	const id = normalizeAgentId(agentId);
 	const configured = resolveAgentConfig(cfg, id)?.agentDir?.trim();
@@ -1104,11 +1101,6 @@ function resolveAgentDir(cfg, agentId) {
 	return path.join(root, "agents", id, "agent");
 }
 
-//#endregion
-//#region src/agents/defaults.ts
-const DEFAULT_PROVIDER = "anthropic";
-const DEFAULT_MODEL = "claude-opus-4-6";
-
 //#endregion
 //#region src/agents/identity.ts
 function resolveAgentIdentity(cfg, agentId) {
@@ -2168,7 +2160,9 @@ function applyContextPruningDefaults(cfg) {
 			};
 			modelsMutated = true;
 		}
-		const primary = resolvePrimaryModelRef(resolveAgentModelPrimaryValue(defaults.model) ?? void 0);
+		const rawModel = defaults.model;
+		const rawPrimary = typeof rawModel === "string" ? rawModel : rawModel?.primary;
+		const primary = resolvePrimaryModelRef(typeof rawPrimary === "string" ? rawPrimary : void 0);
 		if (primary) {
 			const parsedPrimary = parseModelRef(primary, "anthropic");
 			if (isAnthropicCacheRetentionTarget(parsedPrimary)) {
@@ -2201,25 +2195,6 @@ function applyContextPruningDefaults(cfg) {
 		}
 	};
 }
-function applyCompactionDefaults(cfg) {
-	const defaults = cfg.agents?.defaults;
-	if (!defaults) return cfg;
-	const compaction = defaults?.compaction;
-	if (compaction?.mode) return cfg;
-	return {
-		...cfg,
-		agents: {
-			...cfg.agents,
-			defaults: {
-				...defaults,
-				compaction: {
-					...compaction,
-					mode: "safeguard"
-				}
-			}
-		}
-	};
-}
 
 //#endregion
 //#region src/config/env-preserve.ts
@@ -4657,13 +4632,6 @@ function parseDurationMs(raw, opts) {
 	return ms;
 }
 
-//#endregion
-//#region src/config/zod-schema.agent-model.ts
-const AgentModelSchema = z.union([z.string(), z.object({
-	primary: z.string().optional(),
-	fallbacks: z.array(z.string()).optional()
-}).strict()]);
-
 //#endregion
 //#region src/config/zod-schema.allowdeny.ts
 const AllowDenyActionSchema = z.union([z.literal("allow"), z.literal("deny")]);
@@ -5195,7 +5163,7 @@ const AgentEntrySchema = z.object({
 	name: z.string().optional(),
 	workspace: z.string().optional(),
 	agentDir: z.string().optional(),
-	model: AgentModelSchema.optional(),
+	model: z.unknown().optional(),
 	skills: z.array(z.string()).optional(),
 	humanDelay: HumanDelaySchema.optional(),
 	heartbeat: HeartbeatSchema,
@@ -5204,10 +5172,7 @@ const AgentEntrySchema = z.object({
 	groupChat: GroupChatSchema,
 	subagents: z.object({
 		allowAgents: z.array(z.string()).optional(),
-		model: z.union([z.string(), z.object({
-			primary: z.string().optional(),
-			fallbacks: z.array(z.string()).optional()
-		}).strict()]).optional(),
+		model: z.unknown().optional(),
 		thinking: z.string().optional()
 	}).strict().optional(),
 	editableFiles: z.array(z.string()).optional(),
@@ -5254,13 +5219,10 @@ const ToolsSchema = z.object({
 //#endregion
 //#region src/config/zod-schema.agent-defaults.ts
 const AgentDefaultsSchema = z.object({
-	model: AgentModelSchema.optional(),
-	imageModel: AgentModelSchema.optional(),
-	models: z.record(z.string(), z.object({
-		alias: z.string().optional(),
-		params: z.record(z.string(), z.unknown()).optional(),
-		streaming: z.boolean().optional()
-	}).strict()).optional(),
+	model: z.unknown().optional(),
+	imageModel: z.unknown().optional(),
+	models: z.unknown().optional(),
+	workspace: z.string().optional(),
 	repoRoot: z.string().optional(),
 	skipBootstrap: z.boolean().optional(),
 	bootstrapMaxChars: z.number().int().positive().optional(),
@@ -5275,7 +5237,7 @@ const AgentDefaultsSchema = z.object({
 	envelopeTimestamp: z.union([z.literal("on"), z.literal("off")]).optional(),
 	envelopeElapsed: z.union([z.literal("on"), z.literal("off")]).optional(),
 	contextTokens: z.number().int().positive().optional(),
-	cliBackends: z.record(z.string(), CliBackendSchema).optional(),
+	cliBackends: z.unknown().optional(),
 	contextPruning: z.object({
 		mode: z.union([z.literal("off"), z.literal("cache-ttl")]).optional(),
 		ttl: z.string().optional(),
@@ -5297,13 +5259,6 @@ const AgentDefaultsSchema = z.object({
 			placeholder: z.string().optional()
 		}).strict().optional()
 	}).strict().optional(),
-	compaction: z.object({
-		mode: z.union([z.literal("default"), z.literal("safeguard")]).optional(),
-		reserveTokens: z.number().int().nonnegative().optional(),
-		keepRecentTokens: z.number().int().positive().optional(),
-		reserveTokensFloor: z.number().int().nonnegative().optional(),
-		maxHistoryShare: z.number().min(.1).max(.9).optional()
-	}).strict().optional(),
 	thinkingDefault: z.union([
 		z.literal("off"),
 		z.literal("minimal"),
@@ -5341,7 +5296,7 @@ const AgentDefaultsSchema = z.object({
 		maxSpawnDepth: z.number().int().min(1).max(5).optional().describe("Maximum nesting depth for sub-agent spawning. 1 = no nesting (default), 2 = sub-agents can spawn sub-sub-agents."),
 		maxChildrenPerAgent: z.number().int().min(1).max(20).optional().describe("Maximum number of active children a single agent session can spawn (default: 5)."),
 		archiveAfterMinutes: z.number().int().positive().optional(),
-		model: AgentModelSchema.optional(),
+		model: z.unknown().optional(),
 		thinking: z.string().optional(),
 		runTimeoutSeconds: z.number().int().min(0).optional(),
 		announceTimeoutMs: z.number().int().positive().optional()
@@ -5353,7 +5308,9 @@ const AgentDefaultsSchema = z.object({
 		z.literal("gemini"),
 		z.literal("codex"),
 		z.literal("opencode")
-	]).optional()
+	]).optional(),
+	runtimeArgs: z.array(z.string()).optional(),
+	runtimeEnv: z.record(z.string(), z.string()).optional()
 }).strict().optional();
 
 //#endregion
@@ -7270,7 +7227,8 @@ function validateIdentityAvatar(config) {
 			});
 			continue;
 		}
-		if (!isWorkspaceAvatarPath(avatar, resolveAgentWorkspaceDir(config, entry.id ?? resolveDefaultAgentId(config)))) issues.push({
+		const workspaceDir = resolveAgentWorkspaceDirOrNull(config, entry.id ?? resolveDefaultAgentId(config));
+		if (workspaceDir != null && !isWorkspaceAvatarPath(avatar, workspaceDir)) issues.push({
 			path: `agents.list.${index}.identity.avatar`,
 			message: "identity.avatar must stay within the agent workspace."
 		});
@@ -7346,7 +7304,7 @@ function validateConfigObjectWithPluginsBase(raw, opts) {
 		if (registryInfo) return registryInfo;
 		const registry = loadPluginManifestRegistry({
 			config,
-			workspaceDir: resolveAgentWorkspaceDir(config, resolveDefaultAgentId(config)) ?? void 0
+			workspaceDir: resolveAgentWorkspaceDirOrNull(config, resolveDefaultAgentId(config)) ?? void 0
 		});
 		const knownIds = new Set(registry.plugins.map((record) => record.id));
 		const normalizedPlugins = normalizePluginsConfig(config.plugins);
@@ -7949,7 +7907,7 @@ function createConfigIO(overrides = {}) {
 				deps.logger.warn(`Config warnings:\\n${details}`);
 			}
 			warnIfConfigFromFuture(validated.config, deps.logger);
-			const cfg = applyTalkConfigNormalization(applyModelDefaults(applyCompactionDefaults(applyContextPruningDefaults(applyAgentDefaults(applySessionDefaults(applyLoggingDefaults(applyMessageDefaults(validated.config))))))));
+			const cfg = applyTalkConfigNormalization(applyModelDefaults(applyContextPruningDefaults(applyAgentDefaults(applySessionDefaults(applyLoggingDefaults(applyMessageDefaults(validated.config)))))));
 			normalizeConfigPaths(cfg);
 			const duplicates = findDuplicateAgentDirs(cfg, {
 				env: deps.env,
@@ -8009,7 +7967,7 @@ function createConfigIO(overrides = {}) {
 				parsed: {},
 				resolved: {},
 				valid: true,
-				config: applyTalkApiKey(applyTalkConfigNormalization(applyModelDefaults(applyCompactionDefaults(applyContextPruningDefaults(applyAgentDefaults(applySessionDefaults(applyMessageDefaults({})))))))),
+				config: applyTalkApiKey(applyTalkConfigNormalization(applyModelDefaults(applyContextPruningDefaults(applyAgentDefaults(applySessionDefaults(applyMessageDefaults({}))))))),
 				hash,
 				issues: [],
 				warnings: [],
@@ -10088,6 +10046,7 @@ var CLIRuntimeBase = class CLIRuntimeBase {
 	}
 	async *execute(params) {
 		const args = this.buildArgs(params);
+		if (params.extraArgs && params.extraArgs.length > 0) args.push(...params.extraArgs);
 		const env = {
 			...process.env,
 			...this.buildEnv(params),
@@ -10105,6 +10064,7 @@ var CLIRuntimeBase = class CLIRuntimeBase {
 		const startMs = Date.now();
 		const stderrChunks = [];
 		let aborted = false;
+		let yieldedEvents = false;
 		let escalationTimer;
 		const killWithEscalation = () => {
 			if (escalationTimer === void 0) escalationTimer = setTimeout(() => {
@@ -10183,6 +10143,7 @@ var CLIRuntimeBase = class CLIRuntimeBase {
 				while (eventQueue.length > 0) {
 					const event = eventQueue.shift();
 					if (event === null || event === void 0) break;
+					yieldedEvents = true;
 					yield event;
 				}
 			}
@@ -10190,9 +10151,15 @@ var CLIRuntimeBase = class CLIRuntimeBase {
 			if (watchdogTimer !== void 0) clearTimeout(watchdogTimer);
 			params.abortSignal?.removeEventListener("abort", onAbort);
 		}
-		await exitPromise;
+		const { code: exitCode } = await exitPromise;
 		if (escalationTimer !== void 0) clearTimeout(escalationTimer);
 		const durationMs = Date.now() - startMs;
+		const stderr = stderrChunks.join("");
+		if (stderr && (exitCode !== 0 || !yieldedEvents)) yield {
+			type: "error",
+			message: stderr.trim(),
+			code: "CLI_STDERR"
+		};
 		if (watchdogFired) yield {
 			type: "error",
 			message: `Watchdog timeout: no output for ${this.timeoutMs}ms`,
@@ -10210,7 +10177,8 @@ var CLIRuntimeBase = class CLIRuntimeBase {
 				sessionId: void 0,
 				durationMs,
 				usage: void 0,
-				aborted
+				aborted,
+				stderr: stderr || void 0
 			}
 		};
 	}
@@ -11075,12 +11043,37 @@ const SUPPORTED_PROVIDERS = [
 	"codex",
 	"opencode"
 ];
+const validatedCommands = /* @__PURE__ */ new Set();
+/**
+* Verify that a CLI binary exists on PATH.
+*
+* Results are cached per process lifetime so the `which` lookup runs at most
+* once per command.
+*/
+function validateExecutable(command) {
+	if (validatedCommands.has(command)) return;
+	try {
+		execFileSync("which", [command], { stdio: "ignore" });
+		validatedCommands.add(command);
+	} catch {
+		throw new Error(`Runtime '${command}' is configured but the '${command}' binary was not found on PATH. Install it or set agents.defaults.runtime to a different provider.`);
+	}
+}
 function createCliRuntime(provider) {
-	switch (provider.trim().toLowerCase()) {
-		case "claude": return new ClaudeCliRuntime();
-		case "gemini": return new GeminiCliRuntime();
-		case "codex": return new CodexCliRuntime();
-		case "opencode": return new OpenCodeCliRuntime();
+	const normalized = provider.trim().toLowerCase();
+	switch (normalized) {
+		case "claude":
+			validateExecutable(normalized);
+			return new ClaudeCliRuntime();
+		case "gemini":
+			validateExecutable(normalized);
+			return new GeminiCliRuntime();
+		case "codex":
+			validateExecutable(normalized);
+			return new CodexCliRuntime();
+		case "opencode":
+			validateExecutable(normalized);
+			return new OpenCodeCliRuntime();
 		default: throw new Error(`Unknown runtime provider "${provider}". Supported providers: ${SUPPORTED_PROVIDERS.join(", ")}`);
 	}
 }
@@ -11231,6 +11224,8 @@ var ChannelBridge = class {
 	#workspaceDir;
 	#chunkLimit;
 	#mcpServerPath;
+	#runtimeArgs;
+	#runtimeEnv;
 	constructor(options) {
 		this.#provider = options.provider;
 		this.#sessionMap = options.sessionMap;
@@ -11239,6 +11234,8 @@ var ChannelBridge = class {
 		this.#workspaceDir = options.workspaceDir ?? DEFAULT_WORKSPACE_DIR;
 		this.#chunkLimit = options.chunkLimit;
 		this.#mcpServerPath = options.mcpServerPath ?? DEFAULT_MCP_SERVER_PATH;
+		this.#runtimeArgs = options.runtimeArgs;
+		this.#runtimeEnv = options.runtimeEnv;
 	}
 	/**
 	* Process an incoming channel message through the full agent execution pipeline.
@@ -11277,7 +11274,7 @@ var ChannelBridge = class {
 			const mcpServers = this.#buildMcpConfig(message, sessionKey, sideEffectsFile);
 			const runtime = createCliRuntime(this.#provider);
 			let workspaceDir = this.#workspaceDir;
-			let extraEnv;
+			let hookEnv;
 			const runId = randomUUID();
 			if (hookRunner?.hasHooks("before_runtime_spawn")) {
 				const spawnResult = await hookRunner.runBeforeRuntimeSpawn({
@@ -11294,7 +11291,7 @@ var ChannelBridge = class {
 					runtimeName: this.#provider
 				});
 				if (spawnResult?.workspaceDir) workspaceDir = spawnResult.workspaceDir;
-				if (spawnResult?.env) extraEnv = spawnResult.env;
+				if (spawnResult?.env) hookEnv = spawnResult.env;
 			}
 			const adapter = new DeliveryAdapter(this.#chunkLimit !== void 0 ? { chunkLimit: this.#chunkLimit } : void 0);
 			let runResult;
@@ -11307,7 +11304,11 @@ var ChannelBridge = class {
 					mcpServers,
 					abortSignal,
 					workingDirectory: workspaceDir,
-					env: extraEnv
+					env: this.#runtimeEnv || hookEnv ? {
+						...this.#runtimeEnv,
+						...hookEnv
+					} : void 0,
+					extraArgs: this.#runtimeArgs
 				}));
 				payloads = await adapter.process(captured.events, callbacks);
 				runResult = captured.getResult();
@@ -11517,4 +11518,4 @@ function resolveGatewayCredentialsFromConfig(params) {
 }
 
 //#endregion
-export { ChannelBridge, DEFAULT_MODEL, DEFAULT_PROVIDER, ensureAgentWorkspace, loadSessionStore, resolveAgentDir, resolveAgentIdentity, resolveAgentTimeoutMs, resolveAgentWorkspaceDir, resolveGatewayCredentialsFromConfig, resolveGatewayPort, resolveSessionFilePath, resolveStorePath, saveSessionStore };
+export { ChannelBridge, ensureAgentWorkspace, loadSessionStore, resolveAgentDir, resolveAgentIdentity, resolveAgentTimeoutMs, resolveAgentWorkspaceDir, resolveGatewayCredentialsFromConfig, resolveGatewayPort, resolveSessionFilePath, resolveStorePath, saveSessionStore };

package/dist/fetch-Duxh68Ws.js

@@ -0,0 +1,67 @@
+import { y as bindAbortRelay } from "./media-C0_rYTSG.js";
+
+//#region src/infra/fetch.ts
+const wrapFetchWithAbortSignalMarker = Symbol.for("remoteclaw.fetch.abort-signal-wrapped");
+function withDuplex(init, input) {
+	const hasInitBody = init?.body != null;
+	const hasRequestBody = !hasInitBody && typeof Request !== "undefined" && input instanceof Request && input.body != null;
+	if (!hasInitBody && !hasRequestBody) return init;
+	if (init && "duplex" in init) return init;
+	return init ? {
+		...init,
+		duplex: "half"
+	} : { duplex: "half" };
+}
+function wrapFetchWithAbortSignal(fetchImpl) {
+	if (fetchImpl[wrapFetchWithAbortSignalMarker]) return fetchImpl;
+	const wrapped = ((input, init) => {
+		const patchedInit = withDuplex(init, input);
+		const signal = patchedInit?.signal;
+		if (!signal) return fetchImpl(input, patchedInit);
+		if (typeof AbortSignal !== "undefined" && signal instanceof AbortSignal) return fetchImpl(input, patchedInit);
+		if (typeof AbortController === "undefined") return fetchImpl(input, patchedInit);
+		if (typeof signal.addEventListener !== "function") return fetchImpl(input, patchedInit);
+		const controller = new AbortController();
+		const onAbort = bindAbortRelay(controller);
+		let listenerAttached = false;
+		if (signal.aborted) controller.abort();
+		else {
+			signal.addEventListener("abort", onAbort, { once: true });
+			listenerAttached = true;
+		}
+		const cleanup = () => {
+			if (!listenerAttached || typeof signal.removeEventListener !== "function") return;
+			listenerAttached = false;
+			try {
+				signal.removeEventListener("abort", onAbort);
+			} catch {}
+		};
+		try {
+			return fetchImpl(input, {
+				...patchedInit,
+				signal: controller.signal
+			}).finally(cleanup);
+		} catch (error) {
+			cleanup();
+			throw error;
+		}
+	});
+	const wrappedFetch = Object.assign(wrapped, fetchImpl);
+	const fetchWithPreconnect = fetchImpl;
+	wrappedFetch.preconnect = typeof fetchWithPreconnect.preconnect === "function" ? fetchWithPreconnect.preconnect.bind(fetchWithPreconnect) : () => {};
+	Object.defineProperty(wrappedFetch, wrapFetchWithAbortSignalMarker, {
+		value: true,
+		enumerable: false,
+		configurable: false,
+		writable: false
+	});
+	return wrappedFetch;
+}
+function resolveFetch(fetchImpl) {
+	const resolved = fetchImpl ?? globalThis.fetch;
+	if (!resolved) return;
+	return wrapFetchWithAbortSignal(resolved);
+}
+
+//#endregion
+export { resolveFetch as t };

package/dist/fs-safe-S3Zvbabd.js

@@ -0,0 +1,98 @@
+import { n as isPathInside, r as isSymlinkOpenError, t as isNotFoundPathError } from "./path-guards-DJteVA0d.js";
+import { constants } from "node:fs";
+import path from "node:path";
+import fs$1 from "node:fs/promises";
+
+//#region src/infra/file-identity.ts
+function isZero(value) {
+	return value === 0 || value === 0n;
+}
+function sameFileIdentity(left, right, platform = process.platform) {
+	if (left.ino !== right.ino) return false;
+	if (left.dev === right.dev) return true;
+	return platform === "win32" && (isZero(left.dev) || isZero(right.dev));
+}
+
+//#endregion
+//#region src/infra/fs-safe.ts
+var SafeOpenError = class extends Error {
+	constructor(code, message, options) {
+		super(message, options);
+		this.code = code;
+		this.name = "SafeOpenError";
+	}
+};
+const SUPPORTS_NOFOLLOW = process.platform !== "win32" && "O_NOFOLLOW" in constants;
+const OPEN_READ_FLAGS = constants.O_RDONLY | (SUPPORTS_NOFOLLOW ? constants.O_NOFOLLOW : 0);
+const ensureTrailingSep = (value) => value.endsWith(path.sep) ? value : value + path.sep;
+async function openVerifiedLocalFile(filePath) {
+	let handle;
+	try {
+		handle = await fs$1.open(filePath, OPEN_READ_FLAGS);
+	} catch (err) {
+		if (isNotFoundPathError(err)) throw new SafeOpenError("not-found", "file not found");
+		if (isSymlinkOpenError(err)) throw new SafeOpenError("symlink", "symlink open blocked", { cause: err });
+		throw err;
+	}
+	try {
+		const [stat, lstat] = await Promise.all([handle.stat(), fs$1.lstat(filePath)]);
+		if (lstat.isSymbolicLink()) throw new SafeOpenError("symlink", "symlink not allowed");
+		if (!stat.isFile()) throw new SafeOpenError("not-file", "not a file");
+		if (!sameFileIdentity(stat, lstat)) throw new SafeOpenError("path-mismatch", "path changed during read");
+		const realPath = await fs$1.realpath(filePath);
+		if (!sameFileIdentity(stat, await fs$1.stat(realPath))) throw new SafeOpenError("path-mismatch", "path mismatch");
+		return {
+			handle,
+			realPath,
+			stat
+		};
+	} catch (err) {
+		await handle.close().catch(() => {});
+		if (err instanceof SafeOpenError) throw err;
+		if (isNotFoundPathError(err)) throw new SafeOpenError("not-found", "file not found");
+		throw err;
+	}
+}
+async function openFileWithinRoot(params) {
+	let rootReal;
+	try {
+		rootReal = await fs$1.realpath(params.rootDir);
+	} catch (err) {
+		if (isNotFoundPathError(err)) throw new SafeOpenError("not-found", "root dir not found");
+		throw err;
+	}
+	const rootWithSep = ensureTrailingSep(rootReal);
+	const resolved = path.resolve(rootWithSep, params.relativePath);
+	if (!isPathInside(rootWithSep, resolved)) throw new SafeOpenError("invalid-path", "path escapes root");
+	let opened;
+	try {
+		opened = await openVerifiedLocalFile(resolved);
+	} catch (err) {
+		if (err instanceof SafeOpenError) {
+			if (err.code === "not-found") throw err;
+			throw new SafeOpenError("invalid-path", "path is not a regular file under root", { cause: err });
+		}
+		throw err;
+	}
+	if (!isPathInside(rootWithSep, opened.realPath)) {
+		await opened.handle.close().catch(() => {});
+		throw new SafeOpenError("invalid-path", "path escapes root");
+	}
+	return opened;
+}
+async function readLocalFileSafely(params) {
+	const opened = await openVerifiedLocalFile(params.filePath);
+	try {
+		if (params.maxBytes !== void 0 && opened.stat.size > params.maxBytes) throw new SafeOpenError("too-large", `file exceeds limit of ${params.maxBytes} bytes (got ${opened.stat.size})`);
+		return {
+			buffer: await opened.handle.readFile(),
+			realPath: opened.realPath,
+			stat: opened.stat
+		};
+	} finally {
+		await opened.handle.close().catch(() => {});
+	}
+}
+
+//#endregion
+export { sameFileIdentity as i, openFileWithinRoot as n, readLocalFileSafely as r, SafeOpenError as t };