poe-code 3.0.242 → 3.0.243

package/dist/index.js

@@ -85710,7 +85710,7 @@ async function replaceBasePathAtomically(fs28, filePath, createTemporaryPath) {
       if (isAlreadyExistsError14(error3) && !temporaryCreated) {
         continue;
       }
-      if (temporaryCreated) {
+      if (temporaryCreated || !isAlreadyExistsError14(error3)) {
         await fs28.unlink(temporaryPath).catch((cleanupError) => {
           if (!isNotFoundError10(cleanupError)) {
             throw cleanupError;
@@ -88226,8 +88226,8 @@ async function downloadToFile(options) {
     temporaryCreated = true;
     await options.fs.rename(temporaryPath, options.outputPath);
     temporaryCreated = false;
-  } catch {
-    if (temporaryCreated) {
+  } catch (error3) {
+    if (temporaryCreated || !isAlreadyExists8(error3)) {
       await options.fs.unlink(temporaryPath).catch(() => void 0);
     }
     throw new MediaDownloadError("Failed to write media", {
@@ -88237,6 +88237,9 @@ async function downloadToFile(options) {
     });
   }
 }
+function isAlreadyExists8(error3) {
+  return error3 instanceof Error && "code" in error3 && error3.code === "EEXIST";
+}
 var MediaDownloadError;
 var init_media_download = __esm({
   "src/services/media-download.ts"() {
@@ -91114,7 +91117,14 @@ async function pathExists12(fs28, targetPath) {
 }
 async function writePipelineTextFile(fs28, filePath, content, options) {
   if (options.exclusive) {
-    await fs28.writeFile(filePath, content, { encoding: "utf8", flag: "wx" });
+    try {
+      await fs28.writeFile(filePath, content, { encoding: "utf8", flag: "wx" });
+    } catch (error3) {
+      if (!isAlreadyExists9(error3)) {
+        await fs28.unlink(filePath).catch(() => void 0);
+      }
+      throw error3;
+    }
     return;
   }
   const temporaryPath = `${filePath}.${process.pid}.${randomUUID38()}.tmp`;
@@ -91124,12 +91134,15 @@ async function writePipelineTextFile(fs28, filePath, content, options) {
     temporaryCreated = true;
     await fs28.rename(temporaryPath, filePath);
   } catch (error3) {
-    if (temporaryCreated) {
+    if (temporaryCreated || !isAlreadyExists9(error3)) {
       await fs28.unlink(temporaryPath).catch(() => void 0);
     }
     throw error3;
   }
 }
+function isAlreadyExists9(error3) {
+  return error3 instanceof Error && "code" in error3 && error3.code === "EEXIST";
+}
 function registerPipelineCommand(program, container) {
   const pipeline = program.command("pipeline").description("Run a fixed-step task pipeline plan.").addHelpCommand(false);
   pipeline.command("run").description(
@@ -91962,12 +91975,15 @@ async function writeTextFileAtomically(fs28, filePath, content, options) {
     temporaryCreated = true;
     await fs28.rename(temporaryPath, filePath);
   } catch (error3) {
-    if (temporaryCreated) {
+    if (temporaryCreated || !isAlreadyExists10(error3)) {
       await fs28.unlink(temporaryPath).catch(() => void 0);
     }
     throw error3;
   }
 }
+function isAlreadyExists10(error3) {
+  return error3 instanceof Error && "code" in error3 && error3.code === "EEXIST";
+}
 async function resolveDocPath2(options) {
   if (options.providedDoc && options.providedDoc.trim().length > 0) {
     return options.providedDoc.trim();
@@ -93161,10 +93177,17 @@ function registerExperimentCommand(program, container) {
           if (flags.dryRun) {
             resources.logger.dryRun(`Would create: ${runYamlDisplayPath}`);
           } else {
-            await container.fs.writeFile(runYamlPath, templates.runYaml, {
-              encoding: "utf8",
-              flag: "wx"
-            });
+            try {
+              await container.fs.writeFile(runYamlPath, templates.runYaml, {
+                encoding: "utf8",
+                flag: "wx"
+              });
+            } catch (error3) {
+              if (!isAlreadyExists11(error3)) {
+                await container.fs.unlink(runYamlPath).catch(() => void 0);
+              }
+              throw error3;
+            }
             createdRunYaml = true;
             resources.logger.info(`Create: ${runYamlDisplayPath}`);
           }
@@ -93208,6 +93231,9 @@ function registerExperimentCommand(program, container) {
     }
   });
 }
+function isAlreadyExists11(error3) {
+  return error3 instanceof Error && "code" in error3 && error3.code === "EEXIST";
+}
 var DEFAULT_EXPERIMENT_AGENT, DEFAULT_EXPERIMENT_SCOPE, experimentTemplatesCache;
 var init_experiment3 = __esm({
   async "src/cli/commands/experiment.ts"() {
@@ -97183,10 +97209,17 @@ async function writeDefaultDockerfileIfNeeded(input) {
     return false;
   }
   await input.container.fs.mkdir(path156.dirname(dockerfilePath), { recursive: true });
-  await input.container.fs.writeFile(dockerfilePath, defaultDockerfile, {
-    encoding: "utf8",
-    flag: "wx"
-  });
+  try {
+    await input.container.fs.writeFile(dockerfilePath, defaultDockerfile, {
+      encoding: "utf8",
+      flag: "wx"
+    });
+  } catch (error3) {
+    if (!isAlreadyExists12(error3)) {
+      await input.container.fs.unlink(dockerfilePath).catch(() => void 0);
+    }
+    throw error3;
+  }
   return true;
 }
 function parseRuntimeType2(value) {
@@ -97195,6 +97228,9 @@ function parseRuntimeType2(value) {
   }
   throw new Error(`Invalid runtime type "${value}". Expected host, docker, or e2b.`);
 }
+function isAlreadyExists12(error3) {
+  return error3 instanceof Error && "code" in error3 && error3.code === "EEXIST";
+}
 var runtimeTypes, defaultRuntimeType, defaultDockerfile;
 var init_shared2 = __esm({
   "src/cli/commands/runtime/shared.ts"() {
@@ -126013,24 +126049,14 @@ async function executeHarnessNew(program, container, kind, basename10, options)
     readFile56(template2.ajsPath, "utf8")
   ]);
   await container.fs.mkdir(resolvedDir, { recursive: true });
+  const createdPaths = [];
   try {
-    await Promise.all([
-      container.fs.writeFile(mdPath, mdSource, { encoding: "utf8", flag: "wx" }),
-      container.fs.writeFile(ajsPath, ajsSource, { encoding: "utf8", flag: "wx" })
-    ]);
+    await writeHarnessScaffoldFile(container.fs, mdPath, mdSource);
+    createdPaths.push(mdPath);
+    await writeHarnessScaffoldFile(container.fs, ajsPath, ajsSource);
+    createdPaths.push(ajsPath);
   } catch (error3) {
-    await Promise.all([
-      container.fs.unlink(mdPath).catch((cleanupError) => {
-        if (!hasErrorCode7(cleanupError, "ENOENT")) {
-          throw cleanupError;
-        }
-      }),
-      container.fs.unlink(ajsPath).catch((cleanupError) => {
-        if (!hasErrorCode7(cleanupError, "ENOENT")) {
-          throw cleanupError;
-        }
-      })
-    ]).catch(() => void 0);
+    await cleanupHarnessScaffoldFiles(container.fs, createdPaths);
     throw error3;
   }
   resources.context.complete({
@@ -126039,6 +126065,22 @@ async function executeHarnessNew(program, container, kind, basename10, options)
   });
   resources.context.finalize();
 }
+async function writeHarnessScaffoldFile(fs28, filePath, source) {
+  try {
+    await fs28.writeFile(filePath, source, { encoding: "utf8", flag: "wx" });
+  } catch (error3) {
+    if (!hasErrorCode7(error3, "EEXIST")) {
+      await tryUnlinkHarnessScaffoldFile(fs28, filePath);
+    }
+    throw error3;
+  }
+}
+async function cleanupHarnessScaffoldFiles(fs28, filePaths) {
+  await Promise.all(filePaths.map((filePath) => tryUnlinkHarnessScaffoldFile(fs28, filePath)));
+}
+async function tryUnlinkHarnessScaffoldFile(fs28, filePath) {
+  await fs28.unlink(filePath).catch(() => void 0);
+}
 async function executeHarnessList(program, container) {
   const flags = resolveCommandFlags(program);
   const resources = createExecutionResources(container, flags, "harness:list");
@@ -127088,7 +127130,7 @@ var init_package2 = __esm({
   "package.json"() {
     package_default2 = {
       name: "poe-code",
-      version: "3.0.242",
+      version: "3.0.243",
       description: "CLI tool to configure Poe API for developer workflows.",
       type: "module",
       main: "./dist/index.js",