poe-code 3.0.351 → 3.0.352

package/dist/index.js

@@ -93655,6 +93655,7 @@ var init_decimal_integer = __esm({
 
 // src/cli/commands/spawn.ts
 import path145 from "node:path";
+import { randomUUID as randomUUID39 } from "node:crypto";
 import { Option as Option3 } from "commander";
 function registerSpawnCommand(program, container, options = {}) {
   const spawnServices = container.registry.list().filter((service) => typeof service.spawn === "function" || getSpawnConfig(service.name));
@@ -93861,6 +93862,7 @@ function registerSpawnCommand(program, container, options = {}) {
           mcpServers
         );
         if (flags.dryRun) {
+          validateDryRunBridgeResources(canonicalService, container, spawnOptions);
           await spawnCore(container, canonicalService, spawnOptions, {
             dryRun: true,
             verbose: flags.verbose
@@ -94251,6 +94253,45 @@ function resolveHookOptions(from, strategy, scope, command) {
     ...scope ? { scope } : {}
   };
 }
+function validateDryRunBridgeResources(service, container, options) {
+  if ((options.skills === void 0 || options.skills.length === 0) && options.hooks === void 0) {
+    return;
+  }
+  const runId = randomUUID39();
+  let skillsManifest;
+  let hooksManifest;
+  try {
+    if (options.skills !== void 0 && options.skills.length > 0) {
+      skillsManifest = bridgeActiveSkills(
+        service,
+        options.cwd ?? container.env.cwd,
+        options.skills,
+        container.env.homeDir,
+        runId
+      );
+    }
+    if (options.hooks !== void 0) {
+      hooksManifest = bridgeHooks(
+        options.hooks.from,
+        service,
+        options.cwd ?? container.env.cwd,
+        container.env.homeDir,
+        runId,
+        {
+          strategy: options.hooks.strategy === "auto" ? void 0 : options.hooks.strategy,
+          ...options.hooks.scope !== void 0 ? { scope: options.hooks.scope } : {}
+        }
+      );
+    }
+  } finally {
+    if (hooksManifest !== void 0) {
+      cleanupBridgedHooks(hooksManifest);
+    }
+    if (skillsManifest !== void 0) {
+      cleanupBridgedSkills(skillsManifest);
+    }
+  }
+}
 function assertSpawnSupport(label, service, providerSupportsSpawn) {
   if (providerSupportsSpawn) {
     return;
@@ -94282,6 +94323,8 @@ var init_spawn6 = __esm({
     "use strict";
     init_src17();
     init_src7();
+    init_src14();
+    init_src15();
     init_src2();
     init_config5();
     init_shared();
@@ -95792,7 +95835,7 @@ var init_test = __esm({
 });
 
 // src/services/media-download.ts
-import { randomUUID as randomUUID39 } from "node:crypto";
+import { randomUUID as randomUUID40 } from "node:crypto";
 async function downloadToFile(options) {
   const fetcher = options.fetcher ?? globalThis.fetch;
   if (!fetcher) {
@@ -95823,7 +95866,7 @@ async function downloadToFile(options) {
       outputPath: options.outputPath
     });
   }
-  const temporaryPath = `${options.outputPath}.${process.pid}.${randomUUID39()}.tmp`;
+  const temporaryPath = `${options.outputPath}.${process.pid}.${randomUUID40()}.tmp`;
   let temporaryCreated = false;
   try {
     await options.fs.writeFile(temporaryPath, buffer, { flag: "wx" });
@@ -98253,7 +98296,7 @@ var init_dashboard_loop_shared = __esm({
 });
 
 // src/cli/commands/pipeline.ts
-import { randomUUID as randomUUID40 } from "node:crypto";
+import { randomUUID as randomUUID41 } from "node:crypto";
 import path148 from "node:path";
 import { readFile as readFile39, stat as stat24 } from "node:fs/promises";
 import { fileURLToPath as fileURLToPath10 } from "node:url";
@@ -98828,7 +98871,7 @@ async function writePipelineTextFile(fs29, filePath, content, options) {
     }
     return;
   }
-  const temporaryPath = `${filePath}.${process.pid}.${randomUUID40()}.tmp`;
+  const temporaryPath = `${filePath}.${process.pid}.${randomUUID41()}.tmp`;
   let temporaryCreated = false;
   try {
     await fs29.writeFile(temporaryPath, content, { encoding: "utf8", flag: "wx" });
@@ -99433,7 +99476,7 @@ var init_pipeline5 = __esm({
 });
 
 // src/cli/commands/ralph.ts
-import { randomUUID as randomUUID41 } from "node:crypto";
+import { randomUUID as randomUUID42 } from "node:crypto";
 import path149 from "node:path";
 function formatRalphAgentSummary(agent3) {
   return Array.isArray(agent3) ? agent3.join(", ") : agent3;
@@ -99678,7 +99721,7 @@ async function writeTextFileAtomically(fs29, filePath, content, options) {
     await fs29.writeFile(filePath, content, { encoding: "utf8" });
     return;
   }
-  const temporaryPath = `${filePath}.${process.pid}.${randomUUID41()}.tmp`;
+  const temporaryPath = `${filePath}.${process.pid}.${randomUUID42()}.tmp`;
   let temporaryCreated = false;
   try {
     await fs29.writeFile(temporaryPath, content, { encoding: "utf8", flag: "wx" });
@@ -101032,6 +101075,7 @@ function registerLaunchCommand(program, container) {
     const flags = resolveCommandFlags(program);
     const resources = createExecutionResources(container, flags, `launch:stop:${id}`);
     if (flags.dryRun) {
+      await validateManagedProcessExists(container, id);
       resources.logger.dryRun(`Dry run: would stop managed process ${id}.`);
       return;
     }
@@ -101048,6 +101092,7 @@ function registerLaunchCommand(program, container) {
     const flags = resolveCommandFlags(program);
     const resources = createExecutionResources(container, flags, `launch:restart:${id}`);
     if (flags.dryRun) {
+      await validateManagedProcessExists(container, id);
       resources.logger.dryRun(`Dry run: would restart managed process ${id}.`);
       return;
     }
@@ -101337,6 +101382,15 @@ function formatReadinessWait(readyCheck) {
   }
   return `waiting for TCP port ${readyCheck.port}`;
 }
+async function validateManagedProcessExists(container, id) {
+  const records = await listLaunches({ homeDir: container.env.homeDir });
+  if (!records.some((record) => getManagedProcessId(record) === id)) {
+    throw new ValidationError(`Managed process not found: ${id}`);
+  }
+}
+function getManagedProcessId(record) {
+  return record.spec?.id ?? record.state?.id ?? record.id;
+}
 function formatManagedProcessStatus(record, fallbackId) {
   const id = record.spec?.id ?? record.state?.id ?? fallbackId;
   if (record.state?.status) {
@@ -102079,10 +102133,10 @@ var init_status = __esm({
 });
 
 // packages/memory/src/atomic-write.ts
-import { randomUUID as randomUUID42 } from "node:crypto";
+import { randomUUID as randomUUID43 } from "node:crypto";
 import * as fs18 from "node:fs/promises";
 async function writeFileAtomically7(filePath, content) {
-  const tempPath = `${filePath}.${process.pid}.${randomUUID42()}.tmp`;
+  const tempPath = `${filePath}.${process.pid}.${randomUUID43()}.tmp`;
   let tempCreated = false;
   try {
     await fs18.writeFile(tempPath, content, { encoding: "utf8", flag: "wx" });
@@ -102492,7 +102546,7 @@ var init_reconcile2 = __esm({
 });
 
 // packages/memory/src/write.ts
-import { randomUUID as randomUUID43 } from "node:crypto";
+import { randomUUID as randomUUID44 } from "node:crypto";
 import * as fs20 from "node:fs/promises";
 import path158 from "node:path";
 async function writePage(root, relPath, body, opts) {
@@ -102545,8 +102599,8 @@ function parseAppendTarget(originalPage, relPath) {
 }
 async function clearMemory(root) {
   await assertMemoryRootIsNotSymlink(root);
-  const stagedRoot = `${root}.clear-${randomUUID43()}`;
-  const backupRoot = `${root}.backup-${randomUUID43()}`;
+  const stagedRoot = `${root}.clear-${randomUUID44()}`;
+  const backupRoot = `${root}.backup-${randomUUID44()}`;
   let originalMoved = false;
   try {
     await initMemory(stagedRoot);
@@ -104945,11 +104999,11 @@ async function executeRuntimeBuild(program, container, options) {
       resources.logger.info(`Docker runtime uses pinned image ${runtimeConfig.image}.`);
       return;
     }
+    await requireRuntimeBuildPaths(container, runtimeConfig, "Docker");
     if (flags.dryRun) {
       resources.logger.dryRun("Dry run: would build docker runtime template.");
       return;
     }
-    await requireRuntimeBuildPaths(container, runtimeConfig, "Docker");
     const result = await buildDockerRuntimeTemplate({
       cwd: container.env.cwd,
       runtime: runtimeConfig,
@@ -105388,6 +105442,7 @@ async function executeRuntimeJobsAttach(root, container, jobId, options) {
   const resources = createExecutionResources(container, flags, "runtime:jobs:attach");
   const state = createRuntimeState(container);
   const entry = await resolveJob(state, jobId, "running");
+  const since = parseSince(options.since);
   if (flags.dryRun) {
     const syncDetail = options.syncOnExit === true ? " and sync its workspace on exit" : "";
     resources.logger.dryRun(`Dry run: would attach to runtime job ${entry.id}${syncDetail}.`);
@@ -105398,7 +105453,7 @@ async function executeRuntimeJobsAttach(root, container, jobId, options) {
     resources.logger.info(line);
   });
   await streamJobLog(handle, {
-    since: parseSince(options.since),
+    since,
     follow: true,
     write(chunk) {
       logWriter.write(chunk);
@@ -105432,6 +105487,7 @@ async function executeRuntimeJobsLogs(root, container, jobId, options) {
   const resources = createExecutionResources(container, flags, "runtime:jobs:logs");
   const state = createRuntimeState(container);
   const entry = await resolveJob(state, jobId, "pullable");
+  const since = parseSince(options.since);
   if (flags.dryRun) {
     resources.logger.dryRun(`Dry run: would read logs for runtime job ${entry.id}.`);
     return;
@@ -105441,7 +105497,7 @@ async function executeRuntimeJobsLogs(root, container, jobId, options) {
     resources.logger.info(line);
   });
   await streamJobLog(handle, {
-    since: parseSince(options.since),
+    since,
     follow: false,
     write(chunk) {
       logWriter.write(chunk);
@@ -105532,13 +105588,13 @@ function registerRuntimeJobsSandboxCommand(jobs, root, container) {
   jobs.command("sandbox").description("Open a shell in a runtime sandbox.").argument("<envId>", "Runtime sandbox id").option("--runtime <runtime>", "Runtime backend for the sandbox", "docker").action(async (envId, options) => {
     const flags = resolveCommandFlags(root);
     const resources = createExecutionResources(container, flags, "runtime:jobs:sandbox");
+    const factory = selectExecutionEnvFactory(options.runtime);
     if (flags.dryRun) {
       resources.logger.dryRun(
         `Dry run: would open a shell in ${options.runtime} runtime sandbox ${envId}.`
       );
       return;
     }
-    const factory = selectExecutionEnvFactory(options.runtime);
     const job = (await createRuntimeState(container).jobs.list()).filter((entry) => entry.env_id === envId && entry.env_kind === options.runtime).sort((left, right) => Date.parse(right.started_at) - Date.parse(left.started_at))[0];
     const env = await factory.attach(
       envId,
@@ -125653,7 +125709,7 @@ var init_policy = __esm({
 });
 
 // packages/safejs/src/interp/host-call.ts
-import { createHash as createHash10, randomUUID as randomUUID44 } from "node:crypto";
+import { createHash as createHash10, randomUUID as randomUUID45 } from "node:crypto";
 function validateRestoredRecords(records, runId, sourceHash) {
   const ids = /* @__PURE__ */ new Set();
   let previousOrdinal = 0;
@@ -125767,7 +125823,7 @@ var init_host_call = __esm({
       constructor(sourceHash, records = [], resumeProvider) {
         this.sourceHash = sourceHash;
         this.resumeProvider = resumeProvider;
-        this.runId = records[0]?.runId ?? randomUUID44();
+        this.runId = records[0]?.runId ?? randomUUID45();
         this.records = records.map((record) => structuredClone(record));
         validateRestoredRecords(this.records, this.runId, sourceHash);
         this.restored = [...this.records];
@@ -133454,7 +133510,7 @@ var init_error_codes21 = __esm({
 });
 
 // packages/safejs/src/snapshot/backend.ts
-import { randomUUID as randomUUID45 } from "node:crypto";
+import { randomUUID as randomUUID46 } from "node:crypto";
 import { readFile as readFile52, rename as rename27, stat as stat31, unlink as unlink24, writeFile as writeFile28 } from "node:fs/promises";
 import { dirname as dirname10 } from "node:path";
 async function writeSnapshotAtomically(snapshotPath, snapshot2, options) {
@@ -133463,7 +133519,7 @@ async function writeSnapshotAtomically(snapshotPath, snapshot2, options) {
   await assertParentDirectoryExists(snapshotPath, parentPath);
   for (let attempt = 1; attempt <= options.maxAttempts; attempt += 1) {
     try {
-      const temporaryPath = `${snapshotPath}.${randomUUID45()}.tmp`;
+      const temporaryPath = `${snapshotPath}.${randomUUID46()}.tmp`;
       await writeSnapshotOnce(temporaryPath, snapshotPath, contents);
       return;
     } catch (error3) {
@@ -136058,7 +136114,7 @@ var init_extract_schema = __esm({
 });
 
 // packages/agent-harness/src/codegen/emit-schemas.ts
-import { randomUUID as randomUUID46 } from "node:crypto";
+import { randomUUID as randomUUID47 } from "node:crypto";
 import * as nodeFs21 from "node:fs/promises";
 import path171 from "node:path";
 import { fileURLToPath as fileURLToPath13 } from "node:url";
@@ -136218,7 +136274,7 @@ var init_validate4 = __esm({
 });
 
 // packages/agent-harness/src/loader/run.ts
-import { createHash as createHash11, randomUUID as randomUUID47 } from "node:crypto";
+import { createHash as createHash11, randomUUID as randomUUID48 } from "node:crypto";
 import { lstat as lstat34, mkdir as mkdir37, readFile as readFile55, rename as rename28, unlink as unlink25, writeFile as writeFile29 } from "node:fs/promises";
 import os22 from "node:os";
 import { dirname as dirname13, join as join14, parse as parse14, resolve as resolve10, sep as sep7 } from "node:path";
@@ -136580,7 +136636,7 @@ async function writeHostCallRecords(storePath, records) {
   await writeTextFileAtomically2(storePath, serialized);
 }
 async function writeTextFileAtomically2(filePath, content) {
-  const temporaryPath = `${filePath}.${process.pid}.${randomUUID47()}.tmp`;
+  const temporaryPath = `${filePath}.${process.pid}.${randomUUID48()}.tmp`;
   let temporaryCreated = false;
   try {
     await writeFile29(temporaryPath, content, { encoding: "utf8", flag: "wx" });
@@ -136837,6 +136893,7 @@ async function executeHarnessRun(program, container, mdPath, options) {
   const resources = createExecutionResources(container, flags, "harness:run");
   const selectedPath = mdPath ? path172.resolve(container.env.cwd, mdPath) : (await resolveDiscoveredHarness(container, flags.assumeYes)).mdPath;
   if (flags.dryRun) {
+    await resolvePair(selectedPath, container.fs);
     resources.logger.dryRun(
       `Dry run: would run ${formatDisplayPath3(container, selectedPath)} without executing its script or applying fixes.`
     );
@@ -138621,7 +138678,7 @@ var init_package2 = __esm({
   "package.json"() {
     package_default2 = {
       name: "poe-code",
-      version: "3.0.351",
+      version: "3.0.352",
       description: "CLI tool to configure Poe API for developer workflows.",
       type: "module",
       main: "./dist/index.js",