openpond 0.0.68 → 0.0.69

package/dist/chunks/chunk-DLQQIWN2.js

@@ -0,0 +1,648 @@
+import { createRequire as __openpondCreateRequire } from "node:module"; var require = __openpondCreateRequire(import.meta.url);
+import {
+  external_exports
+} from "./chunk-FQS2QL5F.js";
+
+// ../../packages/sdk/dist/actions-local.js
+import { randomUUID } from "node:crypto";
+import { spawn } from "node:child_process";
+import { promises as fs5 } from "node:fs";
+import path5 from "node:path";
+import { promises as fs4 } from "node:fs";
+import path4 from "node:path";
+import { fileURLToPath, pathToFileURL } from "node:url";
+import { build } from "esbuild";
+import { promises as fs } from "node:fs";
+import path from "node:path";
+import { promises as fs2 } from "node:fs";
+import path2 from "node:path";
+import { createHash } from "node:crypto";
+import { promises as fs3 } from "node:fs";
+import { createRequire } from "node:module";
+import path3 from "node:path";
+function isProjectActionDefinition(value) {
+  return Boolean(
+    value && typeof value === "object" && value.kind === "openpond-project-action" && typeof value.id === "string" && typeof value.run === "function"
+  );
+}
+function projectActionJsonSchema(schema) {
+  return external_exports.toJSONSchema(schema, { unrepresentable: "any" });
+}
+function collectProjectActions(modules) {
+  const actions = [];
+  const seenObjects = /* @__PURE__ */ new Set();
+  const visit = (value) => {
+    if (seenObjects.has(value)) return;
+    if (value && (typeof value === "object" || typeof value === "function")) seenObjects.add(value);
+    if (isProjectActionDefinition(value)) {
+      actions.push(value);
+      return;
+    }
+    if (Array.isArray(value)) {
+      value.forEach(visit);
+      return;
+    }
+    if (value && typeof value === "object") Object.values(value).forEach(visit);
+  };
+  modules.forEach(visit);
+  const byId = /* @__PURE__ */ new Map();
+  for (const action of actions) {
+    if (byId.has(action.id)) throw new Error(`Duplicate Project Action id: ${action.id}`);
+    byId.set(action.id, action);
+  }
+  return [...byId.values()].sort((left, right) => left.id.localeCompare(right.id));
+}
+function createProjectActionRegistry(actions) {
+  return {
+    schemaVersion: "openpond.projectActionRegistry.v1",
+    actions: actions.map(toCatalogEntry)
+  };
+}
+function toCatalogEntry(action) {
+  return {
+    id: action.id,
+    sourceActionId: action.id,
+    name: action.id,
+    label: action.label,
+    description: action.description,
+    visibility: "default",
+    inputSchema: projectActionJsonSchema(action.inputSchema),
+    outputSchema: projectActionJsonSchema(action.outputSchema),
+    approvalPolicy: {
+      ...action.approval,
+      required: action.approval.mode === "always" || action.approval.mode === "sensitive" || action.approval.mode === "writes" && action.behavior === "write",
+      risk: action.behavior
+    },
+    artifactPolicy: {
+      outputArtifacts: [],
+      persistRunSummary: true,
+      persistTrace: true
+    },
+    setupRequirements: [...action.setup],
+    mcp: { enabled: false },
+    schedulePolicy: { enabled: false, allowAdHoc: true },
+    trace: { name: action.id, namespace: "project-actions" },
+    implementation: {
+      type: "openpond-project-action",
+      actionId: action.id,
+      behavior: action.behavior,
+      timeoutMs: action.timeoutMs,
+      concurrency: action.concurrency
+    },
+    invokesModel: action.invokesModel
+  };
+}
+var PROJECT_ACTION_CONFIG_PATH = "openpond/project-actions.json";
+var connectionSchema = external_exports.object({
+  values: external_exports.record(external_exports.string(), external_exports.unknown()).optional().default({}),
+  environment: external_exports.record(external_exports.string(), external_exports.string().trim().min(1)).optional().default({})
+}).strict();
+var configSchema = external_exports.object({
+  sourceDirectory: external_exports.string().trim().min(1).optional(),
+  outputDirectory: external_exports.string().trim().min(1).optional(),
+  environment: external_exports.record(external_exports.string(), external_exports.string().trim().min(1)).optional().default({}),
+  connections: external_exports.record(external_exports.string(), connectionSchema).optional().default({})
+}).strict();
+async function loadProjectActionConfiguration(projectRoot) {
+  const resolvedRoot = path.resolve(projectRoot);
+  const configPath = path.join(resolvedRoot, PROJECT_ACTION_CONFIG_PATH);
+  const raw = await fs.readFile(configPath, "utf8").catch((error) => {
+    if (error.code === "ENOENT") return null;
+    throw error;
+  });
+  if (raw === null) return configSchema.parse({});
+  let value;
+  try {
+    value = JSON.parse(raw);
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    throw new Error(`${PROJECT_ACTION_CONFIG_PATH} is not valid JSON: ${message}`);
+  }
+  return configSchema.parse(value);
+}
+function resolveProjectActionRuntime(config, hostEnvironment = process.env) {
+  const environment = {};
+  for (const [runtimeName, hostName] of Object.entries(config.environment)) {
+    const value = hostEnvironment[hostName];
+    if (value !== void 0) environment[runtimeName] = value;
+  }
+  const connections = {};
+  for (const [name, descriptor] of Object.entries(config.connections)) {
+    const value = { ...descriptor.values };
+    for (const [property, hostName] of Object.entries(descriptor.environment)) {
+      const environmentValue = hostEnvironment[hostName];
+      if (environmentValue !== void 0) value[property] = environmentValue;
+    }
+    connections[name] = value;
+  }
+  return { environment, connections };
+}
+var ACTION_FILE = /\.(?:[cm]?[jt]s)$/i;
+var IGNORED_FILE = /(?:\.d\.ts|\.test\.[cm]?[jt]s|\.spec\.[cm]?[jt]s)$/i;
+async function discoverProjectActionFiles(input) {
+  const projectRoot = path2.resolve(input.projectRoot);
+  const sourceRoot = path2.resolve(projectRoot, input.sourceDirectory ?? "openpond/actions");
+  if (!isWithin(projectRoot, sourceRoot)) {
+    throw new Error("Project Action source directory must stay inside the Project root.");
+  }
+  const stats = await fs2.stat(sourceRoot).catch(() => null);
+  if (!stats?.isDirectory()) {
+    throw new Error(`Project Action source directory does not exist: ${sourceRoot}`);
+  }
+  const files = await walk(sourceRoot);
+  const actions = files.filter((file) => ACTION_FILE.test(file) && !IGNORED_FILE.test(file)).map((file) => path2.relative(projectRoot, file).split(path2.sep).join("/")).sort();
+  if (actions.length === 0) {
+    throw new Error(`No Project Action files were found under ${sourceRoot}.`);
+  }
+  return { projectRoot, sourceRoot, files: actions };
+}
+async function walk(directory) {
+  const entries = await fs2.readdir(directory, { withFileTypes: true });
+  const files = [];
+  for (const entry of entries.sort((left, right) => left.name.localeCompare(right.name))) {
+    if (entry.name.startsWith(".") || entry.name === "node_modules") continue;
+    const target = path2.join(directory, entry.name);
+    if (entry.isDirectory()) files.push(...await walk(target));
+    else if (entry.isFile()) files.push(target);
+  }
+  return files;
+}
+function isWithin(root, target) {
+  const relative = path2.relative(root, target);
+  return relative === "" || !relative.startsWith("..") && !path2.isAbsolute(relative);
+}
+function sha256(value) {
+  return createHash("sha256").update(value).digest("hex");
+}
+function canonicalJson(value) {
+  return `${JSON.stringify(sortValue(value), null, 2)}
+`;
+}
+function sortValue(value) {
+  if (Array.isArray(value)) return value.map(sortValue);
+  if (!value || typeof value !== "object") return value;
+  return Object.fromEntries(
+    Object.entries(value).sort(([left], [right]) => left.localeCompare(right)).map(([key, child]) => [key, sortValue(child)])
+  );
+}
+async function validateProjectActionStaticSetup(projectRoot, requirements) {
+  for (const requirement of requirements) {
+    if (requirement.required === false) continue;
+    if (requirement.kind === "package") {
+      try {
+        createRequire(path3.join(projectRoot, "package.json")).resolve(requirement.name);
+      } catch {
+        throw new Error(`Project Action package is not installed: ${requirement.name}`);
+      }
+    }
+    if (requirement.kind === "native_tool" && !await executableExists(requirement.name)) {
+      throw new Error(`Project Action native tool is not installed: ${requirement.name}`);
+    }
+  }
+}
+async function validateProjectActionRunSetup(projectRoot, requirements, request) {
+  await validateProjectActionStaticSetup(projectRoot, requirements);
+  for (const requirement of requirements) {
+    if (requirement.required === false) continue;
+    if (requirement.kind === "connection" && !(requirement.name in (request.connections ?? {}))) {
+      throw new Error(`Project Action connection is not configured: ${requirement.name}`);
+    }
+    if (requirement.kind === "env" && !(requirement.name in (request.environment ?? {}))) {
+      throw new Error(`Project Action environment value is not configured: ${requirement.name}`);
+    }
+  }
+}
+async function executableExists(name) {
+  if (!name.trim() || name.includes("/") || name.includes("\\")) return false;
+  for (const directory of (process.env.PATH ?? "").split(path3.delimiter).filter(Boolean)) {
+    const candidates = process.platform === "win32" ? (process.env.PATHEXT ?? ".EXE;.CMD;.BAT;.COM").split(";").map((extension) => path3.join(directory, `${name}${extension}`)) : [path3.join(directory, name)];
+    for (const candidate of candidates) {
+      if (await fs3.access(candidate).then(() => true).catch(() => false)) return true;
+    }
+  }
+  return false;
+}
+var DEFAULT_PROJECT_ACTION_OUTPUT_DIRECTORY = ".openpond/actions";
+async function buildProjectActions(input) {
+  const configuration = await loadProjectActionConfiguration(input.projectRoot);
+  const discovered = await discoverProjectActionFiles({
+    projectRoot: input.projectRoot,
+    sourceDirectory: input.sourceDirectory ?? configuration.sourceDirectory
+  });
+  const outputDirectory = path4.resolve(
+    discovered.projectRoot,
+    input.outputDirectory ?? configuration.outputDirectory ?? DEFAULT_PROJECT_ACTION_OUTPUT_DIRECTORY
+  );
+  assertWithinProject(discovered.projectRoot, outputDirectory);
+  await fs4.mkdir(outputDirectory, { recursive: true });
+  const entryPath = path4.join(outputDirectory, "entry.mjs");
+  const bundlePath = path4.join(outputDirectory, "bundle.mjs");
+  const runnerPath = path4.join(outputDirectory, "runner.mjs");
+  const registryPath = path4.join(outputDirectory, "action-registry.json");
+  const manifestPath = path4.join(outputDirectory, "build-manifest.json");
+  const imports = discovered.files.map((file, index) => {
+    const relative = path4.relative(outputDirectory, path4.join(discovered.projectRoot, file)).split(path4.sep).join("/");
+    const specifier = relative.startsWith(".") ? relative : `./${relative}`;
+    return `import * as actionModule${index} from ${JSON.stringify(specifier)};`;
+  });
+  const modules = discovered.files.map((_file, index) => `actionModule${index}`).join(", ");
+  await fs4.writeFile(
+    entryPath,
+    [
+      ...imports,
+      `export const projectActionModules = [${modules}];`,
+      "export default projectActionModules;",
+      ""
+    ].join("\n"),
+    "utf8"
+  );
+  await build({
+    entryPoints: [entryPath],
+    outfile: bundlePath,
+    bundle: true,
+    platform: "node",
+    format: "esm",
+    target: "node22.14",
+    sourcemap: false,
+    legalComments: "none",
+    logLevel: "silent",
+    nodePaths: dependencySearchPaths(discovered.projectRoot)
+  });
+  const cacheKey = `openpond_action_build=${Date.now()}_${Math.random().toString(16).slice(2)}`;
+  const loaded = await import(`${pathToFileURL(bundlePath).href}?${cacheKey}`);
+  const actions = collectProjectActions(loaded.projectActionModules ?? loaded.default ?? []);
+  for (const action of actions) {
+    await validateProjectActionStaticSetup(discovered.projectRoot, action.setup);
+  }
+  const registry = createProjectActionRegistry(actions);
+  await fs4.writeFile(registryPath, canonicalJson(registry), "utf8");
+  await fs4.writeFile(runnerPath, runtimeSource(), { encoding: "utf8", mode: 493 });
+  const bundleHash = sha256(await fs4.readFile(bundlePath));
+  const registryHash = sha256(canonicalJson(registry));
+  const manifest = {
+    schemaVersion: "openpond.projectActionBuild.v1",
+    sourceDirectory: path4.relative(discovered.projectRoot, discovered.sourceRoot).split(path4.sep).join("/"),
+    sourceFiles: discovered.files,
+    bundleFile: path4.basename(bundlePath),
+    runnerFile: path4.basename(runnerPath),
+    registryFile: path4.basename(registryPath),
+    bundleHash,
+    registryHash
+  };
+  await fs4.writeFile(manifestPath, canonicalJson(manifest), "utf8");
+  await fs4.rm(entryPath, { force: true });
+  return {
+    projectRoot: discovered.projectRoot,
+    outputDirectory,
+    bundlePath,
+    runnerPath,
+    registryPath,
+    manifestPath,
+    registry,
+    manifest
+  };
+}
+function dependencySearchPaths(projectRoot) {
+  const candidates = [];
+  let current = projectRoot;
+  while (true) {
+    candidates.push(path4.join(current, "node_modules"));
+    const parent = path4.dirname(current);
+    if (parent === current) break;
+    current = parent;
+  }
+  candidates.push(path4.resolve(path4.dirname(fileURLToPath(import.meta.url)), "../../../node_modules"));
+  return [...new Set(candidates)];
+}
+function assertWithinProject(projectRoot, target) {
+  const relative = path4.relative(projectRoot, target);
+  if (relative.startsWith("..") || path4.isAbsolute(relative)) {
+    throw new Error("Project Action output directory must stay inside the Project root.");
+  }
+}
+function runtimeSource() {
+  return `#!/usr/bin/env node
+import { promises as fs } from "node:fs";
+import { stdin } from "node:process";
+import path from "node:path";
+import { fileURLToPath, pathToFileURL } from "node:url";
+
+let requestText = "";
+stdin.setEncoding("utf8");
+for await (const chunk of stdin) requestText += chunk;
+const request = JSON.parse(requestText);
+const bundlePath = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "bundle.mjs");
+const loaded = await import(pathToFileURL(bundlePath).href);
+const values = [];
+const seen = new Set();
+const visit = (value) => {
+  if (seen.has(value)) return;
+  if (value && (typeof value === "object" || typeof value === "function")) seen.add(value);
+  if (value?.kind === "openpond-project-action" && typeof value.run === "function") { values.push(value); return; }
+  if (Array.isArray(value)) { value.forEach(visit); return; }
+  if (value && typeof value === "object") Object.values(value).forEach(visit);
+};
+(loaded.projectActionModules ?? loaded.default ?? []).forEach(visit);
+const action = values.find((candidate) => candidate.id === request.actionId);
+if (!action) throw new Error(\`Unknown Project Action: \${request.actionId}\`);
+const controller = new AbortController();
+const timeoutMs = Math.min(request.timeoutMs ?? action.timeoutMs, action.timeoutMs);
+const timer = setTimeout(() => controller.abort(new Error(\`Project Action timed out after \${timeoutMs}ms.\`)), timeoutMs);
+const traces = [];
+const outputs = [];
+const env = request.environment ?? {};
+const connections = request.connections ?? {};
+const context = {
+  runId: request.runId,
+  actionId: action.id,
+  idempotencyKey: request.idempotencyKey ?? null,
+  projectRoot: request.projectRoot,
+  outputDirectory: request.outputDirectory,
+  signal: controller.signal,
+  env(name) { return Object.prototype.hasOwnProperty.call(env, name) ? env[name] : undefined; },
+  connection(name) {
+    if (!Object.prototype.hasOwnProperty.call(connections, name)) throw new Error(\`Project Action connection is not configured: \${name}\`);
+    return connections[name];
+  },
+  trace(name, payload) { traces.push({ name, ...(payload ? { payload } : {}), timestamp: new Date().toISOString() }); },
+  output(value) {
+    if (!value || typeof value.path !== "string" || !value.path.trim()) throw new Error("Project Action output requires a path.");
+    const outputPath = path.resolve(request.outputDirectory, value.path);
+    const relative = path.relative(request.outputDirectory, outputPath);
+    if (relative.startsWith("..") || path.isAbsolute(relative)) throw new Error("Project Action output must stay inside the run output directory.");
+    outputs.push({ ...value, path: relative.split(path.sep).join("/") });
+  },
+};
+try {
+  const input = action.inputSchema.parse(request.input ?? {});
+  const result = await Promise.race([
+    Promise.resolve(action.run(context, input)),
+    new Promise((_, reject) => controller.signal.addEventListener("abort", () => reject(controller.signal.reason), { once: true })),
+  ]);
+  const output = action.outputSchema.parse(result);
+  for (const artifact of outputs) {
+    const stats = await fs.stat(path.resolve(request.outputDirectory, artifact.path)).catch(() => null);
+    if (!stats?.isFile()) throw new Error(\`Project Action output does not exist: \${artifact.path}\`);
+  }
+  await fs.writeFile(request.responseFile, JSON.stringify({ ok: true, output, traces, outputs }), "utf8");
+} finally {
+  clearTimeout(timer);
+}
+`;
+}
+var localConcurrency = /* @__PURE__ */ new Map();
+function createLocalActionRunner(options) {
+  const projectRoot = path5.resolve(options.projectRoot);
+  const buildPolicy = options.build ?? "if-missing";
+  let currentBuild = null;
+  const ensureBuild = async () => {
+    if (buildPolicy === "always") return runBuild();
+    if (currentBuild) return currentBuild;
+    if (buildPolicy === "never" || buildPolicy === "if-missing") {
+      const configuration = await loadProjectActionConfiguration(projectRoot);
+      const outputDirectory = path5.resolve(
+        projectRoot,
+        options.outputDirectory ?? configuration.outputDirectory ?? DEFAULT_PROJECT_ACTION_OUTPUT_DIRECTORY
+      );
+      const loaded = await loadBuild(projectRoot, outputDirectory);
+      if (loaded) return currentBuild = loaded;
+      if (buildPolicy === "never") {
+        throw new Error(`Project Actions have not been built in ${outputDirectory}.`);
+      }
+    }
+    return runBuild();
+  };
+  const runBuild = async () => {
+    currentBuild = await buildProjectActions({
+      projectRoot,
+      sourceDirectory: options.sourceDirectory,
+      outputDirectory: options.outputDirectory
+    });
+    return currentBuild;
+  };
+  return {
+    build: runBuild,
+    async catalog() {
+      return (await ensureBuild()).registry;
+    },
+    async run(request) {
+      const built = await ensureBuild();
+      const catalogAction = built.registry.actions.find((action) => action.id === request.actionId);
+      if (!catalogAction) throw new Error(`Unknown Project Action: ${request.actionId}`);
+      const configuredRuntime = resolveProjectActionRuntime(
+        await loadProjectActionConfiguration(projectRoot)
+      );
+      const resolvedRequest = {
+        ...request,
+        environment: {
+          ...configuredRuntime.environment,
+          ...request.environment ?? {}
+        },
+        connections: {
+          ...configuredRuntime.connections,
+          ...request.connections ?? {}
+        }
+      };
+      await validateProjectActionRunSetup(projectRoot, catalogAction.setupRequirements, resolvedRequest);
+      const runId = request.runId?.trim() || randomUUID();
+      const actionOutputDirectory = path5.resolve(
+        request.outputDirectory ?? path5.join(projectRoot, ".openpond", "outputs", runId)
+      );
+      assertWithinProject2(projectRoot, actionOutputDirectory, "Project Action output directory");
+      await fs5.mkdir(actionOutputDirectory, { recursive: true });
+      const release = await acquireLocalActionSlot(
+        `${projectRoot}\0${request.actionId}`,
+        catalogAction.implementation.concurrency,
+        resolvedRequest.signal
+      );
+      const responseFile = path5.join(built.outputDirectory, `.run-${randomUUID()}.json`);
+      const startedAt = Date.now();
+      let childResult;
+      let payload;
+      try {
+        childResult = await executeChild({
+          runnerPath: built.runnerPath,
+          cwd: projectRoot,
+          signal: resolvedRequest.signal,
+          request: {
+            actionId: request.actionId,
+            input: resolvedRequest.input ?? {},
+            runId,
+            idempotencyKey: resolvedRequest.idempotencyKey ?? null,
+            timeoutMs: resolvedRequest.timeoutMs,
+            projectRoot,
+            outputDirectory: actionOutputDirectory,
+            responseFile,
+            environment: resolvedRequest.environment ?? {},
+            connections: resolvedRequest.connections ?? {}
+          }
+        });
+        payload = JSON.parse(await fs5.readFile(responseFile, "utf8"));
+      } catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        throw new Error(redactRuntimeValues(message, resolvedRequest));
+      } finally {
+        await fs5.rm(responseFile, { force: true }).catch(() => void 0);
+        release();
+      }
+      return {
+        runId,
+        actionId: request.actionId,
+        status: "succeeded",
+        output: payload.output,
+        stdout: redactRuntimeValues(childResult.stdout, resolvedRequest),
+        stderr: redactRuntimeValues(childResult.stderr, resolvedRequest),
+        traces: redactRuntimeValue(payload.traces, resolvedRequest),
+        outputs: redactRuntimeValue(payload.outputs, resolvedRequest),
+        outputDirectory: actionOutputDirectory,
+        durationMs: Date.now() - startedAt
+      };
+    }
+  };
+}
+async function acquireLocalActionSlot(key, limit, signal) {
+  if (limit === null) return () => void 0;
+  const state = localConcurrency.get(key) ?? { active: 0, waiting: [] };
+  localConcurrency.set(key, state);
+  if (state.active >= limit) {
+    await new Promise((resolve, reject) => {
+      const resume = () => {
+        signal?.removeEventListener("abort", abort);
+        resolve();
+      };
+      const abort = () => {
+        const index = state.waiting.indexOf(resume);
+        if (index >= 0) state.waiting.splice(index, 1);
+        reject(signal?.reason instanceof Error ? signal.reason : new Error("Project Action was cancelled."));
+      };
+      if (signal?.aborted) {
+        abort();
+        return;
+      }
+      state.waiting.push(resume);
+      signal?.addEventListener("abort", abort, { once: true });
+    });
+  } else {
+    state.active += 1;
+  }
+  let released = false;
+  return () => {
+    if (released) return;
+    released = true;
+    const next = state.waiting.shift();
+    if (next) {
+      next();
+      return;
+    }
+    state.active -= 1;
+    if (state.active === 0 && state.waiting.length === 0) localConcurrency.delete(key);
+  };
+}
+async function loadBuild(projectRoot, outputDirectory) {
+  const manifestPath = path5.join(outputDirectory, "build-manifest.json");
+  const registryPath = path5.join(outputDirectory, "action-registry.json");
+  const [manifestText, registryText] = await Promise.all([
+    fs5.readFile(manifestPath, "utf8").catch(() => null),
+    fs5.readFile(registryPath, "utf8").catch(() => null)
+  ]);
+  if (!manifestText || !registryText) return null;
+  const manifest = JSON.parse(manifestText);
+  const registry = JSON.parse(registryText);
+  return {
+    projectRoot,
+    outputDirectory,
+    bundlePath: path5.join(outputDirectory, manifest.bundleFile),
+    runnerPath: path5.join(outputDirectory, manifest.runnerFile),
+    registryPath,
+    manifestPath,
+    registry,
+    manifest
+  };
+}
+function redactRuntimeValues(value, request) {
+  let redacted = value;
+  for (const secret of runtimeStringValues(request)) {
+    if (secret.length >= 4) redacted = redacted.split(secret).join("[REDACTED]");
+  }
+  return redacted;
+}
+function redactRuntimeValue(value, request) {
+  const serialized = JSON.stringify(value);
+  return JSON.parse(redactRuntimeValues(serialized, request));
+}
+function runtimeStringValues(request) {
+  const values = new Set(Object.values(request.environment ?? {}));
+  const visit = (value) => {
+    if (typeof value === "string") values.add(value);
+    else if (Array.isArray(value)) value.forEach(visit);
+    else if (value && typeof value === "object") Object.values(value).forEach(visit);
+  };
+  visit(request.connections ?? {});
+  return [...values].filter(Boolean).sort((left, right) => right.length - left.length);
+}
+function executeChild(input) {
+  return new Promise((resolve, reject) => {
+    if (input.signal?.aborted) {
+      reject(input.signal.reason instanceof Error ? input.signal.reason : new Error("Project Action was cancelled."));
+      return;
+    }
+    let requestJson;
+    try {
+      requestJson = JSON.stringify(input.request);
+    } catch (error) {
+      reject(new Error(`Project Action request is not serializable: ${error instanceof Error ? error.message : String(error)}`));
+      return;
+    }
+    const child = spawn(process.execPath, [input.runnerPath], {
+      cwd: input.cwd,
+      env: minimalEnvironment(),
+      stdio: ["pipe", "pipe", "pipe"]
+    });
+    let stdout = "";
+    let stderr = "";
+    child.stdout.setEncoding("utf8");
+    child.stderr.setEncoding("utf8");
+    child.stdout.on("data", (chunk) => {
+      stdout += chunk;
+    });
+    child.stderr.on("data", (chunk) => {
+      stderr += chunk;
+    });
+    const abort = () => child.kill("SIGTERM");
+    input.signal?.addEventListener("abort", abort, { once: true });
+    child.once("error", reject);
+    child.once("close", (code, signal) => {
+      input.signal?.removeEventListener("abort", abort);
+      if (input.signal?.aborted) {
+        reject(input.signal.reason instanceof Error ? input.signal.reason : new Error("Project Action was cancelled."));
+        return;
+      }
+      if (code !== 0) {
+        reject(new Error(`Project Action process failed (${code ?? signal ?? "unknown"}): ${stderr.trim() || stdout.trim()}`));
+        return;
+      }
+      resolve({ stdout, stderr });
+    });
+    child.stdin.end(requestJson);
+  });
+}
+function assertWithinProject2(projectRoot, target, label) {
+  const relative = path5.relative(projectRoot, target);
+  if (relative.startsWith("..") || path5.isAbsolute(relative)) {
+    throw new Error(`${label} must stay inside the Project root.`);
+  }
+}
+function minimalEnvironment() {
+  const env = {};
+  for (const name of ["PATH", "SystemRoot", "WINDIR", "TMPDIR", "TEMP", "TMP"]) {
+    if (process.env[name] !== void 0) env[name] = process.env[name];
+  }
+  return env;
+}
+
+export {
+  PROJECT_ACTION_CONFIG_PATH,
+  loadProjectActionConfiguration,
+  buildProjectActions,
+  createLocalActionRunner
+};

package/dist/chunks/{chunk-T55IL3GI.js → chunk-DNXBJZAU.js}

@@ -4,7 +4,7 @@ import {
   parseSandboxRuntimeProfileIdOption,
   parseSandboxRuntimePromotionPolicyOption,
   parseSandboxWorkflowModeOption
-} from "./chunk-J2REM7LE.js";
+} from "./chunk-HFPUR4CQ.js";
 import {
   parseBooleanOption,
   parseCsvOption,

package/dist/chunks/{chunk-KLD7NT5J.js → chunk-F36ZVO6U.js}

@@ -15,7 +15,7 @@ import {
   resolveRepoUrl,
   runCommand,
   warnOnRepoHostMismatch
-} from "./chunk-J2REM7LE.js";
+} from "./chunk-HFPUR4CQ.js";
 import {
   normalizeTemplateRepoUrl,
   resolveApiBaseUrlOption,
@@ -28,7 +28,7 @@ import {
   compareSemver,
   fetchLatestNpmVersion,
   getInstalledCliVersion
-} from "./chunk-NA4L2HQM.js";
+} from "./chunk-Y57RTLVV.js";
 import {
   checkOpenPondApiHealth,
   createHeadlessApps,
@@ -45,7 +45,7 @@ import {
   saveProfileApiKey,
   setActiveProfile,
   submitBacktestRun
-} from "./chunk-DBHSOTYZ.js";
+} from "./chunk-D7BO5Y5J.js";
 import {
   parseBooleanOption,
   parseJsonOption,