@amodalai/amodal 0.1.2

package/src/commands/link.ts

@@ -0,0 +1,270 @@
+/**
+ * @license
+ * Copyright 2025 Amodal Labs, Inc.
+ * SPDX-License-Identifier: MIT
+ */
+
+import {writeFile, readFile, mkdir} from 'node:fs/promises';
+import {existsSync} from 'node:fs';
+import * as path from 'node:path';
+
+import type {CommandModule} from 'yargs';
+import prompts from 'prompts';
+
+import {readRcFile} from './login.js';
+import {findRepoRoot} from '../shared/repo-discovery.js';
+
+const PROJECT_DIR = '.amodal';
+const PROJECT_FILE = 'project.json';
+
+export interface ProjectLink {
+  orgId: string;
+  orgName: string;
+  appId: string;
+  appName: string;
+  platformUrl: string;
+}
+
+export interface LinkOptions {
+  cwd?: string;
+  yes?: boolean;
+  orgId?: string;
+  appId?: string;
+}
+
+/**
+ * Read the project link from .amodal/project.json.
+ * Returns null if not linked.
+ */
+export async function readProjectLink(cwd?: string): Promise<ProjectLink | null> {
+  let repoRoot: string;
+  try {
+    repoRoot = findRepoRoot(cwd);
+  } catch {
+    return null;
+  }
+  const linkPath = path.join(repoRoot, PROJECT_DIR, PROJECT_FILE);
+  try {
+    const content = await readFile(linkPath, 'utf-8');
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion
+    return JSON.parse(content) as ProjectLink;
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Write the project link to .amodal/project.json and ensure .amodal/ is gitignored.
+ */
+async function writeProjectLink(repoRoot: string, link: ProjectLink): Promise<void> {
+  const dir = path.join(repoRoot, PROJECT_DIR);
+  await mkdir(dir, {recursive: true});
+  const linkPath = path.join(dir, PROJECT_FILE);
+  await writeFile(linkPath, JSON.stringify(link, null, 2) + '\n');
+
+  // Ensure .amodal/ is in .gitignore
+  const gitignorePath = path.join(repoRoot, '.gitignore');
+  try {
+    const gitignore = existsSync(gitignorePath)
+      ? await readFile(gitignorePath, 'utf-8')
+      : '';
+    if (!gitignore.includes('.amodal')) {
+      const newline = gitignore.endsWith('\n') || gitignore === '' ? '' : '\n';
+      await writeFile(gitignorePath, `${gitignore}${newline}.amodal/\n`);
+    }
+  } catch {
+    // non-fatal
+  }
+}
+
+interface MeResponse {
+  user: {email?: string; name?: string} | null;
+  org: {id: string; name: string} | null;
+  orgs: Array<{id: string; name: string}>;
+  app: {id: string; name: string} | null;
+  apps: Array<{id: string; name: string}>;
+  tenant: {id: string; name: string} | null;
+  tenants: Array<{id: string; name: string}>;
+}
+
+/**
+ * Link the current project to a platform org and app.
+ * Saves to .amodal/project.json (gitignored, local machine state).
+ * Returns 0 on success, 1 on error.
+ */
+export async function runLink(options: LinkOptions = {}): Promise<number> {
+  // Find repo root
+  let repoRoot: string;
+  try {
+    repoRoot = findRepoRoot(options.cwd);
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    process.stderr.write(`[link] ${msg}\n`);
+    return 1;
+  }
+
+  // Check if already linked
+  const existing = await readProjectLink(repoRoot);
+  if (existing && !options.yes) {
+    process.stderr.write(
+      `[link] Already linked to ${existing.orgName} / ${existing.appName}\n`,
+    );
+    const {confirm} = await prompts({
+      type: 'confirm',
+      name: 'confirm',
+      message: 'Overwrite existing link?',
+      initial: false,
+    });
+    if (!confirm) {
+      process.stderr.write('[link] Cancelled.\n');
+      return 0;
+    }
+  }
+
+  // Read auth token
+  const rc = await readRcFile();
+  if (!rc.platform?.token) {
+    process.stderr.write('[link] Not logged in. Run `amodal login` first.\n');
+    return 1;
+  }
+  const platformUrl = rc.platform.url;
+  const token = rc.platform.token;
+
+  // Fetch user info
+  process.stderr.write('[link] Fetching account info...\n');
+  const meResponse = await fetch(`${platformUrl}/api/me`, {
+    headers: {Authorization: `Bearer ${token}`},
+  });
+
+  if (!meResponse.ok) {
+    if (meResponse.status === 401) {
+      process.stderr.write('[link] Session expired. Run `amodal login` again.\n');
+    } else {
+      process.stderr.write(`[link] Failed to fetch account info (HTTP ${meResponse.status})\n`);
+    }
+    return 1;
+  }
+
+  // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion
+  const me = (await meResponse.json()) as MeResponse;
+
+  if (!me.orgs.length) {
+    process.stderr.write('[link] No organizations found. Create one in the admin UI first.\n');
+    return 1;
+  }
+
+  // Select org
+  let selectedOrg: {id: string; name: string};
+  if (options.orgId) {
+    const found = me.orgs.find((o) => o.id === options.orgId);
+    if (!found) {
+      process.stderr.write(`[link] Organization "${options.orgId}" not found.\n`);
+      return 1;
+    }
+    selectedOrg = found;
+  } else if (me.orgs.length === 1) {
+    selectedOrg = me.orgs[0]!;
+  } else {
+    const {orgIndex} = await prompts({
+      type: 'select',
+      name: 'orgIndex',
+      message: 'Select organization',
+      choices: me.orgs.map((o, i) => ({title: o.name, value: i})),
+    });
+    if (orgIndex === undefined) {
+      process.stderr.write('[link] Cancelled.\n');
+      return 1;
+    }
+    selectedOrg = me.orgs[orgIndex]!;
+  }
+
+  // Fetch apps for selected org
+  let apps = me.apps;
+  if (selectedOrg.id !== me.org?.id) {
+    const appsResponse = await fetch(`${platformUrl}/api/orgs/${selectedOrg.id}/applications`, {
+      headers: {Authorization: `Bearer ${token}`},
+    });
+    if (appsResponse.ok) {
+      // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion
+      apps = (await appsResponse.json()) as Array<{id: string; name: string}>;
+    }
+  }
+
+  if (!apps.length) {
+    process.stderr.write('[link] No apps found in this organization. Create one in the admin UI first.\n');
+    return 1;
+  }
+
+  // Select app
+  let selectedApp: {id: string; name: string};
+  if (options.appId) {
+    const found = apps.find((a) => a.id === options.appId);
+    if (!found) {
+      process.stderr.write(`[link] App "${options.appId}" not found.\n`);
+      return 1;
+    }
+    selectedApp = found;
+  } else if (apps.length === 1) {
+    selectedApp = apps[0]!;
+  } else {
+    const {appIndex} = await prompts({
+      type: 'select',
+      name: 'appIndex',
+      message: 'Select app',
+      choices: apps.map((a, i) => ({title: a.name, value: i})),
+    });
+    if (appIndex === undefined) {
+      process.stderr.write('[link] Cancelled.\n');
+      return 1;
+    }
+    selectedApp = apps[appIndex]!;
+  }
+
+  // Save the link
+  const link: ProjectLink = {
+    orgId: selectedOrg.id,
+    orgName: selectedOrg.name,
+    appId: selectedApp.id,
+    appName: selectedApp.name,
+    platformUrl,
+  };
+
+  await writeProjectLink(repoRoot, link);
+
+  process.stderr.write(
+    `[link] Linked to ${selectedOrg.name} / ${selectedApp.name}\n`,
+  );
+  process.stderr.write(`[link] Settings saved to ${PROJECT_DIR}/${PROJECT_FILE}\n`);
+  return 0;
+}
+
+export const linkCommand: CommandModule = {
+  command: 'link',
+  describe: 'Link this project to an amodal org and app',
+  builder: (yargs) =>
+    yargs
+      .option('yes', {
+        type: 'boolean',
+        alias: 'y',
+        describe: 'Skip confirmation prompts',
+      })
+      .option('org-id', {
+        type: 'string',
+        describe: 'Organization ID (skip prompt)',
+      })
+      .option('app-id', {
+        type: 'string',
+        describe: 'App ID (skip prompt)',
+      }),
+  handler: async (argv) => {
+    const code = await runLink({
+      // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion
+      yes: argv['yes'] as boolean | undefined,
+      // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion
+      orgId: argv['orgId'] as string | undefined,
+      // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion
+      appId: argv['appId'] as string | undefined,
+    });
+    process.exit(code);
+  },
+};

package/src/commands/list.test.ts

@@ -0,0 +1,152 @@
+/**
+ * @license
+ * Copyright 2025 Amodal Labs, Inc.
+ * SPDX-License-Identifier: MIT
+ */
+
+import {describe, it, expect, vi, beforeEach} from 'vitest';
+
+const mockFindRepoRoot = vi.fn(() => '/test/repo');
+const mockListLockEntries = vi.fn();
+
+vi.mock('../shared/repo-discovery.js', () => ({
+  findRepoRoot: mockFindRepoRoot,
+}));
+
+vi.mock('@amodalai/core', () => ({
+  listLockEntries: mockListLockEntries,
+  parsePackageKey: vi.fn((key: string) => {
+    const [type, name] = key.split('/');
+    return {type, name};
+  }),
+}));
+
+describe('runList', () => {
+  let stdoutOutput: string;
+  let stderrOutput: string;
+
+  beforeEach(() => {
+    vi.clearAllMocks();
+    mockFindRepoRoot.mockReturnValue('/test/repo');
+    stdoutOutput = '';
+    stderrOutput = '';
+    vi.spyOn(process.stdout, 'write').mockImplementation((chunk) => {
+      stdoutOutput += String(chunk);
+      return true;
+    });
+    vi.spyOn(process.stderr, 'write').mockImplementation((chunk) => {
+      stderrOutput += String(chunk);
+      return true;
+    });
+  });
+
+  it('should print "No packages installed" when no entries', async () => {
+    mockListLockEntries.mockResolvedValue([]);
+
+    const {runList} = await import('./list.js');
+    const result = await runList();
+    expect(result).toBe(0);
+    expect(stderrOutput).toContain('No packages installed');
+  });
+
+  it('should print entries as formatted table', async () => {
+    mockListLockEntries.mockResolvedValue([
+      {key: 'connection/salesforce', type: 'connection', name: 'salesforce', entry: {version: '2.1.0', npm: '@amodalai/connection-salesforce', integrity: 'sha512-abc'}},
+      {key: 'skill/triage', type: 'skill', name: 'triage', entry: {version: '1.0.3', npm: '@amodalai/skill-triage', integrity: 'sha512-def'}},
+    ]);
+
+    const {runList} = await import('./list.js');
+    const result = await runList();
+    expect(result).toBe(0);
+    expect(stdoutOutput).toContain('TYPE');
+    expect(stdoutOutput).toContain('salesforce');
+    expect(stdoutOutput).toContain('triage');
+    expect(stderrOutput).toContain('2 packages installed');
+  });
+
+  it('should filter by type', async () => {
+    mockListLockEntries.mockResolvedValue([]);
+
+    const {runList} = await import('./list.js');
+    const result = await runList({type: 'connection'});
+    expect(result).toBe(0);
+    expect(mockListLockEntries).toHaveBeenCalledWith('/test/repo', 'connection');
+    expect(stderrOutput).toContain('No connection packages installed');
+  });
+
+  it('should output JSON when json option set', async () => {
+    mockListLockEntries.mockResolvedValue([
+      {key: 'connection/stripe', type: 'connection', name: 'stripe', entry: {version: '1.0.0', npm: '@amodalai/connection-stripe', integrity: 'sha512-xyz'}},
+    ]);
+
+    const {runList} = await import('./list.js');
+    const result = await runList({json: true});
+    expect(result).toBe(0);
+
+    const parsed = JSON.parse(stdoutOutput);
+    expect(parsed).toHaveLength(1);
+    expect(parsed[0]).toMatchObject({type: 'connection', name: 'stripe', version: '1.0.0'});
+  });
+
+  it('should return 1 when repo not found', async () => {
+    mockFindRepoRoot.mockImplementation(() => {
+      throw new Error('Not found');
+    });
+
+    const {runList} = await import('./list.js');
+    const result = await runList();
+    expect(result).toBe(1);
+    expect(stderrOutput).toContain('Not found');
+  });
+
+  it('should print "No packages installed" when empty after type filter', async () => {
+    mockListLockEntries.mockResolvedValue([]);
+
+    const {runList} = await import('./list.js');
+    const result = await runList({type: 'skill'});
+    expect(result).toBe(0);
+    expect(stderrOutput).toContain('No skill packages installed');
+  });
+
+  it('should handle single package with correct count', async () => {
+    mockListLockEntries.mockResolvedValue([
+      {key: 'connection/datadog', type: 'connection', name: 'datadog', entry: {version: '3.0.0', npm: '@amodalai/connection-datadog', integrity: 'sha512-ghi'}},
+    ]);
+
+    const {runList} = await import('./list.js');
+    const result = await runList();
+    expect(result).toBe(0);
+    expect(stderrOutput).toContain('1 package installed');
+    expect(stderrOutput).not.toContain('1 packages');
+  });
+
+  it('should pass cwd to findRepoRoot', async () => {
+    mockListLockEntries.mockResolvedValue([]);
+
+    const {runList} = await import('./list.js');
+    await runList({cwd: '/custom/dir'});
+    expect(mockFindRepoRoot).toHaveBeenCalledWith('/custom/dir');
+  });
+
+  it('should include integrity in JSON output', async () => {
+    mockListLockEntries.mockResolvedValue([
+      {key: 'skill/analyze', type: 'skill', name: 'analyze', entry: {version: '1.0.0', npm: '@amodalai/skill-analyze', integrity: 'sha512-integrity-hash'}},
+    ]);
+
+    const {runList} = await import('./list.js');
+    await runList({json: true});
+
+    const parsed = JSON.parse(stdoutOutput);
+    expect(parsed[0]['integrity']).toBe('sha512-integrity-hash');
+  });
+
+  it('should handle json output with empty list', async () => {
+    mockListLockEntries.mockResolvedValue([]);
+
+    const {runList} = await import('./list.js');
+    const result = await runList({json: true});
+    expect(result).toBe(0);
+    // No JSON output when empty — prints "no packages" to stderr instead
+    expect(stderrOutput).toContain('No packages installed');
+  });
+});

package/src/commands/list.ts

@@ -0,0 +1,95 @@
+/**
+ * @license
+ * Copyright 2025 Amodal Labs, Inc.
+ * SPDX-License-Identifier: MIT
+ */
+
+import type {CommandModule} from 'yargs';
+import {listLockEntries} from '@amodalai/core';
+import type {PackageType} from '@amodalai/core';
+import {findRepoRoot} from '../shared/repo-discovery.js';
+
+export interface ListOptions {
+  cwd?: string;
+  type?: PackageType;
+  json?: boolean;
+}
+
+/**
+ * List installed packages from the lock file.
+ * Returns 0 on success, 1 on error.
+ */
+export async function runList(options: ListOptions = {}): Promise<number> {
+  let repoPath: string;
+  try {
+    repoPath = findRepoRoot(options.cwd);
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    process.stderr.write(`[list] ${msg}\n`);
+    return 1;
+  }
+
+  const entries = await listLockEntries(repoPath, options.type);
+
+  if (entries.length === 0) {
+    if (options.type) {
+      process.stderr.write(`[list] No ${options.type} packages installed.\n`);
+    } else {
+      process.stderr.write('[list] No packages installed.\n');
+    }
+    return 0;
+  }
+
+  if (options.json) {
+    const output = entries.map((e) => ({
+      type: e.type,
+      name: e.name,
+      version: e.entry.version,
+      npm: e.entry.npm,
+      integrity: e.entry.integrity,
+    }));
+    process.stdout.write(JSON.stringify(output, null, 2) + '\n');
+    return 0;
+  }
+
+  // Formatted table
+  const typeWidth = Math.max(4, ...entries.map((e) => e.type.length));
+  const nameWidth = Math.max(4, ...entries.map((e) => e.name.length));
+  const versionWidth = Math.max(7, ...entries.map((e) => e.entry.version.length));
+
+  const header = [
+    'TYPE'.padEnd(typeWidth),
+    'NAME'.padEnd(nameWidth),
+    'VERSION'.padEnd(versionWidth),
+    'NPM',
+  ].join('   ');
+
+  process.stdout.write(header + '\n');
+
+  for (const e of entries) {
+    const row = [
+      e.type.padEnd(typeWidth),
+      e.name.padEnd(nameWidth),
+      e.entry.version.padEnd(versionWidth),
+      e.entry.npm,
+    ].join('   ');
+    process.stdout.write(row + '\n');
+  }
+
+  process.stderr.write(`[list] ${entries.length} package${entries.length === 1 ? '' : 's'} installed.\n`);
+  return 0;
+}
+
+export const listCommand: CommandModule = {
+  command: 'list',
+  describe: 'List installed packages',
+  builder: (yargs) =>
+    yargs
+      .option('type', {type: 'string', choices: ['connection', 'skill', 'automation', 'knowledge'] as const, describe: 'Filter by type'})
+      .option('json', {type: 'boolean', default: false, describe: 'Output as JSON'}),
+  handler: async (argv) => {
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion
+    const code = await runList({type: argv['type'] as PackageType | undefined, json: argv['json'] as boolean});
+    process.exit(code);
+  },
+};