@larkup/cli 0.3.1 → 0.3.3

package/dist/chunk-FY7KWENQ.js

@@ -1,598 +0,0 @@
-import {
-  getToolById,
-  invalidateRegistryCache
-} from "./chunk-YUC4VMEE.js";
-import {
-  __require
-} from "./chunk-QGM4M3NI.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 installingTools = /* @__PURE__ */ new Set();
-var uninstallingTools = /* @__PURE__ */ new Set();
-var execAsync = promisify(execCb);
-var packageMutationChain = Promise.resolve();
-function serializePackageMutation(fn) {
-  const run = packageMutationChain.then(fn, fn);
-  packageMutationChain = run.catch(() => {
-  });
-  return run;
-}
-function getToolsDir() {
-  const dataDir = process.env.LARKUP_DATA_DIR?.trim();
-  return path.join(dataDir ? path.resolve(dataDir) : 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();
-  return [...manifest.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);
-}
-var INSTALL_HINTS = {
-  ffmpeg: {
-    macos: "brew install ffmpeg",
-    linux_apt: "sudo apt-get install -y ffmpeg",
-    linux_dnf: "sudo dnf install -y ffmpeg",
-    linux_pacman: "sudo pacman -S --noconfirm ffmpeg",
-    linux_apk: "sudo apk add --no-cache ffmpeg"
-  }
-};
-function detectPlatform() {
-  if (process.platform === "darwin") return "macos";
-  return "linux";
-}
-async function tryAutoInstallDep(dep, onProgress) {
-  const hints = INSTALL_HINTS[dep];
-  if (!hints) return false;
-  const platform = detectPlatform();
-  let installCmd;
-  if (platform === "macos") {
-    try {
-      await execAsync("which brew");
-      installCmd = hints.macos;
-    } catch {
-      return false;
-    }
-  } else {
-    const managers = [
-      { cmd: "apt-get", key: "linux_apt" },
-      { cmd: "dnf", key: "linux_dnf" },
-      { cmd: "pacman", key: "linux_pacman" },
-      { cmd: "apk", key: "linux_apk" }
-    ];
-    for (const { cmd, key } of managers) {
-      try {
-        await execAsync(`which ${cmd}`);
-        installCmd = hints[key];
-        break;
-      } catch {
-      }
-    }
-  }
-  if (!installCmd) return false;
-  onProgress?.(`Auto-installing ${dep} via "${installCmd}"\u2026`);
-  try {
-    await execAsync(installCmd, { timeout: 3e5 });
-    onProgress?.(`${dep} installation command finished.`);
-  } catch (err) {
-    const message = err instanceof Error ? err.message : String(err);
-    onProgress?.(`Auto-install of ${dep} failed: ${message}`);
-    return false;
-  }
-  try {
-    await execAsync(`which ${dep}`);
-    return true;
-  } catch {
-    return false;
-  }
-}
-function buildMissingDepsMessage(deps) {
-  const platform = detectPlatform();
-  const lines = [`Missing system dependencies: ${deps.join(", ")}.`];
-  for (const dep of deps) {
-    const hints = INSTALL_HINTS[dep];
-    if (!hints) {
-      lines.push(`  \u2022 ${dep}: Please install it manually.`);
-      continue;
-    }
-    if (platform === "macos" && hints.macos) {
-      lines.push(`  \u2022 ${dep}: Run \`${hints.macos}\``);
-    } else if (platform === "linux") {
-      const linuxHint = hints.linux_apt || hints.linux_dnf || hints.linux_pacman || hints.linux_apk;
-      if (linuxHint) {
-        lines.push(`  \u2022 ${dep}: Run \`${linuxHint}\``);
-      }
-    }
-  }
-  return lines.join("\n");
-}
-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 (toolId === "video-audio" && dep === "ffmpeg") continue;
-    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) {
-  return Boolean(await resolveWorkspaceToolPath(packageName));
-}
-async function resolveWorkspaceToolPath(packageName) {
-  try {
-    const linkedPath = path.join(process.cwd(), "node_modules", ...packageName.split("/"));
-    const packageRoot = await fs.realpath(linkedPath);
-    const manifest = JSON.parse(
-      await fs.readFile(path.join(packageRoot, "package.json"), "utf8")
-    );
-    return manifest.name === packageName && !packageRoot.includes(`${path.sep}node_modules${path.sep}`) ? packageRoot : void 0;
-  } catch {
-  }
-  let workspaceRoot = process.cwd();
-  while (true) {
-    try {
-      await fs.access(path.join(workspaceRoot, "pnpm-workspace.yaml"));
-      break;
-    } catch {
-      const parent = path.dirname(workspaceRoot);
-      if (parent === workspaceRoot) return void 0;
-      workspaceRoot = parent;
-    }
-  }
-  const toolsRoot = path.join(workspaceRoot, "packages", "marketplace-tools");
-  let entries;
-  try {
-    entries = await fs.readdir(toolsRoot, { withFileTypes: true });
-  } catch {
-    return void 0;
-  }
-  for (const entry of entries) {
-    if (!entry.isDirectory()) continue;
-    const packageRoot = path.join(toolsRoot, entry.name);
-    try {
-      const manifest = JSON.parse(
-        await fs.readFile(path.join(packageRoot, "package.json"), "utf8")
-      );
-      if (manifest.name === packageName) return packageRoot;
-    } catch {
-    }
-  }
-  return void 0;
-}
-async function installTool(toolId, onProgress, initialConfig = {}) {
-  installingTools.add(toolId);
-  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");
-    let missing = (await checkSystemDeps(toolId)).filter((dependency) => dependency !== "docker");
-    if (missing.length > 0) {
-      const stillMissing = [];
-      for (const dep of missing) {
-        report("checking-deps", 18, `Attempting to install ${dep}\u2026`);
-        const installed = await tryAutoInstallDep(dep, (msg) => report("checking-deps", 20, msg));
-        if (installed) {
-          report("checking-deps", 22, `${dep} installed successfully.`);
-        } else {
-          stillMissing.push(dep);
-        }
-      }
-      missing = stillMissing;
-    }
-    if (missing.length > 0) {
-      const msg = buildMissingDepsMessage(missing);
-      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");
-      resolvedPath = await resolveWorkspaceToolPath(descriptor.packageName) ?? 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), ...initialConfig }
-    };
-    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;
-  } finally {
-    installingTools.delete(toolId);
-  }
-}
-async function uninstallTool(toolId) {
-  uninstallingTools.add(toolId);
-  try {
-    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-2WHU3H77.js");
-    unloadTool2(toolId);
-  } finally {
-    uninstallingTools.delete(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();
-var scopedImports = /* @__PURE__ */ new Map();
-async function getScopedImport(revision) {
-  const namespace = `larkup-marketplace-tools${revision === "fixed" ? "" : `-${revision}`}`;
-  const existing = scopedImports.get(namespace);
-  if (existing) return existing;
-  const { register } = await import(
-    /* webpackIgnore: true */
-    "./api-X4PHQJTH.js"
-  );
-  const importer = register({ namespace }).import;
-  if (scopedImports.size >= 8) {
-    scopedImports.delete(scopedImports.keys().next().value);
-  }
-  scopedImports.set(namespace, importer);
-  return importer;
-}
-async function loadTool(toolId) {
-  const installed = await getInstalledTool(toolId);
-  if (!installed) return null;
-  const importPath = await resolveImportPath(installed);
-  const revision = await entryRevision(installed, importPath);
-  const installationKey = `${installed.source}:${installed.resolvedPath}:${installed.version}:${installed.installedAt}:${revision}`;
-  const cached = moduleCache.get(toolId);
-  if (cached?.installationKey === installationKey) return cached.module;
-  try {
-    const busted = cacheBustFileImport(importPath, installationKey);
-    const importer = await getScopedImport(revision);
-    const mod = await importer(busted, import.meta.url);
-    moduleCache.set(toolId, { installationKey, module: mod });
-    return mod;
-  } catch (err) {
-    console.error(`[marketplace] Failed to load tool "${toolId}":`, err);
-    return null;
-  }
-}
-async function entryRevision(installed, importPath) {
-  if (installed.source !== "local" || !importPath.startsWith("file:")) return "fixed";
-  try {
-    const directory = path2.dirname(new URL(importPath).pathname);
-    const files = await fs2.readdir(directory, { withFileTypes: true });
-    let newest = 0;
-    let total = 0;
-    for (const file of files) {
-      if (!file.isFile()) continue;
-      const { mtimeMs, size } = await fs2.stat(path2.join(directory, file.name));
-      newest = Math.max(newest, mtimeMs);
-      total += size;
-    }
-    return newest > 0 ? `${newest}-${total}` : "fixed";
-  } catch {
-    return "fixed";
-  }
-}
-function cacheBustFileImport(importPath, installationKey) {
-  if (!importPath.startsWith("file:")) return importPath;
-  const url = new URL(importPath);
-  url.searchParams.set("larkup-installation", installationKey);
-  return url.href;
-}
-async function resolveImportPath(installed) {
-  switch (installed.source) {
-    case "local": {
-      try {
-        await fs2.access(path2.join(installed.resolvedPath, "package.json"));
-        return resolvePackageEntry(installed.resolvedPath);
-      } catch {
-        const workspacePath = await resolveWorkspaceToolPath(installed.packageName);
-        if (workspacePath) return resolvePackageEntry(workspacePath);
-        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-JS5NUNN6.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
-};