@larkup/cli 0.2.7 → 0.2.8

package/dist/chunk-KMVYMOQV.js

@@ -0,0 +1,436 @@
+import {
+  getToolById,
+  invalidateRegistryCache
+} from "./chunk-UCYL66UI.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);
+var packageMutationChain = Promise.resolve();
+function serializePackageMutation(fn) {
+  const run = packageMutationChain.then(fn, fn);
+  packageMutationChain = run.catch(() => {
+  });
+  return run;
+}
+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 ?? "doc-editor,video-audio").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) {
+  return serializePackageMutation(
+    () => execInstallUnlocked(packageName, version, target, onProgress)
+  );
+}
+async function execInstallUnlocked(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 --prefer-offline`;
+        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-VBH7DQU3.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-ED45DB5F.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/chunk-UCYL66UI.js

@@ -0,0 +1,231 @@
+// ../../packages/marketplace/src/tool-registry.ts
+import { promises as fs } from "fs";
+import path from "path";
+
+// ../../packages/marketplace/src/types.ts
+var DEFAULT_HUB_URL = process.env.LARKUP_HUB_URL ?? "https://hub.larkup.de";
+var STORAGE_WARNING_THRESHOLDS = [
+  1 * 1024 * 1024 * 1024,
+  // 1 GB
+  5 * 1024 * 1024 * 1024,
+  // 5 GB
+  10 * 1024 * 1024 * 1024
+  // 10 GB
+];
+
+// ../../packages/marketplace/src/tool-registry.ts
+var cachedRegistry = null;
+async function discoverLocalManifests() {
+  const registry = {};
+  const searchPaths = [
+    // Monorepo development: packages/tools/*
+    path.resolve(process.cwd(), "packages", "tools"),
+    // Next.js dev server runs in apps/web
+    path.resolve(process.cwd(), "..", "..", "packages", "tools"),
+    // Installed tools: .larkup/tools/node_modules/@larkup
+    path.resolve(process.cwd(), ".larkup", "tools", "node_modules", "@larkup"),
+    path.resolve(process.cwd(), "..", "..", ".larkup", "tools", "node_modules", "@larkup")
+  ];
+  for (const searchPath of searchPaths) {
+    try {
+      const entries = await fs.readdir(searchPath, { withFileTypes: true });
+      for (const entry of entries) {
+        if (!entry.isDirectory()) continue;
+        const manifestPath = path.join(searchPath, entry.name, "tool.manifest.json");
+        try {
+          const raw = await fs.readFile(manifestPath, "utf8");
+          const manifest = JSON.parse(raw);
+          if (manifest.id) {
+            registry[manifest.id] = manifest;
+          }
+        } catch {
+        }
+      }
+    } catch {
+    }
+  }
+  return registry;
+}
+async function fetchHubCatalog(hubUrl) {
+  const baseUrl = hubUrl ?? DEFAULT_HUB_URL;
+  try {
+    const controller = new AbortController();
+    const timeout = setTimeout(() => controller.abort(), 5e3);
+    const res = await fetch(`${baseUrl}/v1/tools`, {
+      signal: controller.signal,
+      headers: { Accept: "application/json" }
+    });
+    clearTimeout(timeout);
+    if (!res.ok) return {};
+    const data = await res.json();
+    const registry = {};
+    for (const tool of data.tools ?? []) {
+      if (tool.id) registry[tool.id] = tool;
+    }
+    return registry;
+  } catch {
+    return {};
+  }
+}
+async function fetchToolFromHub(toolId, hubUrl) {
+  const baseUrl = hubUrl ?? DEFAULT_HUB_URL;
+  try {
+    const controller = new AbortController();
+    const timeout = setTimeout(() => controller.abort(), 5e3);
+    const res = await fetch(`${baseUrl}/v1/tools/${toolId}`, {
+      signal: controller.signal,
+      headers: { Accept: "application/json" }
+    });
+    clearTimeout(timeout);
+    if (!res.ok) return null;
+    const data = await res.json();
+    return data.tool ?? null;
+  } catch {
+    return null;
+  }
+}
+var FALLBACK_REGISTRY = {
+  "video-audio": {
+    id: "video-audio",
+    name: "Video & Audio",
+    description: "Index video and audio files with transcription and frame analysis.",
+    category: "media",
+    version: "0.2.1",
+    pricing: "free",
+    emoji: "\u{1F3AC}",
+    icon: "Film",
+    packageName: "@larkup/tool-video-audio",
+    installSize: "~15 MB",
+    systemDeps: ["ffmpeg"],
+    author: "Larkup",
+    capabilities: [
+      "video-indexing",
+      "audio-indexing",
+      "transcription",
+      "frame-extraction",
+      "youtube-import"
+    ],
+    tags: ["transcription", "ffmpeg", "video", "audio", "whisper"],
+    downloads: 0,
+    repositoryUrl: "https://github.com/Larkup-AI/larkup",
+    license: "Apache-2.0",
+    updatedAt: "2026-07-20",
+    configSchema: [
+      {
+        key: "frameInterval",
+        label: "Frame extraction interval (seconds)",
+        type: "text",
+        defaultValue: "10",
+        help: "Baseline cadence for duration-aware coverage frames; scene changes and a reserved ending pass are added separately."
+      },
+      {
+        key: "audioProvider",
+        label: "Audio Provider",
+        type: "select",
+        help: "Choose the provider used only for audio and video transcription.",
+        options: [
+          { label: "OpenAI", value: "openai" },
+          { label: "Groq", value: "groq" },
+          { label: "Deepgram", value: "deepgram" },
+          { label: "ElevenLabs", value: "elevenlabs" },
+          { label: "Local Whisper", value: "local" }
+        ]
+      },
+      {
+        key: "audioLanguage",
+        label: "Transcription language",
+        type: "text",
+        defaultValue: "auto",
+        help: "Use auto to infer Arabic from the media title and use provider detection otherwise. Enter a language code such as ar, ar-EG, en, or de to override it."
+      },
+      {
+        key: "audioApiKey",
+        label: "Audio API Key",
+        type: "password",
+        help: "Required for the selected audio provider and kept separate from the chat model key."
+      }
+    ]
+  },
+  "clip-embeddings": {
+    id: "clip-embeddings",
+    name: "CLIP Image Search",
+    description: "Direct image-to-image similarity search using CLIP/SigLIP embeddings.",
+    category: "embedding",
+    version: "0.1.0",
+    pricing: "free",
+    emoji: "\u{1F50D}",
+    icon: "ScanEye",
+    packageName: "@larkup/tool-clip-embeddings",
+    installSize: "~200 MB",
+    author: "Larkup",
+    capabilities: ["clip-embeddings", "image-similarity"],
+    tags: ["clip", "siglip", "image-search", "visual-similarity"],
+    downloads: 0,
+    repositoryUrl: "https://github.com/Larkup-AI/larkup",
+    license: "Apache-2.0",
+    updatedAt: "2026-07-20",
+    comingSoon: true
+  },
+  "doc-editor": {
+    id: "doc-editor",
+    name: "Document Editor",
+    description: "AI-powered form filling and document editing with Canvas-style live preview.",
+    category: "utility",
+    version: "0.2.3",
+    pricing: "free",
+    emoji: "\u{1F4DD}",
+    icon: "FileEdit",
+    packageName: "@larkup/tool-doc-editor",
+    installSize: "~5 MB",
+    systemDeps: ["docker"],
+    author: "Larkup",
+    capabilities: ["document-editing", "form-filling", "document-preview"],
+    tags: ["pdf", "docx", "pptx", "form", "canvas", "editor", "fill"],
+    downloads: 0,
+    repositoryUrl: "https://github.com/Larkup-AI/larkup",
+    license: "Apache-2.0",
+    updatedAt: "2026-07-20"
+  }
+};
+async function buildRegistry(opts) {
+  if (cachedRegistry) return cachedRegistry;
+  const registry = { ...FALLBACK_REGISTRY };
+  const localManifests = await discoverLocalManifests();
+  Object.assign(registry, localManifests);
+  if (!opts?.skipHub) {
+    const hubCatalog = await fetchHubCatalog(opts?.hubUrl);
+    Object.assign(registry, hubCatalog);
+  }
+  cachedRegistry = registry;
+  return registry;
+}
+function invalidateRegistryCache() {
+  cachedRegistry = null;
+}
+async function getAllTools() {
+  const registry = await buildRegistry();
+  return Object.values(registry).sort((a, b) => a.name.localeCompare(b.name));
+}
+async function getToolById(id) {
+  const registry = await buildRegistry();
+  return registry[id];
+}
+async function getToolsWithCapability(capability) {
+  const all = await getAllTools();
+  return all.filter((t) => t.capabilities.includes(capability));
+}
+async function getAllCategories() {
+  const all = await getAllTools();
+  const cats = new Set(all.map((t) => t.category));
+  return Array.from(cats).sort();
+}
+
+export {
+  fetchToolFromHub,
+  buildRegistry,
+  invalidateRegistryCache,
+  getAllTools,
+  getToolById,
+  getToolsWithCapability,
+  getAllCategories
+};

package/dist/index.js

@@ -12,6 +12,18 @@ import {
   setActiveServer,
   trackUsageEvent
 } from "./chunk-ZJLA4SIG.js";
+import {
+  getInstalledTool,
+  getInstalledTools,
+  installTool,
+  isToolInstalled,
+  loadTool,
+  uninstallTool
+} from "./chunk-KMVYMOQV.js";
+import {
+  getAllTools,
+  getToolById
+} from "./chunk-UCYL66UI.js";
 import {
   __require
 } from "./chunk-3RG5ZIWI.js";
@@ -22,7 +34,7 @@ import { Command } from "commander";
 // package.json
 var package_default = {
   name: "@larkup/cli",
-  version: "0.2.7",
+  version: "0.2.8",
   publishConfig: {
     access: "public"
   },
@@ -939,12 +951,12 @@ function addChatProviderDependency(dependencies, provider) {
 }
 
 // ../../packages/core/src/generator/generate-server.ts
-function lang(path13) {
-  if (path13.endsWith(".json")) return "json";
-  if (path13.endsWith(".mjs") || path13.endsWith(".js")) return "javascript";
-  if (path13.endsWith(".md")) return "markdown";
-  if (path13.endsWith("Dockerfile")) return "dockerfile";
-  if (path13.endsWith(".yml") || path13.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() {
@@ -2261,22 +2273,22 @@ function generateServer(config) {
     { path: "README.md", contents: readme(config, server) }
   ].map((f) => ({ ...f, language: lang(f.path) }));
   try {
-    const fs12 = __require("fs");
-    const path13 = __require("path");
-    const faviconPath = path13.resolve(process.cwd(), "public/favicon2.ico");
-    if (fs12.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: fs12.readFileSync(faviconPath).toString("base64"),
+        contents: fs13.readFileSync(faviconPath).toString("base64"),
         language: "ico",
         encoding: "base64"
       });
     } else {
-      const webFaviconPath = path13.resolve(process.cwd(), "apps/web/public/favicon2.ico");
-      if (fs12.existsSync(webFaviconPath)) {
+      const webFaviconPath = path14.resolve(process.cwd(), "apps/web/public/favicon2.ico");
+      if (fs13.existsSync(webFaviconPath)) {
         files.push({
           path: "public/favicon2.ico",
-          contents: fs12.readFileSync(webFaviconPath).toString("base64"),
+          contents: fs13.readFileSync(webFaviconPath).toString("base64"),
           language: "ico",
           encoding: "base64"
         });
@@ -2290,12 +2302,12 @@ function generateServer(config) {
 }
 
 // ../../packages/core/src/generator/generate-agent-server.ts
-function lang2(path13) {
-  if (path13.endsWith(".json")) return "json";
-  if (path13.endsWith(".mjs") || path13.endsWith(".js")) return "javascript";
-  if (path13.endsWith(".md")) return "markdown";
-  if (path13.endsWith("Dockerfile")) return "dockerfile";
-  if (path13.endsWith(".yml") || path13.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() {
@@ -3309,22 +3321,22 @@ function generateAgentServer(config) {
     { path: "README.md", contents: readme2(config, server) }
   ].map((f) => ({ ...f, language: lang2(f.path) }));
   try {
-    const fs12 = __require("fs");
-    const path13 = __require("path");
-    const faviconPath = path13.resolve(process.cwd(), "public/favicon2.ico");
-    if (fs12.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: fs12.readFileSync(faviconPath).toString("base64"),
+        contents: fs13.readFileSync(faviconPath).toString("base64"),
         language: "ico",
         encoding: "base64"
       });
     } else {
-      const webFaviconPath = path13.resolve(process.cwd(), "apps/web/public/favicon2.ico");
-      if (fs12.existsSync(webFaviconPath)) {
+      const webFaviconPath = path14.resolve(process.cwd(), "apps/web/public/favicon2.ico");
+      if (fs13.existsSync(webFaviconPath)) {
         files.push({
           path: "public/favicon2.ico",
-          contents: fs12.readFileSync(webFaviconPath).toString("base64"),
+          contents: fs13.readFileSync(webFaviconPath).toString("base64"),
           language: "ico",
           encoding: "base64"
         });
@@ -4641,8 +4653,8 @@ async function readTextFiles(files) {
 }
 
 // src/commands/media.ts
-import { promises as fs8 } from "fs";
-import path9 from "path";
+import { promises as fs9 } from "fs";
+import path10 from "path";
 
 // ../../packages/core/src/media-store.ts
 import { promises as fs7 } from "fs";
@@ -4784,10 +4796,97 @@ function claimMediaAsset(id) {
   });
 }
 
+// ../../packages/marketplace/src/storage-provider.ts
+import { promises as fs8 } from "fs";
+import path9 from "path";
+var LocalStorageProvider = class {
+  id = "local";
+  name = "Local Storage";
+  async mediaDir() {
+    const dataDir = await requireDataDir();
+    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 = 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 = 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 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 = 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;
+  }
+  async delete(uri) {
+    const key = uri.replace("local://", "");
+    const dir = await this.mediaDir();
+    try {
+      await fs8.unlink(path9.join(dir, key));
+    } catch {
+    }
+  }
+  async stats() {
+    try {
+      const dir = await this.mediaDir();
+      return await computeDirStats(dir);
+    } catch {
+      return { usedBytes: 0, fileCount: 0 };
+    }
+  }
+};
+async function computeDirStats(dir) {
+  let usedBytes = 0;
+  let fileCount = 0;
+  async function walk2(d) {
+    let entries;
+    try {
+      entries = await fs8.readdir(d, { withFileTypes: true });
+    } catch {
+      return;
+    }
+    for (const entry of entries) {
+      const full = path9.join(d, entry.name);
+      if (entry.isDirectory()) {
+        await walk2(full);
+      } else {
+        try {
+          const stat = await fs8.stat(full);
+          usedBytes += stat.size;
+          fileCount++;
+        } catch {
+        }
+      }
+    }
+  }
+  await walk2(dir);
+  return { usedBytes, fileCount };
+}
+function createStorageProvider(_config) {
+  return new LocalStorageProvider();
+}
+
 // src/commands/media.ts
-import { isToolInstalled } from "@larkup/marketplace/installer";
-import { loadTool } from "@larkup/marketplace/loader";
-import { createStorageProvider } from "@larkup/marketplace/storage";
 var MIME_TYPES = {
   ".png": "image/png",
   ".jpg": "image/jpeg",
@@ -4829,12 +4928,12 @@ async function processMediaCommand(inputs, options) {
   const assets = await Promise.all(
     mediaFiles.map(async (filePath) => {
       const type = mediaType(filePath);
-      const stat = await fs8.stat(filePath);
-      const extension = path9.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 fs8.readFile(filePath), mimeType);
-      return { type, fileName: path9.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);
@@ -4916,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 fs8.mkdtemp(path9.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,
@@ -4937,7 +5036,7 @@ async function processMediaAsset(asset) {
         dimensions = { width: video.meta.width, height: video.meta.height };
         frameCount = video.frames.length;
       } finally {
-        await fs8.rm(outputDir, { recursive: true, force: true }).catch(() => {
+        await fs9.rm(outputDir, { recursive: true, force: true }).catch(() => {
         });
       }
     } else {
@@ -5015,7 +5114,7 @@ async function indexPendingMedia() {
   spinner2.stop(`Indexed ${finalRun.totalChunks} chunks`);
 }
 function mediaType(filePath) {
-  const extension = path9.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";
@@ -5102,20 +5201,20 @@ async function indexCommand(inputs, options) {
 }
 
 // src/commands/generate.ts
-import { promises as fs9 } from "fs";
-import path10 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 = path10.isAbsolute(options.out) ? options.out : path10.join(process.cwd(), options.out);
+      const dir = path11.isAbsolute(options.out) ? options.out : path11.join(process.cwd(), options.out);
       const server2 = generateServer(config);
-      await fs9.mkdir(dir, { recursive: true });
+      await fs10.mkdir(dir, { recursive: true });
       for (const f of server2.files) {
-        const dest = path10.join(dir, f.path);
-        await fs9.mkdir(path10.dirname(dest), { recursive: true });
-        await fs9.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 {
@@ -5420,13 +5519,6 @@ async function settingsCommand(options) {
 }
 
 // src/commands/marketplace.ts
-import { getAllTools, getToolById } from "@larkup/marketplace/registry";
-import {
-  getInstalledTool,
-  getInstalledTools,
-  installTool,
-  uninstallTool
-} from "@larkup/marketplace/installer";
 async function marketplaceCommand(action = "list", toolId) {
   if (action === "list") {
     const [tools, installed] = await Promise.all([getAllTools(), getInstalledTools()]);
@@ -5470,8 +5562,8 @@ async function marketplaceCommand(action = "list", toolId) {
 }
 
 // src/commands/deploy.ts
-import { promises as fs10 } from "fs";
-import path11 from "path";
+import { promises as fs11 } from "fs";
+import path12 from "path";
 async function deployCommand(target, options) {
   await inServerScope(options.server, async () => {
     await requireActive();
@@ -5507,13 +5599,13 @@ async function deployCommand(target, options) {
   });
 }
 async function copyGenerated(source, output) {
-  const destination = path11.resolve(output);
-  const relative = path11.relative(source, destination);
-  if (relative === "" || !relative.startsWith("..") && !path11.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 fs10.mkdir(destination, { recursive: true });
-  await fs10.cp(source, destination, { recursive: true, force: true });
+  await fs11.mkdir(destination, { recursive: true });
+  await fs11.cp(source, destination, { recursive: true, force: true });
   return destination;
 }
 
@@ -5598,8 +5690,8 @@ function openCommandForPlatform(url) {
 }
 
 // src/commands/documents.ts
-import { promises as fs11 } from "fs";
-import path12 from "path";
+import { promises as fs12 } from "fs";
+import path13 from "path";
 
 // ../../packages/core/src/corpus-retriever.ts
 function applyFilters(docs, filter) {
@@ -5718,10 +5810,10 @@ async function documentsCommand(action = "list", idOrPath, options) {
     }
     if (action === "export") {
       const format = options.format === "jsonl" ? "jsonl" : "csv";
-      const output = path12.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 fs11.mkdir(path12.dirname(output), { recursive: true });
-      await fs11.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;
     }
@@ -5747,7 +5839,7 @@ ${document.content}`);
       return;
     }
     if (action === "update") {
-      const content = options.file ? await fs11.readFile(path12.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-VBH7DQU3.js

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

package/dist/tool-registry-ED45DB5F.js

@@ -0,0 +1,19 @@
+import {
+  buildRegistry,
+  fetchToolFromHub,
+  getAllCategories,
+  getAllTools,
+  getToolById,
+  getToolsWithCapability,
+  invalidateRegistryCache
+} from "./chunk-UCYL66UI.js";
+import "./chunk-3RG5ZIWI.js";
+export {
+  buildRegistry,
+  fetchToolFromHub,
+  getAllCategories,
+  getAllTools,
+  getToolById,
+  getToolsWithCapability,
+  invalidateRegistryCache
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@larkup/cli",
-  "version": "0.2.7",
+  "version": "0.2.8",
   "publishConfig": {
     "access": "public"
   },
@@ -28,9 +28,9 @@
     "cli-table3": "^0.6.5",
     "commander": "^15.0.0",
     "zod": "^4.4.3",
+    "@larkup/vector-stores": "0.1.23",
     "@larkup/core": "0.2.4",
-    "@larkup/marketplace": "0.1.7",
-    "@larkup/vector-stores": "0.1.23"
+    "@larkup/marketplace": "0.1.8"
   },
   "devDependencies": {
     "tsup": "^8.0.0",