@amodalai/amodal 0.1.6 → 0.1.9

package/src/shared/platform-client.ts

@@ -105,12 +105,24 @@ export class PlatformClient {
 
   private async request<T>(method: string, path: string, body?: unknown): Promise<T> {
     const url = `${this.baseUrl}${path}`;
-    const resp = await fetch(url, {
+    let resp = await fetch(url, {
       method,
       headers: this.headers(),
       ...(body ? {body: JSON.stringify(body)} : {}),
     });
 
+    // Auto-refresh on 401
+    if (resp.status === 401) {
+      const refreshed = await this.tryRefreshToken();
+      if (refreshed) {
+        resp = await fetch(url, {
+          method,
+          headers: this.headers(),
+          ...(body ? {body: JSON.stringify(body)} : {}),
+        });
+      }
+    }
+
     if (!resp.ok) {
       let detail = '';
       try {
@@ -128,7 +140,48 @@ export class PlatformClient {
   }
 
   /**
-   * Upload a snapshot and deploy it.
+   * Try to refresh the token using the stored refresh token.
+   * Updates both the in-memory key and the rc file on success.
+   */
+  private async tryRefreshToken(): Promise<boolean> {
+    try {
+      const {readRcFile} = await import('../commands/login.js');
+      const rc = await readRcFile();
+      if (!rc.platform?.refreshToken) return false;
+
+      const res = await fetch(`${this.baseUrl}/api/auth/refresh`, {
+        method: 'POST',
+        headers: {'Content-Type': 'application/json'},
+        body: JSON.stringify({refresh_token: rc.platform.refreshToken}),
+      });
+      if (!res.ok) return false;
+
+      // 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 false;
+
+      // Update in-memory
+      // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion -- private field update
+      (this as unknown as {apiKey: string}).apiKey = data.access_token;
+
+      // Persist to rc file
+      rc.platform.token = data.access_token;
+      if (data.refresh_token) rc.platform.refreshToken = data.refresh_token;
+      const {writeFile} = await import('node:fs/promises');
+      const {homedir} = await import('node:os');
+      const path = await import('node:path');
+      const rcPath = path.join(homedir(), '.amodalrc');
+      await writeFile(rcPath, JSON.stringify(rc, null, 2) + '\n', {mode: 0o600});
+
+      process.stderr.write('[auth] Token refreshed automatically.\n');
+      return true;
+    } catch {
+      return false;
+    }
+  }
+
+  /**
+   * Upload a snapshot and deploy it (without repo files).
    */
   async uploadSnapshot(snapshot: DeploySnapshot, options: {
     environment?: string;
@@ -139,6 +192,66 @@ export class PlatformClient {
     });
   }
 
+  /**
+   * Deploy with repo files — uploads snapshot + repo tarball.
+   * The server builds the runtime-app and uploads to R2.
+   */
+  async deployWithRepo(
+    snapshot: DeploySnapshot,
+    repoTarball: import('node:fs').ReadStream,
+    options: { environment?: string; appId?: string } = {},
+  ): Promise<SnapshotDeploymentMeta> {
+    const url = `${this.baseUrl}/api/snapshot-deployments`;
+
+    const formData = new FormData();
+    formData.append('snapshot', JSON.stringify(snapshot));
+    formData.append('environment', options.environment ?? 'production');
+    if (options.appId) {
+      formData.append('appId', options.appId);
+    }
+
+    // Convert ReadStream to Blob for FormData
+    const chunks: Uint8Array[] = [];
+    for await (const chunk of repoTarball) {
+      // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion -- ReadStream chunks are Buffer/Uint8Array
+      chunks.push(chunk as Uint8Array);
+    }
+    const blob = new Blob(chunks, {type: 'application/gzip'});
+    formData.append('repo', blob, 'repo.tar.gz');
+
+    let resp = await fetch(url, {
+      method: 'POST',
+      headers: {Authorization: `Bearer ${this.apiKey}`},
+      body: formData,
+    });
+
+    // Auto-refresh on 401
+    if (resp.status === 401) {
+      const refreshed = await this.tryRefreshToken();
+      if (refreshed) {
+        // Re-read the tarball - can't reuse the stream
+        resp = await fetch(url, {
+          method: 'POST',
+          headers: {Authorization: `Bearer ${this.apiKey}`},
+          body: formData,
+        });
+      }
+    }
+
+    if (!resp.ok) {
+      let detail = '';
+      try {
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion
+        const errBody = await resp.json() as {error?: string};
+        detail = errBody.error ? `: ${errBody.error}` : '';
+      } catch { /* ignore */ }
+      throw new Error(`Platform API POST /api/snapshot-deployments failed (${resp.status})${detail}`);
+    }
+
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion
+    return resp.json() as Promise<SnapshotDeploymentMeta>;
+  }
+
   /**
    * List deployments for the authenticated tenant.
    */

package/src/shared/tarball.ts

@@ -0,0 +1,30 @@
+/**
+ * @license
+ * Copyright 2025 Amodal Labs, Inc.
+ * SPDX-License-Identifier: MIT
+ */
+
+import {execSync} from 'node:child_process';
+import {mkdtempSync} from 'node:fs';
+import * as path from 'node:path';
+import * as os from 'node:os';
+
+/**
+ * Create a gzipped tarball of the repo directory.
+ * Excludes node_modules, .git, and other non-essential files.
+ *
+ * @returns Path to the tarball file (caller must clean up).
+ */
+export async function createRepoTarball(repoPath: string): Promise<string> {
+  const tarballPath = path.join(
+    mkdtempSync(path.join(os.tmpdir(), 'amodal-deploy-')),
+    'repo.tar.gz',
+  );
+
+  execSync(
+    `tar -czf "${tarballPath}" --exclude=node_modules --exclude=.git --exclude=amodal_packages --exclude=.amodal -C "${repoPath}" .`,
+    {stdio: 'pipe', timeout: 30_000},
+  );
+
+  return tarballPath;
+}

package/src/ui/ChatApp.tsx

@@ -83,16 +83,17 @@ export const ChatApp: React.FC<ChatAppProps> = ({
     }
   }, [resume.messages, resumeSessionId, dispatch]);
 
-  // Keyboard navigation for scrolling
-  const canScroll = !state.isStreaming && !state.pendingQuestion && !state.pendingConfirmation && !state.showSessionBrowser;
+  // Ctrl+C always active — exits the app
   useInput((_input, key) => {
     if (key.ctrl && _input === 'c') {
       exit();
-      return;
     }
+  });
 
-    if (!canScroll) return;
-
+  // Scroll keybindings — only active when input bar is NOT showing
+  // (i.e., during streaming, prompts, or session browser)
+  const isInputBarVisible = !state.isStreaming && !state.pendingQuestion && !state.pendingConfirmation && !state.showSessionBrowser;
+  useInput((_input, key) => {
     // j/k line scroll
     if (_input === 'j') {
       scroll.scrollBy(1);
@@ -107,13 +108,13 @@ export const ChatApp: React.FC<ChatAppProps> = ({
       scroll.scrollBy(viewportHeight);
     }
 
-    // Home/End (map to Meta+< and Meta+>)
+    // Home/End
     if (key.home) {
       scroll.scrollToTop();
     } else if (key.end) {
       scroll.scrollToBottom();
     }
-  });
+  }, {isActive: !isInputBarVisible});
 
   // Slash command handler
   const handleSlashCommand = useCallback(