@amodalai/amodal 0.1.2

package/src/commands/publish.test.ts

@@ -0,0 +1,203 @@
+/**
+ * @license
+ * Copyright 2025 Amodal Labs, Inc.
+ * SPDX-License-Identifier: MIT
+ */
+
+import {describe, it, expect, vi, beforeEach} from 'vitest';
+
+const mockReadPackageManifest = vi.fn();
+const mockStat = vi.fn();
+const mockReadFile = vi.fn();
+const mockExecFile = vi.fn();
+
+vi.mock('@amodalai/core', () => ({
+  readPackageManifest: mockReadPackageManifest,
+}));
+
+vi.mock('node:fs/promises', () => ({
+  stat: mockStat,
+  readFile: mockReadFile,
+}));
+
+vi.mock('node:child_process', () => ({
+  execFile: mockExecFile,
+}));
+
+describe('runPublish', () => {
+  let stderrOutput: string;
+
+  beforeEach(() => {
+    vi.clearAllMocks();
+    mockStat.mockResolvedValue({isFile: () => true});
+    mockReadPackageManifest.mockResolvedValue({
+      type: 'connection',
+      name: 'salesforce',
+    });
+    mockReadFile.mockResolvedValue(JSON.stringify({
+      name: '@amodalai/connection-salesforce',
+      version: '1.0.0',
+      amodal: {type: 'connection', name: 'salesforce'},
+    }));
+    stderrOutput = '';
+    vi.spyOn(process.stderr, 'write').mockImplementation((chunk) => {
+      stderrOutput += String(chunk);
+      return true;
+    });
+  });
+
+  it('should publish successfully', async () => {
+    mockExecFile.mockImplementation(
+      (_cmd: string, _args: string[], _opts: unknown, cb: (err: Error | null, result: {stdout: string; stderr: string}) => void) => {
+        cb(null, {stdout: '', stderr: ''});
+        return {};
+      },
+    );
+
+    const {runPublish} = await import('./publish.js');
+    const result = await runPublish();
+    expect(result).toBe(0);
+    expect(stderrOutput).toContain('Published');
+  });
+
+  it('should show dry run output', async () => {
+    const {runPublish} = await import('./publish.js');
+    const result = await runPublish({dryRun: true});
+    expect(result).toBe(0);
+    expect(stderrOutput).toContain('Dry run');
+    expect(stderrOutput).toContain('connection');
+    expect(mockExecFile).not.toHaveBeenCalled();
+  });
+
+  it('should return 1 when package.json missing', async () => {
+    mockStat.mockRejectedValueOnce(new Error('ENOENT'));
+
+    const {runPublish} = await import('./publish.js');
+    const result = await runPublish();
+    expect(result).toBe(1);
+    expect(stderrOutput).toContain('No package.json');
+  });
+
+  it('should return 1 when manifest invalid', async () => {
+    mockReadPackageManifest.mockRejectedValue(new Error('Missing amodal block'));
+
+    const {runPublish} = await import('./publish.js');
+    const result = await runPublish();
+    expect(result).toBe(1);
+    expect(stderrOutput).toContain('Invalid package');
+  });
+
+  it('should return 1 when required files missing', async () => {
+    // First stat succeeds (package.json), second fails (spec.json)
+    mockStat
+      .mockResolvedValueOnce({isFile: () => true})
+      .mockRejectedValueOnce(new Error('ENOENT'))
+      .mockRejectedValueOnce(new Error('ENOENT'));
+
+    const {runPublish} = await import('./publish.js');
+    const result = await runPublish();
+    expect(result).toBe(1);
+    expect(stderrOutput).toContain('Missing required files');
+  });
+
+  it('should handle npm publish failure', async () => {
+    mockExecFile.mockImplementation(
+      (_cmd: string, _args: string[], _opts: unknown, cb: (err: Error | null) => void) => {
+        cb(new Error('Network error'));
+        return {};
+      },
+    );
+
+    const {runPublish} = await import('./publish.js');
+    const result = await runPublish();
+    expect(result).toBe(1);
+    expect(stderrOutput).toContain('Publish failed');
+  });
+
+  it('should handle already published (409)', async () => {
+    mockExecFile.mockImplementation(
+      (_cmd: string, _args: string[], _opts: unknown, cb: (err: Error | null) => void) => {
+        cb(new Error('EPUBLISHCONFLICT'));
+        return {};
+      },
+    );
+
+    const {runPublish} = await import('./publish.js');
+    const result = await runPublish();
+    expect(result).toBe(1);
+    expect(stderrOutput).toContain('already exists');
+  });
+
+  it('should suggest npm login on auth error (ENEEDAUTH)', async () => {
+    mockExecFile.mockImplementation(
+      (_cmd: string, _args: string[], _opts: unknown, cb: (err: Error | null) => void) => {
+        cb(new Error('ENEEDAUTH'));
+        return {};
+      },
+    );
+
+    const {runPublish} = await import('./publish.js');
+    const result = await runPublish();
+    expect(result).toBe(1);
+    expect(stderrOutput).toContain('npm login');
+  });
+
+  it('should suggest npm login on auth error (E401)', async () => {
+    mockExecFile.mockImplementation(
+      (_cmd: string, _args: string[], _opts: unknown, cb: (err: Error | null) => void) => {
+        cb(new Error('E401'));
+        return {};
+      },
+    );
+
+    const {runPublish} = await import('./publish.js');
+    const result = await runPublish();
+    expect(result).toBe(1);
+    expect(stderrOutput).toContain('npm login');
+  });
+
+  it('should use custom registry', async () => {
+    mockExecFile.mockImplementation(
+      (_cmd: string, args: string[], _opts: unknown, cb: (err: Error | null, result: {stdout: string; stderr: string}) => void) => {
+        expect(args).toContain('https://custom.registry.com');
+        cb(null, {stdout: '', stderr: ''});
+        return {};
+      },
+    );
+
+    const {runPublish} = await import('./publish.js');
+    const result = await runPublish({registry: 'https://custom.registry.com'});
+    expect(result).toBe(0);
+  });
+
+  it('should validate skill package required files', async () => {
+    mockReadPackageManifest.mockResolvedValue({type: 'skill', name: 'triage'});
+    mockReadFile.mockResolvedValue(JSON.stringify({
+      name: '@amodalai/skill-triage',
+      version: '1.0.0',
+      amodal: {type: 'skill', name: 'triage'},
+    }));
+
+    // package.json exists, SKILL.md missing
+    mockStat
+      .mockResolvedValueOnce({isFile: () => true})
+      .mockRejectedValueOnce(new Error('ENOENT'));
+
+    const {runPublish} = await import('./publish.js');
+    const result = await runPublish();
+    expect(result).toBe(1);
+    expect(stderrOutput).toContain('SKILL.md');
+  });
+
+  it('should show package name and version in dry run', async () => {
+    mockReadFile.mockResolvedValue(JSON.stringify({
+      name: '@amodalai/connection-stripe',
+      version: '3.2.1',
+      amodal: {type: 'connection', name: 'stripe'},
+    }));
+
+    const {runPublish} = await import('./publish.js');
+    await runPublish({dryRun: true});
+    expect(stderrOutput).toContain('@amodalai/connection-stripe@3.2.1');
+  });
+});

package/src/commands/publish.ts

@@ -0,0 +1,142 @@
+/**
+ * @license
+ * Copyright 2025 Amodal Labs, Inc.
+ * SPDX-License-Identifier: MIT
+ */
+
+import {readFile, stat} from 'node:fs/promises';
+import {execFile} from 'node:child_process';
+import * as path from 'node:path';
+import {promisify} from 'node:util';
+
+import type {CommandModule} from 'yargs';
+import {readPackageManifest} from '@amodalai/core';
+
+const execFileAsync = promisify(execFile);
+
+const DEFAULT_REGISTRY = 'https://registry.amodalai.com';
+
+export interface PublishOptions {
+  cwd?: string;
+  dryRun?: boolean;
+  registry?: string;
+}
+
+const REQUIRED_FILES: Record<string, string[]> = {
+  connection: ['spec.json', 'surface.md'],
+  skill: ['SKILL.md'],
+  automation: [],
+  knowledge: [],
+  mcp: [],
+};
+
+/**
+ * Publish a package to the registry.
+ * Returns 0 on success, 1 on error.
+ */
+export async function runPublish(options: PublishOptions = {}): Promise<number> {
+  const cwd = options.cwd ?? process.cwd();
+  const registry = options.registry ?? DEFAULT_REGISTRY;
+
+  // Validate package.json exists
+  const pkgJsonPath = path.join(cwd, 'package.json');
+  try {
+    await stat(pkgJsonPath);
+  } catch {
+    process.stderr.write('[publish] No package.json found in current directory.\n');
+    return 1;
+  }
+
+  // Read and validate manifest
+  let manifest;
+  try {
+    manifest = await readPackageManifest(cwd);
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    process.stderr.write(`[publish] Invalid package: ${msg}\n`);
+    return 1;
+  }
+
+  // Check required files
+  const required = REQUIRED_FILES[manifest.type] ?? [];
+  const missingFiles: string[] = [];
+  for (const file of required) {
+    try {
+      await stat(path.join(cwd, file));
+    } catch {
+      missingFiles.push(file);
+    }
+  }
+
+  if (missingFiles.length > 0) {
+    process.stderr.write(`[publish] Missing required files: ${missingFiles.join(', ')}\n`);
+    return 1;
+  }
+
+  // Read package name and version
+  let pkgName: string;
+  let pkgVersion: string;
+  try {
+    const content = await readFile(pkgJsonPath, 'utf-8');
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion
+    const pkg = JSON.parse(content) as Record<string, unknown>;
+    pkgName = String(pkg['name'] ?? '');
+    pkgVersion = String(pkg['version'] ?? '');
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    process.stderr.write(`[publish] Failed to read package.json: ${msg}\n`);
+    return 1;
+  }
+
+  if (options.dryRun) {
+    process.stderr.write(`[publish] Dry run: would publish ${pkgName}@${pkgVersion}\n`);
+    process.stderr.write(`[publish]   Type: ${manifest.type}\n`);
+    process.stderr.write(`[publish]   Name: ${manifest.name}\n`);
+    process.stderr.write(`[publish]   Registry: ${registry}\n`);
+    return 0;
+  }
+
+  process.stderr.write(`[publish] Publishing ${pkgName}@${pkgVersion} to ${registry}...\n`);
+
+  try {
+    await execFileAsync(
+      'npm',
+      ['publish', '--registry', registry],
+      {
+        cwd,
+        timeout: 120_000,
+      },
+    );
+
+    process.stderr.write(`[publish] Published ${pkgName}@${pkgVersion}\n`);
+    return 0;
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    if (msg.includes('403') || msg.includes('409') || msg.includes('EPUBLISHCONFLICT')) {
+      process.stderr.write(`[publish] Version ${pkgVersion} already exists. Bump the version and try again.\n`);
+    } else if (msg.includes('ENEEDAUTH') || msg.includes('E401')) {
+      process.stderr.write(`[publish] Not authenticated. Run \`npm login --registry ${registry}\` first.\n`);
+    } else {
+      process.stderr.write(`[publish] Publish failed: ${msg}\n`);
+    }
+    return 1;
+  }
+}
+
+export const publishCommand: CommandModule = {
+  command: 'publish',
+  describe: 'Publish a package to the registry',
+  builder: (yargs) =>
+    yargs
+      .option('dry-run', {type: 'boolean', default: false, describe: 'Show what would be published'})
+      .option('registry', {type: 'string', describe: 'Registry URL'}),
+  handler: async (argv) => {
+    const code = await runPublish({
+      // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion
+      dryRun: argv['dryRun'] as boolean,
+      // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion
+      registry: argv['registry'] as string | undefined,
+    });
+    process.exit(code);
+  },
+};

package/src/commands/rollback.ts

@@ -0,0 +1,72 @@
+/**
+ * @license
+ * Copyright 2025 Amodal Labs, Inc.
+ * SPDX-License-Identifier: MIT
+ */
+
+import type {CommandModule} from 'yargs';
+import {PlatformClient} from '../shared/platform-client.js';
+
+export interface RollbackOptions {
+  deployId?: string;
+  prev?: boolean;
+  env?: string;
+}
+
+/**
+ * Rollback to a previous deployment.
+ */
+export async function runRollback(options: RollbackOptions = {}): Promise<number> {
+  let client: PlatformClient;
+  try {
+    client = new PlatformClient();
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    process.stderr.write(`[rollback] ${msg}\n`);
+    return 1;
+  }
+
+  const environment = options.env ?? 'production';
+
+  try {
+    const result = await client.rollback({
+      deployId: options.deployId,
+      environment,
+    });
+    process.stderr.write(`[rollback] Rolled back to ${result.id} in ${result.environment}\n`);
+    return 0;
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    process.stderr.write(`[rollback] Failed: ${msg}\n`);
+    return 1;
+  }
+}
+
+export const rollbackCommand: CommandModule = {
+  command: 'rollback [deploy-id]',
+  describe: 'Rollback to a previous deployment',
+  builder: (yargs) =>
+    yargs
+      .positional('deploy-id', {
+        type: 'string',
+        describe: 'Deploy ID to rollback to (omit for previous)',
+      })
+      .option('prev', {
+        type: 'boolean',
+        describe: 'Rollback to previous deployment',
+        default: false,
+      })
+      .option('env', {
+        type: 'string',
+        describe: 'Target environment (default: production)',
+      }),
+  handler: async (argv) => {
+    const code = await runRollback({
+      // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion
+      deployId: argv['deployId'] as string | undefined,
+      // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion
+      env: argv['env'] as string | undefined,
+    });
+    process.exit(code);
+  },
+};

package/src/commands/search.test.ts

@@ -0,0 +1,174 @@
+/**
+ * @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 mockEnsureNpmContext = vi.fn();
+const mockNpmSearch = vi.fn();
+const mockFromNpmName = vi.fn((npm: string) => {
+  const prefix = '@amodalai/';
+  if (!npm.startsWith(prefix)) throw new Error('Not amodal');
+  const rest = npm.slice(prefix.length);
+  const dash = rest.indexOf('-');
+  if (dash < 0) throw new Error('No type');
+  return {type: rest.slice(0, dash), name: rest.slice(dash + 1)};
+});
+
+vi.mock('../shared/repo-discovery.js', () => ({
+  findRepoRoot: mockFindRepoRoot,
+}));
+
+vi.mock('@amodalai/core', () => ({
+  ensureNpmContext: mockEnsureNpmContext,
+  npmSearch: mockNpmSearch,
+  fromNpmName: mockFromNpmName,
+}));
+
+const mockPaths = {
+  root: '/test/repo/.amodal/packages',
+  npmDir: '/test/repo/.amodal/packages/.npm',
+  npmrc: '/test/repo/.amodal/packages/.npm/.npmrc',
+  packageJson: '/test/repo/.amodal/packages/.npm/package.json',
+  nodeModules: '/test/repo/.amodal/packages/.npm/node_modules',
+};
+
+describe('runSearch', () => {
+  let stderrOutput: string;
+  let stdoutOutput: string;
+
+  beforeEach(() => {
+    vi.clearAllMocks();
+    mockFindRepoRoot.mockReturnValue('/test/repo');
+    mockEnsureNpmContext.mockResolvedValue(mockPaths);
+    stderrOutput = '';
+    stdoutOutput = '';
+    vi.spyOn(process.stderr, 'write').mockImplementation((chunk) => {
+      stderrOutput += String(chunk);
+      return true;
+    });
+    vi.spyOn(process.stdout, 'write').mockImplementation((chunk) => {
+      stdoutOutput += String(chunk);
+      return true;
+    });
+  });
+
+  it('should search and display results', async () => {
+    mockNpmSearch.mockResolvedValue([
+      {name: '@amodalai/connection-salesforce', version: '2.1.0', description: 'Salesforce'},
+      {name: '@amodalai/connection-stripe', version: '1.0.0', description: 'Stripe'},
+    ]);
+
+    const {runSearch} = await import('./search.js');
+    const result = await runSearch({query: 'salesforce'});
+    expect(result).toBe(0);
+    expect(stdoutOutput).toContain('salesforce');
+    expect(stdoutOutput).toContain('stripe');
+  });
+
+  it('should filter by type', async () => {
+    mockNpmSearch.mockResolvedValue([
+      {name: '@amodalai/connection-salesforce', version: '2.1.0', description: 'Salesforce'},
+      {name: '@amodalai/skill-triage', version: '1.0.0', description: 'Triage'},
+    ]);
+
+    const {runSearch} = await import('./search.js');
+    const result = await runSearch({type: 'connection'});
+    expect(result).toBe(0);
+    expect(stdoutOutput).toContain('salesforce');
+    expect(stdoutOutput).not.toContain('triage');
+  });
+
+  it('should output JSON when json flag set', async () => {
+    mockNpmSearch.mockResolvedValue([
+      {name: '@amodalai/connection-salesforce', version: '2.1.0', description: 'Salesforce'},
+    ]);
+
+    const {runSearch} = await import('./search.js');
+    const result = await runSearch({json: true});
+    expect(result).toBe(0);
+    const parsed = JSON.parse(stdoutOutput);
+    expect(parsed).toHaveLength(1);
+    expect(parsed[0].type).toBe('connection');
+  });
+
+  it('should handle no results', async () => {
+    mockNpmSearch.mockResolvedValue([]);
+
+    const {runSearch} = await import('./search.js');
+    const result = await runSearch({query: 'nonexistent'});
+    expect(result).toBe(0);
+    expect(stderrOutput).toContain('No packages found');
+  });
+
+  it('should handle registry unreachable', async () => {
+    mockNpmSearch.mockRejectedValue(new Error('Registry unreachable'));
+
+    const {runSearch} = await import('./search.js');
+    const result = await runSearch({query: 'test'});
+    expect(result).toBe(1);
+    expect(stderrOutput).toContain('Search failed');
+  });
+
+  it('should filter out non-amodal packages', async () => {
+    mockNpmSearch.mockResolvedValue([
+      {name: '@amodalai/connection-salesforce', version: '1.0.0', description: 'Salesforce'},
+      {name: 'lodash', version: '4.0.0', description: 'Utility'},
+    ]);
+
+    const {runSearch} = await import('./search.js');
+    const result = await runSearch({});
+    expect(result).toBe(0);
+    expect(stdoutOutput).toContain('salesforce');
+    expect(stdoutOutput).not.toContain('lodash');
+  });
+
+  it('should work without repo root', async () => {
+    mockFindRepoRoot.mockImplementation(() => {
+      throw new Error('Not found');
+    });
+    mockNpmSearch.mockResolvedValue([
+      {name: '@amodalai/skill-triage', version: '1.0.0', description: 'Triage'},
+    ]);
+
+    const {runSearch} = await import('./search.js');
+    const result = await runSearch({query: 'triage'});
+    expect(result).toBe(0);
+  });
+
+  it('should group results by type', async () => {
+    mockNpmSearch.mockResolvedValue([
+      {name: '@amodalai/connection-salesforce', version: '2.0.0', description: 'Salesforce'},
+      {name: '@amodalai/skill-triage', version: '1.0.0', description: 'Triage'},
+    ]);
+
+    const {runSearch} = await import('./search.js');
+    const result = await runSearch({});
+    expect(result).toBe(0);
+    expect(stdoutOutput).toContain('CONNECTION');
+    expect(stdoutOutput).toContain('SKILL');
+  });
+
+  it('should handle npm context failure', async () => {
+    mockEnsureNpmContext.mockRejectedValue(new Error('Permission denied'));
+
+    const {runSearch} = await import('./search.js');
+    const result = await runSearch({});
+    expect(result).toBe(1);
+    expect(stderrOutput).toContain('Failed to set up npm context');
+  });
+
+  it('should show package count', async () => {
+    mockNpmSearch.mockResolvedValue([
+      {name: '@amodalai/connection-salesforce', version: '1.0.0', description: 'Salesforce'},
+      {name: '@amodalai/connection-stripe', version: '1.0.0', description: 'Stripe'},
+    ]);
+
+    const {runSearch} = await import('./search.js');
+    await runSearch({});
+    expect(stderrOutput).toContain('2 packages found');
+  });
+});