@looplia/looplia-cli 0.6.10 → 0.7.0

package/dist/chunk-IVTVHH75.js

@@ -0,0 +1,523 @@
+#!/usr/bin/env node
+import {
+  __dirname2 as __dirname,
+  isValidGitUrl,
+  pathExists
+} from "./chunk-FCL2HRTX.js";
+
+// ../../packages/provider/dist/chunk-FBJ3JTGZ.js
+import { exec } from "child_process";
+import { cp as cp2, mkdir as mkdir2, readdir as readdir2, readFile as readFile2, rm as rm2, writeFile as writeFile2 } from "fs/promises";
+import { homedir as homedir2, tmpdir as tmpdir2 } from "os";
+import { basename, join as join2 } from "path";
+import { promisify } from "util";
+import { createHash } from "crypto";
+import {
+  cp,
+  mkdir,
+  readdir,
+  readFile,
+  realpath,
+  rm,
+  writeFile
+} from "fs/promises";
+import { homedir, tmpdir } from "os";
+import { dirname, join } from "path";
+import { fileURLToPath } from "url";
+async function computeSha256(filePath) {
+  const content = await readFile(filePath);
+  return createHash("sha256").update(content).digest("hex");
+}
+async function validateExtractedPaths(baseDir) {
+  const realBase = await realpath(baseDir);
+  const entries = await readdir(baseDir, { withFileTypes: true });
+  for (const entry of entries) {
+    const fullPath = join(baseDir, entry.name);
+    const entryRealPath = await realpath(fullPath);
+    if (!entryRealPath.startsWith(realBase)) {
+      throw new Error(
+        `Security: Path traversal detected in extracted file: ${entry.name}`
+      );
+    }
+    if (entry.isDirectory()) {
+      await validateExtractedPaths(fullPath);
+    }
+  }
+}
+function getLoopliaPluginPath() {
+  return process.env.LOOPLIA_HOME ?? join(homedir(), ".looplia");
+}
+function getBundledPluginsPath() {
+  const currentFile = typeof __dirname !== "undefined" ? __dirname : dirname(fileURLToPath(import.meta.url));
+  return join(currentFile, "..", "..", "plugins");
+}
+async function parseMarketplace(marketplacePath) {
+  const content = await readFile(marketplacePath, "utf-8");
+  return JSON.parse(content);
+}
+async function getPluginNamesFromSource(bundledPath) {
+  const marketplacePath = join(
+    bundledPath,
+    "..",
+    ".claude-plugin",
+    "marketplace.json"
+  );
+  if (await pathExists(marketplacePath)) {
+    const marketplace = await parseMarketplace(marketplacePath);
+    return marketplace.plugins.map((p) => {
+      const parts = p.source.split("/");
+      return parts.at(-1);
+    }).filter((name) => name !== void 0);
+  }
+  const entries = await readdir(bundledPath, { withFileTypes: true });
+  return entries.filter((e) => e.isDirectory() && !e.name.startsWith(".")).map((e) => e.name);
+}
+function createDefaultProfile() {
+  return {
+    userId: "default",
+    topics: [],
+    style: {
+      tone: "intermediate",
+      targetWordCount: 1e3,
+      voice: "first-person"
+    }
+  };
+}
+async function extractWorkflows(targetDir, pluginNames) {
+  const workflowsDir = join(targetDir, "workflows");
+  await mkdir(workflowsDir, { recursive: true });
+  for (const pluginName of pluginNames) {
+    const pluginWorkflowsPath = join(targetDir, pluginName, "workflows");
+    if (!await pathExists(pluginWorkflowsPath)) {
+      continue;
+    }
+    const entries = await readdir(pluginWorkflowsPath, { withFileTypes: true });
+    for (const entry of entries) {
+      if (entry.isFile() && entry.name.endsWith(".md")) {
+        await cp(
+          join(pluginWorkflowsPath, entry.name),
+          join(workflowsDir, entry.name)
+        );
+      }
+    }
+    await rm(pluginWorkflowsPath, { recursive: true, force: true });
+  }
+}
+async function copyPlugins(targetDir, sourcePath) {
+  const bundledPath = sourcePath ?? getBundledPluginsPath();
+  const pluginNames = await getPluginNamesFromSource(bundledPath);
+  if (pluginNames.length === 0) {
+    throw new Error(`No plugins found at ${bundledPath}`);
+  }
+  if (await pathExists(targetDir)) {
+    await rm(targetDir, { recursive: true, force: true });
+  }
+  await mkdir(targetDir, { recursive: true });
+  for (const pluginName of pluginNames) {
+    const pluginPath = join(bundledPath, pluginName);
+    if (await pathExists(pluginPath)) {
+      await cp(pluginPath, join(targetDir, pluginName), { recursive: true });
+    }
+  }
+  await extractWorkflows(targetDir, pluginNames);
+  await mkdir(join(targetDir, "sandbox"), { recursive: true });
+  await writeFile(
+    join(targetDir, "user-profile.json"),
+    JSON.stringify(createDefaultProfile(), null, 2),
+    "utf-8"
+  );
+  const { installDefaultSources: installDefaultSources2 } = await import("./skill-installer-GJYXIKXE-VS4MWW3V.js");
+  const installResults = await installDefaultSources2();
+  for (const result of installResults) {
+    if (result.status === "failed") {
+      console.warn(
+        `Warning: Failed to download ${result.skill}: ${result.error}`
+      );
+    }
+  }
+  const { compileRegistry } = await import("./compiler-J4DARL4X-2TXNVYEY.js");
+  await compileRegistry();
+}
+async function downloadRemotePlugins(version, targetDir) {
+  const releaseUrl = version === "latest" ? "https://github.com/memorysaver/looplia-core/releases/latest/download/plugins.tar.gz" : `https://github.com/memorysaver/looplia-core/releases/download/${version}/plugins.tar.gz`;
+  console.log(`Downloading looplia plugins from ${releaseUrl}...`);
+  const tempDir = join(tmpdir(), `looplia-download-${Date.now()}`);
+  await mkdir(tempDir, { recursive: true });
+  try {
+    const response = await fetch(releaseUrl);
+    if (!response.ok) {
+      throw new Error(
+        `Failed to download plugins: ${response.status} ${response.statusText}`
+      );
+    }
+    const tarPath = join(tempDir, "plugins.tar.gz");
+    await writeFile(tarPath, Buffer.from(await response.arrayBuffer()));
+    const checksumUrl = `${releaseUrl}.sha256`;
+    const checksumResponse = await fetch(checksumUrl);
+    if (checksumResponse.ok) {
+      const checksumText = await checksumResponse.text();
+      const checksumParts = checksumText.split(" ");
+      const expectedChecksum = checksumParts[0]?.trim();
+      if (!expectedChecksum) {
+        throw new Error("Invalid checksum file format");
+      }
+      const actualChecksum = await computeSha256(tarPath);
+      if (actualChecksum !== expectedChecksum) {
+        throw new Error(
+          `Checksum verification failed. Expected: ${expectedChecksum}, Got: ${actualChecksum}`
+        );
+      }
+      console.log("\u2713 Checksum verified");
+    } else {
+      console.log(
+        "\u26A0 Checksum file not available (older release), skipping verification"
+      );
+    }
+    const { exec: exec2 } = await import("child_process");
+    const { promisify: promisify2 } = await import("util");
+    const execAsync2 = promisify2(exec2);
+    try {
+      await execAsync2("tar -xzf plugins.tar.gz", { cwd: tempDir });
+    } catch (error) {
+      const errorMessage = error instanceof Error ? error.message : String(error);
+      throw new Error(
+        `Failed to extract plugins tarball. Ensure 'tar' is available. Error: ${errorMessage}`
+      );
+    }
+    await rm(tarPath);
+    await validateExtractedPaths(tempDir);
+    await copyPlugins(targetDir, tempDir);
+    console.log(`Plugins downloaded and extracted to ${targetDir}`);
+  } finally {
+    await rm(tempDir, { recursive: true, force: true }).catch(() => {
+    });
+  }
+}
+async function isLoopliaInitialized() {
+  const pluginPath = getLoopliaPluginPath();
+  try {
+    const entries = await readdir(pluginPath, { withFileTypes: true });
+    return entries.some(
+      (e) => e.isDirectory() && !e.name.startsWith(".") && e.name !== "sandbox" && e.name !== "workflows"
+    );
+  } catch {
+    return false;
+  }
+}
+function getDevPluginPaths(projectRoot) {
+  return [
+    { type: "local", path: join(projectRoot, "plugins", "looplia-core") },
+    { type: "local", path: join(projectRoot, "plugins", "looplia-writer") }
+  ];
+}
+async function getProdPluginPaths() {
+  const loopliaPath = getLoopliaPluginPath();
+  const results = [];
+  try {
+    const entries = await readdir(loopliaPath, { withFileTypes: true });
+    const pluginDirs = entries.filter(
+      (e) => e.isDirectory() && !e.name.startsWith(".") && e.name !== "sandbox" && e.name !== "workflows" && e.name !== "plugins" && e.name !== "registry"
+    ).map((e) => e.name);
+    for (const name of pluginDirs) {
+      results.push({ type: "local", path: join(loopliaPath, name) });
+    }
+  } catch {
+  }
+  const pluginsDir = join(loopliaPath, "plugins");
+  try {
+    const entries = await readdir(pluginsDir, { withFileTypes: true });
+    const thirdPartyDirs = entries.filter((e) => e.isDirectory() && !e.name.startsWith(".")).map((e) => e.name);
+    for (const name of thirdPartyDirs) {
+      results.push({ type: "local", path: join(pluginsDir, name) });
+    }
+  } catch {
+  }
+  return results;
+}
+async function getPluginPaths() {
+  if (process.env.LOOPLIA_HOME) {
+    return await getProdPluginPaths();
+  }
+  if (process.env.LOOPLIA_DEV === "true") {
+    const devRoot = process.env.LOOPLIA_DEV_ROOT ?? process.cwd();
+    return getDevPluginPaths(devRoot);
+  }
+  return await getProdPluginPaths();
+}
+var DEFAULT_SOURCES = [
+  {
+    name: "anthropic-skills",
+    url: "https://github.com/anthropics/skills",
+    description: "Official Anthropic skills - xlsx, pdf, pptx, docx, frontend-design, and more"
+  },
+  {
+    name: "awesome-claude-skills",
+    url: "https://github.com/ComposioHQ/awesome-claude-skills",
+    description: "Community-curated Claude skills collection by ComposioHQ"
+  }
+];
+var execAsync = promisify(exec);
+var PROTOCOL_REGEX = /^https?:\/\//;
+var TRAILING_SLASH_REGEX = /\/$/;
+var SLASH_TO_DASH_REGEX = /\//g;
+var CORE_SKILLS = [
+  "workflow-executor",
+  "workflow-executor-inline",
+  "workflow-validator",
+  "registry-loader"
+];
+async function buildSkillPluginMap(pluginPaths) {
+  const map = /* @__PURE__ */ new Map();
+  for (const { path: pluginPath } of pluginPaths) {
+    const skillsDir = join2(pluginPath, "skills");
+    if (!await pathExists(skillsDir)) {
+      continue;
+    }
+    try {
+      const entries = await readdir2(skillsDir, { withFileTypes: true });
+      for (const entry of entries) {
+        if (entry.isDirectory()) {
+          map.set(entry.name, pluginPath);
+        }
+      }
+    } catch {
+    }
+  }
+  return map;
+}
+async function getSelectivePluginPaths(requiredSkills) {
+  const allPluginPaths = await getPluginPaths();
+  if (!requiredSkills || requiredSkills.length === 0) {
+    return allPluginPaths;
+  }
+  const neededSkills = /* @__PURE__ */ new Set([...CORE_SKILLS, ...requiredSkills]);
+  const skillToPlugin = await buildSkillPluginMap(allPluginPaths);
+  const pluginsToLoad = /* @__PURE__ */ new Set();
+  for (const skill of neededSkills) {
+    const pluginPath = skillToPlugin.get(skill);
+    if (pluginPath) {
+      pluginsToLoad.add(pluginPath);
+    }
+  }
+  return allPluginPaths.filter((p) => pluginsToLoad.has(p.path));
+}
+async function installThirdPartyPlugin(gitUrl, skillName) {
+  const loopliaPath = join2(homedir2(), ".looplia");
+  const pluginsDir = join2(loopliaPath, "plugins");
+  await mkdir2(pluginsDir, { recursive: true });
+  const repoName = gitUrl.replace(PROTOCOL_REGEX, "").replace("github.com/", "").replace(TRAILING_SLASH_REGEX, "").replace(SLASH_TO_DASH_REGEX, "-");
+  const targetPath = join2(pluginsDir, repoName);
+  try {
+    if (await pathExists(targetPath)) {
+      await execAsync("git pull", { cwd: targetPath });
+      return {
+        skill: skillName ?? repoName,
+        status: "updated",
+        path: targetPath
+      };
+    }
+    const fullUrl = gitUrl.startsWith("http") ? gitUrl : `https://${gitUrl}`;
+    if (!isValidGitUrl(fullUrl)) {
+      return {
+        skill: skillName ?? repoName,
+        status: "failed",
+        error: `Invalid or untrusted git URL: ${fullUrl}`
+      };
+    }
+    await execAsync(`git clone "${fullUrl}" "${targetPath}"`);
+    return {
+      skill: skillName ?? repoName,
+      status: "installed",
+      path: targetPath
+    };
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    return {
+      skill: skillName ?? repoName,
+      status: "failed",
+      error: message
+    };
+  }
+}
+function isCoreSkill(skillName) {
+  return CORE_SKILLS.includes(skillName);
+}
+async function getPluginSkills(pluginPath) {
+  const skillsDir = join2(pluginPath, "skills");
+  if (!await pathExists(skillsDir)) {
+    return [];
+  }
+  try {
+    const entries = await readdir2(skillsDir, { withFileTypes: true });
+    return entries.filter((e) => e.isDirectory()).map((e) => e.name);
+  } catch {
+    return [];
+  }
+}
+async function createPluginStructure(opts) {
+  const { pluginDir, plugin, marketplace } = opts;
+  await mkdir2(join2(pluginDir, ".claude-plugin"), { recursive: true });
+  await mkdir2(join2(pluginDir, "skills"), { recursive: true });
+  const pluginJson = {
+    name: plugin.name,
+    description: plugin.description,
+    source: { marketplace: marketplace.name, url: marketplace.url }
+  };
+  await writeFile2(
+    join2(pluginDir, ".claude-plugin", "plugin.json"),
+    JSON.stringify(pluginJson, null, 2)
+  );
+}
+async function copyPluginSkills(plugin, tempDir, pluginDir) {
+  if (plugin.skills?.length) {
+    for (const skillPath of plugin.skills) {
+      const skillName = basename(skillPath);
+      const srcPath = join2(tempDir, skillPath);
+      const destPath = join2(pluginDir, "skills", skillName);
+      if (await pathExists(srcPath)) {
+        await cp2(srcPath, destPath, { recursive: true });
+      }
+    }
+  } else {
+    const srcPath = join2(tempDir, plugin.source);
+    const destPath = join2(pluginDir, "skills", plugin.name);
+    if (await pathExists(srcPath)) {
+      await cp2(srcPath, destPath, { recursive: true });
+    }
+  }
+}
+async function installMarketplacePlugin(opts) {
+  const { plugin, tempDir, pluginsDir, marketplace } = opts;
+  const pluginDir = join2(pluginsDir, plugin.name);
+  try {
+    await createPluginStructure({ pluginDir, plugin, marketplace });
+    await copyPluginSkills(plugin, tempDir, pluginDir);
+    return { skill: plugin.name, status: "installed", path: pluginDir };
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    return { skill: plugin.name, status: "failed", error: message };
+  }
+}
+async function installMarketplaceSource(source, tempDir, pluginsDir) {
+  const marketplacePath = join2(tempDir, ".claude-plugin", "marketplace.json");
+  if (!await pathExists(marketplacePath)) {
+    return [];
+  }
+  const marketplaceContent = await readFile2(marketplacePath, "utf-8");
+  const manifest = JSON.parse(marketplaceContent);
+  const marketplace = { name: manifest.name, url: source.url };
+  const results = [];
+  for (const plugin of manifest.plugins) {
+    const result = await installMarketplacePlugin({
+      plugin,
+      tempDir,
+      pluginsDir,
+      marketplace
+    });
+    results.push(result);
+  }
+  return results;
+}
+async function installDefaultSources() {
+  const loopliaPath = process.env.LOOPLIA_HOME ?? join2(homedir2(), ".looplia");
+  const pluginsDir = join2(loopliaPath, "plugins");
+  const registryDir = join2(loopliaPath, "registry");
+  await mkdir2(pluginsDir, { recursive: true });
+  await mkdir2(registryDir, { recursive: true });
+  const installPromises = DEFAULT_SOURCES.map(
+    async (source) => {
+      const tempDir = join2(tmpdir2(), `looplia-${source.name}-${Date.now()}`);
+      try {
+        if (!isValidGitUrl(source.url)) {
+          return {
+            results: [
+              {
+                skill: source.name,
+                status: "failed",
+                error: `Invalid or untrusted git URL: ${source.url}`
+              }
+            ]
+          };
+        }
+        await execAsync(`git clone --depth 1 "${source.url}" "${tempDir}"`);
+        const marketplacePath = join2(
+          tempDir,
+          ".claude-plugin",
+          "marketplace.json"
+        );
+        const hasMarketplace = await pathExists(marketplacePath);
+        let installResults2;
+        if (hasMarketplace) {
+          installResults2 = await installMarketplaceSource(
+            source,
+            tempDir,
+            pluginsDir
+          );
+        } else {
+          const targetPath = join2(pluginsDir, source.name);
+          await cp2(tempDir, targetPath, { recursive: true });
+          installResults2 = [
+            {
+              skill: source.name,
+              status: "installed",
+              path: targetPath
+            }
+          ];
+        }
+        return {
+          results: installResults2,
+          sourceEntry: {
+            id: `github:${source.name}`,
+            type: "github",
+            url: source.url,
+            enabled: true,
+            priority: 50,
+            addedAt: (/* @__PURE__ */ new Date()).toISOString()
+          }
+        };
+      } catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        return {
+          results: [
+            {
+              skill: source.name,
+              status: "failed",
+              error: message
+            }
+          ]
+        };
+      } finally {
+        await rm2(tempDir, { recursive: true, force: true }).catch(() => {
+        });
+      }
+    }
+  );
+  const installResults = await Promise.all(installPromises);
+  const results = [];
+  const sourceEntries = [];
+  for (const { results: pluginResults, sourceEntry } of installResults) {
+    results.push(...pluginResults);
+    if (sourceEntry) {
+      sourceEntries.push(sourceEntry);
+    }
+  }
+  if (sourceEntries.length > 0) {
+    const sourcesPath = join2(registryDir, "sources.json");
+    await writeFile2(sourcesPath, JSON.stringify(sourceEntries, null, 2));
+  }
+  return results;
+}
+
+export {
+  getLoopliaPluginPath,
+  copyPlugins,
+  downloadRemotePlugins,
+  isLoopliaInitialized,
+  getPluginPaths,
+  CORE_SKILLS,
+  getSelectivePluginPaths,
+  installThirdPartyPlugin,
+  isCoreSkill,
+  getPluginSkills,
+  installDefaultSources
+};