@amodalai/amodal 0.1.2

package/src/commands/deploy.ts

@@ -0,0 +1,153 @@
+/**
+ * @license
+ * Copyright 2025 Amodal Labs, Inc.
+ * SPDX-License-Identifier: MIT
+ */
+
+import {execSync} from 'node:child_process';
+import type {CommandModule} from 'yargs';
+import {loadRepo, buildSnapshot, serializeSnapshot, snapshotSizeBytes} from '@amodalai/core';
+import {findRepoRoot} from '../shared/repo-discovery.js';
+import {PlatformClient} from '../shared/platform-client.js';
+import {runValidate} from './validate.js';
+
+export interface DeployOptions {
+  cwd?: string;
+  message?: string;
+  env?: string;
+  dryRun?: boolean;
+}
+
+/**
+ * Get the current user from git config or fallback.
+ */
+function getCurrentUser(): string {
+  try {
+    return execSync('git config user.email', {encoding: 'utf-8'}).trim();
+  } catch {
+    return process.env['USER'] ?? 'unknown';
+  }
+}
+
+/**
+ * Get the current git commit SHA, or undefined if not in a git repo.
+ */
+function getGitSha(): string | undefined {
+  try {
+    return execSync('git rev-parse HEAD', {encoding: 'utf-8'}).trim();
+  } catch {
+    return undefined;
+  }
+}
+
+
+/**
+ * Deploy to the platform: resolve → validate → snapshot → upload.
+ *
+ * Returns 0 on success, 1 on error.
+ */
+export async function runDeploy(options: DeployOptions = {}): Promise<number> {
+  let repoPath: string;
+  try {
+    repoPath = findRepoRoot(options.cwd);
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    process.stderr.write(`[deploy] ${msg}\n`);
+    return 1;
+  }
+
+  // Validate
+  process.stderr.write(`[deploy] Validating ${repoPath}...\n`);
+  const errors = await runValidate({cwd: repoPath});
+  if (errors > 0) {
+    process.stderr.write(`[deploy] Validation failed with ${errors} error(s). Fix errors before deploying.\n`);
+    return 1;
+  }
+
+  // Load repo
+  process.stderr.write('[deploy] Loading repo...\n');
+  let repo;
+  try {
+    repo = await loadRepo({localPath: repoPath});
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    process.stderr.write(`[deploy] Failed to load repo: ${msg}\n`);
+    return 1;
+  }
+
+  // Build snapshot
+  const snapshot = buildSnapshot(repo, {
+    createdBy: getCurrentUser(),
+    source: 'cli',
+    commitSha: getGitSha(),
+    message: options.message,
+  });
+
+  const serialized = serializeSnapshot(snapshot);
+  const size = snapshotSizeBytes(serialized);
+  const environment = options.env ?? 'production';
+
+  process.stderr.write(`[deploy] Snapshot ${snapshot.deployId} built (${(size / 1024).toFixed(1)} KB)\n`);
+  process.stderr.write(`[deploy] Connections: ${Object.keys(snapshot.connections).length}, Skills: ${snapshot.skills.length}, Automations: ${snapshot.automations.length}\n`);
+
+  if (options.dryRun) {
+    process.stderr.write(`[deploy] Dry run — would deploy ${snapshot.deployId} to ${environment}\n`);
+    return 0;
+  }
+
+  // Upload to platform
+  process.stderr.write(`[deploy] Uploading to platform (${environment})...\n`);
+  let client: PlatformClient;
+  try {
+    client = await PlatformClient.create();
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    process.stderr.write(`[deploy] ${msg}\n`);
+    return 1;
+  }
+
+  try {
+    const result = await client.uploadSnapshot(snapshot, {environment});
+    process.stderr.write(`[deploy] Deployed ${result.id} to ${result.environment}\n`);
+    if (result.message) {
+      process.stderr.write(`[deploy] Message: ${result.message}\n`);
+    }
+    return 0;
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    process.stderr.write(`[deploy] Upload failed: ${msg}\n`);
+    return 1;
+  }
+}
+
+export const deployCommand: CommandModule = {
+  command: 'deploy',
+  describe: 'Deploy to the platform',
+  builder: (yargs) =>
+    yargs
+      .option('message', {
+        type: 'string',
+        alias: 'm',
+        describe: 'Deployment message',
+      })
+      .option('env', {
+        type: 'string',
+        describe: 'Target environment (default: production)',
+      })
+      .option('dry-run', {
+        type: 'boolean',
+        describe: 'Build snapshot without uploading',
+        default: false,
+      }),
+  handler: async (argv) => {
+    const code = await runDeploy({
+      // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion
+      message: argv['message'] as string | undefined,
+      // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion
+      env: argv['env'] as string | undefined,
+      // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion
+      dryRun: argv['dryRun'] as boolean | undefined,
+    });
+    process.exit(code);
+  },
+};

package/src/commands/deployments.ts

@@ -0,0 +1,90 @@
+/**
+ * @license
+ * Copyright 2025 Amodal Labs, Inc.
+ * SPDX-License-Identifier: MIT
+ */
+
+import type {CommandModule} from 'yargs';
+import {PlatformClient} from '../shared/platform-client.js';
+
+export interface DeploymentsOptions {
+  env?: string;
+  limit?: number;
+  json?: boolean;
+}
+
+/**
+ * List deployment history.
+ */
+export async function runDeployments(options: DeploymentsOptions = {}): Promise<number> {
+  let client: PlatformClient;
+  try {
+    client = new PlatformClient();
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    process.stderr.write(`[deployments] ${msg}\n`);
+    return 1;
+  }
+
+  try {
+    const deployments = await client.listDeployments({
+      environment: options.env,
+      limit: options.limit ?? 10,
+    });
+
+    if (options.json) {
+      process.stdout.write(JSON.stringify(deployments, null, 2) + '\n');
+      return 0;
+    }
+
+    if (deployments.length === 0) {
+      process.stderr.write('[deployments] No deployments found.\n');
+      return 0;
+    }
+
+    for (const d of deployments) {
+      const active = d.isActive ? ' [ACTIVE]' : '';
+      const msg = d.message ? ` — ${d.message}` : '';
+      const sha = d.commitSha ? ` (${d.commitSha.slice(0, 7)})` : '';
+      process.stdout.write(`${d.id}  ${d.environment}${active}  ${d.createdBy ?? d.source}${sha}  ${d.createdAt}${msg}\n`);
+    }
+
+    return 0;
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    process.stderr.write(`[deployments] Failed: ${msg}\n`);
+    return 1;
+  }
+}
+
+export const deploymentsCommand: CommandModule = {
+  command: 'deployments',
+  describe: 'List deployment history',
+  builder: (yargs) =>
+    yargs
+      .option('env', {
+        type: 'string',
+        describe: 'Filter by environment',
+      })
+      .option('limit', {
+        type: 'number',
+        describe: 'Number of deployments to show',
+        default: 10,
+      })
+      .option('json', {
+        type: 'boolean',
+        describe: 'Output as JSON',
+        default: false,
+      }),
+  handler: async (argv) => {
+    const code = await runDeployments({
+      // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion
+      env: argv['env'] as string | undefined,
+      // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion
+      limit: argv['limit'] as number | undefined,
+      // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion
+      json: argv['json'] as boolean | undefined,
+    });
+    process.exit(code);
+  },
+};

package/src/commands/dev.test.ts

@@ -0,0 +1,63 @@
+/**
+ * @license
+ * Copyright 2025 Amodal Labs, Inc.
+ * SPDX-License-Identifier: MIT
+ */
+
+import {describe, it, expect, vi} from 'vitest';
+
+vi.mock('../shared/repo-discovery.js', () => ({
+  findRepoRoot: vi.fn(() => '/test/repo'),
+}));
+
+vi.mock('@amodalai/runtime', () => ({
+  createLocalServer: vi.fn().mockResolvedValue({
+    app: {},
+    start: vi.fn().mockResolvedValue({}),
+    stop: vi.fn().mockResolvedValue(undefined),
+  }),
+}));
+
+describe('dev command', () => {
+  it('should import without error', async () => {
+    const mod = await import('./dev.js');
+    expect(mod.runDev).toBeDefined();
+    expect(typeof mod.runDev).toBe('function');
+  });
+
+  it('should find repo root', async () => {
+    const {findRepoRoot} = await import('../shared/repo-discovery.js');
+    const root = findRepoRoot('/some/path');
+    expect(root).toBe('/test/repo');
+  });
+
+  it('should create repo server with correct config', async () => {
+    const {createLocalServer} = await import('@amodalai/runtime');
+    const mockExit = vi.spyOn(process, 'exit').mockImplementation(() => {
+      throw new Error('exit');
+    });
+
+    // runDev calls process.exit on success (after server starts), so we catch that
+    try {
+      const {runDev} = await import('./dev.js');
+      // Don't actually run it — just verify the module loads
+      expect(runDev).toBeDefined();
+    } catch {
+      // Expected
+    }
+
+    expect(createLocalServer).toBeDefined();
+    mockExit.mockRestore();
+  });
+
+  it('should use default port 3847', async () => {
+    const mod = await import('./dev.js');
+    // Just verify the export exists — actual server test is integration
+    expect(mod.runDev).toBeDefined();
+  });
+
+  it('should accept custom port', async () => {
+    const mod = await import('./dev.js');
+    expect(mod.runDev).toBeDefined();
+  });
+});

package/src/commands/dev.ts

@@ -0,0 +1,124 @@
+/**
+ * @license
+ * Copyright 2025 Amodal Labs, Inc.
+ * SPDX-License-Identifier: MIT
+ */
+
+import type {CommandModule} from 'yargs';
+import {existsSync} from 'node:fs';
+import path from 'node:path';
+import {fileURLToPath} from 'node:url';
+import {createLocalServer} from '@amodalai/runtime';
+import {findRepoRoot} from '../shared/repo-discovery.js';
+
+async function loadRuntimeApp(): Promise<typeof import('@amodalai/runtime-app/dev') | null> {
+  try {
+    return await import('@amodalai/runtime-app/dev');
+  } catch {
+    // Runtime app is optional — server-only mode without the frontend
+    return null;
+  }
+}
+
+export interface DevOptions {
+  cwd?: string;
+  port?: number;
+  host?: string;
+}
+
+const DEFAULT_PORT = 3847;
+
+/**
+ * Starts a local development server for the repo with hot reload enabled.
+ */
+export async function runDev(options: DevOptions = {}): Promise<void> {
+  let repoPath: string;
+  try {
+    repoPath = findRepoRoot(options.cwd);
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    process.stderr.write(`[dev] ${msg}\n`);
+    process.exit(1);
+  }
+
+  const port = options.port ?? DEFAULT_PORT;
+  const host = options.host ?? '0.0.0.0';
+
+  process.stderr.write(`[dev] Starting dev server for ${repoPath}\n`);
+
+  try {
+    // Try to load the runtime app for the dev UI
+    let appMiddleware: ((req: unknown, res: unknown, next: unknown) => void) | undefined;
+    let staticAppDir: string | undefined;
+
+    const runtimeApp = await loadRuntimeApp();
+    if (runtimeApp) {
+      process.stderr.write('[dev] Loading runtime app (Vite dev server)...\n');
+      appMiddleware = await runtimeApp.createDevMiddleware(repoPath);
+    } else {
+      // Fall back to pre-built static assets (bundled mode or global install)
+      const scriptDir = path.dirname(fileURLToPath(import.meta.url));
+      const candidates = [
+        // esbuild bundle: bundle/app/
+        path.resolve(scriptDir, 'app'),
+        // global/local install: <pkg root>/node_modules/@amodalai/runtime-app/dist/
+        path.resolve(scriptDir, '..', '..', '..', 'node_modules', '@amodal', 'runtime-app', 'dist'),
+      ];
+      for (const dir of candidates) {
+        if (existsSync(path.join(dir, 'index.html'))) {
+          process.stderr.write('[dev] Serving pre-built runtime app\n');
+          staticAppDir = dir;
+          break;
+        }
+      }
+    }
+
+    const server = await createLocalServer({
+      repoPath,
+      port,
+      host,
+      hotReload: true,
+      corsOrigin: '*',
+      appMiddleware,
+      staticAppDir,
+    });
+
+    await server.start();
+
+    // Graceful shutdown
+    const shutdown = async (signal: string): Promise<void> => {
+      process.stderr.write(`\n[dev] Received ${signal}, shutting down...\n`);
+      await server.stop();
+      process.exit(0);
+    };
+
+    process.on('SIGTERM', () => void shutdown('SIGTERM'));
+    process.on('SIGINT', () => void shutdown('SIGINT'));
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    process.stderr.write(`[dev] Failed to start: ${msg}\n`);
+    process.exit(1);
+  }
+}
+
+export const devCommand: CommandModule = {
+  command: 'dev',
+  describe: 'Start local dev server',
+  builder: {
+    port: {
+      type: 'number',
+      describe: 'Port to listen on',
+    },
+    host: {
+      type: 'string',
+      describe: 'Host to bind to',
+    },
+  },
+  handler: async (argv) => {
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion
+    const port = argv['port'] as number | undefined;
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion
+    const host = argv['host'] as string | undefined;
+    await runDev({port, host});
+  },
+};

package/src/commands/diff.test.ts

@@ -0,0 +1,183 @@
+/**
+ * @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 mockGetLockEntry = vi.fn();
+const mockNpmView = vi.fn();
+const mockGetPackageDir = vi.fn();
+const mockReadPackageFile = vi.fn();
+const mockListPackageFiles = vi.fn();
+const mockMakePackageRef = vi.fn((type: string, name: string) => ({
+  type,
+  name,
+  key: `${type}/${name}`,
+  npmName: `@amodalai/${type}-${name}`,
+}));
+
+vi.mock('../shared/repo-discovery.js', () => ({
+  findRepoRoot: mockFindRepoRoot,
+}));
+
+vi.mock('@amodalai/core', () => ({
+  ensureNpmContext: mockEnsureNpmContext,
+  getLockEntry: mockGetLockEntry,
+  npmView: mockNpmView,
+  getPackageDir: mockGetPackageDir,
+  readPackageFile: mockReadPackageFile,
+  listPackageFiles: mockListPackageFiles,
+  makePackageRef: mockMakePackageRef,
+}));
+
+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('runDiff', () => {
+  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 show diff when version differs', async () => {
+    mockGetLockEntry.mockResolvedValue({version: '1.0.0', npm: '@amodalai/connection-salesforce', integrity: 'sha512-old'});
+    mockNpmView.mockResolvedValue({name: '@amodalai/connection-salesforce', version: '2.0.0', versions: ['1.0.0', '2.0.0']});
+    mockGetPackageDir.mockResolvedValue('/test/repo/.amodal/packages/connection--salesforce');
+    mockListPackageFiles.mockResolvedValue(['spec.json', 'surface.md', 'package.json']);
+    mockReadPackageFile.mockResolvedValue('content\nline2\n');
+
+    const {runDiff} = await import('./diff.js');
+    const result = await runDiff({type: 'connection', name: 'salesforce'});
+    expect(result).toBe(0);
+    expect(stdoutOutput).toContain('1.0.0');
+    expect(stdoutOutput).toContain('2.0.0');
+  });
+
+  it('should report already latest', async () => {
+    mockGetLockEntry.mockResolvedValue({version: '2.0.0', npm: '@amodalai/connection-salesforce', integrity: 'sha512-old'});
+    mockNpmView.mockResolvedValue({name: '@amodalai/connection-salesforce', version: '2.0.0', versions: ['1.0.0', '2.0.0']});
+
+    const {runDiff} = await import('./diff.js');
+    const result = await runDiff({type: 'connection', name: 'salesforce'});
+    expect(result).toBe(0);
+    expect(stderrOutput).toContain('already the latest');
+  });
+
+  it('should return 1 when not installed', async () => {
+    mockGetLockEntry.mockResolvedValue(null);
+
+    const {runDiff} = await import('./diff.js');
+    const result = await runDiff({type: 'connection', name: 'salesforce'});
+    expect(result).toBe(1);
+    expect(stderrOutput).toContain('not installed');
+  });
+
+  it('should return 1 when registry unreachable', async () => {
+    mockGetLockEntry.mockResolvedValue({version: '1.0.0', npm: '@amodalai/connection-salesforce', integrity: 'sha512-old'});
+    mockNpmView.mockRejectedValue(new Error('Registry unreachable'));
+
+    const {runDiff} = await import('./diff.js');
+    const result = await runDiff({type: 'connection', name: 'salesforce'});
+    expect(result).toBe(1);
+    expect(stderrOutput).toContain('Failed to query registry');
+  });
+
+  it('should return 1 when repo not found', async () => {
+    mockFindRepoRoot.mockImplementation(() => {
+      throw new Error('Not found');
+    });
+
+    const {runDiff} = await import('./diff.js');
+    const result = await runDiff({type: 'connection', name: 'salesforce'});
+    expect(result).toBe(1);
+    expect(stderrOutput).toContain('Not found');
+  });
+
+  it('should show surface endpoint count', async () => {
+    mockGetLockEntry.mockResolvedValue({version: '1.0.0', npm: '@amodalai/connection-salesforce', integrity: 'sha512-old'});
+    mockNpmView.mockResolvedValue({name: '@amodalai/connection-salesforce', version: '2.0.0', versions: ['1.0.0', '2.0.0']});
+    mockGetPackageDir.mockResolvedValue('/test/repo/.amodal/packages/connection--salesforce');
+    mockListPackageFiles.mockResolvedValue(['surface.md']);
+    mockReadPackageFile.mockResolvedValue('## GET /users\nList users\n\n## POST /users\nCreate user\n');
+
+    const {runDiff} = await import('./diff.js');
+    const result = await runDiff({type: 'connection', name: 'salesforce'});
+    expect(result).toBe(0);
+    expect(stdoutOutput).toContain('2 endpoints');
+  });
+
+  it('should show spec.json keys', async () => {
+    mockGetLockEntry.mockResolvedValue({version: '1.0.0', npm: '@amodalai/connection-salesforce', integrity: 'sha512-old'});
+    mockNpmView.mockResolvedValue({name: '@amodalai/connection-salesforce', version: '2.0.0', versions: ['1.0.0', '2.0.0']});
+    mockGetPackageDir.mockResolvedValue('/test/repo/.amodal/packages/connection--salesforce');
+    mockListPackageFiles.mockResolvedValue(['spec.json']);
+    mockReadPackageFile.mockResolvedValue(JSON.stringify({source: 'https://api.example.com', format: 'openapi'}));
+
+    const {runDiff} = await import('./diff.js');
+    const result = await runDiff({type: 'connection', name: 'salesforce'});
+    expect(result).toBe(0);
+    expect(stdoutOutput).toContain('source');
+    expect(stdoutOutput).toContain('format');
+  });
+
+  it('should handle package not on disk', async () => {
+    mockGetLockEntry.mockResolvedValue({version: '1.0.0', npm: '@amodalai/connection-salesforce', integrity: 'sha512-old'});
+    mockNpmView.mockResolvedValue({name: '@amodalai/connection-salesforce', version: '2.0.0', versions: ['1.0.0', '2.0.0']});
+    mockGetPackageDir.mockResolvedValue(null);
+
+    const {runDiff} = await import('./diff.js');
+    const result = await runDiff({type: 'connection', name: 'salesforce'});
+    expect(result).toBe(1);
+    expect(stderrOutput).toContain('not installed on disk');
+  });
+
+  it('should show access.json rule count', async () => {
+    mockGetLockEntry.mockResolvedValue({version: '1.0.0', npm: '@amodalai/connection-salesforce', integrity: 'sha512-old'});
+    mockNpmView.mockResolvedValue({name: '@amodalai/connection-salesforce', version: '2.0.0', versions: ['1.0.0', '2.0.0']});
+    mockGetPackageDir.mockResolvedValue('/test/repo/.amodal/packages/connection--salesforce');
+    mockListPackageFiles.mockResolvedValue(['access.json']);
+    mockReadPackageFile.mockResolvedValue(JSON.stringify({
+      'GET /users': {confirm: true},
+      'POST /users': {confirm: 'review'},
+    }));
+
+    const {runDiff} = await import('./diff.js');
+    const result = await runDiff({type: 'connection', name: 'salesforce'});
+    expect(result).toBe(0);
+    expect(stdoutOutput).toContain('2 rules');
+  });
+
+  it('should suggest update command', async () => {
+    mockGetLockEntry.mockResolvedValue({version: '1.0.0', npm: '@amodalai/connection-salesforce', integrity: 'sha512-old'});
+    mockNpmView.mockResolvedValue({name: '@amodalai/connection-salesforce', version: '2.0.0', versions: ['1.0.0', '2.0.0']});
+    mockGetPackageDir.mockResolvedValue('/test/repo/.amodal/packages/connection--salesforce');
+    mockListPackageFiles.mockResolvedValue([]);
+
+    const {runDiff} = await import('./diff.js');
+    await runDiff({type: 'connection', name: 'salesforce'});
+    expect(stdoutOutput).toContain('amodal update connection salesforce');
+  });
+});