@robota-sdk/agent-command 3.0.0-beta.64

package/src/plugin/__tests__/plugin-command-module.test.ts

@@ -0,0 +1,214 @@
+import type {
+  ICommandHostContext,
+  ICommandPluginAdapter,
+  ICommandSessionRuntime,
+} from '@robota-sdk/agent-framework';
+import { describe, expect, it, vi } from 'vitest';
+import { createPluginCommandModule } from '../plugin-command-module.js';
+import { executePluginCommand, executeReloadPluginsCommand } from '../plugin-command.js';
+
+function createPluginAdapter(overrides?: Partial<ICommandPluginAdapter>): ICommandPluginAdapter {
+  return {
+    listInstalled: vi.fn().mockResolvedValue([]),
+    listAvailablePlugins: vi.fn().mockResolvedValue([]),
+    install: vi.fn().mockResolvedValue(undefined),
+    uninstall: vi.fn().mockResolvedValue(undefined),
+    enable: vi.fn().mockResolvedValue(undefined),
+    disable: vi.fn().mockResolvedValue(undefined),
+    marketplaceAdd: vi.fn().mockResolvedValue('community'),
+    marketplaceRemove: vi.fn().mockResolvedValue(undefined),
+    marketplaceUpdate: vi.fn().mockResolvedValue(undefined),
+    marketplaceList: vi.fn().mockResolvedValue([]),
+    reloadPlugins: vi.fn().mockResolvedValue({ loadedPluginCount: 2 }),
+    ...overrides,
+  };
+}
+
+function createCommandSessionRuntime(): ICommandSessionRuntime {
+  return {
+    clearHistory: () => undefined,
+    compact: async () => undefined,
+    getContextState: () => ({
+      maxTokens: 100,
+      usedTokens: 10,
+      usedPercentage: 10,
+      remainingPercentage: 90,
+    }),
+    getPermissionMode: () => 'default',
+    setPermissionMode: () => undefined,
+    getSessionId: () => 'session_1',
+    getMessageCount: () => 0,
+    getSessionAllowedTools: () => [],
+    getAutoCompactThreshold: () => false,
+  };
+}
+
+function createCommandHostContext(adapter?: ICommandPluginAdapter): ICommandHostContext {
+  const checkpoint = {
+    id: 'checkpoint_1',
+    sessionId: 'session_1',
+    sequence: 1,
+    prompt: 'prompt',
+    createdAt: '2026-05-03T00:00:00.000Z',
+    fileCount: 0,
+  };
+  return {
+    getSession: () => createCommandSessionRuntime(),
+    getContextState: () => ({
+      maxTokens: 100,
+      usedTokens: 10,
+      usedPercentage: 10,
+      remainingPercentage: 90,
+    }),
+    getAutoCompactThreshold: () => 0.8,
+    getCommandHostAdapters: () => (adapter === undefined ? {} : { plugin: adapter }),
+    compactContext: async () => undefined,
+    getCwd: () => '/workspace',
+    listCommands: () => [],
+    listEditCheckpoints: () => [],
+    restoreEditCheckpoint: async () => ({
+      target: checkpoint,
+      restoredCheckpointCount: 0,
+      restoredFileCount: 0,
+      removedCheckpointCount: 0,
+    }),
+    rollbackEditCheckpoint: async () => ({
+      target: checkpoint,
+      restoredCheckpointCount: 0,
+      restoredFileCount: 0,
+      removedCheckpointCount: 0,
+    }),
+    getUsedMemoryReferences: () => [],
+    recordMemoryEvent: () => undefined,
+    listBackgroundTasks: () => [],
+    readBackgroundTaskLog: async (taskId) => ({ taskId, lines: [] }),
+    cancelBackgroundTask: async () => undefined,
+    closeBackgroundTask: async () => undefined,
+  };
+}
+
+describe('createPluginCommandModule', () => {
+  it('contributes plugin command metadata and executable commands', () => {
+    const module = createPluginCommandModule();
+
+    expect(module.name).toBe('agent-command-plugin');
+    expect(module.commandSources?.[0]?.getCommands()).toEqual([
+      expect.objectContaining({
+        name: 'plugin',
+        description: 'Manage plugins',
+        source: 'plugin-manager',
+        modelInvocable: false,
+        argumentHint: expect.stringContaining('install'),
+      }),
+      expect.objectContaining({
+        name: 'reload-plugins',
+        description: 'Reload all plugin resources',
+        source: 'plugin-manager',
+        modelInvocable: false,
+      }),
+    ]);
+    expect(module.systemCommands?.map((command) => command.name)).toEqual([
+      'plugin',
+      'reload-plugins',
+    ]);
+    expect(module.systemCommands?.[0]?.lifecycle).toBe('inline');
+  });
+});
+
+describe('executePluginCommand', () => {
+  it('opens the host plugin manager for empty args', async () => {
+    await expect(executePluginCommand(createCommandHostContext(), '')).resolves.toEqual({
+      success: true,
+      message: 'Opening plugin manager...',
+      effects: [{ type: 'plugin-tui-requested' }],
+    });
+  });
+
+  it('returns unavailable when an operation needs a missing adapter', async () => {
+    await expect(
+      executePluginCommand(createCommandHostContext(), 'install demo@community'),
+    ).resolves.toEqual({
+      success: false,
+      message: 'Plugin management is not available.',
+    });
+  });
+
+  it('installs plugins through the adapter', async () => {
+    const adapter = createPluginAdapter();
+
+    await expect(
+      executePluginCommand(createCommandHostContext(adapter), 'install demo@community'),
+    ).resolves.toEqual({
+      success: true,
+      message: 'Installed plugin: demo@community',
+    });
+    expect(adapter.install).toHaveBeenCalledWith('demo@community');
+  });
+
+  it('lists marketplaces through the adapter', async () => {
+    const adapter = createPluginAdapter({
+      marketplaceList: vi.fn().mockResolvedValue([{ name: 'community', type: 'git' }]),
+    });
+
+    const result = await executePluginCommand(
+      createCommandHostContext(adapter),
+      'marketplace list',
+    );
+
+    expect(result).toEqual({
+      success: true,
+      message: 'Marketplace sources:\n  community (git)',
+    });
+    expect(adapter.marketplaceList).toHaveBeenCalled();
+  });
+
+  it('reports adapter errors as command failures', async () => {
+    const adapter = createPluginAdapter({
+      enable: vi.fn().mockRejectedValue(new Error('not installed')),
+    });
+
+    await expect(
+      executePluginCommand(createCommandHostContext(adapter), 'enable missing@community'),
+    ).resolves.toEqual({
+      success: false,
+      message: 'Plugin error: not installed',
+    });
+  });
+
+  it('returns usage for incomplete subcommands', async () => {
+    await expect(executePluginCommand(createCommandHostContext(), 'disable')).resolves.toEqual({
+      success: false,
+      message: 'Usage: /plugin disable <name>@<marketplace>',
+    });
+  });
+});
+
+describe('executeReloadPluginsCommand', () => {
+  it('reloads plugins through the adapter and requests registry refresh', async () => {
+    const adapter = createPluginAdapter({
+      reloadPlugins: vi.fn().mockResolvedValue({ loadedPluginCount: 3 }),
+    });
+
+    await expect(
+      executeReloadPluginsCommand(createCommandHostContext(adapter), ''),
+    ).resolves.toEqual({
+      success: true,
+      message: 'Reloaded 3 plugin resources.',
+      effects: [{ type: 'plugin-registry-reload-requested' }],
+    });
+    expect(adapter.reloadPlugins).toHaveBeenCalled();
+  });
+
+  it('reports reload failures instead of returning placeholder success', async () => {
+    const adapter = createPluginAdapter({
+      reloadPlugins: vi.fn().mockRejectedValue(new Error('manifest failed')),
+    });
+
+    await expect(
+      executeReloadPluginsCommand(createCommandHostContext(adapter), ''),
+    ).resolves.toEqual({
+      success: false,
+      message: 'Plugin error: manifest failed',
+    });
+  });
+});

package/src/plugin/index.ts

@@ -0,0 +1,7 @@
+export {
+  createPluginCommandEntry,
+  createPluginCommandModule,
+  createReloadPluginsCommandEntry,
+  PluginManagerCommandSource,
+} from './plugin-command-module.js';
+export { executePluginCommand, executeReloadPluginsCommand } from './plugin-command.js';

package/src/plugin/plugin-command-module.ts

@@ -0,0 +1,81 @@
+import type {
+  ICommand,
+  ICommandModule,
+  ICommandSource,
+  ISystemCommand,
+} from '@robota-sdk/agent-framework';
+import {
+  buildPluginCommandSubcommands,
+  PLUGIN_COMMAND_ARGUMENT_HINT,
+  PLUGIN_COMMAND_DESCRIPTION,
+  RELOAD_PLUGINS_COMMAND_DESCRIPTION,
+} from '@robota-sdk/agent-framework';
+import { executePluginCommand, executeReloadPluginsCommand } from './plugin-command.js';
+
+export function createPluginCommandEntry(): ICommand {
+  return {
+    name: 'plugin',
+    displayName: 'Plugins',
+    description: PLUGIN_COMMAND_DESCRIPTION,
+    source: 'plugin-manager',
+    modelInvocable: false,
+    argumentHint: PLUGIN_COMMAND_ARGUMENT_HINT,
+    subcommands: buildPluginCommandSubcommands(),
+  };
+}
+
+export function createReloadPluginsCommandEntry(): ICommand {
+  return {
+    name: 'reload-plugins',
+    displayName: 'Reload Plugins',
+    description: RELOAD_PLUGINS_COMMAND_DESCRIPTION,
+    source: 'plugin-manager',
+    modelInvocable: false,
+  };
+}
+
+function createPluginSystemCommand(): ISystemCommand {
+  const entry = createPluginCommandEntry();
+  return {
+    name: entry.name,
+    displayName: entry.displayName,
+    description: entry.description,
+    requiresPermission: false,
+    userInvocable: true,
+    modelInvocable: false,
+    argumentHint: entry.argumentHint,
+    lifecycle: 'inline',
+    subcommands: entry.subcommands,
+    execute: executePluginCommand,
+  };
+}
+
+function createReloadPluginsSystemCommand(): ISystemCommand {
+  const entry = createReloadPluginsCommandEntry();
+  return {
+    name: entry.name,
+    displayName: entry.displayName,
+    description: entry.description,
+    requiresPermission: false,
+    userInvocable: true,
+    modelInvocable: false,
+    lifecycle: 'inline',
+    execute: executeReloadPluginsCommand,
+  };
+}
+
+export class PluginManagerCommandSource implements ICommandSource {
+  readonly name = 'plugin-manager';
+
+  getCommands(): ICommand[] {
+    return [createPluginCommandEntry(), createReloadPluginsCommandEntry()];
+  }
+}
+
+export function createPluginCommandModule(): ICommandModule {
+  return {
+    name: 'agent-command-plugin',
+    commandSources: [new PluginManagerCommandSource()],
+    systemCommands: [createPluginSystemCommand(), createReloadPluginsSystemCommand()],
+  };
+}

package/src/plugin/plugin-command.ts

@@ -0,0 +1,230 @@
+import type {
+  ICommandHostContext,
+  ICommandPluginAdapter,
+  ICommandResult,
+} from '@robota-sdk/agent-framework';
+import {
+  createPluginRegistryReloadRequestedEffect,
+  createPluginTuiRequestedEffect,
+  resolvePluginCommandAdapter,
+} from '@robota-sdk/agent-framework';
+
+function getSubcommandParts(args: string): { subcommand: string; subArgs: string } {
+  const parts = args
+    .trim()
+    .split(/\s+/)
+    .filter((part) => part.length > 0);
+  return {
+    subcommand: parts[0] ?? '',
+    subArgs: parts.slice(1).join(' ').trim(),
+  };
+}
+
+function usage(message: string): ICommandResult {
+  return {
+    success: false,
+    message,
+  };
+}
+
+function getPluginAdapter(context: ICommandHostContext): ICommandPluginAdapter | undefined {
+  return resolvePluginCommandAdapter(context);
+}
+
+async function executePluginOperation(
+  context: ICommandHostContext,
+  operation: (adapter: ICommandPluginAdapter) => Promise<string>,
+): Promise<ICommandResult> {
+  const adapter = getPluginAdapter(context);
+  if (adapter === undefined) {
+    return {
+      success: false,
+      message: 'Plugin management is not available.',
+    };
+  }
+
+  try {
+    return {
+      success: true,
+      message: await operation(adapter),
+    };
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    return {
+      success: false,
+      message: `Plugin error: ${message}`,
+    };
+  }
+}
+
+async function executeMarketplaceCommand(
+  context: ICommandHostContext,
+  subArgs: string,
+): Promise<ICommandResult> {
+  const { subcommand, subArgs: marketplaceArgs } = getSubcommandParts(subArgs);
+
+  if (subcommand === 'add' && marketplaceArgs.length > 0) {
+    return executePluginOperation(context, async (adapter) => {
+      const registeredName = await adapter.marketplaceAdd(marketplaceArgs);
+      return `Added marketplace: "${registeredName}" (from ${marketplaceArgs})\nInstall plugins with: /plugin install <name>@${registeredName}`;
+    });
+  }
+
+  if (subcommand === 'remove' && marketplaceArgs.length > 0) {
+    return executePluginOperation(context, async (adapter) => {
+      await adapter.marketplaceRemove(marketplaceArgs);
+      return `Removed marketplace "${marketplaceArgs}" and uninstalled its plugins.`;
+    });
+  }
+
+  if (subcommand === 'update' && marketplaceArgs.length > 0) {
+    return executePluginOperation(context, async (adapter) => {
+      await adapter.marketplaceUpdate(marketplaceArgs);
+      return `Updated marketplace "${marketplaceArgs}".`;
+    });
+  }
+
+  if (subcommand === 'list') {
+    return executePluginOperation(context, async (adapter) => {
+      const sources = await adapter.marketplaceList();
+      if (sources.length === 0) {
+        return 'No marketplace sources configured.';
+      }
+      const lines = sources.map((source) => `  ${source.name} (${source.type})`);
+      return `Marketplace sources:\n${lines.join('\n')}`;
+    });
+  }
+
+  return usage('Usage: /plugin marketplace add <source> | remove <name> | update <name> | list');
+}
+
+type TPluginIdOperation = (
+  adapter: ICommandPluginAdapter,
+  pluginId: string,
+) => Promise<string> | string;
+
+function executePluginIdOperation(
+  context: ICommandHostContext,
+  pluginId: string,
+  usageMessage: string,
+  operation: TPluginIdOperation,
+): Promise<ICommandResult> {
+  if (pluginId.length === 0) {
+    return Promise.resolve(usage(usageMessage));
+  }
+  return executePluginOperation(context, (adapter) =>
+    Promise.resolve(operation(adapter, pluginId)),
+  );
+}
+
+function executePluginManager(): ICommandResult {
+  return {
+    success: true,
+    message: 'Opening plugin manager...',
+    effects: [createPluginTuiRequestedEffect()],
+  };
+}
+
+function executeInstallCommand(
+  context: ICommandHostContext,
+  pluginId: string,
+): Promise<ICommandResult> {
+  return executePluginIdOperation(
+    context,
+    pluginId,
+    'Usage: /plugin install <name>@<marketplace>',
+    async (adapter, targetPluginId) => {
+      await adapter.install(targetPluginId);
+      return `Installed plugin: ${targetPluginId}`;
+    },
+  );
+}
+
+function executeUninstallCommand(
+  context: ICommandHostContext,
+  pluginId: string,
+): Promise<ICommandResult> {
+  return executePluginIdOperation(
+    context,
+    pluginId,
+    'Usage: /plugin uninstall <name>@<marketplace>',
+    async (adapter, targetPluginId) => {
+      await adapter.uninstall(targetPluginId);
+      return `Uninstalled plugin: ${targetPluginId}`;
+    },
+  );
+}
+
+function executeEnableCommand(
+  context: ICommandHostContext,
+  pluginId: string,
+): Promise<ICommandResult> {
+  return executePluginIdOperation(
+    context,
+    pluginId,
+    'Usage: /plugin enable <name>@<marketplace>',
+    async (adapter, targetPluginId) => {
+      await adapter.enable(targetPluginId);
+      return `Enabled plugin: ${targetPluginId}`;
+    },
+  );
+}
+
+function executeDisableCommand(
+  context: ICommandHostContext,
+  pluginId: string,
+): Promise<ICommandResult> {
+  return executePluginIdOperation(
+    context,
+    pluginId,
+    'Usage: /plugin disable <name>@<marketplace>',
+    async (adapter, targetPluginId) => {
+      await adapter.disable(targetPluginId);
+      return `Disabled plugin: ${targetPluginId}`;
+    },
+  );
+}
+
+export async function executePluginCommand(
+  context: ICommandHostContext,
+  args: string,
+): Promise<ICommandResult> {
+  const { subcommand, subArgs } = getSubcommandParts(args);
+  switch (subcommand) {
+    case '':
+    case 'manage':
+      return executePluginManager();
+    case 'install':
+      return executeInstallCommand(context, subArgs);
+    case 'uninstall':
+      return executeUninstallCommand(context, subArgs);
+    case 'enable':
+      return executeEnableCommand(context, subArgs);
+    case 'disable':
+      return executeDisableCommand(context, subArgs);
+    case 'marketplace':
+      return executeMarketplaceCommand(context, subArgs);
+    default:
+      return usage(`Unknown plugin subcommand: ${subcommand}`);
+  }
+}
+
+export async function executeReloadPluginsCommand(
+  context: ICommandHostContext,
+  _args: string,
+): Promise<ICommandResult> {
+  return executePluginOperation(context, async (adapter) => {
+    const result = await adapter.reloadPlugins();
+    const suffix =
+      result.loadedPluginCount === 1
+        ? '1 plugin resource'
+        : `${result.loadedPluginCount} plugin resources`;
+    return `Reloaded ${suffix}.`;
+  }).then((result) => {
+    if (!result.success) return result;
+    return {
+      ...result,
+      effects: [createPluginRegistryReloadRequestedEffect()],
+    };
+  });
+}