@larkup/cli 0.2.4 → 0.2.6

package/dist/chunk-VY6I42DP.js

@@ -0,0 +1,424 @@
+import {
+  getToolById,
+  invalidateRegistryCache
+} from "./chunk-P5JVXA7X.js";
+import {
+  __require
+} from "./chunk-3RG5ZIWI.js";
+
+// ../../packages/marketplace/src/tool-loader.ts
+import { promises as fs2 } from "fs";
+import path2 from "path";
+import { pathToFileURL } from "url";
+
+// ../../packages/marketplace/src/tool-installer.ts
+import { promises as fs } from "fs";
+import path from "path";
+import { exec as execCb } from "child_process";
+import { promisify } from "util";
+var execAsync = promisify(execCb);
+function getToolsDir() {
+  return path.join(process.cwd(), ".larkup", "tools");
+}
+function getManifestPath() {
+  return path.join(getToolsDir(), "installed.json");
+}
+async function ensureDir() {
+  await fs.mkdir(getToolsDir(), { recursive: true });
+}
+async function readManifest() {
+  try {
+    const raw = await fs.readFile(getManifestPath(), "utf8");
+    const parsed = JSON.parse(raw);
+    if (!parsed.downloadCounts) parsed.downloadCounts = {};
+    for (const tool of parsed.tools ?? []) {
+      if (tool.packagePath && !tool.packageName) {
+        tool.packageName = tool.packagePath;
+        delete tool.packagePath;
+      }
+      if (!tool.source) tool.source = "local";
+      if (!tool.resolvedPath) {
+        tool.resolvedPath = tool.packageName;
+      }
+    }
+    return parsed;
+  } catch {
+    return { tools: [], downloadCounts: {}, updatedAt: (/* @__PURE__ */ new Date()).toISOString() };
+  }
+}
+async function writeManifest(manifest) {
+  await ensureDir();
+  manifest.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
+  await fs.writeFile(getManifestPath(), JSON.stringify(manifest, null, 2), "utf8");
+}
+async function getInstalledTools() {
+  const manifest = await readManifest();
+  const tools = [...manifest.tools];
+  const bundledIds = (process.env.LARKUP_BUNDLED_TOOLS ?? "").split(",").map((id) => id.trim()).filter(Boolean);
+  for (const toolId of bundledIds) {
+    if (tools.some((tool) => tool.id === toolId)) continue;
+    const descriptor = await getToolById(toolId);
+    if (!descriptor) continue;
+    tools.push({
+      id: toolId,
+      version: descriptor.version,
+      installedAt: "bundled",
+      packageName: descriptor.packageName,
+      resolvedPath: descriptor.packageName,
+      source: "local",
+      config: buildDefaultConfig(descriptor)
+    });
+  }
+  return tools;
+}
+async function isToolInstalled(toolId) {
+  const tools = await getInstalledTools();
+  return tools.some((t) => t.id === toolId);
+}
+async function getInstalledTool(toolId) {
+  const tools = await getInstalledTools();
+  return tools.find((t) => t.id === toolId);
+}
+async function checkSystemDeps(toolId) {
+  const descriptor = await getToolById(toolId);
+  if (!descriptor?.systemDeps?.length) return [];
+  const target = detectDeploymentTarget();
+  const missing = [];
+  for (const dep of descriptor.systemDeps) {
+    if (target === "docker" && dep === "docker") continue;
+    try {
+      await execAsync(`which ${dep}`);
+    } catch {
+      missing.push(dep);
+    }
+  }
+  return missing;
+}
+function detectDeploymentTarget() {
+  const explicit = process.env.LARKUP_DEPLOYMENT_TARGET;
+  if (explicit && ["local", "docker", "serverless", "sandbox"].includes(explicit)) {
+    return explicit;
+  }
+  if (process.env.VERCEL || process.env.AWS_LAMBDA_FUNCTION_NAME) return "serverless";
+  if (process.env.DOCKER_CONTAINER || isDockerEnvironment()) return "docker";
+  if (process.env.E2B_SANDBOX_ID || process.env.MODAL_TASK_ID) return "sandbox";
+  return "local";
+}
+function isDockerEnvironment() {
+  try {
+    const fs3 = __require("fs");
+    return fs3.existsSync("/.dockerenv");
+  } catch {
+    return false;
+  }
+}
+async function ensureToolsPackageJson() {
+  const toolsDir = getToolsDir();
+  const pkgPath = path.join(toolsDir, "package.json");
+  try {
+    await fs.access(pkgPath);
+  } catch {
+    await ensureDir();
+    await fs.writeFile(
+      pkgPath,
+      JSON.stringify(
+        {
+          name: "larkup-tools",
+          version: "1.0.0",
+          private: true,
+          description: "Isolated directory for installed Larkup marketplace tools."
+        },
+        null,
+        2
+      ),
+      "utf8"
+    );
+  }
+}
+async function execInstall(packageName, version, target, onProgress) {
+  const toolsDir = getToolsDir();
+  switch (target) {
+    case "local":
+    case "docker": {
+      await ensureToolsPackageJson();
+      const install = async (specifier) => {
+        const installCmd = `npm install ${specifier} --prefix "${toolsDir}" --save --no-audit --no-fund`;
+        onProgress?.(`Running: npm install ${specifier}`);
+        const { stderr } = await execAsync(installCmd, {
+          cwd: toolsDir,
+          // Native tool dependencies can take longer under Docker Desktop's
+          // amd64 emulation. Let the request finish instead of reporting a
+          // misleading connection error part way through installation.
+          timeout: target === "docker" ? 3e5 : 12e4,
+          env: {
+            ...process.env,
+            NODE_ENV: "production",
+            // The Docker image runs as an unprivileged user. Keep npm's cache
+            // beside the isolated install so a named .larkup volume is always
+            // writable and installing a Marketplace tool does not fail before
+            // it reaches the registry.
+            HOME: process.env.HOME && process.env.HOME !== "/nonexistent" ? process.env.HOME : toolsDir,
+            npm_config_cache: path.join(toolsDir, ".npm-cache"),
+            npm_config_update_notifier: "false"
+          }
+        });
+        if (stderr && !stderr.includes("npm warn")) {
+          console.warn(`[marketplace] Install stderr: ${stderr}`);
+        }
+      };
+      try {
+        await install(`${packageName}@${version}`);
+      } catch (err) {
+        const message = err instanceof Error ? err.message : "Install command failed";
+        if (!message.includes("ETARGET") && !message.includes("No matching version found")) {
+          throw new Error(`Failed to install ${packageName}: ${message}`);
+        }
+        onProgress?.(
+          `Catalog version ${version} is unavailable; installing the latest published version\u2026`
+        );
+        try {
+          await install(`${packageName}@latest`);
+        } catch (latestErr) {
+          const latestMessage = latestErr instanceof Error ? latestErr.message : "Install command failed";
+          throw new Error(`Failed to install ${packageName}: ${latestMessage}`);
+        }
+      }
+      const resolvedPath = path.join(toolsDir, "node_modules", packageName);
+      try {
+        await fs.access(resolvedPath);
+      } catch {
+        throw new Error(
+          `Package ${packageName} was installed but could not be found at ${resolvedPath}`
+        );
+      }
+      const packageJson = JSON.parse(
+        await fs.readFile(path.join(resolvedPath, "package.json"), "utf8")
+      );
+      return { resolvedPath, version: packageJson.version ?? version };
+    }
+    case "serverless": {
+      onProgress?.("Serverless environment detected \u2014 queuing for next deploy");
+      const pendingPath = path.join(toolsDir, "pending-tools.json");
+      let pending = { tools: [] };
+      try {
+        const raw = await fs.readFile(pendingPath, "utf8");
+        pending = JSON.parse(raw);
+      } catch {
+      }
+      pending.tools.push({ packageName, version });
+      await ensureDir();
+      await fs.writeFile(pendingPath, JSON.stringify(pending, null, 2), "utf8");
+      return { resolvedPath: path.join(toolsDir, "node_modules", packageName), version };
+    }
+    case "sandbox": {
+      onProgress?.("Installing in sandbox environment");
+      await ensureToolsPackageJson();
+      const installCmd = `npm install ${packageName}@${version} --prefix "${toolsDir}" --save --no-audit --no-fund`;
+      await execAsync(installCmd, { cwd: toolsDir, timeout: 12e4 });
+      return { resolvedPath: path.join(toolsDir, "node_modules", packageName), version };
+    }
+    default:
+      throw new Error(`Unsupported deployment target: ${target}`);
+  }
+}
+async function resolveManifest(toolId) {
+  const descriptor = await getToolById(toolId);
+  if (descriptor) return descriptor;
+  throw new Error(`Unknown tool: ${toolId}. Not found in local registry or Hub.`);
+}
+async function isWorkspaceTool(packageName) {
+  try {
+    const { stdout } = await execAsync(`pnpm ls -r --depth -1 --json 2>/dev/null || true`, {
+      cwd: process.cwd(),
+      timeout: 1e4
+    });
+    const data = JSON.parse(stdout || "[]");
+    return Array.isArray(data) && data.some((pkg) => pkg.name === packageName);
+  } catch {
+    return false;
+  }
+}
+async function installTool(toolId, onProgress) {
+  const report = (stage, percent, message) => {
+    onProgress?.({ toolId, stage, percent, message });
+  };
+  try {
+    report("checking-deps", 5, "Resolving tool manifest\u2026");
+    const descriptor = await resolveManifest(toolId);
+    if (descriptor.comingSoon) {
+      throw new Error(`${descriptor.name} is coming soon.`);
+    }
+    report("checking-deps", 15, "Checking system dependencies\u2026");
+    const missing = await checkSystemDeps(toolId);
+    if (missing.length > 0) {
+      const msg = `Missing system dependencies: ${missing.join(", ")}. Please install them first.`;
+      report("failed", 0, msg);
+      throw new Error(msg);
+    }
+    const isWorkspace = await isWorkspaceTool(descriptor.packageName);
+    const target = detectDeploymentTarget();
+    let resolvedPath;
+    let installedVersion = descriptor.version;
+    let source;
+    if (isWorkspace) {
+      report("downloading", 30, "Resolving workspace package\u2026");
+      try {
+        const modulePath = __require.resolve(descriptor.packageName, {
+          paths: [process.cwd()]
+        });
+        resolvedPath = path.dirname(modulePath);
+      } catch {
+        resolvedPath = path.join(process.cwd(), "node_modules", descriptor.packageName);
+      }
+      source = "local";
+      report("installing", 60, "Workspace package resolved.");
+    } else {
+      report("downloading", 30, `Downloading ${descriptor.packageName}@${descriptor.version}\u2026`);
+      const installed = await execInstall(
+        descriptor.packageName,
+        descriptor.version,
+        target,
+        (msg) => report("downloading", 50, msg)
+      );
+      resolvedPath = installed.resolvedPath;
+      installedVersion = installed.version;
+      source = target === "sandbox" ? "sandbox" : "registry";
+      report("installing", 70, "Package installed.");
+    }
+    report("installing", 80, "Registering tool\u2026");
+    await ensureDir();
+    const manifest = await readManifest();
+    const existing = manifest.tools.findIndex((t) => t.id === toolId);
+    const entry = {
+      id: toolId,
+      version: installedVersion,
+      installedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      packageName: descriptor.packageName,
+      resolvedPath,
+      source,
+      config: buildDefaultConfig(descriptor)
+    };
+    if (existing >= 0) {
+      manifest.tools[existing] = entry;
+    } else {
+      manifest.tools.push(entry);
+    }
+    manifest.downloadCounts[toolId] = (manifest.downloadCounts[toolId] ?? 0) + 1;
+    await writeManifest(manifest);
+    notifyHubInstall(toolId).catch(() => {
+    });
+    invalidateRegistryCache();
+    report("completed", 100, "Installed successfully.");
+  } catch (err) {
+    const message = err instanceof Error ? err.message : "Installation failed.";
+    report("failed", 0, message);
+    throw err;
+  }
+}
+async function uninstallTool(toolId) {
+  const manifest = await readManifest();
+  const tool = manifest.tools.find((t) => t.id === toolId);
+  manifest.tools = manifest.tools.filter((t) => t.id !== toolId);
+  await writeManifest(manifest);
+  if (tool?.source === "registry" && tool.packageName) {
+    try {
+      const toolsDir = getToolsDir();
+      await execAsync(`npm uninstall ${tool.packageName} --prefix "${toolsDir}"`, {
+        cwd: toolsDir,
+        timeout: 3e4
+      });
+    } catch {
+    }
+  }
+  invalidateRegistryCache();
+  const { unloadTool: unloadTool2 } = await import("./tool-loader-QU6HBUCA.js");
+  unloadTool2(toolId);
+}
+async function notifyHubInstall(toolId) {
+  const hubUrl = process.env.LARKUP_HUB_URL ?? "https://hub.larkup.de";
+  try {
+    const controller = new AbortController();
+    const timeout = setTimeout(() => controller.abort(), 3e3);
+    await fetch(`${hubUrl}/v1/tools/${toolId}/installed`, {
+      method: "POST",
+      signal: controller.signal,
+      headers: { "Content-Type": "application/json" }
+    });
+    clearTimeout(timeout);
+  } catch {
+  }
+}
+function buildDefaultConfig(descriptor) {
+  const config = {};
+  for (const field of descriptor.configSchema ?? []) {
+    if (field.defaultValue !== void 0) {
+      config[field.key] = field.defaultValue;
+    }
+  }
+  return config;
+}
+
+// ../../packages/marketplace/src/tool-loader.ts
+var moduleCache = /* @__PURE__ */ new Map();
+async function loadTool(toolId) {
+  if (moduleCache.has(toolId)) return moduleCache.get(toolId);
+  const installed = await getInstalledTool(toolId);
+  if (!installed) return null;
+  try {
+    const importPath = await resolveImportPath(installed);
+    const mod = await import(
+      /* webpackIgnore: true */
+      importPath
+    );
+    moduleCache.set(toolId, mod);
+    return mod;
+  } catch (err) {
+    console.error(`[marketplace] Failed to load tool "${toolId}":`, err);
+    return null;
+  }
+}
+async function resolveImportPath(installed) {
+  switch (installed.source) {
+    case "local":
+      return installed.packageName;
+    case "registry":
+    case "sandbox":
+      return resolvePackageEntry(installed.resolvedPath);
+    default:
+      return installed.packageName;
+  }
+}
+async function resolvePackageEntry(packageDir) {
+  const manifestPath = path2.join(packageDir, "package.json");
+  const manifest = JSON.parse(await fs2.readFile(manifestPath, "utf8"));
+  const rootExport = typeof manifest.exports === "object" ? manifest.exports["."] : manifest.exports;
+  const entry = (typeof rootExport === "object" ? rootExport.import ?? rootExport.default : rootExport) ?? manifest.main ?? "index.js";
+  return pathToFileURL(path2.resolve(packageDir, entry)).href;
+}
+function isToolLoaded(toolId) {
+  return moduleCache.has(toolId);
+}
+function unloadTool(toolId) {
+  moduleCache.delete(toolId);
+}
+async function hasCapability(capability) {
+  const { getToolsWithCapability } = await import("./tool-registry-W3JOGDE3.js");
+  const tools = await getToolsWithCapability(capability);
+  for (const t of tools) {
+    const installed = await getInstalledTool(t.id);
+    if (installed) return true;
+  }
+  return false;
+}
+
+export {
+  loadTool,
+  isToolLoaded,
+  unloadTool,
+  hasCapability,
+  getInstalledTools,
+  isToolInstalled,
+  getInstalledTool,
+  installTool,
+  uninstallTool
+};

package/dist/index.js

@@ -12,10 +12,17 @@ import {
   setActiveServer,
   trackUsageEvent
 } from "./chunk-ZJLA4SIG.js";
+import {
+  getInstalledTool,
+  getInstalledTools,
+  installTool,
+  isToolInstalled,
+  loadTool,
+  uninstallTool
+} from "./chunk-VY6I42DP.js";
 import {
   getAllTools,
-  getToolById,
-  invalidateRegistryCache
+  getToolById
 } from "./chunk-P5JVXA7X.js";
 import {
   __require
@@ -27,7 +34,7 @@ import { Command } from "commander";
 // package.json
 var package_default = {
   name: "@larkup/cli",
-  version: "0.2.4",
+  version: "0.2.6",
   publishConfig: {
     access: "public"
   },
@@ -944,12 +951,12 @@ function addChatProviderDependency(dependencies, provider) {
 }
 
 // ../../packages/core/src/generator/generate-server.ts
-function lang(path15) {
-  if (path15.endsWith(".json")) return "json";
-  if (path15.endsWith(".mjs") || path15.endsWith(".js")) return "javascript";
-  if (path15.endsWith(".md")) return "markdown";
-  if (path15.endsWith("Dockerfile")) return "dockerfile";
-  if (path15.endsWith(".yml") || path15.endsWith(".yaml")) return "yaml";
+function lang(path14) {
+  if (path14.endsWith(".json")) return "json";
+  if (path14.endsWith(".mjs") || path14.endsWith(".js")) return "javascript";
+  if (path14.endsWith(".md")) return "markdown";
+  if (path14.endsWith("Dockerfile")) return "dockerfile";
+  if (path14.endsWith(".yml") || path14.endsWith(".yaml")) return "yaml";
   return "text";
 }
 function lancedbStore() {
@@ -2266,22 +2273,22 @@ function generateServer(config) {
     { path: "README.md", contents: readme(config, server) }
   ].map((f) => ({ ...f, language: lang(f.path) }));
   try {
-    const fs14 = __require("fs");
-    const path15 = __require("path");
-    const faviconPath = path15.resolve(process.cwd(), "public/favicon2.ico");
-    if (fs14.existsSync(faviconPath)) {
+    const fs13 = __require("fs");
+    const path14 = __require("path");
+    const faviconPath = path14.resolve(process.cwd(), "public/favicon2.ico");
+    if (fs13.existsSync(faviconPath)) {
       files.push({
         path: "public/favicon2.ico",
-        contents: fs14.readFileSync(faviconPath).toString("base64"),
+        contents: fs13.readFileSync(faviconPath).toString("base64"),
         language: "ico",
         encoding: "base64"
       });
     } else {
-      const webFaviconPath = path15.resolve(process.cwd(), "apps/web/public/favicon2.ico");
-      if (fs14.existsSync(webFaviconPath)) {
+      const webFaviconPath = path14.resolve(process.cwd(), "apps/web/public/favicon2.ico");
+      if (fs13.existsSync(webFaviconPath)) {
         files.push({
           path: "public/favicon2.ico",
-          contents: fs14.readFileSync(webFaviconPath).toString("base64"),
+          contents: fs13.readFileSync(webFaviconPath).toString("base64"),
           language: "ico",
           encoding: "base64"
         });
@@ -2295,12 +2302,12 @@ function generateServer(config) {
 }
 
 // ../../packages/core/src/generator/generate-agent-server.ts
-function lang2(path15) {
-  if (path15.endsWith(".json")) return "json";
-  if (path15.endsWith(".mjs") || path15.endsWith(".js")) return "javascript";
-  if (path15.endsWith(".md")) return "markdown";
-  if (path15.endsWith("Dockerfile")) return "dockerfile";
-  if (path15.endsWith(".yml") || path15.endsWith(".yaml")) return "yaml";
+function lang2(path14) {
+  if (path14.endsWith(".json")) return "json";
+  if (path14.endsWith(".mjs") || path14.endsWith(".js")) return "javascript";
+  if (path14.endsWith(".md")) return "markdown";
+  if (path14.endsWith("Dockerfile")) return "dockerfile";
+  if (path14.endsWith(".yml") || path14.endsWith(".yaml")) return "yaml";
   return "text";
 }
 function lancedbStore2() {
@@ -3314,22 +3321,22 @@ function generateAgentServer(config) {
     { path: "README.md", contents: readme2(config, server) }
   ].map((f) => ({ ...f, language: lang2(f.path) }));
   try {
-    const fs14 = __require("fs");
-    const path15 = __require("path");
-    const faviconPath = path15.resolve(process.cwd(), "public/favicon2.ico");
-    if (fs14.existsSync(faviconPath)) {
+    const fs13 = __require("fs");
+    const path14 = __require("path");
+    const faviconPath = path14.resolve(process.cwd(), "public/favicon2.ico");
+    if (fs13.existsSync(faviconPath)) {
       files.push({
         path: "public/favicon2.ico",
-        contents: fs14.readFileSync(faviconPath).toString("base64"),
+        contents: fs13.readFileSync(faviconPath).toString("base64"),
         language: "ico",
         encoding: "base64"
       });
     } else {
-      const webFaviconPath = path15.resolve(process.cwd(), "apps/web/public/favicon2.ico");
-      if (fs14.existsSync(webFaviconPath)) {
+      const webFaviconPath = path14.resolve(process.cwd(), "apps/web/public/favicon2.ico");
+      if (fs13.existsSync(webFaviconPath)) {
         files.push({
           path: "public/favicon2.ico",
-          contents: fs14.readFileSync(webFaviconPath).toString("base64"),
+          contents: fs13.readFileSync(webFaviconPath).toString("base64"),
           language: "ico",
           encoding: "base64"
         });
@@ -3406,6 +3413,18 @@ async function writeState(state) {
   if (file) await fs2.writeFile(file, JSON.stringify(state, null, 2), "utf8");
   return state;
 }
+async function withActiveVectorTable(config) {
+  const server = await getActiveServer();
+  if (!server || config.vectorStore && config.vectorStore !== "lancedb") return config;
+  const safeId = server.id.replace(/[^a-zA-Z0-9_-]/g, "_");
+  return {
+    ...config,
+    storeConfig: {
+      ...config.storeConfig,
+      tableName: `documents_${safeId}`
+    }
+  };
+}
 function pidAlive(pid) {
   if (!pid) return false;
   try {
@@ -3416,7 +3435,7 @@ function pidAlive(pid) {
   }
 }
 async function emitToDisk(config) {
-  const server = generateServer(config);
+  const server = generateServer(await withActiveVectorTable(config));
   const dir = await outDir(true);
   if (!dir) throw new Error("No active server to emit to.");
   await fs2.mkdir(dir, { recursive: true });
@@ -3452,7 +3471,8 @@ async function startServer(config, serverApiKey) {
     }
   }
   await killPort(port);
-  const dir = await emitToDisk(config);
+  const runtimeConfig = await withActiveVectorTable(config);
+  const dir = await emitToDisk(runtimeConfig);
   try {
     await execAsync("npm install --omit=dev", {
       cwd: dir,
@@ -3467,7 +3487,7 @@ async function startServer(config, serverApiKey) {
     const message = err instanceof Error ? err.message : "npm install failed";
     return writeState({ ...emptyState(port), lastError: message });
   }
-  const dbPath = config.storeConfig.dbPath || "./.larkup/lancedb";
+  const dbPath = runtimeConfig.storeConfig.dbPath || "./.larkup/lancedb";
   const absDb = path2.isAbsolute(dbPath) ? dbPath : path2.join(process.cwd(), dbPath);
   const logPath = path2.join(dir, "server.log");
   await fs2.writeFile(logPath, "", "utf8");
@@ -3480,35 +3500,35 @@ async function startServer(config, serverApiKey) {
     env: {
       ...process.env,
       PORT: String(port),
-      TOP_K: String(config.topK),
+      TOP_K: String(runtimeConfig.topK),
       SERVER_API_KEY: serverApiKey || "",
-      EMBEDDING_API_KEY: config.embeddingApiKey || process.env.EMBEDDING_API_KEY || process.env.OPENAI_API_KEY || "",
-      CHAT_API_KEY: config.chatApiKey || config.customChatModels?.find(
-        (model) => model.modelName === config.chatModelId?.replace(/^custom:/, "")
+      EMBEDDING_API_KEY: runtimeConfig.embeddingApiKey || process.env.EMBEDDING_API_KEY || process.env.OPENAI_API_KEY || "",
+      CHAT_API_KEY: runtimeConfig.chatApiKey || runtimeConfig.customChatModels?.find(
+        (model) => model.modelName === runtimeConfig.chatModelId?.replace(/^custom:/, "")
       )?.apiKey || process.env.CHAT_API_KEY || process.env.OPENAI_API_KEY || "",
-      CHAT_MODEL: process.env.CHAT_MODEL || resolveChatModel(config),
-      CHAT_BASE_URL: config.customChatModels?.find(
-        (model) => model.modelName === config.chatModelId?.replace(/^custom:/, "")
+      CHAT_MODEL: process.env.CHAT_MODEL || resolveChatModel(runtimeConfig),
+      CHAT_BASE_URL: runtimeConfig.customChatModels?.find(
+        (model) => model.modelName === runtimeConfig.chatModelId?.replace(/^custom:/, "")
       )?.baseUrl || process.env.CHAT_BASE_URL || "",
-      OPENAI_API_KEY: config.embeddingApiKey || config.chatApiKey || process.env.OPENAI_API_KEY || "",
-      ANTHROPIC_API_KEY: config.chatApiKey || config.embeddingApiKey || process.env.ANTHROPIC_API_KEY || "",
-      COHERE_API_KEY: config.embeddingApiKey || config.chatApiKey || process.env.COHERE_API_KEY || "",
-      GOOGLE_GENERATIVE_AI_API_KEY: config.embeddingApiKey || config.chatApiKey || process.env.GOOGLE_GENERATIVE_AI_API_KEY || "",
-      PINECONE_API_KEY: config.storeConfig.apiKey || "",
-      PINECONE_INDEX: config.storeConfig.indexName || "",
-      PINECONE_NAMESPACE: config.storeConfig.namespace || "",
-      PINECONE_SPARSE_MODEL: config.storeConfig.sparseModel || "",
-      PINECONE_SPARSE_INDEX: config.storeConfig.sparseIndexName || "",
-      LANCEDB_MODE: config.storeConfig.mode || "local",
+      OPENAI_API_KEY: runtimeConfig.embeddingApiKey || runtimeConfig.chatApiKey || process.env.OPENAI_API_KEY || "",
+      ANTHROPIC_API_KEY: runtimeConfig.chatApiKey || runtimeConfig.embeddingApiKey || process.env.ANTHROPIC_API_KEY || "",
+      COHERE_API_KEY: runtimeConfig.embeddingApiKey || runtimeConfig.chatApiKey || process.env.COHERE_API_KEY || "",
+      GOOGLE_GENERATIVE_AI_API_KEY: runtimeConfig.embeddingApiKey || runtimeConfig.chatApiKey || process.env.GOOGLE_GENERATIVE_AI_API_KEY || "",
+      PINECONE_API_KEY: runtimeConfig.storeConfig.apiKey || "",
+      PINECONE_INDEX: runtimeConfig.storeConfig.indexName || "",
+      PINECONE_NAMESPACE: runtimeConfig.storeConfig.namespace || "",
+      PINECONE_SPARSE_MODEL: runtimeConfig.storeConfig.sparseModel || "",
+      PINECONE_SPARSE_INDEX: runtimeConfig.storeConfig.sparseIndexName || "",
+      LANCEDB_MODE: runtimeConfig.storeConfig.mode || "local",
       LANCEDB_PATH: absDb,
-      LANCEDB_URI: config.storeConfig.uri || "",
-      LANCEDB_API_KEY: config.storeConfig.apiKey || "",
-      LANCEDB_S3_URI: config.storeConfig.s3Uri || "",
-      AWS_ENDPOINT: config.storeConfig.s3Endpoint || "",
-      AWS_REGION: config.storeConfig.s3Region || "",
-      AWS_ACCESS_KEY_ID: config.storeConfig.s3AccessKeyId || "",
-      AWS_SECRET_ACCESS_KEY: config.storeConfig.s3SecretAccessKey || "",
-      LANCEDB_TABLE: config.storeConfig.tableName || "documents"
+      LANCEDB_URI: runtimeConfig.storeConfig.uri || "",
+      LANCEDB_API_KEY: runtimeConfig.storeConfig.apiKey || "",
+      LANCEDB_S3_URI: runtimeConfig.storeConfig.s3Uri || "",
+      AWS_ENDPOINT: runtimeConfig.storeConfig.s3Endpoint || "",
+      AWS_REGION: runtimeConfig.storeConfig.s3Region || "",
+      AWS_ACCESS_KEY_ID: runtimeConfig.storeConfig.s3AccessKeyId || "",
+      AWS_SECRET_ACCESS_KEY: runtimeConfig.storeConfig.s3SecretAccessKey || "",
+      LANCEDB_TABLE: runtimeConfig.storeConfig.tableName || "documents"
     }
   });
   child.unref();
@@ -4633,8 +4653,8 @@ async function readTextFiles(files) {
 }
 
 // src/commands/media.ts
-import { promises as fs10 } from "fs";
-import path11 from "path";
+import { promises as fs9 } from "fs";
+import path10 from "path";
 
 // ../../packages/core/src/media-store.ts
 import { promises as fs7 } from "fs";
@@ -4776,406 +4796,44 @@ function claimMediaAsset(id) {
   });
 }
 
-// ../../packages/marketplace/src/tool-installer.ts
+// ../../packages/marketplace/src/storage-provider.ts
 import { promises as fs8 } from "fs";
 import path9 from "path";
-import { exec as execCb } from "child_process";
-import { promisify as promisify2 } from "util";
-var execAsync2 = promisify2(execCb);
-function getToolsDir() {
-  return path9.join(process.cwd(), ".larkup", "tools");
-}
-function getManifestPath() {
-  return path9.join(getToolsDir(), "installed.json");
-}
-async function ensureDir() {
-  await fs8.mkdir(getToolsDir(), { recursive: true });
-}
-async function readManifest() {
-  try {
-    const raw = await fs8.readFile(getManifestPath(), "utf8");
-    const parsed = JSON.parse(raw);
-    if (!parsed.downloadCounts) parsed.downloadCounts = {};
-    for (const tool2 of parsed.tools ?? []) {
-      if (tool2.packagePath && !tool2.packageName) {
-        tool2.packageName = tool2.packagePath;
-        delete tool2.packagePath;
-      }
-      if (!tool2.source) tool2.source = "local";
-      if (!tool2.resolvedPath) {
-        tool2.resolvedPath = tool2.packageName;
-      }
-    }
-    return parsed;
-  } catch {
-    return { tools: [], downloadCounts: {}, updatedAt: (/* @__PURE__ */ new Date()).toISOString() };
-  }
-}
-async function writeManifest(manifest) {
-  await ensureDir();
-  manifest.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
-  await fs8.writeFile(getManifestPath(), JSON.stringify(manifest, null, 2), "utf8");
-}
-async function getInstalledTools() {
-  const manifest = await readManifest();
-  const tools = [...manifest.tools];
-  const bundledIds = (process.env.LARKUP_BUNDLED_TOOLS ?? "").split(",").map((id) => id.trim()).filter(Boolean);
-  for (const toolId of bundledIds) {
-    if (tools.some((tool2) => tool2.id === toolId)) continue;
-    const descriptor = await getToolById(toolId);
-    if (!descriptor) continue;
-    tools.push({
-      id: toolId,
-      version: descriptor.version,
-      installedAt: "bundled",
-      packageName: descriptor.packageName,
-      resolvedPath: descriptor.packageName,
-      source: "local",
-      config: buildDefaultConfig(descriptor)
-    });
-  }
-  return tools;
-}
-async function isToolInstalled(toolId) {
-  const tools = await getInstalledTools();
-  return tools.some((t) => t.id === toolId);
-}
-async function getInstalledTool(toolId) {
-  const tools = await getInstalledTools();
-  return tools.find((t) => t.id === toolId);
-}
-async function checkSystemDeps(toolId) {
-  const descriptor = await getToolById(toolId);
-  if (!descriptor?.systemDeps?.length) return [];
-  const missing = [];
-  for (const dep of descriptor.systemDeps) {
-    try {
-      await execAsync2(`which ${dep}`);
-    } catch {
-      missing.push(dep);
-    }
-  }
-  return missing;
-}
-function detectDeploymentTarget() {
-  const explicit = process.env.LARKUP_DEPLOYMENT_TARGET;
-  if (explicit && ["local", "docker", "serverless", "sandbox"].includes(explicit)) {
-    return explicit;
-  }
-  if (process.env.VERCEL || process.env.AWS_LAMBDA_FUNCTION_NAME) return "serverless";
-  if (process.env.DOCKER_CONTAINER || isDockerEnvironment()) return "docker";
-  if (process.env.E2B_SANDBOX_ID || process.env.MODAL_TASK_ID) return "sandbox";
-  return "local";
-}
-function isDockerEnvironment() {
-  try {
-    const fs14 = __require("fs");
-    return fs14.existsSync("/.dockerenv");
-  } catch {
-    return false;
-  }
-}
-async function ensureToolsPackageJson() {
-  const toolsDir = getToolsDir();
-  const pkgPath = path9.join(toolsDir, "package.json");
-  try {
-    await fs8.access(pkgPath);
-  } catch {
-    await ensureDir();
-    await fs8.writeFile(
-      pkgPath,
-      JSON.stringify(
-        {
-          name: "larkup-tools",
-          version: "1.0.0",
-          private: true,
-          description: "Isolated directory for installed Larkup marketplace tools."
-        },
-        null,
-        2
-      ),
-      "utf8"
-    );
-  }
-}
-async function execInstall(packageName, version, target, onProgress) {
-  const toolsDir = getToolsDir();
-  switch (target) {
-    case "local":
-    case "docker": {
-      await ensureToolsPackageJson();
-      const install = async (specifier) => {
-        const installCmd = `npm install ${specifier} --prefix "${toolsDir}" --save --no-audit --no-fund`;
-        onProgress?.(`Running: npm install ${specifier}`);
-        const { stderr } = await execAsync2(installCmd, {
-          cwd: toolsDir,
-          timeout: 12e4,
-          // 2 minute timeout
-          env: { ...process.env, NODE_ENV: "production" }
-        });
-        if (stderr && !stderr.includes("npm warn")) {
-          console.warn(`[marketplace] Install stderr: ${stderr}`);
-        }
-      };
-      try {
-        await install(`${packageName}@${version}`);
-      } catch (err) {
-        const message = err instanceof Error ? err.message : "Install command failed";
-        if (!message.includes("ETARGET") && !message.includes("No matching version found")) {
-          throw new Error(`Failed to install ${packageName}: ${message}`);
-        }
-        onProgress?.(
-          `Catalog version ${version} is unavailable; installing the latest published version\u2026`
-        );
-        try {
-          await install(`${packageName}@latest`);
-        } catch (latestErr) {
-          const latestMessage = latestErr instanceof Error ? latestErr.message : "Install command failed";
-          throw new Error(`Failed to install ${packageName}: ${latestMessage}`);
-        }
-      }
-      const resolvedPath = path9.join(toolsDir, "node_modules", packageName);
-      try {
-        await fs8.access(resolvedPath);
-      } catch {
-        throw new Error(
-          `Package ${packageName} was installed but could not be found at ${resolvedPath}`
-        );
-      }
-      const packageJson = JSON.parse(
-        await fs8.readFile(path9.join(resolvedPath, "package.json"), "utf8")
-      );
-      return { resolvedPath, version: packageJson.version ?? version };
-    }
-    case "serverless": {
-      onProgress?.("Serverless environment detected \u2014 queuing for next deploy");
-      const pendingPath = path9.join(toolsDir, "pending-tools.json");
-      let pending = { tools: [] };
-      try {
-        const raw = await fs8.readFile(pendingPath, "utf8");
-        pending = JSON.parse(raw);
-      } catch {
-      }
-      pending.tools.push({ packageName, version });
-      await ensureDir();
-      await fs8.writeFile(pendingPath, JSON.stringify(pending, null, 2), "utf8");
-      return { resolvedPath: path9.join(toolsDir, "node_modules", packageName), version };
-    }
-    case "sandbox": {
-      onProgress?.("Installing in sandbox environment");
-      await ensureToolsPackageJson();
-      const installCmd = `npm install ${packageName}@${version} --prefix "${toolsDir}" --save --no-audit --no-fund`;
-      await execAsync2(installCmd, { cwd: toolsDir, timeout: 12e4 });
-      return { resolvedPath: path9.join(toolsDir, "node_modules", packageName), version };
-    }
-    default:
-      throw new Error(`Unsupported deployment target: ${target}`);
-  }
-}
-async function resolveManifest(toolId) {
-  const descriptor = await getToolById(toolId);
-  if (descriptor) return descriptor;
-  throw new Error(`Unknown tool: ${toolId}. Not found in local registry or Hub.`);
-}
-async function isWorkspaceTool(packageName) {
-  try {
-    const { stdout } = await execAsync2(`pnpm ls -r --depth -1 --json 2>/dev/null || true`, {
-      cwd: process.cwd(),
-      timeout: 1e4
-    });
-    const data = JSON.parse(stdout || "[]");
-    return Array.isArray(data) && data.some((pkg) => pkg.name === packageName);
-  } catch {
-    return false;
-  }
-}
-async function installTool(toolId, onProgress) {
-  const report = (stage, percent, message) => {
-    onProgress?.({ toolId, stage, percent, message });
-  };
-  try {
-    report("checking-deps", 5, "Resolving tool manifest\u2026");
-    const descriptor = await resolveManifest(toolId);
-    if (descriptor.comingSoon) {
-      throw new Error(`${descriptor.name} is coming soon.`);
-    }
-    report("checking-deps", 15, "Checking system dependencies\u2026");
-    const missing = await checkSystemDeps(toolId);
-    if (missing.length > 0) {
-      const msg = `Missing system dependencies: ${missing.join(", ")}. Please install them first.`;
-      report("failed", 0, msg);
-      throw new Error(msg);
-    }
-    const isWorkspace = await isWorkspaceTool(descriptor.packageName);
-    const target = detectDeploymentTarget();
-    let resolvedPath;
-    let installedVersion = descriptor.version;
-    let source;
-    if (isWorkspace) {
-      report("downloading", 30, "Resolving workspace package\u2026");
-      try {
-        const modulePath = __require.resolve(descriptor.packageName, {
-          paths: [process.cwd()]
-        });
-        resolvedPath = path9.dirname(modulePath);
-      } catch {
-        resolvedPath = path9.join(process.cwd(), "node_modules", descriptor.packageName);
-      }
-      source = "local";
-      report("installing", 60, "Workspace package resolved.");
-    } else {
-      report("downloading", 30, `Downloading ${descriptor.packageName}@${descriptor.version}\u2026`);
-      const installed = await execInstall(
-        descriptor.packageName,
-        descriptor.version,
-        target,
-        (msg) => report("downloading", 50, msg)
-      );
-      resolvedPath = installed.resolvedPath;
-      installedVersion = installed.version;
-      source = target === "sandbox" ? "sandbox" : "registry";
-      report("installing", 70, "Package installed.");
-    }
-    report("installing", 80, "Registering tool\u2026");
-    await ensureDir();
-    const manifest = await readManifest();
-    const existing = manifest.tools.findIndex((t) => t.id === toolId);
-    const entry = {
-      id: toolId,
-      version: installedVersion,
-      installedAt: (/* @__PURE__ */ new Date()).toISOString(),
-      packageName: descriptor.packageName,
-      resolvedPath,
-      source,
-      config: buildDefaultConfig(descriptor)
-    };
-    if (existing >= 0) {
-      manifest.tools[existing] = entry;
-    } else {
-      manifest.tools.push(entry);
-    }
-    manifest.downloadCounts[toolId] = (manifest.downloadCounts[toolId] ?? 0) + 1;
-    await writeManifest(manifest);
-    notifyHubInstall(toolId).catch(() => {
-    });
-    invalidateRegistryCache();
-    report("completed", 100, "Installed successfully.");
-  } catch (err) {
-    const message = err instanceof Error ? err.message : "Installation failed.";
-    report("failed", 0, message);
-    throw err;
-  }
-}
-async function uninstallTool(toolId) {
-  const manifest = await readManifest();
-  const tool2 = manifest.tools.find((t) => t.id === toolId);
-  manifest.tools = manifest.tools.filter((t) => t.id !== toolId);
-  await writeManifest(manifest);
-  if (tool2?.source === "registry" && tool2.packageName) {
-    try {
-      const toolsDir = getToolsDir();
-      await execAsync2(`npm uninstall ${tool2.packageName} --prefix "${toolsDir}"`, {
-        cwd: toolsDir,
-        timeout: 3e4
-      });
-    } catch {
-    }
-  }
-  invalidateRegistryCache();
-}
-async function notifyHubInstall(toolId) {
-  const hubUrl = process.env.LARKUP_HUB_URL ?? "https://hub.larkup.de";
-  try {
-    const controller = new AbortController();
-    const timeout = setTimeout(() => controller.abort(), 3e3);
-    await fetch(`${hubUrl}/v1/tools/${toolId}/installed`, {
-      method: "POST",
-      signal: controller.signal,
-      headers: { "Content-Type": "application/json" }
-    });
-    clearTimeout(timeout);
-  } catch {
-  }
-}
-function buildDefaultConfig(descriptor) {
-  const config = {};
-  for (const field of descriptor.configSchema ?? []) {
-    if (field.defaultValue !== void 0) {
-      config[field.key] = field.defaultValue;
-    }
-  }
-  return config;
-}
-
-// ../../packages/marketplace/src/tool-loader.ts
-var moduleCache = /* @__PURE__ */ new Map();
-async function loadTool(toolId) {
-  if (moduleCache.has(toolId)) return moduleCache.get(toolId);
-  const installed = await getInstalledTool(toolId);
-  if (!installed) return null;
-  try {
-    const importPath = resolveImportPath(installed);
-    const mod = await import(
-      /* webpackIgnore: true */
-      importPath
-    );
-    moduleCache.set(toolId, mod);
-    return mod;
-  } catch (err) {
-    console.error(`[marketplace] Failed to load tool "${toolId}":`, err);
-    return null;
-  }
-}
-function resolveImportPath(installed) {
-  switch (installed.source) {
-    case "local":
-      return installed.packageName;
-    case "registry":
-    case "sandbox":
-      return installed.resolvedPath;
-    default:
-      return installed.packageName;
-  }
-}
-
-// ../../packages/marketplace/src/storage-provider.ts
-import { promises as fs9 } from "fs";
-import path10 from "path";
 var LocalStorageProvider = class {
   id = "local";
   name = "Local Storage";
   async mediaDir() {
     const dataDir = await requireDataDir();
-    const dir = path10.join(dataDir, "media");
-    await fs9.mkdir(dir, { recursive: true });
+    const dir = path9.join(dataDir, "media");
+    await fs8.mkdir(dir, { recursive: true });
     return dir;
   }
   async store(key, data, _mimeType) {
     const dir = await this.mediaDir();
-    const filePath = path10.join(dir, key);
-    await fs9.mkdir(path10.dirname(filePath), { recursive: true });
-    await fs9.writeFile(filePath, data);
+    const filePath = path9.join(dir, key);
+    await fs8.mkdir(path9.dirname(filePath), { recursive: true });
+    await fs8.writeFile(filePath, data);
     return `local://${key}`;
   }
   async storeFile(key, sourcePath, _mimeType) {
     const dir = await this.mediaDir();
-    const filePath = path10.join(dir, key);
-    await fs9.mkdir(path10.dirname(filePath), { recursive: true });
-    await fs9.copyFile(sourcePath, filePath);
+    const filePath = path9.join(dir, key);
+    await fs8.mkdir(path9.dirname(filePath), { recursive: true });
+    await fs8.copyFile(sourcePath, filePath);
     return `local://${key}`;
   }
   async retrieve(uri) {
     const filePath = await this.resolvePath(uri);
     if (!filePath) throw new Error(`Unsupported local storage URI: ${uri}`);
-    return fs9.readFile(filePath);
+    return fs8.readFile(filePath);
   }
   async resolvePath(uri) {
     if (!uri.startsWith("local://")) return void 0;
     const key = uri.slice("local://".length);
     const dir = await this.mediaDir();
-    const filePath = path10.resolve(dir, key);
-    const relative = path10.relative(dir, filePath);
-    if (relative.startsWith("..") || path10.isAbsolute(relative)) {
+    const filePath = path9.resolve(dir, key);
+    const relative = path9.relative(dir, filePath);
+    if (relative.startsWith("..") || path9.isAbsolute(relative)) {
       throw new Error("Invalid local storage URI");
     }
     return filePath;
@@ -5184,7 +4842,7 @@ var LocalStorageProvider = class {
     const key = uri.replace("local://", "");
     const dir = await this.mediaDir();
     try {
-      await fs9.unlink(path10.join(dir, key));
+      await fs8.unlink(path9.join(dir, key));
     } catch {
     }
   }
@@ -5203,17 +4861,17 @@ async function computeDirStats(dir) {
   async function walk2(d) {
     let entries;
     try {
-      entries = await fs9.readdir(d, { withFileTypes: true });
+      entries = await fs8.readdir(d, { withFileTypes: true });
     } catch {
       return;
     }
     for (const entry of entries) {
-      const full = path10.join(d, entry.name);
+      const full = path9.join(d, entry.name);
       if (entry.isDirectory()) {
         await walk2(full);
       } else {
         try {
-          const stat = await fs9.stat(full);
+          const stat = await fs8.stat(full);
           usedBytes += stat.size;
           fileCount++;
         } catch {
@@ -5270,12 +4928,12 @@ async function processMediaCommand(inputs, options) {
   const assets = await Promise.all(
     mediaFiles.map(async (filePath) => {
       const type = mediaType(filePath);
-      const stat = await fs10.stat(filePath);
-      const extension = path11.extname(filePath).toLowerCase() || ".bin";
+      const stat = await fs9.stat(filePath);
+      const extension = path10.extname(filePath).toLowerCase() || ".bin";
       const key = `${type}s/${Date.now()}_${Math.random().toString(36).slice(2)}${extension}`;
       const mimeType = MIME_TYPES[extension] || "application/octet-stream";
-      const storageUri = storage.storeFile ? await storage.storeFile(key, filePath, mimeType) : await storage.store(key, await fs10.readFile(filePath), mimeType);
-      return { type, fileName: path11.basename(filePath), mimeType, storageUri, fileSize: stat.size };
+      const storageUri = storage.storeFile ? await storage.storeFile(key, filePath, mimeType) : await storage.store(key, await fs9.readFile(filePath), mimeType);
+      return { type, fileName: path10.basename(filePath), mimeType, storageUri, fileSize: stat.size };
     })
   );
   const stored = await addMediaAssets(assets);
@@ -5357,7 +5015,7 @@ async function processMediaAsset(asset) {
       if (!tool2.processVideo)
         throw new Error("The installed Video & Audio tool cannot process videos.");
       await update("Extracting video audio", 20);
-      const outputDir = await fs10.mkdtemp(path11.join(process.cwd(), ".larkup", "tmp-media-"));
+      const outputDir = await fs9.mkdtemp(path10.join(process.cwd(), ".larkup", "tmp-media-"));
       try {
         const video = await tool2.processVideo(localFile, {
           outputDir,
@@ -5378,7 +5036,7 @@ async function processMediaAsset(asset) {
         dimensions = { width: video.meta.width, height: video.meta.height };
         frameCount = video.frames.length;
       } finally {
-        await fs10.rm(outputDir, { recursive: true, force: true }).catch(() => {
+        await fs9.rm(outputDir, { recursive: true, force: true }).catch(() => {
         });
       }
     } else {
@@ -5456,7 +5114,7 @@ async function indexPendingMedia() {
   spinner2.stop(`Indexed ${finalRun.totalChunks} chunks`);
 }
 function mediaType(filePath) {
-  const extension = path11.extname(filePath).toLowerCase();
+  const extension = path10.extname(filePath).toLowerCase();
   if ([".png", ".jpg", ".jpeg", ".webp", ".gif"].includes(extension)) return "image";
   if ([".mp4", ".webm", ".mov", ".mkv"].includes(extension)) return "video";
   if ([".mp3", ".m4a", ".wav", ".ogg", ".flac"].includes(extension)) return "audio";
@@ -5543,20 +5201,20 @@ async function indexCommand(inputs, options) {
 }
 
 // src/commands/generate.ts
-import { promises as fs11 } from "fs";
-import path12 from "path";
+import { promises as fs10 } from "fs";
+import path11 from "path";
 async function generateCommand(options) {
   await inServerScope(options.server, async () => {
     await requireActive();
     const config = await readConfig();
     if (options.out) {
-      const dir = path12.isAbsolute(options.out) ? options.out : path12.join(process.cwd(), options.out);
+      const dir = path11.isAbsolute(options.out) ? options.out : path11.join(process.cwd(), options.out);
       const server2 = generateServer(config);
-      await fs11.mkdir(dir, { recursive: true });
+      await fs10.mkdir(dir, { recursive: true });
       for (const f of server2.files) {
-        const dest = path12.join(dir, f.path);
-        await fs11.mkdir(path12.dirname(dest), { recursive: true });
-        await fs11.writeFile(dest, f.contents, "utf8");
+        const dest = path11.join(dir, f.path);
+        await fs10.mkdir(path11.dirname(dest), { recursive: true });
+        await fs10.writeFile(dest, f.contents, "utf8");
       }
       log.success(`Generated ${server2.files.length} files \u2192 ${dir}`);
     } else {
@@ -5904,8 +5562,8 @@ async function marketplaceCommand(action = "list", toolId) {
 }
 
 // src/commands/deploy.ts
-import { promises as fs12 } from "fs";
-import path13 from "path";
+import { promises as fs11 } from "fs";
+import path12 from "path";
 async function deployCommand(target, options) {
   await inServerScope(options.server, async () => {
     await requireActive();
@@ -5941,13 +5599,13 @@ async function deployCommand(target, options) {
   });
 }
 async function copyGenerated(source, output) {
-  const destination = path13.resolve(output);
-  const relative = path13.relative(source, destination);
-  if (relative === "" || !relative.startsWith("..") && !path13.isAbsolute(relative)) {
+  const destination = path12.resolve(output);
+  const relative = path12.relative(source, destination);
+  if (relative === "" || !relative.startsWith("..") && !path12.isAbsolute(relative)) {
     throw new Error("Deployment output must be outside the generated server directory.");
   }
-  await fs12.mkdir(destination, { recursive: true });
-  await fs12.cp(source, destination, { recursive: true, force: true });
+  await fs11.mkdir(destination, { recursive: true });
+  await fs11.cp(source, destination, { recursive: true, force: true });
   return destination;
 }
 
@@ -6032,8 +5690,8 @@ function openCommandForPlatform(url) {
 }
 
 // src/commands/documents.ts
-import { promises as fs13 } from "fs";
-import path14 from "path";
+import { promises as fs12 } from "fs";
+import path13 from "path";
 
 // ../../packages/core/src/corpus-retriever.ts
 function applyFilters(docs, filter) {
@@ -6152,10 +5810,10 @@ async function documentsCommand(action = "list", idOrPath, options) {
     }
     if (action === "export") {
       const format = options.format === "jsonl" ? "jsonl" : "csv";
-      const output = path14.resolve(options.out || idOrPath || `corpus.${format}`);
+      const output = path13.resolve(options.out || idOrPath || `corpus.${format}`);
       const content = format === "jsonl" ? await exportCorpusAsJSONL(void 0, Number.MAX_SAFE_INTEGER) : await exportCorpusAsCSV(void 0, Number.MAX_SAFE_INTEGER);
-      await fs13.mkdir(path14.dirname(output), { recursive: true });
-      await fs13.writeFile(output, content, "utf8");
+      await fs12.mkdir(path13.dirname(output), { recursive: true });
+      await fs12.writeFile(output, content, "utf8");
       log.success(`Exported corpus \u2192 ${output}`);
       return;
     }
@@ -6181,7 +5839,7 @@ ${document.content}`);
       return;
     }
     if (action === "update") {
-      const content = options.file ? await fs13.readFile(path14.resolve(options.file), "utf8") : options.text;
+      const content = options.file ? await fs12.readFile(path13.resolve(options.file), "utf8") : options.text;
       const updated = await updateDocument(document.id, {
         title: options.title,
         content,

package/dist/tool-loader-QU6HBUCA.js

@@ -0,0 +1,14 @@
+import {
+  hasCapability,
+  isToolLoaded,
+  loadTool,
+  unloadTool
+} from "./chunk-VY6I42DP.js";
+import "./chunk-P5JVXA7X.js";
+import "./chunk-3RG5ZIWI.js";
+export {
+  hasCapability,
+  isToolLoaded,
+  loadTool,
+  unloadTool
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@larkup/cli",
-  "version": "0.2.4",
+  "version": "0.2.6",
   "publishConfig": {
     "access": "public"
   },
@@ -28,9 +28,9 @@
     "cli-table3": "^0.6.5",
     "commander": "^15.0.0",
     "zod": "^4.4.3",
-    "@larkup/core": "0.2.2",
-    "@larkup/marketplace": "0.1.4",
-    "@larkup/vector-stores": "0.1.22"
+    "@larkup/marketplace": "0.1.6",
+    "@larkup/vector-stores": "0.1.22",
+    "@larkup/core": "0.2.3"
   },
   "devDependencies": {
     "tsup": "^8.0.0",