@botbotgo/common 1.0.65

package/dist/chunk-X4TDNR4V.js

@@ -0,0 +1,206 @@
+// src/config/yaml.ts
+import { existsSync, readFileSync, statSync } from "fs";
+import { readFile, stat } from "fs/promises";
+import path2 from "path";
+import { parse as parseYaml } from "yaml";
+
+// src/config/path.ts
+import path from "path";
+import { homedir } from "os";
+function isPathRef(value) {
+  return typeof value === "string" && value.length > 0 && (value.endsWith(".yaml") || value.endsWith(".yml"));
+}
+function expandHomePath(inputPath, options = {}) {
+  const home = options.homeDir ?? homedir();
+  if (inputPath === "~") return home;
+  if (inputPath.startsWith("~/")) return path.join(home, inputPath.slice(2));
+  return inputPath;
+}
+function resolveConfigPath(pathRef, configDir, options = {}) {
+  const expanded = options.expandHome === false ? pathRef : expandHomePath(pathRef, { homeDir: options.homeDir });
+  return path.resolve(configDir, expanded);
+}
+function asObject(input) {
+  return typeof input === "object" && input !== null ? input : void 0;
+}
+function toPathRef(input) {
+  if (typeof input === "string" && input.trim().length > 0) return { ref: input.trim() };
+  const obj = asObject(input);
+  if (!obj) return void 0;
+  const value = (typeof obj.__filePath === "string" && obj.__filePath.trim().length > 0 ? obj.__filePath.trim() : void 0) ?? (typeof obj.ref === "string" && obj.ref.trim().length > 0 ? obj.ref.trim() : void 0);
+  return value ? { ref: value } : void 0;
+}
+
+// src/config/yaml.ts
+var YAML_CACHE = /* @__PURE__ */ new Map();
+function clearYamlFileCache() {
+  YAML_CACHE.clear();
+}
+function substituteEnvInString(input, env, missingEnv) {
+  return input.replace(/\$\{(\w+)\}/g, (_, name) => {
+    const value = env[name];
+    if (value !== void 0) return value;
+    return missingEnv === "empty" ? "" : `\${${name}}`;
+  });
+}
+function substituteEnvInValue(input, options) {
+  if (typeof input === "string") {
+    return substituteEnvInString(input, options.env, options.missingEnv);
+  }
+  if (Array.isArray(input)) {
+    return input.map((item) => substituteEnvInValue(item, options));
+  }
+  if (input && typeof input === "object") {
+    const out = {};
+    for (const [k, v] of Object.entries(input)) {
+      out[k] = substituteEnvInValue(v, options);
+    }
+    return out;
+  }
+  return input;
+}
+function parseYamlContent(content, options = {}) {
+  const parsed = parseYaml(content);
+  if (options.substituteEnv === false) return parsed;
+  return substituteEnvInValue(parsed, {
+    env: options.env ?? process.env,
+    missingEnv: options.missingEnv ?? "keep"
+  });
+}
+function readFromCache(filePath, mtimeMs) {
+  const cached = YAML_CACHE.get(filePath);
+  if (!cached) return void 0;
+  if (cached.mtimeMs !== mtimeMs) return void 0;
+  return cached.value;
+}
+function writeCache(filePath, mtimeMs, value) {
+  YAML_CACHE.set(filePath, { mtimeMs, value });
+}
+function loadYamlFileSync(filePath, options = {}) {
+  const absPath = path2.resolve(filePath);
+  if (!existsSync(absPath)) return void 0;
+  const useCache = options.cache === true;
+  const fileStat = statSync(absPath);
+  if (useCache) {
+    const cached = readFromCache(absPath, fileStat.mtimeMs);
+    if (cached !== void 0) return cached;
+  }
+  const content = readFileSync(absPath, "utf-8");
+  const parsed = parseYamlContent(content, options);
+  if (useCache) writeCache(absPath, fileStat.mtimeMs, parsed);
+  return parsed;
+}
+async function loadYamlFile(filePath, options = {}) {
+  const absPath = path2.resolve(filePath);
+  let fileStat;
+  try {
+    fileStat = await stat(absPath);
+  } catch (err) {
+    if (err?.code === "ENOENT") return void 0;
+    throw err;
+  }
+  const useCache = options.cache === true;
+  if (useCache) {
+    const cached = readFromCache(absPath, fileStat.mtimeMs);
+    if (cached !== void 0) return cached;
+  }
+  const content = await readFile(absPath, "utf-8");
+  const parsed = parseYamlContent(content, options);
+  if (useCache) writeCache(absPath, fileStat.mtimeMs, parsed);
+  return parsed;
+}
+
+// src/config/kind.ts
+import { dirname } from "path";
+function toResourceHeader(input) {
+  const obj = asObject(input);
+  if (!obj) throw new Error("Invalid config document: expected object root");
+  const apiVersion = typeof obj.apiVersion === "string" ? obj.apiVersion.trim() : "";
+  const kind = typeof obj.kind === "string" ? obj.kind.trim() : "";
+  const spec = obj.spec;
+  if (!apiVersion) throw new Error("Invalid config document: missing apiVersion");
+  if (!kind) throw new Error("Invalid config document: missing kind");
+  if (spec === void 0) throw new Error("Invalid config document: missing spec");
+  const metadataRaw = asObject(obj.metadata);
+  const metadata = metadataRaw ? {
+    name: typeof metadataRaw.name === "string" ? metadataRaw.name : void 0,
+    labels: metadataRaw.labels && typeof metadataRaw.labels === "object" && !Array.isArray(metadataRaw.labels) ? metadataRaw.labels : void 0
+  } : void 0;
+  return { apiVersion, kind, metadata, spec };
+}
+function isRefNode(input) {
+  const obj = asObject(input);
+  return !!obj && typeof obj.ref === "string" && obj.ref.trim().length > 0;
+}
+async function resolveKindResourceFile(entryFile, options = {}) {
+  const baseDir = options.baseDir ?? process.cwd();
+  const entryAbs = resolveConfigPath(entryFile, baseDir);
+  const maxDepth = options.maxDepth ?? 50;
+  const cache = /* @__PURE__ */ new Map();
+  const visiting = /* @__PURE__ */ new Set();
+  const resolveNode = async (node, currentDir, depth) => {
+    if (depth > maxDepth) throw new Error(`Config ref resolution exceeded maxDepth=${maxDepth}`);
+    if (isRefNode(node)) {
+      const next = resolveConfigPath(node.ref, currentDir);
+      return loadResource(next, depth + 1);
+    }
+    if (Array.isArray(node)) {
+      return Promise.all(node.map((item) => resolveNode(item, currentDir, depth + 1)));
+    }
+    const obj = asObject(node);
+    if (!obj) return node;
+    const out = {};
+    for (const [k, v] of Object.entries(obj)) {
+      out[k] = await resolveNode(v, currentDir, depth + 1);
+    }
+    return out;
+  };
+  const loadResource = async (absPath, depth) => {
+    if (depth > maxDepth) throw new Error(`Config ref resolution exceeded maxDepth=${maxDepth}`);
+    if (options.cache !== false) {
+      const cached = cache.get(absPath);
+      if (cached) return cached;
+    }
+    if (visiting.has(absPath)) {
+      throw new Error(`Config ref cycle detected at: ${absPath}`);
+    }
+    visiting.add(absPath);
+    try {
+      const raw = await loadYamlFile(absPath, options.yaml);
+      const header = toResourceHeader(raw);
+      if (options.expectedApiVersion && header.apiVersion !== options.expectedApiVersion) {
+        throw new Error(`Unexpected apiVersion "${header.apiVersion}" at ${absPath}`);
+      }
+      const resolvedSpec = await resolveNode(header.spec, dirname(absPath), depth + 1);
+      const resolved = {
+        ...header,
+        spec: resolvedSpec,
+        __filePath: absPath
+      };
+      if (options.cache !== false) cache.set(absPath, resolved);
+      return resolved;
+    } finally {
+      visiting.delete(absPath);
+    }
+  };
+  const root = await loadResource(entryAbs, 0);
+  if (options.expectedKind && root.kind !== options.expectedKind) {
+    throw new Error(`Expected kind "${options.expectedKind}" but got "${root.kind}" at ${root.__filePath}`);
+  }
+  return root;
+}
+
+export {
+  isPathRef,
+  expandHomePath,
+  resolveConfigPath,
+  asObject,
+  toPathRef,
+  clearYamlFileCache,
+  parseYamlContent,
+  loadYamlFileSync,
+  loadYamlFile,
+  isRefNode,
+  resolveKindResourceFile
+};
+//# sourceMappingURL=chunk-X4TDNR4V.js.map

package/dist/chunk-X4TDNR4V.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/config/yaml.ts","../src/config/path.ts","../src/config/kind.ts"],"sourcesContent":["import { existsSync, readFileSync, statSync } from \"node:fs\";\nimport { readFile, stat } from \"node:fs/promises\";\nimport path from \"node:path\";\nimport { parse as parseYaml } from \"yaml\";\nimport { resolveConfigPath } from \"./path.js\";\n\nexport interface YamlEnvOptions {\n  substituteEnv?: boolean;\n  missingEnv?: \"keep\" | \"empty\";\n  env?: NodeJS.ProcessEnv;\n}\n\nexport interface LoadYamlOptions extends YamlEnvOptions {\n  cache?: boolean;\n}\n\nexport interface LoadModuleConfigOptions<TConfig, TRaw = Record<string, unknown>> {\n  path?: string;\n  defaultPath?: string;\n  appRoot?: string;\n  yaml?: LoadYamlOptions;\n  unwrapSpec?: boolean;\n  fallback: TConfig;\n  normalize?: (raw: TRaw, meta: { resolvedPath: string }) => TConfig;\n}\n\ninterface CacheEntry {\n  mtimeMs: number;\n  value: unknown;\n}\n\nconst YAML_CACHE = new Map<string, CacheEntry>();\n\nexport function clearYamlFileCache(): void {\n  YAML_CACHE.clear();\n}\n\nfunction substituteEnvInString(\n  input: string,\n  env: NodeJS.ProcessEnv,\n  missingEnv: \"keep\" | \"empty\",\n): string {\n  return input.replace(/\\$\\{(\\w+)\\}/g, (_, name: string) => {\n    const value = env[name];\n    if (value !== undefined) return value;\n    return missingEnv === \"empty\" ? \"\" : `\\${${name}}`;\n  });\n}\n\nfunction substituteEnvInValue(\n  input: unknown,\n  options: { env: NodeJS.ProcessEnv; missingEnv: \"keep\" | \"empty\" },\n): unknown {\n  if (typeof input === \"string\") {\n    return substituteEnvInString(input, options.env, options.missingEnv);\n  }\n  if (Array.isArray(input)) {\n    return input.map((item) => substituteEnvInValue(item, options));\n  }\n  if (input && typeof input === \"object\") {\n    const out: Record<string, unknown> = {};\n    for (const [k, v] of Object.entries(input)) {\n      out[k] = substituteEnvInValue(v, options);\n    }\n    return out;\n  }\n  return input;\n}\n\nexport function parseYamlContent<T = unknown>(\n  content: string,\n  options: YamlEnvOptions = {},\n): T {\n  const parsed = parseYaml(content) as unknown;\n  if (options.substituteEnv === false) return parsed as T;\n  return substituteEnvInValue(parsed, {\n    env: options.env ?? process.env,\n    missingEnv: options.missingEnv ?? \"keep\",\n  }) as T;\n}\n\nfunction readFromCache(filePath: string, mtimeMs: number): unknown | undefined {\n  const cached = YAML_CACHE.get(filePath);\n  if (!cached) return undefined;\n  if (cached.mtimeMs !== mtimeMs) return undefined;\n  return cached.value;\n}\n\nfunction writeCache(filePath: string, mtimeMs: number, value: unknown): void {\n  YAML_CACHE.set(filePath, { mtimeMs, value });\n}\n\nexport function loadYamlFileSync<T = unknown>(\n  filePath: string,\n  options: LoadYamlOptions = {},\n): T | undefined {\n  const absPath = path.resolve(filePath);\n  if (!existsSync(absPath)) return undefined;\n  const useCache = options.cache === true;\n  const fileStat = statSync(absPath);\n  if (useCache) {\n    const cached = readFromCache(absPath, fileStat.mtimeMs);\n    if (cached !== undefined) return cached as T;\n  }\n  const content = readFileSync(absPath, \"utf-8\");\n  const parsed = parseYamlContent<T>(content, options);\n  if (useCache) writeCache(absPath, fileStat.mtimeMs, parsed);\n  return parsed;\n}\n\nexport async function loadYamlFile<T = unknown>(\n  filePath: string,\n  options: LoadYamlOptions = {},\n): Promise<T | undefined> {\n  const absPath = path.resolve(filePath);\n  let fileStat;\n  try {\n    fileStat = await stat(absPath);\n  } catch (err) {\n    if ((err as NodeJS.ErrnoException)?.code === \"ENOENT\") return undefined;\n    throw err;\n  }\n  const useCache = options.cache === true;\n  if (useCache) {\n    const cached = readFromCache(absPath, fileStat.mtimeMs);\n    if (cached !== undefined) return cached as T;\n  }\n  const content = await readFile(absPath, \"utf-8\");\n  const parsed = parseYamlContent<T>(content, options);\n  if (useCache) writeCache(absPath, fileStat.mtimeMs, parsed);\n  return parsed;\n}\n\nexport async function loadYamlObject(\n  filePath: string,\n  options: LoadYamlOptions = {},\n): Promise<Record<string, unknown>> {\n  const parsed = await loadYamlFile<unknown>(filePath, options);\n  if (parsed && typeof parsed === \"object\" && !Array.isArray(parsed)) {\n    return parsed as Record<string, unknown>;\n  }\n  return {};\n}\n\n/**\n * Generic module config loader:\n * 1) resolve path (path || defaultPath) relative to appRoot\n * 2) load YAML as object\n * 3) normalize into module-owned config interface\n * 4) fallback when missing/invalid\n */\nexport async function loadModuleConfig<TConfig, TRaw = Record<string, unknown>>(\n  options: LoadModuleConfigOptions<TConfig, TRaw>,\n): Promise<TConfig> {\n  const selected = options.path ?? options.defaultPath;\n  if (!selected) return options.fallback;\n\n  const appRoot = options.appRoot ?? process.cwd();\n  const resolvedPath = resolveConfigPath(selected, appRoot);\n  const loaded = await loadYamlFile<unknown>(resolvedPath, options.yaml);\n  if (!loaded || typeof loaded !== \"object\" || Array.isArray(loaded)) return options.fallback;\n  const raw = options.unwrapSpec === true\n    ? (\n      typeof (loaded as { spec?: unknown }).spec === \"object\" &&\n      (loaded as { spec?: unknown }).spec !== null &&\n      !Array.isArray((loaded as { spec?: unknown }).spec)\n        ? (loaded as { spec: unknown }).spec\n        : loaded\n    )\n    : loaded;\n\n  if (options.normalize) {\n    return options.normalize(raw as TRaw, { resolvedPath });\n  }\n  return raw as TConfig;\n}\n","import path from \"node:path\";\nimport { homedir } from \"node:os\";\n\nexport interface ResolveConfigPathOptions {\n  expandHome?: boolean;\n  homeDir?: string;\n}\n\nexport type PathRef = { ref?: string };\n\nexport function isPathRef(value: unknown): value is string {\n  return (\n    typeof value === \"string\" &&\n    value.length > 0 &&\n    (value.endsWith(\".yaml\") || value.endsWith(\".yml\"))\n  );\n}\n\nexport function expandHomePath(inputPath: string, options: { homeDir?: string } = {}): string {\n  const home = options.homeDir ?? homedir();\n  if (inputPath === \"~\") return home;\n  if (inputPath.startsWith(\"~/\")) return path.join(home, inputPath.slice(2));\n  return inputPath;\n}\n\nexport function resolveConfigPath(\n  pathRef: string,\n  configDir: string,\n  options: ResolveConfigPathOptions = {},\n): string {\n  const expanded = options.expandHome === false ? pathRef : expandHomePath(pathRef, { homeDir: options.homeDir });\n  return path.resolve(configDir, expanded);\n}\n\nexport function asObject(input: unknown): Record<string, unknown> | undefined {\n  return typeof input === \"object\" && input !== null ? (input as Record<string, unknown>) : undefined;\n}\n\nexport function toPathRef(input: unknown): PathRef | undefined {\n  if (typeof input === \"string\" && input.trim().length > 0) return { ref: input.trim() };\n  const obj = asObject(input);\n  if (!obj) return undefined;\n  const value =\n    (typeof (obj as { __filePath?: unknown }).__filePath === \"string\" &&\n    (obj as { __filePath: string }).__filePath.trim().length > 0\n      ? (obj as { __filePath: string }).__filePath.trim()\n      : undefined) ??\n    (typeof obj.ref === \"string\" && obj.ref.trim().length > 0 ? obj.ref.trim() : undefined);\n  return value ? { ref: value } : undefined;\n}\n","import { dirname } from \"node:path\";\nimport { loadYamlFile, type LoadYamlOptions } from \"./yaml.js\";\nimport { asObject, resolveConfigPath } from \"./path.js\";\n\nexport interface ResourceMetadata {\n  name?: string;\n  labels?: Record<string, string>;\n}\n\nexport interface ResourceHeader {\n  apiVersion: string;\n  kind: string;\n  metadata?: ResourceMetadata;\n  spec: unknown;\n}\n\nexport type RefNode = { ref: string };\n\nexport type ResolvedResource<TSpec = unknown> = ResourceHeader & {\n  spec: TSpec;\n  __filePath: string;\n};\n\nexport interface ResolveKindResourceOptions {\n  baseDir?: string;\n  maxDepth?: number;\n  cache?: boolean;\n  yaml?: LoadYamlOptions;\n  expectedKind?: string;\n  expectedApiVersion?: string;\n}\n\nfunction toResourceHeader(input: unknown): ResourceHeader {\n  const obj = asObject(input);\n  if (!obj) throw new Error(\"Invalid config document: expected object root\");\n\n  const apiVersion = typeof obj.apiVersion === \"string\" ? obj.apiVersion.trim() : \"\";\n  const kind = typeof obj.kind === \"string\" ? obj.kind.trim() : \"\";\n  const spec = (obj as { spec?: unknown }).spec;\n  if (!apiVersion) throw new Error(\"Invalid config document: missing apiVersion\");\n  if (!kind) throw new Error(\"Invalid config document: missing kind\");\n  if (spec === undefined) throw new Error(\"Invalid config document: missing spec\");\n  const metadataRaw = asObject(obj.metadata);\n  const metadata: ResourceMetadata | undefined = metadataRaw\n    ? {\n        name: typeof metadataRaw.name === \"string\" ? metadataRaw.name : undefined,\n        labels:\n          metadataRaw.labels && typeof metadataRaw.labels === \"object\" && !Array.isArray(metadataRaw.labels)\n            ? (metadataRaw.labels as Record<string, string>)\n            : undefined,\n      }\n    : undefined;\n  return { apiVersion, kind, metadata, spec };\n}\n\nexport function isRefNode(input: unknown): input is RefNode {\n  const obj = asObject(input);\n  return !!obj && typeof obj.ref === \"string\" && obj.ref.trim().length > 0;\n}\n\nexport async function resolveKindResourceFile<TSpec = unknown>(\n  entryFile: string,\n  options: ResolveKindResourceOptions = {},\n): Promise<ResolvedResource<TSpec>> {\n  const baseDir = options.baseDir ?? process.cwd();\n  const entryAbs = resolveConfigPath(entryFile, baseDir);\n  const maxDepth = options.maxDepth ?? 50;\n  const cache = new Map<string, ResolvedResource>();\n  const visiting = new Set<string>();\n\n  const resolveNode = async (node: unknown, currentDir: string, depth: number): Promise<unknown> => {\n    if (depth > maxDepth) throw new Error(`Config ref resolution exceeded maxDepth=${maxDepth}`);\n    if (isRefNode(node)) {\n      const next = resolveConfigPath(node.ref, currentDir);\n      return loadResource(next, depth + 1);\n    }\n    if (Array.isArray(node)) {\n      return Promise.all(node.map((item) => resolveNode(item, currentDir, depth + 1)));\n    }\n    const obj = asObject(node);\n    if (!obj) return node;\n    const out: Record<string, unknown> = {};\n    for (const [k, v] of Object.entries(obj)) {\n      out[k] = await resolveNode(v, currentDir, depth + 1);\n    }\n    return out;\n  };\n\n  const loadResource = async (absPath: string, depth: number): Promise<ResolvedResource> => {\n    if (depth > maxDepth) throw new Error(`Config ref resolution exceeded maxDepth=${maxDepth}`);\n    if (options.cache !== false) {\n      const cached = cache.get(absPath);\n      if (cached) return cached;\n    }\n    if (visiting.has(absPath)) {\n      throw new Error(`Config ref cycle detected at: ${absPath}`);\n    }\n    visiting.add(absPath);\n    try {\n      const raw = await loadYamlFile(absPath, options.yaml);\n      const header = toResourceHeader(raw);\n      if (options.expectedApiVersion && header.apiVersion !== options.expectedApiVersion) {\n        throw new Error(`Unexpected apiVersion \"${header.apiVersion}\" at ${absPath}`);\n      }\n      const resolvedSpec = await resolveNode(header.spec, dirname(absPath), depth + 1);\n      const resolved: ResolvedResource = {\n        ...header,\n        spec: resolvedSpec,\n        __filePath: absPath,\n      };\n      if (options.cache !== false) cache.set(absPath, resolved);\n      return resolved;\n    } finally {\n      visiting.delete(absPath);\n    }\n  };\n\n  const root = await loadResource(entryAbs, 0);\n  if (options.expectedKind && root.kind !== options.expectedKind) {\n    throw new Error(`Expected kind \"${options.expectedKind}\" but got \"${root.kind}\" at ${root.__filePath}`);\n  }\n  return root as ResolvedResource<TSpec>;\n}\n"],"mappings":"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","names":["path","path"]}

package/dist/cli/index.d.ts

@@ -0,0 +1 @@
+export { toErrorMessage, formatLogPath, StartupProgressRenderer, runStartupStep, } from "./startup.js";

package/dist/cli/index.js

@@ -0,0 +1,13 @@
+import {
+  StartupProgressRenderer,
+  formatLogPath,
+  runStartupStep,
+  toErrorMessage
+} from "../chunk-HBCZVEUG.js";
+export {
+  StartupProgressRenderer,
+  formatLogPath,
+  runStartupStep,
+  toErrorMessage
+};
+//# sourceMappingURL=index.js.map

package/dist/cli/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}

package/dist/cli/startup.d.ts

@@ -0,0 +1,14 @@
+export declare function toErrorMessage(error: unknown): string;
+export declare function formatLogPath(pathValue: string): string;
+export declare class StartupProgressRenderer {
+    private readonly isDynamic;
+    private readonly frames;
+    private readonly lineByStep;
+    private readonly timerByStep;
+    private readonly frameIndexByStep;
+    private lineCount;
+    start(stepId: string, title: string): void;
+    complete(stepId: string, title: string, ok: boolean, detail: string, elapsedMs: number): void;
+    private renderLine;
+}
+export declare function runStartupStep<T>(progress: StartupProgressRenderer, title: string, fn: () => Promise<T> | T, formatResult?: (result: T) => string): Promise<T>;

package/dist/config/hydrate.d.ts

@@ -0,0 +1,15 @@
+export interface HydrateScopedDefaultsOptions<TConfig, TScope extends {
+    ref?: string;
+}, TDefaults> {
+    appRoot: string;
+    getScope: (config: TConfig) => TScope | undefined;
+    setScope: (config: TConfig, scope: TScope) => TConfig;
+    resolveDefaults: (ref: string, appRoot: string) => Promise<TDefaults>;
+}
+/**
+ * Generic helper for config maps that keep a scoped ref as `{ ref }`.
+ * It loads defaults per unique ref once, then merges with item-local scope.
+ */
+export declare function hydrateNamedScopedDefaults<TConfig, TScope extends {
+    ref?: string;
+}, TDefaults extends Record<string, unknown>>(configs: Record<string, TConfig>, options: HydrateScopedDefaultsOptions<TConfig, TScope, TDefaults>): Promise<Record<string, TConfig>>;

package/dist/config/index.d.ts

@@ -0,0 +1,3 @@
+export { loadYamlFile, loadYamlFileSync, parseYamlContent, clearYamlFileCache, type LoadYamlOptions, } from "./yaml.js";
+export { expandHomePath, resolveConfigPath, asObject, isPathRef, toPathRef, type ResolveConfigPathOptions, type PathRef, } from "./path.js";
+export { resolveKindResourceFile, isRefNode, type ResourceMetadata, type ResourceHeader, type RefNode, type ResolvedResource, type ResolveKindResourceOptions, } from "./kind.js";

package/dist/config/index.js

@@ -0,0 +1,27 @@
+import {
+  asObject,
+  clearYamlFileCache,
+  expandHomePath,
+  isPathRef,
+  isRefNode,
+  loadYamlFile,
+  loadYamlFileSync,
+  parseYamlContent,
+  resolveConfigPath,
+  resolveKindResourceFile,
+  toPathRef
+} from "../chunk-X4TDNR4V.js";
+export {
+  asObject,
+  clearYamlFileCache,
+  expandHomePath,
+  isPathRef,
+  isRefNode,
+  loadYamlFile,
+  loadYamlFileSync,
+  parseYamlContent,
+  resolveConfigPath,
+  resolveKindResourceFile,
+  toPathRef
+};
+//# sourceMappingURL=index.js.map

package/dist/config/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}

package/dist/config/kind.d.ts

@@ -0,0 +1,28 @@
+import { type LoadYamlOptions } from "./yaml.js";
+export interface ResourceMetadata {
+    name?: string;
+    labels?: Record<string, string>;
+}
+export interface ResourceHeader {
+    apiVersion: string;
+    kind: string;
+    metadata?: ResourceMetadata;
+    spec: unknown;
+}
+export type RefNode = {
+    ref: string;
+};
+export type ResolvedResource<TSpec = unknown> = ResourceHeader & {
+    spec: TSpec;
+    __filePath: string;
+};
+export interface ResolveKindResourceOptions {
+    baseDir?: string;
+    maxDepth?: number;
+    cache?: boolean;
+    yaml?: LoadYamlOptions;
+    expectedKind?: string;
+    expectedApiVersion?: string;
+}
+export declare function isRefNode(input: unknown): input is RefNode;
+export declare function resolveKindResourceFile<TSpec = unknown>(entryFile: string, options?: ResolveKindResourceOptions): Promise<ResolvedResource<TSpec>>;

package/dist/config/path.d.ts

@@ -0,0 +1,14 @@
+export interface ResolveConfigPathOptions {
+    expandHome?: boolean;
+    homeDir?: string;
+}
+export type PathRef = {
+    ref?: string;
+};
+export declare function isPathRef(value: unknown): value is string;
+export declare function expandHomePath(inputPath: string, options?: {
+    homeDir?: string;
+}): string;
+export declare function resolveConfigPath(pathRef: string, configDir: string, options?: ResolveConfigPathOptions): string;
+export declare function asObject(input: unknown): Record<string, unknown> | undefined;
+export declare function toPathRef(input: unknown): PathRef | undefined;

package/dist/config/yaml.d.ts

@@ -0,0 +1,32 @@
+export interface YamlEnvOptions {
+    substituteEnv?: boolean;
+    missingEnv?: "keep" | "empty";
+    env?: NodeJS.ProcessEnv;
+}
+export interface LoadYamlOptions extends YamlEnvOptions {
+    cache?: boolean;
+}
+export interface LoadModuleConfigOptions<TConfig, TRaw = Record<string, unknown>> {
+    path?: string;
+    defaultPath?: string;
+    appRoot?: string;
+    yaml?: LoadYamlOptions;
+    unwrapSpec?: boolean;
+    fallback: TConfig;
+    normalize?: (raw: TRaw, meta: {
+        resolvedPath: string;
+    }) => TConfig;
+}
+export declare function clearYamlFileCache(): void;
+export declare function parseYamlContent<T = unknown>(content: string, options?: YamlEnvOptions): T;
+export declare function loadYamlFileSync<T = unknown>(filePath: string, options?: LoadYamlOptions): T | undefined;
+export declare function loadYamlFile<T = unknown>(filePath: string, options?: LoadYamlOptions): Promise<T | undefined>;
+export declare function loadYamlObject(filePath: string, options?: LoadYamlOptions): Promise<Record<string, unknown>>;
+/**
+ * Generic module config loader:
+ * 1) resolve path (path || defaultPath) relative to appRoot
+ * 2) load YAML as object
+ * 3) normalize into module-owned config interface
+ * 4) fallback when missing/invalid
+ */
+export declare function loadModuleConfig<TConfig, TRaw = Record<string, unknown>>(options: LoadModuleConfigOptions<TConfig, TRaw>): Promise<TConfig>;

package/dist/connectivity/check.d.ts

@@ -0,0 +1,19 @@
+import type { CheckConnectivityResult } from "./types.js";
+export interface EndpointConnectivityOptions {
+    timeoutMs?: number;
+    resolveHost?: {
+        from: string;
+        to: string;
+    };
+    host?: string;
+    verifySSL?: boolean;
+    bypassAuth?: boolean;
+    featureKey?: string;
+}
+export declare function checkEndpointConnectivity(baseURL: string, options?: {
+    timeoutMs?: number;
+} & EndpointConnectivityOptions): Promise<CheckConnectivityResult>;
+export interface BuildUnreachableErrorOptions {
+    suggestion?: string;
+}
+export declare function buildUnreachableError(endpointId: string, baseURL: string, detail?: string, options?: BuildUnreachableErrorOptions): string;

package/dist/connectivity/index.d.ts

@@ -0,0 +1,3 @@
+export { checkEndpointConnectivity, buildUnreachableError, } from "./check.js";
+export type { EndpointConnectivityOptions } from "./check.js";
+export type { ConnectionStatus, ConnectionPhase, CheckConnectivityResult, } from "./types.js";

package/dist/connectivity/index.js

@@ -0,0 +1,102 @@
+// src/connectivity/check.ts
+import https from "https";
+var DEFAULT_TIMEOUT_MS = 8e3;
+function probePath(baseURL) {
+  const base = baseURL.replace(/\/+$/, "");
+  if (base.endsWith("/v1")) return `${base}/models`;
+  return base.includes("/v1") ? `${base}/models` : `${base}/v1/models`;
+}
+function resolveProbeRequest(baseURL, endpointOptions) {
+  let path = probePath(baseURL);
+  const urlObj = new URL(path);
+  const resolveFrom = endpointOptions?.resolveHost?.from;
+  const resolveTo = endpointOptions?.resolveHost?.to;
+  let hostHeader = endpointOptions?.host;
+  if (resolveFrom && resolveTo && urlObj.hostname) {
+    urlObj.hostname = urlObj.hostname.replace(resolveFrom, resolveTo);
+    hostHeader = hostHeader ?? resolveFrom;
+  }
+  const searchParams = new URLSearchParams(urlObj.search);
+  if (endpointOptions?.bypassAuth === true) searchParams.set("bypass_auth", "true");
+  urlObj.search = searchParams.toString();
+  return { url: urlObj.toString(), hostHeader };
+}
+function checkWithHttps(url, hostHeader, options) {
+  return new Promise((resolve) => {
+    const u = new URL(url);
+    const reqOpts = {
+      hostname: u.hostname,
+      port: u.port || (u.protocol === "https:" ? 443 : 80),
+      path: u.pathname + u.search,
+      method: "GET",
+      headers: { Accept: "application/json" },
+      rejectUnauthorized: options.verifySSL
+    };
+    if (hostHeader) reqOpts.headers = { ...reqOpts.headers, Host: hostHeader };
+    const timeoutId = setTimeout(() => {
+      req.destroy();
+      resolve({ reachable: false, message: "Connection timed out" });
+    }, options.timeoutMs);
+    const req = https.request(reqOpts, (res) => {
+      clearTimeout(timeoutId);
+      resolve({
+        reachable: true,
+        message: res.statusCode === 200 ? "OK" : `HTTP ${res.statusCode}`,
+        statusCode: res.statusCode
+      });
+    });
+    req.on("error", (err) => {
+      clearTimeout(timeoutId);
+      resolve({ reachable: false, message: err.message || "Connection failed" });
+    });
+    req.end();
+  });
+}
+async function checkEndpointConnectivity(baseURL, options) {
+  const timeoutMs = options?.timeoutMs ?? DEFAULT_TIMEOUT_MS;
+  const useHttps = options?.resolveHost != null || options?.verifySSL === false || options?.host != null || options?.bypassAuth === true;
+  if (useHttps) {
+    const { url: url2, hostHeader } = resolveProbeRequest(baseURL, options);
+    return checkWithHttps(url2, hostHeader, {
+      timeoutMs,
+      verifySSL: options?.verifySSL === true
+    });
+  }
+  const url = probePath(baseURL);
+  const controller = new AbortController();
+  const timeoutId = setTimeout(() => controller.abort(), timeoutMs);
+  try {
+    const res = await fetch(url, {
+      method: "GET",
+      signal: controller.signal,
+      headers: { Accept: "application/json" }
+    });
+    clearTimeout(timeoutId);
+    return {
+      reachable: true,
+      message: res.ok ? "OK" : `HTTP ${res.status}`,
+      statusCode: res.status
+    };
+  } catch (err) {
+    clearTimeout(timeoutId);
+    const message = err instanceof Error ? err.message : String(err);
+    const isTimeout = err instanceof Error && err.name === "AbortError";
+    return {
+      reachable: false,
+      message: isTimeout ? "Connection timed out" : message || "Connection failed"
+    };
+  }
+}
+function buildUnreachableError(endpointId, baseURL, detail, options) {
+  const parts = [
+    `Cannot connect to endpoint (endpoint: ${endpointId}, base URL: ${baseURL}).`,
+    detail && ` ${detail}`,
+    options?.suggestion ? ` ${options.suggestion}` : ""
+  ];
+  return parts.filter(Boolean).join("").trim();
+}
+export {
+  buildUnreachableError,
+  checkEndpointConnectivity
+};
+//# sourceMappingURL=index.js.map

package/dist/connectivity/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/connectivity/check.ts"],"sourcesContent":["/**\n * Check connectivity to OpenAI-compatible endpoints.\n */\nimport https from \"node:https\";\nimport type { CheckConnectivityResult } from \"./types.js\";\n\nconst DEFAULT_TIMEOUT_MS = 8000;\n\nexport interface EndpointConnectivityOptions {\n  timeoutMs?: number;\n  resolveHost?: { from: string; to: string };\n  host?: string;\n  verifySSL?: boolean;\n  bypassAuth?: boolean;\n  featureKey?: string;\n}\n\nfunction probePath(baseURL: string): string {\n  const base = baseURL.replace(/\\/+$/, \"\");\n  if (base.endsWith(\"/v1\")) return `${base}/models`;\n  return base.includes(\"/v1\") ? `${base}/models` : `${base}/v1/models`;\n}\n\nfunction resolveProbeRequest(\n  baseURL: string,\n  endpointOptions?: EndpointConnectivityOptions | null\n): { url: string; hostHeader: string | undefined } {\n  let path = probePath(baseURL);\n  const urlObj = new URL(path);\n  const resolveFrom = endpointOptions?.resolveHost?.from;\n  const resolveTo = endpointOptions?.resolveHost?.to;\n  let hostHeader = endpointOptions?.host;\n  if (resolveFrom && resolveTo && urlObj.hostname) {\n    urlObj.hostname = urlObj.hostname.replace(resolveFrom, resolveTo);\n    hostHeader = hostHeader ?? resolveFrom;\n  }\n  const searchParams = new URLSearchParams(urlObj.search);\n  if (endpointOptions?.bypassAuth === true) searchParams.set(\"bypass_auth\", \"true\");\n  urlObj.search = searchParams.toString();\n  return { url: urlObj.toString(), hostHeader };\n}\n\nfunction checkWithHttps(\n  url: string,\n  hostHeader: string | undefined,\n  options: { timeoutMs: number; verifySSL: boolean }\n): Promise<CheckConnectivityResult> {\n  return new Promise((resolve) => {\n    const u = new URL(url);\n    const reqOpts: https.RequestOptions = {\n      hostname: u.hostname,\n      port: u.port || (u.protocol === \"https:\" ? 443 : 80),\n      path: u.pathname + u.search,\n      method: \"GET\",\n      headers: { Accept: \"application/json\" },\n      rejectUnauthorized: options.verifySSL,\n    };\n    if (hostHeader) reqOpts.headers = { ...reqOpts.headers, Host: hostHeader };\n\n    const timeoutId = setTimeout(() => {\n      req.destroy();\n      resolve({ reachable: false, message: \"Connection timed out\" });\n    }, options.timeoutMs);\n\n    const req = https.request(reqOpts, (res) => {\n      clearTimeout(timeoutId);\n      resolve({\n        reachable: true,\n        message: res.statusCode === 200 ? \"OK\" : `HTTP ${res.statusCode}`,\n        statusCode: res.statusCode,\n      });\n    });\n    req.on(\"error\", (err) => {\n      clearTimeout(timeoutId);\n      resolve({ reachable: false, message: err.message || \"Connection failed\" });\n    });\n    req.end();\n  });\n}\n\nexport async function checkEndpointConnectivity(\n  baseURL: string,\n  options?: { timeoutMs?: number } & EndpointConnectivityOptions\n): Promise<CheckConnectivityResult> {\n  const timeoutMs = options?.timeoutMs ?? DEFAULT_TIMEOUT_MS;\n  const useHttps =\n    options?.resolveHost != null ||\n    options?.verifySSL === false ||\n    options?.host != null ||\n    options?.bypassAuth === true;\n\n  if (useHttps) {\n    const { url, hostHeader } = resolveProbeRequest(baseURL, options);\n    return checkWithHttps(url, hostHeader, {\n      timeoutMs,\n      verifySSL: options?.verifySSL === true,\n    });\n  }\n\n  const url = probePath(baseURL);\n  const controller = new AbortController();\n  const timeoutId = setTimeout(() => controller.abort(), timeoutMs);\n\n  try {\n    const res = await fetch(url, {\n      method: \"GET\",\n      signal: controller.signal,\n      headers: { Accept: \"application/json\" },\n    });\n    clearTimeout(timeoutId);\n    return {\n      reachable: true,\n      message: res.ok ? \"OK\" : `HTTP ${res.status}`,\n      statusCode: res.status,\n    };\n  } catch (err) {\n    clearTimeout(timeoutId);\n    const message = err instanceof Error ? err.message : String(err);\n    const isTimeout = err instanceof Error && err.name === \"AbortError\";\n    return {\n      reachable: false,\n      message: isTimeout ? \"Connection timed out\" : message || \"Connection failed\",\n    };\n  }\n}\n\nexport interface BuildUnreachableErrorOptions {\n  suggestion?: string;\n}\n\nexport function buildUnreachableError(\n  endpointId: string,\n  baseURL: string,\n  detail?: string,\n  options?: BuildUnreachableErrorOptions\n): string {\n  const parts = [\n    `Cannot connect to endpoint (endpoint: ${endpointId}, base URL: ${baseURL}).`,\n    detail && ` ${detail}`,\n    options?.suggestion ? ` ${options.suggestion}` : \"\",\n  ];\n  return parts.filter(Boolean).join(\"\").trim();\n}\n"],"mappings":"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","names":["url"]}

package/dist/connectivity/types.d.ts

@@ -0,0 +1,12 @@
+export type ConnectionPhase = "checking" | "reachable" | "unreachable";
+export interface ConnectionStatus {
+    phase: ConnectionPhase;
+    endpointId?: string;
+    baseURL?: string;
+    message?: string;
+}
+export interface CheckConnectivityResult {
+    reachable: boolean;
+    message?: string;
+    statusCode?: number;
+}

package/dist/context/default-context.d.ts

@@ -0,0 +1,10 @@
+export interface AgentContext {
+    set<T>(token: symbol, value: T): void;
+    get<T>(token: symbol): T;
+    has(token: symbol): boolean;
+    tryGet<T>(token: symbol): T | undefined;
+}
+export declare function createAgentContext(): AgentContext;
+export declare function isAgentContext(value: unknown): value is AgentContext;
+export declare function getDefaultAgentContext(): AgentContext;
+export declare function resetDefaultAgentContext(): void;

package/dist/context/index.d.ts

@@ -0,0 +1,2 @@
+export { AgentContextTokens, type AgentContextTokenKey } from "./tokens.js";
+export { createAgentContext, getDefaultAgentContext, isAgentContext, type AgentContext, } from "./default-context.js";

package/dist/context/index.js

@@ -0,0 +1,16 @@
+import {
+  AgentContextTokens
+} from "../chunk-RQSSJFDP.js";
+import {
+  createAgentContext,
+  getDefaultAgentContext,
+  isAgentContext
+} from "../chunk-GQZFDM3S.js";
+import "../chunk-QG6CT2GZ.js";
+export {
+  AgentContextTokens,
+  createAgentContext,
+  getDefaultAgentContext,
+  isAgentContext
+};
+//# sourceMappingURL=index.js.map

package/dist/context/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}

package/dist/context/tokens.d.ts

@@ -0,0 +1,29 @@
+/**
+ * Well-known Symbol tokens for AgentContext.
+ * Use these to register and retrieve modules from an AgentContext.
+ *
+ * @example
+ * ```ts
+ * ctx.set(AgentContextTokens.ChatModel, llm);
+ * const llm = ctx.get<BaseChatModel>(AgentContextTokens.ChatModel);
+ * ```
+ */
+export declare const AgentContextTokens: {
+    /** The shared AgentEventBus instance */
+    readonly EventBus: symbol;
+    /** The primary chat model (BaseChatModel) */
+    readonly ChatModel: symbol;
+    /** The embedding model (Embeddings) */
+    readonly EmbedModel: symbol;
+    /** The vision-language chat model (BaseChatModel) */
+    readonly VlmModel: symbol;
+    /** The memory client (AgentMemory) */
+    readonly Memory: symbol;
+    /** The initialized tool list */
+    readonly Tools: symbol;
+    /** The loaded skill set (SkillSet | undefined) */
+    readonly SkillSet: symbol;
+    /** The initialized agent runtime instance (react/deep) */
+    readonly Runtime: symbol;
+};
+export type AgentContextTokenKey = (typeof AgentContextTokens)[keyof typeof AgentContextTokens];

package/dist/events/index.d.ts

@@ -0,0 +1,17 @@
+export interface AgentEvent<TPayload = unknown> {
+    id: string;
+    name: string;
+    from: string;
+    to: string;
+    at: string;
+    payload?: TPayload;
+}
+export interface AgentEventBus {
+    publish<TPayload = unknown>(event: Omit<AgentEvent<TPayload>, "id" | "at">): AgentEvent<TPayload>;
+    subscribe(listener: AgentEventListener): () => void;
+}
+export type AgentEventListener = (event: AgentEvent) => void;
+export declare function createAgentEventBus(): AgentEventBus;
+export declare function createConsoleAgentEventListener(writer?: (line: string) => void): AgentEventListener;
+export { createProgressAgentEventListener, type ProgressEventListenerOptions, } from "./progress-listener.js";
+export { createRuntime2TreeEventListener, resolveRuntime2DebugConfig, type Runtime2EventDebugConfig, type Runtime2EventRuntimeConfig, type Runtime2TreeEventListenerOptions, } from "./runtime2-tree-listener.js";