toolcraft 0.0.27 → 0.0.34

package/dist/mcp-proxy.js

@@ -1,9 +1,10 @@
 import { existsSync } from "node:fs";
-import { lstat, mkdir, readFile, rename, writeFile } from "node:fs/promises";
+import { lstat, mkdir, readFile, rename, unlink, writeFile } from "node:fs/promises";
 import path from "node:path";
 import { createHash, randomUUID } from "node:crypto";
-import { createLogger } from "@poe-code/design-system";
+import { createLogger } from "toolcraft-design";
 import { HttpTransport, McpClient, StdioTransport } from "tiny-mcp-client";
+import { hasOwnErrorCode } from "./error-codes.js";
 import { convertJsonSchema } from "./json-schema-converter.js";
 const GROUP_CONFIG_SYMBOL_DESCRIPTION = "toolcraft.group.config";
 const MCP_PROXY_SCHEMA_URL = "https://poe-platform.github.io/poe-code/schemas/toolcraft/mcp-proxy.schema.json";
@@ -175,8 +176,7 @@ async function readCache(cachePath) {
         };
     }
     catch (error) {
-        const code = error.code;
-        if (code === "ENOENT" || error instanceof SyntaxError) {
+        if (hasOwnErrorCode(error, "ENOENT") || error instanceof SyntaxError) {
             return undefined;
         }
         return undefined;
@@ -185,14 +185,31 @@ async function readCache(cachePath) {
 async function writeCache(cachePath, cache) {
     const directory = path.dirname(cachePath);
     const tempPath = `${cachePath}.tmp-${randomUUID()}`;
+    let tempCreated = false;
     await assertCachePathHasNoSymlinks(cachePath);
     await assertCachePathHasNoSymlinks(tempPath);
     await mkdir(directory, { recursive: true });
     await assertCachePathHasNoSymlinks(directory);
-    await writeFile(tempPath, `${JSON.stringify(cache, null, 2)}\n`);
-    await assertCachePathHasNoSymlinks(tempPath);
-    await assertCachePathHasNoSymlinks(cachePath);
-    await rename(tempPath, cachePath);
+    try {
+        await writeFile(tempPath, `${JSON.stringify(cache, null, 2)}\n`, {
+            encoding: "utf8",
+            flag: "wx"
+        });
+        tempCreated = true;
+        await assertCachePathHasNoSymlinks(tempPath);
+        await assertCachePathHasNoSymlinks(cachePath);
+        await rename(tempPath, cachePath);
+        tempCreated = false;
+    }
+    catch (error) {
+        if (tempCreated || !isAlreadyExistsError(error)) {
+            await unlink(tempPath).catch(() => undefined);
+        }
+        throw error;
+    }
+}
+function isAlreadyExistsError(error) {
+    return hasOwnErrorCode(error, "EEXIST");
 }
 async function fetchCache(name, config) {
     const logger = createLogger((message) => {
@@ -402,7 +419,7 @@ async function assertCachePathHasNoSymlinks(filePath) {
             }
         }
         catch (error) {
-            if (error.code !== "ENOENT") {
+            if (!hasOwnErrorCode(error, "ENOENT")) {
                 throw error;
             }
         }

package/dist/mcp.js

@@ -93,8 +93,8 @@ function isPlainObject(value) {
 function createFs() {
     return {
         readFile: async (path, encoding = "utf8") => readFile(path, { encoding }),
-        writeFile: async (path, contents) => {
-            await writeFile(path, contents);
+        writeFile: async (path, contents, options) => {
+            await writeFile(path, contents, options);
         },
         exists: async (path) => {
             try {
@@ -356,6 +356,48 @@ function validateSchemaValue(schema, value, casing, label, errors) {
             return value.map((item, index) => validateSchemaValue(unwrappedSchema.item, item, casing, `${label}[${index}]`, errors));
         case "object":
             return validateObjectSchema(unwrappedSchema, value, casing, label, errors);
+        case "json":
+            return value;
+        case "record": {
+            if (!isPlainObject(value)) {
+                errors.push({
+                    path: label,
+                    message: `Invalid value for "${label}". Expected an object, got ${describeReceived(value)}.`
+                });
+                return value;
+            }
+            return Object.fromEntries(Object.entries(value).map(([key, item]) => [
+                key,
+                validateSchemaValue(unwrappedSchema.value, item, casing, `${label}.${key}`, errors)
+            ]));
+        }
+        case "oneOf": {
+            if (!isPlainObject(value)) {
+                return value;
+            }
+            const discriminatorKey = formatSegment(unwrappedSchema.discriminator, casing);
+            const discriminator = value[discriminatorKey];
+            const branch = typeof discriminator === "string" ? unwrappedSchema.branches[discriminator] : undefined;
+            if (branch === undefined) {
+                return value;
+            }
+            const { [discriminatorKey]: ignoredDiscriminator, ...branchValue } = value;
+            void ignoredDiscriminator;
+            return {
+                [unwrappedSchema.discriminator]: discriminator,
+                ...validateObjectSchema(branch, branchValue, casing, label, errors)
+            };
+        }
+        case "union": {
+            if (!isPlainObject(value)) {
+                return value;
+            }
+            const branch = unwrappedSchema.branches.find((candidate) => Object.keys(candidate.shape).every((key) => candidate.shape[key]?.kind === "optional" ||
+                Object.prototype.hasOwnProperty.call(value, formatSegment(key, casing))));
+            return branch === undefined
+                ? value
+                : validateObjectSchema(branch, value, casing, label, errors);
+        }
     }
 }
 function validateObjectSchema(schema, value, casing, label, errors) {
@@ -373,6 +415,15 @@ function validateObjectSchema(schema, value, casing, label, errors) {
     }
     for (const key of Object.keys(value)) {
         if (!expectedKeys.has(key)) {
+            if (schema.additionalProperties === true) {
+                Object.defineProperty(result, key, {
+                    value: value[key],
+                    enumerable: true,
+                    configurable: true,
+                    writable: true
+                });
+                continue;
+            }
             const fieldLabel = label.length === 0 ? key : `${label}.${key}`;
             errors.push({
                 path: fieldLabel,
@@ -557,7 +608,7 @@ function createDeferredMCPServer(root, options) {
 }
 export function createMCPServer(roots, options) {
     const normalizedRoot = normalizeRoots(roots);
-    const root = options.approvals === false ? normalizedRoot : mergeApprovalsGroup(normalizedRoot);
+    const root = options.approvals === true ? mergeApprovalsGroup(normalizedRoot) : normalizedRoot;
     if (!hasMcpProxyGroups(root)) {
         return createResolvedMCPServer(root, options);
     }
@@ -566,7 +617,7 @@ export function createMCPServer(roots, options) {
 export async function runMCP(roots, options) {
     enableSourceMaps();
     const normalizedRoot = normalizeRoots(roots);
-    const root = options.approvals === false ? normalizedRoot : mergeApprovalsGroup(normalizedRoot);
+    const root = options.approvals === true ? mergeApprovalsGroup(normalizedRoot) : normalizedRoot;
     await resolveMcpProxies(root, { projectRoot: options.projectRoot });
     const server = createResolvedMCPServer(root, options);
     await server.listen();

package/dist/renderer.js

@@ -1,5 +1,5 @@
 import YAML from "yaml";
-import { renderDetailCard } from "@poe-code/design-system";
+import { renderDetailCard } from "toolcraft-design";
 function isObject(value) {
     return value !== null && typeof value === "object" && !Array.isArray(value);
 }

package/dist/schema-scope.js

@@ -21,14 +21,35 @@ export function filterSchemaForScope(schema, scope) {
         case "number":
         case "boolean":
         case "enum":
+        case "json":
             return schema;
+        case "record": {
+            const value = filterSchemaForScope(schema.value, scope);
+            return value === undefined ? undefined : { ...schema, value };
+        }
+        case "oneOf":
+            return {
+                ...schema,
+                branches: Object.fromEntries(Object.entries(schema.branches).flatMap(([name, branch]) => {
+                    const filtered = filterSchemaForScope(branch, scope);
+                    return filtered?.kind === "object" ? [[name, filtered]] : [];
+                }))
+            };
+        case "union":
+            return {
+                ...schema,
+                branches: schema.branches.flatMap((branch) => {
+                    const filtered = filterSchemaForScope(branch, scope);
+                    return filtered?.kind === "object" ? [filtered] : [];
+                })
+            };
         case "object":
             return {
                 ...schema,
                 shape: Object.fromEntries(Object.entries(schema.shape).flatMap(([key, childSchema]) => {
                     const filtered = filterSchemaForScope(childSchema, scope);
                     return filtered === undefined ? [] : [[key, filtered]];
-                })),
+                }))
             };
     }
 }

package/dist/sdk.js

@@ -74,8 +74,8 @@ function isPlainObject(value) {
 function createFs() {
     return {
         readFile: async (path, encoding = "utf8") => readFile(path, { encoding }),
-        writeFile: async (path, contents) => {
-            await writeFile(path, contents);
+        writeFile: async (path, contents, options) => {
+            await writeFile(path, contents, options);
         },
         exists: async (path) => {
             try {
@@ -179,6 +179,45 @@ function validateSchemaValue(schema, value, label, errors) {
             return value.map((item, index) => validateSchemaValue(unwrappedSchema.item, item, `${label}[${index}]`, errors));
         case "object":
             return validateObjectSchema(unwrappedSchema, value, label, errors);
+        case "json":
+            return value;
+        case "record": {
+            if (!isPlainObject(value)) {
+                errors.push({
+                    path: label,
+                    message: `Invalid value for "${label}". Expected an object, got ${describeReceived(value)}.`
+                });
+                return value;
+            }
+            return Object.fromEntries(Object.entries(value).map(([key, item]) => [
+                key,
+                validateSchemaValue(unwrappedSchema.value, item, `${label}.${key}`, errors)
+            ]));
+        }
+        case "oneOf": {
+            if (!isPlainObject(value)) {
+                return value;
+            }
+            const discriminator = value[unwrappedSchema.discriminator];
+            const branch = typeof discriminator === "string" ? unwrappedSchema.branches[discriminator] : undefined;
+            if (branch === undefined) {
+                return value;
+            }
+            const { [unwrappedSchema.discriminator]: ignoredDiscriminator, ...branchValue } = value;
+            void ignoredDiscriminator;
+            return {
+                [unwrappedSchema.discriminator]: discriminator,
+                ...validateObjectSchema(branch, branchValue, label, errors)
+            };
+        }
+        case "union": {
+            if (!isPlainObject(value)) {
+                return value;
+            }
+            const branch = unwrappedSchema.branches.find((candidate) => Object.keys(candidate.shape).every((key) => candidate.shape[key]?.kind === "optional" ||
+                Object.prototype.hasOwnProperty.call(value, formatSegment(key))));
+            return branch === undefined ? value : validateObjectSchema(branch, value, label, errors);
+        }
     }
 }
 function validateObjectSchema(schema, value, label, errors) {
@@ -196,6 +235,15 @@ function validateObjectSchema(schema, value, label, errors) {
     }
     for (const key of Object.keys(value)) {
         if (!expectedKeys.has(key)) {
+            if (schema.additionalProperties === true) {
+                Object.defineProperty(result, key, {
+                    value: value[key],
+                    enumerable: true,
+                    configurable: true,
+                    writable: true
+                });
+                continue;
+            }
             const fieldLabel = label.length === 0 ? key : `${label}.${key}`;
             errors.push({
                 path: fieldLabel,
@@ -266,7 +314,7 @@ function defineMember(target, key, value) {
 }
 export function createSDK(root, options = {}) {
     enableSourceMaps();
-    const mergedRoot = options.approvals === false ? root : mergeApprovalsGroup(root);
+    const mergedRoot = options.approvals === true ? mergeApprovalsGroup(root) : root;
     if (!hasMcpProxyGroups(mergedRoot)) {
         return createResolvedSDK(mergedRoot, options);
     }

package/dist/source-snippet.js

@@ -1,4 +1,4 @@
-import { text } from "@poe-code/design-system";
+import { text } from "toolcraft-design";
 export function renderSourceSnippet(opts) {
     const lines = opts.source.replaceAll("\r\n", "\n").replaceAll("\r", "\n").split("\n");
     const line = clampInteger(opts.line, 1, Math.max(lines.length, 1));

package/node_modules/@poe-code/agent-defs/dist/agents/claude-code.js

@@ -6,6 +6,11 @@ export const claudeCodeAgent = {
     aliases: ["claude"],
     binaryName: "claude",
     apiShapes: ["anthropic-messages"],
+    otelCapture: {
+        env: {
+            CLAUDE_CODE_ENABLE_TELEMETRY: "1"
+        }
+    },
     configPath: "~/.claude/settings.json",
     branding: {
         colors: {

package/node_modules/@poe-code/agent-defs/dist/agents/codex.js

@@ -5,6 +5,16 @@ export const codexAgent = {
     summary: "Configure Codex to use Poe as the model provider.",
     binaryName: "codex",
     apiShapes: ["openai-responses"],
+    otelCapture: {
+        args: (endpoint, content) => [
+            "-c",
+            `otel.trace_exporter={"otlp-http"={endpoint=${JSON.stringify(`${endpoint}/v1/traces`)},protocol="json"}}`,
+            "-c",
+            `otel.exporter={"otlp-http"={endpoint=${JSON.stringify(`${endpoint}/v1/logs`)},protocol="json"}}`,
+            "-c",
+            `otel.log_user_prompt=${content}`
+        ]
+    },
     configPath: "~/.codex/config.toml",
     branding: {
         colors: {

package/node_modules/@poe-code/agent-defs/dist/agents/cursor.d.ts

@@ -0,0 +1,2 @@
+import type { AgentDefinition } from "../types.js";
+export declare const cursorAgent: AgentDefinition;

package/node_modules/@poe-code/agent-defs/dist/agents/cursor.js

@@ -0,0 +1,15 @@
+export const cursorAgent = {
+    id: "cursor",
+    name: "cursor",
+    aliases: ["cursor-agent"],
+    label: "Cursor",
+    summary: "Cursor's CLI coding agent.",
+    binaryName: "cursor-agent",
+    configPath: "~/.cursor/cli-config.json",
+    branding: {
+        colors: {
+            dark: "#FFFFFF",
+            light: "#000000"
+        }
+    }
+};

package/node_modules/@poe-code/agent-defs/dist/agents/goose.js

@@ -5,6 +5,7 @@ export const gooseAgent = {
     summary: "Block's open-source AI agent with ACP support.",
     binaryName: "goose",
     apiShapes: ["openai-chat-completions"],
+    otelCapture: {},
     configPath: "~/.config/goose/config.yaml",
     branding: {
         colors: {

package/node_modules/@poe-code/agent-defs/dist/agents/index.d.ts

@@ -1,6 +1,7 @@
 export { claudeCodeAgent } from "./claude-code.js";
 export { claudeDesktopAgent } from "./claude-desktop.js";
 export { codexAgent } from "./codex.js";
+export { cursorAgent } from "./cursor.js";
 export { geminiCliAgent } from "./gemini-cli.js";
 export { openCodeAgent } from "./opencode.js";
 export { kimiAgent } from "./kimi.js";

package/node_modules/@poe-code/agent-defs/dist/agents/index.js

@@ -1,6 +1,7 @@
 export { claudeCodeAgent } from "./claude-code.js";
 export { claudeDesktopAgent } from "./claude-desktop.js";
 export { codexAgent } from "./codex.js";
+export { cursorAgent } from "./cursor.js";
 export { geminiCliAgent } from "./gemini-cli.js";
 export { openCodeAgent } from "./opencode.js";
 export { kimiAgent } from "./kimi.js";

package/node_modules/@poe-code/agent-defs/dist/agents/opencode.js

@@ -5,6 +5,11 @@ export const openCodeAgent = {
     summary: "Configure OpenCode CLI to use the Poe API.",
     binaryName: "opencode",
     apiShapes: ["openai-chat-completions"],
+    otelCapture: {
+        env: {
+            OPENCODE_CONFIG_CONTENT: '{"experimental":{"openTelemetry":true}}'
+        }
+    },
     configPath: "~/.config/opencode/config.json",
     branding: {
         colors: {

package/node_modules/@poe-code/agent-defs/dist/index.d.ts

@@ -1,5 +1,5 @@
-export type { AgentDefinition, ApiShapeId } from "./types.js";
+export type { AgentDefinition, ApiShapeId, OtelCaptureDefinition } from "./types.js";
 export type { AgentSpecifier } from "./specifier.js";
-export { claudeCodeAgent, claudeDesktopAgent, codexAgent, geminiCliAgent, openCodeAgent, kimiAgent, gooseAgent, poeAgentAgent } from "./agents/index.js";
+export { claudeCodeAgent, claudeDesktopAgent, codexAgent, cursorAgent, geminiCliAgent, openCodeAgent, kimiAgent, gooseAgent, poeAgentAgent } from "./agents/index.js";
 export { allAgents, resolveAgentId } from "./registry.js";
 export { parseAgentSpecifier, formatAgentSpecifier, normalizeAgentId } from "./specifier.js";

package/node_modules/@poe-code/agent-defs/dist/index.js

@@ -1,3 +1,3 @@
-export { claudeCodeAgent, claudeDesktopAgent, codexAgent, geminiCliAgent, openCodeAgent, kimiAgent, gooseAgent, poeAgentAgent } from "./agents/index.js";
+export { claudeCodeAgent, claudeDesktopAgent, codexAgent, cursorAgent, geminiCliAgent, openCodeAgent, kimiAgent, gooseAgent, poeAgentAgent } from "./agents/index.js";
 export { allAgents, resolveAgentId } from "./registry.js";
 export { parseAgentSpecifier, formatAgentSpecifier, normalizeAgentId } from "./specifier.js";

package/node_modules/@poe-code/agent-defs/dist/registry.js

@@ -1,4 +1,4 @@
-import { claudeCodeAgent, claudeDesktopAgent, codexAgent, geminiCliAgent, openCodeAgent, kimiAgent, gooseAgent, poeAgentAgent } from "./agents/index.js";
+import { claudeCodeAgent, claudeDesktopAgent, codexAgent, cursorAgent, geminiCliAgent, openCodeAgent, kimiAgent, gooseAgent, poeAgentAgent } from "./agents/index.js";
 function freezeAgent(agent) {
     if (agent.aliases !== undefined) {
         Object.freeze(agent.aliases);
@@ -6,6 +6,12 @@ function freezeAgent(agent) {
     if (agent.apiShapes !== undefined) {
         Object.freeze(agent.apiShapes);
     }
+    if (agent.otelCapture?.env !== undefined) {
+        Object.freeze(agent.otelCapture.env);
+    }
+    if (agent.otelCapture !== undefined) {
+        Object.freeze(agent.otelCapture);
+    }
     Object.freeze(agent.branding.colors);
     Object.freeze(agent.branding);
     return Object.freeze(agent);
@@ -14,6 +20,7 @@ export const allAgents = Object.freeze([
     freezeAgent(claudeCodeAgent),
     freezeAgent(claudeDesktopAgent),
     freezeAgent(codexAgent),
+    freezeAgent(cursorAgent),
     freezeAgent(geminiCliAgent),
     freezeAgent(openCodeAgent),
     freezeAgent(kimiAgent),

package/node_modules/@poe-code/agent-defs/dist/specifier.js

@@ -1,4 +1,7 @@
 import { resolveAgentId } from "./registry.js";
+function getOwnModel(specifier) {
+    return Object.prototype.hasOwnProperty.call(specifier, "model") ? specifier.model : undefined;
+}
 export function parseAgentSpecifier(input) {
     const colonIndex = input.indexOf(":");
     if (colonIndex === -1) {
@@ -12,8 +15,9 @@ export function parseAgentSpecifier(input) {
     };
 }
 export function formatAgentSpecifier(specifier) {
-    if (specifier.model) {
-        return `${specifier.agent}:${specifier.model}`;
+    const model = getOwnModel(specifier);
+    if (model) {
+        return `${specifier.agent}:${model}`;
     }
     return specifier.agent;
 }
@@ -22,6 +26,6 @@ export function normalizeAgentId(input) {
     const agent = resolveAgentId(specifier.agent) ?? specifier.agent;
     return formatAgentSpecifier({
         agent,
-        model: specifier.model
+        model: getOwnModel(specifier)
     });
 }

package/node_modules/@poe-code/agent-defs/dist/types.d.ts

@@ -1,4 +1,8 @@
 export type ApiShapeId = "openai-chat-completions" | "openai-responses" | "anthropic-messages" | "google-generations";
+export interface OtelCaptureDefinition {
+    env?: Record<string, string>;
+    args?: (endpoint: string, content: boolean) => string[];
+}
 export interface AgentDefinition {
     id: string;
     name: string;
@@ -8,6 +12,7 @@ export interface AgentDefinition {
     /** Binary name for CLI agents. Optional for GUI-only apps like Claude Desktop. */
     binaryName?: string;
     readonly apiShapes?: readonly ApiShapeId[];
+    readonly otelCapture?: OtelCaptureDefinition;
     configPath: string;
     branding: {
         colors: {

package/node_modules/@poe-code/agent-human-in-loop/dist/providers/osascript.js

@@ -19,7 +19,7 @@ export function osascriptProvider(options = {}) {
                 return parseStdout(stdout);
             }
             catch (error) {
-                if (error.code === "ENOENT") {
+                if (hasOwnErrorCode(error, "ENOENT")) {
                     throw new Error("osascript not found — provide a different provider on this platform");
                 }
                 if (isUserCanceled(error)) {
@@ -31,3 +31,9 @@ export function osascriptProvider(options = {}) {
         }
     };
 }
+function hasOwnErrorCode(error, code) {
+    return (typeof error === "object" &&
+        error !== null &&
+        Object.prototype.hasOwnProperty.call(error, "code") &&
+        error.code === code);
+}

package/node_modules/@poe-code/agent-mcp-config/dist/configs.js

@@ -31,6 +31,12 @@ const agentMcpConfigs = {
         format: "toml",
         shape: "standard"
     },
+    cursor: {
+        configFile: "~/.cursor/mcp.json",
+        configKey: "mcpServers",
+        format: "json",
+        shape: "standard"
+    },
     opencode: {
         configFile: "~/.config/opencode/opencode.json",
         configKey: "mcp",

package/node_modules/@poe-code/config-mutations/dist/error-codes.d.ts

@@ -0,0 +1 @@
+export declare function hasOwnErrorCode(error: unknown, code: string): error is NodeJS.ErrnoException;

package/node_modules/@poe-code/config-mutations/dist/error-codes.js

@@ -0,0 +1,6 @@
+export function hasOwnErrorCode(error, code) {
+    return (typeof error === "object" &&
+        error !== null &&
+        Object.prototype.hasOwnProperty.call(error, "code") &&
+        error.code === code);
+}

package/node_modules/@poe-code/config-mutations/dist/execution/apply-mutation.js

@@ -1,9 +1,11 @@
+import { randomUUID } from "node:crypto";
 import path from "node:path";
-import { renderTemplate } from "@poe-code/design-system";
+import { renderTemplate } from "toolcraft-design";
 import { getConfigFormat, detectFormat } from "../formats/index.js";
 import { cloneConfigObject, setConfigEntry } from "../formats/object.js";
 import { resolvePath } from "./path-utils.js";
 import { isNotFound, readFileIfExists, pathExists, createTimestamp } from "../fs-utils.js";
+import { hasOwnErrorCode } from "../error-codes.js";
 // ============================================================================
 // Helper Functions
 // ============================================================================
@@ -29,6 +31,7 @@ async function backupInvalidDocument(context, targetPath, content) {
         }
         catch (error) {
             if (!isAlreadyExists(error)) {
+                await context.fs.unlink(backupPath).catch(() => undefined);
                 throw error;
             }
             attempt += 1;
@@ -36,7 +39,7 @@ async function backupInvalidDocument(context, targetPath, content) {
     }
 }
 function isAlreadyExists(error) {
-    return Boolean(error && typeof error === "object" && "code" in error && error.code === "EEXIST");
+    return hasOwnErrorCode(error, "EEXIST");
 }
 async function assertRegularWriteTarget(context, targetPath) {
     // Symlinks inside the managed home directory are untrusted: an attacker could
@@ -65,30 +68,36 @@ async function assertRegularWriteTarget(context, targetPath) {
 }
 async function writeAtomically(context, targetPath, content) {
     await assertRegularWriteTarget(context, targetPath);
-    let attempt = 0;
-    while (true) {
-        const tempPath = `${targetPath}.mutation-tmp-${attempt}`;
+    for (let attempt = 0; attempt < 10; attempt += 1) {
+        const tempPath = `${targetPath}.mutation-tmp-${process.pid}-${randomUUID()}`;
+        let tempCreated = false;
         try {
+            await assertRegularWriteTarget(context, tempPath);
             await context.fs.writeFile(tempPath, content, { encoding: "utf8", flag: "wx" });
+            tempCreated = true;
             await context.fs.rename(tempPath, targetPath);
+            tempCreated = false;
             return;
         }
         catch (error) {
-            if (isAlreadyExists(error)) {
-                attempt += 1;
-                continue;
-            }
-            try {
-                await context.fs.unlink(tempPath);
-            }
-            catch (cleanupError) {
-                if (!isNotFound(cleanupError)) {
-                    void cleanupError;
+            const alreadyExists = isAlreadyExists(error);
+            if (tempCreated || !alreadyExists) {
+                try {
+                    await context.fs.unlink(tempPath);
+                }
+                catch (cleanupError) {
+                    if (!isNotFound(cleanupError)) {
+                        void cleanupError;
+                    }
                 }
             }
+            if (alreadyExists) {
+                continue;
+            }
             throw error;
         }
     }
+    throw new Error(`Unable to create temporary mutation file for ${targetPath}.`);
 }
 function describeMutation(kind, targetPath) {
     const displayPath = targetPath ?? "target";
@@ -392,6 +401,7 @@ async function applyBackup(mutation, context, options) {
             }
             catch (error) {
                 if (!isAlreadyExists(error)) {
+                    await context.fs.unlink(backupPath).catch(() => undefined);
                     throw error;
                 }
                 attempt += 1;

package/node_modules/@poe-code/config-mutations/dist/formats/json.js

@@ -39,7 +39,7 @@ function merge(base, patch) {
         if (value === undefined) {
             continue;
         }
-        const existing = result[key];
+        const existing = hasConfigEntry(result, key) ? result[key] : undefined;
         if (isConfigObject(existing) && isConfigObject(value)) {
             setConfigEntry(result, key, merge(existing, value));
             continue;

package/node_modules/@poe-code/config-mutations/dist/formats/toml.js

@@ -23,7 +23,7 @@ function merge(base, patch) {
         if (value === undefined) {
             continue;
         }
-        const existing = result[key];
+        const existing = hasConfigEntry(result, key) ? result[key] : undefined;
         if (isConfigObject(existing) && isConfigObject(value)) {
             setConfigEntry(result, key, merge(existing, value));
             continue;

package/node_modules/@poe-code/config-mutations/dist/formats/yaml.js

@@ -26,7 +26,7 @@ function merge(base, patch) {
         if (value === undefined) {
             continue;
         }
-        const existing = result[key];
+        const existing = hasConfigEntry(result, key) ? result[key] : undefined;
         if (isConfigObject(existing) && isConfigObject(value)) {
             setConfigEntry(result, key, merge(existing, value));
             continue;

package/node_modules/@poe-code/config-mutations/dist/fs-utils.js

@@ -1,11 +1,9 @@
+import { hasOwnErrorCode } from "./error-codes.js";
 /**
  * Check if an error is a "file not found" (ENOENT) error.
  */
 export function isNotFound(error) {
-    return (typeof error === "object" &&
-        error !== null &&
-        "code" in error &&
-        error.code === "ENOENT");
+    return hasOwnErrorCode(error, "ENOENT");
 }
 /**
  * Read a file if it exists, returning null if not found.