@amodalai/amodal 0.1.2

package/src/auth/prompt.test.ts

@@ -0,0 +1,205 @@
+/**
+ * @license
+ * Copyright 2025 Amodal Labs, Inc.
+ * SPDX-License-Identifier: MIT
+ */
+
+import {describe, it, expect, vi, beforeEach} from 'vitest';
+import type {PackageAuth} from '@amodalai/core';
+
+const mockFindMissingEnvVars = vi.fn<(path: string, required: string[]) => Promise<string[]>>();
+const mockUpsertEnvEntries = vi.fn<(path: string, entries: Record<string, string>) => Promise<void>>();
+const mockPrompts = vi.fn();
+
+vi.mock('@amodalai/core', () => ({
+  findMissingEnvVars: (...args: unknown[]) => mockFindMissingEnvVars(args[0] as string, args[1] as string[]),
+  upsertEnvEntries: (...args: unknown[]) => mockUpsertEnvEntries(args[0] as string, args[1] as Record<string, string>),
+}));
+
+vi.mock('prompts', () => ({
+  default: (...args: unknown[]) => mockPrompts(...args),
+}));
+
+import {getRequiredEnvVars, promptForCredentials} from './prompt.js';
+
+describe('getRequiredEnvVars', () => {
+  it('returns envVars keys for bearer auth', () => {
+    const auth: PackageAuth = {
+      type: 'bearer',
+      envVars: {API_TOKEN: 'Your API token'},
+    };
+    expect(getRequiredEnvVars(auth)).toEqual(['API_TOKEN']);
+  });
+
+  it('returns envVars keys for oauth2 auth', () => {
+    const auth: PackageAuth = {
+      type: 'oauth2',
+      authorizeUrl: 'https://example.com/auth',
+      tokenUrl: 'https://example.com/token',
+      envVars: {ACCESS_TOKEN: 'Access token', REFRESH_TOKEN: 'Refresh token'},
+    };
+    expect(getRequiredEnvVars(auth)).toEqual(['ACCESS_TOKEN', 'REFRESH_TOKEN']);
+  });
+
+  it('returns envVars keys for api_key auth', () => {
+    const auth: PackageAuth = {
+      type: 'api_key',
+      envVars: {MY_API_KEY: 'API key'},
+    };
+    expect(getRequiredEnvVars(auth)).toEqual(['MY_API_KEY']);
+  });
+
+  it('extracts $VAR references from api_key headers', () => {
+    const auth: PackageAuth = {
+      type: 'api_key',
+      headers: {'X-Api-Key': '$SECRET_KEY'},
+      envVars: {},
+    };
+    expect(getRequiredEnvVars(auth)).toEqual(['SECRET_KEY']);
+  });
+
+  it('extracts ${VAR} references from api_key headers', () => {
+    const auth: PackageAuth = {
+      type: 'api_key',
+      headers: {Authorization: 'ApiKey ${API_KEY_VAR}'},
+    };
+    expect(getRequiredEnvVars(auth)).toEqual(['API_KEY_VAR']);
+  });
+
+  it('deduplicates vars from envVars and headers', () => {
+    const auth: PackageAuth = {
+      type: 'api_key',
+      headers: {'X-Key': '$MY_KEY'},
+      envVars: {MY_KEY: 'The key'},
+    };
+    expect(getRequiredEnvVars(auth)).toEqual(['MY_KEY']);
+  });
+
+  it('returns empty for auth with no envVars', () => {
+    const auth: PackageAuth = {
+      type: 'bearer',
+    };
+    expect(getRequiredEnvVars(auth)).toEqual([]);
+  });
+});
+
+describe('promptForCredentials', () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+  });
+
+  it('returns early when no credentials required', async () => {
+    const auth: PackageAuth = {type: 'bearer'};
+    const result = await promptForCredentials({
+      auth,
+      envFilePath: '/tmp/.env',
+    });
+    expect(result.summary).toBe('No credentials required');
+    expect(result.credentials).toEqual({});
+  });
+
+  it('returns summary when all credentials already set', async () => {
+    const auth: PackageAuth = {
+      type: 'bearer',
+      envVars: {TOKEN: 'token'},
+    };
+    mockFindMissingEnvVars.mockResolvedValue([]);
+
+    const result = await promptForCredentials({
+      auth,
+      envFilePath: '/tmp/.env',
+    });
+    expect(result.summary).toBe('All credentials already set');
+  });
+
+  it('returns missing vars in dryRun mode without prompting', async () => {
+    const auth: PackageAuth = {
+      type: 'bearer',
+      envVars: {TOKEN_A: 'a', TOKEN_B: 'b'},
+    };
+    mockFindMissingEnvVars.mockResolvedValue(['TOKEN_A', 'TOKEN_B']);
+
+    const result = await promptForCredentials({
+      auth,
+      envFilePath: '/tmp/.env',
+      dryRun: true,
+    });
+    expect(result.summary).toBe('Missing credentials: TOKEN_A, TOKEN_B');
+    expect(mockPrompts).not.toHaveBeenCalled();
+  });
+
+  it('prompts for missing vars with password type', async () => {
+    const auth: PackageAuth = {
+      type: 'bearer',
+      envVars: {MY_TOKEN: 'Your token'},
+    };
+    mockFindMissingEnvVars.mockResolvedValue(['MY_TOKEN']);
+    mockPrompts.mockResolvedValue({value: 'secret123'});
+    mockUpsertEnvEntries.mockResolvedValue(undefined);
+
+    const result = await promptForCredentials({
+      auth,
+      envFilePath: '/tmp/.env',
+    });
+
+    expect(mockPrompts).toHaveBeenCalledWith(
+      expect.objectContaining({type: 'password', name: 'value'}),
+    );
+    expect(result.credentials).toEqual({MY_TOKEN: 'secret123'});
+    expect(result.summary).toBe('Set 1 credential');
+  });
+
+  it('includes description in prompt message', async () => {
+    const auth: PackageAuth = {
+      type: 'bearer',
+      envVars: {API_KEY: 'Your Acme API key'},
+    };
+    mockFindMissingEnvVars.mockResolvedValue(['API_KEY']);
+    mockPrompts.mockResolvedValue({value: 'key123'});
+    mockUpsertEnvEntries.mockResolvedValue(undefined);
+
+    await promptForCredentials({auth, envFilePath: '/tmp/.env'});
+
+    expect(mockPrompts).toHaveBeenCalledWith(
+      expect.objectContaining({message: 'API_KEY (Your Acme API key)'}),
+    );
+  });
+
+  it('handles user cancellation gracefully', async () => {
+    const auth: PackageAuth = {
+      type: 'api_key',
+      envVars: {KEY_A: 'a', KEY_B: 'b'},
+    };
+    mockFindMissingEnvVars.mockResolvedValue(['KEY_A', 'KEY_B']);
+    mockPrompts
+      .mockResolvedValueOnce({value: 'val_a'})
+      .mockResolvedValueOnce({});  // Ctrl+C — no value
+
+    const result = await promptForCredentials({
+      auth,
+      envFilePath: '/tmp/.env',
+    });
+
+    expect(result.summary).toContain('Cancelled');
+    expect(result.summary).toContain('1 of 2');
+  });
+
+  it('writes collected credentials to env file', async () => {
+    const auth: PackageAuth = {
+      type: 'bearer',
+      envVars: {A: 'first', B: 'second'},
+    };
+    mockFindMissingEnvVars.mockResolvedValue(['A', 'B']);
+    mockPrompts
+      .mockResolvedValueOnce({value: 'val_a'})
+      .mockResolvedValueOnce({value: 'val_b'});
+    mockUpsertEnvEntries.mockResolvedValue(undefined);
+
+    await promptForCredentials({auth, envFilePath: '/tmp/test.env'});
+
+    expect(mockUpsertEnvEntries).toHaveBeenCalledWith(
+      '/tmp/test.env',
+      {A: 'val_a', B: 'val_b'},
+    );
+  });
+});

package/src/auth/prompt.ts

@@ -0,0 +1,111 @@
+/**
+ * @license
+ * Copyright 2025 Amodal Labs, Inc.
+ * SPDX-License-Identifier: MIT
+ */
+
+import prompts from 'prompts';
+import {
+  findMissingEnvVars,
+  upsertEnvEntries,
+} from '@amodalai/core';
+import type {PackageAuth} from '@amodalai/core';
+
+import type {AuthResult} from './types.js';
+
+export interface PromptCredentialsOptions {
+  auth: PackageAuth;
+  envFilePath: string;
+  dryRun?: boolean;
+}
+
+/**
+ * Extract all required env var names from any auth type.
+ */
+export function getRequiredEnvVars(auth: PackageAuth): string[] {
+  const vars: string[] = [];
+
+  // Collect from envVars map (all auth types can have this)
+  if (auth['envVars']) {
+    vars.push(...Object.keys(auth['envVars']));
+  }
+
+  // For api_key, also extract $VAR references from headers values
+  if (auth.type === 'api_key' && auth['headers']) {
+    for (const value of Object.values(auth['headers'])) {
+      const match = /\$\{?([A-Z_][A-Z0-9_]*)\}?/.exec(value);
+      if (match && !vars.includes(match[1])) {
+        vars.push(match[1]);
+      }
+    }
+  }
+
+  return vars;
+}
+
+/**
+ * Prompt user for missing credentials and write them to the env file.
+ */
+export async function promptForCredentials(
+  options: PromptCredentialsOptions,
+): Promise<AuthResult> {
+  const {auth, envFilePath, dryRun} = options;
+  const required = getRequiredEnvVars(auth);
+
+  if (required.length === 0) {
+    return {
+      credentials: {},
+      summary: 'No credentials required',
+    };
+  }
+
+  const missing = await findMissingEnvVars(envFilePath, required);
+
+  if (missing.length === 0) {
+    return {
+      credentials: {},
+      summary: 'All credentials already set',
+    };
+  }
+
+  if (dryRun) {
+    return {
+      credentials: {},
+      summary: `Missing credentials: ${missing.join(', ')}`,
+    };
+  }
+
+  const descriptions = auth['envVars'] ?? {};
+  const collected: Record<string, string> = {};
+
+  for (const varName of missing) {
+    const description = descriptions[varName];
+    const message = description
+      ? `${varName} (${description})`
+      : varName;
+
+    const response = await prompts({
+      type: 'password',
+      name: 'value',
+      message,
+    });
+
+    // User cancelled (Ctrl+C)
+    if (response['value'] === undefined) {
+      return {
+        credentials: collected,
+        summary: `Cancelled. ${Object.keys(collected).length} of ${missing.length} credentials collected`,
+      };
+    }
+
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion
+    collected[varName] = response['value'] as string;
+  }
+
+  await upsertEnvEntries(envFilePath, collected);
+
+  return {
+    credentials: collected,
+    summary: `Set ${Object.keys(collected).length} credential${Object.keys(collected).length === 1 ? '' : 's'}`,
+  };
+}

package/src/auth/test-connection.test.ts

@@ -0,0 +1,224 @@
+/**
+ * @license
+ * Copyright 2025 Amodal Labs, Inc.
+ * SPDX-License-Identifier: MIT
+ */
+
+import {describe, it, expect, vi, beforeEach, afterEach} from 'vitest';
+import type {PackageAuth} from '@amodalai/core';
+
+const mockReadEnvFile = vi.fn<(path: string) => Promise<Map<string, string>>>();
+
+vi.mock('@amodalai/core', () => ({
+  readEnvFile: (...args: unknown[]) => mockReadEnvFile(args[0] as string),
+}));
+
+import {resolveEndpointUrl, buildAuthHeaders, testConnection} from './test-connection.js';
+
+describe('resolveEndpointUrl', () => {
+  it('substitutes $VAR placeholders', () => {
+    const env = new Map([['BASE_URL', 'https://api.example.com']]);
+    expect(resolveEndpointUrl('$BASE_URL/users', env)).toBe(
+      'https://api.example.com/users',
+    );
+  });
+
+  it('substitutes ${VAR} placeholders', () => {
+    const env = new Map([['HOST', 'example.com']]);
+    expect(resolveEndpointUrl('https://${HOST}/api', env)).toBe(
+      'https://example.com/api',
+    );
+  });
+
+  it('replaces missing vars with empty string', () => {
+    const env = new Map<string, string>();
+    expect(resolveEndpointUrl('$MISSING/path', env)).toBe('/path');
+  });
+
+  it('handles multiple vars', () => {
+    const env = new Map([
+      ['HOST', 'example.com'],
+      ['PORT', '8080'],
+    ]);
+    expect(resolveEndpointUrl('https://${HOST}:$PORT/api', env)).toBe(
+      'https://example.com:8080/api',
+    );
+  });
+});
+
+describe('buildAuthHeaders', () => {
+  it('returns empty for no auth', () => {
+    const env = new Map<string, string>();
+    expect(buildAuthHeaders(undefined, env)).toEqual({});
+  });
+
+  it('builds Bearer header for bearer auth', () => {
+    const auth: PackageAuth = {
+      type: 'bearer',
+      envVars: {MY_TOKEN: 'token desc'},
+    };
+    const env = new Map([['MY_TOKEN', 'secret123']]);
+    expect(buildAuthHeaders(auth, env)).toEqual({
+      Authorization: 'Bearer secret123',
+    });
+  });
+
+  it('builds custom headers for api_key auth', () => {
+    const auth: PackageAuth = {
+      type: 'api_key',
+      headers: {'X-Api-Key': '$API_KEY'},
+    };
+    const env = new Map([['API_KEY', 'mykey']]);
+    expect(buildAuthHeaders(auth, env)).toEqual({
+      'X-Api-Key': 'mykey',
+    });
+  });
+
+  it('builds Bearer header for oauth2 auth', () => {
+    const auth: PackageAuth = {
+      type: 'oauth2',
+      authorizeUrl: 'https://example.com/auth',
+      tokenUrl: 'https://example.com/token',
+      envVars: {ACCESS_TOKEN: 'Access token'},
+    };
+    const env = new Map([['ACCESS_TOKEN', 'oauth-token']]);
+    expect(buildAuthHeaders(auth, env)).toEqual({
+      Authorization: 'Bearer oauth-token',
+    });
+  });
+
+  it('returns empty when token not in env', () => {
+    const auth: PackageAuth = {
+      type: 'bearer',
+      envVars: {TOKEN: 'desc'},
+    };
+    const env = new Map<string, string>();
+    expect(buildAuthHeaders(auth, env)).toEqual({});
+  });
+});
+
+describe('testConnection', () => {
+  const stderrSpy = vi.spyOn(process.stderr, 'write').mockReturnValue(true);
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any -- vitest spy type mismatch with globalThis.fetch overloads
+  let fetchSpy: any;
+
+  beforeEach(() => {
+    vi.clearAllMocks();
+    mockReadEnvFile.mockResolvedValue(new Map());
+    fetchSpy = vi.spyOn(globalThis, 'fetch');
+  });
+
+  afterEach(() => {
+    fetchSpy.mockRestore();
+  });
+
+  it('reports success for OK response with JSON array', async () => {
+    fetchSpy.mockResolvedValue(
+      new Response(JSON.stringify([1, 2, 3]), {status: 200}),
+    );
+
+    const report = await testConnection({
+      connectionName: 'test',
+      testEndpoints: ['https://api.example.com/items'],
+      envFilePath: '/tmp/.env',
+    });
+
+    expect(report.allPassed).toBe(true);
+    expect(report.results[0].status).toBe('ok');
+    expect(report.results[0].recordCount).toBe(3);
+  });
+
+  it('reports success with count field in JSON', async () => {
+    fetchSpy.mockResolvedValue(
+      new Response(JSON.stringify({count: 42, items: []}), {status: 200}),
+    );
+
+    const report = await testConnection({
+      connectionName: 'test',
+      testEndpoints: ['https://api.example.com/items'],
+      envFilePath: '/tmp/.env',
+    });
+
+    expect(report.results[0].recordCount).toBe(42);
+  });
+
+  it('reports error for HTTP failure', async () => {
+    fetchSpy.mockResolvedValue(
+      new Response('Unauthorized', {status: 401}),
+    );
+
+    const report = await testConnection({
+      connectionName: 'test',
+      testEndpoints: ['https://api.example.com/items'],
+      envFilePath: '/tmp/.env',
+    });
+
+    expect(report.allPassed).toBe(false);
+    expect(report.results[0].status).toBe('error');
+    expect(report.results[0].statusCode).toBe(401);
+  });
+
+  it('reports error for network failure', async () => {
+    fetchSpy.mockRejectedValue(new Error('ECONNREFUSED'));
+
+    const report = await testConnection({
+      connectionName: 'test',
+      testEndpoints: ['https://api.example.com/items'],
+      envFilePath: '/tmp/.env',
+    });
+
+    expect(report.allPassed).toBe(false);
+    expect(report.results[0].status).toBe('error');
+    expect(report.results[0].error).toBe('ECONNREFUSED');
+  });
+
+  it('tests endpoints sequentially', async () => {
+    fetchSpy
+      .mockResolvedValueOnce(new Response('[]', {status: 200}))
+      .mockResolvedValueOnce(new Response('Forbidden', {status: 403}));
+
+    const report = await testConnection({
+      connectionName: 'multi',
+      testEndpoints: [
+        'https://api.example.com/a',
+        'https://api.example.com/b',
+      ],
+      envFilePath: '/tmp/.env',
+    });
+
+    expect(report.results).toHaveLength(2);
+    expect(report.results[0].status).toBe('ok');
+    expect(report.results[1].status).toBe('error');
+    expect(report.allPassed).toBe(false);
+  });
+
+  it('resolves URL placeholders from env', async () => {
+    mockReadEnvFile.mockResolvedValue(
+      new Map([['BASE', 'https://api.example.com']]),
+    );
+    fetchSpy.mockResolvedValue(new Response('[]', {status: 200}));
+
+    await testConnection({
+      connectionName: 'test',
+      testEndpoints: ['$BASE/items'],
+      envFilePath: '/tmp/.env',
+    });
+
+    expect(fetchSpy).toHaveBeenCalledWith(
+      'https://api.example.com/items',
+      expect.anything(),
+    );
+  });
+
+  it('writes progress to stderr', async () => {
+    fetchSpy.mockResolvedValue(new Response('[]', {status: 200}));
+
+    await testConnection({
+      connectionName: 'test',
+      testEndpoints: ['https://api.example.com/items'],
+      envFilePath: '/tmp/.env',
+    });
+
+    expect(stderrSpy).toHaveBeenCalled();
+  });
+});