@withone/cli 1.12.9 → 1.13.0

package/dist/chunk-NHI5URAV.js

@@ -0,0 +1,1221 @@
+// src/lib/flow-runner.ts
+import fs2 from "fs";
+import path2 from "path";
+import crypto from "crypto";
+
+// src/lib/flow-engine.ts
+import fs from "fs";
+import path from "path";
+import { exec } from "child_process";
+import { promisify } from "util";
+
+// src/lib/api.ts
+var API_BASE = "https://api.withone.ai/v1";
+var ApiError = class extends Error {
+  constructor(status, message) {
+    super(message);
+    this.status = status;
+    this.name = "ApiError";
+  }
+};
+var OneApi = class {
+  constructor(apiKey) {
+    this.apiKey = apiKey;
+  }
+  async request(path3) {
+    return this.requestFull({ path: path3 });
+  }
+  async requestFull(opts) {
+    let url = `${API_BASE}${opts.path}`;
+    if (opts.queryParams && Object.keys(opts.queryParams).length > 0) {
+      const params = new URLSearchParams(opts.queryParams);
+      url += `?${params.toString()}`;
+    }
+    const headers = {
+      "x-one-secret": this.apiKey,
+      "Content-Type": "application/json",
+      ...opts.headers
+    };
+    const fetchOpts = {
+      method: opts.method || "GET",
+      headers
+    };
+    if (opts.body !== void 0) {
+      fetchOpts.body = JSON.stringify(opts.body);
+    }
+    const response = await fetch(url, fetchOpts);
+    if (!response.ok) {
+      const text = await response.text();
+      throw new ApiError(response.status, text || `HTTP ${response.status}`);
+    }
+    return response.json();
+  }
+  async validateApiKey() {
+    try {
+      await this.listConnections();
+      return true;
+    } catch (error) {
+      if (error instanceof ApiError && error.status === 401) {
+        return false;
+      }
+      throw error;
+    }
+  }
+  async listConnections() {
+    const allConnections = [];
+    let page = 1;
+    let totalPages = 1;
+    do {
+      const response = await this.request(`/vault/connections?page=${page}&limit=100`);
+      allConnections.push(...response.rows || []);
+      totalPages = response.pages || 1;
+      page++;
+    } while (page <= totalPages);
+    return allConnections;
+  }
+  async listPlatforms() {
+    const allPlatforms = [];
+    let page = 1;
+    let totalPages = 1;
+    do {
+      const response = await this.request(`/available-connectors?page=${page}&limit=100`);
+      allPlatforms.push(...response.rows || []);
+      totalPages = response.pages || 1;
+      page++;
+    } while (page <= totalPages);
+    return allPlatforms;
+  }
+  async searchActions(platform, query, agentType) {
+    const isKnowledgeAgent = !agentType || agentType === "knowledge";
+    const queryParams = {
+      query,
+      limit: "5"
+    };
+    if (isKnowledgeAgent) {
+      queryParams.knowledgeAgent = "true";
+    } else {
+      queryParams.executeAgent = "true";
+    }
+    const response = await this.requestFull({
+      path: `/available-actions/search/${platform}`,
+      queryParams
+    });
+    return response || [];
+  }
+  async getActionDetails(actionId) {
+    const response = await this.requestFull({
+      path: "/knowledge",
+      queryParams: { _id: actionId }
+    });
+    const actions = response?.rows || [];
+    if (actions.length === 0) {
+      throw new ApiError(404, `Action with ID ${actionId} not found`);
+    }
+    return actions[0];
+  }
+  async getActionKnowledge(actionId) {
+    const action = await this.getActionDetails(actionId);
+    if (!action.knowledge || !action.method) {
+      return {
+        knowledge: "No knowledge was found",
+        method: "No method was found"
+      };
+    }
+    return {
+      knowledge: action.knowledge,
+      method: action.method
+    };
+  }
+  async executePassthroughRequest(args, preloadedAction) {
+    const action = preloadedAction ?? await this.getActionDetails(args.actionId);
+    const method = action.method;
+    const contentType = args.isFormData ? "multipart/form-data" : args.isFormUrlEncoded ? "application/x-www-form-urlencoded" : "application/json";
+    const requestHeaders = {
+      "x-one-secret": this.apiKey,
+      "x-one-connection-key": args.connectionKey,
+      "x-one-action-id": action._id,
+      "Content-Type": contentType,
+      ...args.headers
+    };
+    const finalActionPath = args.pathVariables ? replacePathVariables(action.path, args.pathVariables) : action.path;
+    const normalizedPath = finalActionPath.startsWith("/") ? finalActionPath : `/${finalActionPath}`;
+    const url = `${API_BASE.replace("/v1", "")}/v1/passthrough${normalizedPath}`;
+    const isCustomAction = action.tags?.includes("custom");
+    let requestData = args.data;
+    if (isCustomAction && method?.toLowerCase() !== "get") {
+      requestData = {
+        ...args.data,
+        connectionKey: args.connectionKey
+      };
+    }
+    let queryString = "";
+    if (args.queryParams && Object.keys(args.queryParams).length > 0) {
+      const params = new URLSearchParams(
+        Object.entries(args.queryParams).map(([k, v]) => [k, String(v)])
+      );
+      queryString = `?${params.toString()}`;
+    }
+    const fullUrl = `${url}${queryString}`;
+    const fetchOpts = {
+      method,
+      headers: requestHeaders
+    };
+    if (method?.toLowerCase() !== "get" && requestData !== void 0) {
+      if (args.isFormUrlEncoded) {
+        const params = new URLSearchParams();
+        if (requestData && typeof requestData === "object" && !Array.isArray(requestData)) {
+          Object.entries(requestData).forEach(([key, value]) => {
+            if (typeof value === "object") {
+              params.append(key, JSON.stringify(value));
+            } else {
+              params.append(key, String(value));
+            }
+          });
+        }
+        fetchOpts.body = params.toString();
+      } else if (args.isFormData) {
+        const boundary = `----FormBoundary${Date.now()}`;
+        requestHeaders["Content-Type"] = `multipart/form-data; boundary=${boundary}`;
+        let body = "";
+        if (requestData && typeof requestData === "object" && !Array.isArray(requestData)) {
+          Object.entries(requestData).forEach(([key, value]) => {
+            body += `--${boundary}\r
+`;
+            body += `Content-Disposition: form-data; name="${key}"\r
+\r
+`;
+            body += typeof value === "object" ? JSON.stringify(value) : String(value);
+            body += "\r\n";
+          });
+        }
+        body += `--${boundary}--\r
+`;
+        fetchOpts.body = body;
+        fetchOpts.headers = requestHeaders;
+      } else {
+        fetchOpts.body = JSON.stringify(requestData);
+      }
+    }
+    const sanitizedConfig = {
+      url: fullUrl,
+      method,
+      headers: {
+        ...requestHeaders,
+        "x-one-secret": "***REDACTED***"
+      },
+      params: args.queryParams ? Object.fromEntries(
+        Object.entries(args.queryParams).map(([k, v]) => [k, String(v)])
+      ) : void 0,
+      data: requestData
+    };
+    if (args.dryRun) {
+      return {
+        requestConfig: sanitizedConfig,
+        responseData: null
+      };
+    }
+    const response = await fetch(fullUrl, fetchOpts);
+    if (!response.ok) {
+      const text = await response.text();
+      throw new ApiError(response.status, text || `HTTP ${response.status}`);
+    }
+    const responseText = await response.text();
+    const responseData = responseText ? JSON.parse(responseText) : {};
+    return {
+      requestConfig: sanitizedConfig,
+      responseData
+    };
+  }
+  async waitForConnection(platform, timeoutMs = 5 * 60 * 1e3, pollIntervalMs = 5e3, onPoll) {
+    const startTime = Date.now();
+    const existingConnections = await this.listConnections();
+    const existingIds = new Set(existingConnections.map((c) => c.id));
+    while (Date.now() - startTime < timeoutMs) {
+      await sleep(pollIntervalMs);
+      onPoll?.();
+      const currentConnections = await this.listConnections();
+      const newConnection = currentConnections.find(
+        (c) => c.platform.toLowerCase() === platform.toLowerCase() && !existingIds.has(c.id)
+      );
+      if (newConnection) {
+        return newConnection;
+      }
+    }
+    throw new TimeoutError(`Timed out waiting for ${platform} connection`);
+  }
+};
+var TimeoutError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "TimeoutError";
+  }
+};
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+function replacePathVariables(path3, variables) {
+  if (!path3) return path3;
+  let result = path3;
+  result = result.replace(/\{\{([^}]+)\}\}/g, (_match, variable) => {
+    const trimmedVariable = variable.trim();
+    const value = variables[trimmedVariable];
+    if (value === void 0 || value === null || value === "") {
+      throw new Error(`Missing value for path variable: ${trimmedVariable}`);
+    }
+    return encodeURIComponent(value.toString()).replace(/%3A/gi, ":");
+  });
+  result = result.replace(/\{([^}]+)\}/g, (_match, variable) => {
+    const trimmedVariable = variable.trim();
+    const value = variables[trimmedVariable];
+    if (value === void 0 || value === null || value === "") {
+      throw new Error(`Missing value for path variable: ${trimmedVariable}`);
+    }
+    return encodeURIComponent(value.toString()).replace(/%3A/gi, ":");
+  });
+  return result;
+}
+var PERMISSION_METHODS = {
+  read: ["GET"],
+  write: ["GET", "POST", "PUT", "PATCH"],
+  admin: null
+};
+function filterByPermissions(actions, permissions) {
+  const allowed = PERMISSION_METHODS[permissions];
+  if (allowed === null) return actions;
+  return actions.filter((a) => allowed.includes(a.method.toUpperCase()));
+}
+function isMethodAllowed(method, permissions) {
+  const allowed = PERMISSION_METHODS[permissions];
+  if (allowed === null) return true;
+  return allowed.includes(method.toUpperCase());
+}
+function isActionAllowed(actionId, allowedActionIds) {
+  return allowedActionIds.includes("*") || allowedActionIds.includes(actionId);
+}
+function buildActionKnowledgeWithGuidance(knowledge, method, platform, actionId) {
+  const baseUrl = "https://api.withone.ai";
+  return `${knowledge}
+
+API REQUEST STRUCTURE
+======================
+URL: ${baseUrl}/v1/passthrough/{{PATH}}
+
+IMPORTANT: When constructing the URL, only include the API endpoint path after the base URL.
+Do NOT include the full third-party API URL.
+
+Examples:
+  Correct: ${baseUrl}/v1/passthrough/crm/v3/objects/contacts/search
+  Incorrect: ${baseUrl}/v1/passthrough/https://api.hubapi.com/crm/v3/objects/contacts/search
+
+METHOD: ${method}
+
+HEADERS:
+- x-one-secret: {{process.env.ONE_SECRET}}
+- x-one-connection-key: {{process.env.ONE_${platform.toUpperCase()}_CONNECTION_KEY}}
+- x-one-action-id: ${actionId}
+- ... (other headers)
+
+BODY: {{BODY}}
+
+QUERY PARAMS: {{QUERY_PARAMS}}`;
+}
+
+// src/lib/flow-engine.ts
+var execAsync = promisify(exec);
+function sleep2(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+function resolveSelector(selectorPath, context) {
+  if (!selectorPath.startsWith("$.")) return selectorPath;
+  const parts = selectorPath.slice(2).split(/\.|\[/).map((p) => p.replace(/\]$/, ""));
+  let current = context;
+  for (const part of parts) {
+    if (current === null || current === void 0) return void 0;
+    if (part === "*" && Array.isArray(current)) {
+      continue;
+    }
+    if (Array.isArray(current) && part === "*") {
+      continue;
+    }
+    if (Array.isArray(current)) {
+      const idx = Number(part);
+      if (!isNaN(idx)) {
+        current = current[idx];
+      } else {
+        current = current.map((item) => item?.[part]);
+      }
+    } else if (typeof current === "object") {
+      current = current[part];
+    } else {
+      return void 0;
+    }
+  }
+  return current;
+}
+function interpolateString(str, context) {
+  return str.replace(/\{\{(\$\.[^}]+)\}\}/g, (_match, selector) => {
+    const value = resolveSelector(selector, context);
+    if (value === void 0 || value === null) return "";
+    if (typeof value === "object") return JSON.stringify(value);
+    return String(value);
+  });
+}
+function resolveValue(value, context) {
+  if (typeof value === "string") {
+    if (value.startsWith("$.") && !value.includes("{{")) {
+      return resolveSelector(value, context);
+    }
+    if (value.includes("{{$.")) {
+      return interpolateString(value, context);
+    }
+    return value;
+  }
+  if (Array.isArray(value)) {
+    return value.map((item) => resolveValue(item, context));
+  }
+  if (value && typeof value === "object") {
+    const resolved = {};
+    for (const [k, v] of Object.entries(value)) {
+      resolved[k] = resolveValue(v, context);
+    }
+    return resolved;
+  }
+  return value;
+}
+function evaluateExpression(expr, context) {
+  const fn = new Function("$", `return (${expr})`);
+  return fn(context);
+}
+function getByDotPath(obj, dotPath) {
+  const parts = dotPath.split(".");
+  let current = obj;
+  for (const part of parts) {
+    if (current === null || current === void 0) return void 0;
+    if (typeof current === "object") {
+      current = current[part];
+    } else {
+      return void 0;
+    }
+  }
+  return current;
+}
+function setByDotPath(obj, dotPath, value) {
+  const parts = dotPath.split(".");
+  let current = obj;
+  for (let i = 0; i < parts.length - 1; i++) {
+    if (current[parts[i]] === void 0 || current[parts[i]] === null) {
+      current[parts[i]] = {};
+    }
+    current = current[parts[i]];
+  }
+  current[parts[parts.length - 1]] = value;
+}
+var ALLOWED_MODULES = {
+  buffer: () => import("buffer"),
+  crypto: () => import("crypto"),
+  url: () => import("url"),
+  path: () => import("path")
+};
+var BLOCKED_MODULES = /* @__PURE__ */ new Set([
+  "fs",
+  "http",
+  "https",
+  "net",
+  "child_process",
+  "process",
+  "os",
+  "cluster",
+  "dgram",
+  "tls",
+  "vm",
+  "worker_threads"
+]);
+function createSandboxedRequire() {
+  const cache = {};
+  return async (moduleName) => {
+    const clean = moduleName.replace(/^node:/, "");
+    if (BLOCKED_MODULES.has(clean)) {
+      throw new Error(`Module "${moduleName}" is blocked in code steps`);
+    }
+    if (!ALLOWED_MODULES[clean]) {
+      throw new Error(`Module "${moduleName}" not available. Allowed: ${Object.keys(ALLOWED_MODULES).join(", ")}`);
+    }
+    if (!cache[clean]) cache[clean] = await ALLOWED_MODULES[clean]();
+    return cache[clean];
+  };
+}
+async function executeActionStep(step, context, api, permissions, allowedActionIds) {
+  const action = step.action;
+  const platform = resolveValue(action.platform, context);
+  const actionId = resolveValue(action.actionId, context);
+  const connectionKey = resolveValue(action.connectionKey, context);
+  const data = action.data ? resolveValue(action.data, context) : void 0;
+  const pathVars = action.pathVars ? resolveValue(action.pathVars, context) : void 0;
+  const queryParams = action.queryParams ? resolveValue(action.queryParams, context) : void 0;
+  const headers = action.headers ? resolveValue(action.headers, context) : void 0;
+  if (!isActionAllowed(actionId, allowedActionIds)) {
+    throw new Error(`Action "${actionId}" is not in the allowed action list`);
+  }
+  const actionDetails = await api.getActionDetails(actionId);
+  if (!isMethodAllowed(actionDetails.method, permissions)) {
+    throw new Error(`Method "${actionDetails.method}" is not allowed under "${permissions}" permission level`);
+  }
+  const result = await api.executePassthroughRequest({
+    platform,
+    actionId,
+    connectionKey,
+    data,
+    pathVariables: pathVars,
+    queryParams,
+    headers
+  }, actionDetails);
+  return {
+    status: "success",
+    response: result.responseData,
+    output: result.responseData
+  };
+}
+function executeTransformStep(step, context) {
+  const output = evaluateExpression(step.transform.expression, context);
+  return { status: "success", output, response: output };
+}
+async function executeCodeStep(step, context) {
+  const source = step.code.source;
+  const AsyncFunction = Object.getPrototypeOf(async function() {
+  }).constructor;
+  const sandboxedRequire = createSandboxedRequire();
+  const fn = new AsyncFunction("$", "require", source);
+  const output = await fn(context, sandboxedRequire);
+  return { status: "success", output, response: output };
+}
+async function executeConditionStep(step, context, api, permissions, allowedActionIds, options, flowStack) {
+  const condition = step.condition;
+  const result = evaluateExpression(condition.expression, context);
+  const branch = result ? condition.then : condition.else || [];
+  const branchResults = await executeSteps(branch, context, api, permissions, allowedActionIds, options, void 0, flowStack);
+  return {
+    status: "success",
+    output: { conditionResult: !!result, stepsExecuted: branchResults },
+    response: { conditionResult: !!result }
+  };
+}
+async function executeLoopStep(step, context, api, permissions, allowedActionIds, options, flowStack) {
+  const loop = step.loop;
+  const items = resolveValue(loop.over, context);
+  if (!Array.isArray(items)) {
+    throw new Error(`Loop "over" must resolve to an array, got ${typeof items}`);
+  }
+  const maxIterations = loop.maxIterations || 1e3;
+  const bounded = items.slice(0, maxIterations);
+  const savedLoop = { ...context.loop };
+  const iterationResults = [];
+  if (loop.maxConcurrency && loop.maxConcurrency > 1) {
+    const results2 = new Array(bounded.length);
+    for (let batchStart = 0; batchStart < bounded.length; batchStart += loop.maxConcurrency) {
+      const batch = bounded.slice(batchStart, batchStart + loop.maxConcurrency);
+      const batchResults = await Promise.all(
+        batch.map(async (item, batchIdx) => {
+          const i = batchStart + batchIdx;
+          const iterContext = {
+            ...context,
+            loop: {
+              [loop.as]: item,
+              item,
+              i,
+              ...loop.indexAs ? { [loop.indexAs]: i } : {}
+            },
+            steps: { ...context.steps }
+          };
+          const beforeKeys = new Set(Object.keys(iterContext.steps));
+          await executeSteps(loop.steps, iterContext, api, permissions, allowedActionIds, options, void 0, flowStack);
+          const iterResult = {};
+          for (const [key, val] of Object.entries(iterContext.steps)) {
+            if (!beforeKeys.has(key) || iterContext.steps[key] !== context.steps[key]) {
+              iterResult[key] = val;
+            }
+          }
+          iterationResults[i] = iterResult;
+          Object.assign(context.steps, iterContext.steps);
+          return iterContext.loop[loop.as];
+        })
+      );
+      for (let j = 0; j < batchResults.length; j++) {
+        results2[batchStart + j] = batchResults[j];
+      }
+    }
+    context.loop = savedLoop;
+    return {
+      status: "success",
+      output: results2,
+      response: { items: results2, iterations: iterationResults }
+    };
+  }
+  const results = [];
+  for (let i = 0; i < bounded.length; i++) {
+    context.loop = {
+      [loop.as]: bounded[i],
+      item: bounded[i],
+      i
+    };
+    if (loop.indexAs) {
+      context.loop[loop.indexAs] = i;
+    }
+    const beforeKeys = new Set(Object.keys(context.steps));
+    await executeSteps(loop.steps, context, api, permissions, allowedActionIds, options, void 0, flowStack);
+    const iterResult = {};
+    for (const [key, val] of Object.entries(context.steps)) {
+      if (!beforeKeys.has(key) || context.steps[key] !== (beforeKeys.has(key) ? void 0 : val)) {
+        iterResult[key] = val;
+      }
+    }
+    iterationResults.push(iterResult);
+    results.push(context.loop[loop.as]);
+  }
+  context.loop = savedLoop;
+  return {
+    status: "success",
+    output: results,
+    response: { items: results, iterations: iterationResults }
+  };
+}
+async function executeParallelStep(step, context, api, permissions, allowedActionIds, options, flowStack) {
+  const parallel = step.parallel;
+  const maxConcurrency = parallel.maxConcurrency || 5;
+  const steps = parallel.steps;
+  const results = [];
+  for (let i = 0; i < steps.length; i += maxConcurrency) {
+    const batch = steps.slice(i, i + maxConcurrency);
+    const batchResults = await Promise.all(
+      batch.map((s) => executeSingleStep(s, context, api, permissions, allowedActionIds, options, flowStack))
+    );
+    for (let j = 0; j < batch.length; j++) {
+      context.steps[batch[j].id] = batchResults[j];
+    }
+    results.push(...batchResults);
+  }
+  return { status: "success", output: results, response: results };
+}
+function executeFileReadStep(step, context) {
+  const config = step.fileRead;
+  const filePath = resolveValue(config.path, context);
+  const resolvedPath = path.resolve(filePath);
+  const content = fs.readFileSync(resolvedPath, "utf-8");
+  const output = config.parseJson ? JSON.parse(content) : content;
+  return { status: "success", output, response: output };
+}
+function executeFileWriteStep(step, context) {
+  const config = step.fileWrite;
+  const filePath = resolveValue(config.path, context);
+  const content = resolveValue(config.content, context);
+  const resolvedPath = path.resolve(filePath);
+  const dir = path.dirname(resolvedPath);
+  if (!fs.existsSync(dir)) {
+    fs.mkdirSync(dir, { recursive: true });
+  }
+  const stringContent = typeof content === "string" ? content : JSON.stringify(content, null, 2);
+  if (config.append) {
+    fs.appendFileSync(resolvedPath, stringContent);
+  } else {
+    fs.writeFileSync(resolvedPath, stringContent);
+  }
+  return { status: "success", output: { path: resolvedPath, bytesWritten: stringContent.length }, response: { path: resolvedPath } };
+}
+async function executeWhileStep(step, context, api, permissions, allowedActionIds, options, flowStack) {
+  const config = step.while;
+  const maxIterations = config.maxIterations ?? 100;
+  const results = [];
+  context.steps[step.id] = {
+    status: "success",
+    output: { lastResult: void 0, iteration: 0, results: [] }
+  };
+  for (let iteration = 0; iteration < maxIterations; iteration++) {
+    if (iteration > 0) {
+      const conditionResult = evaluateExpression(config.condition, context);
+      if (!conditionResult) break;
+    }
+    await executeSteps(config.steps, context, api, permissions, allowedActionIds, options, void 0, flowStack);
+    const lastStepId = config.steps[config.steps.length - 1]?.id;
+    const lastResult = lastStepId ? context.steps[lastStepId]?.output : void 0;
+    results.push(lastResult);
+    context.steps[step.id] = {
+      status: "success",
+      output: { lastResult, iteration, results }
+    };
+  }
+  return {
+    status: "success",
+    output: { lastResult: results[results.length - 1], iteration: results.length, results },
+    response: { iterations: results.length, results }
+  };
+}
+async function executeSubflowStep(step, context, api, permissions, allowedActionIds, options, flowStack) {
+  const config = step.flow;
+  const resolvedKey = resolveValue(config.key, context);
+  const resolvedInputs = config.inputs ? resolveValue(config.inputs, context) : {};
+  if (flowStack.includes(resolvedKey)) {
+    throw new Error(`Circular flow detected: ${[...flowStack, resolvedKey].join(" \u2192 ")}`);
+  }
+  const { loadFlow: loadFlow2 } = await import("./flow-runner-JHEAUFDL.js");
+  const subFlow = loadFlow2(resolvedKey);
+  const subContext = await executeFlow(
+    subFlow,
+    resolvedInputs,
+    api,
+    permissions,
+    allowedActionIds,
+    options,
+    void 0,
+    [...flowStack, resolvedKey]
+  );
+  return {
+    status: "success",
+    output: subContext.steps,
+    response: subContext
+  };
+}
+async function executePaginateStep(step, context, api, permissions, allowedActionIds, options) {
+  const config = step.paginate;
+  const maxPages = config.maxPages ?? 10;
+  const allResults = [];
+  let pageToken = void 0;
+  let pages = 0;
+  for (let page = 0; page < maxPages; page++) {
+    const actionConfig = JSON.parse(JSON.stringify(config.action));
+    if (pageToken !== void 0 && pageToken !== null) {
+      const resolved = resolveValue(actionConfig, context);
+      setByDotPath(resolved, config.inputTokenParam, pageToken);
+      const syntheticStep = {
+        id: `${step.id}__page${page}`,
+        name: `${step.id} page ${page}`,
+        type: "action",
+        action: resolved
+      };
+      const result = await executeActionStep(syntheticStep, context, api, permissions, allowedActionIds);
+      const response = result.response;
+      const pageResults = getByDotPath(response, config.resultsField);
+      if (Array.isArray(pageResults)) allResults.push(...pageResults);
+      pageToken = getByDotPath(response, config.pageTokenField);
+      pages++;
+      options.onEvent?.({ event: "step:page", stepId: step.id, page: pages });
+      if (pageToken === void 0 || pageToken === null) break;
+    } else if (page === 0) {
+      const resolvedAction = resolveValue(actionConfig, context);
+      const syntheticStep = {
+        id: `${step.id}__page0`,
+        name: `${step.id} page 0`,
+        type: "action",
+        action: resolvedAction
+      };
+      const result = await executeActionStep(syntheticStep, context, api, permissions, allowedActionIds);
+      const response = result.response;
+      const pageResults = getByDotPath(response, config.resultsField);
+      if (Array.isArray(pageResults)) allResults.push(...pageResults);
+      pageToken = getByDotPath(response, config.pageTokenField);
+      pages++;
+      options.onEvent?.({ event: "step:page", stepId: step.id, page: pages });
+      if (pageToken === void 0 || pageToken === null) break;
+    }
+  }
+  return {
+    status: "success",
+    output: allResults,
+    response: { pages, totalResults: allResults.length, results: allResults }
+  };
+}
+async function executeBashStep(step, context, options) {
+  if (!options.allowBash) {
+    throw new Error("Bash steps require --allow-bash flag for security");
+  }
+  const config = step.bash;
+  const command = resolveValue(config.command, context);
+  const cwd = config.cwd ? resolveValue(config.cwd, context) : process.cwd();
+  const env = config.env ? { ...process.env, ...resolveValue(config.env, context) } : process.env;
+  const { stdout, stderr } = await execAsync(command, {
+    timeout: config.timeout || 3e4,
+    cwd,
+    env,
+    maxBuffer: 10 * 1024 * 1024
+  });
+  const output = config.parseJson ? JSON.parse(stdout) : stdout.trim();
+  return {
+    status: "success",
+    output,
+    response: { stdout: stdout.trim(), stderr: stderr.trim(), exitCode: 0 }
+  };
+}
+async function executeSingleStep(step, context, api, permissions, allowedActionIds, options, flowStack = []) {
+  if (step.if) {
+    const condResult = evaluateExpression(step.if, context);
+    if (!condResult) {
+      const result = { status: "skipped" };
+      context.steps[step.id] = result;
+      return result;
+    }
+  }
+  if (step.unless) {
+    const condResult = evaluateExpression(step.unless, context);
+    if (condResult) {
+      const result = { status: "skipped" };
+      context.steps[step.id] = result;
+      return result;
+    }
+  }
+  const startTime = Date.now();
+  let lastError;
+  const maxAttempts = step.onError?.strategy === "retry" && step.onError.retries ? step.onError.retries + 1 : 1;
+  for (let attempt = 1; attempt <= maxAttempts; attempt++) {
+    try {
+      if (attempt > 1) {
+        options.onEvent?.({
+          event: "step:retry",
+          stepId: step.id,
+          attempt,
+          maxRetries: step.onError.retries
+        });
+        const delay = step.onError?.retryDelayMs || 1e3;
+        await sleep2(delay);
+      }
+      if (options.mock && (step.type === "action" || step.type === "paginate" || step.type === "bash")) {
+        const resolvedConfig = step[step.type] ? resolveValue(step[step.type], context) : {};
+        options.onEvent?.({ event: "step:mock", stepId: step.id, type: step.type, config: resolvedConfig });
+        const result2 = {
+          status: "success",
+          output: { _mock: true, ...resolvedConfig },
+          response: { _mock: true },
+          durationMs: Date.now() - startTime
+        };
+        context.steps[step.id] = result2;
+        return result2;
+      }
+      let result;
+      switch (step.type) {
+        case "action":
+          result = await executeActionStep(step, context, api, permissions, allowedActionIds);
+          break;
+        case "transform":
+          result = executeTransformStep(step, context);
+          break;
+        case "code":
+          result = await executeCodeStep(step, context);
+          break;
+        case "condition":
+          result = await executeConditionStep(step, context, api, permissions, allowedActionIds, options, flowStack);
+          break;
+        case "loop":
+          result = await executeLoopStep(step, context, api, permissions, allowedActionIds, options, flowStack);
+          break;
+        case "parallel":
+          result = await executeParallelStep(step, context, api, permissions, allowedActionIds, options, flowStack);
+          break;
+        case "file-read":
+          result = executeFileReadStep(step, context);
+          break;
+        case "file-write":
+          result = executeFileWriteStep(step, context);
+          break;
+        case "while":
+          result = await executeWhileStep(step, context, api, permissions, allowedActionIds, options, flowStack);
+          break;
+        case "flow":
+          result = await executeSubflowStep(step, context, api, permissions, allowedActionIds, options, flowStack);
+          break;
+        case "paginate":
+          result = await executePaginateStep(step, context, api, permissions, allowedActionIds, options);
+          break;
+        case "bash":
+          result = await executeBashStep(step, context, options);
+          break;
+        default:
+          throw new Error(`Unknown step type: ${step.type}`);
+      }
+      result.durationMs = Date.now() - startTime;
+      if (attempt > 1) result.retries = attempt - 1;
+      context.steps[step.id] = result;
+      return result;
+    } catch (err) {
+      lastError = err instanceof Error ? err : new Error(String(err));
+      if (attempt === maxAttempts) {
+        break;
+      }
+    }
+  }
+  const errorMessage = lastError?.message || "Unknown error";
+  const strategy = step.onError?.strategy || "fail";
+  if (strategy === "continue") {
+    const result = {
+      status: "failed",
+      error: errorMessage,
+      durationMs: Date.now() - startTime
+    };
+    context.steps[step.id] = result;
+    return result;
+  }
+  if (strategy === "fallback" && step.onError?.fallbackStepId) {
+    const result = {
+      status: "failed",
+      error: errorMessage,
+      durationMs: Date.now() - startTime
+    };
+    context.steps[step.id] = result;
+    return result;
+  }
+  throw lastError;
+}
+async function executeSteps(steps, context, api, permissions, allowedActionIds, options, completedStepIds, flowStack = []) {
+  const results = [];
+  for (const step of steps) {
+    if (completedStepIds?.has(step.id)) {
+      results.push(context.steps[step.id] || { status: "success" });
+      continue;
+    }
+    options.onEvent?.({
+      event: "step:start",
+      stepId: step.id,
+      stepName: step.name,
+      type: step.type,
+      timestamp: (/* @__PURE__ */ new Date()).toISOString()
+    });
+    try {
+      const result = await executeSingleStep(step, context, api, permissions, allowedActionIds, options, flowStack);
+      results.push(result);
+      options.onEvent?.({
+        event: "step:complete",
+        stepId: step.id,
+        status: result.status,
+        durationMs: result.durationMs,
+        retries: result.retries
+      });
+    } catch (error) {
+      const errorMsg = error instanceof Error ? error.message : String(error);
+      options.onEvent?.({
+        event: "step:error",
+        stepId: step.id,
+        error: errorMsg,
+        strategy: step.onError?.strategy || "fail"
+      });
+      throw error;
+    }
+  }
+  return results;
+}
+async function executeFlow(flow, inputs, api, permissions, allowedActionIds, options = {}, resumeState, flowStack = []) {
+  for (const [name, decl] of Object.entries(flow.inputs)) {
+    if (decl.required !== false && inputs[name] === void 0 && decl.default === void 0) {
+      throw new Error(`Missing required input: "${name}" \u2014 ${decl.description || ""}`);
+    }
+  }
+  const resolvedInputs = {};
+  for (const [name, decl] of Object.entries(flow.inputs)) {
+    if (inputs[name] !== void 0) {
+      resolvedInputs[name] = inputs[name];
+    } else if (decl.default !== void 0) {
+      resolvedInputs[name] = decl.default;
+    }
+  }
+  const context = resumeState?.context || {
+    input: resolvedInputs,
+    env: process.env,
+    steps: {},
+    loop: {}
+  };
+  const completedStepIds = resumeState ? new Set(resumeState.completedSteps) : void 0;
+  if (options.dryRun && !options.mock) {
+    options.onEvent?.({
+      event: "flow:dry-run",
+      flowKey: flow.key,
+      resolvedInputs,
+      steps: flow.steps.map((s) => ({ id: s.id, name: s.name, type: s.type })),
+      timestamp: (/* @__PURE__ */ new Date()).toISOString()
+    });
+    return context;
+  }
+  options.onEvent?.({
+    event: options.mock ? "flow:mock-start" : "flow:start",
+    flowKey: flow.key,
+    totalSteps: flow.steps.length,
+    timestamp: (/* @__PURE__ */ new Date()).toISOString()
+  });
+  const flowStart = Date.now();
+  try {
+    await executeSteps(flow.steps, context, api, permissions, allowedActionIds, options, completedStepIds, flowStack);
+    const stepEntries = Object.values(context.steps);
+    const completed = stepEntries.filter((s) => s.status === "success").length;
+    const failed = stepEntries.filter((s) => s.status === "failed").length;
+    const skipped = stepEntries.filter((s) => s.status === "skipped").length;
+    options.onEvent?.({
+      event: "flow:complete",
+      flowKey: flow.key,
+      status: "success",
+      durationMs: Date.now() - flowStart,
+      stepsCompleted: completed,
+      stepsFailed: failed,
+      stepsSkipped: skipped
+    });
+  } catch (error) {
+    const errorMsg = error instanceof Error ? error.message : String(error);
+    options.onEvent?.({
+      event: "flow:error",
+      flowKey: flow.key,
+      status: "failed",
+      error: errorMsg,
+      durationMs: Date.now() - flowStart
+    });
+    throw error;
+  }
+  return context;
+}
+
+// src/lib/flow-runner.ts
+var FLOWS_DIR = ".one/flows";
+var RUNS_DIR = ".one/flows/.runs";
+var LOGS_DIR = ".one/flows/.logs";
+function ensureDir(dir) {
+  if (!fs2.existsSync(dir)) {
+    fs2.mkdirSync(dir, { recursive: true });
+  }
+}
+function generateRunId() {
+  return crypto.randomBytes(6).toString("hex");
+}
+var FlowRunner = class _FlowRunner {
+  runId;
+  flowKey;
+  state;
+  logPath;
+  statePath;
+  paused = false;
+  constructor(flow, inputs, runId) {
+    this.runId = runId || generateRunId();
+    this.flowKey = flow.key;
+    ensureDir(RUNS_DIR);
+    ensureDir(LOGS_DIR);
+    this.statePath = path2.join(RUNS_DIR, `${flow.key}-${this.runId}.state.json`);
+    this.logPath = path2.join(LOGS_DIR, `${flow.key}-${this.runId}.log`);
+    this.state = {
+      runId: this.runId,
+      flowKey: flow.key,
+      status: "running",
+      startedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      inputs,
+      completedSteps: [],
+      context: {
+        input: inputs,
+        env: {},
+        steps: {},
+        loop: {}
+      }
+    };
+  }
+  getRunId() {
+    return this.runId;
+  }
+  getLogPath() {
+    return this.logPath;
+  }
+  getStatePath() {
+    return this.statePath;
+  }
+  requestPause() {
+    this.paused = true;
+  }
+  log(level, msg, data) {
+    const entry = {
+      ts: (/* @__PURE__ */ new Date()).toISOString(),
+      level,
+      msg,
+      ...data
+    };
+    fs2.appendFileSync(this.logPath, JSON.stringify(entry) + "\n");
+  }
+  saveState() {
+    fs2.writeFileSync(this.statePath, JSON.stringify(this.state, null, 2));
+  }
+  createEventHandler(externalHandler) {
+    return (event) => {
+      this.log(
+        event.event.includes("error") ? "warn" : "info",
+        event.event,
+        event
+      );
+      if (event.event === "step:complete" && event.stepId) {
+        this.state.completedSteps.push(event.stepId);
+        this.state.currentStepId = void 0;
+        this.saveState();
+      }
+      if (event.event === "step:start" && event.stepId) {
+        this.state.currentStepId = event.stepId;
+      }
+      externalHandler?.(event);
+      if (this.paused && event.event === "step:complete") {
+        this.state.status = "paused";
+        this.state.pausedAt = (/* @__PURE__ */ new Date()).toISOString();
+        this.saveState();
+      }
+    };
+  }
+  async execute(flow, api, permissions, allowedActionIds, options = {}) {
+    this.log("info", "Flow started", { flowKey: this.flowKey, runId: this.runId });
+    this.state.status = "running";
+    const liveContext = {
+      input: this.state.inputs,
+      env: process.env,
+      steps: {},
+      loop: {}
+    };
+    this.state.context = liveContext;
+    this.saveState();
+    const eventHandler = this.createEventHandler(options.onEvent);
+    try {
+      const context = await executeFlow(
+        flow,
+        this.state.inputs,
+        api,
+        permissions,
+        allowedActionIds,
+        { ...options, onEvent: eventHandler },
+        { context: liveContext, completedSteps: [] }
+      );
+      this.state.status = "completed";
+      this.state.completedAt = (/* @__PURE__ */ new Date()).toISOString();
+      this.state.context = context;
+      this.saveState();
+      this.log("info", "Flow completed", { status: "success" });
+      return context;
+    } catch (error) {
+      const errorMsg = error instanceof Error ? error.message : String(error);
+      this.state.status = "failed";
+      this.state.context.steps = this.state.context.steps || {};
+      this.saveState();
+      this.log("error", "Flow failed", { error: errorMsg });
+      throw error;
+    }
+  }
+  async resume(flow, api, permissions, allowedActionIds, options = {}) {
+    this.log("info", "Flow resumed", { flowKey: this.flowKey, runId: this.runId });
+    this.state.status = "running";
+    this.state.pausedAt = void 0;
+    this.state.context.env = process.env;
+    this.saveState();
+    const eventHandler = this.createEventHandler(options.onEvent);
+    try {
+      const context = await executeFlow(
+        flow,
+        this.state.inputs,
+        api,
+        permissions,
+        allowedActionIds,
+        { ...options, onEvent: eventHandler },
+        {
+          context: this.state.context,
+          completedSteps: this.state.completedSteps
+        }
+      );
+      this.state.status = "completed";
+      this.state.completedAt = (/* @__PURE__ */ new Date()).toISOString();
+      this.state.context = context;
+      this.saveState();
+      this.log("info", "Flow completed after resume", { status: "success" });
+      return context;
+    } catch (error) {
+      const errorMsg = error instanceof Error ? error.message : String(error);
+      this.state.status = "failed";
+      this.saveState();
+      this.log("error", "Flow failed after resume", { error: errorMsg });
+      throw error;
+    }
+  }
+  static loadRunState(runId) {
+    ensureDir(RUNS_DIR);
+    const files = fs2.readdirSync(RUNS_DIR).filter((f) => f.includes(runId) && f.endsWith(".state.json"));
+    if (files.length === 0) return null;
+    try {
+      const content = fs2.readFileSync(path2.join(RUNS_DIR, files[0]), "utf-8");
+      return JSON.parse(content);
+    } catch {
+      return null;
+    }
+  }
+  static fromRunState(state) {
+    const runner = Object.create(_FlowRunner.prototype);
+    runner.runId = state.runId;
+    runner.flowKey = state.flowKey;
+    runner.state = state;
+    runner.paused = false;
+    runner.statePath = path2.join(RUNS_DIR, `${state.flowKey}-${state.runId}.state.json`);
+    runner.logPath = path2.join(LOGS_DIR, `${state.flowKey}-${state.runId}.log`);
+    return runner;
+  }
+  static listRuns(flowKey) {
+    ensureDir(RUNS_DIR);
+    const files = fs2.readdirSync(RUNS_DIR).filter((f) => f.endsWith(".state.json"));
+    const runs = [];
+    for (const file of files) {
+      try {
+        const content = fs2.readFileSync(path2.join(RUNS_DIR, file), "utf-8");
+        const state = JSON.parse(content);
+        if (!flowKey || state.flowKey === flowKey) {
+          runs.push(state);
+        }
+      } catch {
+      }
+    }
+    return runs.sort((a, b) => new Date(b.startedAt).getTime() - new Date(a.startedAt).getTime());
+  }
+};
+function resolveFlowPath(keyOrPath) {
+  if (keyOrPath.includes("/") || keyOrPath.includes("\\") || keyOrPath.endsWith(".json")) {
+    return path2.resolve(keyOrPath);
+  }
+  return path2.resolve(FLOWS_DIR, `${keyOrPath}.flow.json`);
+}
+function loadFlow(keyOrPath) {
+  const flowPath = resolveFlowPath(keyOrPath);
+  if (!fs2.existsSync(flowPath)) {
+    throw new Error(`Flow not found: ${flowPath}`);
+  }
+  const content = fs2.readFileSync(flowPath, "utf-8");
+  return JSON.parse(content);
+}
+function listFlows() {
+  const flowsDir = path2.resolve(FLOWS_DIR);
+  if (!fs2.existsSync(flowsDir)) return [];
+  const files = fs2.readdirSync(flowsDir).filter((f) => f.endsWith(".flow.json"));
+  const flows = [];
+  for (const file of files) {
+    try {
+      const content = fs2.readFileSync(path2.join(flowsDir, file), "utf-8");
+      const flow = JSON.parse(content);
+      flows.push({
+        key: flow.key,
+        name: flow.name,
+        description: flow.description,
+        inputCount: Object.keys(flow.inputs).length,
+        stepCount: flow.steps.length,
+        path: path2.join(flowsDir, file)
+      });
+    } catch {
+    }
+  }
+  return flows;
+}
+function saveFlow(flow, outputPath) {
+  const flowPath = outputPath ? path2.resolve(outputPath) : path2.resolve(FLOWS_DIR, `${flow.key}.flow.json`);
+  const dir = path2.dirname(flowPath);
+  ensureDir(dir);
+  fs2.writeFileSync(flowPath, JSON.stringify(flow, null, 2) + "\n");
+  return flowPath;
+}
+
+export {
+  OneApi,
+  TimeoutError,
+  filterByPermissions,
+  isMethodAllowed,
+  isActionAllowed,
+  buildActionKnowledgeWithGuidance,
+  FlowRunner,
+  resolveFlowPath,
+  loadFlow,
+  listFlows,
+  saveFlow
+};