poe-code 3.0.350 → 3.0.352

package/dist/index.js

@@ -67664,6 +67664,9 @@ function parseTaskStatus(value, availableSteps, taskId) {
     throw new Error(`Invalid status for task "${taskId}": expected at least one step status.`);
   }
   for (const [stepName, stepStatus] of stepStatuses) {
+    if (stepName.length === 0) {
+      throw new Error(`Invalid status for task "${taskId}": step names must be non-empty.`);
+    }
     if (availableSteps && !Object.hasOwn(availableSteps, stepName)) {
       throw new Error(`Unknown step "${stepName}" referenced by task "${taskId}".`);
     }
@@ -67847,11 +67850,17 @@ function parsePlan(planContent, options = {}) {
     "mcp"
   ]);
   const kind = getOwnEntry25(document, "kind");
-  if (kind !== void 0 && kind !== "pipeline") {
+  if (kind === void 0) {
+    throw new Error('Invalid plan YAML: missing required "kind".');
+  }
+  if (kind !== "pipeline") {
     throw new Error('Invalid plan YAML: "kind" must be "pipeline".');
   }
   const version = getOwnEntry25(document, "version");
-  if (version !== void 0 && version !== 1) {
+  if (version === void 0) {
+    throw new Error('Invalid plan YAML: missing required "version".');
+  }
+  if (version !== 1) {
     throw new Error('Invalid plan YAML: "version" must be 1.');
   }
   let extendsName = "default";
@@ -67870,6 +67879,9 @@ function parsePlan(planContent, options = {}) {
     }
     stepOverrides = {};
     for (const [stepName, value] of Object.entries(stepsValue)) {
+      if (stepName.length === 0) {
+        throw new Error("Invalid plan YAML: step names must be non-empty.");
+      }
       defineRecordEntry3(stepOverrides, stepName, parseStepOverride(value, `steps.${stepName}`));
     }
   }
@@ -67882,6 +67894,7 @@ function parsePlan(planContent, options = {}) {
     if (!isRecord22(value)) {
       throw new Error(`Invalid tasks[${index}]: expected an object.`);
     }
+    rejectUnknownProperties(value, ["id", "title", "prompt", "status"], `tasks[${index}].`);
     const id = asRequiredString(getOwnEntry25(value, "id"), `tasks[${index}].id`);
     if (ids.has(id)) {
       throw new Error(`Duplicate task id "${id}".`);
@@ -68307,7 +68320,7 @@ function selectFromTask(task) {
     return task.status === "done" ? { kind: "completed" } : { kind: "run", task };
   }
   const stepName = Object.entries(task.status).find(([, value]) => value !== "done")?.[0];
-  return stepName ? { kind: "run", task, stepName } : { kind: "completed" };
+  return stepName !== void 0 ? { kind: "run", task, stepName } : { kind: "completed" };
 }
 function selectNextExecution(plan, taskId) {
   const tasks = taskId ? plan.tasks.filter((task) => task.id === taskId) : plan.tasks;
@@ -68395,7 +68408,13 @@ function looksLikeDocPath(value) {
 }
 async function resolveDocVarFromPath(options) {
   const trimmed = options.value.trim();
-  const absolutePath = path83.isAbsolute(trimmed) ? trimmed : path83.join(options.cwd, trimmed);
+  const absolutePath = path83.resolve(options.cwd, trimmed);
+  const relativePath = path83.relative(options.cwd, absolutePath);
+  if (relativePath === ".." || relativePath.startsWith(`..${path83.sep}`) || path83.isAbsolute(relativePath)) {
+    throw new Error(
+      `Pipeline doc var "${options.key}" resolves outside the project root: ${trimmed}`
+    );
+  }
   try {
     return await options.readFile(absolutePath, "utf8");
   } catch (error3) {
@@ -93636,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));
@@ -93842,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
@@ -94232,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;
@@ -94263,6 +94323,8 @@ var init_spawn6 = __esm({
     "use strict";
     init_src17();
     init_src7();
+    init_src14();
+    init_src15();
     init_src2();
     init_config5();
     init_shared();
@@ -95773,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) {
@@ -95804,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" });
@@ -98234,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";
@@ -98314,8 +98376,10 @@ function resolveMaxRuns(value) {
   if (value == null) {
     return void 0;
   }
-  const parsed = Number.parseInt(value, 10);
-  if (!Number.isFinite(parsed) || parsed < 1) {
+  const trimmed = value.trim();
+  const hasOnlyDigits = trimmed.length > 0 && [...trimmed].every((character) => character >= "0" && character <= "9");
+  const parsed = Number(trimmed);
+  if (!hasOnlyDigits || !Number.isSafeInteger(parsed) || parsed < 1) {
     throw new ValidationError(`Invalid max-runs "${value}". Expected a positive integer.`);
   }
   return parsed;
@@ -98362,15 +98426,19 @@ function formatPipelineTasksSummary(summary) {
   }
   return parts.join(", ");
 }
-function summarizePipelinePlan(plan) {
+function summarizePipelinePlan(plan, taskId) {
+  const tasks = taskId ? plan.tasks.filter((task) => task.id === taskId) : plan.tasks;
+  if (taskId && tasks.length === 0) {
+    throw new ValidationError(`Task "${taskId}" was not found in the plan.`);
+  }
   const summary = {
     planPath: "",
     done: 0,
     failed: 0,
     open: 0,
-    total: plan.tasks.length
+    total: tasks.length
   };
-  for (const task of plan.tasks) {
+  for (const task of tasks) {
     const statuses = typeof task.status === "string" ? [task.status] : Object.values(task.status);
     if (statuses.length > 0 && statuses.every((status) => status === "done")) {
       summary.done += 1;
@@ -98391,8 +98459,14 @@ async function dryRunPipelinePlans(options) {
     );
     const content = await options.container.fs.readFile(absolutePath, "utf8");
     const plan = parsePlan(content);
-    const summary = summarizePipelinePlan(plan);
+    const summary = summarizePipelinePlan(plan, options.task);
     options.resources.logger.dryRun(`Would run: ${planPath}`);
+    if (options.task) {
+      options.resources.logger.dryRun(`Task: ${options.task}`);
+    }
+    if (options.maxRuns !== void 0) {
+      options.resources.logger.dryRun(`Max runs: ${options.maxRuns}`);
+    }
     options.resources.logger.dryRun(
       `Tasks: ${summary.done} done, ${summary.failed} failed, ${summary.open} open`
     );
@@ -98797,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" });
@@ -98827,6 +98901,7 @@ function registerPipelineCommand(program, container) {
       if (options.plan && options.plans && options.plans.length > 0) {
         throw new ValidationError("Use either --plan or --plans, not both.");
       }
+      const maxRuns = resolveMaxRuns(options.maxRuns);
       if (flags.dryRun) {
         const commandConfig2 = await resolvePipelineCommandConfig(container, { readOnly: true });
         const planPaths2 = await resolvePlanPaths({
@@ -98842,7 +98917,13 @@ function registerPipelineCommand(program, container) {
         if (!planPaths2 || planPaths2.length === 0) {
           return;
         }
-        await dryRunPipelinePlans({ container, resources, planPaths: planPaths2 });
+        await dryRunPipelinePlans({
+          container,
+          resources,
+          planPaths: planPaths2,
+          ...maxRuns !== void 0 ? { maxRuns } : {},
+          ...options.task ? { task: options.task } : {}
+        });
         return;
       }
       if (!flags.assumeYes && !options.agent) {
@@ -98866,7 +98947,6 @@ function registerPipelineCommand(program, container) {
       const agent3 = resolvePipelineAgent(selectedAgent.agent);
       const commandConfig = await resolvePipelineCommandConfig(container);
       integrations = await loadIntegrations(commandConfig.configDoc);
-      const maxRuns = resolveMaxRuns(options.maxRuns);
       const planPaths = await resolvePlanPaths({
         cwd: container.env.cwd,
         homeDir: container.env.homeDir,
@@ -99396,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;
@@ -99641,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" });
@@ -100995,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;
     }
@@ -101011,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;
     }
@@ -101300,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) {
@@ -102042,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" });
@@ -102455,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) {
@@ -102508,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);
@@ -104908,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,
@@ -105351,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}.`);
@@ -105361,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);
@@ -105395,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;
@@ -105404,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);
@@ -105495,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,
@@ -125616,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;
@@ -125730,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];
@@ -133417,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) {
@@ -133426,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) {
@@ -136021,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";
@@ -136181,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";
@@ -136543,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" });
@@ -136800,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.`
     );
@@ -138584,7 +138678,7 @@ var init_package2 = __esm({
   "package.json"() {
     package_default2 = {
       name: "poe-code",
-      version: "3.0.350",
+      version: "3.0.352",
       description: "CLI tool to configure Poe API for developer workflows.",
       type: "module",
       main: "./dist/index.js",