@amodalai/amodal 0.3.89 → 0.3.91

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@amodalai/amodal",
-  "version": "0.3.89",
+  "version": "0.3.91",
   "description": "Amodal CLI",
   "license": "MIT",
   "repository": {
@@ -18,7 +18,6 @@
     "amodal": "dist/src/main.js"
   },
   "dependencies": {
-    "@aws-sdk/client-s3": "^3.700.0",
     "ink": "^6.8.0",
     "ink-spinner": "^5.0.0",
     "ink-text-input": "^6.0.0",
@@ -27,12 +26,12 @@
     "react": "^19.2.4",
     "yargs": "^17.7.2",
     "zod": "^4.3.6",
-    "@amodalai/types": "0.3.89",
-    "@amodalai/core": "0.3.89",
-    "@amodalai/db": "0.3.89",
-    "@amodalai/runtime": "0.3.89",
-    "@amodalai/studio": "0.3.89",
-    "@amodalai/runtime-app": "0.3.89"
+    "@amodalai/types": "0.3.91",
+    "@amodalai/core": "0.3.91",
+    "@amodalai/db": "0.3.91",
+    "@amodalai/runtime": "0.3.91",
+    "@amodalai/studio": "0.3.91",
+    "@amodalai/runtime-app": "0.3.91"
   },
   "devDependencies": {
     "@types/node": "^20.11.24",

package/src/commands/audit.ts

@@ -5,86 +5,19 @@
  */
 
 import type {CommandModule} from 'yargs';
-import {resolvePlatformConfig} from '../shared/platform-client.js';
 
 export interface AuditOptions {
   sessionId: string;
   format?: 'json' | 'table';
-  platformUrl?: string;
-  platformApiKey?: string;
 }
 
 /**
- * Retrieve audit trail for a session from the platform.
+ * Hosted audit trails are not available from the OSS CLI.
  */
 export async function runAudit(options: AuditOptions): Promise<void> {
-  let platformUrl: string;
-  let apiKey: string;
-  try {
-    const config = await resolvePlatformConfig({
-      url: options.platformUrl,
-      apiKey: options.platformApiKey,
-    });
-    platformUrl = config.url;
-    apiKey = config.apiKey;
-  } catch (err) {
-    const msg = err instanceof Error ? err.message : String(err);
-    process.stderr.write(`[audit] ${msg}\n`);
-    process.exit(1);
-  }
-
-  try {
-    const response = await fetch(`${platformUrl}/api/audit/sessions/${options.sessionId}`, {
-      headers: {'Authorization': `Bearer ${apiKey}`},
-    });
-
-    if (!response.ok) {
-      process.stderr.write(`[audit] HTTP ${response.status}: ${await response.text()}\n`);
-      process.exit(1);
-    }
-
-    // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion -- platform response
-    const data = await response.json() as {
-      sessionId: string;
-      events: Array<{
-        id: string;
-        eventType: string;
-        data: Record<string, unknown>;
-        tokenCount: number | null;
-        durationMs: number | null;
-        createdAt: string;
-      }>;
-    };
-
-    if (options.format === 'json') {
-      process.stdout.write(JSON.stringify(data, null, 2) + '\n');
-      return;
-    }
-
-    // Table format
-    const events = data.events;
-    if (events.length === 0) {
-      process.stdout.write('No audit events found for this session.\n');
-      return;
-    }
-
-    const typeWidth = Math.max(10, ...events.map((e) => e.eventType.length));
-    process.stdout.write(`\nSession: ${data.sessionId}\n`);
-    process.stdout.write(`${'Type'.padEnd(typeWidth)}  ${'Time'.padEnd(24)}  Details\n`);
-    process.stdout.write('-'.repeat(typeWidth + 50) + '\n');
-
-    for (const event of events) {
-      const time = event.createdAt.slice(0, 24);
-      const details = event.durationMs ? `${event.durationMs}ms` : '';
-      process.stdout.write(`${event.eventType.padEnd(typeWidth)}  ${time.padEnd(24)}  ${details}\n`);
-    }
-
-    process.stdout.write(`\nTotal: ${events.length} events\n`);
-  } catch (err) {
-    const msg = err instanceof Error ? err.message : String(err);
-    process.stderr.write(`[audit] Error: ${msg}\n`);
-    process.exit(1);
-  }
+  void options;
+  process.stderr.write('[audit] Hosted audit retrieval is not included in the OSS CLI.\n');
+  process.exit(1);
 }
 
 export const auditCommand: CommandModule = {

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

@@ -10,7 +10,7 @@ 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 */
+  /** Sandbox snapshot ID for fast workspace creation */
   snapshotId: z.string().min(1),
   /** Content hash of the tool's source files */
   imageHash: z.string().min(1),

package/src/commands/build-tools.ts

@@ -7,7 +7,6 @@
 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';
 
@@ -76,139 +75,13 @@ function loadExistingManifest(repoPath: string): BuildManifest | 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.
+ * Build local custom-tool manifest entries.
  *
  * 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.
+ * 3. Otherwise, generate a local placeholder snapshot id. Hosted control
+ *    planes own sandbox image builds outside the OSS CLI.
  *
  * Writes .amodal/build-manifest.json locally for caching.
  * The manifest is also included in the deploy snapshot.
@@ -220,8 +93,6 @@ export async function buildToolTemplates(
   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;
@@ -243,16 +114,8 @@ export async function buildToolTemplates(
       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`);
-    }
+    const snapshotId = `local-${imageHash.slice(0, 16)}`;
+    process.stderr.write(`[build-tools] ${tool.name}: using local placeholder\n`);
 
     builtTools[tool.name] = {snapshotId, imageHash, sandboxLanguage: tool.sandboxLanguage, hasDockerfile: tool.hasDockerfile, hasSetupScript: tool.hasSetupScript};
     built++;

package/src/commands/build.test.ts

@@ -39,7 +39,7 @@ describe('runBuild', () => {
     expect(stderrWrites.some((s) => s.includes('amodal.json'))).toBe(true);
   });
 
-  it('builds a snapshot and writes resolved-config.json', async () => {
+  it('packs a tarball and writes a manifest', async () => {
     mkdirSync(testDir, {recursive: true});
     writeFileSync(join(testDir, 'amodal.json'), JSON.stringify({
       name: 'test-agent',
@@ -48,16 +48,21 @@ describe('runBuild', () => {
     }));
 
     const {runBuild} = await import('./build.js');
-    const outputPath = join(testDir, 'output.json');
-    const code = await runBuild({cwd: testDir, output: outputPath});
+    const outputDir = join(testDir, 'build-out');
+    const code = await runBuild({cwd: testDir, output: outputDir});
 
     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);
+    const tarballPath = join(outputDir, 'agent.tar.gz');
+    const manifestPath = join(outputDir, 'manifest.json');
+    expect(existsSync(tarballPath)).toBe(true);
+    expect(existsSync(manifestPath)).toBe(true);
+
+    const manifest = JSON.parse(readFileSync(manifestPath, 'utf-8'));
+    expect(typeof manifest.deployId).toBe('string');
+    expect(manifest.deployId.length).toBeGreaterThan(0);
+    expect(manifest.agentName).toBe('test-agent');
+    expect(manifest.source).toBe('cli');
+    expect(stderrWrites.some((s) => s.includes('Wrote tarball'))).toBe(true);
   });
 });

package/src/commands/build.ts

@@ -1,14 +1,16 @@
 /**
  * @license
- * Copyright 2025 Amodal Labs, Inc.
+ * Copyright 2026 Amodal Labs, Inc.
  * SPDX-License-Identifier: MIT
  */
 
-import {writeFileSync} from 'node:fs';
+import {writeFileSync, mkdirSync} from 'node:fs';
 import {join, resolve} from 'node:path';
 import {execSync} from 'node:child_process';
+import {randomUUID} from 'node:crypto';
 import type {CommandModule} from 'yargs';
-import {loadRepo, buildSnapshot, serializeSnapshot, snapshotSizeBytes} from '@amodalai/core';
+import {loadRepo} from '@amodalai/core';
+import type {ToolBuildManifest} from '@amodalai/types';
 import {buildToolTemplates} from './build-tools.js';
 import {findRepoRoot} from '../shared/repo-discovery.js';
 import {runValidate} from './validate.js';
@@ -20,8 +22,22 @@ export interface BuildOptions {
 }
 
 /**
- * Get the current user from git config or fallback.
+ * Audit + handoff metadata `amodal build` emits alongside the bundle
+ * tarball. Captures who built it, from where, against which commit —
+ * the minimum a runtime / platform needs without re-parsing the bundle.
  */
+export interface DeployManifest {
+  deployId: string;
+  createdAt: string;
+  createdBy: string;
+  source: 'cli' | 'github' | 'admin-ui';
+  commitSha?: string;
+  branch?: string;
+  message?: string;
+  agentName: string;
+  toolBuildManifest?: ToolBuildManifest;
+}
+
 function getCurrentUser(): string {
   try {
     return execSync('git config user.email', {encoding: 'utf-8'}).trim();
@@ -30,9 +46,6 @@ function getCurrentUser(): string {
   }
 }
 
-/**
- * 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();
@@ -41,14 +54,23 @@ function getGitSha(): string | undefined {
   }
 }
 
+function getGitBranch(): string | undefined {
+  try {
+    return execSync('git rev-parse --abbrev-ref HEAD', {encoding: 'utf-8'}).trim();
+  } catch {
+    return undefined;
+  }
+}
+
 /**
- * Build a deploy snapshot from the local repo.
+ * Build a deploy artifact (tarball + manifest) from the local repo.
  *
  * 1. Find repo root
  * 2. Validate configuration
- * 3. Load and resolve repo
- * 4. Build snapshot
- * 5. Write to output file
+ * 3. Load and resolve repo (verifies it parses)
+ * 4. Optionally build tool sandbox snapshots
+ * 5. Pack the repo (including `node_modules`) into a tarball
+ * 6. Write a manifest describing the build
  */
 export async function runBuild(options: BuildOptions = {}): Promise<number> {
   let repoPath: string;
@@ -68,7 +90,7 @@ export async function runBuild(options: BuildOptions = {}): Promise<number> {
     return 1;
   }
 
-  // Load repo
+  // Load repo to verify it parses cleanly
   process.stderr.write('[build] Loading repo...\n');
   let repo;
   try {
@@ -80,51 +102,69 @@ export async function runBuild(options: BuildOptions = {}): Promise<number> {
   }
 
   // Build tool sandbox snapshots if requested
-  let buildManifest;
+  let toolBuildManifest: ToolBuildManifest | undefined;
   if (options.tools && repo.tools.length > 0) {
     process.stderr.write(`[build] Building ${repo.tools.length} tool sandbox(es)...\n`);
-    buildManifest = await buildToolTemplates(repoPath, repo.tools);
+    toolBuildManifest = await buildToolTemplates(repoPath, repo.tools);
   } else if (options.tools && repo.tools.length === 0) {
     process.stderr.write('[build] No tools found in tools/ directory\n');
   }
 
-  // Build snapshot (includes tool metadata + build manifest if available)
-  const snapshot = buildSnapshot(repo, {
+  const outDir = options.output ? resolve(options.output) : join(repoPath, 'build');
+  mkdirSync(outDir, {recursive: true});
+
+  // Pack the repo into a tarball. Excludes things that don't belong in
+  // a deploy artifact: VCS dir, prior build output, environment files.
+  const tarballPath = join(outDir, 'agent.tar.gz');
+  process.stderr.write(`[build] Packing ${repoPath} → ${tarballPath}\n`);
+  try {
+    execSync(
+      `tar -czf "${tarballPath}" ` +
+      `--exclude='.git' --exclude='build' --exclude='.env' --exclude='.env.local' ` +
+      `-C "${repoPath}" .`,
+      {stdio: 'pipe'},
+    );
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    process.stderr.write(`[build] tar failed: ${msg}\n`);
+    return 1;
+  }
+
+  const manifest: DeployManifest = {
+    deployId: randomUUID(),
+    createdAt: new Date().toISOString(),
     createdBy: getCurrentUser(),
     source: 'cli',
-    commitSha: getGitSha(),
-    buildManifest,
-  });
-
-  // Serialize and write
-  const serialized = serializeSnapshot(snapshot);
-  const size = snapshotSizeBytes(serialized);
-  const outputPath = options.output
-    ? resolve(options.output)
-    : join(repoPath, 'resolved-config.json');
+    agentName: repo.config.name,
+    ...(getGitSha() ? {commitSha: getGitSha()} : {}),
+    ...(getGitBranch() ? {branch: getGitBranch()} : {}),
+    ...(toolBuildManifest ? {toolBuildManifest} : {}),
+  };
 
-  writeFileSync(outputPath, serialized);
+  const manifestPath = join(outDir, 'manifest.json');
+  writeFileSync(manifestPath, JSON.stringify(manifest, null, 2));
 
-  process.stderr.write(`[build] Snapshot ${snapshot.deployId} written to ${outputPath}\n`);
-  process.stderr.write(`[build] Size: ${(size / 1024).toFixed(1)} KB\n`);
-  process.stderr.write(`[build] Connections: ${Object.keys(snapshot.connections).length}, Skills: ${snapshot.skills.length}, Automations: ${snapshot.automations.length}, Knowledge: ${snapshot.knowledge.length}, Tools: ${repo.tools.length}\n`);
+  process.stderr.write(`[build] Wrote tarball ${tarballPath}\n`);
+  process.stderr.write(`[build] Wrote manifest ${manifestPath}\n`);
+  process.stderr.write(`[build] deployId=${manifest.deployId} commit=${manifest.commitSha ?? '(no git)'} branch=${manifest.branch ?? '-'}\n`);
+  process.stderr.write(`[build] Bundle: connections=${repo.connections.size + repo.externalConnections.size}, skills=${repo.skills.length}, automations=${repo.automations.length}, knowledge=${repo.knowledge.length}, tools=${repo.tools.length}\n`);
 
   return 0;
 }
 
 export const buildCommand: CommandModule = {
   command: 'build',
-  describe: 'Build a deploy snapshot from the local repo',
+  describe: 'Pack a deploy artifact (tarball + manifest) from the local repo',
   builder: (yargs) =>
     yargs
       .option('output', {
         type: 'string',
         alias: 'o',
-        describe: 'Output file path (default: resolved-config.json)',
+        describe: 'Output directory (default: ./build)',
       })
       .option('tools', {
         type: 'boolean',
-        describe: 'Build Daytona sandbox snapshots for custom tools',
+        describe: 'Include local custom-tool build metadata',
         default: false,
       }),
   handler: async (argv) => {

package/src/commands/chat.ts

@@ -8,7 +8,7 @@ import type http from 'node:http';
 import {createElement} from 'react';
 import {render} from 'ink';
 import type {CommandModule} from 'yargs';
-import {createLocalServer, createSnapshotServer} from '@amodalai/runtime';
+import {createLocalServer, createBundleServer} from '@amodalai/runtime';
 import {findRepoRoot} from '../shared/repo-discovery.js';
 import {runConnectionPreflight, printPreflightTable} from '../shared/connection-preflight.js';
 import {ChatApp} from '../ui/ChatApp.js';
@@ -28,7 +28,7 @@ export interface ChatOptions {
  *
  * Three modes:
  *   --url <remote>    → connect to an already-running server (no local boot)
- *   --config <file>   → boot from a snapshot file
+ *   --config <dir>    → boot from an extracted bundle directory (offline replay)
  *   (default)         → boot from the local repo
  */
 export async function runChat(options: ChatOptions): Promise<void> {
@@ -57,9 +57,9 @@ export async function runChat(options: ChatOptions): Promise<void> {
   let repoPath: string | undefined;
 
   if (options.config) {
-    process.stderr.write(`[chat] Loading snapshot from ${options.config}\n`);
-    serverInstance = await createSnapshotServer({
-      snapshotPath: options.config,
+    process.stderr.write(`[chat] Loading bundle from ${options.config}\n`);
+    serverInstance = await createBundleServer({
+      bundlePath: options.config,
       port,
       host: '127.0.0.1',
     });

package/src/commands/deploy.test.ts

@@ -20,13 +20,6 @@ vi.mock('./validate.js', () => ({
   runValidate: (...args: unknown[]) => mockRunValidate(...args),
 }));
 
-const mockPlatformCreate = vi.fn();
-vi.mock('../shared/platform-client.js', () => ({
-  PlatformClient: {
-    create: (...args: unknown[]) => mockPlatformCreate(...args),
-  },
-}));
-
 // Import after mock
 const {runDeploy} = await import('./deploy.js');
 
@@ -49,9 +42,6 @@ describe('deploy command', () => {
 
     mockFindRepoRoot.mockReturnValue(testDir);
     mockRunValidate.mockResolvedValue(0); // Validation passes
-    mockPlatformCreate.mockResolvedValue({
-      uploadSnapshot: vi.fn().mockResolvedValue({id: 'deploy-test123', environment: 'production'}),
-    });
   });
 
   afterEach(() => {
@@ -95,15 +85,14 @@ describe('deploy command', () => {
     stderrSpy.mockRestore();
   });
 
-  it('returns 1 when platform not configured and not dry-run', async () => {
-    mockPlatformCreate.mockRejectedValue(new Error('Platform URL not found. Run `amodal login`.'));
+  it('returns 1 for cloud deploy in OSS CLI', async () => {
     const stderrSpy = vi.spyOn(process.stderr, 'write').mockImplementation(() => true);
 
     try {
       const code = await runDeploy({cwd: testDir});
       expect(code).toBe(1);
       const messages = stderrSpy.mock.calls.map((c) => String(c[0]));
-      expect(messages.some((m) => m.includes('Platform'))).toBe(true);
+      expect(messages.some((m) => m.includes('not included in the OSS CLI'))).toBe(true);
     } finally {
       stderrSpy.mockRestore();
     }