@celilo/cli 0.1.0

package/src/cli/commands/hook-run.ts

@@ -0,0 +1,176 @@
+/**
+ * Hook run command
+ *
+ * Runs a module hook in isolation for testing/debugging
+ *
+ * Usage:
+ *   celilo hook run <module-id> <hook-name> [--debug] [key=value...]
+ */
+
+import { eq } from 'drizzle-orm';
+import { FuelGauge } from '../../cli/fuel-gauge';
+import { getDb } from '../../db/client';
+import { moduleConfigs, modules, secrets } from '../../db/schema';
+import { loadCapabilityFunctions } from '../../hooks/capability-loader';
+import { invokeHook } from '../../hooks/executor';
+import { createConsoleLogger } from '../../hooks/logger';
+import { createGaugeLogger } from '../../hooks/logger';
+import type { ModuleManifest } from '../../manifest/schema';
+import { decryptSecret } from '../../secrets/encryption';
+import { getOrCreateMasterKey } from '../../secrets/master-key';
+import { getArg, hasFlag, validateRequiredArgs } from '../parser';
+import type { CommandResult } from '../types';
+
+/**
+ * Handle hook run command
+ *
+ * @param args - Command arguments: [module-id, hook-name, ...key=value inputs]
+ * @param flags - Command flags
+ * @returns Command result
+ */
+export async function handleHookRun(
+  args: string[],
+  flags: Record<string, string | boolean>,
+): Promise<CommandResult> {
+  const error = validateRequiredArgs(args, 2);
+  if (error) {
+    return {
+      success: false,
+      error: `${error}\n\nUsage:\n  celilo hook run <module-id> <hook-name> [--debug] [key=value...]`,
+    };
+  }
+
+  const moduleId = getArg(args, 0);
+  const hookName = getArg(args, 1);
+  if (!moduleId || !hookName) {
+    return {
+      success: false,
+      error: 'Module ID and hook name are required',
+    };
+  }
+
+  const debug = hasFlag(flags, 'debug');
+  const db = getDb();
+
+  // Look up module
+  const module = db.select().from(modules).where(eq(modules.id, moduleId)).get();
+  if (!module) {
+    return {
+      success: false,
+      error: `Module not found: ${moduleId}`,
+    };
+  }
+
+  // Find hook definition in manifest
+  const manifest = module.manifestData as ModuleManifest;
+  const hookDef = manifest.hooks?.[hookName as keyof typeof manifest.hooks];
+  if (!hookDef) {
+    const available = Object.keys(manifest.hooks || {});
+    return {
+      success: false,
+      error: `Hook '${hookName}' not found in module '${moduleId}'.\n\nAvailable hooks: ${available.length > 0 ? available.join(', ') : '(none)'}`,
+    };
+  }
+
+  // Parse key=value inputs from remaining args
+  const inputs: Record<string, unknown> = {};
+  for (let i = 2; i < args.length; i++) {
+    const arg = args[i];
+    const eqIndex = arg.indexOf('=');
+    if (eqIndex > 0) {
+      inputs[arg.substring(0, eqIndex)] = arg.substring(eqIndex + 1);
+    }
+  }
+
+  // Build config map from DB
+  const configRecords = db
+    .select()
+    .from(moduleConfigs)
+    .where(eq(moduleConfigs.moduleId, moduleId))
+    .all();
+  const configMap: Record<string, unknown> = {};
+  for (const c of configRecords) {
+    configMap[c.key] = c.valueJson ? JSON.parse(c.valueJson) : c.value;
+  }
+
+  // Build secrets map from DB
+  const secretRecords = db.select().from(secrets).where(eq(secrets.moduleId, moduleId)).all();
+  const masterKey = await getOrCreateMasterKey();
+  const secretMap: Record<string, string> = {};
+  for (const s of secretRecords) {
+    secretMap[s.name] = decryptSecret(
+      { encryptedValue: s.encryptedValue, iv: s.iv, authTag: s.authTag },
+      masterKey,
+    );
+  }
+
+  const requiredCapabilities = manifest.requires.capabilities.map((c) => c.name);
+
+  // Run the hook — use console logger in debug mode, FuelGauge otherwise.
+  // The logger is constructed BEFORE loadCapabilityFunctions so the
+  // auto-logging wrapper (HOOK_API_V2 D6) can capture it for every
+  // capability call.
+  if (debug) {
+    const logger = createConsoleLogger(moduleId, hookName);
+    const capabilityFunctions = await loadCapabilityFunctions(moduleId, db, logger);
+    const result = await invokeHook(
+      module.sourcePath,
+      hookName,
+      manifest.celilo_contract,
+      hookDef,
+      inputs,
+      configMap,
+      secretMap,
+      logger,
+      { debug, capabilities: capabilityFunctions, requiredCapabilities },
+    );
+
+    if (!result.success) {
+      let errorMsg = result.error || 'Hook execution failed';
+      if (result.screenshotPath) {
+        errorMsg += `\n\nScreenshot saved: ${result.screenshotPath}`;
+      }
+      return { success: false, error: errorMsg };
+    }
+
+    return {
+      success: true,
+      message: `Hook '${hookName}' completed in ${result.duration}ms`,
+      data: result.outputs,
+    };
+  }
+
+  // Non-debug: use FuelGauge
+  const gauge = new FuelGauge(`Running hook: ${hookName}`);
+  gauge.start();
+  const logger = createGaugeLogger(gauge, moduleId, hookName);
+  const capabilityFunctions = await loadCapabilityFunctions(moduleId, db, logger);
+
+  const result = await invokeHook(
+    module.sourcePath,
+    hookName,
+    manifest.celilo_contract,
+    hookDef,
+    inputs,
+    configMap,
+    secretMap,
+    logger,
+    { debug: false, capabilities: capabilityFunctions, requiredCapabilities },
+  );
+
+  if (!result.success) {
+    gauge.stop(false);
+    let errorMsg = result.error || 'Hook execution failed';
+    if (result.screenshotPath) {
+      errorMsg += `\n\nScreenshot saved: ${result.screenshotPath}`;
+    }
+    return { success: false, error: errorMsg };
+  }
+
+  gauge.stop(true);
+  return {
+    success: true,
+    message: `Hook '${hookName}' completed in ${result.duration}ms`,
+    data: result.outputs,
+  };
+}