@iowarp/clio-coder 0.4.7 → 0.4.9

package/src/tools/web-fetch.ts

@@ -2,7 +2,7 @@ import { UNTRUSTED_CONTENT_BANNER } from "../core/untrusted-content.js";
 import type { ToolResult, ToolSpec } from "./registry.js";
 import { truncateUtf8 } from "./truncate-utf8.js";
 import { fetchWebUrl } from "./web-fetch-network.js";
-import { webFetchToolSurface } from "./web-fetch-surface.js";
+import { webFetchToolSurface, webReadToolSurface } from "./web-fetch-surface.js";
 
 const DEFAULT_TIMEOUT_MS = 30_000;
 const DEFAULT_MAX_BYTES = 600_000;
@@ -759,3 +759,28 @@ export const webFetchTool: ToolSpec = {
 		}
 	},
 };
+
+/** The GET-only arguments web_read forwards; method, headers, and body cannot reach the request. */
+const WEB_READ_ARGUMENT_KEYS = ["url", "timeout_ms", "max_bytes", "format"] as const;
+
+/**
+ * web_read is web_fetch with the request shape fixed to a plain GET. One
+ * implementation: the arguments are projected onto the read-only subset and
+ * the same fetch, summaries, binary refusal, private-network gate, and byte
+ * caps apply. Only the message prefix changes, so an error names the tool
+ * that was called.
+ */
+export const webReadTool: ToolSpec = {
+	...webReadToolSurface,
+	async run(args, options): Promise<ToolResult> {
+		const projected: Record<string, unknown> = {};
+		for (const key of WEB_READ_ARGUMENT_KEYS) {
+			if (args[key] !== undefined) projected[key] = args[key];
+		}
+		const result = await webFetchTool.run(projected, options);
+		if (result.kind === "error") {
+			return { ...result, message: result.message.replace(/^web_fetch:/u, "web_read:") };
+		}
+		return result;
+	},
+};

package/src/tools/write.ts

@@ -1,16 +1,15 @@
-import { mkdirSync, readFileSync, writeFileSync } from "node:fs";
-import { dirname } from "node:path";
+import { open, stat } from "node:fs/promises";
 import { Type } from "typebox";
 import { ToolNames } from "../core/tool-names.js";
 import { generateDiffString } from "./edit-diff.js";
-import { withFileMutationQueue } from "./file-mutation-queue.js";
+import { publishFileAtomically, withFileMutationQueue } from "./file-mutation-queue.js";
 import { resolveToCwd } from "./path-utils.js";
 import type { ToolResult, ToolSpec } from "./registry.js";
 
 export const writeTool: ToolSpec = {
 	name: ToolNames.Write,
 	description:
-		"Write a UTF-8 text file, creating parent directories and overwriting existing files. Use edit for surgical changes.",
+		"Write a UTF-8 text file, creating parent directories and overwriting existing files. Publishes atomically through symlinks, preserving mode bits. In-process writes are serialized; external writers are not locked and the last rename wins. Use edit for surgical changes.",
 	parameters: Type.Object({
 		path: Type.String({ description: "File path (relative or absolute)." }),
 		content: Type.String({ description: "Full UTF-8 file contents." }),
@@ -25,22 +24,40 @@ export const writeTool: ToolSpec = {
 		if (content === null) return { kind: "error", message: "write: missing content argument" };
 		const filePath = resolveToCwd(pathArg);
 		try {
-			let previousEndedWithNewline = false;
-			let previousContent = "";
-			await withFileMutationQueue(filePath, async () => {
-				try {
-					previousContent = readFileSync(filePath, "utf8");
-					previousEndedWithNewline = previousContent.endsWith("\n");
-				} catch {
-					previousContent = "";
-					previousEndedWithNewline = false;
+			const bytes = Buffer.byteLength(content, "utf8");
+			const { file, diff, previousEndedWithNewline, skipDiff } = await withFileMutationQueue(filePath, async () => {
+				const previous = await stat(filePath).catch((error: NodeJS.ErrnoException) => {
+					if (error.code === "ENOENT") return null;
+					throw error;
+				});
+				if (previous && !previous.isFile()) throw new Error("Refusing directory or non-file target");
+				let skipDiff = Math.max(previous?.size ?? 0, bytes) > 1024 * 1024;
+				let previousContent = "";
+				if (previous && !skipDiff) {
+					const handle = await open(filePath, "r");
+					try {
+						// The sentinel bounds the actual read even if an external writer
+						// grows or replaces the file after the earlier metadata check.
+						const buffer = Buffer.allocUnsafe(1024 * 1024 + 1);
+						let total = 0;
+						while (total < buffer.length) {
+							const { bytesRead } = await handle.read(buffer, total, buffer.length - total, total);
+							if (bytesRead === 0) break;
+							total += bytesRead;
+						}
+						skipDiff = total > 1024 * 1024;
+						if (!skipDiff) previousContent = buffer.toString("utf8", 0, total);
+					} finally {
+						await handle.close();
+					}
 				}
-				mkdirSync(dirname(filePath), { recursive: true });
-				writeFileSync(filePath, content, "utf8");
+				const diff = skipDiff ? undefined : generateDiffString(previousContent, content).diff;
+				const file = await publishFileAtomically(filePath, content);
+				return { file, diff, previousEndedWithNewline: previousContent.endsWith("\n"), skipDiff };
 			});
-			const bytes = Buffer.byteLength(content, "utf8");
-			const diff = generateDiffString(previousContent, content).diff;
 			let output = `wrote ${bytes}B to ${pathArg}`;
+			if (skipDiff) output += "\nnote: diff skipped because the previous or new file exceeds 1 MiB";
+			if (file.durabilityWarning) output += `\n${file.durabilityWarning}`;
 			if (previousEndedWithNewline && !content.endsWith("\n")) {
 				output += `\nnote: ${pathArg} no longer ends with a newline; the previous content did`;
 			}
@@ -48,10 +65,19 @@ export const writeTool: ToolSpec = {
 			// before it falls back to the length of the returned text. A write's
 			// text is a confirmation sentence, so without this the ledger printed
 			// the sentence's length as the file size.
-			return { kind: "ok", output, details: { diff, paths: [filePath], observation: { shownBytes: bytes } } };
+			return {
+				kind: "ok",
+				output,
+				details: {
+					file: { before: file.before, after: file.after },
+					diff,
+					paths: [filePath],
+					observation: { shownBytes: bytes },
+				},
+			};
 		} catch (err) {
 			const msg = err instanceof Error ? err.message : String(err);
-			return { kind: "error", message: `write: ${msg}` };
+			return { kind: "error", message: `write: Nothing was published. ${msg}` };
 		}
 	},
 };

package/src/worker/spec-contract.ts

@@ -381,6 +381,33 @@ function validateTarget(value: unknown, runtimeId: string, runtimeAliases: Reado
 	readOptionalEnum(target, "lifecycle", "WorkerSpec.target", TARGET_LIFECYCLES);
 	if (target.auth !== undefined) validateTargetAuth(target.auth);
 	if (target.pricing !== undefined) validateTargetPricing(target.pricing);
+	if (target.cache !== undefined) {
+		const cache = readRecord(target.cache, "WorkerSpec.target.cache");
+		readOptionalEnum(cache, "retention", "WorkerSpec.target.cache", ["none", "short", "long"] as const);
+		if (cache.deployment !== undefined) {
+			const binding = readRecord(cache.deployment, "WorkerSpec.target.cache.deployment");
+			readString(binding.backend, "WorkerSpec.target.cache.deployment.backend");
+			readOptionalEnum(binding, "backend", "WorkerSpec.target.cache.deployment", ["llamacpp", "vllm"] as const);
+			for (const key of ["controlUrl", "model", "build"])
+				readString(binding[key], `WorkerSpec.target.cache.deployment.${key}`);
+			readOptionalString(binding, "gatewayDeploymentId", "WorkerSpec.target.cache.deployment");
+			const url = new URL(readString(binding.controlUrl, "WorkerSpec.target.cache.deployment.controlUrl"));
+			if (!["http:", "https:"].includes(url.protocol) || url.username || url.password || url.search || url.hash)
+				throw new Error(
+					"WorkerSpec.target.cache.deployment.controlUrl must be HTTP(S) without credentials, query, or fragment",
+				);
+		}
+		if (cache.warm !== undefined) {
+			const warm = readRecord(cache.warm, "WorkerSpec.target.cache.warm");
+			for (const key of ["maxInputTokens", "maxDurationMs", "cooldownMs"]) {
+				if (
+					warm[key] !== undefined &&
+					(typeof warm[key] !== "number" || !Number.isSafeInteger(warm[key]) || (warm[key] as number) < 1)
+				)
+					throw new Error(`WorkerSpec.target.cache.warm.${key} must be a positive safe integer`);
+			}
+		}
+	}
 	if (target.capabilities !== undefined) validateCapabilityPatch(target.capabilities, "WorkerSpec.target.capabilities");
 }
 

package/dist/chunk-B6UM3OZC.js

@@ -1,15 +0,0 @@
-import { createRequire as __clioCreateRequire } from "node:module"; const require = __clioCreateRequire(import.meta.url);
-import {
-  init_esm_shims
-} from "./chunk-ECBHH7LU.js";
-
-// src/domains/evidence/ordering.ts
-init_esm_shims();
-function compareCodepoints(left, right) {
-  return left < right ? -1 : left > right ? 1 : 0;
-}
-
-export {
-  compareCodepoints
-};
-//# sourceMappingURL=chunk-B6UM3OZC.js.map

package/dist/chunk-GJ24ODAX.js

@@ -1,196 +0,0 @@
-import { createRequire as __clioCreateRequire } from "node:module"; const require = __clioCreateRequire(import.meta.url);
-import {
-  gitCommitAttributionEnabled,
-  reportCommitAttributionDiagnostic,
-  withManagedGitCommitAttributionEnvironment
-} from "./chunk-LTR5QCLS.js";
-import {
-  clampTimerDelayMs
-} from "./chunk-6EXUUOSN.js";
-import {
-  AI_AGENT_NAME
-} from "./chunk-ZTNFYMIO.js";
-import {
-  init_esm_shims
-} from "./chunk-ECBHH7LU.js";
-
-// src/core/safe-exec.ts
-init_esm_shims();
-import { spawn } from "node:child_process";
-import path from "node:path";
-import { performance } from "node:perf_hooks";
-var SAFE_EXEC_DEFAULT_TIMEOUT_MS = 12e4;
-var SAFE_EXEC_DEFAULT_MAX_OUTPUT_BYTES = 6e5;
-var ENV_ALLOWLIST = [
-  "PATH",
-  "HOME",
-  "USER",
-  "LOGNAME",
-  "LANG",
-  "LC_ALL",
-  "TMPDIR",
-  "TEMP",
-  "TMP",
-  "CI",
-  "NO_COLOR",
-  // Platform/session location variables needed by installed local CLIs. These
-  // locate operator-owned state; provider keys and Clio gates are deliberately
-  // absent from this allowlist.
-  "XDG_CONFIG_HOME",
-  "XDG_CACHE_HOME",
-  "XDG_STATE_HOME",
-  "APPDATA",
-  "LOCALAPPDATA",
-  "SYSTEMROOT",
-  "WINDIR",
-  "COMSPEC",
-  "PATHEXT"
-];
-function buildSafeToolEnv(extra = {}, source = process.env) {
-  const env = {};
-  for (const key of ENV_ALLOWLIST) {
-    const value = source[key];
-    if (value !== void 0) env[key] = value;
-  }
-  for (const [key, value] of Object.entries(extra)) {
-    if (!/^[A-Z_][A-Z0-9_]*$/i.test(key)) continue;
-    env[key] = value;
-  }
-  env.AI_AGENT = AI_AGENT_NAME;
-  return env;
-}
-function resolveSafeCwd(cwd, workspaceRoot = process.cwd()) {
-  const root = path.resolve(workspaceRoot);
-  const resolved = cwd === void 0 ? root : path.isAbsolute(cwd) ? path.resolve(cwd) : path.resolve(root, cwd);
-  const rel = path.relative(root, resolved);
-  if (rel === "" || !rel.startsWith("..") && !path.isAbsolute(rel)) return resolved;
-  throw new Error(`cwd escapes workspace root: ${resolved}`);
-}
-function runCommandVector(file, args, options = {}) {
-  return new Promise((resolve) => {
-    const startedAt = performance.now();
-    const cwd = resolveSafeCwd(options.cwd, options.workspaceRoot);
-    const timeoutMs = clampTimerDelayMs(options.timeoutMs ?? SAFE_EXEC_DEFAULT_TIMEOUT_MS);
-    const maxOutputBytes = options.maxOutputBytes ?? SAFE_EXEC_DEFAULT_MAX_OUTPUT_BYTES;
-    const attribution = withManagedGitCommitAttributionEnvironment(buildSafeToolEnv(options.env), {
-      cwd,
-      enabled: gitCommitAttributionEnabled(process.env)
-    });
-    reportCommitAttributionDiagnostic(attribution.diagnostic);
-    let aborted = false;
-    let timedOut = false;
-    let outputCapped = false;
-    let outputBytes = 0;
-    let stdout = "";
-    let stderr = "";
-    let settled = false;
-    let killSent = false;
-    let timeoutId = null;
-    let killGraceTimer = null;
-    const child = spawn(file, [...args], {
-      cwd,
-      env: attribution.env,
-      detached: process.platform !== "win32",
-      stdio: ["ignore", "pipe", "pipe"]
-    });
-    const clearKillGraceTimer = () => {
-      if (killGraceTimer) clearTimeout(killGraceTimer);
-      killGraceTimer = null;
-    };
-    const sendSignal = (signalName) => {
-      const pid = child.pid;
-      if (pid && process.platform !== "win32") {
-        try {
-          process.kill(-pid, signalName);
-          return;
-        } catch {
-        }
-      }
-      child.kill(signalName);
-    };
-    const killChild = () => {
-      if (killSent) return;
-      killSent = true;
-      sendSignal("SIGTERM");
-      killGraceTimer = setTimeout(() => sendSignal("SIGKILL"), 3e3);
-    };
-    const onAbort = () => {
-      aborted = true;
-      killChild();
-    };
-    if (timeoutMs > 0) {
-      timeoutId = setTimeout(() => {
-        timedOut = true;
-        killChild();
-      }, timeoutMs);
-    }
-    if (options.signal?.aborted) onAbort();
-    else options.signal?.addEventListener("abort", onAbort, { once: true });
-    const appendChunk = (target, chunk) => {
-      outputBytes += chunk.byteLength;
-      if (outputBytes > maxOutputBytes) {
-        outputCapped = true;
-        killChild();
-        return;
-      }
-      if (target === "stdout") stdout += chunk.toString("utf8");
-      else stderr += chunk.toString("utf8");
-    };
-    child.stdout?.on("data", (chunk) => appendChunk("stdout", chunk));
-    child.stderr?.on("data", (chunk) => appendChunk("stderr", chunk));
-    child.on("error", (error) => {
-      if (settled) return;
-      settled = true;
-      if (timeoutId) clearTimeout(timeoutId);
-      clearKillGraceTimer();
-      options.signal?.removeEventListener("abort", onAbort);
-      resolve({
-        file,
-        args: [...args],
-        cwd,
-        stdout,
-        stderr: stderr.length > 0 ? stderr : error.message,
-        exitCode: null,
-        signal: null,
-        aborted,
-        timedOut,
-        outputCapped,
-        durationMs: Math.round(performance.now() - startedAt)
-      });
-    });
-    child.on("close", (code, signalName) => {
-      if (settled) return;
-      settled = true;
-      if (timeoutId) clearTimeout(timeoutId);
-      clearKillGraceTimer();
-      options.signal?.removeEventListener("abort", onAbort);
-      resolve({
-        file,
-        args: [...args],
-        cwd,
-        stdout,
-        stderr,
-        exitCode: code,
-        signal: signalName,
-        aborted,
-        timedOut,
-        outputCapped,
-        durationMs: Math.round(performance.now() - startedAt)
-      });
-    });
-  });
-}
-function combineSafeOutput(result) {
-  const { stdout, stderr } = result;
-  return stderr.length > 0 ? `${stdout}${stdout.endsWith("\n") || stdout.length === 0 ? "" : "\n"}${stderr}` : stdout;
-}
-
-export {
-  SAFE_EXEC_DEFAULT_TIMEOUT_MS,
-  SAFE_EXEC_DEFAULT_MAX_OUTPUT_BYTES,
-  buildSafeToolEnv,
-  resolveSafeCwd,
-  runCommandVector,
-  combineSafeOutput
-};
-//# sourceMappingURL=chunk-GJ24ODAX.js.map

package/dist/chunk-HRAKUPIH.js

@@ -1,57 +0,0 @@
-import { createRequire as __clioCreateRequire } from "node:module"; const require = __clioCreateRequire(import.meta.url);
-import {
-  StringEnum
-} from "./chunk-5CMARGPF.js";
-import {
-  typebox_exports
-} from "./chunk-GH5ZR6JP.js";
-import {
-  ToolNames
-} from "./chunk-WLHX3MM5.js";
-import {
-  init_esm_shims
-} from "./chunk-ECBHH7LU.js";
-
-// src/tools/context/surface.ts
-init_esm_shims();
-var contextToolSurface = {
-  name: ToolNames.Context,
-  description: "Environment context: scope=workspace returns the git/project snapshot, scope=docs searches Clio's bundled documentation (omit query to list the corpus), scope=skills lists installed and marketplace skills or loads an installed one by name, scope=library reads the recipe catalog (installed skills/agents/prompts/fleets with their owner and invocation, plus installable packages) without activating or installing anything, scope=recall returns an exact persisted evicted or summarized tool result by ref; omit ref to discover historical results by query with bounded limit/offset pages. For repository code and the repo's generated wiki use code_nav (mode=wiki).",
-  parameters: typebox_exports.Object({
-    scope: StringEnum(["workspace", "docs", "skills", "library", "recall"], { description: "Context source." }),
-    query: typebox_exports.Optional(
-      typebox_exports.String({
-        description: "scope=docs: question or terms. scope=library: name, owner, or description terms. scope=recall without ref: path, tool, or ref terms; omit to list."
-      })
-    ),
-    name: typebox_exports.Optional(typebox_exports.String({ description: "scope=skills: skill name to load; omit to list." })),
-    kind: typebox_exports.Optional(
-      StringEnum(["skill", "agent", "prompt", "fleet", "plugin"], {
-        description: "scope=library: one recipe kind, or plugin for installable package rows."
-      })
-    ),
-    limit: typebox_exports.Optional(
-      typebox_exports.Number({
-        description: "scope=docs: max sections (default 5, max 12). scope=library: max rows (default 20, max 50). scope=recall: max refs (default 8, max 12)."
-      })
-    ),
-    ref: typebox_exports.Optional(
-      typebox_exports.String({
-        description: "scope=library: exact kind:name or resource key for one record. scope=recall: exact persisted result ref; omit for discovery."
-      })
-    ),
-    offset: typebox_exports.Optional(
-      typebox_exports.Number({
-        description: "scope=library and scope=recall discovery: zero-based offset; follow nextOffset (default 0)."
-      })
-    ),
-    include_tree: typebox_exports.Optional(typebox_exports.Boolean({ description: "scope=skills: list files under the skill base_dir." }))
-  }),
-  baseActionClass: "read",
-  executionMode: "parallel"
-};
-
-export {
-  contextToolSurface
-};
-//# sourceMappingURL=chunk-HRAKUPIH.js.map