opencode-marketplace 0.3.1 → 0.4.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "opencode-marketplace",
-  "version": "0.3.1",
+  "version": "0.4.0",
   "description": "CLI marketplace for OpenCode plugins",
   "type": "module",
   "author": "nikiforovall",

package/src/cli.ts

@@ -1,5 +1,6 @@
 import { cac } from "cac";
 import { version } from "../package.json";
+import { importPlugins } from "./commands/import";
 import { install } from "./commands/install";
 import { list } from "./commands/list";
 import { scan } from "./commands/scan";
@@ -12,14 +13,36 @@ export function run(argv = process.argv) {
   cli
     .command("install <path>", "Install a plugin from a local directory or GitHub URL")
     .option("--scope <scope>", "Installation scope (user/project)", { default: "user" })
+    .option(
+      "--target-dir <dir>",
+      "Custom installation directory (overrides default scope directory)",
+    )
     .option("--force", "Overwrite existing components", { default: false })
     .option("-i, --interactive", "Interactively select components to install", { default: false })
-    .action((path, options) => {
+    .action(async (path, options) => {
       if (options.scope !== "user" && options.scope !== "project") {
         console.error(`Invalid scope: ${options.scope}. Must be 'user' or 'project'.`);
         process.exit(1);
       }
-      return install(path, options);
+
+      try {
+        await install(path, options);
+      } catch (error) {
+        if (error instanceof Error) {
+          console.error(`\nError: ${error.message}`);
+        } else {
+          console.error("\nUnknown error occurred during installation");
+        }
+        process.exit(1);
+      }
+    });
+
+  cli
+    .command("import [config-path]", "Install plugins from import config file")
+    .option("--target-dir <dir>", "Custom installation directory (overrides ~/.config/opencode)")
+    .option("--force", "Overwrite existing components", { default: false })
+    .action((configPath, options) => {
+      return importPlugins(configPath, options);
     });
 
   cli
@@ -67,14 +90,15 @@ export function run(argv = process.argv) {
   cli.help();
   cli.version(version);
 
-  try {
-    const parsed = cli.parse(argv);
+  // Show help when no command is provided (just "opencode-marketplace")
+  // argv.length is 2 when only executable is run (process.argv includes [node, script])
+  if (argv.length <= 2) {
+    cli.outputHelp();
+    process.exit(0);
+  }
 
-    // Show help when no command is provided
-    if (!parsed.args.length && !parsed.options.help && !parsed.options.version) {
-      cli.outputHelp();
-      process.exit(0);
-    }
+  try {
+    cli.parse(argv);
   } catch (error) {
     if (error instanceof Error && error.message.includes("missing required args")) {
       console.error(error.message);

package/src/commands/import.ts

@@ -0,0 +1,69 @@
+import { getDefaultImportConfigPath, loadImportConfig } from "../import-config";
+import { install } from "./install";
+
+export interface ImportOptions {
+  targetDir?: string;
+  force: boolean;
+  verbose?: boolean;
+}
+
+export async function importPlugins(configPath: string | undefined, options: ImportOptions) {
+  const { targetDir, force, verbose } = options;
+  const actualConfigPath = configPath || getDefaultImportConfigPath();
+
+  try {
+    console.log(`Importing plugins from ${actualConfigPath}...\n`);
+
+    const config = await loadImportConfig(actualConfigPath);
+
+    if (config.plugins.length === 0) {
+      console.log("No plugins found in configuration.");
+      return;
+    }
+
+    const results = {
+      installed: 0,
+      updated: 0,
+      skipped: 0,
+      failed: 0,
+    };
+
+    for (let i = 0; i < config.plugins.length; i++) {
+      const source = config.plugins[i];
+      const displayNum = `[${i + 1}/${config.plugins.length}]`;
+
+      console.log(`${displayNum} ${source}`);
+
+      try {
+        const result = await install(source, {
+          scope: "user",
+          force,
+          verbose,
+          skipIfSameHash: true,
+          targetDir,
+        });
+
+        if (result.status === "installed") results.installed++;
+        else if (result.status === "updated") results.updated++;
+        else if (result.status === "skipped") results.skipped++;
+      } catch (error) {
+        results.failed++;
+        console.error(`  Error: ${error instanceof Error ? error.message : String(error)}`);
+      }
+      console.log(""); // Empty line between plugins
+    }
+
+    console.log("Import complete:");
+    console.log(`  Installed: ${results.installed}`);
+    console.log(`  Updated:   ${results.updated}`);
+    console.log(`  Skipped:   ${results.skipped}`);
+    console.log(`  Failed:    ${results.failed}`);
+
+    if (results.failed > 0) {
+      process.exit(1);
+    }
+  } catch (error) {
+    console.error(`Error: ${error instanceof Error ? error.message : String(error)}`);
+    process.exit(1);
+  }
+}

package/src/commands/install.ts

@@ -21,6 +21,8 @@ export interface InstallOptions {
   force: boolean;
   verbose?: boolean;
   interactive?: boolean;
+  skipIfSameHash?: boolean;
+  targetDir?: string;
 }
 
 interface ConflictInfo {
@@ -29,10 +31,16 @@ interface ConflictInfo {
   conflictingPlugin: string | null; // null = untracked file
 }
 
-export async function install(path: string, options: InstallOptions) {
-  const { scope, force, verbose, interactive } = options;
+export interface InstallResult {
+  status: "installed" | "updated" | "skipped";
+  pluginName: string;
+}
+
+export async function install(path: string, options: InstallOptions): Promise<InstallResult> {
+  const { scope, force, verbose, interactive, skipIfSameHash, targetDir } = options;
 
   let tempDir: string | null = null;
+
   let pluginSource: PluginSource;
 
   try {
@@ -110,7 +118,7 @@ export async function install(path: string, options: InstallOptions) {
           if (tempDir) {
             await cleanup(tempDir);
           }
-          return;
+          return { status: "skipped", pluginName: "" };
         }
 
         if (result.selected.length === 0) {
@@ -118,7 +126,7 @@ export async function install(path: string, options: InstallOptions) {
           if (tempDir) {
             await cleanup(tempDir);
           }
-          return;
+          return { status: "skipped", pluginName: "" };
         }
 
         componentsToInstall = result.selected;
@@ -128,7 +136,7 @@ export async function install(path: string, options: InstallOptions) {
           if (tempDir) {
             await cleanup(tempDir);
           }
-          return;
+          return { status: "skipped", pluginName: "" };
         }
         throw error;
       }
@@ -151,14 +159,25 @@ export async function install(path: string, options: InstallOptions) {
     console.log(`Installing ${pluginName} [${shortHash}]...`);
 
     // Step 5: Check for existing installation
-    const existingPlugin = await getInstalledPlugin(pluginName, scope);
+    const existingPlugin = await getInstalledPlugin(pluginName, scope, targetDir);
+    let installStatus: "installed" | "updated" | "skipped" = "installed";
 
     if (existingPlugin) {
       if (existingPlugin.hash === pluginHash) {
+        if (skipIfSameHash) {
+          if (verbose) {
+            console.log(`[VERBOSE] Skipping ${pluginName} (already up to date)`);
+          }
+          if (tempDir) {
+            await cleanup(tempDir);
+          }
+          return { status: "skipped", pluginName };
+        }
         // Same plugin, same hash - reinstall
         if (verbose) {
           console.log(`[VERBOSE] Reinstalling existing plugin (same hash)`);
         }
+        installStatus = "installed";
       } else {
         // Same plugin, different hash - update
         if (verbose) {
@@ -166,11 +185,12 @@ export async function install(path: string, options: InstallOptions) {
             `[VERBOSE] Updating plugin from [${existingPlugin.hash.substring(0, 8)}] to [${shortHash}]`,
           );
         }
+        installStatus = "updated";
       }
     }
 
     // Step 6: Detect conflicts
-    const conflicts = await detectConflicts(componentsToInstall, pluginName, scope);
+    const conflicts = await detectConflicts(componentsToInstall, pluginName, scope, targetDir);
 
     if (conflicts.length > 0 && !force) {
       console.error("\nConflict detected:");
@@ -194,7 +214,7 @@ export async function install(path: string, options: InstallOptions) {
     }
 
     // Step 7: Ensure target directories exist
-    await ensureComponentDirsExist(scope);
+    await ensureComponentDirsExist(scope, targetDir);
 
     // Step 8: Copy components
     const installedComponents = {
@@ -207,7 +227,13 @@ export async function install(path: string, options: InstallOptions) {
     const sortedComponents = [...componentsToInstall].sort((a, b) => a.name.localeCompare(b.name));
 
     for (const component of sortedComponents) {
-      const targetPath = getComponentTargetPath(pluginName, component.name, component.type, scope);
+      const targetPath = getComponentTargetPath(
+        pluginName,
+        component.name,
+        component.type,
+        scope,
+        targetDir,
+      );
 
       // Remove trailing slash for copying
       const normalizedTarget = targetPath.endsWith("/") ? targetPath.slice(0, -1) : targetPath;
@@ -233,7 +259,7 @@ export async function install(path: string, options: InstallOptions) {
     }
 
     // Step 9: Update registry
-    const registry = await loadRegistry(scope);
+    const registry = await loadRegistry(scope, targetDir);
 
     const newPlugin: InstalledPlugin = {
       name: pluginName,
@@ -245,7 +271,7 @@ export async function install(path: string, options: InstallOptions) {
     };
 
     registry.plugins[pluginName] = newPlugin;
-    await saveRegistry(registry, scope);
+    await saveRegistry(registry, scope, targetDir);
 
     // Step 10: Cleanup temp directory if remote installation
     if (tempDir) {
@@ -254,19 +280,18 @@ export async function install(path: string, options: InstallOptions) {
 
     // Step 11: Print success message
     const componentCounts = formatComponentCount(installedComponents);
-    console.log(`\nInstalled ${pluginName} (${componentCounts}) to ${scope} scope.`);
+    const locationMsg = targetDir ? `to ${targetDir}` : `to ${scope} scope`;
+    console.log(`\nInstalled ${pluginName} (${componentCounts}) ${locationMsg}.`);
+
+    return { status: installStatus, pluginName };
   } catch (error) {
     // Cleanup temp directory on error
     if (tempDir) {
       await cleanup(tempDir);
     }
 
-    if (error instanceof Error) {
-      console.error(`\nError: ${error.message}`);
-    } else {
-      console.error("\nUnknown error occurred during installation");
-    }
-    process.exit(1);
+    // Re-throw the error to let the caller handle it
+    throw error;
   }
 }
 
@@ -280,12 +305,19 @@ async function detectConflicts(
   components: DiscoveredComponent[],
   pluginName: string,
   scope: Scope,
+  targetDir?: string,
 ): Promise<ConflictInfo[]> {
   const conflicts: ConflictInfo[] = [];
-  const registry = await loadRegistry(scope);
+  const registry = await loadRegistry(scope, targetDir);
 
   for (const component of components) {
-    const targetPath = getComponentTargetPath(pluginName, component.name, component.type, scope);
+    const targetPath = getComponentTargetPath(
+      pluginName,
+      component.name,
+      component.type,
+      scope,
+      targetDir,
+    );
 
     // Remove trailing slash for existence check
     const normalizedTarget = targetPath.endsWith("/") ? targetPath.slice(0, -1) : targetPath;

package/src/import-config.ts

@@ -0,0 +1,70 @@
+import { existsSync } from "node:fs";
+import { readFile } from "node:fs/promises";
+import { homedir } from "node:os";
+import { dirname, isAbsolute, join, resolve } from "node:path";
+import { isGitHubUrl } from "./github";
+import type { ImportConfig } from "./types";
+
+/**
+ * Returns the default import config path: ~/.config/opencode/ocm-import.json
+ */
+export function getDefaultImportConfigPath(): string {
+  return join(homedir(), ".config", "opencode", "ocm-import.json");
+}
+
+/**
+ * Loads and validates the import configuration file.
+ *
+ * @param configPath Path to the config file
+ * @returns Parsed and validated ImportConfig
+ * @throws Error if file not found, invalid JSON, or invalid schema
+ */
+export async function loadImportConfig(configPath: string): Promise<ImportConfig> {
+  const absolutePath = resolve(configPath);
+
+  if (!existsSync(absolutePath)) {
+    throw new Error(`Import configuration file not found: ${configPath}`);
+  }
+
+  const content = await readFile(absolutePath, "utf-8");
+  let config: unknown;
+
+  try {
+    config = JSON.parse(content);
+  } catch (error) {
+    throw new Error(
+      `Failed to parse import configuration (invalid JSON): ${error instanceof Error ? error.message : String(error)}`,
+    );
+  }
+
+  // Validation
+  if (!config || typeof config !== "object") {
+    throw new Error("Invalid import configuration: expected an object");
+  }
+
+  if (!("plugins" in config) || !Array.isArray(config.plugins)) {
+    throw new Error("Invalid import configuration: 'plugins' must be an array");
+  }
+
+  // Resolve relative paths
+  const configDir = dirname(absolutePath);
+  const plugins: string[] = [];
+
+  for (let i = 0; i < config.plugins.length; i++) {
+    const source = config.plugins[i];
+    if (typeof source !== "string" || source.trim() === "") {
+      throw new Error(`Invalid import configuration: 'plugins[${i}]' must be a non-empty string`);
+    }
+
+    const trimmedSource = source.trim();
+
+    // Resolve relative paths for local sources (not GitHub URLs and not absolute paths)
+    if (!isGitHubUrl(trimmedSource) && !isAbsolute(trimmedSource)) {
+      plugins.push(resolve(configDir, trimmedSource));
+    } else {
+      plugins.push(trimmedSource);
+    }
+  }
+
+  return { plugins };
+}

package/src/paths.ts

@@ -10,10 +10,10 @@ import { getComponentTargetName } from "./types";
  *   - User scope: "~/.config/opencode/command/"
  *   - Project scope: ".opencode/command/"
  */
-export function getComponentDir(type: ComponentType, scope: Scope): string {
+export function getComponentDir(type: ComponentType, scope: Scope, targetDir?: string): string {
   const basePath =
     scope === "user"
-      ? join(homedir(), ".config", "opencode", type)
+      ? join(targetDir || join(homedir(), ".config", "opencode"), type)
       : join(process.cwd(), ".opencode", type);
 
   return `${normalize(basePath)}/`;
@@ -32,8 +32,9 @@ export function getComponentTargetPath(
   componentName: string,
   type: ComponentType,
   scope: Scope,
+  targetDir?: string,
 ): string {
-  const baseDir = getComponentDir(type, scope);
+  const baseDir = getComponentDir(type, scope, targetDir);
   const targetName = getComponentTargetName(pluginName, componentName);
   const fullPath = join(baseDir, targetName);
 
@@ -49,8 +50,10 @@ export function getComponentTargetPath(
  * Ensures all component directories (command, agent, skill) exist for the given scope.
  * Idempotent - safe to call multiple times.
  */
-export async function ensureComponentDirsExist(scope: Scope): Promise<void> {
+export async function ensureComponentDirsExist(scope: Scope, targetDir?: string): Promise<void> {
   const dirs: ComponentType[] = ["command", "agent", "skill"];
 
-  await Promise.all(dirs.map((type) => mkdir(getComponentDir(type, scope), { recursive: true })));
+  await Promise.all(
+    dirs.map((type) => mkdir(getComponentDir(type, scope, targetDir), { recursive: true })),
+  );
 }

package/src/registry.ts

@@ -7,9 +7,10 @@ import type { InstalledPlugin, PluginRegistry, Scope } from "./types";
 /**
  * Returns the path to the registry file for the given scope.
  */
-export function getRegistryPath(scope: Scope): string {
+export function getRegistryPath(scope: Scope, targetDir?: string): string {
   if (scope === "user") {
-    return join(homedir(), ".config", "opencode", "plugins", "installed.json");
+    const base = targetDir || join(homedir(), ".config", "opencode");
+    return join(base, "plugins", "installed.json");
   }
   // project scope
   return join(process.cwd(), ".opencode", "plugins", "installed.json");
@@ -19,8 +20,8 @@ export function getRegistryPath(scope: Scope): string {
  * Loads the plugin registry for the given scope.
  * Returns an empty registry if the file does not exist.
  */
-export async function loadRegistry(scope: Scope): Promise<PluginRegistry> {
-  const path = getRegistryPath(scope);
+export async function loadRegistry(scope: Scope, targetDir?: string): Promise<PluginRegistry> {
+  const path = getRegistryPath(scope, targetDir);
 
   if (!existsSync(path)) {
     return { version: 2, plugins: {} };
@@ -47,8 +48,12 @@ export async function loadRegistry(scope: Scope): Promise<PluginRegistry> {
  * Saves the plugin registry for the given scope.
  * Uses atomic write pattern.
  */
-export async function saveRegistry(registry: PluginRegistry, scope: Scope): Promise<void> {
-  const path = getRegistryPath(scope);
+export async function saveRegistry(
+  registry: PluginRegistry,
+  scope: Scope,
+  targetDir?: string,
+): Promise<void> {
+  const path = getRegistryPath(scope, targetDir);
   const dir = join(path, "..");
 
   if (!existsSync(dir)) {
@@ -66,8 +71,9 @@ export async function saveRegistry(registry: PluginRegistry, scope: Scope): Prom
 export async function getInstalledPlugin(
   name: string,
   scope: Scope,
+  targetDir?: string,
 ): Promise<InstalledPlugin | null> {
-  const registry = await loadRegistry(scope);
+  const registry = await loadRegistry(scope, targetDir);
   return registry.plugins[name] || null;
 }
 

package/src/types.ts

@@ -41,6 +41,13 @@ export interface PluginRegistry {
   plugins: Record<string, InstalledPlugin>;
 }
 
+/**
+ * Configuration for importing multiple plugins at once
+ */
+export interface ImportConfig {
+  plugins: string[];
+}
+
 // Validation & Helpers
 
 /**