@amodalai/amodal 0.1.6 → 0.1.9

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@amodalai/amodal",
-  "version": "0.1.6",
+  "version": "0.1.9",
   "description": "Amodal CLI",
   "license": "MIT",
   "repository": {
@@ -30,11 +30,11 @@
     "semver": "^7.6.0",
     "yargs": "^17.7.2",
     "zod": "^4.3.6",
-    "@amodalai/core": "0.1.6",
-    "@amodalai/runtime": "0.1.6"
+    "@amodalai/runtime": "0.1.9",
+    "@amodalai/core": "0.1.9"
   },
   "peerDependencies": {
-    "@amodalai/runtime-app": "0.1.6"
+    "@amodalai/runtime-app": "0.1.9"
   },
   "peerDependenciesMeta": {
     "@amodalai/runtime-app": {

package/src/commands/chat.ts

@@ -10,6 +10,7 @@ import {render} from 'ink';
 import type {CommandModule} from 'yargs';
 import {createLocalServer, createSnapshotServer} from '@amodalai/runtime';
 import {findRepoRoot} from '../shared/repo-discovery.js';
+import {runConnectionPreflight, printPreflightTable} from '../shared/connection-preflight.js';
 import {ChatApp} from '../ui/ChatApp.js';
 
 export interface ChatOptions {
@@ -53,6 +54,7 @@ export async function runChat(options: ChatOptions): Promise<void> {
   // Mode 2 & 3: Boot a local server
   const port = options.port ?? 0;
   let serverInstance: {app: unknown; start: () => Promise<unknown>; stop: () => Promise<void>};
+  let repoPath: string | undefined;
 
   if (options.config) {
     process.stderr.write(`[chat] Loading snapshot from ${options.config}\n`);
@@ -62,7 +64,6 @@ export async function runChat(options: ChatOptions): Promise<void> {
       host: '127.0.0.1',
     });
   } else {
-    let repoPath: string;
     try {
       repoPath = findRepoRoot(options.cwd);
     } catch (err) {
@@ -86,11 +87,46 @@ export async function runChat(options: ChatOptions): Promise<void> {
   const actualPort = typeof addr === 'object' && addr !== null ? addr.port : port;
   const baseUrl = `http://127.0.0.1:${actualPort}`;
 
+  // Preflight connection check (non-blocking)
+  if (repoPath) {
+    const preflight = await runConnectionPreflight(repoPath);
+    if (preflight.results.length > 0) {
+      process.stderr.write('\n');
+      printPreflightTable(preflight.results);
+      if (preflight.hasFailures) {
+        process.stderr.write('\n  WARNING: Some connections failed. The agent may not work correctly.\n');
+      }
+      process.stderr.write('\n');
+    }
+  }
+
+  // Resolve "latest" to an actual session ID
+  let resumeId = options.resume;
+  if (resumeId === 'latest') {
+    try {
+      const res = await fetch(`${baseUrl}/sessions`);
+      if (res.ok) {
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion
+        const body = await res.json() as {sessions: Array<{id: string}>};
+        if (body.sessions.length > 0) {
+          resumeId = body.sessions[0].id;
+          process.stderr.write(`[chat] Resuming session ${resumeId}\n`);
+        } else {
+          process.stderr.write('[chat] No previous sessions found, starting fresh\n');
+          resumeId = undefined;
+        }
+      }
+    } catch {
+      process.stderr.write('[chat] Could not fetch sessions, starting fresh\n');
+      resumeId = undefined;
+    }
+  }
+
   const {waitUntilExit} = render(
     createElement(ChatApp, {
       baseUrl,
       tenantId,
-      resumeSessionId: options.resume,
+      resumeSessionId: resumeId,
       fullscreen: options.fullscreen,
     }),
   );

package/src/commands/deploy.ts

@@ -5,11 +5,14 @@
  */
 
 import {execSync} from 'node:child_process';
+import {createReadStream} from 'node:fs';
 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';
+import {createRepoTarball} from '../shared/tarball.js';
+import {readProjectLink} from './link.js';
 
 export interface DeployOptions {
   cwd?: string;
@@ -107,11 +110,24 @@ export async function runDeploy(options: DeployOptions = {}): Promise<number> {
   }
 
   try {
-    const result = await client.uploadSnapshot(snapshot, {environment});
+    // Create tarball of the repo for server-side runtime-app build
+    process.stderr.write('[deploy] Packaging repo...\n');
+    const tarballPath = await createRepoTarball(repoPath);
+
+    // Read appId from project link
+    const projectLink = await readProjectLink();
+    const appId = projectLink?.appId;
+
+    const result = await client.deployWithRepo(snapshot, createReadStream(tarballPath), {environment, appId});
     process.stderr.write(`[deploy] Deployed ${result.id} to ${result.environment}\n`);
     if (result.message) {
       process.stderr.write(`[deploy] Message: ${result.message}\n`);
     }
+
+    // Cleanup tarball
+    const {unlinkSync} = await import('node:fs');
+    try { unlinkSync(tarballPath); } catch { /* best-effort */ }
+
     return 0;
   } catch (err) {
     const msg = err instanceof Error ? err.message : String(err);

package/src/commands/dev.ts

@@ -10,20 +10,13 @@ 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;
-  }
-}
+import {runConnectionPreflight, printPreflightTable} from '../shared/connection-preflight.js';
 
 export interface DevOptions {
   cwd?: string;
   port?: number;
   host?: string;
+  resume?: string;
 }
 
 const DEFAULT_PORT = 3847;
@@ -47,29 +40,22 @@ export async function runDev(options: DevOptions = {}): Promise<void> {
   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;
-        }
+    // Use pre-built static assets for the SPA for the SPA.
+    // Vite dev middleware is only used inside the monorepo with `pnpm dev`.
+    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', '@amodalai', '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;
       }
     }
 
@@ -79,12 +65,23 @@ export async function runDev(options: DevOptions = {}): Promise<void> {
       host,
       hotReload: true,
       corsOrigin: '*',
-      appMiddleware,
       staticAppDir,
+      resumeSessionId: options.resume,
     });
 
     await server.start();
 
+    // Preflight connection check (non-blocking)
+    const preflight = await runConnectionPreflight(repoPath);
+    if (preflight.results.length > 0) {
+      process.stderr.write('\n');
+      printPreflightTable(preflight.results);
+      if (preflight.hasFailures) {
+        process.stderr.write('\n  WARNING: Some connections failed. The agent may not work correctly.\n');
+      }
+      process.stderr.write('\n');
+    }
+
     // Graceful shutdown
     const shutdown = async (signal: string): Promise<void> => {
       process.stderr.write(`\n[dev] Received ${signal}, shutting down...\n`);
@@ -113,12 +110,18 @@ export const devCommand: CommandModule = {
       type: 'string',
       describe: 'Host to bind to',
     },
+    resume: {
+      type: 'string',
+      describe: 'Resume a previous session by ID or "latest"',
+    },
   },
   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});
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion
+    const resume = argv['resume'] as string | undefined;
+    await runDev({port, host, resume});
   },
 };

package/src/commands/index.ts

@@ -16,7 +16,7 @@ import {updateCommand} from './update.js';
 import {diffCommand} from './diff.js';
 import {searchCommand} from './search.js';
 import {publishCommand} from './publish.js';
-import {loginCommand} from './login.js';
+import {loginCommand, logoutCommand} from './login.js';
 import {linkCommand} from './link.js';
 import {syncCommand} from './sync.js';
 import {secretsCommand} from './secrets.js';
@@ -54,6 +54,7 @@ export const amodalCommands = [
   searchCommand,
   publishCommand,
   loginCommand,
+  logoutCommand,
   linkCommand,
   syncCommand,
   // Platform

package/src/commands/login.ts

@@ -143,12 +143,34 @@ export async function runLogin(options: LoginOptions = {}): Promise<number> {
   const platformUrl = options.platformUrl ?? process.env['PLATFORM_API_URL'] ?? DEFAULT_PLATFORM_URL;
   const adminUrl = options.adminUrl ?? process.env['ADMIN_UI_URL'] ?? DEFAULT_ADMIN_UI_URL;
 
-  // Check if already logged in
+  // Check if already logged in — try refreshing the token first
   const rc = await readRcFile();
   if (rc.platform?.url === platformUrl && rc.platform.token) {
-    process.stderr.write(`[login] Already logged in to ${platformUrl}\n`);
-    process.stderr.write('[login] Run `amodal logout` first, or use --platform-url for a different instance.\n');
-    return 0;
+    // Try the existing token
+    const meRes = await fetch(`${platformUrl}/api/me`, {
+      headers: {Authorization: `Bearer ${rc.platform.token}`},
+    }).catch(() => null);
+
+    if (meRes?.ok) {
+      process.stderr.write(`[login] Already logged in to ${platformUrl}\n`);
+      return 0;
+    }
+
+    // Token expired — try refresh
+    if (rc.platform.refreshToken) {
+      process.stderr.write('[login] Token expired, refreshing...\n');
+      const refreshed = await refreshAccessToken(platformUrl, rc.platform.refreshToken);
+      if (refreshed) {
+        rc.platform.token = refreshed.token;
+        rc.platform.refreshToken = refreshed.refreshToken;
+        await writeRcFile(rc);
+        process.stderr.write('[login] Token refreshed successfully.\n');
+        return 0;
+      }
+    }
+
+    // Refresh failed — proceed to re-login
+    process.stderr.write('[login] Session expired. Re-authenticating...\n');
   }
 
   // Start local callback server
@@ -234,6 +256,56 @@ export async function runLogin(options: LoginOptions = {}): Promise<number> {
   }
 }
 
+/**
+ * Refresh an expired Supabase access token using the refresh token.
+ */
+async function refreshAccessToken(
+  platformUrl: string,
+  refreshToken: string,
+): Promise<{token: string; refreshToken: string} | null> {
+  try {
+    const res = await fetch(`${platformUrl}/api/auth/refresh`, {
+      method: 'POST',
+      headers: {'Content-Type': 'application/json'},
+      body: JSON.stringify({refresh_token: refreshToken}),
+    });
+    if (!res.ok) return null;
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion
+    const data = (await res.json()) as {access_token?: string; refresh_token?: string};
+    if (!data.access_token) return null;
+    return {
+      token: data.access_token,
+      refreshToken: data.refresh_token ?? refreshToken,
+    };
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Log out by removing saved credentials.
+ */
+export async function runLogout(): Promise<number> {
+  const rc = await readRcFile();
+  if (!rc.platform) {
+    process.stderr.write('[logout] Not logged in.\n');
+    return 0;
+  }
+  delete rc.platform;
+  await writeRcFile(rc);
+  process.stderr.write('[logout] Logged out.\n');
+  return 0;
+}
+
+export const logoutCommand: CommandModule = {
+  command: 'logout',
+  describe: 'Log out from the amodal platform',
+  handler: async () => {
+    const code = await runLogout();
+    process.exit(code);
+  },
+};
+
 export const loginCommand: CommandModule = {
   command: 'login',
   describe: 'Log in to the amodal platform',

package/src/commands/validate.test.ts

@@ -15,10 +15,17 @@ vi.mock('../shared/repo-discovery.js', () => ({
   findRepoRoot: mockFindRepoRoot,
 }));
 
+const mockMcpManager = {
+  startServers: vi.fn().mockResolvedValue(undefined),
+  getServerInfo: vi.fn().mockReturnValue([]),
+  shutdown: vi.fn().mockResolvedValue(undefined),
+};
+
 vi.mock('@amodalai/core', () => ({
   loadRepo: mockLoadRepo,
   readLockFile: mockReadLockFile,
   resolveAllPackages: mockResolveAllPackages,
+  McpManager: vi.fn(() => mockMcpManager),
 }));
 
 describe('runValidate', () => {
@@ -38,7 +45,7 @@ describe('runValidate', () => {
     });
 
     const {runValidate} = await import('./validate.js');
-    const result = await runValidate();
+    const result = await runValidate({skipTest: true});
     expect(result).toBe(0);
   });
 
@@ -50,7 +57,7 @@ describe('runValidate', () => {
     });
 
     const {runValidate} = await import('./validate.js');
-    const result = await runValidate();
+    const result = await runValidate({skipTest: true});
     expect(result).toBe(0); // warnings don't cause failure
   });
 
@@ -62,7 +69,7 @@ describe('runValidate', () => {
     });
 
     const {runValidate} = await import('./validate.js');
-    const result = await runValidate();
+    const result = await runValidate({skipTest: true});
     expect(result).toBe(0);
   });
 
@@ -74,7 +81,7 @@ describe('runValidate', () => {
     });
 
     const {runValidate} = await import('./validate.js');
-    const result = await runValidate();
+    const result = await runValidate({skipTest: true});
     expect(result).toBe(1);
   });
 
@@ -86,7 +93,7 @@ describe('runValidate', () => {
     });
 
     const {runValidate} = await import('./validate.js');
-    const result = await runValidate();
+    const result = await runValidate({skipTest: true});
     expect(result).toBe(0);
   });
 
@@ -94,7 +101,7 @@ describe('runValidate', () => {
     mockLoadRepo.mockRejectedValue(new Error('Config parse failed'));
 
     const {runValidate} = await import('./validate.js');
-    const result = await runValidate();
+    const result = await runValidate({skipTest: true});
     expect(result).toBe(1);
   });
 
@@ -104,7 +111,7 @@ describe('runValidate', () => {
     });
 
     const {runValidate} = await import('./validate.js');
-    const result = await runValidate();
+    const result = await runValidate({skipTest: true});
     expect(result).toBe(1);
   });
 
@@ -119,7 +126,7 @@ describe('runValidate', () => {
     });
 
     const {runValidate} = await import('./validate.js');
-    const result = await runValidate();
+    const result = await runValidate({skipTest: true});
     expect(result).toBe(2);
   });
 
@@ -131,7 +138,7 @@ describe('runValidate', () => {
     });
 
     const {runValidate} = await import('./validate.js');
-    const result = await runValidate();
+    const result = await runValidate({skipTest: true});
     expect(result).toBe(1); // 1 error
   });
 
@@ -152,7 +159,7 @@ describe('runValidate', () => {
     });
 
     const {runValidate} = await import('./validate.js');
-    const result = await runValidate({packages: true});
+    const result = await runValidate({packages: true, skipTest: true});
     expect(result).toBe(0);
     expect(mockResolveAllPackages).toHaveBeenCalled();
   });
@@ -173,7 +180,7 @@ describe('runValidate', () => {
     });
 
     const {runValidate} = await import('./validate.js');
-    const result = await runValidate({packages: true});
+    const result = await runValidate({packages: true, skipTest: true});
     expect(result).toBe(0); // warnings only
   });
 
@@ -193,7 +200,7 @@ describe('runValidate', () => {
     });
 
     const {runValidate} = await import('./validate.js');
-    const result = await runValidate({packages: true});
+    const result = await runValidate({packages: true, skipTest: true});
     expect(result).toBe(1);
   });
 
@@ -206,7 +213,7 @@ describe('runValidate', () => {
     mockReadLockFile.mockResolvedValue(null);
 
     const {runValidate} = await import('./validate.js');
-    const result = await runValidate({packages: true});
+    const result = await runValidate({packages: true, skipTest: true});
     expect(result).toBe(0);
     expect(mockResolveAllPackages).not.toHaveBeenCalled();
   });
@@ -219,7 +226,7 @@ describe('runValidate', () => {
     });
 
     const {runValidate} = await import('./validate.js');
-    const result = await runValidate();
+    const result = await runValidate({skipTest: true});
     expect(result).toBe(0);
     expect(mockReadLockFile).not.toHaveBeenCalled();
   });
@@ -234,7 +241,7 @@ describe('runValidate', () => {
     mockResolveAllPackages.mockRejectedValue(new Error('Disk error'));
 
     const {runValidate} = await import('./validate.js');
-    const result = await runValidate({packages: true});
+    const result = await runValidate({packages: true, skipTest: true});
     expect(result).toBe(1);
   });
 
@@ -254,7 +261,153 @@ describe('runValidate', () => {
     });
 
     const {runValidate} = await import('./validate.js');
-    const result = await runValidate({packages: true});
+    const result = await runValidate({packages: true, skipTest: true});
     expect(result).toBe(0); // warning only
   });
+
+  // Live connection testing
+  describe('live connection tests', () => {
+    const mockFetch = vi.fn();
+
+    beforeEach(() => {
+      vi.stubGlobal('fetch', mockFetch);
+      mockFetch.mockReset();
+    });
+
+    it('should test REST connections and report pass on 200', async () => {
+      mockLoadRepo.mockResolvedValue({
+        connections: new Map([['myapi', {
+          surface: [{method: 'GET', path: '/test'}],
+          access: {},
+          spec: {baseUrl: 'https://api.example.com', auth: {type: 'none'}},
+        }]]),
+        skills: [],
+        automations: [],
+      });
+      mockFetch.mockResolvedValue({status: 200, redirected: false});
+
+      const {runValidate} = await import('./validate.js');
+      const result = await runValidate({skipTest: false});
+      expect(result).toBe(0);
+      expect(mockFetch).toHaveBeenCalledWith(
+        'https://api.example.com',
+        expect.objectContaining({method: 'GET'}),
+      );
+    });
+
+    it('should report fail on 401', async () => {
+      mockLoadRepo.mockResolvedValue({
+        connections: new Map([['myapi', {
+          surface: [{method: 'GET', path: '/test'}],
+          access: {},
+          spec: {baseUrl: 'https://api.example.com', auth: {type: 'bearer', token: 'env:BAD_KEY'}},
+        }]]),
+        skills: [],
+        automations: [],
+      });
+      mockFetch.mockResolvedValue({status: 401, redirected: false});
+
+      const {runValidate} = await import('./validate.js');
+      const result = await runValidate({skipTest: false});
+      expect(result).toBe(1);
+    });
+
+    it('should use testPath when available', async () => {
+      mockLoadRepo.mockResolvedValue({
+        connections: new Map([['myapi', {
+          surface: [{method: 'GET', path: '/me'}],
+          access: {},
+          spec: {baseUrl: 'https://api.example.com/v2', testPath: '/me', auth: {type: 'none'}},
+        }]]),
+        skills: [],
+        automations: [],
+      });
+      mockFetch.mockResolvedValue({status: 200, redirected: false});
+
+      const {runValidate} = await import('./validate.js');
+      const result = await runValidate({skipTest: false});
+      expect(result).toBe(0);
+      expect(mockFetch).toHaveBeenCalledWith(
+        'https://api.example.com/v2/me',
+        expect.objectContaining({method: 'GET'}),
+      );
+    });
+
+    it('should report network errors as fail', async () => {
+      mockLoadRepo.mockResolvedValue({
+        connections: new Map([['myapi', {
+          surface: [{method: 'GET', path: '/test'}],
+          access: {},
+          spec: {baseUrl: 'https://unreachable.example.com', auth: {type: 'none'}},
+        }]]),
+        skills: [],
+        automations: [],
+      });
+      mockFetch.mockRejectedValue(new Error('ECONNREFUSED'));
+
+      const {runValidate} = await import('./validate.js');
+      const result = await runValidate({skipTest: false});
+      expect(result).toBe(1);
+    });
+
+    it('should test MCP servers and report pass on connected', async () => {
+      mockMcpManager.getServerInfo.mockReturnValue([
+        {name: 'xpoz', status: 'connected', tools: ['search', 'get'], error: undefined},
+      ]);
+
+      mockLoadRepo.mockResolvedValue({
+        connections: new Map(),
+        skills: [],
+        automations: [],
+        mcpServers: {xpoz: {transport: 'http', url: 'https://mcp.xpoz.ai/mcp'}},
+      });
+
+      const {runValidate} = await import('./validate.js');
+      const result = await runValidate({skipTest: false});
+      expect(result).toBe(0);
+      expect(mockMcpManager.startServers).toHaveBeenCalled();
+      expect(mockMcpManager.shutdown).toHaveBeenCalled();
+    });
+
+    it('should report MCP server failure', async () => {
+      mockMcpManager.getServerInfo.mockReturnValue([
+        {name: 'broken', status: 'error', tools: [], error: 'Connection refused'},
+      ]);
+
+      mockLoadRepo.mockResolvedValue({
+        connections: new Map(),
+        skills: [],
+        automations: [],
+        mcpServers: {broken: {transport: 'http', url: 'https://broken.example.com/mcp'}},
+      });
+
+      const {runValidate} = await import('./validate.js');
+      const result = await runValidate({skipTest: false});
+      expect(result).toBe(1);
+    });
+
+    it('should handle redirect + retry for auth stripping', async () => {
+      mockLoadRepo.mockResolvedValue({
+        connections: new Map([['myapi', {
+          surface: [{method: 'GET', path: '/test'}],
+          access: {},
+          spec: {baseUrl: 'https://api.example.com/v2', auth: {type: 'bearer', token: 'env:MY_TOKEN'}},
+        }]]),
+        skills: [],
+        automations: [],
+      });
+      // First call: redirected, lost auth → 401
+      // Second call: retry with auth → 200
+      mockFetch
+        .mockResolvedValueOnce({status: 401, redirected: true, url: 'https://api.example.com/v2/'})
+        .mockResolvedValueOnce({status: 200, redirected: false});
+
+      process.env['MY_TOKEN'] = 'test-token';
+      const {runValidate} = await import('./validate.js');
+      const result = await runValidate({skipTest: false});
+      expect(result).toBe(0);
+      expect(mockFetch).toHaveBeenCalledTimes(2);
+      delete process.env['MY_TOKEN'];
+    });
+  });
 });