jettypod 4.4.120 → 4.4.121

package/apps/dashboard/lib/tauri-bridge.ts

@@ -0,0 +1,102 @@
+// Tauri IPC bridge for auth, project, Claude CLI, and shell operations.
+// Database operations are in data-bridge.ts.
+// Low-level primitives (invoke, isTauri, openShell, openDialog) live in lib/tauri.ts.
+
+import { invoke, isTauri, openShell, openDialog as tauriOpenDialog } from './tauri';
+
+export { isTauri };
+
+// Auth types
+export interface AuthUser {
+  email: string;
+  plan: string;
+  name?: string;
+}
+
+export interface AuthStatus {
+  authenticated: boolean;
+  user: AuthUser | null;
+}
+
+// Auth namespace
+export const auth = {
+  getStatus: () => invoke<AuthStatus>('auth_get_status'),
+  getToken: () => invoke<string | null>('auth_get_token'),
+  saveToken: (token: string, user: AuthUser) => invoke<void>('auth_save_token', { token, user }),
+  logout: () => invoke<void>('auth_logout'),
+  hasLoggedInBefore: () => invoke<boolean>('auth_has_logged_in_before'),
+  getPostLoginPath: () => invoke<string | null>('auth_get_post_login_path'),
+  setPostLoginPath: (path: string | null) => invoke<void>('auth_set_post_login_path', { path }),
+  loginWithGoogle: () => invoke<void>('auth_login_with_google'),
+};
+
+// Project types
+export interface RecentProject {
+  name: string;
+  path: string;
+}
+
+// Project namespace
+export const project = {
+  getRecent: () => invoke<RecentProject[]>('project_get_recent'),
+  addRecent: (name: string, path: string) => invoke<void>('project_add_recent', { name, path }),
+  async openDialog(): Promise<{ success: boolean; canceled?: boolean; error?: string }> {
+    let selected: string | string[] | null;
+    try {
+      selected = await tauriOpenDialog({ directory: true, title: 'Open JettyPod Project' });
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      console.error('Dialog open failed:', msg);
+      return { success: false, error: msg };
+    }
+    if (!selected || (Array.isArray(selected) && selected.length === 0)) {
+      return { success: false, canceled: true };
+    }
+    const projectPath = Array.isArray(selected) ? selected[0] : selected;
+    try {
+      await invoke('db_init', { projectPath });
+      const name = projectPath.split('/').pop() || projectPath;
+      await invoke('project_add_recent', { name, path: projectPath });
+      return { success: true };
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      console.error('Project init failed:', msg);
+      return { success: false, error: msg };
+    }
+  },
+  async newProject(): Promise<{ success: boolean; canceled?: boolean }> {
+    // Same as openDialog — user picks folder, we initialize it
+    return project.openDialog();
+  },
+  async openRecent(path: string): Promise<{ success: boolean }> {
+    try {
+      await invoke('db_init', { projectPath: path });
+      const name = path.split('/').pop() || path;
+      await invoke('project_add_recent', { name, path });
+      return { success: true };
+    } catch {
+      return { success: false };
+    }
+  },
+};
+
+// Claude CLI types
+export interface CliResult {
+  success: boolean;
+  error: string | null;
+  output: string | null;
+}
+
+// Claude CLI namespace
+export const claudeCode = {
+  isAuthenticated: () => invoke<boolean>('claude_code_is_authenticated'),
+  login: () => invoke<CliResult>('claude_code_login'),
+  install: () => invoke<CliResult>('claude_code_install'),
+  update: () => invoke<CliResult>('claude_code_update'),
+};
+
+// Shell namespace
+export const shell = {
+  openPath: (path: string) => openShell(path),
+  openUrl: (url: string) => openShell(url),
+};

package/apps/dashboard/lib/tauri.ts

@@ -0,0 +1,106 @@
+/**
+ * Canonical Tauri IPC bridge — single source of truth for all __TAURI__ access.
+ *
+ * Every module that needs Tauri globals (invoke, listen, shell, dialog)
+ * should import from this file instead of touching window.__TAURI__ directly.
+ */
+
+interface TauriGlobal {
+  core: {
+    invoke<T>(cmd: string, args?: Record<string, unknown>): Promise<T>;
+  };
+  shell: {
+    open: (path: string) => Promise<void>;
+  };
+  dialog: {
+    open: (options?: {
+      directory?: boolean;
+      multiple?: boolean;
+      title?: string;
+    }) => Promise<string | string[] | null>;
+  };
+  event: {
+    listen: <T>(
+      event: string,
+      handler: (event: { payload: T }) => void
+    ) => Promise<() => void>;
+  };
+}
+
+function getTauri(): TauriGlobal {
+  return (window as any).__TAURI__;
+}
+
+/** Returns true when running inside a Tauri webview. */
+export function isTauri(): boolean {
+  return !!(window as any).__TAURI__;
+}
+
+/** Invoke a Tauri IPC command. */
+export async function invoke<T>(
+  cmd: string,
+  args?: Record<string, unknown>
+): Promise<T> {
+  return getTauri().core.invoke(cmd, args);
+}
+
+/** Listen for a Tauri event. Returns an unlisten function. */
+export async function listen<T>(
+  event: string,
+  handler: (event: { payload: T }) => void
+): Promise<() => void> {
+  return getTauri().event.listen(event, handler);
+}
+
+/** Invoke a Tauri IPC command with a timeout. Rejects if the call doesn't resolve within timeoutMs. */
+export async function invokeWithTimeout<T>(
+  cmd: string,
+  args?: Record<string, unknown>,
+  timeoutMs: number = 10000
+): Promise<T> {
+  return Promise.race([
+    invoke<T>(cmd, args),
+    new Promise<never>((_, reject) =>
+      setTimeout(() => reject(new Error(`IPC timeout after ${timeoutMs}ms: ${cmd}`)), timeoutMs)
+    ),
+  ]);
+}
+
+// ─── Shell command result type ──────────────────────────────
+
+export interface ShellCommandResult {
+  stdout: string;
+  stderr: string;
+  exit_code: number | null;
+}
+
+/**
+ * Run a shell command and return its output.
+ * Used by service recovery for pre-flight checks and remedies.
+ */
+export async function runShellCommand(
+  command: string,
+  args: string[],
+  options?: { cwd?: string; timeoutMs?: number }
+): Promise<ShellCommandResult> {
+  return invoke<ShellCommandResult>('run_shell_command', {
+    command,
+    args,
+    cwd: options?.cwd ?? null,
+    timeoutMs: options?.timeoutMs ?? null,
+  });
+}
+
+/** Open a path or URL via the system shell. */
+export function openShell(path: string): Promise<void> {
+  return getTauri().shell.open(path);
+}
+
+/** Open a native file/directory dialog. */
+export function openDialog(options?: {
+  directory?: boolean;
+  multiple?: boolean;
+  title?: string;
+}): Promise<string | string[] | null> {
+  return getTauri().dialog.open(options);
+}

package/apps/dashboard/lib/utils.ts

@@ -5,8 +5,8 @@ export function cn(...inputs: ClassValue[]) {
   return twMerge(clsx(inputs))
 }
 
+export const WS_PORT = 47808;
+
 export function getWebSocketUrl(): string {
-  return typeof window !== 'undefined'
-    ? `ws://${window.location.hostname}:47808`
-    : 'ws://localhost:47808';
+  return `ws://${window.location.hostname}:${WS_PORT}`;
 }

package/apps/dashboard/next-env.d.ts

@@ -1,6 +1,6 @@
 /// <reference types="next" />
 /// <reference types="next/image-types/global" />
-import "./.next/types/routes.d.ts";
+import "./.next/dev/types/routes.d.ts";
 
 // NOTE: This file should not be edited
 // see https://nextjs.org/docs/app/api-reference/config/typescript for more information.

package/apps/dashboard/package.json

@@ -1,59 +1,47 @@
 {
   "name": "dashboard",
-  "version": "4.4.120",
+  "version": "4.4.121",
   "private": true,
-  "main": "electron/main.js",
   "scripts": {
-    "dev": "concurrently -n next,ws -c blue,green \"next dev --webpack\" \"node scripts/ws-server.js\"",
-    "build": "next build --webpack",
-    "start": "next start",
+    "dev": "vite",
+    "build": "vite build",
+    "preview": "vite preview",
     "lint": "eslint",
-    "preelectron:dev": "npm rebuild better-sqlite3 --silent",
-    "electron:dev": "electron .",
-    "prebuild:node": "node scripts/download-node.js",
-    "electron:build": "npm run prebuild:node && npm run build && npx electron-builder --config electron-builder.config.js",
-    "electron:build:mac": "npm run prebuild:node && npm run build && npx electron-builder --config electron-builder.config.js --mac",
-    "electron:build:mac:arm64": "npm run build && npx electron-builder --config electron-builder.config.js --mac --arm64",
-    "electron:build:mac:x64": "npm run build && npx electron-builder --config electron-builder.config.js --mac --x64",
-    "electron:build:mac:universal": "npm run build && npx electron-builder --config electron-builder.config.js --mac --universal",
-    "electron:build:win": "npm run build && npx electron-builder --config electron-builder.config.js --win",
-    "electron:build:linux": "npm run build && npx electron-builder --config electron-builder.config.js --linux",
-    "electron:pack": "npm run build && npx electron-builder --config electron-builder.config.js --dir",
-    "upload:r2": "node scripts/upload-to-r2.js",
-    "electron:release": "npm run electron:build:mac && npm run upload:r2"
+    "tauri:dev": "cargo tauri dev",
+    "tauri:build": "node scripts/tauri-build.js",
+    "tauri:build:release": "node scripts/tauri-build.js --release",
+    "tauri:build:arm64": "node scripts/tauri-build.js --release --target=arm64",
+    "tauri:build:x64": "node scripts/tauri-build.js --release --target=x64",
+    "tauri:build:universal": "node scripts/tauri-build.js --release --target=universal",
+    "tauri:release": "node scripts/tauri-build.js --release --upload",
+    "upload:tauri:r2": "node scripts/upload-tauri-to-r2.js"
   },
   "dependencies": {
     "@dnd-kit/core": "^6.3.1",
     "@dnd-kit/sortable": "^10.0.0",
-    "@dnd-kit/utilities": "^3.2.2",
-    "@tailwindcss/typography": "^0.5.19",
-    "better-sqlite3": "^12.5.0",
+    "@fontsource-variable/geist-mono": "^5.2.7",
+    "@tanstack/react-virtual": "^3.13.19",
     "class-variance-authority": "^0.7.1",
     "clsx": "^2.1.1",
-    "electron-updater": "^6.3.9",
+    "eventemitter3": "^5.0.4",
     "framer-motion": "^11.15.0",
-    "lucide-react": "^0.555.0",
-    "next": "16.0.6",
     "react": "19.2.0",
     "react-dom": "19.2.0",
     "react-markdown": "^10.1.0",
+    "react-router-dom": "^7.13.0",
     "remark-gfm": "^4.0.1",
-    "tailwind-merge": "^3.4.0",
-    "ws": "^8.19.0"
+    "tailwind-merge": "^3.4.0"
   },
   "devDependencies": {
-    "@tailwindcss/postcss": "^4",
-    "@types/better-sqlite3": "^7.6.13",
+    "@tailwindcss/vite": "^4.2.0",
     "@types/node": "^20",
     "@types/react": "^19",
     "@types/react-dom": "^19",
-    "concurrently": "^9.2.1",
-    "electron": "^32.0.0",
-    "electron-builder": "^26.4.0",
+    "@vitejs/plugin-react-swc": "^4.2.3",
     "eslint": "^9",
-    "eslint-config-next": "16.0.6",
     "tailwindcss": "^4",
     "tw-animate-css": "^1.4.0",
-    "typescript": "5.9.3"
+    "typescript": "5.9.3",
+    "vite": "^7.3.1"
   }
 }

package/apps/dashboard/scripts/tauri-build.js

@@ -0,0 +1,228 @@
+#!/usr/bin/env node
+
+/**
+ * Tauri Build Script
+ *
+ * Orchestrates the Tauri release build:
+ * 1. Validates prerequisites (cargo-tauri, signing keys)
+ * 2. Builds the Vite frontend
+ * 3. Runs `cargo tauri build` with code signing
+ * 4. Optionally uploads to R2
+ *
+ * Usage:
+ *   node scripts/tauri-build.js [--release] [--upload] [--target arm64|x64|universal]
+ *
+ * Environment variables:
+ *   APPLE_SIGNING_IDENTITY  - Code signing identity (default: "-" for ad-hoc)
+ *   APPLE_TEAM_ID           - Apple Developer Team ID (enables notarization)
+ *   APPLE_ID                - Apple ID email (for notarization)
+ *   APPLE_PASSWORD          - App-specific password (for notarization)
+ *   TAURI_SIGNING_PRIVATE_KEY     - Ed25519 private key for update signing
+ *   TAURI_SIGNING_PRIVATE_KEY_PASSWORD - Password for the signing key
+ */
+
+const { execSync, spawnSync } = require('child_process');
+const fs = require('fs');
+const path = require('path');
+
+const ROOT = path.resolve(__dirname, '..');
+const TAURI_DIR = path.join(ROOT, 'src-tauri');
+const TAURI_CONF = path.join(TAURI_DIR, 'tauri.conf.json');
+const TAURI_PROD_CONF = path.join(TAURI_DIR, 'tauri.prod.conf.json');
+// Cargo uses the workspace-level target/ directory (repo root), not src-tauri/target/
+const WORKSPACE_ROOT = path.resolve(ROOT, '..', '..');
+
+// ---------------------------------------------------------------------------
+// Argument parsing
+// ---------------------------------------------------------------------------
+
+const args = process.argv.slice(2);
+const isRelease = args.includes('--release');
+const doUpload = args.includes('--upload');
+const targetArg = args.find(a => a.startsWith('--target='));
+const target = targetArg ? targetArg.split('=')[1] : null;
+
+// ---------------------------------------------------------------------------
+// Validation
+// ---------------------------------------------------------------------------
+
+function check(label, fn) {
+  process.stdout.write(`  ${label}... `);
+  try {
+    const result = fn();
+    console.log('✅');
+    return result;
+  } catch (e) {
+    console.log('❌');
+    console.error(`    ${e.message}`);
+    process.exit(1);
+  }
+}
+
+function validate() {
+  console.log('\n🔍 Validating prerequisites:\n');
+
+  check('cargo-tauri CLI', () => {
+    try {
+      execSync('cargo tauri --version 2>/dev/null', { stdio: 'pipe', env: { ...process.env, PATH: `${process.env.HOME}/.cargo/bin:${process.env.PATH}` } });
+    } catch {
+      throw new Error('cargo-tauri not found. Install with: cargo install tauri-cli');
+    }
+  });
+
+  check('Rust toolchain', () => {
+    try {
+      execSync('rustc --version 2>/dev/null', { stdio: 'pipe', env: { ...process.env, PATH: `${process.env.HOME}/.cargo/bin:${process.env.PATH}` } });
+    } catch {
+      throw new Error('Rust not found. Install from https://rustup.rs');
+    }
+  });
+
+  check('tauri.conf.json', () => {
+    if (!fs.existsSync(TAURI_CONF)) {
+      throw new Error(`Missing ${TAURI_CONF}`);
+    }
+  });
+
+  if (isRelease) {
+    check('Signing identity', () => {
+      const identity = process.env.APPLE_SIGNING_IDENTITY;
+      if (!identity || identity === '-') {
+        console.log('\n    ⚠️  Using ad-hoc signing. Set APPLE_SIGNING_IDENTITY for production.');
+      }
+    });
+
+    if (process.env.APPLE_TEAM_ID) {
+      check('Notarization credentials', () => {
+        if (!process.env.APPLE_ID) throw new Error('APPLE_ID required for notarization');
+        if (!process.env.APPLE_PASSWORD) throw new Error('APPLE_PASSWORD required for notarization');
+      });
+    }
+
+    check('Update signing key', () => {
+      if (!process.env.TAURI_SIGNING_PRIVATE_KEY) {
+        console.log('\n    ⚠️  No TAURI_SIGNING_PRIVATE_KEY set. Updates won\'t be signed.');
+      }
+    });
+  }
+}
+
+// ---------------------------------------------------------------------------
+// Build steps
+// ---------------------------------------------------------------------------
+
+function runCommand(label, cmd, opts = {}) {
+  console.log(`\n📦 ${label}...`);
+  const env = {
+    ...process.env,
+    PATH: `${process.env.HOME}/.cargo/bin:${process.env.PATH}`,
+  };
+
+  const result = spawnSync('sh', ['-c', cmd], {
+    stdio: 'inherit',
+    cwd: opts.cwd || ROOT,
+    env,
+  });
+
+  if (result.status !== 0) {
+    console.error(`\n❌ ${label} failed (exit code ${result.status})`);
+    process.exit(1);
+  }
+}
+
+function updateSigningIdentity() {
+  // Pass signing identity via APPLE_SIGNING_IDENTITY env var.
+  // Tauri reads this automatically — no need to mutate tauri.conf.json.
+  const identity = process.env.APPLE_SIGNING_IDENTITY;
+  if (identity && identity !== '-') {
+    console.log(`  Using signing identity: ${identity}`);
+  } else {
+    console.log('  Using ad-hoc signing (no APPLE_SIGNING_IDENTITY set)');
+  }
+}
+
+function buildTauri() {
+  let buildCmd = 'cargo tauri build';
+
+  if (target === 'universal') {
+    buildCmd += ' --target universal-apple-darwin';
+  } else if (target === 'arm64') {
+    buildCmd += ' --target aarch64-apple-darwin';
+  } else if (target === 'x64') {
+    buildCmd += ' --target x86_64-apple-darwin';
+  }
+
+  // Apply production config overlay for release builds
+  if (isRelease && fs.existsSync(TAURI_PROD_CONF)) {
+    buildCmd += ` --config "${TAURI_PROD_CONF}"`;
+    console.log('  Applying production config overlay (JettyPod name + clean icon)');
+  }
+
+  // Pass signing key via environment
+  const extraEnv = [];
+  if (process.env.TAURI_SIGNING_PRIVATE_KEY) {
+    extraEnv.push('TAURI_SIGNING_PRIVATE_KEY');
+  }
+  if (process.env.TAURI_SIGNING_PRIVATE_KEY_PASSWORD) {
+    extraEnv.push('TAURI_SIGNING_PRIVATE_KEY_PASSWORD');
+  }
+
+  runCommand('Building Tauri app', buildCmd, { cwd: TAURI_DIR });
+}
+
+function showArtifacts() {
+  const targetDir = path.join(WORKSPACE_ROOT, 'target');
+  // When cross-compiling, bundles go under target/{triple}/release/bundle/
+  const candidates = [
+    path.join(targetDir, 'release', 'bundle'),
+    path.join(targetDir, 'x86_64-apple-darwin', 'release', 'bundle'),
+    path.join(targetDir, 'aarch64-apple-darwin', 'release', 'bundle'),
+    path.join(targetDir, 'universal-apple-darwin', 'release', 'bundle'),
+  ];
+  const bundleDir = candidates.find(d => fs.existsSync(d)) || path.join(targetDir, 'release', 'bundle');
+
+  console.log('\n✅ Build complete! Artifacts:');
+
+  // Check for DMG files
+  const dmgDir = path.join(bundleDir, 'dmg');
+  if (fs.existsSync(dmgDir)) {
+    const dmgs = fs.readdirSync(dmgDir).filter(f => f.endsWith('.dmg'));
+    dmgs.forEach(f => {
+      const size = (fs.statSync(path.join(dmgDir, f)).size / 1024 / 1024).toFixed(1);
+      console.log(`  📀 ${f} (${size} MB)`);
+    });
+  }
+
+  // Check for app bundle
+  const macosDir = path.join(bundleDir, 'macos');
+  if (fs.existsSync(macosDir)) {
+    const apps = fs.readdirSync(macosDir).filter(f => f.endsWith('.app'));
+    apps.forEach(f => {
+      console.log(`  📱 ${f}`);
+    });
+  }
+}
+
+// ---------------------------------------------------------------------------
+// Main
+// ---------------------------------------------------------------------------
+
+console.log('🚀 JettyPod Tauri Build');
+console.log(`   Mode: ${isRelease ? 'RELEASE' : 'DEBUG'}`);
+console.log(`   Target: ${target || 'native'}`);
+console.log(`   Upload: ${doUpload ? 'yes' : 'no'}`);
+
+validate();
+
+if (isRelease) {
+  updateSigningIdentity();
+}
+
+buildTauri();
+showArtifacts();
+
+if (doUpload) {
+  runCommand('Uploading to R2', 'node scripts/upload-tauri-to-r2.js');
+}
+
+console.log('\n🎉 Done!\n');

package/apps/dashboard/scripts/upload-tauri-to-r2.js

@@ -0,0 +1,125 @@
+#!/usr/bin/env node
+
+/**
+ * Upload Tauri release artifacts to Cloudflare R2.
+ * Run after tauri build: node scripts/upload-tauri-to-r2.js
+ *
+ * Requires wrangler login or CLOUDFLARE_API_TOKEN env var.
+ *
+ * Uploads DMG and update signature files to R2 under the
+ * tauri/ prefix, organized by target/arch for the updater endpoint.
+ */
+
+const { execSync } = require('child_process');
+const fs = require('fs');
+const path = require('path');
+
+const BUCKET_NAME = 'jettypod-releases';
+// Cargo uses the workspace-level target/ directory (repo root), not src-tauri/target/
+const WORKSPACE_ROOT = path.resolve(__dirname, '..', '..', '..');
+const TARGET_DIR = path.join(WORKSPACE_ROOT, 'target');
+
+// Tauri puts release bundles under target/release/bundle/
+// or target/{triple}/release/bundle/ for cross-compilation
+function findBundleDir() {
+  const candidates = [
+    path.join(TARGET_DIR, 'release', 'bundle'),
+    path.join(TARGET_DIR, 'aarch64-apple-darwin', 'release', 'bundle'),
+    path.join(TARGET_DIR, 'x86_64-apple-darwin', 'release', 'bundle'),
+    path.join(TARGET_DIR, 'universal-apple-darwin', 'release', 'bundle'),
+  ];
+
+  for (const dir of candidates) {
+    if (fs.existsSync(dir)) return dir;
+  }
+
+  return null;
+}
+
+function findArtifacts(bundleDir) {
+  const artifacts = [];
+
+  // DMG files
+  const dmgDir = path.join(bundleDir, 'dmg');
+  if (fs.existsSync(dmgDir)) {
+    for (const f of fs.readdirSync(dmgDir)) {
+      if (f.endsWith('.dmg')) {
+        artifacts.push({ name: f, path: path.join(dmgDir, f), type: 'dmg' });
+      }
+    }
+  }
+
+  // Update signature files (.tar.gz and .sig for Tauri updater)
+  const macosDir = path.join(bundleDir, 'macos');
+  if (fs.existsSync(macosDir)) {
+    for (const f of fs.readdirSync(macosDir)) {
+      if (f.endsWith('.tar.gz') || f.endsWith('.tar.gz.sig')) {
+        artifacts.push({ name: f, path: path.join(macosDir, f), type: 'update' });
+      }
+    }
+  }
+
+  return artifacts;
+}
+
+function uploadFile(artifact, r2Key) {
+  const stats = fs.statSync(artifact.path);
+  const sizeMB = (stats.size / (1024 * 1024)).toFixed(1);
+
+  process.stdout.write(`  ${r2Key} (${sizeMB} MB)... `);
+
+  try {
+    execSync(
+      `npx wrangler r2 object put "${BUCKET_NAME}/${r2Key}" --file="${artifact.path}" --remote`,
+      { stdio: 'pipe' }
+    );
+    console.log('✅');
+    return true;
+  } catch (error) {
+    console.log('❌');
+    console.error(`    ${error.message}`);
+    return false;
+  }
+}
+
+function main() {
+  console.log('🚀 Uploading Tauri release artifacts to R2...\n');
+
+  const bundleDir = findBundleDir();
+  if (!bundleDir) {
+    console.error('❌ No Tauri bundle directory found.');
+    console.error('Run `cargo tauri build` first.');
+    process.exit(1);
+  }
+
+  console.log(`Bundle dir: ${bundleDir}\n`);
+
+  const artifacts = findArtifacts(bundleDir);
+  if (artifacts.length === 0) {
+    console.error('❌ No release artifacts found.');
+    process.exit(1);
+  }
+
+  console.log(`Found ${artifacts.length} artifact(s):\n`);
+
+  let success = 0;
+  let failed = 0;
+
+  for (const artifact of artifacts) {
+    // Upload under tauri/ prefix for organization
+    const r2Key = `tauri/${artifact.name}`;
+    if (uploadFile(artifact, r2Key)) {
+      success++;
+    } else {
+      failed++;
+    }
+  }
+
+  console.log(`\n📦 Upload complete: ${success} uploaded, ${failed} failed`);
+
+  if (failed > 0) {
+    process.exit(1);
+  }
+}
+
+main();