sea-dev 1.0.0

package/scripts/src/sync-render-yaml.ts

@@ -0,0 +1,290 @@
+#!/usr/bin/env node
+
+/**
+ * Script to fetch Render services and update render.yaml to match deployed configuration
+ * Usage: RENDER_API_KEY=your_key tsx .scripts/sync-render-yaml.ts
+ */
+
+import fs from 'fs';
+import path from 'path';
+import { parse, stringify } from 'yaml';
+
+const RENDER_API_KEY = process.env.RENDER_API_KEY;
+const RENDER_YAML_PATH = path.join(process.cwd(), 'render.yaml');
+
+if (!RENDER_API_KEY) {
+    console.error('❌ RENDER_API_KEY environment variable is required');
+    console.error('Get your API key from: https://dashboard.render.com/u/settings');
+    console.error('Usage: RENDER_API_KEY=your_key tsx .scripts/sync-render-yaml.ts');
+    process.exit(1);
+}
+
+interface RenderService {
+    id: string;
+    type: string;
+    name: string;
+    repo: string;
+    autoDeploy: string;
+    branch: string;
+    rootDir?: string;
+    serviceDetails: {
+        plan?: string;
+        region?: string;
+        runtime?: string;
+        buildPlan?: string;
+        envSpecificDetails?: {
+            buildCommand?: string;
+            startCommand?: string;
+            dockerCommand?: string;
+            dockerfilePath?: string;
+        };
+        healthCheckPath?: string;
+        publishPath?: string;
+        env?: string;
+        envVars?: Array<{
+            key: string;
+            value?: string;
+        }>;
+    };
+}
+
+interface RenderDatabase {
+    id: string;
+    name: string;
+    plan: string;
+    region: string;
+    databaseName: string;
+    user: string;
+    version: string;
+}
+
+async function fetchRenderServices(): Promise<RenderService[]> {
+    console.log('🔍 Fetching services from Render...');
+
+    const response = await fetch('https://api.render.com/v1/services?limit=100', {
+        headers: {
+            'Accept': 'application/json',
+            'Authorization': `Bearer ${RENDER_API_KEY}`,
+        },
+    });
+
+    if (!response.ok) {
+        throw new Error(`Render API error: ${response.status} ${response.statusText}`);
+    }
+
+    const data = await response.json();
+
+    // The Render API returns an array of { cursor, service } objects
+    const services = Array.isArray(data) ? data.map((item: { service?: RenderService }) => item.service).filter(Boolean) : [];
+    console.log(`✅ Found ${services.length} services`);
+    return services;
+}
+
+async function fetchRenderDatabases(): Promise<RenderDatabase[]> {
+    console.log('🔍 Fetching databases from Render...');
+
+    const response = await fetch('https://api.render.com/v1/postgres?limit=100', {
+        headers: {
+            'Accept': 'application/json',
+            'Authorization': `Bearer ${RENDER_API_KEY}`,
+        },
+    });
+
+    if (!response.ok) {
+        throw new Error(`Render API error: ${response.status} ${response.statusText}`);
+    }
+
+    const data = await response.json();
+
+    // Debug: Check structure
+    if (data && data.length > 0) {
+        console.log('📋 Database API response sample:', JSON.stringify(data[0], null, 2));
+    }
+
+    const databases = Array.isArray(data) ? data.map((item: { database?: RenderDatabase } | RenderDatabase) => ('database' in item ? item.database : item)).filter(Boolean) : [];
+    console.log(`✅ Found ${databases.length} databases`);
+    return databases;
+}
+
+function mapServiceToYaml(service: RenderService): Record<string, unknown> {
+    const baseService: Record<string, unknown> = {
+        type: service.type === 'web_service' ? 'web' : service.type === 'background_worker' ? 'worker' : service.type,
+        name: service.name,
+        repo: service.repo,
+        autoDeploy: service.autoDeploy === 'yes',
+    };
+
+    // Add common fields
+    if (service.serviceDetails?.plan) {
+        baseService.plan = service.serviceDetails.plan;
+    }
+
+    if (service.serviceDetails?.region) {
+        baseService.region = service.serviceDetails.region;
+    }
+
+    // Determine runtime
+    if (service.serviceDetails?.runtime) {
+        baseService.runtime = service.serviceDetails.runtime;
+    } else if (service.serviceDetails?.env) {
+        baseService.runtime = service.serviceDetails.env;
+    }
+
+    if (service.rootDir) {
+        baseService.rootDir = service.rootDir;
+    }
+
+    // Type-specific fields from envSpecificDetails
+    const envDetails = service.serviceDetails?.envSpecificDetails;
+
+    if (envDetails?.buildCommand) {
+        baseService.buildCommand = envDetails.buildCommand;
+    }
+    if (envDetails?.startCommand) {
+        baseService.startCommand = envDetails.startCommand;
+    }
+    if (envDetails?.dockerCommand) {
+        baseService.dockerCommand = envDetails.dockerCommand;
+    }
+    if (envDetails?.dockerfilePath) {
+        baseService.dockerfilePath = envDetails.dockerfilePath;
+        baseService.dockerContext = '.';
+    }
+
+    if (service.serviceDetails?.healthCheckPath) {
+        baseService.healthCheckPath = service.serviceDetails.healthCheckPath;
+    }
+
+    if (service.serviceDetails?.publishPath) {
+        baseService.staticPublishPath = service.serviceDetails.publishPath;
+    }
+
+    return baseService;
+}
+
+async function main() {
+    try {
+        // Fetch current services from Render
+        const allServices = await fetchRenderServices();
+
+        // Filter out PR preview services and suspended services
+        const services = allServices.filter(s => {
+            // Exclude services with PR # in the name (previews)
+            if (s.name.includes(' PR #')) {
+                return false;
+            }
+            // Exclude suspended services
+            if ('suspended' in s && s.suspended && s.suspended !== 'not_suspended') {
+                return false;
+            }
+            // Exclude services from other repos (like website, ph-proxy, etc.)
+            if (!s.repo || !s.repo.includes('seadotdev/app')) {
+                return false;
+            }
+            return true;
+        });
+
+        console.log(`✅ Filtered to ${services.length} production services`);
+
+        const databases = await fetchRenderDatabases();
+
+        // Read current render.yaml
+        console.log('📖 Reading current render.yaml...');
+        const currentYaml = fs.readFileSync(RENDER_YAML_PATH, 'utf8');
+        const currentConfig = parse(currentYaml);
+
+        console.log('\n📊 Current services in YAML:');
+        currentConfig.services?.forEach((s: Record<string, unknown>) => {
+            console.log(`  - ${s.name} (${s.type})`);
+        });
+
+        console.log('\n📊 Deployed services on Render:');
+        services.forEach((s) => {
+            console.log(`  - ${s.name} (${s.type})`);
+        });
+
+        // Map services to YAML format
+        const mappedServices = services.map(mapServiceToYaml);
+
+        // Check if conversion-worker exists
+        const hasConversionWorker = services.some(s => s.name === 'conversion-worker');
+
+        if (!hasConversionWorker) {
+            console.log('\n⚠️  conversion-worker not found in deployed services');
+            console.log('You can add it by deploying from the Render dashboard or keeping it in YAML for next deploy');
+
+            // Keep the conversion-worker from current YAML if it exists
+            const currentConversionWorker = currentConfig.services?.find((s: Record<string, unknown>) => s.name === 'conversion-worker');
+            if (currentConversionWorker) {
+                mappedServices.push(currentConversionWorker);
+                console.log('✅ Kept conversion-worker from current YAML');
+            }
+        }
+
+        // Preserve env vars from current config (since API might not return all details)
+        const updatedServices = mappedServices.map((service: Record<string, unknown>) => {
+            const currentService = currentConfig.services?.find((s: Record<string, unknown>) => s.name === service.name);
+            if (currentService?.envVars) {
+                service.envVars = currentService.envVars;
+            }
+            if (currentService?.previews) {
+                service.previews = currentService.previews;
+            }
+            if (currentService?.preDeployCommand) {
+                service.preDeployCommand = currentService.preDeployCommand;
+            }
+            return service;
+        });
+
+        // Map databases from Render to YAML format
+        const updatedDatabases = databases.map((db: RenderDatabase) => ({
+            name: db.name,
+            postgresMajorVersion: db.version?.split('.')[0] || '16',
+            databaseName: db.databaseName,
+            region: db.region,
+            plan: db.plan,
+            user: db.user,
+        }));
+
+        console.log('\n📊 Database plans:');
+        updatedDatabases.forEach((db: { name: string; plan: string }) => {
+            const current = currentConfig.databases?.find((d: Record<string, unknown>) => d.name === db.name) as { plan?: string } | undefined;
+            if (current && current.plan !== db.plan) {
+                console.log(`  ⚠️  ${db.name}: ${current.plan} → ${db.plan}`);
+            } else {
+                console.log(`  ✓ ${db.name}: ${db.plan}`);
+            }
+        });
+
+        // Update the config
+        const updatedConfig = {
+            ...currentConfig,
+            databases: updatedDatabases,
+            services: updatedServices,
+        };
+
+        // Write back to render.yaml
+        console.log('\n💾 Updating render.yaml...');
+
+        const yamlContent = stringify(updatedConfig, {
+            lineWidth: 0,
+            defaultStringType: 'PLAIN',
+            defaultKeyType: 'PLAIN',
+        });
+
+        // Add the schema comment back
+        const finalContent = '# yaml-language-server: $schema=https://render.com/schema/render.yaml.json\n' + yamlContent;
+        fs.writeFileSync(RENDER_YAML_PATH, finalContent);
+
+        console.log('✅ render.yaml updated successfully!');
+        console.log('\n📝 Summary:');
+        console.log(`  - Services: ${updatedServices.length}`);
+        console.log(`  - Databases: ${databases.length}`);
+
+    } catch (error) {
+        console.error('❌ Error:', error);
+        process.exit(1);
+    }
+}
+
+main();

package/scripts/src/test-chat-stream.ts

@@ -0,0 +1,300 @@
+#!/usr/bin/env tsx
+/**
+ * Test script for streaming chat API endpoint.
+ * Tests the /v2/chat/form/{formId}/stream endpoint and formats the output
+ * similarly to the /send endpoint output.
+ *
+ * Usage:
+ *   SEA_API_KEY=your-key tsx scripts/test-chat-stream.ts
+ *
+ * Optional environment variables:
+ *   API_BASE_URL - defaults to http://localhost:10000
+ *   SEA_API_KEY  - required, your API key
+ */
+
+import * as readline from "node:readline";
+
+const API_BASE_URL = process.env.API_BASE_URL || "http://localhost:10000";
+const API_KEY = process.env.SEA_API_KEY;
+
+if (!API_KEY) {
+  console.error("Error: SEA_API_KEY environment variable not set");
+  process.exit(1);
+}
+
+const rl = readline.createInterface({
+  input: process.stdin,
+  output: process.stdout,
+});
+
+function question(prompt: string): Promise<string> {
+  return new Promise((resolve) => {
+    rl.question(prompt, resolve);
+  });
+}
+
+interface StreamEvent {
+  type: string;
+  messageId?: string;
+  textDelta?: string;
+  text?: string;
+  id?: string;
+  toolCallId?: string;
+  toolName?: string;
+  args?: unknown;
+  input?: unknown;
+  result?: unknown;
+  output?: unknown;
+  argsTextDelta?: string;
+  inputTextDelta?: string;
+  [key: string]: unknown;
+}
+
+interface MessagePart {
+  type: string;
+  text?: string;
+  state?: string;
+  toolCallId?: string;
+  input?: unknown;
+  output?: unknown;
+  errorText?: string;
+  [key: string]: unknown;
+}
+
+interface FormattedMessage {
+  id: string;
+  role: string;
+  parts: MessagePart[];
+}
+
+async function main() {
+  const formId = (await question("Enter form ID: ")).trim();
+  const message = (await question("Enter message (default: 'hello'): ")).trim() || "hello";
+
+  rl.close();
+
+  const url = `${API_BASE_URL}/v2/chat/form/${formId}/stream`;
+  const headers = {
+    Authorization: `Bearer ${API_KEY}`,
+    "Content-Type": "application/json",
+  };
+  const payload = { message };
+
+  console.log(`\nStreaming from: ${url}`);
+  console.log(`Message: ${message}\n`);
+  console.log("=".repeat(80));
+
+  try {
+    const response = await fetch(url, {
+      method: "POST",
+      headers,
+      body: JSON.stringify(payload),
+    });
+
+    if (!response.ok) {
+      const errorText = await response.text();
+      console.error(`Error: ${response.status}`);
+      console.error(errorText);
+      process.exit(1);
+    }
+
+    if (!response.body) {
+      console.error("Error: No response body");
+      process.exit(1);
+    }
+
+    // Track state to format output like the send endpoint
+    let messageId = "";
+    let currentText = "";
+    const parts: MessagePart[] = [];
+    const toolCallMap = new Map<string, { toolName: string; args: unknown }>();
+
+    // Process the SSE stream
+    const reader = response.body.getReader();
+    const decoder = new TextDecoder();
+    let buffer = "";
+
+    while (true) {
+      const { done, value } = await reader.read();
+      if (done) break;
+
+      buffer += decoder.decode(value, { stream: true });
+      const lines = buffer.split("\n");
+      buffer = lines.pop() || "";
+
+      for (const line of lines) {
+        if (line.startsWith("data: ") && line.length > 6) {
+          try {
+            const data: StreamEvent = JSON.parse(line.slice(6));
+
+            // Print raw event data
+            console.log(JSON.stringify(data));
+
+            switch (data.type) {
+              case "start":
+                if (data.messageId) {
+                  messageId = data.messageId;
+                }
+                break;
+
+              case "step-start":
+              case "start-step":
+                console.log("\n[Step started]");
+                break;
+
+              case "text-start":
+                currentText = "";
+                break;
+
+              case "text-delta":
+                if (data.textDelta) {
+                  currentText += data.textDelta;
+                  process.stdout.write(data.textDelta);
+                }
+                break;
+
+              case "text-end":
+                // Text part complete - add to parts
+                if (currentText) {
+                  parts.push({
+                    type: "text",
+                    text: currentText,
+                    state: "done",
+                  });
+                  currentText = ""; // Reset for next text part
+                }
+                break;
+
+              case "tool-input-start":
+                // Tool input streaming started
+                if (data.toolCallId && data.toolName) {
+                  console.log(`\n[Tool call: ${data.toolName}]`);
+                  toolCallMap.set(data.toolCallId, {
+                    toolName: data.toolName,
+                    args: {},
+                  });
+                }
+                break;
+
+              case "tool-input-delta":
+                // Tool input streaming (usually arguments being built)
+                // Just accumulate, we'll use tool-input-available for the final args
+                break;
+
+              case "tool-call":
+              case "tool-input-available":
+                // Tool call with complete args
+                if (data.toolCallId && data.toolName) {
+                  const finalInput = data.input || data.args;
+                  toolCallMap.set(data.toolCallId, {
+                    toolName: data.toolName,
+                    args: finalInput,
+                  });
+                  parts.push({
+                    type: `tool-${data.toolName}`,
+                    toolCallId: data.toolCallId,
+                    input: finalInput,
+                    state: "input-available",
+                  });
+                }
+                break;
+
+              case "tool-result":
+              case "tool-output-available":
+                // Tool result
+                if (data.toolCallId && data.toolName) {
+                  console.log(`\n[Tool result: ${data.toolName}]`);
+                  const toolCall = toolCallMap.get(data.toolCallId);
+                  const finalOutput = data.output || data.result;
+                  parts.push({
+                    type: `tool-${data.toolName}`,
+                    toolCallId: data.toolCallId,
+                    input: toolCall?.args,
+                    output: finalOutput,
+                    state: "output-available",
+                  });
+                }
+                break;
+
+              case "step-finish":
+              case "finish-step":
+                console.log("\n[Step finished]");
+                break;
+
+              case "finish":
+                // Stream complete
+                break;
+
+              case "error":
+                console.error("\n[Error]:", data);
+                break;
+
+              default:
+                // Log unexpected event types
+                const knownTypes = [
+                  "start",
+                  "text-start",
+                  "text-delta",
+                  "text-end",
+                  "tool-call",
+                  "tool-call-streaming-start",
+                  "tool-call-delta",
+                  "tool-result",
+                  "tool-input-start",
+                  "tool-input-delta",
+                  "tool-input-available",
+                  "tool-output-available",
+                  "step-start",
+                  "start-step",
+                  "step-finish",
+                  "finish-step",
+                  "finish",
+                  "error",
+                ];
+                if (!knownTypes.includes(data.type)) {
+                  console.log("\nUnexpected event:", data);
+                }
+            }
+          } catch (e) {
+            // Skip malformed JSON
+          }
+        }
+      }
+    }
+
+    const messages: FormattedMessage[] = [];
+    if (messageId && parts.length > 0) {
+      messages.push({
+        id: messageId,
+        role: "assistant",
+        parts,
+      });
+    }
+
+    console.log("\n" + "=".repeat(80));
+    console.log("Stream complete!\n");
+
+    // Display formatted output like send endpoint
+    if (messages.length > 0) {
+      console.log("Formatted response (like /send endpoint):");
+      const textParts = parts.filter((p) => p.type === "text");
+      const fullText = textParts.map((p) => p.text).join("\n");
+      console.log(JSON.stringify({ text: fullText || undefined, messages }, null, 2));
+    }
+  } catch (error) {
+    if (error instanceof Error) {
+      console.error(`Request error: ${error.message}`);
+    } else {
+      console.error("Request error:", error);
+    }
+    process.exit(1);
+  }
+}
+
+// Handle interrupts gracefully
+process.on("SIGINT", () => {
+  console.log("\n\nInterrupted by user");
+  process.exit(0);
+});
+
+main();