helloloop 0.3.1 → 0.7.0

package/src/install_claude.mjs

@@ -0,0 +1,189 @@
+import path from "node:path";
+
+import { ensureDir, fileExists, nowIso, readJson, writeJson } from "./common.mjs";
+import {
+  CLAUDE_MARKETPLACE_NAME,
+  CLAUDE_PLUGIN_KEY,
+  assertPathInside,
+  copyDirectory,
+  removePathIfExists,
+  removeTargetIfNeeded,
+  resolveHomeDir,
+} from "./install_shared.mjs";
+
+function updateClaudeSettings(settingsFile, marketplaceRoot) {
+  const settings = fileExists(settingsFile) ? readJson(settingsFile) : {};
+
+  settings.extraKnownMarketplaces = settings.extraKnownMarketplaces || {};
+  settings.enabledPlugins = settings.enabledPlugins || {};
+  settings.extraKnownMarketplaces[CLAUDE_MARKETPLACE_NAME] = {
+    source: {
+      source: "directory",
+      path: marketplaceRoot,
+    },
+  };
+  settings.enabledPlugins[CLAUDE_PLUGIN_KEY] = true;
+
+  writeJson(settingsFile, settings);
+}
+
+function removeClaudeSettingsEntries(settingsFile) {
+  if (!fileExists(settingsFile)) {
+    return false;
+  }
+
+  const settings = readJson(settingsFile);
+  let changed = false;
+
+  if (settings.extraKnownMarketplaces && Object.hasOwn(settings.extraKnownMarketplaces, CLAUDE_MARKETPLACE_NAME)) {
+    delete settings.extraKnownMarketplaces[CLAUDE_MARKETPLACE_NAME];
+    changed = true;
+  }
+  if (settings.enabledPlugins && Object.hasOwn(settings.enabledPlugins, CLAUDE_PLUGIN_KEY)) {
+    delete settings.enabledPlugins[CLAUDE_PLUGIN_KEY];
+    changed = true;
+  }
+
+  if (changed) {
+    writeJson(settingsFile, settings);
+  }
+  return changed;
+}
+
+function updateClaudeKnownMarketplaces(knownMarketplacesFile, marketplaceRoot, updatedAt) {
+  const knownMarketplaces = fileExists(knownMarketplacesFile) ? readJson(knownMarketplacesFile) : {};
+  knownMarketplaces[CLAUDE_MARKETPLACE_NAME] = {
+    source: {
+      source: "directory",
+      path: marketplaceRoot,
+    },
+    installLocation: marketplaceRoot,
+    lastUpdated: updatedAt,
+  };
+  writeJson(knownMarketplacesFile, knownMarketplaces);
+}
+
+function removeClaudeKnownMarketplace(knownMarketplacesFile) {
+  if (!fileExists(knownMarketplacesFile)) {
+    return false;
+  }
+
+  const knownMarketplaces = readJson(knownMarketplacesFile);
+  if (!Object.hasOwn(knownMarketplaces, CLAUDE_MARKETPLACE_NAME)) {
+    return false;
+  }
+
+  delete knownMarketplaces[CLAUDE_MARKETPLACE_NAME];
+  writeJson(knownMarketplacesFile, knownMarketplaces);
+  return true;
+}
+
+function updateClaudeInstalledPlugins(installedPluginsFile, pluginRoot, pluginVersion, updatedAt) {
+  const installedPlugins = fileExists(installedPluginsFile)
+    ? readJson(installedPluginsFile)
+    : { version: 2, plugins: {} };
+
+  installedPlugins.version = 2;
+  installedPlugins.plugins = installedPlugins.plugins || {};
+  installedPlugins.plugins[CLAUDE_PLUGIN_KEY] = [
+    {
+      scope: "user",
+      installPath: pluginRoot,
+      version: pluginVersion,
+      installedAt: updatedAt,
+      lastUpdated: updatedAt,
+    },
+  ];
+
+  writeJson(installedPluginsFile, installedPlugins);
+}
+
+function removeClaudeInstalledPlugin(installedPluginsFile) {
+  if (!fileExists(installedPluginsFile)) {
+    return false;
+  }
+
+  const installedPlugins = readJson(installedPluginsFile);
+  if (!installedPlugins.plugins || !Object.hasOwn(installedPlugins.plugins, CLAUDE_PLUGIN_KEY)) {
+    return false;
+  }
+
+  delete installedPlugins.plugins[CLAUDE_PLUGIN_KEY];
+  writeJson(installedPluginsFile, installedPlugins);
+  return true;
+}
+
+export function installClaudeHost(bundleRoot, options = {}) {
+  const resolvedClaudeHome = resolveHomeDir(options.claudeHome, ".claude");
+  const sourceMarketplaceRoot = path.join(bundleRoot, "hosts", "claude", "marketplace");
+  const sourceManifest = path.join(bundleRoot, ".claude-plugin", "plugin.json");
+  const pluginVersion = readJson(sourceManifest).version || readJson(path.join(bundleRoot, "package.json")).version;
+  const targetPluginsRoot = path.join(resolvedClaudeHome, "plugins");
+  const targetMarketplaceRoot = path.join(targetPluginsRoot, "marketplaces", CLAUDE_MARKETPLACE_NAME);
+  const targetCachePluginsRoot = path.join(targetPluginsRoot, "cache", CLAUDE_MARKETPLACE_NAME, "helloloop");
+  const targetInstalledPluginRoot = path.join(targetCachePluginsRoot, pluginVersion);
+  const knownMarketplacesFile = path.join(targetPluginsRoot, "known_marketplaces.json");
+  const installedPluginsFile = path.join(targetPluginsRoot, "installed_plugins.json");
+  const settingsFile = path.join(resolvedClaudeHome, "settings.json");
+
+  if (!fileExists(sourceManifest)) {
+    throw new Error(`未找到 Claude 插件 manifest：${sourceManifest}`);
+  }
+  if (!fileExists(path.join(sourceMarketplaceRoot, ".claude-plugin", "marketplace.json"))) {
+    throw new Error(`未找到 Claude marketplace 模板：${sourceMarketplaceRoot}`);
+  }
+
+  assertPathInside(resolvedClaudeHome, targetMarketplaceRoot, "Claude marketplace 目录");
+  assertPathInside(resolvedClaudeHome, targetInstalledPluginRoot, "Claude 插件缓存目录");
+  removeTargetIfNeeded(targetMarketplaceRoot, options.force);
+  removeTargetIfNeeded(targetCachePluginsRoot, options.force);
+
+  ensureDir(targetPluginsRoot);
+  ensureDir(path.dirname(targetMarketplaceRoot));
+  ensureDir(path.dirname(targetInstalledPluginRoot));
+  copyDirectory(sourceMarketplaceRoot, targetMarketplaceRoot);
+  copyDirectory(path.join(sourceMarketplaceRoot, "plugins", "helloloop"), targetInstalledPluginRoot);
+  const updatedAt = nowIso();
+  updateClaudeSettings(settingsFile, targetMarketplaceRoot);
+  updateClaudeKnownMarketplaces(knownMarketplacesFile, targetMarketplaceRoot, updatedAt);
+  updateClaudeInstalledPlugins(installedPluginsFile, targetInstalledPluginRoot, pluginVersion, updatedAt);
+
+  return {
+    host: "claude",
+    displayName: "Claude",
+    targetRoot: targetInstalledPluginRoot,
+    marketplaceFile: path.join(targetMarketplaceRoot, ".claude-plugin", "marketplace.json"),
+    settingsFile,
+  };
+}
+
+export function uninstallClaudeHost(options = {}) {
+  const resolvedClaudeHome = resolveHomeDir(options.claudeHome, ".claude");
+  const targetPluginsRoot = path.join(resolvedClaudeHome, "plugins");
+  const targetMarketplaceRoot = path.join(targetPluginsRoot, "marketplaces", CLAUDE_MARKETPLACE_NAME);
+  const targetCachePluginsRoot = path.join(targetPluginsRoot, "cache", CLAUDE_MARKETPLACE_NAME);
+  const knownMarketplacesFile = path.join(targetPluginsRoot, "known_marketplaces.json");
+  const installedPluginsFile = path.join(targetPluginsRoot, "installed_plugins.json");
+  const settingsFile = path.join(resolvedClaudeHome, "settings.json");
+
+  const removedMarketplaceDir = removePathIfExists(targetMarketplaceRoot);
+  const removedCacheDir = removePathIfExists(targetCachePluginsRoot);
+  const removedKnownMarketplace = removeClaudeKnownMarketplace(knownMarketplacesFile);
+  const removedInstalledPlugin = removeClaudeInstalledPlugin(installedPluginsFile);
+  const removedSettingsEntries = removeClaudeSettingsEntries(settingsFile);
+
+  return {
+    host: "claude",
+    displayName: "Claude",
+    targetRoot: targetCachePluginsRoot,
+    removed: [
+      removedMarketplaceDir,
+      removedCacheDir,
+      removedKnownMarketplace,
+      removedInstalledPlugin,
+      removedSettingsEntries,
+    ].some(Boolean),
+    marketplaceFile: path.join(targetMarketplaceRoot, ".claude-plugin", "marketplace.json"),
+    settingsFile,
+  };
+}

package/src/install_codex.mjs

@@ -0,0 +1,114 @@
+import path from "node:path";
+
+import { ensureDir, fileExists, readJson, writeJson } from "./common.mjs";
+import {
+  assertPathInside,
+  codexBundleEntries,
+  copyBundleEntries,
+  removePathIfExists,
+  removeTargetIfNeeded,
+  resolveHomeDir,
+} from "./install_shared.mjs";
+
+function updateCodexMarketplace(marketplaceFile) {
+  const marketplace = fileExists(marketplaceFile)
+    ? readJson(marketplaceFile)
+    : {
+      name: "local-plugins",
+      interface: {
+        displayName: "Local Plugins",
+      },
+      plugins: [],
+    };
+
+  marketplace.interface = marketplace.interface || {
+    displayName: "Local Plugins",
+  };
+  marketplace.plugins = Array.isArray(marketplace.plugins) ? marketplace.plugins : [];
+
+  const nextEntry = {
+    name: "helloloop",
+    source: {
+      source: "local",
+      path: "./plugins/helloloop",
+    },
+    policy: {
+      installation: "AVAILABLE",
+      authentication: "ON_INSTALL",
+    },
+    category: "Coding",
+  };
+
+  const existingIndex = marketplace.plugins.findIndex((plugin) => plugin?.name === "helloloop");
+  if (existingIndex >= 0) {
+    marketplace.plugins.splice(existingIndex, 1, nextEntry);
+  } else {
+    marketplace.plugins.push(nextEntry);
+  }
+
+  writeJson(marketplaceFile, marketplace);
+}
+
+function removeCodexMarketplaceEntry(marketplaceFile) {
+  if (!fileExists(marketplaceFile)) {
+    return false;
+  }
+
+  const marketplace = readJson(marketplaceFile);
+  const plugins = Array.isArray(marketplace.plugins) ? marketplace.plugins : [];
+  const nextPlugins = plugins.filter((plugin) => plugin?.name !== "helloloop");
+  if (nextPlugins.length === plugins.length) {
+    return false;
+  }
+
+  marketplace.plugins = nextPlugins;
+  writeJson(marketplaceFile, marketplace);
+  return true;
+}
+
+export function installCodexHost(bundleRoot, options = {}) {
+  const resolvedCodexHome = resolveHomeDir(options.codexHome, ".codex");
+  const targetPluginsRoot = path.join(resolvedCodexHome, "plugins");
+  const targetPluginRoot = path.join(targetPluginsRoot, "helloloop");
+  const marketplaceFile = path.join(resolvedCodexHome, ".agents", "plugins", "marketplace.json");
+  const manifestFile = path.join(bundleRoot, ".codex-plugin", "plugin.json");
+
+  if (!fileExists(manifestFile)) {
+    throw new Error(`未找到 Codex 插件 manifest：${manifestFile}`);
+  }
+
+  assertPathInside(resolvedCodexHome, targetPluginRoot, "Codex 目标插件目录");
+  removeTargetIfNeeded(targetPluginRoot, options.force);
+
+  ensureDir(targetPluginsRoot);
+  ensureDir(targetPluginRoot);
+  copyBundleEntries(bundleRoot, targetPluginRoot, codexBundleEntries);
+  removePathIfExists(path.join(targetPluginRoot, ".git"));
+
+  ensureDir(path.dirname(marketplaceFile));
+  updateCodexMarketplace(marketplaceFile);
+
+  return {
+    host: "codex",
+    displayName: "Codex",
+    targetRoot: targetPluginRoot,
+    marketplaceFile,
+  };
+}
+
+export function uninstallCodexHost(options = {}) {
+  const resolvedCodexHome = resolveHomeDir(options.codexHome, ".codex");
+  const targetPluginRoot = path.join(resolvedCodexHome, "plugins", "helloloop");
+  const marketplaceFile = path.join(resolvedCodexHome, ".agents", "plugins", "marketplace.json");
+
+  const removedPlugin = removePathIfExists(targetPluginRoot);
+  const removedMarketplace = removeCodexMarketplaceEntry(marketplaceFile);
+
+  return {
+    host: "codex",
+    displayName: "Codex",
+    targetRoot: targetPluginRoot,
+    removed: removedPlugin || removedMarketplace,
+    marketplaceFile,
+  };
+}

package/src/install_gemini.mjs

@@ -0,0 +1,43 @@
+import path from "node:path";
+
+import { ensureDir, fileExists } from "./common.mjs";
+import {
+  assertPathInside,
+  copyDirectory,
+  removePathIfExists,
+  removeTargetIfNeeded,
+  resolveHomeDir,
+} from "./install_shared.mjs";
+
+export function installGeminiHost(bundleRoot, options = {}) {
+  const resolvedGeminiHome = resolveHomeDir(options.geminiHome, ".gemini");
+  const sourceExtensionRoot = path.join(bundleRoot, "hosts", "gemini", "extension");
+  const targetExtensionRoot = path.join(resolvedGeminiHome, "extensions", "helloloop");
+
+  if (!fileExists(path.join(sourceExtensionRoot, "gemini-extension.json"))) {
+    throw new Error(`未找到 Gemini 扩展清单：${sourceExtensionRoot}`);
+  }
+
+  assertPathInside(resolvedGeminiHome, targetExtensionRoot, "Gemini 扩展目录");
+  removeTargetIfNeeded(targetExtensionRoot, options.force);
+  ensureDir(path.dirname(targetExtensionRoot));
+  copyDirectory(sourceExtensionRoot, targetExtensionRoot);
+
+  return {
+    host: "gemini",
+    displayName: "Gemini",
+    targetRoot: targetExtensionRoot,
+  };
+}
+
+export function uninstallGeminiHost(options = {}) {
+  const resolvedGeminiHome = resolveHomeDir(options.geminiHome, ".gemini");
+  const targetExtensionRoot = path.join(resolvedGeminiHome, "extensions", "helloloop");
+
+  return {
+    host: "gemini",
+    displayName: "Gemini",
+    targetRoot: targetExtensionRoot,
+    removed: removePathIfExists(targetExtensionRoot),
+  };
+}

package/src/install_shared.mjs

@@ -0,0 +1,138 @@
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+
+import { ensureDir, fileExists, readJson, writeJson } from "./common.mjs";
+
+export const runtimeBundleEntries = [
+  ".claude-plugin",
+  ".codex-plugin",
+  "LICENSE",
+  "README.md",
+  "bin",
+  "hosts",
+  "package.json",
+  "scripts",
+  "skills",
+  "src",
+  "templates",
+];
+
+export const codexBundleEntries = runtimeBundleEntries.filter((entry) => ![
+  ".claude-plugin",
+  "hosts",
+].includes(entry));
+
+export const supportedHosts = ["codex", "claude", "gemini"];
+export const CLAUDE_MARKETPLACE_NAME = "helloloop-local";
+export const CLAUDE_PLUGIN_KEY = "helloloop@helloloop-local";
+
+export function resolveHomeDir(homeDir, defaultDirName) {
+  return path.resolve(homeDir || path.join(os.homedir(), defaultDirName));
+}
+
+export function assertPathInside(parentDir, targetDir, label) {
+  const relative = path.relative(parentDir, targetDir);
+  if (!relative || relative.startsWith("..") || path.isAbsolute(relative)) {
+    throw new Error(`${label} 超出允许范围：${targetDir}`);
+  }
+}
+
+function sleepSync(ms) {
+  const shared = new SharedArrayBuffer(4);
+  const view = new Int32Array(shared);
+  Atomics.wait(view, 0, 0, Math.max(0, ms));
+}
+
+function isRetryableRemoveError(error) {
+  const code = String(error?.code || "").toUpperCase();
+  return ["ENOTEMPTY", "EPERM", "EBUSY"].includes(code);
+}
+
+function removeDirectoryWithRetries(targetPath) {
+  const retryDelaysMs = [0, 50, 150, 300];
+  let lastError = null;
+
+  for (const delayMs of retryDelaysMs) {
+    if (delayMs > 0) {
+      sleepSync(delayMs);
+    }
+    try {
+      fs.rmSync(targetPath, { recursive: true, force: true, maxRetries: 3, retryDelay: 100 });
+      return;
+    } catch (error) {
+      lastError = error;
+      if (!isRetryableRemoveError(error)) {
+        throw error;
+      }
+    }
+  }
+
+  const tempPath = `${targetPath}.removing-${Date.now()}`;
+  fs.renameSync(targetPath, tempPath);
+  try {
+    fs.rmSync(tempPath, { recursive: true, force: true, maxRetries: 3, retryDelay: 100 });
+  } catch (error) {
+    throw lastError || error;
+  }
+}
+
+function removeFsPath(targetPath) {
+  const stats = fs.lstatSync(targetPath);
+  if (stats.isDirectory() && !stats.isSymbolicLink()) {
+    removeDirectoryWithRetries(targetPath);
+    return;
+  }
+  fs.rmSync(targetPath, { force: true, recursive: true, maxRetries: 3, retryDelay: 100 });
+}
+
+export function removeTargetIfNeeded(targetPath, force) {
+  if (!fileExists(targetPath)) {
+    return;
+  }
+  if (!force) {
+    throw new Error(`目标目录已存在：${targetPath}。若要覆盖，请追加 --force。`);
+  }
+  removeFsPath(targetPath);
+}
+
+export function removePathIfExists(targetPath) {
+  if (!fileExists(targetPath)) {
+    return false;
+  }
+  removeFsPath(targetPath);
+  return true;
+}
+
+export function copyBundleEntries(bundleRoot, targetRoot, entries) {
+  for (const entry of entries) {
+    const sourcePath = path.join(bundleRoot, entry);
+    if (!fileExists(sourcePath)) {
+      continue;
+    }
+
+    fs.cpSync(sourcePath, path.join(targetRoot, entry), {
+      force: true,
+      recursive: true,
+    });
+  }
+}
+
+export function copyDirectory(sourceRoot, targetRoot) {
+  fs.cpSync(sourceRoot, targetRoot, {
+    force: true,
+    recursive: true,
+  });
+}
+
+export function loadOrInitJson(filePath, fallbackValue) {
+  if (!fileExists(filePath)) {
+    return fallbackValue;
+  }
+  return readJson(filePath);
+}
+
+export function writeJsonFile(filePath, value) {
+  ensureDir(path.dirname(filePath));
+  writeJson(filePath, value);
+}