@fredlackey/devutils 0.0.19 → 0.1.0

package/src/commands/api/disable.js

@@ -0,0 +1,73 @@
+'use strict';
+
+const fs = require('fs');
+const shell = require('../../lib/shell');
+const loader = require('../../api/loader');
+
+const meta = {
+  description: 'Remove an installed API plugin',
+  arguments: [
+    { name: 'name', description: 'Plugin name to remove', required: true }
+  ],
+  flags: [
+    { name: 'confirm', type: 'boolean', description: 'Skip confirmation prompt' }
+  ]
+};
+
+/**
+ * Removes an installed API plugin.
+ * Runs npm uninstall, removes the entry from plugins.json,
+ * and asks for confirmation unless --confirm is passed.
+ *
+ * @param {object} args - Parsed CLI arguments { positional, flags }.
+ * @param {object} context - CLI context { output, errors, prompt }.
+ */
+async function run(args, context) {
+  const pluginName = args.positional[0];
+
+  if (!pluginName) {
+    context.errors.throwError(400, 'Missing required argument: <name>. Example: dev api disable gmail', 'api');
+    return;
+  }
+
+  // Check if the plugin is installed
+  const plugins = loader.readPluginsJson();
+  const entry = plugins[pluginName];
+
+  if (!entry) {
+    context.output.info(`Plugin "${pluginName}" is not installed.`);
+    return;
+  }
+
+  // Ask for confirmation unless --confirm is passed
+  if (!args.flags.confirm) {
+    const ok = await context.prompt.confirm(
+      `Remove plugin "${pluginName}" (${entry.package})?`,
+      false
+    );
+    if (!ok) {
+      context.output.info('Cancelled.');
+      return;
+    }
+  }
+
+  // Run npm uninstall
+  const result = await shell.exec(`npm uninstall ${entry.package}`, { cwd: loader.PLUGINS_DIR });
+
+  if (result.exitCode !== 0) {
+    context.errors.throwError(
+      500,
+      `Failed to uninstall plugin "${pluginName}".\n${result.stderr || result.stdout}`,
+      'api'
+    );
+    return;
+  }
+
+  // Remove the entry from plugins.json
+  delete plugins[pluginName];
+  fs.writeFileSync(loader.PLUGINS_FILE, JSON.stringify(plugins, null, 2) + '\n');
+
+  context.output.info(`Plugin "${pluginName}" removed.`);
+}
+
+module.exports = { meta, run };

package/src/commands/api/enable.js

@@ -0,0 +1,148 @@
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+const shell = require('../../lib/shell');
+const loader = require('../../api/loader');
+
+const meta = {
+  description: 'Install an API plugin from npm or a git repository',
+  arguments: [
+    { name: 'name', description: 'Plugin name or full package name', required: true }
+  ],
+  flags: [
+    { name: 'source', type: 'string', description: 'Install source type: "npm" or "git" (default: npm)' },
+    { name: 'url', type: 'string', description: 'Package name or git URL when using a non-registry plugin' }
+  ]
+};
+
+/**
+ * Installs an API plugin from npm or a git repository.
+ * Resolves short names (like "gmail") through the registry, or accepts
+ * full package names (starting with "@") and git URLs directly.
+ *
+ * @param {object} args - Parsed CLI arguments { positional, flags }.
+ * @param {object} context - CLI context { output, errors, prompt }.
+ */
+async function run(args, context) {
+  const pluginName = args.positional[0];
+
+  if (!pluginName) {
+    context.errors.throwError(400, 'Missing required argument: <name>. Example: dev api enable gmail', 'api');
+    return;
+  }
+
+  // Resolve the package name from the registry or direct input
+  const registry = loader.getRegistryPlugins();
+  const registryEntry = registry.find(entry => entry.name === pluginName);
+  let packageName;
+
+  if (registryEntry) {
+    // Found in registry - use the registry package name
+    packageName = registryEntry.package;
+  } else if (args.flags.url) {
+    // Not in registry but user provided a URL/package name
+    packageName = args.flags.url;
+  } else if (pluginName.startsWith('@') || pluginName.includes('/')) {
+    // Looks like a scoped npm package or git URL - use directly
+    packageName = pluginName;
+  } else {
+    context.errors.throwError(
+      404,
+      `Plugin "${pluginName}" not found in the registry. Use --source git --url <git-url> to install from a git repository, or --url <package-name> to install a non-registry npm package.`,
+      'api'
+    );
+    return;
+  }
+
+  // Check if already installed
+  const installed = loader.readPluginsJson();
+  if (installed[pluginName]) {
+    context.output.info(
+      `Plugin "${pluginName}" is already installed (version ${installed[pluginName].version || 'unknown'}). Use "dev api update ${pluginName}" to update.`
+    );
+    return;
+  }
+
+  // Ensure the plugins directory exists with a package.json
+  const pluginsDir = loader.PLUGINS_DIR;
+  const pkgJsonPath = path.join(pluginsDir, 'package.json');
+
+  if (!fs.existsSync(pkgJsonPath)) {
+    fs.mkdirSync(pluginsDir, { recursive: true });
+    fs.writeFileSync(pkgJsonPath, JSON.stringify({
+      name: 'devutils-plugins',
+      version: '1.0.0',
+      private: true,
+      description: 'DevUtils CLI plugin packages'
+    }, null, 2) + '\n');
+  }
+
+  // Determine the install target
+  const installTarget = args.flags.url || packageName;
+
+  // Run npm install
+  context.output.info(`Installing ${pluginName} (${installTarget})...`);
+  const result = await shell.exec(`npm install ${installTarget}`, { cwd: pluginsDir });
+
+  if (result.exitCode !== 0) {
+    context.errors.throwError(
+      500,
+      `Failed to install plugin "${pluginName}".\n${result.stderr || result.stdout}`,
+      'api'
+    );
+    return;
+  }
+
+  // Read the installed version from the plugin's package.json
+  let installedVersion = 'unknown';
+  try {
+    const pluginPkgPath = path.join(pluginsDir, 'node_modules', packageName, 'package.json');
+    const pluginPkg = JSON.parse(fs.readFileSync(pluginPkgPath, 'utf8'));
+    installedVersion = pluginPkg.version || 'unknown';
+  } catch (err) {
+    // Could not read version, continue with 'unknown'
+  }
+
+  // Update plugins.json
+  const plugins = loader.readPluginsJson();
+  const sourceType = args.flags.source || 'npm';
+  plugins[pluginName] = {
+    package: packageName,
+    version: installedVersion,
+    source: sourceType,
+    installedAt: new Date().toISOString()
+  };
+
+  // Only store the URL if one was explicitly provided
+  if (args.flags.url) {
+    plugins[pluginName].url = args.flags.url;
+  }
+
+  // Ensure the parent directory exists for plugins.json
+  const pluginsFileDir = path.dirname(loader.PLUGINS_FILE);
+  if (!fs.existsSync(pluginsFileDir)) {
+    fs.mkdirSync(pluginsFileDir, { recursive: true });
+  }
+
+  fs.writeFileSync(loader.PLUGINS_FILE, JSON.stringify(plugins, null, 2) + '\n');
+
+  // Validate the plugin contract
+  const loadResult = loader.loadPlugin(pluginName);
+  if (loadResult.error) {
+    context.output.info(
+      `Warning: Plugin installed but does not follow the expected contract. It may not work correctly.\n${loadResult.message}`
+    );
+  }
+
+  // Print success
+  context.output.info(`Plugin "${pluginName}" installed (v${installedVersion}).`);
+
+  // Show auth hint if available from the registry entry
+  const authService = registryEntry ? registryEntry.auth : null;
+  if (authService) {
+    context.output.info(`This plugin requires "${authService}" authentication. Run "dev auth login ${authService}" if you haven't already.`);
+  }
+}
+
+module.exports = { meta, run };

package/src/commands/api/index.js

@@ -0,0 +1,15 @@
+/**
+ * API service registration.
+ * API plugin system — manages plugin installation, removal, and updates.
+ * Plugin commands are loaded at runtime from ~/.devutils/plugins/.
+ */
+module.exports = {
+  name: 'api',
+  description: 'API plugin system',
+  commands: {
+    list:    () => require('./list'),
+    enable:  () => require('./enable'),
+    disable: () => require('./disable'),
+    update:  () => require('./update'),
+  }
+};

package/src/commands/api/list.js

@@ -0,0 +1,66 @@
+'use strict';
+
+const loader = require('../../api/loader');
+
+const meta = {
+  description: 'List installed and available API plugins',
+  arguments: [],
+  flags: [
+    { name: 'installed', type: 'boolean', description: 'Show only installed plugins' },
+    { name: 'available', type: 'boolean', description: 'Show only available (not installed) plugins' }
+  ]
+};
+
+/**
+ * Lists installed and/or available API plugins.
+ * Shows both by default, or filters with --installed / --available flags.
+ *
+ * @param {object} args - Parsed CLI arguments { positional, flags }.
+ * @param {object} context - CLI context { output, errors }.
+ */
+async function run(args, context) {
+  const installed = loader.getInstalledPlugins();
+  const registry = loader.getRegistryPlugins();
+  const installedNames = Object.keys(installed);
+
+  // Build the installed list
+  const installedList = installedNames.map(name => ({
+    name,
+    package: installed[name].package,
+    version: installed[name].version || 'unknown',
+    source: installed[name].source || 'npm',
+    installedAt: installed[name].installedAt || ''
+  }));
+
+  // Build the available list (registry entries that are not installed)
+  const availableList = registry
+    .filter(entry => !installed[entry.name])
+    .map(entry => ({
+      name: entry.name,
+      package: entry.package,
+      description: entry.description
+    }));
+
+  // Apply filters
+  const showInstalled = args.flags.installed || !args.flags.available;
+  const showAvailable = args.flags.available || !args.flags.installed;
+
+  const result = {};
+
+  if (showInstalled) {
+    result.installed = installedList;
+  }
+  if (showAvailable) {
+    result.available = availableList;
+  }
+
+  // If only installed was requested and nothing is installed, give a hint
+  if (args.flags.installed && installedList.length === 0) {
+    context.output.info('No API plugins installed. Run "dev api enable <name>" to install one.');
+    return;
+  }
+
+  context.output.out(result);
+}
+
+module.exports = { meta, run };

package/src/commands/api/update.js

@@ -0,0 +1,87 @@
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+const shell = require('../../lib/shell');
+const loader = require('../../api/loader');
+
+const meta = {
+  description: 'Update an installed API plugin to the latest version',
+  arguments: [
+    { name: 'name', description: 'Plugin name to update', required: true }
+  ],
+  flags: []
+};
+
+/**
+ * Updates an installed API plugin to the latest version.
+ * For npm-sourced plugins, runs npm update. For git-sourced plugins,
+ * re-runs npm install with the original git URL.
+ *
+ * @param {object} args - Parsed CLI arguments { positional, flags }.
+ * @param {object} context - CLI context { output, errors }.
+ */
+async function run(args, context) {
+  const pluginName = args.positional[0];
+
+  if (!pluginName) {
+    context.errors.throwError(400, 'Missing required argument: <name>. Example: dev api update gmail', 'api');
+    return;
+  }
+
+  // Check if the plugin is installed
+  const plugins = loader.readPluginsJson();
+  const entry = plugins[pluginName];
+
+  if (!entry) {
+    context.output.info(`Plugin "${pluginName}" is not installed.`);
+    return;
+  }
+
+  const previousVersion = entry.version || 'unknown';
+  const pluginsDir = loader.PLUGINS_DIR;
+
+  // Determine update strategy based on source type
+  let result;
+  if (entry.source === 'git' && entry.url) {
+    // Git-sourced plugins: re-install from the original URL
+    context.output.info(`Updating ${pluginName} from git...`);
+    result = await shell.exec(`npm install ${entry.url}`, { cwd: pluginsDir });
+  } else {
+    // npm-sourced plugins: use npm update
+    context.output.info(`Updating ${pluginName}...`);
+    result = await shell.exec(`npm update ${entry.package}`, { cwd: pluginsDir });
+  }
+
+  if (result.exitCode !== 0) {
+    context.errors.throwError(
+      500,
+      `Failed to update plugin "${pluginName}".\n${result.stderr || result.stdout}`,
+      'api'
+    );
+    return;
+  }
+
+  // Read the new version from the plugin's package.json
+  let newVersion = 'unknown';
+  try {
+    const pluginPkgPath = path.join(pluginsDir, 'node_modules', entry.package, 'package.json');
+    const pluginPkg = JSON.parse(fs.readFileSync(pluginPkgPath, 'utf8'));
+    newVersion = pluginPkg.version || 'unknown';
+  } catch (err) {
+    // Could not read version
+  }
+
+  // Update the version in plugins.json
+  plugins[pluginName].version = newVersion;
+  fs.writeFileSync(loader.PLUGINS_FILE, JSON.stringify(plugins, null, 2) + '\n');
+
+  // Report the result
+  if (newVersion !== previousVersion) {
+    context.output.info(`Updated ${pluginName} from ${previousVersion} to ${newVersion}.`);
+  } else {
+    context.output.info(`${pluginName} is already at the latest version (${newVersion}).`);
+  }
+}
+
+module.exports = { meta, run };

package/src/commands/auth/index.js

@@ -0,0 +1,15 @@
+/**
+ * Auth service registration.
+ * OAuth and credential management.
+ */
+module.exports = {
+  name: 'auth',
+  description: 'OAuth and credential management',
+  commands: {
+    login:   () => require('./login'),
+    logout:  () => require('./logout'),
+    list:    () => require('./list'),
+    status:  () => require('./status'),
+    refresh: () => require('./refresh'),
+  }
+};

package/src/commands/auth/list.js

@@ -0,0 +1,49 @@
+'use strict';
+
+const { AUTH_SERVICES, readCredential, getTokenStatus } = require('./services');
+
+const meta = {
+  description: 'List all connected services and their token status',
+  arguments: [],
+  flags: []
+};
+
+/**
+ * Run the auth list command.
+ * Scans all known services from AUTH_SERVICES and shows their auth status.
+ * Shows 'valid', 'expired', or 'missing' for each service.
+ *
+ * @param {object} args - Parsed CLI arguments (positional, flags).
+ * @param {object} context - CLI context (output, prompt, errors).
+ */
+async function run(args, context) {
+  const services = Object.keys(AUTH_SERVICES);
+  const results = [];
+
+  for (const service of services) {
+    const config = AUTH_SERVICES[service];
+    const credential = readCredential(service);
+    const status = getTokenStatus(credential);
+
+    results.push({
+      service: service,
+      type: config.type,
+      status: status,
+      authenticatedAt: credential && credential.authenticatedAt ? credential.authenticatedAt : '-'
+    });
+  }
+
+  // Check if any services are connected
+  const hasConnected = results.some(r => r.status !== 'missing');
+
+  if (!hasConnected) {
+    context.output.info('No services authenticated. Run "dev auth login <service>" to connect.');
+    context.output.info('');
+    context.output.info('Available services: ' + services.join(', '));
+    return;
+  }
+
+  context.output.out(results);
+}
+
+module.exports = { meta, run };