@amodalai/amodal 0.1.2

package/src/commands/status.ts

@@ -0,0 +1,94 @@
+/**
+ * @license
+ * Copyright 2025 Amodal Labs, Inc.
+ * SPDX-License-Identifier: MIT
+ */
+
+import type {CommandModule} from 'yargs';
+import {PlatformClient} from '../shared/platform-client.js';
+
+export interface StatusOptions {
+  env?: string;
+  json?: boolean;
+}
+
+/**
+ * Show current deployment status per environment.
+ */
+export async function runStatus(options: StatusOptions = {}): Promise<number> {
+  let client: PlatformClient;
+  try {
+    client = await PlatformClient.create();
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    process.stderr.write(`[status] ${msg}\n`);
+    return 1;
+  }
+
+  const environments = options.env ? [options.env] : ['production', 'staging'];
+
+  try {
+    const results: Array<{environment: string; id?: string; createdAt?: string; createdBy?: string; commitSha?: string}> = [];
+
+    for (const env of environments) {
+      const deployments = await client.listDeployments({environment: env, limit: 1});
+      const active = deployments.find((d) => d.isActive);
+      if (active) {
+        results.push({
+          environment: env,
+          id: active.id,
+          createdAt: active.createdAt,
+          createdBy: active.createdBy ?? undefined,
+          commitSha: active.commitSha ?? undefined,
+        });
+      } else {
+        results.push({environment: env});
+      }
+    }
+
+    if (options.json) {
+      process.stdout.write(JSON.stringify(results, null, 2) + '\n');
+      return 0;
+    }
+
+    for (const r of results) {
+      if (r.id) {
+        const sha = r.commitSha ? ` (${r.commitSha.slice(0, 7)})` : '';
+        process.stdout.write(`${r.environment}: ${r.id}${sha} — ${r.createdBy ?? 'unknown'} at ${r.createdAt}\n`);
+      } else {
+        process.stdout.write(`${r.environment}: no active deployment\n`);
+      }
+    }
+
+    return 0;
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    process.stderr.write(`[status] Failed: ${msg}\n`);
+    return 1;
+  }
+}
+
+export const statusCommand: CommandModule = {
+  command: 'status',
+  describe: 'Show current deployment status',
+  builder: (yargs) =>
+    yargs
+      .option('env', {
+        type: 'string',
+        describe: 'Check specific environment',
+      })
+      .option('json', {
+        type: 'boolean',
+        describe: 'Output as JSON',
+        default: false,
+      }),
+  handler: async (argv) => {
+    const code = await runStatus({
+      // 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
+      json: argv['json'] as boolean | undefined,
+    });
+    process.exit(code);
+  },
+};

package/src/commands/sync.test.ts

@@ -0,0 +1,130 @@
+/**
+ * @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 mockLoadRepo = vi.fn();
+const mockBuildSyncPlan = vi.fn();
+
+vi.mock('../shared/repo-discovery.js', () => ({
+  findRepoRoot: mockFindRepoRoot,
+}));
+
+vi.mock('@amodalai/core', () => ({
+  loadRepo: mockLoadRepo,
+  buildSyncPlan: mockBuildSyncPlan,
+}));
+
+describe('runSync', () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+    mockFindRepoRoot.mockReturnValue('/test/repo');
+  });
+
+  it('should return 0 when all connections are in sync', async () => {
+    mockLoadRepo.mockResolvedValue({
+      connections: new Map([['api', {spec: {format: 'openapi', source: 'https://api.test'}}]]),
+    });
+    mockBuildSyncPlan.mockResolvedValue({
+      connectionName: 'api',
+      added: [],
+      removed: [],
+      changed: [],
+      unchanged: ['GET /users'],
+    });
+
+    const {runSync} = await import('./sync.js');
+    const result = await runSync();
+    expect(result).toBe(0);
+  });
+
+  it('should return 1 in check mode when drift detected', async () => {
+    mockLoadRepo.mockResolvedValue({
+      connections: new Map([['api', {spec: {format: 'openapi', source: 'https://api.test'}}]]),
+    });
+    mockBuildSyncPlan.mockResolvedValue({
+      connectionName: 'api',
+      added: [{method: 'GET', path: '/new'}],
+      removed: [],
+      changed: [],
+      unchanged: [],
+    });
+
+    const {runSync} = await import('./sync.js');
+    const result = await runSync({check: true});
+    expect(result).toBe(1);
+  });
+
+  it('should skip non-openapi connections', async () => {
+    mockLoadRepo.mockResolvedValue({
+      connections: new Map([['api', {spec: {format: 'graphql', source: 'https://api.test'}}]]),
+    });
+
+    const {runSync} = await import('./sync.js');
+    const result = await runSync();
+    expect(result).toBe(0);
+    expect(mockBuildSyncPlan).not.toHaveBeenCalled();
+  });
+
+  it('should filter by connection name', async () => {
+    mockLoadRepo.mockResolvedValue({
+      connections: new Map([
+        ['api-1', {spec: {format: 'openapi', source: 'https://api1.test'}}],
+        ['api-2', {spec: {format: 'openapi', source: 'https://api2.test'}}],
+      ]),
+    });
+    mockBuildSyncPlan.mockResolvedValue({
+      connectionName: 'api-1',
+      added: [],
+      removed: [],
+      changed: [],
+      unchanged: [],
+    });
+
+    const {runSync} = await import('./sync.js');
+    await runSync({connection: 'api-1'});
+    expect(mockBuildSyncPlan).toHaveBeenCalledTimes(1);
+  });
+
+  it('should return 1 when repo not found', async () => {
+    mockFindRepoRoot.mockImplementation(() => {
+      throw new Error('Not found');
+    });
+
+    const {runSync} = await import('./sync.js');
+    const result = await runSync();
+    expect(result).toBe(1);
+  });
+
+  it('should handle sync errors gracefully', async () => {
+    mockLoadRepo.mockResolvedValue({
+      connections: new Map([['api', {spec: {format: 'openapi', source: 'https://api.test'}}]]),
+    });
+    mockBuildSyncPlan.mockRejectedValue(new Error('Fetch failed'));
+
+    const {runSync} = await import('./sync.js');
+    const result = await runSync();
+    expect(result).toBe(0);
+  });
+
+  it('should return 0 in check mode when no drift', async () => {
+    mockLoadRepo.mockResolvedValue({
+      connections: new Map([['api', {spec: {format: 'openapi', source: 'https://api.test'}}]]),
+    });
+    mockBuildSyncPlan.mockResolvedValue({
+      connectionName: 'api',
+      added: [],
+      removed: [],
+      changed: [],
+      unchanged: ['GET /users'],
+    });
+
+    const {runSync} = await import('./sync.js');
+    const result = await runSync({check: true});
+    expect(result).toBe(0);
+  });
+});

package/src/commands/sync.ts

@@ -0,0 +1,119 @@
+/**
+ * @license
+ * Copyright 2025 Amodal Labs, Inc.
+ * SPDX-License-Identifier: MIT
+ */
+
+import {loadRepo,buildSyncPlan} from '@amodalai/core';
+import type {SyncPlan} from '@amodalai/core';
+import type {CommandModule} from 'yargs';
+import {findRepoRoot} from '../shared/repo-discovery.js';
+
+export interface SyncOptions {
+  cwd?: string;
+  /** CI mode — just check, exit 1 if drift detected */
+  check?: boolean;
+  /** Only sync a specific connection */
+  connection?: string;
+}
+
+/**
+ * For each connection with an OpenAPI spec URL, fetch the spec,
+ * detect drift against the surface endpoints, and optionally
+ * apply updates interactively.
+ */
+export async function runSync(options: SyncOptions = {}): Promise<number> {
+  let repoPath: string;
+  try {
+    repoPath = findRepoRoot(options.cwd);
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    process.stderr.write(`[sync] ${msg}\n`);
+    return 1;
+  }
+
+  process.stderr.write(`[sync] Loading repo from ${repoPath}\n`);
+
+  const repo = await loadRepo({localPath: repoPath});
+  let hasDrift = false;
+
+  for (const [name, conn] of repo.connections) {
+    if (options.connection && name !== options.connection) {
+      continue;
+    }
+
+    if (conn.spec.format !== 'openapi') {
+      process.stderr.write(`[sync] ${name}: not an openapi connection (${conn.spec.format}), skipping\n`);
+      continue;
+    }
+
+    process.stderr.write(`[sync] ${name}: checking for drift...\n`);
+
+    try {
+      const plan = await buildSyncPlan(conn);
+      printSyncPlan(name, plan);
+
+      if (plan.added.length > 0 || plan.removed.length > 0 || plan.changed.length > 0) {
+        hasDrift = true;
+      }
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      process.stderr.write(`[sync] ${name}: error — ${msg}\n`);
+    }
+  }
+
+  if (options.check) {
+    return hasDrift ? 1 : 0;
+  }
+
+  return 0;
+}
+
+function printSyncPlan(connectionName: string, plan: SyncPlan): void {
+  const total = plan.added.length + plan.removed.length + plan.changed.length;
+
+  if (total === 0) {
+    process.stderr.write(`[sync] ${connectionName}: in sync (${plan.unchanged.length} endpoints)\n`);
+    return;
+  }
+
+  process.stderr.write(`[sync] ${connectionName}: ${total} change(s) detected\n`);
+
+  for (const ep of plan.added) {
+    const label = 'method' in ep ? `${ep['method']} ${ep['path']}` : ep.name;
+    process.stderr.write(`  + ${label}\n`);
+  }
+
+  for (const ep of plan.removed) {
+    process.stderr.write(`  - ${ep.method} ${ep.path}\n`);
+  }
+
+  for (const change of plan.changed) {
+    const label = 'endpoint' in change ? change['endpoint'] : change.name;
+    process.stderr.write(`  ~ ${label} (${change.changes.join(', ')})\n`);
+  }
+}
+
+export const syncCommand: CommandModule = {
+  command: 'sync',
+  describe: 'Check for OpenAPI spec drift',
+  builder: {
+    check: {
+      type: 'boolean' as const,
+      default: false,
+      describe: 'CI mode — exit 1 if drift detected',
+    },
+    connection: {
+      type: 'string' as const,
+      describe: 'Only sync a specific connection',
+    },
+  },
+  handler: async (argv) => {
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion
+    const check = argv['check'] as boolean;
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion
+    const connection = argv['connection'] as string | undefined;
+    const code = await runSync({check, connection});
+    process.exit(code);
+  },
+};

package/src/commands/test-query.test.ts

@@ -0,0 +1,42 @@
+/**
+ * @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({address: () => ({port: 9999})}),
+    stop: vi.fn().mockResolvedValue(undefined),
+  }),
+}));
+
+describe('test-query command', () => {
+  it('should import without error', async () => {
+    const mod = await import('./test-query.js');
+    expect(mod.runTestQuery).toBeDefined();
+    expect(typeof mod.runTestQuery).toBe('function');
+  });
+
+  it('should require a message', async () => {
+    const mod = await import('./test-query.js');
+    expect(mod.runTestQuery).toBeDefined();
+  });
+
+  it('should use default tenant ID', async () => {
+    const mod = await import('./test-query.js');
+    expect(mod.runTestQuery).toBeDefined();
+  });
+
+  it('should accept custom port', async () => {
+    const mod = await import('./test-query.js');
+    expect(mod.runTestQuery).toBeDefined();
+  });
+});

package/src/commands/test-query.ts

@@ -0,0 +1,129 @@
+/**
+ * @license
+ * Copyright 2025 Amodal Labs, Inc.
+ * SPDX-License-Identifier: MIT
+ */
+
+import type {CommandModule} from 'yargs';
+import {createLocalServer} from '@amodalai/runtime';
+import {findRepoRoot} from '../shared/repo-discovery.js';
+
+export interface TestQueryOptions {
+  cwd?: string;
+  message: string;
+  tenantId?: string;
+  port?: number;
+}
+
+/**
+ * Sends a single test query to an ephemeral repo server and streams
+ * the response to stdout.
+ */
+export async function runTestQuery(options: TestQueryOptions): Promise<void> {
+  let repoPath: string;
+  try {
+    repoPath = findRepoRoot(options.cwd);
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    process.stderr.write(`[test-query] ${msg}\n`);
+    process.exit(1);
+  }
+
+  const port = options.port ?? 0; // 0 = random available port
+  const tenantId = options.tenantId ?? 'test-user';
+
+  process.stderr.write(`[test-query] Loading repo from ${repoPath}\n`);
+
+  const server = await createLocalServer({
+    repoPath,
+    port,
+    host: '127.0.0.1',
+    hotReload: false,
+  });
+
+  const httpServer = await server.start();
+  const addr = httpServer.address();
+  const actualPort = typeof addr === 'object' && addr !== null ? addr.port : port;
+
+  try {
+    const url = `http://127.0.0.1:${actualPort}/chat`;
+    const response = await fetch(url, {
+      method: 'POST',
+      headers: {'Content-Type': 'application/json'},
+      body: JSON.stringify({
+        message: options.message,
+        tenant_id: tenantId,
+      }),
+    });
+
+    if (!response.ok) {
+      process.stderr.write(`[test-query] HTTP ${response.status}: ${await response.text()}\n`);
+      return;
+    }
+
+    // Parse SSE response
+    const text = await response.text();
+    const lines = text.split('\n');
+
+    for (const line of lines) {
+      if (!line.startsWith('data: ')) continue;
+      const jsonStr = line.substring(6);
+      try {
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion -- parsing SSE event
+        const event = JSON.parse(jsonStr) as Record<string, unknown>;
+        if (event['type'] === 'text_delta') {
+          process.stdout.write(String(event['content'] ?? ''));
+        } else if (event['type'] === 'tool_call_start') {
+          process.stderr.write(`\n[tool] ${event['tool_name']}(${JSON.stringify(event['parameters'])})\n`);
+        } else if (event['type'] === 'tool_call_result') {
+          const status = event['status'];
+          if (status === 'error') {
+            process.stderr.write(`[tool] ERROR: ${event['error']}\n`);
+          } else {
+            const result = String(event['result'] ?? '');
+            const preview = result.length > 200 ? result.substring(0, 200) + '...' : result;
+            process.stderr.write(`[tool] OK (${event['duration_ms']}ms): ${preview}\n`);
+          }
+        } else if (event['type'] === 'error') {
+          process.stderr.write(`\n[error] ${event['message']}\n`);
+        }
+      } catch {
+        // Skip invalid JSON lines
+      }
+    }
+
+    process.stdout.write('\n');
+  } finally {
+    await server.stop();
+  }
+}
+
+export const testQueryCommand: CommandModule = {
+  command: 'test-query <message>',
+  describe: 'Send a test query to the local server',
+  builder: (yargs) =>
+    yargs
+      .positional('message', {
+        type: 'string',
+        demandOption: true,
+        describe: 'The message to send',
+      })
+      .option('tenant-id', {
+        type: 'string',
+        describe: 'Tenant ID to use for the query',
+      })
+      .option('port', {
+        type: 'number',
+        describe: 'Port for the ephemeral server',
+      }),
+  handler: async (argv) => {
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion
+    const message = argv['message'] as string;
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion
+    const tenantId = argv['tenant-id'] as string | undefined;
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion
+    const port = argv['port'] as number | undefined;
+
+    await runTestQuery({message, tenantId, port});
+  },
+};

package/src/commands/uninstall.test.ts

@@ -0,0 +1,162 @@
+/**
+ * @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 mockGetLockEntry = vi.fn();
+const mockGetNpmContextPaths = vi.fn();
+const mockMakePackageRef = vi.fn((type: string, name: string) => ({
+  type,
+  name,
+  key: `${type}/${name}`,
+  npmName: `@amodalai/${type}-${name}`,
+}));
+const mockNpmUninstall = vi.fn();
+const mockRemoveLockEntry = vi.fn();
+const mockToSymlinkName = vi.fn((type: string, name: string) => `${type}--${name}`);
+
+const mockUnlink = vi.fn();
+const mockStat = vi.fn();
+
+vi.mock('../shared/repo-discovery.js', () => ({
+  findRepoRoot: mockFindRepoRoot,
+}));
+
+vi.mock('@amodalai/core', () => ({
+  getLockEntry: mockGetLockEntry,
+  getNpmContextPaths: mockGetNpmContextPaths,
+  makePackageRef: mockMakePackageRef,
+  npmUninstall: mockNpmUninstall,
+  removeLockEntry: mockRemoveLockEntry,
+  toSymlinkName: mockToSymlinkName,
+}));
+
+vi.mock('node:fs/promises', () => ({
+  unlink: mockUnlink,
+  stat: mockStat,
+}));
+
+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('runUninstall', () => {
+  let stderrOutput: string;
+
+  beforeEach(() => {
+    vi.clearAllMocks();
+    mockFindRepoRoot.mockReturnValue('/test/repo');
+    mockGetNpmContextPaths.mockReturnValue(mockPaths);
+    mockGetLockEntry.mockResolvedValue({version: '1.0.0', npm: '@amodalai/connection-stripe', integrity: 'sha512-abc'});
+    mockNpmUninstall.mockResolvedValue(undefined);
+    mockRemoveLockEntry.mockResolvedValue({lockVersion: 1, packages: {}});
+    mockUnlink.mockResolvedValue(undefined);
+    mockStat.mockRejectedValue(Object.assign(new Error('ENOENT'), {code: 'ENOENT'}));
+    stderrOutput = '';
+    vi.spyOn(process.stderr, 'write').mockImplementation((chunk) => {
+      stderrOutput += String(chunk);
+      return true;
+    });
+  });
+
+  it('should uninstall a package successfully', async () => {
+    const {runUninstall} = await import('./uninstall.js');
+    const result = await runUninstall({type: 'connection', name: 'stripe'});
+    expect(result).toBe(0);
+    expect(mockNpmUninstall).toHaveBeenCalledWith(mockPaths, '@amodalai/connection-stripe');
+    expect(mockRemoveLockEntry).toHaveBeenCalledWith('/test/repo', 'connection', 'stripe');
+    expect(mockUnlink).toHaveBeenCalled();
+    expect(stderrOutput).toContain('Removed connection/stripe');
+  });
+
+  it('should return 1 when package not in lock file', async () => {
+    mockGetLockEntry.mockResolvedValue(null);
+
+    const {runUninstall} = await import('./uninstall.js');
+    const result = await runUninstall({type: 'connection', name: 'unknown'});
+    expect(result).toBe(1);
+    expect(stderrOutput).toContain('not installed');
+    expect(mockNpmUninstall).not.toHaveBeenCalled();
+  });
+
+  it('should handle symlink already gone (ENOENT)', async () => {
+    mockUnlink.mockRejectedValue(Object.assign(new Error('ENOENT'), {code: 'ENOENT'}));
+
+    const {runUninstall} = await import('./uninstall.js');
+    const result = await runUninstall({type: 'connection', name: 'stripe'});
+    expect(result).toBe(0);
+    expect(stderrOutput).toContain('Removed connection/stripe');
+  });
+
+  it('should return 1 when npm uninstall fails', async () => {
+    mockNpmUninstall.mockRejectedValue(new Error('npm error'));
+
+    const {runUninstall} = await import('./uninstall.js');
+    const result = await runUninstall({type: 'skill', name: 'triage'});
+    expect(result).toBe(1);
+    expect(stderrOutput).toContain('npm uninstall failed');
+  });
+
+  it('should return 1 when repo not found', async () => {
+    mockFindRepoRoot.mockImplementation(() => {
+      throw new Error('Not found');
+    });
+
+    const {runUninstall} = await import('./uninstall.js');
+    const result = await runUninstall({type: 'connection', name: 'stripe'});
+    expect(result).toBe(1);
+    expect(stderrOutput).toContain('Not found');
+  });
+
+  it('should print note when override directory exists', async () => {
+    mockStat.mockResolvedValue({isDirectory: () => true});
+
+    const {runUninstall} = await import('./uninstall.js');
+    const result = await runUninstall({type: 'connection', name: 'stripe'});
+    expect(result).toBe(0);
+    expect(stderrOutput).toContain('local override directory still exists');
+  });
+
+  it('should pass cwd to findRepoRoot', async () => {
+    const {runUninstall} = await import('./uninstall.js');
+    await runUninstall({cwd: '/custom/dir', type: 'connection', name: 'test'});
+    expect(mockFindRepoRoot).toHaveBeenCalledWith('/custom/dir');
+  });
+
+  it('should warn but succeed when symlink removal fails with non-ENOENT error', async () => {
+    mockUnlink.mockRejectedValue(Object.assign(new Error('EPERM'), {code: 'EPERM'}));
+
+    const {runUninstall} = await import('./uninstall.js');
+    const result = await runUninstall({type: 'connection', name: 'stripe'});
+    expect(result).toBe(0);
+    expect(stderrOutput).toContain('could not remove symlink');
+  });
+
+  it('should use correct override dir path with plural type', async () => {
+    mockStat.mockResolvedValue({isDirectory: () => true});
+
+    const {runUninstall} = await import('./uninstall.js');
+    await runUninstall({type: 'skill', name: 'triage'});
+    // Override dir: skills/triage
+    expect(mockStat).toHaveBeenCalledWith(
+      expect.stringContaining('skills/triage'),
+    );
+  });
+
+  it('should handle no override dir without error', async () => {
+    mockStat.mockRejectedValue(Object.assign(new Error('ENOENT'), {code: 'ENOENT'}));
+
+    const {runUninstall} = await import('./uninstall.js');
+    const result = await runUninstall({type: 'connection', name: 'stripe'});
+    expect(result).toBe(0);
+    expect(stderrOutput).not.toContain('override');
+  });
+});