@amodalai/amodal 0.1.2

package/src/commands/search.ts

@@ -0,0 +1,154 @@
+/**
+ * @license
+ * Copyright 2025 Amodal Labs, Inc.
+ * SPDX-License-Identifier: MIT
+ */
+
+import type {CommandModule} from 'yargs';
+import {
+  ensureNpmContext,
+  fromNpmName,
+  npmSearch,
+} from '@amodalai/core';
+import type {PackageType} from '@amodalai/core';
+import {findRepoRoot} from '../shared/repo-discovery.js';
+
+export interface SearchOptions {
+  cwd?: string;
+  query?: string;
+  type?: PackageType;
+  json?: boolean;
+}
+
+/**
+ * Search the registry for packages.
+ * Returns 0 on success, 1 on error.
+ */
+export async function runSearch(options: SearchOptions = {}): Promise<number> {
+  let repoPath: string | undefined;
+  try {
+    repoPath = findRepoRoot(options.cwd);
+  } catch {
+    // Not in a repo — use temp context
+  }
+
+  let paths;
+  try {
+    paths = await ensureNpmContext(repoPath ?? process.cwd());
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    process.stderr.write(`[search] Failed to set up npm context: ${msg}\n`);
+    return 1;
+  }
+
+  // Build query
+  let query = options.type ? `@amodalai/${options.type}-` : '@amodalai/';
+  if (options.query) {
+    query += options.query;
+  }
+
+  process.stderr.write(`[search] Searching for "${query}"...\n`);
+
+  let results;
+  try {
+    results = await npmSearch(paths, query);
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    process.stderr.write(`[search] Search failed: ${msg}\n`);
+    return 1;
+  }
+
+  // Filter to @amodalai/ packages only
+  results = results.filter((r) => r.name.startsWith('@amodalai/'));
+
+  // Further filter by type if specified
+  if (options.type) {
+    results = results.filter((r) => {
+      try {
+        const parsed = fromNpmName(r.name);
+        return parsed.type === options.type;
+      } catch {
+        return false;
+      }
+    });
+  }
+
+  if (results.length === 0) {
+    process.stderr.write('[search] No packages found.\n');
+    return 0;
+  }
+
+  if (options.json) {
+    const output = results.map((r) => {
+      let type: string | undefined;
+      let name: string | undefined;
+      try {
+        const parsed = fromNpmName(r.name);
+        type = parsed.type;
+        name = parsed.name;
+      } catch {
+        // Not a parseable amodal name
+      }
+      return {
+        npm: r.name,
+        version: r.version,
+        description: r.description,
+        type,
+        name,
+      };
+    });
+    process.stdout.write(JSON.stringify(output, null, 2) + '\n');
+    return 0;
+  }
+
+  // Categorize results
+  const grouped = new Map<string, Array<{name: string; version: string; description: string; npm: string}>>();
+  for (const r of results) {
+    let category = 'other';
+    let pkgName = r.name;
+    try {
+      const parsed = fromNpmName(r.name);
+      category = parsed.type;
+      pkgName = parsed.name;
+    } catch {
+      // Not parseable
+    }
+    if (!grouped.has(category)) {
+      grouped.set(category, []);
+    }
+    grouped.get(category)!.push({name: pkgName, version: r.version, description: r.description, npm: r.name});
+  }
+
+  for (const [category, items] of grouped) {
+    process.stdout.write(`\n  ${category.toUpperCase()}\n`);
+    const nameWidth = Math.max(4, ...items.map((i) => i.name.length));
+    const versionWidth = Math.max(7, ...items.map((i) => i.version.length));
+    for (const item of items) {
+      process.stdout.write(`    ${item.name.padEnd(nameWidth)}   ${item.version.padEnd(versionWidth)}   ${item.description}\n`);
+    }
+  }
+
+  process.stderr.write(`\n[search] ${results.length} package${results.length === 1 ? '' : 's'} found.\n`);
+  return 0;
+}
+
+export const searchCommand: CommandModule = {
+  command: 'search [query]',
+  describe: 'Search the registry for packages',
+  builder: (yargs) =>
+    yargs
+      .positional('query', {type: 'string', describe: 'Search query'})
+      .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) => {
+    const code = await runSearch({
+      // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion
+      query: argv['query'] as string | undefined,
+      // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion
+      type: argv['type'] as PackageType | undefined,
+      // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion
+      json: argv['json'] as boolean,
+    });
+    process.exit(code);
+  },
+};

package/src/commands/secrets.test.ts

@@ -0,0 +1,168 @@
+/**
+ * @license
+ * Copyright 2025 Amodal Labs, Inc.
+ * SPDX-License-Identifier: MIT
+ */
+
+import {describe, it, expect, vi, beforeEach, afterEach} from 'vitest';
+
+describe('runSecrets', () => {
+  let stderrOutput: string;
+  let stdoutOutput: string;
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  let fetchSpy: any;
+  const originalEnv = process.env;
+
+  beforeEach(() => {
+    vi.clearAllMocks();
+    process.env = {
+      ...originalEnv,
+      PLATFORM_API_URL: 'https://api.example.com',
+      PLATFORM_API_KEY: 'test-key',
+    };
+    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;
+    });
+    fetchSpy = vi.spyOn(globalThis, 'fetch');
+  });
+
+  afterEach(() => {
+    process.env = originalEnv;
+    fetchSpy.mockRestore();
+  });
+
+  it('should set a secret', async () => {
+    fetchSpy.mockResolvedValue(new Response('{}', {status: 200}));
+
+    const {runSecrets} = await import('./secrets.js');
+    const result = await runSecrets({subcommand: 'set', key: 'DB_URL', value: 'postgres://...'});
+    expect(result).toBe(0);
+    expect(stderrOutput).toContain('set successfully');
+  });
+
+  it('should return 1 when key missing for set', async () => {
+    const {runSecrets} = await import('./secrets.js');
+    const result = await runSecrets({subcommand: 'set'});
+    expect(result).toBe(1);
+    expect(stderrOutput).toContain('Missing key');
+  });
+
+  it('should return 1 when value missing for set', async () => {
+    const {runSecrets} = await import('./secrets.js');
+    const result = await runSecrets({subcommand: 'set', key: 'DB_URL'});
+    expect(result).toBe(1);
+    expect(stderrOutput).toContain('Missing value');
+  });
+
+  it('should list secrets', async () => {
+    fetchSpy.mockResolvedValue(new Response(JSON.stringify([
+      {key: 'DB_URL'},
+      {key: 'API_KEY'},
+    ]), {status: 200}));
+
+    const {runSecrets} = await import('./secrets.js');
+    const result = await runSecrets({subcommand: 'list'});
+    expect(result).toBe(0);
+    expect(stdoutOutput).toContain('DB_URL');
+    expect(stdoutOutput).toContain('API_KEY');
+  });
+
+  it('should list secrets as JSON', async () => {
+    fetchSpy.mockResolvedValue(new Response(JSON.stringify([{key: 'DB_URL'}]), {status: 200}));
+
+    const {runSecrets} = await import('./secrets.js');
+    const result = await runSecrets({subcommand: 'list', json: true});
+    expect(result).toBe(0);
+    const parsed = JSON.parse(stdoutOutput);
+    expect(parsed).toHaveLength(1);
+  });
+
+  it('should handle empty secrets list', async () => {
+    fetchSpy.mockResolvedValue(new Response('[]', {status: 200}));
+
+    const {runSecrets} = await import('./secrets.js');
+    const result = await runSecrets({subcommand: 'list'});
+    expect(result).toBe(0);
+    expect(stderrOutput).toContain('No secrets configured');
+  });
+
+  it('should delete a secret', async () => {
+    fetchSpy.mockResolvedValue(new Response('{}', {status: 200}));
+
+    const {runSecrets} = await import('./secrets.js');
+    const result = await runSecrets({subcommand: 'delete', key: 'DB_URL'});
+    expect(result).toBe(0);
+    expect(stderrOutput).toContain('deleted');
+  });
+
+  it('should return 1 when key missing for delete', async () => {
+    const {runSecrets} = await import('./secrets.js');
+    const result = await runSecrets({subcommand: 'delete'});
+    expect(result).toBe(1);
+    expect(stderrOutput).toContain('Missing key');
+  });
+
+  it('should return 1 when platform not configured', async () => {
+    delete process.env['PLATFORM_API_URL'];
+    delete process.env['PLATFORM_API_KEY'];
+
+    const {runSecrets} = await import('./secrets.js');
+    const result = await runSecrets({subcommand: 'list'});
+    expect(result).toBe(1);
+  });
+
+  it('should handle auth failure', async () => {
+    fetchSpy.mockResolvedValue(new Response('Unauthorized', {status: 401}));
+
+    const {runSecrets} = await import('./secrets.js');
+    const result = await runSecrets({subcommand: 'list'});
+    expect(result).toBe(1);
+    expect(stderrOutput).toContain('401');
+  });
+
+  it('should handle network error', async () => {
+    fetchSpy.mockRejectedValue(new Error('ECONNREFUSED'));
+
+    const {runSecrets} = await import('./secrets.js');
+    const result = await runSecrets({subcommand: 'set', key: 'K', value: 'V'});
+    expect(result).toBe(1);
+    expect(stderrOutput).toContain('ECONNREFUSED');
+  });
+
+  it('should handle set server error', async () => {
+    fetchSpy.mockResolvedValue(new Response('Internal Error', {status: 500}));
+
+    const {runSecrets} = await import('./secrets.js');
+    const result = await runSecrets({subcommand: 'set', key: 'K', value: 'V'});
+    expect(result).toBe(1);
+    expect(stderrOutput).toContain('500');
+  });
+
+  it('should show count for listed secrets', async () => {
+    fetchSpy.mockResolvedValue(new Response(JSON.stringify([
+      {key: 'A'},
+      {key: 'B'},
+      {key: 'C'},
+    ]), {status: 200}));
+
+    const {runSecrets} = await import('./secrets.js');
+    await runSecrets({subcommand: 'list'});
+    expect(stderrOutput).toContain('3 secrets');
+  });
+
+  it('should use singular for single secret', async () => {
+    fetchSpy.mockResolvedValue(new Response(JSON.stringify([{key: 'ONLY'}]), {status: 200}));
+
+    const {runSecrets} = await import('./secrets.js');
+    await runSecrets({subcommand: 'list'});
+    expect(stderrOutput).toContain('1 secret configured');
+    expect(stderrOutput).not.toContain('1 secrets');
+  });
+});

package/src/commands/secrets.ts

@@ -0,0 +1,163 @@
+/**
+ * @license
+ * Copyright 2025 Amodal Labs, Inc.
+ * SPDX-License-Identifier: MIT
+ */
+
+import type {CommandModule} from 'yargs';
+import {resolvePlatformConfig} from '../shared/platform-client.js';
+
+export interface SecretsOptions {
+  cwd?: string;
+  subcommand: 'set' | 'list' | 'delete';
+  key?: string;
+  value?: string;
+  json?: boolean;
+}
+
+/**
+ * Manage platform secrets.
+ * Returns 0 on success, 1 on error.
+ */
+export async function runSecrets(options: SecretsOptions): Promise<number> {
+  let config: {url: string; apiKey: string};
+  try {
+    config = await resolvePlatformConfig();
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    process.stderr.write(`[secrets] ${msg}\n`);
+    return 1;
+  }
+
+  const headers: Record<string, string> = {
+    'Authorization': `Bearer ${config.apiKey}`,
+    'Content-Type': 'application/json',
+  };
+
+  switch (options.subcommand) {
+    case 'set': {
+      if (!options.key) {
+        process.stderr.write('[secrets] Missing key. Usage: amodal secrets set <key> <value>\n');
+        return 1;
+      }
+      if (options.value === undefined) {
+        process.stderr.write('[secrets] Missing value. Usage: amodal secrets set <key> <value>\n');
+        return 1;
+      }
+
+      try {
+        const response = await fetch(`${config.url}/api/secrets`, {
+          method: 'PUT',
+          headers,
+          body: JSON.stringify({key: options.key, value: options.value}),
+        });
+
+        if (!response.ok) {
+          process.stderr.write(`[secrets] Failed to set secret: ${response.status} ${response.statusText}\n`);
+          return 1;
+        }
+
+        process.stderr.write(`[secrets] Secret "${options.key}" set successfully.\n`);
+        return 0;
+      } catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        process.stderr.write(`[secrets] Failed to set secret: ${msg}\n`);
+        return 1;
+      }
+    }
+
+    case 'list': {
+      try {
+        const response = await fetch(`${config.url}/api/secrets`, {
+          method: 'GET',
+          headers,
+        });
+
+        if (!response.ok) {
+          process.stderr.write(`[secrets] Failed to list secrets: ${response.status} ${response.statusText}\n`);
+          return 1;
+        }
+
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion
+        const secrets = (await response.json()) as Array<{key: string}>;
+
+        if (secrets.length === 0) {
+          process.stderr.write('[secrets] No secrets configured.\n');
+          return 0;
+        }
+
+        if (options.json) {
+          process.stdout.write(JSON.stringify(secrets, null, 2) + '\n');
+          return 0;
+        }
+
+        process.stdout.write('KEY\n');
+        for (const secret of secrets) {
+          process.stdout.write(`${secret.key}\n`);
+        }
+
+        process.stderr.write(`[secrets] ${secrets.length} secret${secrets.length === 1 ? '' : 's'} configured.\n`);
+        return 0;
+      } catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        process.stderr.write(`[secrets] Failed to list secrets: ${msg}\n`);
+        return 1;
+      }
+    }
+
+    case 'delete': {
+      if (!options.key) {
+        process.stderr.write('[secrets] Missing key. Usage: amodal secrets delete <key>\n');
+        return 1;
+      }
+
+      try {
+        const response = await fetch(`${config.url}/api/secrets/${encodeURIComponent(options.key)}`, {
+          method: 'DELETE',
+          headers,
+        });
+
+        if (!response.ok) {
+          process.stderr.write(`[secrets] Failed to delete secret: ${response.status} ${response.statusText}\n`);
+          return 1;
+        }
+
+        process.stderr.write(`[secrets] Secret "${options.key}" deleted.\n`);
+        return 0;
+      } catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        process.stderr.write(`[secrets] Failed to delete secret: ${msg}\n`);
+        return 1;
+      }
+    }
+
+    default:
+      break;
+  }
+
+  return 1;
+}
+
+export const secretsCommand: CommandModule = {
+  command: 'secrets <subcommand> [key] [value]',
+  describe: 'Manage platform secrets',
+  builder: (yargs) =>
+    yargs
+      .positional('subcommand', {type: 'string', demandOption: true, choices: ['set', 'list', 'delete'] as const, describe: 'Action'})
+      .positional('key', {type: 'string', describe: 'Secret key'})
+      .positional('value', {type: 'string', describe: 'Secret value (for set)'})
+      .option('json', {type: 'boolean', default: false, describe: 'Output as JSON'}),
+  handler: async (argv) => {
+    const code = await runSecrets({
+      // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion
+      subcommand: argv['subcommand'] as 'set' | 'list' | 'delete',
+      // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion
+      key: argv['key'] as string | undefined,
+      // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion
+      value: argv['value'] as string | undefined,
+      // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion
+      json: argv['json'] as boolean,
+    });
+    process.exit(code);
+  },
+};

package/src/commands/serve.ts

@@ -0,0 +1,166 @@
+/**
+ * @license
+ * Copyright 2025 Amodal Labs, Inc.
+ * SPDX-License-Identifier: MIT
+ */
+
+import type {CommandModule} from 'yargs';
+import {loadSnapshotFromFile, snapshotToRepo} from '@amodalai/core';
+import type {AmodalRepo} from '@amodalai/core';
+import {createLocalServer} from '@amodalai/runtime';
+import {PlatformClient} from '../shared/platform-client.js';
+
+export interface ServeOptions {
+  config?: string;
+  platform?: boolean;
+  project?: string;
+  env?: string;
+  port?: number;
+  host?: string;
+}
+
+const DEFAULT_PORT = 3847;
+
+/**
+ * Load a repo from a snapshot file or from the platform.
+ */
+async function loadFromSource(options: ServeOptions): Promise<AmodalRepo | null> {
+  if (options.config) {
+    process.stderr.write(`[serve] Loading snapshot from ${options.config}...\n`);
+    try {
+      const snapshot = await loadSnapshotFromFile(options.config);
+      const repo = snapshotToRepo(snapshot, options.config);
+      process.stderr.write(`[serve] Loaded ${snapshot.deployId} (${snapshot.skills.length} skills, ${Object.keys(snapshot.connections).length} connections)\n`);
+      return repo;
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      process.stderr.write(`[serve] Failed to load snapshot: ${msg}\n`);
+      return null;
+    }
+  }
+
+  if (options.platform) {
+    process.stderr.write('[serve] Fetching active snapshot from platform...\n');
+    let client: PlatformClient;
+    try {
+      client = await PlatformClient.create();
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      process.stderr.write(`[serve] ${msg}\n`);
+      return null;
+    }
+
+    const environment = options.env ?? 'production';
+    try {
+      const snapshot = await client.getActiveSnapshot(environment);
+      const repo = snapshotToRepo(snapshot, `platform:${environment}`);
+      process.stderr.write(`[serve] Loaded ${snapshot.deployId} from ${environment}\n`);
+      return repo;
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      process.stderr.write(`[serve] Failed to fetch snapshot: ${msg}\n`);
+      return null;
+    }
+  }
+
+  process.stderr.write('[serve] Specify --config <file> or --platform to load a snapshot.\n');
+  return null;
+}
+
+/**
+ * Load an agent runtime from a snapshot (file or platform) and start the server.
+ *
+ * Returns the loaded repo, or exits with error.
+ */
+export async function runServe(options: ServeOptions): Promise<AmodalRepo | null> {
+  const repo = await loadFromSource(options);
+  if (!repo) return null;
+
+  // Start the runtime server
+  const port = options.port ?? DEFAULT_PORT;
+  const host = options.host ?? '0.0.0.0';
+
+  process.stderr.write(`[serve] Starting server on ${host}:${port}...\n`);
+
+  try {
+    const server = await createLocalServer({
+      repoPath: repo.origin,
+      port,
+      host,
+      hotReload: false,
+      corsOrigin: '*',
+    });
+
+    await server.start();
+
+    process.stderr.write(`[serve] Agent "${repo.config.name}" serving at http://${host}:${port}\n`);
+
+    // Graceful shutdown
+    const shutdown = async (signal: string): Promise<void> => {
+      process.stderr.write(`\n[serve] 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(`[serve] Failed to start server: ${msg}\n`);
+    return null;
+  }
+
+  return repo;
+}
+
+export const serveCommand: CommandModule = {
+  command: 'serve',
+  describe: 'Load and serve an agent from a snapshot',
+  builder: (yargs) =>
+    yargs
+      .option('config', {
+        type: 'string',
+        describe: 'Path to resolved-config.json snapshot file',
+      })
+      .option('platform', {
+        type: 'boolean',
+        describe: 'Fetch active snapshot from platform',
+        default: false,
+      })
+      .option('project', {
+        type: 'string',
+        describe: 'Platform project name',
+      })
+      .option('env', {
+        type: 'string',
+        describe: 'Platform environment (default: production)',
+      })
+      .option('port', {
+        type: 'number',
+        describe: `Port to listen on (default: ${DEFAULT_PORT})`,
+      })
+      .option('host', {
+        type: 'string',
+        describe: 'Host to bind to (default: 0.0.0.0)',
+      }),
+  handler: async (argv) => {
+    const repo = await runServe({
+      // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion
+      config: argv['config'] as string | undefined,
+      // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion
+      platform: argv['platform'] as boolean | undefined,
+      // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion
+      project: argv['project'] 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
+      port: argv['port'] as number | undefined,
+      // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion
+      host: argv['host'] as string | undefined,
+    });
+    if (!repo) {
+      process.exit(1);
+    }
+    // Server is running — process stays alive until SIGTERM/SIGINT
+  },
+};