@whatalo/cli-kit 1.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Whatalo Inc.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,43 @@
+# @whatalo/cli-kit
+
+Shared runtime utilities for the Whatalo CLI ecosystem.
+
+This package powers `@whatalo/cli` and related developer tools with reusable modules for:
+
+- session storage and device authentication flows
+- authenticated HTTP requests
+- CLI output formatting and error handling
+- project configuration loading and validation
+- local tunnel management
+- version checks and upgrade messaging
+
+## Intended usage
+
+`@whatalo/cli-kit` is a support package for Whatalo developer tooling. Most developers should install and use `@whatalo/cli` instead of consuming this package directly.
+
+## Installation
+
+```bash
+pnpm add @whatalo/cli-kit
+```
+
+## Module entry points
+
+```ts
+import { getSession } from "@whatalo/cli-kit/session";
+import { WhataloApiClient } from "@whatalo/cli-kit/http";
+import { success, withErrorHandler } from "@whatalo/cli-kit/output";
+import { readConfig } from "@whatalo/cli-kit/config";
+```
+
+## Requirements
+
+- Node.js 18 or newer
+
+## Documentation
+
+Developer documentation is available at `developers.whatalo.com`.
+
+## License
+
+MIT

package/dist/config/index.cjs

@@ -0,0 +1,250 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+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 __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/config/index.ts
+var config_exports = {};
+__export(config_exports, {
+  CONFIG_FILE_NAME: () => CONFIG_FILE_NAME,
+  REQUIRED_FIELDS: () => REQUIRED_FIELDS,
+  loadManifest: () => loadManifest,
+  parseEnvFile: () => parseEnvFile,
+  pluginConfigSchema: () => pluginConfigSchema,
+  readConfig: () => readConfig,
+  updateEnvFile: () => updateEnvFile,
+  validateConfig: () => validateConfig,
+  writeConfig: () => writeConfig
+});
+module.exports = __toCommonJS(config_exports);
+
+// src/config/toml.ts
+var import_promises = require("fs/promises");
+var import_node_path = __toESM(require("path"), 1);
+var import_toml = __toESM(require("@iarna/toml"), 1);
+
+// src/config/types.ts
+var REQUIRED_FIELDS = [
+  "plugin.name",
+  "plugin.plugin_id",
+  "plugin.slug",
+  "build.dev_command",
+  "build.build_command",
+  "build.output_dir",
+  "dev.port"
+];
+var CONFIG_FILE_NAME = "whatalo.app.toml";
+
+// src/config/toml.ts
+async function readConfig(dir) {
+  const filePath = import_node_path.default.join(dir, CONFIG_FILE_NAME);
+  let raw;
+  try {
+    raw = await (0, import_promises.readFile)(filePath, "utf-8");
+  } catch {
+    throw new Error(
+      `Could not find ${CONFIG_FILE_NAME} in "${dir}". Run \`whatalo init\` to set up your project.`
+    );
+  }
+  let parsed;
+  try {
+    parsed = import_toml.default.parse(raw);
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    throw new Error(
+      `Failed to parse ${CONFIG_FILE_NAME}: ${message}. Check for syntax errors.`
+    );
+  }
+  validateRequiredFields(parsed);
+  return parsed;
+}
+async function writeConfig(dir, config) {
+  const filePath = import_node_path.default.join(dir, CONFIG_FILE_NAME);
+  const content = import_toml.default.stringify(config);
+  await (0, import_promises.writeFile)(filePath, content, "utf-8");
+}
+function validateRequiredFields(obj) {
+  for (const fieldPath of REQUIRED_FIELDS) {
+    const parts = fieldPath.split(".");
+    let current = obj;
+    for (const part of parts) {
+      if (current === null || current === void 0 || typeof current !== "object") {
+        throw new Error(
+          `Missing \`${fieldPath}\` in ${CONFIG_FILE_NAME}. Run \`whatalo init\` to set up your project.`
+        );
+      }
+      current = current[part];
+    }
+    if (current === null || current === void 0 || current === "") {
+      throw new Error(
+        `Missing \`${fieldPath}\` in ${CONFIG_FILE_NAME}. Run \`whatalo init\` to set up your project.`
+      );
+    }
+  }
+}
+
+// src/config/schema.ts
+var import_zod = require("zod");
+var pluginConfigSchema = import_zod.z.object({
+  plugin: import_zod.z.object({
+    name: import_zod.z.string().min(1, "Plugin name cannot be empty").max(100, "Plugin name must be 100 characters or fewer"),
+    plugin_id: import_zod.z.string().min(1, "plugin_id cannot be empty").regex(
+      /^[a-zA-Z0-9_-]+$/,
+      "Invalid plugin_id format. Must contain only alphanumeric characters, hyphens, or underscores."
+    ),
+    slug: import_zod.z.string().regex(
+      /^[a-z0-9][a-z0-9-]*[a-z0-9]$/,
+      "Slug must be lowercase alphanumeric with hyphens, cannot start or end with a hyphen."
+    )
+  }),
+  build: import_zod.z.object({
+    dev_command: import_zod.z.string().min(1, "dev_command cannot be empty"),
+    build_command: import_zod.z.string().min(1, "build_command cannot be empty"),
+    output_dir: import_zod.z.string().min(1, "output_dir cannot be empty")
+  }).optional(),
+  webhooks: import_zod.z.object({
+    url: import_zod.z.string().url("Webhook URL must be a valid URL").refine((u) => u.startsWith("https://"), {
+      message: "Webhook URL must use HTTPS"
+    }).optional(),
+    events: import_zod.z.array(import_zod.z.string()).optional()
+  }).optional(),
+  dev: import_zod.z.object({
+    port: import_zod.z.number().int("Port must be an integer").min(1024, "Port must be >= 1024").max(65535, "Port must be <= 65535").default(5173),
+    store: import_zod.z.string().optional()
+  }).optional()
+});
+function validateConfig(raw) {
+  const result = pluginConfigSchema.safeParse(raw);
+  if (result.success) {
+    return { success: true, data: result.data };
+  }
+  const errors = result.error.issues.map((issue) => ({
+    path: issue.path.join("."),
+    message: issue.message
+  }));
+  return { success: false, errors };
+}
+
+// src/config/env-file.ts
+var import_promises2 = require("fs/promises");
+function parseEnvFile(content) {
+  const lines = content.split("\n");
+  return lines.map((raw) => {
+    const trimmed = raw.trim();
+    if (trimmed === "" || trimmed.startsWith("#")) {
+      return { raw };
+    }
+    const eqIndex = trimmed.indexOf("=");
+    if (eqIndex === -1) {
+      return { raw };
+    }
+    const key = trimmed.slice(0, eqIndex).trim();
+    let value = trimmed.slice(eqIndex + 1).trim();
+    if (value.startsWith('"') && value.endsWith('"') || value.startsWith("'") && value.endsWith("'")) {
+      value = value.slice(1, -1);
+    }
+    return { raw, key, value };
+  });
+}
+async function updateEnvFile(filePath, vars) {
+  let existingContent = "";
+  try {
+    existingContent = await (0, import_promises2.readFile)(filePath, "utf-8");
+  } catch {
+  }
+  const entries = existingContent ? parseEnvFile(existingContent) : [];
+  const updatedKeys = /* @__PURE__ */ new Set();
+  const updatedLines = entries.map((entry) => {
+    if (entry.key && entry.key in vars) {
+      updatedKeys.add(entry.key);
+      return `${entry.key}=${vars[entry.key]}`;
+    }
+    return entry.raw;
+  });
+  const newVars = Object.entries(vars).filter(
+    ([key]) => !updatedKeys.has(key)
+  );
+  if (newVars.length > 0) {
+    if (updatedLines.length > 0 && updatedLines[updatedLines.length - 1] !== "") {
+      updatedLines.push("");
+    }
+    updatedLines.push("# Whatalo Plugin Variables");
+    for (const [key, value] of newVars) {
+      updatedLines.push(`${key}=${value}`);
+    }
+  }
+  const output = updatedLines.join("\n");
+  await (0, import_promises2.writeFile)(filePath, output.endsWith("\n") ? output : output + "\n", "utf-8");
+}
+
+// src/config/manifest-loader.ts
+var import_esbuild = require("esbuild");
+var import_promises3 = require("fs/promises");
+var import_node_os = require("os");
+var import_node_url = require("url");
+var import_node_path2 = __toESM(require("path"), 1);
+var MANIFEST_FILE_NAME = "whatalo.app.ts";
+async function loadManifest(dir) {
+  const entryPoint = import_node_path2.default.join(dir, MANIFEST_FILE_NAME);
+  let tmpDir = null;
+  try {
+    tmpDir = await (0, import_promises3.mkdtemp)(import_node_path2.default.join((0, import_node_os.tmpdir)(), "whatalo-manifest-"));
+    const outfile = import_node_path2.default.join(tmpDir, "manifest.mjs");
+    await (0, import_esbuild.build)({
+      entryPoints: [entryPoint],
+      bundle: true,
+      format: "esm",
+      outfile,
+      platform: "node",
+      // Silence esbuild output — errors are caught below
+      logLevel: "silent"
+    });
+    const mod = await import((0, import_node_url.pathToFileURL)(outfile).href);
+    return mod.default ?? null;
+  } catch {
+    return null;
+  } finally {
+    if (tmpDir) {
+      try {
+        await (0, import_promises3.rm)(tmpDir, { recursive: true, force: true });
+      } catch {
+      }
+    }
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  CONFIG_FILE_NAME,
+  REQUIRED_FIELDS,
+  loadManifest,
+  parseEnvFile,
+  pluginConfigSchema,
+  readConfig,
+  updateEnvFile,
+  validateConfig,
+  writeConfig
+});

package/dist/config/index.d.cts

@@ -0,0 +1,75 @@
+export { C as CONFIG_FILE_NAME, E as EnvEntry, R as REQUIRED_FIELDS, W as WhataloAppConfig, p as parseEnvFile, r as readConfig, u as updateEnvFile, w as writeConfig } from '../env-file-KvUHlLtI.cjs';
+import { z } from 'zod';
+
+/**
+ * Zod v4 schema for `whatalo.app.toml` validation.
+ * Provides typed, detailed error messages instead of manual field checks.
+ */
+
+declare const pluginConfigSchema: z.ZodObject<{
+    plugin: z.ZodObject<{
+        name: z.ZodString;
+        plugin_id: z.ZodString;
+        slug: z.ZodString;
+    }, z.core.$strip>;
+    build: z.ZodOptional<z.ZodObject<{
+        dev_command: z.ZodString;
+        build_command: z.ZodString;
+        output_dir: z.ZodString;
+    }, z.core.$strip>>;
+    webhooks: z.ZodOptional<z.ZodObject<{
+        url: z.ZodOptional<z.ZodString>;
+        events: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    }, z.core.$strip>>;
+    dev: z.ZodOptional<z.ZodObject<{
+        port: z.ZodDefault<z.ZodNumber>;
+        store: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+type PluginConfigSchema = z.infer<typeof pluginConfigSchema>;
+/**
+ * Validates a parsed TOML object against the plugin config schema.
+ * Returns a structured result with field-level errors.
+ */
+declare function validateConfig(raw: unknown): {
+    success: boolean;
+    data?: PluginConfigSchema;
+    errors?: Array<{
+        path: string;
+        message: string;
+    }>;
+};
+
+/** Subset of the AppManifest relevant for CLI operations */
+interface ManifestData {
+    id?: string;
+    name?: string;
+    description?: string;
+    version?: string;
+    appUrl?: string;
+    webhookUrl?: string;
+    permissions?: string[];
+    adminUI?: {
+        pages?: Array<{
+            path: string;
+            title: string;
+            icon: string;
+            position: string;
+            navigationLabel?: string;
+        }>;
+    };
+    [key: string]: unknown;
+}
+/**
+ * Loads and evaluates the `whatalo.app.ts` manifest file from a plugin project.
+ *
+ * Uses esbuild to bundle the TypeScript file (including any imports like
+ * `@whatalo/app-sdk/manifest`) into a standalone ESM module, then dynamically
+ * imports it to extract the default export.
+ *
+ * Returns null if the file does not exist or fails to load — callers should
+ * treat this as a non-fatal condition and fall back gracefully.
+ */
+declare function loadManifest(dir: string): Promise<ManifestData | null>;
+
+export { type ManifestData, type PluginConfigSchema, loadManifest, pluginConfigSchema, validateConfig };

package/dist/config/index.d.ts

@@ -0,0 +1,75 @@
+export { C as CONFIG_FILE_NAME, E as EnvEntry, R as REQUIRED_FIELDS, W as WhataloAppConfig, p as parseEnvFile, r as readConfig, u as updateEnvFile, w as writeConfig } from '../env-file-KvUHlLtI.js';
+import { z } from 'zod';
+
+/**
+ * Zod v4 schema for `whatalo.app.toml` validation.
+ * Provides typed, detailed error messages instead of manual field checks.
+ */
+
+declare const pluginConfigSchema: z.ZodObject<{
+    plugin: z.ZodObject<{
+        name: z.ZodString;
+        plugin_id: z.ZodString;
+        slug: z.ZodString;
+    }, z.core.$strip>;
+    build: z.ZodOptional<z.ZodObject<{
+        dev_command: z.ZodString;
+        build_command: z.ZodString;
+        output_dir: z.ZodString;
+    }, z.core.$strip>>;
+    webhooks: z.ZodOptional<z.ZodObject<{
+        url: z.ZodOptional<z.ZodString>;
+        events: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    }, z.core.$strip>>;
+    dev: z.ZodOptional<z.ZodObject<{
+        port: z.ZodDefault<z.ZodNumber>;
+        store: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+type PluginConfigSchema = z.infer<typeof pluginConfigSchema>;
+/**
+ * Validates a parsed TOML object against the plugin config schema.
+ * Returns a structured result with field-level errors.
+ */
+declare function validateConfig(raw: unknown): {
+    success: boolean;
+    data?: PluginConfigSchema;
+    errors?: Array<{
+        path: string;
+        message: string;
+    }>;
+};
+
+/** Subset of the AppManifest relevant for CLI operations */
+interface ManifestData {
+    id?: string;
+    name?: string;
+    description?: string;
+    version?: string;
+    appUrl?: string;
+    webhookUrl?: string;
+    permissions?: string[];
+    adminUI?: {
+        pages?: Array<{
+            path: string;
+            title: string;
+            icon: string;
+            position: string;
+            navigationLabel?: string;
+        }>;
+    };
+    [key: string]: unknown;
+}
+/**
+ * Loads and evaluates the `whatalo.app.ts` manifest file from a plugin project.
+ *
+ * Uses esbuild to bundle the TypeScript file (including any imports like
+ * `@whatalo/app-sdk/manifest`) into a standalone ESM module, then dynamically
+ * imports it to extract the default export.
+ *
+ * Returns null if the file does not exist or fails to load — callers should
+ * treat this as a non-fatal condition and fall back gracefully.
+ */
+declare function loadManifest(dir: string): Promise<ManifestData | null>;
+
+export { type ManifestData, type PluginConfigSchema, loadManifest, pluginConfigSchema, validateConfig };

package/dist/config/index.mjs

@@ -0,0 +1,205 @@
+// src/config/toml.ts
+import { readFile, writeFile } from "fs/promises";
+import path from "path";
+import TOML from "@iarna/toml";
+
+// src/config/types.ts
+var REQUIRED_FIELDS = [
+  "plugin.name",
+  "plugin.plugin_id",
+  "plugin.slug",
+  "build.dev_command",
+  "build.build_command",
+  "build.output_dir",
+  "dev.port"
+];
+var CONFIG_FILE_NAME = "whatalo.app.toml";
+
+// src/config/toml.ts
+async function readConfig(dir) {
+  const filePath = path.join(dir, CONFIG_FILE_NAME);
+  let raw;
+  try {
+    raw = await readFile(filePath, "utf-8");
+  } catch {
+    throw new Error(
+      `Could not find ${CONFIG_FILE_NAME} in "${dir}". Run \`whatalo init\` to set up your project.`
+    );
+  }
+  let parsed;
+  try {
+    parsed = TOML.parse(raw);
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    throw new Error(
+      `Failed to parse ${CONFIG_FILE_NAME}: ${message}. Check for syntax errors.`
+    );
+  }
+  validateRequiredFields(parsed);
+  return parsed;
+}
+async function writeConfig(dir, config) {
+  const filePath = path.join(dir, CONFIG_FILE_NAME);
+  const content = TOML.stringify(config);
+  await writeFile(filePath, content, "utf-8");
+}
+function validateRequiredFields(obj) {
+  for (const fieldPath of REQUIRED_FIELDS) {
+    const parts = fieldPath.split(".");
+    let current = obj;
+    for (const part of parts) {
+      if (current === null || current === void 0 || typeof current !== "object") {
+        throw new Error(
+          `Missing \`${fieldPath}\` in ${CONFIG_FILE_NAME}. Run \`whatalo init\` to set up your project.`
+        );
+      }
+      current = current[part];
+    }
+    if (current === null || current === void 0 || current === "") {
+      throw new Error(
+        `Missing \`${fieldPath}\` in ${CONFIG_FILE_NAME}. Run \`whatalo init\` to set up your project.`
+      );
+    }
+  }
+}
+
+// src/config/schema.ts
+import { z } from "zod";
+var pluginConfigSchema = z.object({
+  plugin: z.object({
+    name: z.string().min(1, "Plugin name cannot be empty").max(100, "Plugin name must be 100 characters or fewer"),
+    plugin_id: z.string().min(1, "plugin_id cannot be empty").regex(
+      /^[a-zA-Z0-9_-]+$/,
+      "Invalid plugin_id format. Must contain only alphanumeric characters, hyphens, or underscores."
+    ),
+    slug: z.string().regex(
+      /^[a-z0-9][a-z0-9-]*[a-z0-9]$/,
+      "Slug must be lowercase alphanumeric with hyphens, cannot start or end with a hyphen."
+    )
+  }),
+  build: z.object({
+    dev_command: z.string().min(1, "dev_command cannot be empty"),
+    build_command: z.string().min(1, "build_command cannot be empty"),
+    output_dir: z.string().min(1, "output_dir cannot be empty")
+  }).optional(),
+  webhooks: z.object({
+    url: z.string().url("Webhook URL must be a valid URL").refine((u) => u.startsWith("https://"), {
+      message: "Webhook URL must use HTTPS"
+    }).optional(),
+    events: z.array(z.string()).optional()
+  }).optional(),
+  dev: z.object({
+    port: z.number().int("Port must be an integer").min(1024, "Port must be >= 1024").max(65535, "Port must be <= 65535").default(5173),
+    store: z.string().optional()
+  }).optional()
+});
+function validateConfig(raw) {
+  const result = pluginConfigSchema.safeParse(raw);
+  if (result.success) {
+    return { success: true, data: result.data };
+  }
+  const errors = result.error.issues.map((issue) => ({
+    path: issue.path.join("."),
+    message: issue.message
+  }));
+  return { success: false, errors };
+}
+
+// src/config/env-file.ts
+import { readFile as readFile2, writeFile as writeFile2 } from "fs/promises";
+function parseEnvFile(content) {
+  const lines = content.split("\n");
+  return lines.map((raw) => {
+    const trimmed = raw.trim();
+    if (trimmed === "" || trimmed.startsWith("#")) {
+      return { raw };
+    }
+    const eqIndex = trimmed.indexOf("=");
+    if (eqIndex === -1) {
+      return { raw };
+    }
+    const key = trimmed.slice(0, eqIndex).trim();
+    let value = trimmed.slice(eqIndex + 1).trim();
+    if (value.startsWith('"') && value.endsWith('"') || value.startsWith("'") && value.endsWith("'")) {
+      value = value.slice(1, -1);
+    }
+    return { raw, key, value };
+  });
+}
+async function updateEnvFile(filePath, vars) {
+  let existingContent = "";
+  try {
+    existingContent = await readFile2(filePath, "utf-8");
+  } catch {
+  }
+  const entries = existingContent ? parseEnvFile(existingContent) : [];
+  const updatedKeys = /* @__PURE__ */ new Set();
+  const updatedLines = entries.map((entry) => {
+    if (entry.key && entry.key in vars) {
+      updatedKeys.add(entry.key);
+      return `${entry.key}=${vars[entry.key]}`;
+    }
+    return entry.raw;
+  });
+  const newVars = Object.entries(vars).filter(
+    ([key]) => !updatedKeys.has(key)
+  );
+  if (newVars.length > 0) {
+    if (updatedLines.length > 0 && updatedLines[updatedLines.length - 1] !== "") {
+      updatedLines.push("");
+    }
+    updatedLines.push("# Whatalo Plugin Variables");
+    for (const [key, value] of newVars) {
+      updatedLines.push(`${key}=${value}`);
+    }
+  }
+  const output = updatedLines.join("\n");
+  await writeFile2(filePath, output.endsWith("\n") ? output : output + "\n", "utf-8");
+}
+
+// src/config/manifest-loader.ts
+import { build } from "esbuild";
+import { mkdtemp, rm } from "fs/promises";
+import { tmpdir } from "os";
+import { pathToFileURL } from "url";
+import path2 from "path";
+var MANIFEST_FILE_NAME = "whatalo.app.ts";
+async function loadManifest(dir) {
+  const entryPoint = path2.join(dir, MANIFEST_FILE_NAME);
+  let tmpDir = null;
+  try {
+    tmpDir = await mkdtemp(path2.join(tmpdir(), "whatalo-manifest-"));
+    const outfile = path2.join(tmpDir, "manifest.mjs");
+    await build({
+      entryPoints: [entryPoint],
+      bundle: true,
+      format: "esm",
+      outfile,
+      platform: "node",
+      // Silence esbuild output — errors are caught below
+      logLevel: "silent"
+    });
+    const mod = await import(pathToFileURL(outfile).href);
+    return mod.default ?? null;
+  } catch {
+    return null;
+  } finally {
+    if (tmpDir) {
+      try {
+        await rm(tmpDir, { recursive: true, force: true });
+      } catch {
+      }
+    }
+  }
+}
+export {
+  CONFIG_FILE_NAME,
+  REQUIRED_FIELDS,
+  loadManifest,
+  parseEnvFile,
+  pluginConfigSchema,
+  readConfig,
+  updateEnvFile,
+  validateConfig,
+  writeConfig
+};