@amodalai/amodal 0.1.2

package/src/commands/automations.ts

@@ -0,0 +1,205 @@
+/**
+ * @license
+ * Copyright 2025 Amodal Labs, Inc.
+ * SPDX-License-Identifier: MIT
+ */
+
+import type {CommandModule} from 'yargs';
+
+const DEFAULT_URL = 'http://localhost:3847';
+
+interface AutomationEntry {
+  name: string;
+  title: string;
+  schedule?: string;
+  webhookTriggered: boolean;
+  running: boolean;
+}
+
+async function fetchJson(url: string, method: 'GET' | 'POST' = 'GET'): Promise<unknown> {
+  const res = await fetch(url, {method});
+  const body = await res.json();
+  if (!res.ok) {
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion -- JSON response
+    const err = (body as Record<string, unknown>)['error'] ?? res.statusText;
+    throw new Error(String(err));
+  }
+  return body;
+}
+
+export interface AutomationsOptions {
+  url?: string;
+  json?: boolean;
+}
+
+/**
+ * List automations from a running server.
+ */
+export async function runAutomationsList(options: AutomationsOptions = {}): Promise<number> {
+  const base = options.url ?? DEFAULT_URL;
+  try {
+    const data = await fetchJson(`${base}/automations`);
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion -- JSON response
+    const automations = (data as {automations: AutomationEntry[]}).automations;
+
+    if (automations.length === 0) {
+      process.stderr.write('[automations] No automations defined.\n');
+      return 0;
+    }
+
+    if (options.json) {
+      process.stdout.write(JSON.stringify(automations, null, 2) + '\n');
+      return 0;
+    }
+
+    const nameW = Math.max(4, ...automations.map((a) => a.name.length));
+    const titleW = Math.max(5, ...automations.map((a) => a.title.length));
+    const typeW = 8;
+    const statusW = 7;
+
+    const header = [
+      'NAME'.padEnd(nameW),
+      'TITLE'.padEnd(titleW),
+      'TYPE'.padEnd(typeW),
+      'STATUS'.padEnd(statusW),
+      'SCHEDULE',
+    ].join('   ');
+
+    process.stdout.write(header + '\n');
+
+    for (const a of automations) {
+      const type = a.webhookTriggered ? 'webhook' : 'cron';
+      const status = a.running ? 'running' : 'stopped';
+      const row = [
+        a.name.padEnd(nameW),
+        a.title.padEnd(titleW),
+        type.padEnd(typeW),
+        status.padEnd(statusW),
+        a.schedule ?? '-',
+      ].join('   ');
+      process.stdout.write(row + '\n');
+    }
+
+    return 0;
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    process.stderr.write(`[automations] ${msg}\n`);
+    return 1;
+  }
+}
+
+/**
+ * Start a cron automation on a running server.
+ */
+export async function runAutomationsStart(name: string, options: AutomationsOptions = {}): Promise<number> {
+  const base = options.url ?? DEFAULT_URL;
+  try {
+    await fetchJson(`${base}/automations/${encodeURIComponent(name)}/start`, 'POST');
+    process.stderr.write(`[automations] Started "${name}"\n`);
+    return 0;
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    process.stderr.write(`[automations] ${msg}\n`);
+    return 1;
+  }
+}
+
+/**
+ * Stop a running cron automation on a running server.
+ */
+export async function runAutomationsStop(name: string, options: AutomationsOptions = {}): Promise<number> {
+  const base = options.url ?? DEFAULT_URL;
+  try {
+    await fetchJson(`${base}/automations/${encodeURIComponent(name)}/stop`, 'POST');
+    process.stderr.write(`[automations] Stopped "${name}"\n`);
+    return 0;
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    process.stderr.write(`[automations] ${msg}\n`);
+    return 1;
+  }
+}
+
+/**
+ * Manually trigger an automation on a running server.
+ */
+export async function runAutomationsRun(name: string, options: AutomationsOptions = {}): Promise<number> {
+  const base = options.url ?? DEFAULT_URL;
+  try {
+    await fetchJson(`${base}/automations/${encodeURIComponent(name)}/run`, 'POST');
+    process.stderr.write(`[automations] Triggered "${name}"\n`);
+    return 0;
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    process.stderr.write(`[automations] ${msg}\n`);
+    return 1;
+  }
+}
+
+export const automationsCommand: CommandModule = {
+  command: 'automations <action> [name]',
+  describe: 'Manage automations on a running server',
+  builder: (yargs) =>
+    yargs
+      .positional('action', {
+        type: 'string',
+        choices: ['list', 'start', 'stop', 'run'] as const,
+        describe: 'Action to perform',
+      })
+      .positional('name', {
+        type: 'string',
+        describe: 'Automation name (required for start/stop/run)',
+      })
+      .option('url', {
+        type: 'string',
+        describe: `Server URL (default: ${DEFAULT_URL})`,
+      })
+      .option('json', {
+        type: 'boolean',
+        default: false,
+        describe: 'Output as JSON (list only)',
+      }),
+  handler: async (argv) => {
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion
+    const action = argv['action'] as string;
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion
+    const name = argv['name'] as string | undefined;
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion
+    const url = argv['url'] as string | undefined;
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion
+    const json = argv['json'] as boolean;
+
+    let code: number;
+    switch (action) {
+      case 'list':
+        code = await runAutomationsList({url, json});
+        break;
+      case 'start':
+        if (!name) {
+          process.stderr.write('[automations] Name required for start\n');
+          process.exit(1);
+        }
+        code = await runAutomationsStart(name, {url});
+        break;
+      case 'stop':
+        if (!name) {
+          process.stderr.write('[automations] Name required for stop\n');
+          process.exit(1);
+        }
+        code = await runAutomationsStop(name, {url});
+        break;
+      case 'run':
+        if (!name) {
+          process.stderr.write('[automations] Name required for run\n');
+          process.exit(1);
+        }
+        code = await runAutomationsRun(name, {url});
+        break;
+      default:
+        process.stderr.write(`[automations] Unknown action: ${action}\n`);
+        code = 1;
+        break;
+    }
+    process.exit(code);
+  },
+};

package/src/commands/build-manifest-types.ts

@@ -0,0 +1,35 @@
+/**
+ * @license
+ * Copyright 2025 Amodal Labs, Inc.
+ * SPDX-License-Identifier: MIT
+ */
+
+import {z} from 'zod';
+
+/**
+ * Schema for a single tool entry in the build manifest.
+ */
+export const BuildManifestToolSchema = z.object({
+  /** Daytona snapshot ID for fast workspace creation */
+  snapshotId: z.string().min(1),
+  /** Content hash of the tool's source files */
+  imageHash: z.string().min(1),
+  /** Sandbox language runtime */
+  sandboxLanguage: z.string().default('typescript'),
+  /** Whether the tool was built from a Dockerfile */
+  hasDockerfile: z.boolean().default(false),
+  /** Whether the tool has a setup.sh script */
+  hasSetupScript: z.boolean().default(false),
+});
+
+/**
+ * Schema for .amodal/build-manifest.json.
+ */
+export const BuildManifestSchema = z.object({
+  version: z.literal(1),
+  builtAt: z.string().datetime(),
+  tools: z.record(z.string(), BuildManifestToolSchema),
+});
+
+export type BuildManifest = z.infer<typeof BuildManifestSchema>;
+export type BuildManifestTool = z.infer<typeof BuildManifestToolSchema>;

package/src/commands/build-tools.ts

@@ -0,0 +1,281 @@
+/**
+ * @license
+ * Copyright 2025 Amodal Labs, Inc.
+ * SPDX-License-Identifier: MIT
+ */
+
+import {createHash} from 'node:crypto';
+import {readFileSync, writeFileSync, mkdirSync, existsSync, readdirSync} from 'node:fs';
+import {join, relative} from 'node:path';
+import {execSync} from 'node:child_process';
+import type {LoadedTool} from '@amodalai/core';
+import type {BuildManifest} from './build-manifest-types.js';
+
+/**
+ * Recursively list all files in a directory, returning paths relative to root.
+ * Skips node_modules, .git, __pycache__.
+ */
+export function listFilesRecursive(dir: string, root?: string): string[] {
+  const base = root ?? dir;
+  const results: string[] = [];
+  try {
+    const entries = readdirSync(dir, {withFileTypes: true});
+    for (const entry of entries.sort((a, b) => a.name.localeCompare(b.name))) {
+      const fullPath = join(dir, entry.name);
+      if (entry.isDirectory()) {
+        if (['node_modules', '.git', '__pycache__', '.venv', 'dist'].includes(entry.name)) {
+          continue;
+        }
+        results.push(...listFilesRecursive(fullPath, base));
+      } else if (entry.isFile()) {
+        results.push(relative(base, fullPath));
+      }
+    }
+  } catch {
+    // Directory unreadable
+  }
+  return results;
+}
+
+/**
+ * Compute a content hash for all files in the tool directory (recursive).
+ */
+function computeToolHash(tool: LoadedTool): string {
+  const hash = createHash('sha256');
+  const files = listFilesRecursive(tool.location);
+
+  for (const relPath of files) {
+    hash.update(`file:${relPath}:`);
+    try {
+      hash.update(readFileSync(join(tool.location, relPath)));
+    } catch {
+      hash.update('unreadable');
+    }
+  }
+
+  hash.update(`sandbox-language:${tool.sandboxLanguage}`);
+
+  return hash.digest('hex');
+}
+
+/**
+ * Load the existing build manifest if it exists.
+ */
+function loadExistingManifest(repoPath: string): BuildManifest | null {
+  const manifestPath = join(repoPath, '.amodal', 'build-manifest.json');
+  if (!existsSync(manifestPath)) {
+    return null;
+  }
+  try {
+    const content = readFileSync(manifestPath, 'utf-8');
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion
+    return JSON.parse(content) as BuildManifest;
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Read the platform config from amodal.json.
+ */
+function getPlatformConfig(repoPath: string): {apiUrl: string; apiKey: string} | null {
+  try {
+    const configPath = join(repoPath, 'amodal.json');
+    const raw = JSON.parse(readFileSync(configPath, 'utf-8'));
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion
+    const config = raw as Record<string, unknown>;
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion
+    const platform = config['platform'] as {projectId?: string; apiKey?: string} | undefined;
+    if (!platform?.apiKey) return null;
+
+    const apiUrl = (process.env['PLATFORM_API_URL'] ?? 'https://api.amodal.dev').replace(/\/$/, '');
+    return {apiUrl, apiKey: platform.apiKey};
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Create a tar.gz archive of the tool directory.
+ * Excludes node_modules, .git, __pycache__, etc.
+ */
+export function createToolArchive(tool: LoadedTool): Buffer {
+  // Use system tar — available on macOS and Linux
+  const tarOutput = execSync(
+    'tar -czf - ' +
+    '--exclude=node_modules --exclude=.git --exclude=__pycache__ ' +
+    '--exclude=.venv --exclude=dist ' +
+    '-C ' + JSON.stringify(tool.location) + ' .',
+    {maxBuffer: 50 * 1024 * 1024}, // 50MB max
+  );
+  return Buffer.from(tarOutput);
+}
+
+const POLL_INTERVAL_MS = 3000;
+const POLL_TIMEOUT_MS = 5 * 60 * 1000; // 5 minutes max
+
+/**
+ * Upload a tool bundle to the platform API and wait for the build to complete.
+ *
+ * 1. POST /api/tools/build — starts the build (Vercel creates a Daytona
+ *    sandbox, uploads files, kicks off setup commands asynchronously)
+ * 2. Poll GET /api/tools/build/:id — waits for setup to finish, then
+ *    the platform snapshots the sandbox and returns the snapshotId
+ *
+ * The ISV never needs Daytona credentials. The platform owns the infra.
+ */
+async function buildToolOnPlatform(
+  platformUrl: string,
+  apiKey: string,
+  tool: LoadedTool,
+  imageHash: string,
+): Promise<string> {
+  const archive = createToolArchive(tool);
+  const fileCount = listFilesRecursive(tool.location).length;
+
+  process.stderr.write(`[build-tools] ${tool.name}: uploading ${fileCount} files (${(archive.length / 1024).toFixed(1)} KB)\n`);
+
+  // 1. Start the build
+  const startResponse = await fetch(`${platformUrl}/api/tools/build`, {
+    method: 'POST',
+    headers: {
+      'Authorization': `Bearer ${apiKey}`,
+      'Content-Type': 'application/gzip',
+      'X-Tool-Name': tool.name,
+      'X-Tool-Hash': imageHash,
+      'X-Sandbox-Language': tool.sandboxLanguage,
+      'X-Has-Setup-Script': String(tool.hasSetupScript),
+      'X-Has-Requirements-Txt': String(tool.hasRequirementsTxt),
+      'X-Has-Dockerfile': String(tool.hasDockerfile),
+      'X-Has-Package-Json': String(tool.hasPackageJson),
+    },
+    body: archive,
+  });
+
+  if (!startResponse.ok) {
+    const text = await startResponse.text().catch(() => '');
+    throw new Error(`Platform tool build failed to start (${startResponse.status}): ${text}`);
+  }
+
+  // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion
+  const buildResult = await startResponse.json() as {id: string; status: string; snapshotId?: string; error?: string};
+
+  // If already complete (no setup needed), return immediately
+  if (buildResult.status === 'complete' && buildResult.snapshotId) {
+    return buildResult.snapshotId;
+  }
+  if (buildResult.status === 'failed') {
+    throw new Error(`Tool build failed: ${buildResult.error ?? 'unknown error'}`);
+  }
+
+  // 2. Poll until complete
+  const buildId = buildResult.id;
+  const startTime = Date.now();
+
+  while (Date.now() - startTime < POLL_TIMEOUT_MS) {
+    await new Promise((r) => setTimeout(r, POLL_INTERVAL_MS));
+
+    const pollResponse = await fetch(`${platformUrl}/api/tools/build/${buildId}`, {
+      headers: {'Authorization': `Bearer ${apiKey}`},
+    });
+
+    if (!pollResponse.ok) {
+      throw new Error(`Failed to poll build status (${pollResponse.status})`);
+    }
+
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion
+    const poll = await pollResponse.json() as {status: string; snapshotId?: string; error?: string};
+
+    if (poll.status === 'complete' && poll.snapshotId) {
+      return poll.snapshotId;
+    }
+    if (poll.status === 'failed') {
+      throw new Error(`Tool build failed: ${poll.error ?? 'unknown error'}`);
+    }
+
+    process.stderr.write(`[build-tools] ${tool.name}: ${poll.status}...\n`);
+  }
+
+  throw new Error(`Tool build timed out after ${POLL_TIMEOUT_MS / 1000}s`);
+}
+
+/**
+ * Build Daytona sandbox snapshots for custom tools.
+ *
+ * For each tool:
+ * 1. Compute a content hash of all files in the tool directory
+ * 2. If hash matches existing manifest entry, skip (cached)
+ * 3. Otherwise, upload to the platform API which builds the image
+ *    and creates the Daytona snapshot using the platform's Daytona key
+ *
+ * The ISV never touches Daytona directly. The platform owns the infra.
+ *
+ * Writes .amodal/build-manifest.json locally for caching.
+ * The manifest is also included in the deploy snapshot.
+ */
+export async function buildToolTemplates(
+  repoPath: string,
+  tools: LoadedTool[],
+): Promise<BuildManifest> {
+  const existing = loadExistingManifest(repoPath);
+  const existingTools = existing?.tools ?? {};
+
+  const platform = getPlatformConfig(repoPath);
+
+  const builtTools: Record<string, {snapshotId: string; imageHash: string; sandboxLanguage: string; hasDockerfile: boolean; hasSetupScript: boolean}> = {};
+  let skipped = 0;
+  let built = 0;
+
+  for (const tool of tools) {
+    const imageHash = computeToolHash(tool);
+    const existingEntry = existingTools[tool.name];
+
+    if (existingEntry && existingEntry.imageHash === imageHash) {
+      builtTools[tool.name] = existingEntry;
+      skipped++;
+      process.stderr.write(`[build-tools] ${tool.name}: cached (hash match)\n`);
+      continue;
+    }
+
+    if (tool.hasSetupScript) {
+      process.stderr.write(`[build-tools] ${tool.name}: building with setup.sh (${tool.sandboxLanguage})\n`);
+    } else {
+      process.stderr.write(`[build-tools] ${tool.name}: building (${tool.sandboxLanguage})\n`);
+    }
+
+    let snapshotId: string;
+    if (platform) {
+      // Upload to platform API → platform builds on Daytona
+      snapshotId = await buildToolOnPlatform(platform.apiUrl, platform.apiKey, tool, imageHash);
+    } else {
+      // No platform configured — generate a placeholder
+      // (local dev mode — tools run in-process, snapshots not needed)
+      snapshotId = `local-${imageHash.slice(0, 16)}`;
+      process.stderr.write(`[build-tools] ${tool.name}: no platform configured, using local placeholder\n`);
+    }
+
+    builtTools[tool.name] = {snapshotId, imageHash, sandboxLanguage: tool.sandboxLanguage, hasDockerfile: tool.hasDockerfile, hasSetupScript: tool.hasSetupScript};
+    built++;
+    process.stderr.write(`[build-tools] ${tool.name}: snapshot ${snapshotId}\n`);
+  }
+
+  const manifest: BuildManifest = {
+    version: 1,
+    builtAt: new Date().toISOString(),
+    tools: builtTools,
+  };
+
+  // Write manifest locally for caching
+  const amodalDir = join(repoPath, '.amodal');
+  if (!existsSync(amodalDir)) {
+    mkdirSync(amodalDir, {recursive: true});
+  }
+  writeFileSync(
+    join(amodalDir, 'build-manifest.json'),
+    JSON.stringify(manifest, null, 2),
+  );
+
+  process.stderr.write(`[build-tools] Done: ${built} built, ${skipped} cached\n`);
+
+  return manifest;
+}

package/src/commands/build.test.ts

@@ -0,0 +1,63 @@
+/**
+ * @license
+ * Copyright 2025 Amodal Labs, Inc.
+ * SPDX-License-Identifier: MIT
+ */
+
+import {describe, it, expect, vi, beforeEach, afterEach} from 'vitest';
+import {mkdirSync, writeFileSync, rmSync, existsSync, readFileSync} from 'node:fs';
+import {join} from 'node:path';
+import {tmpdir} from 'node:os';
+import {randomBytes} from 'node:crypto';
+
+// Mock process.exit to not actually exit
+const mockExit = vi.spyOn(process, 'exit').mockImplementation(() => undefined as never);
+const stderrWrites: string[] = [];
+vi.spyOn(process.stderr, 'write').mockImplementation((s) => {
+  stderrWrites.push(String(s));
+  return true;
+});
+
+const testDir = join(tmpdir(), `build-test-${randomBytes(4).toString('hex')}`);
+
+beforeEach(() => {
+  stderrWrites.length = 0;
+  mockExit.mockClear();
+});
+
+afterEach(() => {
+  rmSync(testDir, {recursive: true, force: true});
+});
+
+describe('runBuild', () => {
+  it('returns 1 when no amodal.json found', async () => {
+    mkdirSync(testDir, {recursive: true});
+
+    const {runBuild} = await import('./build.js');
+    const code = await runBuild({cwd: testDir});
+    expect(code).toBe(1);
+    expect(stderrWrites.some((s) => s.includes('amodal.json'))).toBe(true);
+  });
+
+  it('builds a snapshot and writes resolved-config.json', async () => {
+    mkdirSync(testDir, {recursive: true});
+    writeFileSync(join(testDir, 'amodal.json'), JSON.stringify({
+      name: 'test-agent',
+      version: '1.0.0',
+      models: {main: {provider: 'anthropic', model: 'claude-sonnet-4-20250514'}},
+    }));
+
+    const {runBuild} = await import('./build.js');
+    const outputPath = join(testDir, 'output.json');
+    const code = await runBuild({cwd: testDir, output: outputPath});
+
+    expect(code).toBe(0);
+    expect(existsSync(outputPath)).toBe(true);
+
+    const snapshot = JSON.parse(readFileSync(outputPath, 'utf-8'));
+    expect(snapshot.deployId).toMatch(/^deploy-[0-9a-f]{7}$/);
+    expect(snapshot.config.name).toBe('test-agent');
+    expect(snapshot.source).toBe('cli');
+    expect(stderrWrites.some((s) => s.includes('Snapshot'))).toBe(true);
+  });
+});