revisium 2.3.0 → 2.5.0-alpha.0

package/src/commands/auth/__tests__/auth-command.utils.spec.ts

@@ -0,0 +1,41 @@
+import {
+  formatAuthLoginHint,
+  formatAuthRevisiumUrl,
+  formatAuthTarget,
+} from '../auth-command.utils';
+
+describe('auth command formatting helpers', () => {
+  it('formats instance and URL targets consistently', () => {
+    expect(formatAuthTarget('cloud', 'https://cloud.revisium.io')).toBe(
+      'instance "cloud" (https://cloud.revisium.io)',
+    );
+    expect(formatAuthTarget(undefined, 'https://cloud.revisium.io')).toBe(
+      'https://cloud.revisium.io',
+    );
+  });
+
+  it('formats login hints for instance and URL targets', () => {
+    expect(
+      formatAuthLoginHint({
+        instanceName: 'cloud',
+        baseUrl: 'https://cloud.revisium.io',
+        credential: 'admin',
+      }),
+    ).toBe("--instance 'cloud' --credential 'admin' --api-key");
+
+    expect(
+      formatAuthLoginHint({
+        baseUrl: 'https://cloud.revisium.io',
+        credential: 'default',
+      }),
+    ).toBe(
+      "--url 'revisium://cloud.revisium.io' --credential 'default' --api-key",
+    );
+  });
+
+  it('formats HTTP base URLs as revisium URLs', () => {
+    expect(formatAuthRevisiumUrl('http://localhost:9222')).toBe(
+      'revisium+http://localhost:9222',
+    );
+  });
+});

package/src/commands/auth/__tests__/auth-login.command.spec.ts

@@ -0,0 +1,131 @@
+import { AuthLoginCommand } from '../auth-login.command';
+import {
+  CredentialStoreService,
+  CredentialTargetService,
+} from 'src/services/credentials';
+import { InteractiveService, LoggerService } from 'src/services/common';
+
+describe('AuthLoginCommand', () => {
+  let credentialTargets: { resolveRequired: jest.Mock };
+  let credentialStore: { saveApiKey: jest.Mock };
+  let interactive: { promptPassword: jest.Mock };
+  let logger: { success: jest.Mock };
+  let command: AuthLoginCommand;
+
+  beforeEach(() => {
+    credentialTargets = {
+      resolveRequired: jest.fn().mockResolvedValue({
+        baseUrl: 'https://cloud.revisium.io',
+        credential: 'admin',
+        instanceName: 'cloud',
+        authMode: 'stored',
+      }),
+    };
+    credentialStore = {
+      saveApiKey: jest.fn(),
+    };
+    interactive = {
+      promptPassword: jest.fn().mockResolvedValue(' rev_prompt '),
+    };
+    logger = {
+      success: jest.fn(),
+    };
+    command = new AuthLoginCommand(
+      credentialTargets as unknown as CredentialTargetService,
+      credentialStore as unknown as CredentialStoreService,
+      interactive as unknown as InteractiveService,
+      logger as unknown as LoggerService,
+    );
+  });
+
+  it('prompts for an API key and saves it for the resolved target', async () => {
+    await command.run([], {
+      instance: 'cloud',
+      credential: 'admin',
+      apiKey: true,
+    });
+
+    expect(interactive.promptPassword).toHaveBeenCalledWith(
+      'Enter Revisium API key:',
+    );
+    expect(credentialStore.saveApiKey).toHaveBeenCalledWith(
+      {
+        baseUrl: 'https://cloud.revisium.io',
+        credential: 'admin',
+      },
+      'rev_prompt',
+    );
+    expect(logger.success).toHaveBeenCalledWith(
+      'Saved API key credential "admin" for instance "cloud" (https://cloud.revisium.io)',
+    );
+  });
+
+  it('rejects authMode none targets unless force is set', async () => {
+    credentialTargets.resolveRequired.mockResolvedValue({
+      baseUrl: 'http://localhost:9222',
+      credential: 'default',
+      instanceName: 'local',
+      authMode: 'none',
+    });
+
+    await expect(
+      command.run([], {
+        instance: 'local',
+        apiKey: true,
+      }),
+    ).rejects.toThrow('uses authMode "none"');
+
+    expect(credentialStore.saveApiKey).not.toHaveBeenCalled();
+  });
+
+  it('allows forced saves for authMode none targets', async () => {
+    credentialTargets.resolveRequired.mockResolvedValue({
+      baseUrl: 'http://localhost:9222',
+      credential: 'default',
+      instanceName: 'local',
+      authMode: 'none',
+    });
+
+    await command.run([], {
+      instance: 'local',
+      apiKey: true,
+      force: true,
+    });
+
+    expect(credentialStore.saveApiKey).toHaveBeenCalledWith(
+      {
+        baseUrl: 'http://localhost:9222',
+        credential: 'default',
+      },
+      'rev_prompt',
+    );
+  });
+
+  it('requires one API key input mode', async () => {
+    await expect(
+      command.run([], {
+        instance: 'cloud',
+      }),
+    ).rejects.toThrow('Pass --api-key to prompt, or --api-key-stdin');
+
+    await expect(
+      command.run([], {
+        instance: 'cloud',
+        apiKey: true,
+        apiKeyStdin: true,
+      }),
+    ).rejects.toThrow('Use only one credential input');
+  });
+
+  it('parses command options', () => {
+    expect(command.parseUrl('revisium://cloud.revisium.io')).toBe(
+      'revisium://cloud.revisium.io',
+    );
+    expect(command.parseInstance('cloud')).toBe('cloud');
+    expect(command.parseCredential('admin')).toBe('admin');
+    expect(command.parseApiKey()).toBe(true);
+    expect(command.parseApiKeyStdin()).toBe(true);
+    expect(command.parseForce()).toBe(true);
+    expect(command.parseForce('false')).toBe(false);
+  });
+});

package/src/commands/auth/__tests__/auth-logout.command.spec.ts

@@ -0,0 +1,85 @@
+import { AuthLogoutCommand } from '../auth-logout.command';
+import {
+  CredentialStoreService,
+  CredentialTargetService,
+} from 'src/services/credentials';
+import { LoggerService } from 'src/services/common';
+
+describe('AuthLogoutCommand', () => {
+  let credentialTargets: { resolveOrCurrentContext: jest.Mock };
+  let credentialStore: { deleteCredential: jest.Mock };
+  let logger: {
+    success: jest.Mock;
+    warn: jest.Mock;
+  };
+  let command: AuthLogoutCommand;
+
+  beforeEach(() => {
+    credentialTargets = {
+      resolveOrCurrentContext: jest.fn().mockResolvedValue({
+        baseUrl: 'https://cloud.revisium.io',
+        credential: 'admin',
+        instanceName: 'cloud',
+        authMode: 'stored',
+      }),
+    };
+    credentialStore = {
+      deleteCredential: jest.fn().mockReturnValue(true),
+    };
+    logger = {
+      success: jest.fn(),
+      warn: jest.fn(),
+    };
+    command = new AuthLogoutCommand(
+      credentialTargets as unknown as CredentialTargetService,
+      credentialStore as unknown as CredentialStoreService,
+      logger as unknown as LoggerService,
+    );
+  });
+
+  it('deletes a saved credential for the resolved target', async () => {
+    await command.run([], {
+      instance: 'cloud',
+      credential: 'admin',
+    });
+
+    expect(credentialTargets.resolveOrCurrentContext).toHaveBeenCalledWith({
+      instance: 'cloud',
+      credential: 'admin',
+    });
+    expect(credentialStore.deleteCredential).toHaveBeenCalledWith({
+      baseUrl: 'https://cloud.revisium.io',
+      credential: 'admin',
+    });
+    expect(logger.success).toHaveBeenCalledWith(
+      'Deleted saved credential "admin" for instance "cloud" (https://cloud.revisium.io)',
+    );
+    expect(logger.warn).not.toHaveBeenCalled();
+  });
+
+  it('warns when the resolved credential does not exist', async () => {
+    credentialTargets.resolveOrCurrentContext.mockResolvedValue({
+      baseUrl: 'https://cloud.revisium.io',
+      credential: 'default',
+      authMode: 'stored',
+    });
+    credentialStore.deleteCredential.mockReturnValue(false);
+
+    await command.run([], {
+      url: 'revisium://cloud.revisium.io',
+    });
+
+    expect(logger.warn).toHaveBeenCalledWith(
+      'No saved credential "default" found for https://cloud.revisium.io',
+    );
+    expect(logger.success).not.toHaveBeenCalled();
+  });
+
+  it('parses command options', () => {
+    expect(command.parseUrl('revisium://cloud.revisium.io')).toBe(
+      'revisium://cloud.revisium.io',
+    );
+    expect(command.parseInstance('cloud')).toBe('cloud');
+    expect(command.parseCredential('admin')).toBe('admin');
+  });
+});

package/src/commands/auth/__tests__/auth-status.command.spec.ts

@@ -0,0 +1,106 @@
+import { AuthStatusCommand } from '../auth-status.command';
+import {
+  CredentialStoreService,
+  CredentialTargetService,
+} from 'src/services/credentials';
+import { LoggerService } from 'src/services/common';
+
+describe('AuthStatusCommand', () => {
+  let credentialTargets: { resolveOrCurrentContext: jest.Mock };
+  let credentialStore: { hasCredential: jest.Mock };
+  let logger: {
+    info: jest.Mock;
+    success: jest.Mock;
+    warn: jest.Mock;
+  };
+  let command: AuthStatusCommand;
+
+  beforeEach(() => {
+    credentialTargets = {
+      resolveOrCurrentContext: jest.fn().mockResolvedValue({
+        baseUrl: 'https://cloud.revisium.io',
+        credential: 'admin',
+        instanceName: 'cloud',
+        contextName: 'dictionary',
+        authMode: 'stored',
+      }),
+    };
+    credentialStore = {
+      hasCredential: jest.fn().mockReturnValue(true),
+    };
+    logger = {
+      info: jest.fn(),
+      success: jest.fn(),
+      warn: jest.fn(),
+    };
+    command = new AuthStatusCommand(
+      credentialTargets as unknown as CredentialTargetService,
+      credentialStore as unknown as CredentialStoreService,
+      logger as unknown as LoggerService,
+    );
+  });
+
+  it('prints saved credential status for the current context', async () => {
+    await command.run([], {});
+
+    expect(credentialTargets.resolveOrCurrentContext).toHaveBeenCalledWith({});
+    expect(credentialStore.hasCredential).toHaveBeenCalledWith({
+      baseUrl: 'https://cloud.revisium.io',
+      credential: 'admin',
+    });
+    expect(logger.info).toHaveBeenCalledWith('Context: dictionary');
+    expect(logger.info).toHaveBeenCalledWith('Instance: cloud');
+    expect(logger.info).toHaveBeenCalledWith(
+      'Base URL: https://cloud.revisium.io',
+    );
+    expect(logger.info).toHaveBeenCalledWith('Credential: admin');
+    expect(logger.info).toHaveBeenCalledWith('Auth mode: stored');
+    expect(logger.success).toHaveBeenCalledWith('Saved credential found');
+    expect(logger.warn).not.toHaveBeenCalled();
+  });
+
+  it('prints a login hint when the target has no saved credential', async () => {
+    credentialTargets.resolveOrCurrentContext.mockResolvedValue({
+      baseUrl: 'https://cloud.revisium.io',
+      credential: 'default',
+      authMode: 'stored',
+    });
+    credentialStore.hasCredential.mockReturnValue(false);
+
+    await command.run([], {
+      url: 'revisium://cloud.revisium.io/admin/dictionary/master',
+    });
+
+    expect(logger.warn).toHaveBeenCalledWith(
+      "No saved credential found. Run: revisium auth login --url 'revisium://cloud.revisium.io' --credential 'default' --api-key",
+    );
+  });
+
+  it('does not read the credential store for authMode none targets', async () => {
+    credentialTargets.resolveOrCurrentContext.mockResolvedValue({
+      baseUrl: 'http://localhost:9222',
+      credential: 'default',
+      instanceName: 'local',
+      authMode: 'none',
+    });
+
+    await command.run([], {
+      instance: 'local',
+    });
+
+    expect(logger.info).toHaveBeenCalledWith(
+      'Saved credentials are bypassed for authMode "none".',
+    );
+    expect(credentialStore.hasCredential).not.toHaveBeenCalled();
+    expect(logger.success).not.toHaveBeenCalled();
+    expect(logger.warn).not.toHaveBeenCalled();
+  });
+
+  it('parses command options', () => {
+    expect(command.parseUrl('revisium://cloud.revisium.io')).toBe(
+      'revisium://cloud.revisium.io',
+    );
+    expect(command.parseInstance('cloud')).toBe('cloud');
+    expect(command.parseCredential('admin')).toBe('admin');
+  });
+});

package/src/commands/auth/__tests__/auth.command.spec.ts

@@ -0,0 +1,18 @@
+import { AuthCommand } from '../auth.command';
+
+describe('AuthCommand', () => {
+  it('shows help when no auth subcommand is provided', async () => {
+    const command = new AuthCommand();
+    const help = jest.fn();
+
+    Object.assign(command, {
+      command: {
+        help,
+      },
+    });
+
+    await command.run();
+
+    expect(help).toHaveBeenCalled();
+  });
+});

package/src/commands/auth/auth-command.utils.ts

@@ -0,0 +1,36 @@
+export interface AuthCommandTarget {
+  instanceName?: string;
+  baseUrl: string;
+  credential: string;
+}
+
+function quoteArg(value: string): string {
+  if (process.platform === 'win32') {
+    return `"${value.replaceAll('"', '""')}"`;
+  }
+  const escaped = value.replaceAll("'", String.raw`'\''`);
+  return `'${escaped}'`;
+}
+
+export function formatAuthTarget(
+  instanceName: string | undefined,
+  baseUrl: string,
+): string {
+  return instanceName ? `instance "${instanceName}" (${baseUrl})` : baseUrl;
+}
+
+export function formatAuthLoginHint(target: AuthCommandTarget): string {
+  const targetSelector = target.instanceName
+    ? `--instance ${quoteArg(target.instanceName)}`
+    : `--url ${quoteArg(formatAuthRevisiumUrl(target.baseUrl))}`;
+
+  return `${targetSelector} --credential ${quoteArg(target.credential)} --api-key`;
+}
+
+export function formatAuthRevisiumUrl(baseUrl: string): string {
+  if (baseUrl.startsWith('http://')) {
+    return `revisium+http://${baseUrl.slice('http://'.length)}`;
+  }
+
+  return `revisium://${baseUrl.replace(/^https:\/\//, '')}`;
+}

package/src/commands/auth/auth-login.command.ts

@@ -0,0 +1,146 @@
+import { CommandRunner, Option, SubCommand } from 'nest-commander';
+import {
+  CredentialStoreService,
+  CredentialTargetService,
+} from 'src/services/credentials';
+import { InteractiveService, LoggerService } from 'src/services/common';
+import { parseBooleanOption } from 'src/utils/parse-boolean.utils';
+import { formatAuthTarget } from './auth-command.utils';
+
+interface Options {
+  url?: string;
+  instance?: string;
+  credential?: string;
+  apiKey?: boolean;
+  apiKeyStdin?: boolean;
+  force?: boolean;
+}
+
+@SubCommand({
+  name: 'login',
+  description: 'Save an API key in the OS credential store',
+})
+export class AuthLoginCommand extends CommandRunner {
+  constructor(
+    private readonly credentialTargets: CredentialTargetService,
+    private readonly credentialStore: CredentialStoreService,
+    private readonly interactive: InteractiveService,
+    private readonly logger: LoggerService,
+  ) {
+    super();
+  }
+
+  async run(_inputs: string[], options: Options): Promise<void> {
+    if (options.apiKey && options.apiKeyStdin) {
+      throw new Error(
+        'Use only one credential input: --api-key or --api-key-stdin',
+      );
+    }
+    if (!options.apiKey && !options.apiKeyStdin) {
+      throw new Error(
+        'Pass --api-key to prompt, or --api-key-stdin for scripts',
+      );
+    }
+
+    const target = await this.credentialTargets.resolveRequired(options);
+    if (target.authMode === 'none' && !options.force) {
+      throw new Error(
+        `Instance "${target.instanceName || target.baseUrl}" uses authMode "none". Pass --force to save credentials anyway.`,
+      );
+    }
+
+    const apiKey = options.apiKeyStdin
+      ? await this.readApiKeyFromStdin()
+      : await this.promptForApiKey();
+
+    this.credentialStore.saveApiKey(
+      {
+        baseUrl: target.baseUrl,
+        credential: target.credential,
+      },
+      apiKey,
+    );
+
+    this.logger.success(
+      `Saved API key credential "${target.credential}" for ${formatAuthTarget(target.instanceName, target.baseUrl)}`,
+    );
+  }
+
+  private async promptForApiKey(): Promise<string> {
+    const apiKey = await this.interactive.promptPassword(
+      'Enter Revisium API key:',
+    );
+    return this.validateApiKey(apiKey);
+  }
+
+  private async readApiKeyFromStdin(): Promise<string> {
+    const chunks: Buffer[] = [];
+
+    for await (const chunk of process.stdin) {
+      chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(String(chunk)));
+      if (Buffer.concat(chunks).includes(10)) {
+        break;
+      }
+    }
+
+    return this.validateApiKey(
+      Buffer.concat(chunks).toString('utf-8').split(/\r?\n/, 1)[0],
+    );
+  }
+
+  private validateApiKey(value: string | undefined): string {
+    const apiKey = value?.trim();
+    if (!apiKey) {
+      throw new Error('API key cannot be empty');
+    }
+    return apiKey;
+  }
+
+  @Option({
+    flags: '--url <url>',
+    description: 'Revisium server or target URL',
+  })
+  parseUrl(value: string) {
+    return value;
+  }
+
+  @Option({
+    flags: '--instance <name>',
+    description: 'Instance name from workspace config',
+  })
+  parseInstance(value: string) {
+    return value;
+  }
+
+  @Option({
+    flags: '--credential <name>',
+    description: 'Credential name (default: default)',
+  })
+  parseCredential(value: string) {
+    return value;
+  }
+
+  @Option({
+    flags: '--api-key',
+    description: 'Prompt for an API key and save it',
+  })
+  parseApiKey(): boolean {
+    return true;
+  }
+
+  @Option({
+    flags: '--api-key-stdin',
+    description: 'Read one API key line from stdin and save it',
+  })
+  parseApiKeyStdin(): boolean {
+    return true;
+  }
+
+  @Option({
+    flags: '--force [boolean]',
+    description: 'Allow saving credentials for an authMode none instance',
+  })
+  parseForce(value?: string): boolean {
+    return parseBooleanOption(value);
+  }
+}

package/src/commands/auth/auth-logout.command.ts

@@ -0,0 +1,71 @@
+import { CommandRunner, Option, SubCommand } from 'nest-commander';
+import {
+  CredentialStoreService,
+  CredentialTargetService,
+} from 'src/services/credentials';
+import { LoggerService } from 'src/services/common';
+import { formatAuthTarget } from './auth-command.utils';
+
+interface Options {
+  url?: string;
+  instance?: string;
+  credential?: string;
+}
+
+@SubCommand({
+  name: 'logout',
+  description: 'Delete a saved Revisium credential',
+})
+export class AuthLogoutCommand extends CommandRunner {
+  constructor(
+    private readonly credentialTargets: CredentialTargetService,
+    private readonly credentialStore: CredentialStoreService,
+    private readonly logger: LoggerService,
+  ) {
+    super();
+  }
+
+  async run(_inputs: string[], options: Options): Promise<void> {
+    const target =
+      await this.credentialTargets.resolveOrCurrentContext(options);
+    const deleted = this.credentialStore.deleteCredential({
+      baseUrl: target.baseUrl,
+      credential: target.credential,
+    });
+
+    if (deleted) {
+      this.logger.success(
+        `Deleted saved credential "${target.credential}" for ${formatAuthTarget(target.instanceName, target.baseUrl)}`,
+      );
+      return;
+    }
+
+    this.logger.warn(
+      `No saved credential "${target.credential}" found for ${formatAuthTarget(target.instanceName, target.baseUrl)}`,
+    );
+  }
+
+  @Option({
+    flags: '--url <url>',
+    description: 'Revisium server or target URL',
+  })
+  parseUrl(value: string) {
+    return value;
+  }
+
+  @Option({
+    flags: '--instance <name>',
+    description: 'Instance name from workspace config',
+  })
+  parseInstance(value: string) {
+    return value;
+  }
+
+  @Option({
+    flags: '--credential <name>',
+    description: 'Credential name',
+  })
+  parseCredential(value: string) {
+    return value;
+  }
+}