claudeup 1.8.0 → 3.3.0

package/{dist → src}/prerunner/index.js

@@ -1,32 +1,46 @@
 import { UpdateCache } from "../services/update-cache.js";
-import { refreshLocalMarketplaces } from "../services/local-marketplace.js";
 import { getAvailablePlugins, clearMarketplaceCache, saveInstalledPluginVersion, } from "../services/plugin-manager.js";
 import { runClaude } from "../services/claude-runner.js";
+import { recoverMarketplaceSettings } from "../services/claude-settings.js";
 /**
  * Prerun orchestration: Check for updates, apply them, then run claude
  * @param claudeArgs - Arguments to pass to claude CLI
+ * @param options - Prerun options (force, etc.)
  * @returns Exit code from claude process
  */
-export async function prerunClaude(claudeArgs) {
+export async function prerunClaude(claudeArgs, options = {}) {
     const cache = new UpdateCache();
     try {
-        // STEP 1: Check if we should update (time-based cache)
-        const shouldUpdate = await cache.shouldCheckForUpdates();
+        // STEP 1: Check if we should update (time-based cache, or forced)
+        const shouldUpdate = options.force || (await cache.shouldCheckForUpdates());
+        if (options.force) {
+            console.log("⟳ Forcing plugin update check...");
+        }
         if (shouldUpdate) {
-            // STEP 2: Refresh all marketplaces (git pull)
-            const refreshResults = await refreshLocalMarketplaces();
-            // STEP 3: Clear cache to force fresh plugin info
+            // STEP 1.5: Recover marketplace settings (enable autoUpdate, remove stale entries)
+            const recovery = await recoverMarketplaceSettings();
+            if (recovery.enabledAutoUpdate.length > 0) {
+                console.log(`✓ Enabled auto-update for: ${recovery.enabledAutoUpdate.join(", ")}`);
+            }
+            if (recovery.removed.length > 0) {
+                console.log(`✓ Removed stale marketplaces: ${recovery.removed.join(", ")}`);
+            }
+            // STEP 2: Clear cache to force fresh plugin info
+            // Note: Marketplace updates should be done via Claude Code's /plugin marketplace update
             clearMarketplaceCache();
-            // STEP 4: Get updated plugin info (to detect versions)
+            // STEP 3: Get updated plugin info (to detect versions)
             const plugins = await getAvailablePlugins();
-            // STEP 4.5: Auto-update enabled plugins with available updates
+            // STEP 4: Auto-update enabled plugins with available updates
             const autoUpdatedPlugins = [];
             for (const plugin of plugins) {
                 // Only update if:
                 // 1. Plugin is enabled
                 // 2. Plugin has an update available
                 // 3. Plugin has both installedVersion and version (newVersion)
-                if (plugin.enabled && plugin.hasUpdate && plugin.installedVersion && plugin.version) {
+                if (plugin.enabled &&
+                    plugin.hasUpdate &&
+                    plugin.installedVersion &&
+                    plugin.version) {
                     try {
                         // Save new version - this will:
                         // 1. Update settings.json
@@ -45,39 +59,16 @@ export async function prerunClaude(claudeArgs) {
                     }
                 }
             }
-            // STEP 5: Build summary - show all updated plugins (not just enabled)
-            const updatedMarketplaces = [];
-            const updatedPlugins = [];
-            const failed = [];
-            for (const result of refreshResults) {
-                if (result.success && result.updated) {
-                    updatedMarketplaces.push(result.name);
-                    // Find ALL plugins from this marketplace (regardless of enabled state)
-                    const mpPlugins = plugins.filter((p) => p.marketplace === result.name);
-                    if (mpPlugins.length > 0) {
-                        updatedPlugins.push(...mpPlugins.map((p) => `${p.name} v${p.version}`));
-                    }
-                }
-                else if (!result.success) {
-                    failed.push(`${result.name}${result.error ? ` (${result.error})` : ""}`);
-                }
-            }
-            // STEP 6: Save cache
+            // STEP 5: Save cache
             await cache.saveCheck({
                 lastUpdateCheck: new Date().toISOString(),
-                lastUpdateResult: { updated: updatedPlugins, failed, autoUpdated: autoUpdatedPlugins },
+                lastUpdateResult: {
+                    updated: [],
+                    failed: [],
+                    autoUpdated: autoUpdatedPlugins,
+                },
             });
-            // STEP 7: Display summary (marketplace-level and plugin-level)
-            if (updatedMarketplaces.length > 0) {
-                console.log(`✓ Updated marketplace(s): ${updatedMarketplaces.join(", ")}`);
-                if (updatedPlugins.length > 0) {
-                    console.log(`  Plugins: ${updatedPlugins.join(", ")}`);
-                }
-            }
-            if (failed.length > 0) {
-                console.warn(`⚠ Failed to update: ${failed.join(", ")}`);
-            }
-            // Display auto-update summary
+            // STEP 6: Display auto-update summary
             if (autoUpdatedPlugins.length > 0) {
                 console.log(`✓ Auto-updated ${autoUpdatedPlugins.length} plugin(s):`);
                 for (const { pluginId, oldVersion, newVersion } of autoUpdatedPlugins) {
@@ -94,4 +85,3 @@ export async function prerunClaude(claudeArgs) {
     // STEP 8: Always run claude (even if update failed)
     return runClaude(claudeArgs);
 }
-//# sourceMappingURL=index.js.map

package/src/prerunner/index.ts

@@ -0,0 +1,124 @@
+import { UpdateCache } from "../services/update-cache.js";
+import {
+	getAvailablePlugins,
+	clearMarketplaceCache,
+	saveInstalledPluginVersion,
+} from "../services/plugin-manager.js";
+import { runClaude } from "../services/claude-runner.js";
+import { recoverMarketplaceSettings } from "../services/claude-settings.js";
+
+export interface PrerunOptions {
+	force?: boolean; // Bypass cache and force update check
+}
+
+/**
+ * Prerun orchestration: Check for updates, apply them, then run claude
+ * @param claudeArgs - Arguments to pass to claude CLI
+ * @param options - Prerun options (force, etc.)
+ * @returns Exit code from claude process
+ */
+export async function prerunClaude(
+	claudeArgs: string[],
+	options: PrerunOptions = {},
+): Promise<number> {
+	const cache = new UpdateCache();
+
+	try {
+		// STEP 1: Check if we should update (time-based cache, or forced)
+		const shouldUpdate = options.force || (await cache.shouldCheckForUpdates());
+
+		if (options.force) {
+			console.log("⟳ Forcing plugin update check...");
+		}
+
+		if (shouldUpdate) {
+			// STEP 1.5: Recover marketplace settings (enable autoUpdate, remove stale entries)
+			const recovery = await recoverMarketplaceSettings();
+			if (recovery.enabledAutoUpdate.length > 0) {
+				console.log(
+					`✓ Enabled auto-update for: ${recovery.enabledAutoUpdate.join(", ")}`,
+				);
+			}
+			if (recovery.removed.length > 0) {
+				console.log(
+					`✓ Removed stale marketplaces: ${recovery.removed.join(", ")}`,
+				);
+			}
+
+			// STEP 2: Clear cache to force fresh plugin info
+			// Note: Marketplace updates should be done via Claude Code's /plugin marketplace update
+			clearMarketplaceCache();
+
+			// STEP 3: Get updated plugin info (to detect versions)
+			const plugins = await getAvailablePlugins();
+
+			// STEP 4: Auto-update enabled plugins with available updates
+			const autoUpdatedPlugins: Array<{
+				pluginId: string;
+				oldVersion: string;
+				newVersion: string;
+			}> = [];
+
+			for (const plugin of plugins) {
+				// Only update if:
+				// 1. Plugin is enabled
+				// 2. Plugin has an update available
+				// 3. Plugin has both installedVersion and version (newVersion)
+				if (
+					plugin.enabled &&
+					plugin.hasUpdate &&
+					plugin.installedVersion &&
+					plugin.version
+				) {
+					try {
+						// Save new version - this will:
+						// 1. Update settings.json
+						// 2. Call updateInstalledPluginsRegistry()
+						// 3. Copy plugin files to cache (via copyPluginToCache())
+						await saveInstalledPluginVersion(plugin.id, plugin.version);
+
+						autoUpdatedPlugins.push({
+							pluginId: plugin.id,
+							oldVersion: plugin.installedVersion,
+							newVersion: plugin.version,
+						});
+					} catch (error) {
+						// Non-fatal: Log warning and continue
+						console.warn(
+							`⚠ Failed to auto-update ${plugin.id}:`,
+							error instanceof Error ? error.message : "Unknown error",
+						);
+					}
+				}
+			}
+
+			// STEP 5: Save cache
+			await cache.saveCheck({
+				lastUpdateCheck: new Date().toISOString(),
+				lastUpdateResult: {
+					updated: [],
+					failed: [],
+					autoUpdated: autoUpdatedPlugins,
+				},
+			});
+
+			// STEP 6: Display auto-update summary
+			if (autoUpdatedPlugins.length > 0) {
+				console.log(`✓ Auto-updated ${autoUpdatedPlugins.length} plugin(s):`);
+				for (const { pluginId, oldVersion, newVersion } of autoUpdatedPlugins) {
+					console.log(`  - ${pluginId}: ${oldVersion} → ${newVersion}`);
+				}
+			}
+		}
+		// If !shouldUpdate → silent (no output)
+	} catch (error) {
+		// Non-fatal errors - warn and continue
+		console.warn(
+			"Warning: Plugin update check failed:",
+			error instanceof Error ? error.message : "Unknown error",
+		);
+	}
+
+	// STEP 8: Always run claude (even if update failed)
+	return runClaude(claudeArgs);
+}

package/{dist → src}/services/claude-runner.js

@@ -1,5 +1,5 @@
-import { spawn } from 'node:child_process';
-import { which } from '../utils/command-utils.js';
+import { spawn } from "node:child_process";
+import { which } from "../utils/command-utils.js";
 /**
  * Execute claude CLI with provided arguments
  * @param args - Arguments to pass to claude
@@ -7,23 +7,22 @@ import { which } from '../utils/command-utils.js';
  */
 export async function runClaude(args) {
     // Check if claude exists
-    const claudePath = await which('claude');
+    const claudePath = await which("claude");
     if (!claudePath) {
-        console.error('Error: claude CLI not found in PATH');
-        console.error('Install with: npm install -g @anthropic-ai/claude-code');
+        console.error("Error: claude CLI not found in PATH");
+        console.error("Install with: npm install -g @anthropic-ai/claude-code");
         return 1;
     }
     // Spawn claude with full TTY inheritance using the resolved path
     return new Promise((resolve) => {
         const proc = spawn(claudePath, args, {
-            stdio: 'inherit', // Pass through stdin, stdout, stderr
+            stdio: "inherit", // Pass through stdin, stdout, stderr
             shell: false, // Use full path, no shell needed (fixes DEP0190)
         });
-        proc.on('exit', (code) => resolve(code || 0));
-        proc.on('error', (err) => {
-            console.error('Failed to run claude:', err.message);
+        proc.on("exit", (code) => resolve(code || 0));
+        proc.on("error", (err) => {
+            console.error("Failed to run claude:", err.message);
             resolve(1);
         });
     });
 }
-//# sourceMappingURL=claude-runner.js.map

package/src/services/claude-runner.ts

@@ -0,0 +1,31 @@
+import { spawn } from "node:child_process";
+import { which } from "../utils/command-utils.js";
+
+/**
+ * Execute claude CLI with provided arguments
+ * @param args - Arguments to pass to claude
+ * @returns Exit code from claude process
+ */
+export async function runClaude(args: string[]): Promise<number> {
+	// Check if claude exists
+	const claudePath = await which("claude");
+	if (!claudePath) {
+		console.error("Error: claude CLI not found in PATH");
+		console.error("Install with: npm install -g @anthropic-ai/claude-code");
+		return 1;
+	}
+
+	// Spawn claude with full TTY inheritance using the resolved path
+	return new Promise((resolve) => {
+		const proc = spawn(claudePath, args, {
+			stdio: "inherit", // Pass through stdin, stdout, stderr
+			shell: false, // Use full path, no shell needed (fixes DEP0190)
+		});
+
+		proc.on("exit", (code) => resolve(code || 0));
+		proc.on("error", (err) => {
+			console.error("Failed to run claude:", err.message);
+			resolve(1);
+		});
+	});
+}

package/{dist → src}/services/claude-settings.js

@@ -148,22 +148,10 @@ export async function setAllowMcp(_allow, _projectPath) {
     // .mcp.json doesn't have an allowMcp setting - servers are either in the file or not
     // This function is kept for API compatibility but is now a no-op
 }
-// Marketplace management
-export async function addMarketplace(marketplace, projectPath) {
-    const settings = await readSettings(projectPath);
-    settings.extraKnownMarketplaces = settings.extraKnownMarketplaces || {};
-    settings.extraKnownMarketplaces[marketplace.name] = {
-        source: marketplace.source,
-    };
-    await writeSettings(settings, projectPath);
-}
-export async function removeMarketplace(name, projectPath) {
-    const settings = await readSettings(projectPath);
-    if (settings.extraKnownMarketplaces) {
-        delete settings.extraKnownMarketplaces[name];
-    }
-    await writeSettings(settings, projectPath);
-}
+// Marketplace management - READ ONLY
+// Use Claude Code CLI commands to add/remove marketplaces:
+// claude marketplace add owner/repo
+// claude marketplace remove name
 // Plugin management
 export async function enablePlugin(pluginId, enabled, projectPath) {
     const settings = await readSettings(projectPath);
@@ -286,22 +274,8 @@ export async function getConfiguredMarketplaces(projectPath) {
     const settings = await readSettings(projectPath);
     return settings.extraKnownMarketplaces || {};
 }
-// Global marketplace management
-export async function addGlobalMarketplace(marketplace) {
-    const settings = await readGlobalSettings();
-    settings.extraKnownMarketplaces = settings.extraKnownMarketplaces || {};
-    settings.extraKnownMarketplaces[marketplace.name] = {
-        source: marketplace.source,
-    };
-    await writeGlobalSettings(settings);
-}
-export async function removeGlobalMarketplace(name) {
-    const settings = await readGlobalSettings();
-    if (settings.extraKnownMarketplaces) {
-        delete settings.extraKnownMarketplaces[name];
-    }
-    await writeGlobalSettings(settings);
-}
+// Global marketplace management - READ ONLY
+// Marketplaces are managed via Claude Code's native system
 export async function getGlobalConfiguredMarketplaces() {
     const settings = await readGlobalSettings();
     return settings.extraKnownMarketplaces || {};
@@ -397,6 +371,72 @@ export async function discoverAllGlobalMarketplaces() {
 // installed_plugins.json registry management
 const INSTALLED_PLUGINS_FILE = path.join(os.homedir(), ".claude", "plugins", "installed_plugins.json");
 const KNOWN_MARKETPLACES_FILE = path.join(os.homedir(), ".claude", "plugins", "known_marketplaces.json");
+/**
+ * Write known_marketplaces.json
+ */
+async function writeKnownMarketplaces(marketplaces) {
+    await fs.ensureDir(path.dirname(KNOWN_MARKETPLACES_FILE));
+    await fs.writeJson(KNOWN_MARKETPLACES_FILE, marketplaces, { spaces: 2 });
+}
+/**
+ * Set autoUpdate flag for a marketplace in known_marketplaces.json
+ * This is where Claude Code actually reads the autoUpdate setting
+ */
+export async function setMarketplaceAutoUpdate(marketplaceName, autoUpdate) {
+    const known = await readKnownMarketplaces();
+    if (known[marketplaceName]) {
+        known[marketplaceName].autoUpdate = autoUpdate;
+        await writeKnownMarketplaces(known);
+        return true;
+    }
+    return false; // Marketplace not yet installed by Claude Code
+}
+/**
+ * Get autoUpdate status for a marketplace
+ */
+export async function getMarketplaceAutoUpdate(marketplaceName) {
+    const known = await readKnownMarketplaces();
+    return known[marketplaceName]?.autoUpdate;
+}
+/**
+ * Check if a marketplace is from MadAppGang
+ */
+function isMadAppGangMarketplace(entry) {
+    const repo = entry.source?.repo?.toLowerCase() || "";
+    return repo.includes("madappgang");
+}
+/**
+ * Recover/sync marketplace settings:
+ * - Enable autoUpdate for MadAppGang marketplaces that don't have it set
+ * - Remove entries for marketplaces whose installLocation no longer exists
+ */
+export async function recoverMarketplaceSettings() {
+    const known = await readKnownMarketplaces();
+    const result = {
+        enabledAutoUpdate: [],
+        removed: [],
+    };
+    const updatedKnown = {};
+    for (const [name, entry] of Object.entries(known)) {
+        // Check if install location still exists
+        if (entry.installLocation &&
+            !(await fs.pathExists(entry.installLocation))) {
+            result.removed.push(name);
+            continue;
+        }
+        // Enable autoUpdate if not set - only for MadAppGang marketplaces
+        if (entry.autoUpdate === undefined && isMadAppGangMarketplace(entry)) {
+            entry.autoUpdate = true;
+            result.enabledAutoUpdate.push(name);
+        }
+        updatedKnown[name] = entry;
+    }
+    // Write back if any changes were made
+    if (result.enabledAutoUpdate.length > 0 || result.removed.length > 0) {
+        await writeKnownMarketplaces(updatedKnown);
+    }
+    return result;
+}
 /**
  * Read known_marketplaces.json to get marketplace source info
  */
@@ -604,4 +644,3 @@ export async function removeFromInstalledPluginsRegistry(pluginId, scope, projec
         console.warn(`Failed to remove from registry for ${pluginId}:`, error instanceof Error ? error.message : "Unknown error");
     }
 }
-//# sourceMappingURL=claude-settings.js.map