@dexto/core 1.1.4 → 1.1.6

package/dist/utils/path.js

@@ -0,0 +1,159 @@
+import * as path from "path";
+import { existsSync } from "fs";
+import { promises as fs } from "fs";
+import { homedir } from "os";
+import { createRequire } from "module";
+import { fileURLToPath } from "url";
+import { walkUpDirectories } from "./fs-walk.js";
+import {
+  getExecutionContext,
+  findDextoSourceRoot,
+  findDextoProjectRoot
+} from "./execution-context.js";
+import { logger } from "../logger/index.js";
+function getDextoPath(type, filename, startPath) {
+  const context = getExecutionContext(startPath);
+  let basePath;
+  switch (context) {
+    case "dexto-source": {
+      const sourceRoot = findDextoSourceRoot(startPath);
+      if (!sourceRoot) {
+        throw new Error("Not in dexto source context");
+      }
+      basePath = path.join(sourceRoot, ".dexto", type);
+      break;
+    }
+    case "dexto-project": {
+      const projectRoot = findDextoProjectRoot(startPath);
+      if (!projectRoot) {
+        throw new Error("Not in dexto project context");
+      }
+      basePath = path.join(projectRoot, ".dexto", type);
+      break;
+    }
+    case "global-cli": {
+      basePath = path.join(homedir(), ".dexto", type);
+      break;
+    }
+    default: {
+      throw new Error(`Unknown execution context: ${context}`);
+    }
+  }
+  return filename ? path.join(basePath, filename) : basePath;
+}
+function getDextoGlobalPath(type, filename) {
+  const basePath = path.join(homedir(), ".dexto", type);
+  return filename ? path.join(basePath, filename) : basePath;
+}
+async function copyDirectory(src, dest) {
+  await fs.mkdir(dest, { recursive: true });
+  const entries = await fs.readdir(src, { withFileTypes: true });
+  for (const entry of entries) {
+    const srcPath = path.join(src, entry.name);
+    const destPath = path.join(dest, entry.name);
+    if (entry.isDirectory()) {
+      await copyDirectory(srcPath, destPath);
+    } else {
+      await fs.copyFile(srcPath, destPath);
+    }
+  }
+}
+function isPath(str) {
+  if (path.isAbsolute(str)) return true;
+  if (/[\\/]/.test(str)) return true;
+  if (/\.(ya?ml|json)$/i.test(str)) return true;
+  return false;
+}
+function findPackageRoot(startPath = process.cwd()) {
+  return walkUpDirectories(startPath, (dirPath) => {
+    const pkgPath = path.join(dirPath, "package.json");
+    return existsSync(pkgPath);
+  });
+}
+function resolveBundledScript(scriptPath) {
+  const candidates = scriptPath.startsWith("dist/") ? [scriptPath, scriptPath.replace(/^dist\//, "")] : [`dist/${scriptPath}`, scriptPath];
+  const triedAbs = [];
+  const tryRoots = (roots) => {
+    for (const root of roots) {
+      if (!root) continue;
+      for (const rel of candidates) {
+        const abs = path.resolve(root, rel);
+        if (existsSync(abs)) return abs;
+        triedAbs.push(abs);
+      }
+    }
+    return null;
+  };
+  const envRoot = process?.env?.DEXTO_PACKAGE_ROOT;
+  const fromEnv = tryRoots([envRoot]);
+  if (fromEnv) return fromEnv;
+  try {
+    const require2 = createRequire(import.meta.url);
+    const pkgJson = require2.resolve("dexto/package.json");
+    const pkgRoot = path.dirname(pkgJson);
+    const fromPkg = tryRoots([pkgRoot]);
+    if (fromPkg) return fromPkg;
+  } catch {
+  }
+  try {
+    const thisModuleDir = path.dirname(fileURLToPath(import.meta.url));
+    const sourceRoot = findDextoSourceRoot(thisModuleDir);
+    const fromSource = tryRoots([sourceRoot ?? void 0]);
+    if (fromSource) return fromSource;
+  } catch {
+  }
+  const repoRoot = findPackageRoot();
+  const fromCwd = tryRoots([repoRoot ?? void 0]);
+  if (fromCwd) return fromCwd;
+  throw new Error(
+    `Bundled script not found: ${scriptPath} (tried absolute: ${triedAbs.join(", ")})`
+  );
+}
+async function ensureDextoGlobalDirectory() {
+  const dextoDir = path.join(homedir(), ".dexto");
+  try {
+    await fs.mkdir(dextoDir, { recursive: true });
+  } catch (error) {
+    if (error.code !== "EEXIST") {
+      throw error;
+    }
+  }
+}
+function getDextoEnvPath(startPath = process.cwd()) {
+  const context = getExecutionContext(startPath);
+  let envPath = "";
+  switch (context) {
+    case "dexto-source": {
+      const sourceRoot = findDextoSourceRoot(startPath);
+      if (!sourceRoot) {
+        throw new Error("Not in dexto source context");
+      }
+      envPath = path.join(sourceRoot, ".env");
+      break;
+    }
+    case "dexto-project": {
+      const projectRoot = findDextoProjectRoot(startPath);
+      if (!projectRoot) {
+        throw new Error("Not in dexto project context");
+      }
+      envPath = path.join(projectRoot, ".env");
+      break;
+    }
+    case "global-cli": {
+      envPath = path.join(homedir(), ".dexto", ".env");
+      break;
+    }
+  }
+  logger.debug(`Dexto env path: ${envPath}, context: ${context}`);
+  return envPath;
+}
+export {
+  copyDirectory,
+  ensureDextoGlobalDirectory,
+  findPackageRoot,
+  getDextoEnvPath,
+  getDextoGlobalPath,
+  getDextoPath,
+  isPath,
+  resolveBundledScript
+};

package/dist/utils/port-utils.cjs

@@ -0,0 +1,37 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var port_utils_exports = {};
+__export(port_utils_exports, {
+  getPort: () => getPort
+});
+module.exports = __toCommonJS(port_utils_exports);
+function getPort(envVar, defaultPort, varName) {
+  if (envVar === void 0) {
+    return defaultPort;
+  }
+  const port = parseInt(envVar, 10);
+  if (isNaN(port) || port <= 0 || port > 65535) {
+    throw new Error(`Environment variable ${varName} value "${envVar}" is not a valid port`);
+  }
+  return port;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  getPort
+});

package/dist/utils/port-utils.d.cts

@@ -0,0 +1,11 @@
+/**
+ * Parse an environment variable as a port number, with validation.
+ * @param envVar - the string value from process.env
+ * @param defaultPort - fallback port if envVar is undefined
+ * @param varName - the name of the environment variable (used in error messages)
+ * @returns a valid port number
+ * @throws if envVar is set but not a valid port number
+ */
+declare function getPort(envVar: string | undefined, defaultPort: number, varName: string): number;
+
+export { getPort };

package/dist/utils/port-utils.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Parse an environment variable as a port number, with validation.
+ * @param envVar - the string value from process.env
+ * @param defaultPort - fallback port if envVar is undefined
+ * @param varName - the name of the environment variable (used in error messages)
+ * @returns a valid port number
+ * @throws if envVar is set but not a valid port number
+ */
+declare function getPort(envVar: string | undefined, defaultPort: number, varName: string): number;
+
+export { getPort };

package/dist/utils/port-utils.js

@@ -0,0 +1,13 @@
+function getPort(envVar, defaultPort, varName) {
+  if (envVar === void 0) {
+    return defaultPort;
+  }
+  const port = parseInt(envVar, 10);
+  if (isNaN(port) || port <= 0 || port > 65535) {
+    throw new Error(`Environment variable ${varName} value "${envVar}" is not a valid port`);
+  }
+  return port;
+}
+export {
+  getPort
+};

package/dist/utils/port-utils.spec.cjs

@@ -0,0 +1,26 @@
+"use strict";
+var import_vitest = require("vitest");
+var import_port_utils = require("./port-utils.js");
+(0, import_vitest.describe)("getPort", () => {
+  (0, import_vitest.it)("returns default if envVar is undefined", () => {
+    (0, import_vitest.expect)((0, import_port_utils.getPort)(void 0, 3e3, "TEST")).toBe(3e3);
+  });
+  (0, import_vitest.it)("parses valid numeric string", () => {
+    (0, import_vitest.expect)((0, import_port_utils.getPort)("8080", 3e3, "TEST")).toBe(8080);
+  });
+  (0, import_vitest.it)("throws error for non-numeric string", () => {
+    (0, import_vitest.expect)(() => (0, import_port_utils.getPort)("not-a-number", 3e3, "TEST")).toThrow(
+      'Environment variable TEST value "not-a-number" is not a valid port'
+    );
+  });
+  (0, import_vitest.it)("throws error for negative port", () => {
+    (0, import_vitest.expect)(() => (0, import_port_utils.getPort)("-1", 3e3, "TEST")).toThrow(
+      'Environment variable TEST value "-1" is not a valid port'
+    );
+  });
+  (0, import_vitest.it)("throws error for port > 65535", () => {
+    (0, import_vitest.expect)(() => (0, import_port_utils.getPort)("70000", 3e3, "TEST")).toThrow(
+      'Environment variable TEST value "70000" is not a valid port'
+    );
+  });
+});

package/dist/utils/port-utils.spec.d.cts

@@ -0,0 +1,2 @@
+
+export {  }

package/dist/utils/port-utils.spec.d.ts

@@ -0,0 +1,2 @@
+
+export {  }

package/dist/utils/port-utils.spec.js

@@ -0,0 +1,25 @@
+import { describe, it, expect } from "vitest";
+import { getPort } from "./port-utils.js";
+describe("getPort", () => {
+  it("returns default if envVar is undefined", () => {
+    expect(getPort(void 0, 3e3, "TEST")).toBe(3e3);
+  });
+  it("parses valid numeric string", () => {
+    expect(getPort("8080", 3e3, "TEST")).toBe(8080);
+  });
+  it("throws error for non-numeric string", () => {
+    expect(() => getPort("not-a-number", 3e3, "TEST")).toThrow(
+      'Environment variable TEST value "not-a-number" is not a valid port'
+    );
+  });
+  it("throws error for negative port", () => {
+    expect(() => getPort("-1", 3e3, "TEST")).toThrow(
+      'Environment variable TEST value "-1" is not a valid port'
+    );
+  });
+  it("throws error for port > 65535", () => {
+    expect(() => getPort("70000", 3e3, "TEST")).toThrow(
+      'Environment variable TEST value "70000" is not a valid port'
+    );
+  });
+});

package/dist/utils/redactor.cjs

@@ -0,0 +1,105 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var redactor_exports = {};
+__export(redactor_exports, {
+  redactSensitiveData: () => redactSensitiveData
+});
+module.exports = __toCommonJS(redactor_exports);
+const SENSITIVE_FIELDS = [
+  "apikey",
+  "api_key",
+  "token",
+  "access_token",
+  "refresh_token",
+  "password",
+  "secret"
+];
+const FILE_DATA_FIELDS = [
+  "base64",
+  "filedata",
+  "file_data",
+  "imagedata",
+  "image_data",
+  "audiodata",
+  "audio_data",
+  "data"
+];
+const SENSITIVE_PATTERNS = [
+  /\bsk-[A-Za-z0-9]{20,}\b/g,
+  // OpenAI API keys (at least 20 chars after sk-)
+  /\bBearer\s+[A-Za-z0-9\-_.=]+\b/gi,
+  // Bearer tokens
+  /\b[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\.[A-Za-z]{2,}\b/g,
+  // Emails
+  /\beyJ[A-Za-z0-9_-]*\.[A-Za-z0-9_-]*\.[A-Za-z0-9_-]*/g
+  // JWT tokens
+];
+const REDACTED = "[REDACTED]";
+const REDACTED_CIRCULAR = "[REDACTED_CIRCULAR]";
+const FILE_DATA_TRUNCATED = "[FILE_DATA_TRUNCATED]";
+function isLargeBase64Data(value) {
+  return value.length > 1e3 && /^[A-Za-z0-9+/=]{1000,}$/.test(value.substring(0, 1e3));
+}
+function truncateFileData(value, key, parent) {
+  if (typeof value !== "string") return value;
+  const lowerKey = key.toLowerCase();
+  const hasFileContext = !!parent && ("mimeType" in parent || "filename" in parent || "fileName" in parent);
+  const looksLikeFileField = FILE_DATA_FIELDS.includes(lowerKey) || lowerKey === "data" && hasFileContext;
+  if (looksLikeFileField && isLargeBase64Data(value)) {
+    return `${FILE_DATA_TRUNCATED} (${value.length} chars)`;
+  }
+  return value;
+}
+function redactSensitiveData(input, seen = /* @__PURE__ */ new WeakSet()) {
+  if (typeof input === "string") {
+    let result = input;
+    for (const pattern of SENSITIVE_PATTERNS) {
+      result = result.replace(pattern, REDACTED);
+    }
+    return result;
+  }
+  if (Array.isArray(input)) {
+    if (seen.has(input)) return REDACTED_CIRCULAR;
+    seen.add(input);
+    return input.map((item) => redactSensitiveData(item, seen));
+  }
+  if (input && typeof input === "object") {
+    if (seen.has(input)) return REDACTED_CIRCULAR;
+    seen.add(input);
+    const result = {};
+    for (const [key, value] of Object.entries(input)) {
+      if (SENSITIVE_FIELDS.includes(key.toLowerCase())) {
+        result[key] = REDACTED;
+      } else {
+        const truncatedValue = truncateFileData(
+          value,
+          key,
+          input
+        );
+        result[key] = redactSensitiveData(truncatedValue, seen);
+      }
+    }
+    return result;
+  }
+  return input;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  redactSensitiveData
+});

package/dist/utils/redactor.d.cts

@@ -0,0 +1,18 @@
+/**
+ * Utility to redact sensitive information from objects, arrays, and strings.
+ * - Redacts by field name (e.g., apiKey, token, password, etc.)
+ * - Redacts by value pattern (e.g., OpenAI keys, Bearer tokens, emails)
+ * - Handles deeply nested structures and circular references
+ * - Recursive and preserves structure
+ * - Easy to extend
+ */
+/**
+ * Redacts sensitive data from an object, array, or string.
+ * Handles circular references gracefully.
+ * @param input - The data to redact
+ * @param seen - Internal set to track circular references
+ * @returns The redacted data
+ */
+declare function redactSensitiveData(input: unknown, seen?: WeakSet<object>): unknown;
+
+export { redactSensitiveData };

package/dist/utils/redactor.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Utility to redact sensitive information from objects, arrays, and strings.
+ * - Redacts by field name (e.g., apiKey, token, password, etc.)
+ * - Redacts by value pattern (e.g., OpenAI keys, Bearer tokens, emails)
+ * - Handles deeply nested structures and circular references
+ * - Recursive and preserves structure
+ * - Easy to extend
+ */
+/**
+ * Redacts sensitive data from an object, array, or string.
+ * Handles circular references gracefully.
+ * @param input - The data to redact
+ * @param seen - Internal set to track circular references
+ * @returns The redacted data
+ */
+declare function redactSensitiveData(input: unknown, seen?: WeakSet<object>): unknown;
+
+export { redactSensitiveData };

package/dist/utils/redactor.js

@@ -0,0 +1,81 @@
+const SENSITIVE_FIELDS = [
+  "apikey",
+  "api_key",
+  "token",
+  "access_token",
+  "refresh_token",
+  "password",
+  "secret"
+];
+const FILE_DATA_FIELDS = [
+  "base64",
+  "filedata",
+  "file_data",
+  "imagedata",
+  "image_data",
+  "audiodata",
+  "audio_data",
+  "data"
+];
+const SENSITIVE_PATTERNS = [
+  /\bsk-[A-Za-z0-9]{20,}\b/g,
+  // OpenAI API keys (at least 20 chars after sk-)
+  /\bBearer\s+[A-Za-z0-9\-_.=]+\b/gi,
+  // Bearer tokens
+  /\b[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\.[A-Za-z]{2,}\b/g,
+  // Emails
+  /\beyJ[A-Za-z0-9_-]*\.[A-Za-z0-9_-]*\.[A-Za-z0-9_-]*/g
+  // JWT tokens
+];
+const REDACTED = "[REDACTED]";
+const REDACTED_CIRCULAR = "[REDACTED_CIRCULAR]";
+const FILE_DATA_TRUNCATED = "[FILE_DATA_TRUNCATED]";
+function isLargeBase64Data(value) {
+  return value.length > 1e3 && /^[A-Za-z0-9+/=]{1000,}$/.test(value.substring(0, 1e3));
+}
+function truncateFileData(value, key, parent) {
+  if (typeof value !== "string") return value;
+  const lowerKey = key.toLowerCase();
+  const hasFileContext = !!parent && ("mimeType" in parent || "filename" in parent || "fileName" in parent);
+  const looksLikeFileField = FILE_DATA_FIELDS.includes(lowerKey) || lowerKey === "data" && hasFileContext;
+  if (looksLikeFileField && isLargeBase64Data(value)) {
+    return `${FILE_DATA_TRUNCATED} (${value.length} chars)`;
+  }
+  return value;
+}
+function redactSensitiveData(input, seen = /* @__PURE__ */ new WeakSet()) {
+  if (typeof input === "string") {
+    let result = input;
+    for (const pattern of SENSITIVE_PATTERNS) {
+      result = result.replace(pattern, REDACTED);
+    }
+    return result;
+  }
+  if (Array.isArray(input)) {
+    if (seen.has(input)) return REDACTED_CIRCULAR;
+    seen.add(input);
+    return input.map((item) => redactSensitiveData(item, seen));
+  }
+  if (input && typeof input === "object") {
+    if (seen.has(input)) return REDACTED_CIRCULAR;
+    seen.add(input);
+    const result = {};
+    for (const [key, value] of Object.entries(input)) {
+      if (SENSITIVE_FIELDS.includes(key.toLowerCase())) {
+        result[key] = REDACTED;
+      } else {
+        const truncatedValue = truncateFileData(
+          value,
+          key,
+          input
+        );
+        result[key] = redactSensitiveData(truncatedValue, seen);
+      }
+    }
+    return result;
+  }
+  return input;
+}
+export {
+  redactSensitiveData
+};

package/dist/utils/result.cjs

@@ -0,0 +1,115 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var result_exports = {};
+__export(result_exports, {
+  EnvExpandedString: () => EnvExpandedString,
+  NonEmptyEnvExpandedString: () => NonEmptyEnvExpandedString,
+  NonEmptyTrimmed: () => NonEmptyTrimmed,
+  OptionalURL: () => OptionalURL,
+  RequiredEnvURL: () => RequiredEnvURL,
+  fail: () => fail,
+  hasErrors: () => hasErrors,
+  ok: () => ok,
+  splitIssues: () => splitIssues,
+  zodToIssues: () => zodToIssues
+});
+module.exports = __toCommonJS(result_exports);
+var import_zod = require("zod");
+var import_types = require("../errors/types.cjs");
+const NonEmptyTrimmed = import_zod.z.string().transform((s) => s.trim()).refine((s) => s.length > 0, { message: "Required" });
+function isValidUrl(s) {
+  try {
+    const u = new URL(s);
+    return u.protocol === "http:" || u.protocol === "https:";
+  } catch {
+    return false;
+  }
+}
+const OptionalURL = import_zod.z.string().transform((s) => s.trim()).refine((s) => s === "" || isValidUrl(s), { message: "Invalid URL" }).transform((s) => s === "" ? void 0 : s).optional();
+const EnvExpandedString = (env) => import_zod.z.string().transform((input) => {
+  if (typeof input !== "string") return "";
+  const envToUse = env ?? process.env;
+  const out = input.replace(
+    /\$([A-Z_][A-Z0-9_]*)|\${([A-Z_][A-Z0-9_]*)}/gi,
+    (_, a, b) => envToUse[a || b] ?? ""
+  );
+  return out.trim();
+});
+const NonEmptyEnvExpandedString = (env) => EnvExpandedString(env).refine((s) => s.length > 0, {
+  message: "Value is required"
+});
+const RequiredEnvURL = (env) => EnvExpandedString(env).refine(
+  (s) => {
+    try {
+      const u = new URL(s);
+      return u.protocol === "http:" || u.protocol === "https:";
+    } catch {
+      return false;
+    }
+  },
+  { message: "Invalid URL" }
+);
+const ok = (data, issues = []) => ({
+  ok: true,
+  data,
+  issues
+  // warnings live alongside errors here
+});
+const fail = (issues) => ({
+  ok: false,
+  issues
+});
+function hasErrors(issues) {
+  return issues.some((i) => i.severity !== "warning");
+}
+function splitIssues(issues) {
+  return {
+    errors: issues.filter((i) => i.severity !== "warning"),
+    warnings: issues.filter((i) => i.severity === "warning")
+  };
+}
+function zodToIssues(err, severity = "error") {
+  return err.errors.map((e) => {
+    const params = e.params || {};
+    return {
+      code: params.code ?? "schema_validation",
+      message: e.message,
+      scope: params.scope ?? import_types.ErrorScope.AGENT,
+      // Fallback for non-custom Zod errors
+      // Treat plain Zod schema failures as USER errors by default
+      type: params.type ?? import_types.ErrorType.USER,
+      path: e.path,
+      severity,
+      context: params
+    };
+  });
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  EnvExpandedString,
+  NonEmptyEnvExpandedString,
+  NonEmptyTrimmed,
+  OptionalURL,
+  RequiredEnvURL,
+  fail,
+  hasErrors,
+  ok,
+  splitIssues,
+  zodToIssues
+});