@pellux/goodvibes-agent 0.1.0

package/src/input/commands/runtime-services.ts

@@ -0,0 +1,291 @@
+import type {
+  CommandContext,
+  CommandExtensionServices,
+  CommandOpsServices,
+  CommandPlatformServices,
+  CommandProviderServices,
+  CommandSessionServices,
+  CommandWorkspaceServices,
+} from '../command-registry.ts';
+import type { UiReadModels } from '../../runtime/ui-read-models.ts';
+import type { ShellPathService } from '@/runtime/index.ts';
+import type { EcosystemCatalogPathOptions } from '@/runtime/index.ts';
+import type { PluginPathOptions } from '../../plugins/loader';
+import type { DirectTransport } from '@/runtime/index.ts';
+import type { KnowledgeApi } from '@pellux/goodvibes-sdk/platform/knowledge';
+import type { HookApi } from '@pellux/goodvibes-sdk/platform/hooks';
+import type { McpApi } from '@pellux/goodvibes-sdk/platform/mcp';
+import type { OperatorClient } from '@/runtime/index.ts';
+import type { OpsApi } from '@/runtime/index.ts';
+import type { PeerClient } from '@/runtime/index.ts';
+import { GOODVIBES_AGENT_SURFACE_ROOT } from '../../config/surface.ts';
+import type { ProviderApi } from '@pellux/goodvibes-sdk/platform/providers';
+import type {
+  ShellAgentManagerService,
+  ShellAcpManagerService,
+  ShellAutomationManagerService,
+  ShellAutomationManagerRuntimeService,
+  ShellModeManagerService,
+  ShellPlanManagerService,
+  ShellSessionOrchestrationService,
+} from '@/runtime/index.ts';
+
+function requireContextValue<T>(value: T | null | undefined, name: string): T {
+  if (value == null) {
+    throw new Error(`commandContext.${name} is required but was not wired at bootstrap`);
+  }
+  return value;
+}
+
+export function requireSession(context: CommandContext): CommandSessionServices {
+  return context.session;
+}
+
+export function requireProvider(context: CommandContext): CommandProviderServices {
+  return context.provider;
+}
+
+export function requireWorkspace(context: CommandContext): CommandWorkspaceServices {
+  return context.workspace;
+}
+
+export function requirePlatform(context: CommandContext): CommandPlatformServices {
+  return context.platform;
+}
+
+export function requireOps(context: CommandContext): CommandOpsServices {
+  return context.ops;
+}
+
+export function requireExtensions(context: CommandContext): CommandExtensionServices {
+  return context.extensions;
+}
+
+export function requireReadModels(context: CommandContext): UiReadModels {
+  return requireContextValue(context.platform.readModels, 'platform.readModels');
+}
+
+export function requireShellPaths(context: Pick<CommandContext, 'workspace'>): ShellPathService {
+  return requireContextValue(context.workspace.shellPaths, 'workspace.shellPaths');
+}
+
+export function requireEcosystemCatalogPaths(
+  context: CommandContext,
+): EcosystemCatalogPathOptions {
+  const shellPaths = requireShellPaths(context);
+  return {
+    cwd: shellPaths.workingDirectory,
+    homeDir: shellPaths.homeDirectory,
+    projectCatalogRoot: shellPaths.resolveProjectPath(GOODVIBES_AGENT_SURFACE_ROOT, 'ecosystem'),
+    userCatalogRoot: shellPaths.resolveUserPath(GOODVIBES_AGENT_SURFACE_ROOT, 'ecosystem'),
+  };
+}
+
+export function requirePluginPathOptions(
+  context: CommandContext,
+): PluginPathOptions {
+  const shellPaths = requireShellPaths(context);
+  return {
+    cwd: shellPaths.workingDirectory,
+    homeDir: shellPaths.homeDirectory,
+  };
+}
+
+export function openCommandPanel(
+  context: Pick<CommandContext, 'showPanel'>,
+  panelId: string,
+  pane?: 'top' | 'bottom',
+): void {
+  const showPanel = requireContextValue(context.showPanel, 'showPanel');
+  showPanel(panelId, pane);
+}
+
+export function openOnboardingWizard(
+  context: Pick<CommandContext, 'openOnboardingWizard'>,
+  modeOrOptions?: import('../onboarding/onboarding-wizard.ts').OnboardingWizardMode
+    | import('../handler-ui-state.ts').OpenOnboardingWizardOptions,
+): void {
+  const openWizard = requireContextValue(context.openOnboardingWizard, 'openOnboardingWizard');
+  openWizard(modeOrOptions);
+}
+
+export function requireKeybindingsManager(context: CommandContext) {
+  return requireContextValue(context.workspace.keybindingsManager, 'workspace.keybindingsManager');
+}
+
+export function requireProfileManager(context: CommandContext) {
+  return requireContextValue(context.workspace.profileManager, 'workspace.profileManager');
+}
+
+export function requirePanelManager(context: CommandContext) {
+  return requireContextValue(context.workspace.panelManager, 'workspace.panelManager');
+}
+
+export function requireBookmarkManager(context: CommandContext) {
+  return requireContextValue(context.workspace.bookmarkManager, 'workspace.bookmarkManager');
+}
+
+export function requireSessionManager(context: CommandContext) {
+  return requireContextValue(context.session.sessionManager, 'session.sessionManager');
+}
+
+export function requireSecretsManager(context: CommandContext) {
+  return requireContextValue(context.platform.secretsManager, 'platform.secretsManager');
+}
+
+export function requireSubscriptionManager(context: CommandContext) {
+  return requireContextValue(context.platform.subscriptionManager, 'platform.subscriptionManager');
+}
+
+export function requireServiceRegistry(context: CommandContext) {
+  return requireContextValue(context.platform.serviceRegistry, 'platform.serviceRegistry');
+}
+
+export function requireLocalUserAuthManager(context: CommandContext) {
+  return requireContextValue(context.platform.localUserAuthManager, 'platform.localUserAuthManager');
+}
+
+export function requireTokenAuditor(context: CommandContext) {
+  return requireContextValue(context.platform.tokenAuditor, 'platform.tokenAuditor');
+}
+
+export function requireReplayEngine(context: CommandContext) {
+  return requireContextValue(context.platform.replayEngine, 'platform.replayEngine');
+}
+
+export function requireWebhookNotifier(context: CommandContext) {
+  return requireContextValue(context.platform.webhookNotifier, 'platform.webhookNotifier');
+}
+
+export function requireSessionMemoryStore(context: CommandContext) {
+  return requireContextValue(context.session.sessionMemoryStore, 'session.sessionMemoryStore');
+}
+
+export function requireSessionLineageTracker(context: CommandContext) {
+  return requireContextValue(context.session.sessionLineageTracker, 'session.sessionLineageTracker');
+}
+
+export function requireSessionChangeTracker(context: CommandContext) {
+  return requireContextValue(context.session.changeTracker, 'session.changeTracker');
+}
+
+export function requirePlanManager(context: CommandContext): ShellPlanManagerService {
+  return requireContextValue(context.ops.planManager, 'ops.planManager') as ShellPlanManagerService;
+}
+
+export function requireAdaptivePlanner(context: CommandContext): unknown {
+  return requireContextValue(context.ops.adaptivePlanner, 'ops.adaptivePlanner');
+}
+
+export function requireSessionOrchestration(context: CommandContext): ShellSessionOrchestrationService {
+  return requireContextValue(context.ops.sessionOrchestration, 'ops.sessionOrchestration') as ShellSessionOrchestrationService;
+}
+
+export function requireForensicsRegistry(context: CommandContext) {
+  return requireContextValue(context.extensions.forensicsRegistry, 'extensions.forensicsRegistry');
+}
+
+export function requirePluginManager(context: CommandContext) {
+  return requireContextValue(context.extensions.pluginManager, 'extensions.pluginManager');
+}
+
+export function requirePolicyRuntimeState(context: CommandContext) {
+  return requireContextValue(context.extensions.policyRuntimeState, 'extensions.policyRuntimeState');
+}
+
+export function requireMcpRegistry(context: CommandContext) {
+  return requireContextValue(context.extensions.mcpRegistry, 'extensions.mcpRegistry');
+}
+
+export function requireToolRegistry(context: CommandContext) {
+  return requireContextValue(context.extensions.toolRegistry, 'extensions.toolRegistry');
+}
+
+export function requireHookWorkbench(context: CommandContext) {
+  return requireContextValue(context.extensions.hookWorkbench, 'extensions.hookWorkbench');
+}
+
+export function requireIntegrationHelpers(context: CommandContext) {
+  return requireContextValue(context.extensions.integrationHelpers, 'extensions.integrationHelpers');
+}
+
+export function requireProviderOptimizer(context: CommandContext) {
+  return requireContextValue(context.provider.providerOptimizer, 'provider.providerOptimizer');
+}
+
+export function requireFavoritesStore(context: CommandContext) {
+  return requireContextValue(context.provider.favoritesStore, 'provider.favoritesStore');
+}
+
+export function requireBenchmarkStore(context: CommandContext) {
+  return requireContextValue(context.provider.benchmarkStore, 'provider.benchmarkStore');
+}
+
+export function requireRemoteRuntime(context: CommandContext) {
+  return requireContextValue(context.ops.remoteRuntime, 'ops.remoteRuntime');
+}
+
+export function requireOperatorClient(context: CommandContext): OperatorClient {
+  return requireContextValue(context.clients?.operator, 'clients.operator');
+}
+
+export function requirePeerClient(context: CommandContext): PeerClient {
+  return requireContextValue(context.clients?.peer, 'clients.peer');
+}
+
+export function requireProviderApi(context: CommandContext): ProviderApi {
+  return requireContextValue(context.clients?.providerApi, 'clients.providerApi');
+}
+
+export async function compactConversation(context: CommandContext): Promise<void> {
+  await context.session.conversationManager.compact(
+    context.provider.providerRegistry,
+    context.session.runtime.model,
+    'manual',
+    context.session.runtime.provider,
+  );
+}
+
+export function requireKnowledgeApi(context: CommandContext): KnowledgeApi {
+  return requireContextValue(context.clients?.knowledgeApi, 'clients.knowledgeApi');
+}
+
+export function requireHookApi(context: CommandContext): HookApi {
+  return requireContextValue(context.clients?.hookApi, 'clients.hookApi');
+}
+
+export function requireMcpApi(context: CommandContext): McpApi {
+  return requireContextValue(context.clients?.mcpApi, 'clients.mcpApi');
+}
+
+export function requireOpsApi(context: CommandContext): OpsApi {
+  return requireContextValue(context.clients?.opsApi, 'clients.opsApi');
+}
+
+export function requireDirectTransport(context: CommandContext): DirectTransport {
+  return requireContextValue(context.clients?.transport, 'clients.transport');
+}
+
+export function requireAgentManager(context: CommandContext): ShellAgentManagerService {
+  return requireContextValue(context.ops.agentManager, 'ops.agentManager') as ShellAgentManagerService;
+}
+
+export function requireAcpManager(context: CommandContext): ShellAcpManagerService {
+  return requireContextValue(context.ops.acpManager, 'ops.acpManager') as ShellAcpManagerService;
+}
+
+export function requireModeManager(context: CommandContext): ShellModeManagerService {
+  return requireContextValue(context.ops.modeManager, 'ops.modeManager') as ShellModeManagerService;
+}
+
+export function requireAutomationManager(context: CommandContext): ShellAutomationManagerRuntimeService {
+  return requireContextValue(context.ops.automationManager, 'ops.automationManager') as ShellAutomationManagerRuntimeService;
+}
+
+export function requireSandboxSessionRegistry(context: CommandContext) {
+  return requireContextValue(context.workspace.sandboxSessionRegistry, 'workspace.sandboxSessionRegistry');
+}
+
+export function requireWorktreeRegistry(context: CommandContext) {
+  return requireContextValue(context.workspace.worktreeRegistry, 'workspace.worktreeRegistry');
+}

package/src/input/commands/schedule-runtime.ts

@@ -0,0 +1,91 @@
+import type { CommandRegistry } from '../command-registry.ts';
+import {
+  formatEveryInterval,
+} from '@pellux/goodvibes-sdk/platform/automation';
+import type { AutomationJob } from '@pellux/goodvibes-sdk/platform/automation';
+import type { AutomationScheduleDefinition } from '@pellux/goodvibes-sdk/platform/automation';
+
+function formatSchedule(schedule: AutomationScheduleDefinition): string {
+  switch (schedule.kind) {
+    case 'cron':
+      return [
+        schedule.expression,
+        schedule.timezone ? `[${schedule.timezone}]` : '',
+        schedule.staggerMs !== undefined ? `[stagger ${schedule.staggerMs}ms]` : '',
+      ].filter(Boolean).join(' ');
+    case 'every':
+      return formatEveryInterval(schedule.intervalMs);
+    case 'at':
+      return new Date(schedule.at).toLocaleString();
+  }
+}
+
+function formatNextRun(nextRunAt?: number): string {
+  return nextRunAt ? new Date(nextRunAt).toLocaleString() : 'n/a';
+}
+
+function formatPrompt(job: AutomationJob): string {
+  const prompt = (job.execution.prompt ?? job.description ?? '').trim();
+  return prompt.length > 60 ? `${prompt.slice(0, 60)}...` : prompt;
+}
+
+function printReadOnlyScheduleBoundary(print: (text: string) => void, requestedAction: string): void {
+  print([
+    'GoodVibes Agent schedule commands are read-only in this runtime.',
+    `  requested: ${requestedAction}`,
+    '  policy: no local Agent automation jobs, scheduled spawns, or immediate automation runs',
+    '  use: /schedule list',
+    '  future: mutate schedules through an Agent-safe public daemon route after explicit approval',
+  ].join('\n'));
+}
+
+export function registerScheduleRuntimeCommands(registry: CommandRegistry): void {
+  registry.register({
+    name: 'schedule',
+    aliases: ['sched'],
+    description: 'Inspect automation jobs and scheduled runs',
+    usage: 'list',
+    argsHint: 'list',
+    async handler(args, ctx) {
+      const manager = ctx.ops.automationManager;
+      if (!manager) {
+        ctx.print('Automation manager is not available in this runtime.');
+        return;
+      }
+      const sub = args[0];
+
+      if (!sub || sub === 'list') {
+        const jobs = manager.listJobs();
+        if (jobs.length === 0) {
+          ctx.print(
+            'No automation jobs.\n'
+            + 'Agent schedule commands are read-only here; create/run/enable/disable/remove are blocked until an Agent-safe route exists.'
+          );
+          return;
+        }
+        const lines = ['Automation jobs:', ''];
+        for (const job of jobs) {
+          const status = job.enabled ? '● enabled ' : '○ paused  ';
+          const next = formatNextRun(job.nextRunAt);
+          const last = job.lastRunAt ? new Date(job.lastRunAt).toLocaleString() : 'never';
+          lines.push(`  ${job.id.slice(0, 12)}  ${status} runs:${job.runCount}  next:${next}  last:${last}`);
+          lines.push(`    name: ${job.name}  schedule: ${formatSchedule(job.schedule)}`);
+          lines.push(`    prompt: ${formatPrompt(job)}`);
+        }
+        ctx.print(lines.join('\n'));
+        return;
+      }
+
+      if (sub === 'add' || sub === 'remove' || sub === 'enable' || sub === 'disable' || sub === 'run') {
+        printReadOnlyScheduleBoundary(ctx.print, `/schedule ${args.join(' ')}`.trim());
+        return;
+      }
+
+      ctx.print(
+        'Usage:\n'
+        + '  /schedule list\n'
+        + '  Agent schedule mutations and runs are blocked until an Agent-safe route exists.'
+      );
+    },
+  });
+}

package/src/input/commands/services-runtime.ts

@@ -0,0 +1,209 @@
+import { mkdirSync, readFileSync, writeFileSync } from 'node:fs';
+import { dirname, join, resolve } from 'node:path';
+import type { CommandRegistry } from '../command-registry.ts';
+import type { SelectionAction, SelectionItem } from '../selection-modal.ts';
+import { openCommandPanel, requireServiceRegistry, requireShellPaths } from './runtime-services.ts';
+import { summarizeError } from '@pellux/goodvibes-sdk/platform/utils';
+import { GOODVIBES_AGENT_SURFACE_ROOT } from '../../config/surface.ts';
+
+export function registerServicesRuntimeCommands(registry: CommandRegistry): void {
+  registry.register({
+    name: 'services',
+    aliases: ['svc'],
+    description: 'Manage API service configurations',
+    usage: '[open|list|inspect <name>|test <name>|resolve <name>|auth <name>|auth-review|doctor|export <path>|import <path>]',
+    async handler(args, ctx) {
+      const sub = args[0] ?? 'open';
+      const shellPaths = requireShellPaths(ctx);
+      if (sub === 'open' || sub === 'panel') {
+        openCommandPanel(ctx, 'services');
+        return;
+      }
+      const svcRegistry = requireServiceRegistry(ctx);
+      const all = svcRegistry.getAll();
+      const keys = Object.keys(all);
+      if (sub === 'inspect') {
+        const name = args[1];
+        if (!name) {
+          ctx.print('Usage: /services inspect <name>');
+          return;
+        }
+        const inspection = await svcRegistry.inspect(name);
+        if (!inspection) {
+          ctx.print(`Unknown service: ${name}`);
+          return;
+        }
+        ctx.print([
+          `Service ${name}`,
+          `  authType: ${inspection.config.authType}`,
+          `  baseUrl: ${inspection.config.baseUrl ?? '(none)'}`,
+          `  primaryCredential: ${inspection.hasPrimaryCredential ? 'present' : 'missing'}`,
+          `  passwordCredential: ${inspection.hasPasswordCredential ? 'present' : 'missing'}`,
+          `  webhookUrl: ${inspection.hasWebhookUrl ? 'present' : 'missing'}`,
+          `  signingSecret: ${inspection.hasSigningSecret ? 'present' : 'missing'}`,
+          `  publicKey: ${inspection.hasPublicKey ? 'present' : 'missing'}`,
+          `  appToken: ${inspection.hasAppToken ? 'present' : 'missing'}`,
+        ].join('\n'));
+        return;
+      }
+      if (sub === 'test') {
+        const name = args[1];
+        if (!name) {
+          ctx.print('Usage: /services test <name>');
+          return;
+        }
+        const result = await svcRegistry.testConnection(name);
+        ctx.print([
+          `Service test ${name}`,
+          `  ok: ${result.ok ? 'yes' : 'no'}`,
+          `  status: ${result.status ?? 'n/a'}`,
+          `  url: ${result.testedUrl ?? 'n/a'}`,
+          `  error: ${result.error ?? 'none'}`,
+        ].join('\n'));
+        return;
+      }
+      if (sub === 'resolve') {
+        const name = args[1];
+        if (!name) {
+          ctx.print('Usage: /services resolve <name>');
+          return;
+        }
+        const headers = await svcRegistry.resolveAuth(name);
+        if (!headers) {
+          ctx.print(`Service ${name} has no resolvable auth headers right now.`);
+          return;
+        }
+        ctx.print([
+          `Resolved auth headers for ${name}`,
+          ...Object.keys(headers).map((key) => `  ${key}: <redacted>`),
+        ].join('\n'));
+        return;
+      }
+      if (sub === 'auth') {
+        const name = args[1];
+        if (!name) {
+          ctx.print('Usage: /services auth <name>');
+          return;
+        }
+        const headers = await svcRegistry.resolveAuth(name);
+        if (!headers) {
+          ctx.print(`Service ${name} has no resolvable auth headers right now.`);
+          return;
+        }
+        ctx.print([
+          `Service auth ${name}`,
+          ...Object.keys(headers).map((key) => `  ${key}: <resolved>`),
+        ].join('\n'));
+        return;
+      }
+      if (sub === 'doctor') {
+        const inspections = await Promise.all(keys.map((name) => svcRegistry.inspect(name)));
+        const issues = inspections
+          .filter((inspection): inspection is NonNullable<typeof inspection> => inspection !== null)
+          .flatMap((inspection) => {
+            const findings: string[] = [];
+            if (!inspection.hasPrimaryCredential) findings.push(`${inspection.config.name}: missing primary credential`);
+            if (inspection.config.authType === 'basic' && !inspection.hasPasswordCredential) findings.push(`${inspection.config.name}: missing password credential`);
+            if (!inspection.config.baseUrl) findings.push(`${inspection.config.name}: no baseUrl configured`);
+            return findings;
+          });
+        ctx.print([
+          'Service Doctor',
+          `  configured: ${keys.length}`,
+          `  issues: ${issues.length}`,
+          ...(issues.length > 0 ? issues.map((issue) => `  ${issue}`) : ['  all configured services passed readiness checks']),
+        ].join('\n'));
+        return;
+      }
+      if (sub === 'auth-review') {
+        const inspections = await Promise.all(keys.map((name) => svcRegistry.inspect(name)));
+        const authCounts = new Map<string, number>();
+        const issues = inspections
+          .filter((inspection): inspection is NonNullable<typeof inspection> => inspection !== null)
+          .flatMap((inspection) => {
+            authCounts.set(inspection.config.authType, (authCounts.get(inspection.config.authType) ?? 0) + 1);
+            const findings: string[] = [];
+            if (!inspection.config.baseUrl) findings.push(`${inspection.config.name}: missing baseUrl`);
+            if ((inspection.config.authType === 'bearer' || inspection.config.authType === 'api-key') && !inspection.hasPrimaryCredential) {
+              findings.push(`${inspection.config.name}: missing primary credential`);
+            }
+            if (inspection.config.authType === 'basic' && !inspection.hasPasswordCredential) {
+              findings.push(`${inspection.config.name}: missing password credential`);
+            }
+            return findings;
+          });
+        ctx.print([
+          'Service Auth Review',
+          `  configured: ${keys.length}`,
+          ...[...authCounts.entries()].map(([authType, count]) => `  ${authType}: ${count}`),
+          ...(issues.length > 0 ? ['', ...issues.map((issue) => `  issue: ${issue}`)] : ['', '  all configured services have a complete auth posture']),
+        ].join('\n'));
+        return;
+      }
+      if (sub === 'export') {
+        const pathArg = args[1];
+        if (!pathArg) {
+          ctx.print('Usage: /services export <path>');
+          return;
+        }
+        const targetPath = shellPaths.resolveWorkspacePath(pathArg);
+        mkdirSync(dirname(targetPath), { recursive: true });
+        writeFileSync(targetPath, JSON.stringify(all, null, 2) + '\n', 'utf-8');
+        ctx.print(`Exported services config to ${targetPath}`);
+        return;
+      }
+      if (sub === 'import') {
+        const pathArg = args[1];
+        if (!pathArg) {
+          ctx.print('Usage: /services import <path>');
+          return;
+        }
+        const sourcePath = shellPaths.resolveWorkspacePath(pathArg);
+        try {
+          const parsed = JSON.parse(readFileSync(sourcePath, 'utf-8')) as Record<string, unknown>;
+          const targetPath = shellPaths.resolveProjectPath(GOODVIBES_AGENT_SURFACE_ROOT, 'services.json');
+          mkdirSync(dirname(targetPath), { recursive: true });
+          writeFileSync(targetPath, JSON.stringify(parsed, null, 2) + '\n', 'utf-8');
+          ctx.print(`Imported services config from ${sourcePath}`);
+        } catch (error) {
+          ctx.print(`Failed to import services config: ${summarizeError(error)}`);
+        }
+        return;
+      }
+      if (ctx.openSelection) {
+        const testAction = new Map<string, SelectionAction>([['t', 'select' as const]]);
+        const items: SelectionItem[] = keys.length === 0
+          ? [{ id: '_empty', label: 'No services configured', detail: '.goodvibes/agent/services.json' }]
+          : keys.map((key) => ({ id: key, label: all[key].name ?? key, detail: `${all[key].authType}  ${all[key].baseUrl ?? '(no url)'}`, actions: '[t] test' }));
+        ctx.openSelection('Services', items, { allowSearch: true, customActions: testAction }, (result) => {
+          if (!result || result.item.id === '_empty') return;
+          const svc = all[result.item.id];
+          if (!svc) return;
+          if (result.action === 'select') {
+            void svcRegistry.testConnection(result.item.id).then((testResult) => {
+              ctx.print([
+                `Service test ${result.item.id}`,
+                `  ok: ${testResult.ok ? 'yes' : 'no'}`,
+                `  status: ${testResult.status ?? 'n/a'}`,
+                `  url: ${testResult.testedUrl ?? 'n/a'}`,
+                `  error: ${testResult.error ?? 'none'}`,
+              ].join('\n'));
+            });
+            return;
+          }
+          ctx.print([
+            `Service ${result.item.id}`,
+            `  authType: ${svc.authType}`,
+            `  baseUrl: ${svc.baseUrl ?? '(none)'}`,
+          ].join('\n'));
+        });
+        return;
+      }
+      if (keys.length === 0) {
+        ctx.print('[services] No services configured. Add entries to .goodvibes/agent/services.json');
+        return;
+      }
+      ctx.print(['Services:', '', ...keys.map((key) => `  ${key.padEnd(20)} ${all[key].authType.padEnd(10)} ${all[key].baseUrl ?? '(no url)'}`)].join('\n'));
+    },
+  });
+}