revisium 2.3.0 → 2.5.0-alpha.0

package/src/services/url/__tests__/url-parser.service.spec.ts

@@ -0,0 +1,162 @@
+import { UrlParserService } from '../url-parser.service';
+
+describe('UrlParserService', () => {
+  let service: UrlParserService;
+
+  beforeEach(() => {
+    service = new UrlParserService();
+  });
+
+  describe('parse - revisium+http://', () => {
+    it('forces HTTP for non-localhost host', () => {
+      const result = service.parse(
+        'revisium+http://admin:pass@my-service:80/org/proj/branch',
+      );
+
+      expect(result).toEqual({
+        baseUrl: 'http://my-service:80',
+        username: 'admin',
+        password: 'pass',
+        token: undefined,
+        apikey: undefined,
+        organization: 'org',
+        project: 'proj',
+        branch: 'branch',
+        revision: undefined,
+      });
+    });
+
+    it('forces HTTP for non-localhost host with draft revision', () => {
+      const result = service.parse(
+        'revisium+http://admin:pass@my-service:80/org/proj/branch:draft',
+      );
+
+      expect(result).toEqual({
+        baseUrl: 'http://my-service:80',
+        username: 'admin',
+        password: 'pass',
+        token: undefined,
+        apikey: undefined,
+        organization: 'org',
+        project: 'proj',
+        branch: 'branch',
+        revision: 'draft',
+      });
+    });
+
+    it('forces HTTP without port', () => {
+      const result = service.parse(
+        'revisium+http://admin:pass@my-service/org/proj/branch',
+      );
+
+      expect(result).toEqual({
+        baseUrl: 'http://my-service',
+        username: 'admin',
+        password: 'pass',
+        token: undefined,
+        apikey: undefined,
+        organization: 'org',
+        project: 'proj',
+        branch: 'branch',
+        revision: undefined,
+      });
+    });
+
+    it('forces HTTP with token auth', () => {
+      const result = service.parse(
+        'revisium+http://payment-svc:80/org/proj/master?token=abc123',
+      );
+
+      expect(result).toEqual({
+        baseUrl: 'http://payment-svc:80',
+        username: undefined,
+        password: undefined,
+        token: 'abc123',
+        apikey: undefined,
+        organization: 'org',
+        project: 'proj',
+        branch: 'master',
+        revision: undefined,
+      });
+    });
+  });
+
+  describe('parse - revisium+https://', () => {
+    it('forces HTTPS for any host', () => {
+      const result = service.parse(
+        'revisium+https://admin:pass@my-service/org/proj/branch',
+      );
+
+      expect(result).toEqual({
+        baseUrl: 'https://my-service',
+        username: 'admin',
+        password: 'pass',
+        token: undefined,
+        apikey: undefined,
+        organization: 'org',
+        project: 'proj',
+        branch: 'branch',
+        revision: undefined,
+      });
+    });
+
+    it('forces HTTPS even for localhost', () => {
+      const result = service.parse(
+        'revisium+https://admin:pass@localhost:8443/org/proj/main',
+      );
+
+      expect(result).toEqual({
+        baseUrl: 'https://localhost:8443',
+        username: 'admin',
+        password: 'pass',
+        token: undefined,
+        apikey: undefined,
+        organization: 'org',
+        project: 'proj',
+        branch: 'main',
+        revision: undefined,
+      });
+    });
+  });
+
+  describe('parse - revisium:// (unchanged behavior)', () => {
+    it('auto-detects http for localhost', () => {
+      const result = service.parse(
+        'revisium://admin:pass@localhost:8888/org/proj/branch',
+      );
+
+      expect(result.baseUrl).toBe('http://localhost:8888');
+    });
+
+    it('auto-detects https for remote host', () => {
+      const result = service.parse(
+        'revisium://admin:pass@cloud.revisium.io/org/proj/branch',
+      );
+
+      expect(result.baseUrl).toBe('https://cloud.revisium.io');
+    });
+  });
+
+  describe('buildBaseUrlFromHost - protocolOverride', () => {
+    it('uses override when provided', () => {
+      expect(service.buildBaseUrlFromHost('my-service:80', 'http')).toBe(
+        'http://my-service:80',
+      );
+    });
+
+    it('override takes precedence over localhost auto-detect', () => {
+      expect(service.buildBaseUrlFromHost('localhost:8080', 'https')).toBe(
+        'https://localhost:8080',
+      );
+    });
+
+    it('falls back to auto-detect when no override', () => {
+      expect(service.buildBaseUrlFromHost('localhost:8080')).toBe(
+        'http://localhost:8080',
+      );
+      expect(service.buildBaseUrlFromHost('cloud.revisium.io')).toBe(
+        'https://cloud.revisium.io',
+      );
+    });
+  });
+});

package/src/services/url/auth-prompt.service.ts

@@ -1,9 +1,10 @@
 import { Injectable } from '@nestjs/common';
 import { InteractiveService } from '../common';
 
-export type AuthMethod = 'token' | 'apikey' | 'password';
+export type AuthMethod = 'none' | 'token' | 'apikey' | 'password';
 
 export type AuthCredentials =
+  | { method: 'none' }
   | { method: 'token'; token: string }
   | { method: 'apikey'; apikey: string }
   | { method: 'password'; username: string; password: string };
@@ -27,6 +28,10 @@ export class AuthPromptService {
       ],
     );
 
+    if (authMethod === 'none') {
+      return { method: 'none' };
+    }
+
     if (authMethod === 'token') {
       const token = await this.interactive.promptPassword(
         `[${label}] Paste token:`,

package/src/services/url/url-builder.service.ts

@@ -46,6 +46,10 @@ export class UrlBuilderService {
 
     const basePath = `revisium://${baseUrlWithoutProtocol}/${url.organization}/${url.project}${branchPart}`;
 
+    if (url.auth.method === 'none') {
+      return basePath;
+    }
+
     if (url.auth.method === 'token') {
       const tokenValue = maskSecrets ? '****' : url.auth.token;
       return `${basePath}?token=${tokenValue}`;

package/src/services/url/url-parser.service.ts

@@ -27,6 +27,14 @@ function validatePort(port: number, context: string): void {
 @Injectable()
 export class UrlParserService {
   parse(input: string): RevisiumUrl {
+    if (input.startsWith('revisium+http://')) {
+      return this.parseRevisiumUrl(input, 'http');
+    }
+
+    if (input.startsWith('revisium+https://')) {
+      return this.parseRevisiumUrl(input, 'https');
+    }
+
     if (input.startsWith('revisium://')) {
       return this.parseRevisiumUrl(input);
     }
@@ -39,7 +47,10 @@ export class UrlParserService {
     return `${protocol}://${host}${portSuffix}`;
   }
 
-  buildBaseUrlFromHost(hostWithPort: string): string {
+  buildBaseUrlFromHost(
+    hostWithPort: string,
+    protocolOverride?: 'http' | 'https',
+  ): string {
     const [host, portStr] = hostWithPort.split(':');
     const port = portStr ? Number.parseInt(portStr, 10) : undefined;
 
@@ -47,8 +58,9 @@ export class UrlParserService {
       validatePort(port, `in "${hostWithPort}"`);
     }
 
-    const isLocalhost = LOCALHOST_HOSTS.has(host.toLowerCase());
-    const protocol = isLocalhost ? 'http' : 'https';
+    const protocol =
+      protocolOverride ??
+      (LOCALHOST_HOSTS.has(host.toLowerCase()) ? 'http' : 'https');
 
     if (port) {
       return this.buildBaseUrl(protocol, host, port);
@@ -65,8 +77,11 @@ export class UrlParserService {
     validatePort(port, context);
   }
 
-  private parseRevisiumUrl(url: string): RevisiumUrl {
-    const withoutProtocol = url.replace('revisium://', '');
+  private parseRevisiumUrl(
+    url: string,
+    forceProtocol?: 'http' | 'https',
+  ): RevisiumUrl {
+    const withoutProtocol = url.replace(/^revisium(\+https?)?:\/\//, '');
 
     const [mainPart, queryString] = withoutProtocol.split('?');
     const queryParams = this.parseQueryParams(queryString);
@@ -104,7 +119,7 @@ export class UrlParserService {
     const pathParts = hostAndPath.split('/');
     const hostWithPort = pathParts[0];
 
-    const baseUrl = this.buildBaseUrlFromHost(hostWithPort);
+    const baseUrl = this.buildBaseUrlFromHost(hostWithPort, forceProtocol);
 
     const branchWithRevision = pathParts[3] || undefined;
     let branch: string | undefined;

package/src/services/workspace/__tests__/workspace-config.service.spec.ts

@@ -0,0 +1,378 @@
+import { mkdtemp, mkdir, readFile, rm, writeFile } from 'node:fs/promises';
+import { join } from 'node:path';
+import { tmpdir } from 'node:os';
+import { WorkspaceConfigService } from '../workspace-config.service';
+import { UrlParserService } from '../../url/url-parser.service';
+import { CredentialStoreService } from '../../credentials';
+
+describe('WorkspaceConfigService', () => {
+  let service: WorkspaceConfigService;
+  let tempDir: string;
+
+  beforeEach(async () => {
+    service = new WorkspaceConfigService(new UrlParserService());
+    tempDir = await mkdtemp(join(tmpdir(), 'revisium-cli-workspace-'));
+  });
+
+  afterEach(async () => {
+    await rm(tempDir, { recursive: true, force: true });
+  });
+
+  it('writes and discovers the nearest workspace config from a child folder', async () => {
+    const loaded = await service.loadOrCreate(tempDir);
+    loaded.config.instances.local = {
+      baseUrl: 'http://localhost:9222',
+      authMode: 'none',
+    };
+    await service.save(loaded.path, loaded.config);
+
+    const childDir = join(tempDir, 'examples', 'dictionary');
+    await mkdir(childDir, { recursive: true });
+
+    const discovered = await service.load(childDir);
+
+    expect(discovered?.path).toBe(loaded.path);
+    expect(discovered?.config.instances.local).toEqual({
+      baseUrl: 'http://localhost:9222',
+      authMode: 'none',
+    });
+  });
+
+  it('normalizes revisium URLs to server base URLs', () => {
+    expect(
+      service.normalizeBaseUrl('revisium://localhost:9222/admin/proj'),
+    ).toBe('http://localhost:9222');
+    expect(service.normalizeBaseUrl('https://cloud.revisium.io/')).toBe(
+      'https://cloud.revisium.io',
+    );
+  });
+
+  it('rejects direct http instance URLs with missing host or extra target path', () => {
+    expect(() => service.normalizeBaseUrl('https://')).toThrow(
+      'Use http(s)://host[:port]',
+    );
+    expect(() =>
+      service.normalizeBaseUrl('https://cloud.revisium.io/admin/dictionary'),
+    ).toThrow('Use http(s)://host[:port]');
+    expect(() =>
+      service.normalizeBaseUrl('https://cloud.revisium.io?token=secret'),
+    ).toThrow('Use http(s)://host[:port]');
+  });
+
+  it('parses context URLs with default branch and revision', () => {
+    expect(
+      service.parseContextUrl('revisium://localhost:9222/admin/dictionary'),
+    ).toEqual({
+      baseUrl: 'http://localhost:9222',
+      organization: 'admin',
+      project: 'dictionary',
+      branch: 'master',
+      revision: 'draft',
+    });
+  });
+
+  it('resolves no-auth workspace contexts', () => {
+    const url = service.resolveConnection(
+      {
+        path: join(tempDir, '.revisium', 'revisium-cli.config.json'),
+        config: {
+          version: 1,
+          currentContext: 'dictionary-local',
+          instances: {
+            local: {
+              baseUrl: 'http://localhost:9222',
+              authMode: 'none',
+            },
+          },
+          contexts: {
+            'dictionary-local': {
+              instance: 'local',
+              organization: 'admin',
+              project: 'dictionary',
+            },
+          },
+        },
+      },
+      undefined,
+      {},
+    );
+
+    expect(url).toEqual({
+      baseUrl: 'http://localhost:9222',
+      auth: { method: 'none' },
+      organization: 'admin',
+      project: 'dictionary',
+      branch: 'master',
+      revision: 'draft',
+    });
+  });
+
+  it('loads an existing context with its config path', async () => {
+    const loaded = await service.loadOrCreate(tempDir);
+    loaded.config.contexts.demo = {
+      instance: 'local',
+      organization: 'admin',
+      project: 'dictionary',
+    };
+    await service.save(loaded.path, loaded.config);
+
+    const result = await service.loadContext('demo', tempDir);
+
+    expect(result.loaded.path).toBe(loaded.path);
+    expect(result.context.project).toBe('dictionary');
+  });
+
+  it('fails when loading a missing context', async () => {
+    const loaded = await service.loadOrCreate(tempDir);
+    await service.save(loaded.path, loaded.config);
+
+    await expect(service.loadContext('missing', tempDir)).rejects.toThrow(
+      'Revisium context "missing" was not found',
+    );
+  });
+
+  it('lets environment credentials override no-auth mode', () => {
+    const url = service.resolveConnection(
+      {
+        path: join(tempDir, '.revisium', 'revisium-cli.config.json'),
+        config: {
+          version: 1,
+          currentContext: 'dictionary-local',
+          instances: {
+            local: {
+              baseUrl: 'http://localhost:9222',
+              authMode: 'none',
+            },
+          },
+          contexts: {
+            'dictionary-local': {
+              instance: 'local',
+              organization: 'admin',
+              project: 'dictionary',
+            },
+          },
+        },
+      },
+      undefined,
+      { apikey: 'rev_test' },
+    );
+
+    expect(url.auth).toEqual({ method: 'apikey', apikey: 'rev_test' });
+  });
+
+  it('resolves saved credentials for stored workspace contexts', () => {
+    const credentialStore = {
+      getCredential: jest
+        .fn()
+        .mockReturnValue({ method: 'apikey', apikey: 'rev_saved' }),
+    } as unknown as CredentialStoreService;
+    service = new WorkspaceConfigService(
+      new UrlParserService(),
+      credentialStore,
+    );
+
+    const url = service.resolveConnection(
+      {
+        path: join(tempDir, '.revisium', 'revisium-cli.config.json'),
+        config: {
+          version: 1,
+          currentContext: 'cloud',
+          instances: {
+            cloud: {
+              baseUrl: 'https://cloud.revisium.io',
+              authMode: 'stored',
+            },
+          },
+          contexts: {
+            cloud: {
+              instance: 'cloud',
+              credential: 'admin',
+              organization: 'admin',
+              project: 'dictionary',
+            },
+          },
+        },
+      },
+      undefined,
+      {},
+    );
+
+    expect(url.auth).toEqual({ method: 'apikey', apikey: 'rev_saved' });
+    expect(credentialStore.getCredential).toHaveBeenCalledWith({
+      baseUrl: 'https://cloud.revisium.io',
+      credential: 'admin',
+    });
+  });
+
+  it('lets environment credentials override saved credentials', () => {
+    const credentialStore = {
+      getCredential: jest.fn(),
+    } as unknown as CredentialStoreService;
+    service = new WorkspaceConfigService(
+      new UrlParserService(),
+      credentialStore,
+    );
+
+    const url = service.resolveConnection(
+      {
+        path: join(tempDir, '.revisium', 'revisium-cli.config.json'),
+        config: {
+          version: 1,
+          currentContext: 'cloud',
+          instances: {
+            cloud: {
+              baseUrl: 'https://cloud.revisium.io',
+              authMode: 'stored',
+            },
+          },
+          contexts: {
+            cloud: {
+              instance: 'cloud',
+              credential: 'admin',
+              organization: 'admin',
+              project: 'dictionary',
+            },
+          },
+        },
+      },
+      undefined,
+      { apikey: 'rev_env' },
+    );
+
+    expect(url.auth).toEqual({ method: 'apikey', apikey: 'rev_env' });
+    expect(credentialStore.getCredential).not.toHaveBeenCalled();
+  });
+
+  it('fails with remediation when stored credentials cannot be read', () => {
+    const credentialStore = {
+      getCredential: jest.fn(() => {
+        throw new Error(
+          'Could not read Revisium credential "admin" for https://cloud.revisium.io: keyring unavailable',
+        );
+      }),
+    } as unknown as CredentialStoreService;
+    service = new WorkspaceConfigService(
+      new UrlParserService(),
+      credentialStore,
+    );
+
+    expect(() =>
+      service.resolveConnection(
+        {
+          path: join(tempDir, '.revisium', 'revisium-cli.config.json'),
+          config: {
+            version: 1,
+            currentContext: 'cloud',
+            instances: {
+              cloud: {
+                baseUrl: 'https://cloud.revisium.io',
+                authMode: 'stored',
+              },
+            },
+            contexts: {
+              cloud: {
+                instance: 'cloud',
+                credential: 'admin',
+                organization: 'admin',
+                project: 'dictionary',
+              },
+            },
+          },
+        },
+        undefined,
+        {},
+      ),
+    ).toThrow(
+      'No credentials found for context "cloud" credential "admin". Could not read the OS credential store',
+    );
+  });
+
+  it('fails with remediation when stored credentials are required', () => {
+    expect(() =>
+      service.resolveConnection(
+        {
+          path: join(tempDir, '.revisium', 'revisium-cli.config.json'),
+          config: {
+            version: 1,
+            currentContext: 'cloud',
+            instances: {
+              cloud: {
+                baseUrl: 'https://cloud.revisium.io',
+                authMode: 'stored',
+              },
+            },
+            contexts: {
+              cloud: {
+                instance: 'cloud',
+                credential: 'admin',
+                organization: 'admin',
+                project: 'dictionary',
+              },
+            },
+          },
+        },
+        undefined,
+        {},
+      ),
+    ).toThrow(
+      'No credentials found for context "cloud" credential "admin". Run: revisium auth login --instance cloud --credential admin --api-key.',
+    );
+  });
+
+  it('rejects malformed config files', async () => {
+    const configPath = service.getDefaultConfigPath(tempDir);
+    await mkdir(join(tempDir, '.revisium'), { recursive: true });
+    await writeFile(configPath, '{"version":2}', 'utf-8');
+
+    await expect(service.load(tempDir)).rejects.toThrow(
+      'unsupported version 2',
+    );
+  });
+
+  it('normalizes instance base URLs when loading config files', async () => {
+    const configPath = service.getDefaultConfigPath(tempDir);
+    await mkdir(join(tempDir, '.revisium'), { recursive: true });
+    await writeFile(
+      configPath,
+      JSON.stringify({
+        version: 1,
+        instances: {
+          cloud: {
+            baseUrl: 'https://cloud.revisium.io/',
+            authMode: 'stored',
+          },
+        },
+        contexts: {},
+      }),
+      'utf-8',
+    );
+
+    const loaded = await service.load(tempDir);
+
+    expect(loaded?.config.instances.cloud.baseUrl).toBe(
+      'https://cloud.revisium.io',
+    );
+  });
+
+  it('writes only the workspace config file when saving', async () => {
+    const loaded = await service.loadOrCreate(tempDir);
+    loaded.config.instances.local = {
+      baseUrl: 'http://localhost:9222',
+      authMode: 'none',
+    };
+
+    await service.save(loaded.path, loaded.config);
+
+    const raw = await readFile(loaded.path, 'utf-8');
+    expect(JSON.parse(raw)).toEqual({
+      version: 1,
+      instances: {
+        local: {
+          baseUrl: 'http://localhost:9222',
+          authMode: 'none',
+        },
+      },
+      contexts: {},
+    });
+  });
+});

package/src/services/workspace/index.ts

@@ -0,0 +1,14 @@
+export {
+  DEFAULT_BRANCH,
+  DEFAULT_CREDENTIAL,
+  DEFAULT_REVISION,
+  LoadedWorkspaceContext,
+  LoadedWorkspaceConfig,
+  WORKSPACE_CONFIG_DIR,
+  WORKSPACE_CONFIG_FILE,
+  WorkspaceAuthMode,
+  WorkspaceConfig,
+  WorkspaceConfigService,
+  WorkspaceContextConfig,
+  WorkspaceInstanceConfig,
+} from './workspace-config.service';