rush-ai 0.3.1 → 0.4.0

package/dist/index.js

@@ -33,7 +33,7 @@ import {
 } from "./chunk-UJLVFMWM.js";
 
 // src/index.ts
-import chalk6 from "chalk";
+import chalk8 from "chalk";
 import { Command } from "commander";
 
 // src/output/formatters/csv.ts
@@ -286,7 +286,7 @@ function getApiBaseUrl() {
 async function loginViaBrowser(jsonMode) {
   const baseUrl = getApiBaseUrl();
   const state = randomBytes(16).toString("hex");
-  return new Promise((resolve7, reject) => {
+  return new Promise((resolve9, reject) => {
     const server = createServer(async (req, res) => {
       try {
         const url = new URL(req.url ?? "/", "http://localhost");
@@ -299,12 +299,13 @@ async function loginViaBrowser(jsonMode) {
         const returnedState = url.searchParams.get("state");
         const error = url.searchParams.get("error");
         if (error) {
-          const desc = url.searchParams.get("error_description") ?? "Authentication failed";
+          const desc = url.searchParams.get("error_description") ?? "\u8BA4\u8BC1\u5931\u8D25";
           res.writeHead(200, { "Content-Type": "text/html" });
           res.end(
             getHtmlPage(
-              "Authentication Failed",
-              `Error: ${desc}. You can close this window.`
+              "\u8BA4\u8BC1\u5931\u8D25",
+              `\u9519\u8BEF\uFF1A${desc}\u3002\u4F60\u53EF\u4EE5\u5173\u95ED\u6B64\u9875\u9762\u3002`,
+              baseUrl
             )
           );
           server.close();
@@ -315,8 +316,9 @@ async function loginViaBrowser(jsonMode) {
           res.writeHead(400, { "Content-Type": "text/html" });
           res.end(
             getHtmlPage(
-              "Authentication Failed",
-              "Invalid callback parameters. You can close this window."
+              "\u8BA4\u8BC1\u5931\u8D25",
+              "\u56DE\u8C03\u53C2\u6570\u65E0\u6548\uFF0C\u8BF7\u91CD\u65B0\u767B\u5F55\u3002\u4F60\u53EF\u4EE5\u5173\u95ED\u6B64\u9875\u9762\u3002",
+              baseUrl
             )
           );
           server.close();
@@ -336,8 +338,9 @@ async function loginViaBrowser(jsonMode) {
           res.writeHead(200, { "Content-Type": "text/html" });
           res.end(
             getHtmlPage(
-              "Authentication Failed",
-              "Token exchange failed. You can close this window."
+              "\u8BA4\u8BC1\u5931\u8D25",
+              "Token \u4EA4\u6362\u5931\u8D25\uFF0C\u8BF7\u91CD\u8BD5\u3002\u4F60\u53EF\u4EE5\u5173\u95ED\u6B64\u9875\u9762\u3002",
+              baseUrl
             )
           );
           server.close();
@@ -356,8 +359,10 @@ async function loginViaBrowser(jsonMode) {
         res.writeHead(200, { "Content-Type": "text/html" });
         res.end(
           getHtmlPage(
-            "Authentication Successful",
-            "You are now logged in. You can close this window and return to the terminal."
+            "\u8BA4\u8BC1\u6210\u529F",
+            "\u4F60\u5DF2\u6210\u529F\u767B\u5F55\uFF0C\u53EF\u4EE5\u5173\u95ED\u6B64\u9875\u9762\u5E76\u8FD4\u56DE\u7EC8\u7AEF\u3002",
+            baseUrl,
+            expiresAt ?? void 0
           )
         );
         server.close();
@@ -377,7 +382,7 @@ async function loginViaBrowser(jsonMode) {
             );
           }
         }
-        resolve7();
+        resolve9();
       } catch (err) {
         server.close();
         reject(
@@ -415,21 +420,37 @@ async function loginViaBrowser(jsonMode) {
 function escapeHtml(text) {
   return text.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&#x27;");
 }
-function getHtmlPage(title, message) {
+function getHtmlPage(title, message, serverUrl, expiresAt) {
+  const metaLines = [
+    `<span class="label">\u670D\u52A1\u5668</span> <span class="value">${escapeHtml(serverUrl)}</span>`
+  ];
+  if (expiresAt) {
+    metaLines.push(
+      `<span class="label">\u6709\u6548\u671F\u81F3</span> <span class="value">${escapeHtml(new Date(expiresAt).toLocaleString("zh-CN"))}</span>`
+    );
+  }
+  const metaHtml = metaLines.map((line) => `<div class="meta-row">${line}</div>`).join("\n    ");
   return `<!DOCTYPE html>
-<html>
-<head><title>Rush CLI - ${escapeHtml(title)}</title>
+<html lang="zh-CN">
+<head><meta charset="utf-8"><title>Rush CLI - ${escapeHtml(title)}</title>
 <style>
-  body { font-family: -apple-system, BlinkMacSystemFont, sans-serif; display: flex; align-items: center; justify-content: center; height: 100vh; margin: 0; background: #f5f5f5; }
-  .card { background: white; border-radius: 12px; padding: 40px; box-shadow: 0 2px 10px rgba(0,0,0,0.1); text-align: center; max-width: 400px; }
-  h1 { color: #333; font-size: 1.5em; }
+  body { font-family: -apple-system, BlinkMacSystemFont, "PingFang SC", "Microsoft YaHei", sans-serif; display: flex; align-items: center; justify-content: center; height: 100vh; margin: 0; background: #f5f5f5; }
+  .card { background: white; border-radius: 12px; padding: 40px; box-shadow: 0 2px 10px rgba(0,0,0,0.1); text-align: center; max-width: 420px; }
+  h1 { color: #333; font-size: 1.5em; margin-bottom: 8px; }
   p { color: #666; line-height: 1.6; }
+  .meta { margin-top: 16px; padding-top: 16px; border-top: 1px solid #eee; text-align: left; }
+  .meta-row { color: #888; font-size: 0.85em; line-height: 2; }
+  .meta-row .label { color: #999; }
+  .meta-row .value { color: #555; font-family: "SF Mono", Menlo, monospace; }
 </style>
 </head>
 <body>
   <div class="card">
     <h1>${escapeHtml(title)}</h1>
     <p>${escapeHtml(message)}</p>
+    <div class="meta">
+    ${metaHtml}
+    </div>
   </div>
 </body>
 </html>`;
@@ -571,11 +592,458 @@ function registerAuthCommand(program) {
   });
 }
 
+// src/commands/check/index.ts
+import { resolve } from "path";
+import chalk2 from "chalk";
+
+// src/commands/check/checks/database.ts
+import { existsSync, readFileSync } from "fs";
+import { join } from "path";
+var PLACEHOLDER_PATTERNS = [
+  "your-",
+  "placeholder",
+  "xxx",
+  "example",
+  "<",
+  ">",
+  "${",
+  "todo"
+];
+function isPlaceholder(value) {
+  const lower = value.toLowerCase();
+  return PLACEHOLDER_PATTERNS.some((p) => lower.includes(p));
+}
+function parseEnvFile(filePath) {
+  if (!existsSync(filePath)) return {};
+  try {
+    const content = readFileSync(filePath, "utf-8");
+    const vars = {};
+    for (const line of content.split("\n")) {
+      const trimmed = line.trim();
+      if (!trimmed || trimmed.startsWith("#")) continue;
+      const match = trimmed.match(/^([^=]+)=(.*)$/);
+      if (match) vars[match[1]] = match[2];
+    }
+    return vars;
+  } catch {
+    return {};
+  }
+}
+function checkDatabase(projectPath, framework) {
+  const defaultInfo = {
+    detected: false,
+    type: null,
+    autoCreate: false
+  };
+  if (framework !== "nextjs") {
+    return {
+      checks: [],
+      info: defaultInfo
+    };
+  }
+  const checks = [];
+  const envVars = parseEnvFile(join(projectPath, ".env.local"));
+  const postgresUrl = envVars.USER_POSTGRESQL_URL;
+  if (postgresUrl && !isPlaceholder(postgresUrl) && (postgresUrl.startsWith("postgresql://") || postgresUrl.startsWith("postgres://"))) {
+    checks.push({
+      name: "database_config",
+      severity: "info",
+      message: "Valid PostgreSQL config found in .env.local \u2014 Rush will use your existing database"
+    });
+    return {
+      checks,
+      info: { detected: true, type: "postgresql", autoCreate: false }
+    };
+  }
+  const supabaseUrl = envVars.SUPABASE_URL;
+  const supabaseKey = envVars.SUPABASE_SERVICE_ROLE_KEY || envVars.SUPABASE_KEY;
+  if (supabaseUrl && supabaseKey && !isPlaceholder(supabaseUrl) && !isPlaceholder(supabaseKey) && supabaseUrl.startsWith("https://") && supabaseKey.length > 20) {
+    checks.push({
+      name: "database_config",
+      severity: "info",
+      message: "Valid Supabase config found in .env.local \u2014 Rush will use your existing database"
+    });
+    return {
+      checks,
+      info: { detected: true, type: "supabase", autoCreate: false }
+    };
+  }
+  const hasPlaceholder = postgresUrl && isPlaceholder(postgresUrl) || supabaseUrl && isPlaceholder(supabaseUrl);
+  if (hasPlaceholder) {
+    checks.push({
+      name: "database_config",
+      severity: "warning",
+      message: "Database env vars in .env.local contain placeholder values \u2014 Rush will auto-create a Supabase database and overwrite them",
+      fix: "Either set real database credentials or remove the placeholder values"
+    });
+  } else {
+    checks.push({
+      name: "database_config",
+      severity: "info",
+      message: "No database config detected \u2014 Rush will auto-create a Supabase database for this Next.js project"
+    });
+  }
+  return {
+    checks,
+    info: { detected: false, type: null, autoCreate: true }
+  };
+}
+
+// src/commands/check/checks/framework.ts
+import { existsSync as existsSync2, readFileSync as readFileSync2 } from "fs";
+import { join as join2 } from "path";
+var NEXT_CONFIG_FILES = [
+  "next.config.js",
+  "next.config.ts",
+  "next.config.mjs"
+];
+var VITE_CONFIG_FILES = ["vite.config.ts", "vite.config.js"];
+function detectFramework(projectPath) {
+  const pkgPath = join2(projectPath, "package.json");
+  if (!existsSync2(pkgPath)) return "unknown";
+  try {
+    const raw = JSON.parse(readFileSync2(pkgPath, "utf-8"));
+    const deps = { ...raw.dependencies, ...raw.devDependencies };
+    if (deps.next) return "nextjs";
+    if (deps.vite || VITE_CONFIG_FILES.some((f) => existsSync2(join2(projectPath, f)))) {
+      return "vite";
+    }
+    return "unknown";
+  } catch {
+    return "unknown";
+  }
+}
+function checkFramework(projectPath) {
+  const checks = [];
+  const framework = detectFramework(projectPath);
+  checks.push({
+    name: "framework_detected",
+    severity: "info",
+    message: `Detected framework: ${framework}`
+  });
+  if (framework === "nextjs") {
+    const hasConfig = NEXT_CONFIG_FILES.some(
+      (f) => existsSync2(join2(projectPath, f))
+    );
+    if (!hasConfig) {
+      checks.push({
+        name: "config_file",
+        severity: "warning",
+        message: "No next.config.js/ts/mjs found",
+        fix: "Create a next.config.js file"
+      });
+    }
+  } else if (framework === "vite") {
+    const hasConfig = VITE_CONFIG_FILES.some(
+      (f) => existsSync2(join2(projectPath, f))
+    );
+    if (hasConfig) {
+      checks.push({
+        name: "config_file",
+        severity: "info",
+        message: "Vite config file found"
+      });
+    }
+    if (existsSync2(join2(projectPath, "index.html"))) {
+      checks.push({
+        name: "index_html",
+        severity: "info",
+        message: "index.html found (Vite entry point)"
+      });
+    } else {
+      checks.push({
+        name: "index_html",
+        severity: "warning",
+        message: "index.html not found \u2014 Vite projects typically need this as entry point",
+        fix: "Create an index.html at the project root"
+      });
+    }
+  }
+  return checks;
+}
+
+// src/commands/check/checks/lock-file.ts
+import { existsSync as existsSync3 } from "fs";
+import { join as join3 } from "path";
+function detectPackageManager(projectPath) {
+  if (existsSync3(join3(projectPath, "pnpm-lock.yaml"))) return "pnpm";
+  if (existsSync3(join3(projectPath, "yarn.lock"))) return "yarn";
+  if (existsSync3(join3(projectPath, "package-lock.json"))) return "npm";
+  return null;
+}
+function checkLockFile(projectPath) {
+  const checks = [];
+  const pm = detectPackageManager(projectPath);
+  if (pm) {
+    checks.push({
+      name: "lock_file_exists",
+      severity: "info",
+      message: `Package manager: ${pm}`
+    });
+  } else {
+    checks.push({
+      name: "lock_file_exists",
+      severity: "warning",
+      message: "No lock file found (pnpm-lock.yaml, yarn.lock, or package-lock.json)",
+      fix: "Run `npm install` to generate package-lock.json",
+      autoFixable: true
+    });
+  }
+  return checks;
+}
+
+// src/commands/check/checks/package-json.ts
+import { existsSync as existsSync4, readFileSync as readFileSync3 } from "fs";
+import { join as join4 } from "path";
+function readPackageJson(projectPath) {
+  const pkgPath = join4(projectPath, "package.json");
+  if (!existsSync4(pkgPath)) {
+    return { exists: false };
+  }
+  try {
+    const raw = JSON.parse(readFileSync3(pkgPath, "utf-8"));
+    return {
+      exists: true,
+      scripts: raw.scripts,
+      dependencies: raw.dependencies,
+      devDependencies: raw.devDependencies
+    };
+  } catch {
+    return { exists: false };
+  }
+}
+function checkPackageJson(projectPath) {
+  const checks = [];
+  const pkg = readPackageJson(projectPath);
+  if (!pkg.exists) {
+    checks.push({
+      name: "package_json_exists",
+      severity: "error",
+      message: "package.json not found",
+      fix: "Run `npm init -y` to create one"
+    });
+    return checks;
+  }
+  if (!pkg.scripts?.dev) {
+    checks.push({
+      name: "scripts_dev",
+      severity: "error",
+      message: 'Missing "dev" script in package.json',
+      fix: 'Add a dev script (e.g., "dev": "vite" or "dev": "next dev")',
+      autoFixable: true
+    });
+  }
+  if (!pkg.scripts?.build) {
+    checks.push({
+      name: "scripts_build",
+      severity: "warning",
+      message: 'Missing "build" script in package.json \u2014 deployment may skip build step',
+      fix: 'Add a build script (e.g., "build": "vite build" or "build": "next build")',
+      autoFixable: true
+    });
+  }
+  if (pkg.scripts?.build) {
+    const build = pkg.scripts.build;
+    if (/^(?:vue-)?tsc\s.*&&/.test(build)) {
+      checks.push({
+        name: "build_tsc_prefix",
+        severity: "info",
+        message: `Build script starts with tsc: "${build}" \u2014 Rush will auto-strip the tsc check during build`
+      });
+    }
+  }
+  return checks;
+}
+
+// src/commands/check/checks/port-env.ts
+import { existsSync as existsSync5, readFileSync as readFileSync4 } from "fs";
+import { join as join5 } from "path";
+var VITE_CONFIG_FILES2 = ["vite.config.ts", "vite.config.js"];
+function readDevScript(projectPath) {
+  const pkgPath = join5(projectPath, "package.json");
+  if (!existsSync5(pkgPath)) return null;
+  try {
+    const raw = JSON.parse(readFileSync4(pkgPath, "utf-8"));
+    return raw.scripts?.dev ?? null;
+  } catch {
+    return null;
+  }
+}
+function viteConfigReadsPort(projectPath) {
+  for (const file of VITE_CONFIG_FILES2) {
+    const filePath = join5(projectPath, file);
+    if (!existsSync5(filePath)) continue;
+    try {
+      const content = readFileSync4(filePath, "utf-8");
+      if (/process\.env\.PORT/.test(content)) return true;
+      if (/env\s*\(\s*['"]PORT['"]\s*\)/.test(content)) return true;
+    } catch {
+    }
+  }
+  return false;
+}
+function devScriptReadsPort(devScript) {
+  if (/\$PORT|\$\{PORT\}|%PORT%/.test(devScript)) return true;
+  if (/--port\s+\$/.test(devScript)) return true;
+  return false;
+}
+function checkPortEnv(projectPath, framework) {
+  const checks = [];
+  if (framework === "nextjs") {
+    checks.push({
+      name: "port_env",
+      severity: "info",
+      message: "Next.js natively supports PORT env \u2014 no config change needed"
+    });
+    return checks;
+  }
+  if (framework === "vite") {
+    if (viteConfigReadsPort(projectPath)) {
+      checks.push({
+        name: "port_env",
+        severity: "info",
+        message: "Vite config reads process.env.PORT"
+      });
+      return checks;
+    }
+    const devScript2 = readDevScript(projectPath);
+    if (devScript2 && devScriptReadsPort(devScript2)) {
+      checks.push({
+        name: "port_env",
+        severity: "info",
+        message: "Dev script references PORT"
+      });
+      return checks;
+    }
+    checks.push({
+      name: "port_env",
+      severity: "error",
+      message: "Vite config does not read process.env.PORT \u2014 Rush Pod passes PORT=8000",
+      fix: 'Add `server: { port: parseInt(process.env.PORT || "5173") }` to vite.config.ts',
+      autoFixable: true
+    });
+    return checks;
+  }
+  const devScript = readDevScript(projectPath);
+  if (devScript && devScriptReadsPort(devScript)) {
+    checks.push({
+      name: "port_env",
+      severity: "info",
+      message: "Dev script references PORT"
+    });
+  } else {
+    checks.push({
+      name: "port_env",
+      severity: "error",
+      message: "Dev server must read PORT env var \u2014 Rush Pod passes PORT=8000",
+      fix: "Ensure your dev server reads process.env.PORT or accepts --port $PORT",
+      autoFixable: false
+    });
+  }
+  return checks;
+}
+
+// src/commands/check/index.ts
+function severityIcon(severity) {
+  switch (severity) {
+    case "error":
+      return chalk2.red("\u2717");
+    case "warning":
+      return chalk2.yellow("!");
+    case "info":
+      return chalk2.dim("\xB7");
+  }
+}
+function displayResults(report) {
+  output.newline();
+  output.log(chalk2.bold("  Rush Deploy Check"));
+  output.log(
+    chalk2.dim(
+      `  Framework: ${report.framework} | Package Manager: ${report.packageManager ?? "unknown"}`
+    )
+  );
+  output.newline();
+  const grouped = {
+    error: report.checks.filter((c) => c.severity === "error"),
+    warning: report.checks.filter((c) => c.severity === "warning"),
+    info: report.checks.filter((c) => c.severity === "info")
+  };
+  for (const [severity, checks] of Object.entries(grouped)) {
+    if (checks.length === 0) continue;
+    for (const check of checks) {
+      const icon = severityIcon(check.severity);
+      output.log(`  ${icon} ${check.message}`);
+      if (check.fix && severity !== "info") {
+        output.log(chalk2.dim(`    \u2192 ${check.fix}`));
+      }
+    }
+  }
+  output.newline();
+  const { errors, warnings } = report.summary;
+  const parts = [];
+  if (errors > 0) parts.push(chalk2.red(`${errors} errors`));
+  if (warnings > 0) parts.push(chalk2.yellow(`${warnings} warnings`));
+  if (errors === 0 && warnings === 0)
+    parts.push(chalk2.green("All checks passed"));
+  output.log(`  ${parts.join(", ")}`);
+  if (report.deployable) {
+    output.newline();
+    output.log(
+      chalk2.green("  Ready to deploy! Run `rush-ai task deploy` to proceed.")
+    );
+  } else {
+    output.newline();
+    output.log(chalk2.red("  Fix the errors above before deploying."));
+  }
+  output.newline();
+}
+function runChecks(projectPath) {
+  const framework = detectFramework(projectPath);
+  const packageManager = detectPackageManager(projectPath);
+  const checks = [
+    ...checkPackageJson(projectPath),
+    ...checkFramework(projectPath),
+    ...checkLockFile(projectPath),
+    ...checkPortEnv(projectPath, framework)
+  ];
+  const { checks: dbChecks, info: dbInfo } = checkDatabase(
+    projectPath,
+    framework
+  );
+  checks.push(...dbChecks);
+  const errors = checks.filter((c) => c.severity === "error").length;
+  const warnings = checks.filter((c) => c.severity === "warning").length;
+  const info = checks.filter((c) => c.severity === "info").length;
+  return {
+    framework,
+    packageManager,
+    database: dbInfo,
+    checks,
+    summary: { errors, warnings, info },
+    deployable: errors === 0
+  };
+}
+function registerCheckCommand(program) {
+  program.command("check").description("Check if the current project is ready for Rush deployment").option("-p, --path <dir>", "Project directory to check", ".").action(async (opts) => {
+    const projectPath = resolve(opts.path);
+    const jsonMode = program.opts().json;
+    const report = runChecks(projectPath);
+    if (jsonMode) {
+      output.log(JSON.stringify(report, null, 2));
+    } else {
+      displayResults(report);
+    }
+    if (!report.deployable) {
+      process.exit(1);
+    }
+  });
+}
+
 // src/commands/completion/index.ts
-import { existsSync } from "fs";
+import { existsSync as existsSync6 } from "fs";
 import { appendFile, mkdir, readFile, writeFile } from "fs/promises";
 import { homedir } from "os";
-import { basename, dirname, join } from "path";
+import { basename, dirname, join as join6 } from "path";
 var MARKER_BEGIN = "###-begin-rush-ai-completion-###";
 var MARKER_END = "###-end-rush-ai-completion-###";
 var COMPLETION_SCRIPTS = {
@@ -644,11 +1112,11 @@ function getShellRcFile(shell) {
   const home = homedir();
   switch (shell) {
     case "bash":
-      return existsSync(join(home, ".bashrc")) ? join(home, ".bashrc") : join(home, ".bash_profile");
+      return existsSync6(join6(home, ".bashrc")) ? join6(home, ".bashrc") : join6(home, ".bash_profile");
     case "zsh":
-      return join(home, ".zshrc");
+      return join6(home, ".zshrc");
     case "fish":
-      return join(home, ".config", "fish", "completions", "rush-ai.fish");
+      return join6(home, ".config", "fish", "completions", "rush-ai.fish");
     default:
       throw new Error(`Unsupported shell: ${shell}`);
   }
@@ -904,7 +1372,7 @@ function registerConfigCommand(program) {
 }
 
 // src/commands/doctor/index.ts
-import chalk2 from "chalk";
+import chalk3 from "chalk";
 
 // src/commands/doctor/checks/auth.ts
 var checkAuth = async () => {
@@ -1019,11 +1487,11 @@ var checkAuth = async () => {
 };
 
 // src/commands/doctor/checks/config.ts
-import { accessSync, constants, existsSync as existsSync2, mkdirSync } from "fs";
+import { accessSync, constants, existsSync as existsSync7, mkdirSync } from "fs";
 var checkConfig = async () => {
   const checks = [];
   const configDir = getConfigDir();
-  const dirExists = existsSync2(configDir);
+  const dirExists = existsSync7(configDir);
   let writable = false;
   if (dirExists) {
     try {
@@ -1273,18 +1741,18 @@ var checkEnvironment = async () => {
 };
 
 // src/commands/doctor/checks/plugins.ts
-import { existsSync as existsSync3, readFileSync, writeFileSync } from "fs";
+import { existsSync as existsSync8, readFileSync as readFileSync5, writeFileSync } from "fs";
 import { homedir as homedir2 } from "os";
-import { resolve } from "path";
-var PLUGINS_FILE = resolve(homedir2(), ".rush", "plugins", "installed.json");
+import { resolve as resolve2 } from "path";
+var PLUGINS_FILE = resolve2(homedir2(), ".rush", "plugins", "installed.json");
 var MCP_CONFIG_PATHS = {
-  "claude-code": resolve(homedir2(), ".claude", "settings.json"),
-  cursor: resolve(homedir2(), ".cursor", "mcp.json")
+  "claude-code": resolve2(homedir2(), ".claude", "settings.json"),
+  cursor: resolve2(homedir2(), ".cursor", "mcp.json")
 };
 function safeReadJson(filePath, fallback) {
-  if (!existsSync3(filePath)) return fallback;
+  if (!existsSync8(filePath)) return fallback;
   try {
-    return JSON.parse(readFileSync(filePath, "utf-8"));
+    return JSON.parse(readFileSync5(filePath, "utf-8"));
   } catch {
     return fallback;
   }
@@ -1314,7 +1782,7 @@ function checkMcpForPlugin(name, manifest) {
       value: `Installed (v${manifest.version}), unknown type: ${manifest.type}`
     };
   }
-  if (!existsSync3(configPath)) {
+  if (!existsSync8(configPath)) {
     return {
       name: `plugin_${name}`,
       group: "Plugins",
@@ -1328,7 +1796,7 @@ function checkMcpForPlugin(name, manifest) {
     };
   }
   try {
-    const config = JSON.parse(readFileSync(configPath, "utf-8"));
+    const config = JSON.parse(readFileSync5(configPath, "utf-8"));
     const servers = config.mcpServers;
     if (!servers || !("rush" in servers)) {
       return {
@@ -1431,17 +1899,17 @@ function getSummary(checks) {
 function statusIcon(status) {
   switch (status) {
     case "pass":
-      return chalk2.green("\u2713");
+      return chalk3.green("\u2713");
     case "warn":
-      return chalk2.yellow("!");
+      return chalk3.yellow("!");
     case "fail":
-      return chalk2.red("\u2717");
+      return chalk3.red("\u2717");
     case "info":
-      return chalk2.dim("\xB7");
+      return chalk3.dim("\xB7");
   }
 }
 var LABEL_WIDTH = 20;
-function displayResults(checks) {
+function displayResults2(checks) {
   const groups = /* @__PURE__ */ new Map();
   for (const check of checks) {
     const existing = groups.get(check.group) ?? [];
@@ -1450,7 +1918,7 @@ function displayResults(checks) {
   }
   output.newline();
   for (const [groupName, groupChecks] of groups) {
-    output.log(`  ${chalk2.bold(groupName)}`);
+    output.log(`  ${chalk3.bold(groupName)}`);
     for (const check of groupChecks) {
       const icon = statusIcon(check.status);
       const label = check.label.padEnd(LABEL_WIDTH);
@@ -1460,21 +1928,21 @@ function displayResults(checks) {
   }
   const summary = getSummary(checks);
   const parts = [];
-  parts.push(chalk2.green(`${summary.pass} passed`));
-  if (summary.warn > 0) parts.push(chalk2.yellow(`${summary.warn} warnings`));
-  if (summary.fail > 0) parts.push(chalk2.red(`${summary.fail} failed`));
+  parts.push(chalk3.green(`${summary.pass} passed`));
+  if (summary.warn > 0) parts.push(chalk3.yellow(`${summary.warn} warnings`));
+  if (summary.fail > 0) parts.push(chalk3.red(`${summary.fail} failed`));
   if (summary.warn === 0 && summary.fail === 0) {
     parts.push("0 warnings");
     parts.push("0 failed");
   }
-  output.log(`  ${chalk2.bold("Summary:")} ${parts.join(", ")}`);
+  output.log(`  ${chalk3.bold("Summary:")} ${parts.join(", ")}`);
   if (summary.fail > 0 || summary.warn > 0) {
     const fixable = checks.filter(
       (c) => c.status !== "pass" && c.status !== "info" && c.autoFix
     );
     if (fixable.length > 0) {
       output.log(
-        chalk2.dim(`  Run \`rush-ai doctor --fix\` to attempt auto-fixes.`)
+        chalk3.dim(`  Run \`rush-ai doctor --fix\` to attempt auto-fixes.`)
       );
     }
   }
@@ -1528,7 +1996,7 @@ function registerDoctorCommand(program) {
     if (jsonMode) {
       outputJson(checks);
     } else {
-      displayResults(checks);
+      displayResults2(checks);
     }
     const hasFail = checks.some((c) => c.status === "fail");
     if (hasFail) {
@@ -1677,34 +2145,34 @@ function registerMcpCommand(program) {
 }
 
 // src/commands/plugin/index.ts
-import { existsSync as existsSync11, mkdirSync as mkdirSync5, readFileSync as readFileSync5, writeFileSync as writeFileSync4 } from "fs";
+import { existsSync as existsSync16, mkdirSync as mkdirSync5, readFileSync as readFileSync9, writeFileSync as writeFileSync4 } from "fs";
 import { homedir as homedir8 } from "os";
-import { resolve as resolve6 } from "path";
-import chalk4 from "chalk";
+import { resolve as resolve7 } from "path";
+import chalk5 from "chalk";
 
 // src/commands/plugin/adapters/claude-code.ts
-import { existsSync as existsSync5 } from "fs";
+import { existsSync as existsSync10 } from "fs";
 import { homedir as homedir3 } from "os";
-import { resolve as resolve3 } from "path";
+import { resolve as resolve4 } from "path";
 
 // src/commands/plugin/adapters/base.ts
 import {
   copyFileSync,
-  existsSync as existsSync4,
+  existsSync as existsSync9,
   mkdirSync as mkdirSync2,
-  readFileSync as readFileSync2,
+  readFileSync as readFileSync6,
   writeFileSync as writeFileSync2
 } from "fs";
-import { resolve as resolve2 } from "path";
+import { resolve as resolve3 } from "path";
 var BaseJsonAdapter = class {
   detect() {
-    return existsSync4(this.configDir);
+    return existsSync9(this.configDir);
   }
   readConfig() {
     const file = this.configPath();
-    if (!existsSync4(file)) return {};
+    if (!existsSync9(file)) return {};
     try {
-      return JSON.parse(readFileSync2(file, "utf-8"));
+      return JSON.parse(readFileSync6(file, "utf-8"));
     } catch (err) {
       throw new Error(
         `Failed to parse ${file}: ${err instanceof Error ? err.message : "invalid JSON"}`
@@ -1734,16 +2202,16 @@ var BaseJsonAdapter = class {
   }
   writeConfig(config) {
     const file = this.configPath();
-    if (!existsSync4(this.configDir)) {
+    if (!existsSync9(this.configDir)) {
       mkdirSync2(this.configDir, { recursive: true });
     }
-    if (existsSync4(file)) {
+    if (existsSync9(file)) {
       copyFileSync(file, `${file}.bak`);
     }
     writeFileSync2(file, JSON.stringify(config, null, 2), "utf-8");
   }
   configPath() {
-    return resolve2(this.configDir, this.configFile);
+    return resolve3(this.configDir, this.configFile);
   }
 };
 
@@ -1752,25 +2220,25 @@ var ClaudeCodeAdapter = class extends BaseJsonAdapter {
   name = "claude-code";
   description = "Claude Code integration (MCP config + SKILL.md + commands)";
   version = "0.2.0";
-  configDir = resolve3(homedir3(), ".claude");
+  configDir = resolve4(homedir3(), ".claude");
   configFile = "settings.json";
   detect() {
-    return existsSync5(this.configDir);
+    return existsSync10(this.configDir);
   }
 };
 
 // src/commands/plugin/adapters/cursor.ts
-import { existsSync as existsSync6 } from "fs";
+import { existsSync as existsSync11 } from "fs";
 import { homedir as homedir4 } from "os";
-import { resolve as resolve4 } from "path";
+import { resolve as resolve5 } from "path";
 var CursorAdapter = class extends BaseJsonAdapter {
   name = "cursor";
   description = "Cursor integration (MCP config)";
   version = "0.2.0";
-  configDir = resolve4(homedir4(), ".cursor");
+  configDir = resolve5(homedir4(), ".cursor");
   configFile = "mcp.json";
   detect() {
-    return existsSync6(this.configDir);
+    return existsSync11(this.configDir);
   }
 };
 
@@ -1801,11 +2269,11 @@ function getAdapterDescriptions() {
 import { createHash } from "crypto";
 import {
   copyFileSync as copyFileSync2,
-  existsSync as existsSync7,
+  existsSync as existsSync12,
   lstatSync,
   mkdirSync as mkdirSync3,
   readdirSync,
-  readFileSync as readFileSync3,
+  readFileSync as readFileSync7,
   readlinkSync,
   rmSync,
   symlinkSync,
@@ -1813,24 +2281,24 @@ import {
   writeFileSync as writeFileSync3
 } from "fs";
 import { homedir as homedir5 } from "os";
-import { dirname as dirname2, join as join2, relative, resolve as resolve5 } from "path";
+import { dirname as dirname2, join as join7, relative, resolve as resolve6 } from "path";
 var ASSET_SCHEMA_VERSION = 1;
-var PLUGINS_BASE = resolve5(homedir5(), ".rush", "plugins");
+var PLUGINS_BASE = resolve6(homedir5(), ".rush", "plugins");
 function getAssetManifestPath(pluginName) {
-  return resolve5(PLUGINS_BASE, pluginName, "asset-manifest.json");
+  return resolve6(PLUGINS_BASE, pluginName, "asset-manifest.json");
 }
 function getAssetStorePath(pluginName) {
-  return resolve5(PLUGINS_BASE, pluginName, "assets");
+  return resolve6(PLUGINS_BASE, pluginName, "assets");
 }
 function computeChecksum(filePath) {
-  const content = readFileSync3(filePath);
+  const content = readFileSync7(filePath);
   return createHash("sha256").update(content).digest("hex");
 }
 function loadAssetManifest(pluginName) {
   const manifestPath = getAssetManifestPath(pluginName);
-  if (!existsSync7(manifestPath)) return null;
+  if (!existsSync12(manifestPath)) return null;
   try {
-    return JSON.parse(readFileSync3(manifestPath, "utf-8"));
+    return JSON.parse(readFileSync7(manifestPath, "utf-8"));
   } catch {
     return null;
   }
@@ -1844,10 +2312,10 @@ function installAssets(options) {
   const existing = loadAssetManifest(pluginName);
   const sourceFiles = collectFiles(sourceDir);
   for (const relPath of sourceFiles) {
-    const srcFile = resolve5(sourceDir, relPath);
-    const destFile = resolve5(storePath, relPath);
+    const srcFile = resolve6(sourceDir, relPath);
+    const destFile = resolve6(storePath, relPath);
     const newChecksum = computeChecksum(srcFile);
-    if (existsSync7(destFile) && !force && existing) {
+    if (existsSync12(destFile) && !force && existing) {
       const existingEntry = existing.files.find((f) => f.path === relPath);
       if (existingEntry) {
         const currentChecksum = computeChecksum(destFile);
@@ -1872,8 +2340,8 @@ function installAssets(options) {
       type: "file"
     });
   }
-  const skillTarget = resolve5(homedir5(), ".claude", "skills", "rush-task");
-  if (!existsSync7(skillTarget)) {
+  const skillTarget = resolve6(homedir5(), ".claude", "skills", "rush-task");
+  if (!existsSync12(skillTarget)) {
     mkdirSync3(dirname2(skillTarget), { recursive: true });
     try {
       symlinkSync(storePath, skillTarget, "dir");
@@ -1893,7 +2361,7 @@ function installAssets(options) {
       const stat = lstatSync(skillTarget);
       if (stat.isSymbolicLink()) {
         const linkTarget = readlinkSync(skillTarget);
-        if (linkTarget === storePath || resolve5(linkTarget) === storePath) {
+        if (linkTarget === storePath || resolve6(linkTarget) === storePath) {
           files.push({
             path: "_symlink_skill",
             checksum: "",
@@ -1925,11 +2393,11 @@ function installAssets(options) {
   return manifest;
 }
 var ALLOWED_DELETE_PREFIXES = [
-  resolve5(homedir5(), ".rush", "plugins"),
-  resolve5(homedir5(), ".claude", "skills")
+  resolve6(homedir5(), ".rush", "plugins"),
+  resolve6(homedir5(), ".claude", "skills")
 ];
 function isPathAllowed(targetPath) {
-  const resolved = resolve5(targetPath);
+  const resolved = resolve6(targetPath);
   return ALLOWED_DELETE_PREFIXES.some(
     (prefix) => resolved.startsWith(`${prefix}/`)
   );
@@ -1944,7 +2412,7 @@ function uninstallAssets(pluginName) {
     return;
   }
   for (const entry of manifest.files) {
-    if (!existsSync7(entry.target)) continue;
+    if (!existsSync12(entry.target)) continue;
     if (!isPathAllowed(entry.target)) {
       output.warn(
         `  Refusing to delete ${entry.target}: outside allowed directories`
@@ -1974,7 +2442,7 @@ function uninstallAssets(pluginName) {
     }
   }
   const manifestPath = getAssetManifestPath(pluginName);
-  if (existsSync7(manifestPath)) {
+  if (existsSync12(manifestPath)) {
     rmSync(manifestPath);
   }
   const storePath = getAssetStorePath(pluginName);
@@ -1990,7 +2458,7 @@ function collectFiles(dir, base) {
   const files = [];
   const baseDir = base ?? dir;
   for (const entry of readdirSync(dir, { withFileTypes: true })) {
-    const fullPath = join2(dir, entry.name);
+    const fullPath = join7(dir, entry.name);
     if (entry.isDirectory()) {
       files.push(...collectFiles(fullPath, baseDir));
     } else if (entry.isFile()) {
@@ -2001,14 +2469,14 @@ function collectFiles(dir, base) {
 }
 
 // src/commands/plugin/doctor.ts
-import { existsSync as existsSync8, readFileSync as readFileSync4 } from "fs";
+import { existsSync as existsSync13, readFileSync as readFileSync8 } from "fs";
 import { homedir as homedir6 } from "os";
 import path from "path";
 function findCliInPath() {
   const pathDirs = (process.env.PATH || "").split(path.delimiter);
   for (const dir of pathDirs) {
     const candidate = path.join(dir, "rush-ai");
-    if (existsSync8(candidate)) return candidate;
+    if (existsSync13(candidate)) return candidate;
   }
   return null;
 }
@@ -2103,7 +2571,7 @@ function checkMcpConfig(ctx) {
       detail: `Unknown plugin type: ${type2}`
     };
   }
-  if (!existsSync8(configPath)) {
+  if (!existsSync13(configPath)) {
     return {
       name: "mcp_config",
       label: "MCP config",
@@ -2113,7 +2581,7 @@ function checkMcpConfig(ctx) {
     };
   }
   try {
-    const config = JSON.parse(readFileSync4(configPath, "utf-8"));
+    const config = JSON.parse(readFileSync8(configPath, "utf-8"));
     const servers = config.mcpServers;
     if (servers && "rush" in servers) {
       const rushServer = servers.rush;
@@ -2188,10 +2656,10 @@ async function runDoctorChecks(ctx) {
 }
 
 // src/commands/plugin/preflight.ts
-import { accessSync as accessSync2, constants as constants2, existsSync as existsSync9, mkdirSync as mkdirSync4 } from "fs";
+import { accessSync as accessSync2, constants as constants2, existsSync as existsSync14, mkdirSync as mkdirSync4 } from "fs";
 import { homedir as homedir7 } from "os";
 import path2 from "path";
-import chalk3 from "chalk";
+import chalk4 from "chalk";
 async function runPreflightChecks(options) {
   const results = [];
   try {
@@ -2233,7 +2701,7 @@ async function runPreflightChecks(options) {
   }
   const rushDir = path2.resolve(homedir7(), ".rush");
   try {
-    if (!existsSync9(rushDir)) {
+    if (!existsSync14(rushDir)) {
       mkdirSync4(rushDir, { recursive: true });
     }
     accessSync2(rushDir, constants2.W_OK);
@@ -2254,7 +2722,7 @@ async function runPreflightChecks(options) {
   } else {
     output.info("Preflight checks...");
     for (const r of results) {
-      const icon = r.status === "pass" ? chalk3.green("[PASS]") : r.status === "warn" ? chalk3.yellow("[WARN]") : chalk3.red("[FAIL]");
+      const icon = r.status === "pass" ? chalk4.green("[PASS]") : r.status === "warn" ? chalk4.yellow("[WARN]") : chalk4.red("[FAIL]");
       output.log(`  ${icon} ${r.name}: ${r.detail}`);
     }
   }
@@ -2263,7 +2731,7 @@ async function runPreflightChecks(options) {
 
 // src/commands/plugin/verify.ts
 import { execFileSync as execFileSync2 } from "child_process";
-import { existsSync as existsSync10 } from "fs";
+import { existsSync as existsSync15 } from "fs";
 async function runVerification(options) {
   const results = [];
   results.push(checkConfigFile(options.adapter));
@@ -2274,7 +2742,7 @@ async function runVerification(options) {
 }
 function checkConfigFile(adapter) {
   const configFile = adapter.configPath();
-  if (!existsSync10(configFile)) {
+  if (!existsSync15(configFile)) {
     return {
       name: "config_file",
       label: "IDE config",
@@ -2399,12 +2867,12 @@ function checkAuthStatus() {
 
 // src/commands/plugin/index.ts
 var CURRENT_SCHEMA_VERSION = 2;
-var PLUGINS_DIR = resolve6(homedir8(), ".rush", "plugins");
-var PLUGINS_FILE2 = resolve6(PLUGINS_DIR, "installed.json");
+var PLUGINS_DIR = resolve7(homedir8(), ".rush", "plugins");
+var PLUGINS_FILE2 = resolve7(PLUGINS_DIR, "installed.json");
 function safeReadJson2(filePath, fallback) {
-  if (!existsSync11(filePath)) return fallback;
+  if (!existsSync16(filePath)) return fallback;
   try {
-    return JSON.parse(readFileSync5(filePath, "utf-8"));
+    return JSON.parse(readFileSync9(filePath, "utf-8"));
   } catch {
     return fallback;
   }
@@ -2424,7 +2892,7 @@ function loadInstalledPlugins(autoMigrate = true) {
   return raw;
 }
 function saveInstalledPlugins(data) {
-  if (!existsSync11(PLUGINS_DIR)) {
+  if (!existsSync16(PLUGINS_DIR)) {
     mkdirSync5(PLUGINS_DIR, { recursive: true });
   }
   writeFileSync4(PLUGINS_FILE2, JSON.stringify(data, null, 2), "utf-8");
@@ -2455,21 +2923,21 @@ function resolvePluginAssetsDir() {
     );
     return null;
   }
-  const bundled = resolve6(baseDir, "plugin-assets");
-  if (existsSync11(bundled)) return bundled;
-  const monorepo = resolve6(baseDir, "..", "..", "..", "..", "rush-plugin");
-  if (existsSync11(monorepo)) return monorepo;
+  const bundled = resolve7(baseDir, "plugin-assets");
+  if (existsSync16(bundled)) return bundled;
+  const monorepo = resolve7(baseDir, "..", "..", "..", "..", "rush-plugin");
+  if (existsSync16(monorepo)) return monorepo;
   return null;
 }
 function getCliVersion() {
   try {
-    const pkgPath = resolve6(
+    const pkgPath = resolve7(
       import.meta.dirname ?? __dirname,
       "..",
       "..",
       "package.json"
     );
-    const pkg = JSON.parse(readFileSync5(pkgPath, "utf-8"));
+    const pkg = JSON.parse(readFileSync9(pkgPath, "utf-8"));
     return pkg.version ?? "0.2.0";
   } catch {
     return "0.2.0";
@@ -2747,7 +3215,7 @@ function registerPluginCommand(program) {
       let warn = 0;
       let fail = 0;
       for (const check of checks) {
-        const icon = check.status === "pass" ? chalk4.green("[PASS]") : check.status === "warn" ? chalk4.yellow("[WARN]") : chalk4.red("[FAIL]");
+        const icon = check.status === "pass" ? chalk5.green("[PASS]") : check.status === "warn" ? chalk5.yellow("[WARN]") : chalk5.red("[FAIL]");
         output.log(`  ${icon} ${check.label}: ${check.detail}`);
         if (check.fix) {
           output.dim(`         Fix: ${check.fix}`);
@@ -2768,7 +3236,7 @@ function registerPluginCommand(program) {
 }
 function printVerifyResults(results) {
   for (const r of results) {
-    const icon = r.status === "pass" ? chalk4.green("[PASS]") : r.status === "warn" ? chalk4.yellow("[WARN]") : chalk4.red("[FAIL]");
+    const icon = r.status === "pass" ? chalk5.green("[PASS]") : r.status === "warn" ? chalk5.yellow("[WARN]") : chalk5.red("[FAIL]");
     output.log(`  ${icon} ${r.label}: ${r.detail}`);
     if (r.fix) {
       output.dim(`         Fix: ${r.fix}`);
@@ -2784,17 +3252,17 @@ import { Readable } from "stream";
 import { pipeline } from "stream/promises";
 
 // src/output/diff.ts
-import chalk5 from "chalk";
+import chalk6 from "chalk";
 function containsDiff(text) {
   return /^@@\s+-\d+/m.test(text) || /^---\s+a\//m.test(text);
 }
 function colorizeDiff(text) {
   return text.split("\n").map((line) => {
     if (line.startsWith("+++") || line.startsWith("---"))
-      return chalk5.bold(line);
-    if (line.startsWith("+")) return chalk5.green(line);
-    if (line.startsWith("-")) return chalk5.red(line);
-    if (line.startsWith("@@")) return chalk5.cyan(line);
+      return chalk6.bold(line);
+    if (line.startsWith("+")) return chalk6.green(line);
+    if (line.startsWith("-")) return chalk6.red(line);
+    if (line.startsWith("@@")) return chalk6.cyan(line);
     return line;
   }).join("\n");
 }
@@ -2817,18 +3285,228 @@ async function readStdinIfPiped() {
   if (process.stdin.isTTY) {
     return null;
   }
-  return new Promise((resolve7, reject) => {
+  return new Promise((resolve9, reject) => {
     const chunks = [];
     process.stdin.on("data", (chunk) => {
       chunks.push(chunk);
     });
     process.stdin.on("end", () => {
-      resolve7(Buffer.concat(chunks).toString("utf-8").trim());
+      resolve9(Buffer.concat(chunks).toString("utf-8").trim());
     });
     process.stdin.on("error", reject);
   });
 }
 
+// src/commands/task/deploy.ts
+import { resolve as resolve8 } from "path";
+import chalk7 from "chalk";
+
+// src/util/git.ts
+import { execFileSync as execFileSync3 } from "child_process";
+import { existsSync as existsSync17 } from "fs";
+import { join as join8 } from "path";
+function isGitRepo(projectPath) {
+  return existsSync17(join8(projectPath, ".git"));
+}
+function gitInit(projectPath) {
+  execFileSync3("git", ["init"], { cwd: projectPath, stdio: "pipe" });
+}
+function hasUncommittedChanges(projectPath) {
+  try {
+    const status = execFileSync3("git", ["status", "--porcelain"], {
+      cwd: projectPath,
+      encoding: "utf-8"
+    });
+    return status.trim().length > 0;
+  } catch {
+    return false;
+  }
+}
+function gitAddAndCommit(projectPath, message) {
+  execFileSync3("git", ["add", "-A"], { cwd: projectPath, stdio: "pipe" });
+  execFileSync3("git", ["commit", "-m", message, "--allow-empty"], {
+    cwd: projectPath,
+    stdio: "pipe",
+    env: {
+      ...process.env,
+      GIT_AUTHOR_NAME: process.env.GIT_AUTHOR_NAME || "rush-ai",
+      GIT_AUTHOR_EMAIL: process.env.GIT_AUTHOR_EMAIL || "rush-ai@rush.dev",
+      GIT_COMMITTER_NAME: process.env.GIT_COMMITTER_NAME || "rush-ai",
+      GIT_COMMITTER_EMAIL: process.env.GIT_COMMITTER_EMAIL || "rush-ai@rush.dev"
+    }
+  });
+}
+function gitPushUrl(projectPath, url) {
+  try {
+    execFileSync3("git", ["push", url, "HEAD:main", "--force"], {
+      cwd: projectPath,
+      stdio: "pipe",
+      timeout: 3e5,
+      maxBuffer: 10 * 1024 * 1024
+    });
+    return { success: true, stderr: "" };
+  } catch (err) {
+    const rawStderr = err && typeof err === "object" && "stderr" in err ? String(err.stderr) : "unknown error";
+    return { success: false, stderr: sanitizeGitOutput(rawStderr) };
+  }
+}
+function sanitizeGitOutput(text) {
+  return text.replace(/https?:\/\/[^@]*@/g, "https://***@");
+}
+
+// src/commands/task/deploy.ts
+function sleep(ms) {
+  return new Promise((r) => setTimeout(r, ms));
+}
+function maskToken2(url) {
+  return url.replace(/:([^@]{4})[^@]*@/, ":$1****@");
+}
+function registerDeploySubcommand(task, program) {
+  task.command("deploy").description("Deploy a local project to Rush platform").option("-n, --name <name>", "Project name").option("-p, --path <dir>", "Project directory", ".").action(async (opts) => {
+    requireAuth();
+    const format = resolveFormat(program.opts());
+    const client = createClient();
+    const projectPath = resolve8(opts.path);
+    if (format !== "json") {
+      output.info("Checking project readiness...");
+    }
+    const report = runChecks(projectPath);
+    if (!report.deployable) {
+      if (format === "json") {
+        output.log(
+          JSON.stringify(
+            { error: "Project has errors that must be fixed", report },
+            null,
+            2
+          )
+        );
+      } else {
+        output.error(
+          "Project has errors that must be fixed before deploying."
+        );
+        output.dim("Run `rush-ai check` for details.");
+      }
+      process.exit(1);
+    }
+    if (format !== "json") {
+      output.info("Creating Rush project...");
+    }
+    const projectName = opts.name || `deploy-${Date.now().toString(36)}`;
+    const { data } = await client.post(
+      "/api/projects/deploy-cli",
+      {
+        name: projectName,
+        framework: report.framework,
+        packageManager: report.packageManager
+      }
+    );
+    if (!data.success || !data.gitPushUrl) {
+      throw new RushError(
+        "Failed to create project \u2014 no git push URL returned"
+      );
+    }
+    if (format !== "json") {
+      output.success(`Project created: ${data.projectId}`);
+    }
+    if (format !== "json") {
+      output.info("Pushing code to Rush...");
+    }
+    if (!isGitRepo(projectPath)) {
+      gitInit(projectPath);
+    }
+    if (hasUncommittedChanges(projectPath)) {
+      gitAddAndCommit(projectPath, "deploy to rush");
+    }
+    const pushResult = gitPushUrl(projectPath, data.gitPushUrl);
+    if (!pushResult.success) {
+      if (format === "json") {
+        output.log(
+          JSON.stringify(
+            {
+              error: "Git push failed",
+              details: pushResult.stderr,
+              projectId: data.projectId
+            },
+            null,
+            2
+          )
+        );
+      } else {
+        output.error("Git push failed:");
+        output.log(pushResult.stderr);
+        output.dim(
+          "Check your VPN connection and network. The project was created but code was not pushed."
+        );
+        output.dim(`Project ID: ${data.projectId}`);
+      }
+      process.exit(1);
+    }
+    if (format !== "json") {
+      output.success("Code pushed successfully");
+    }
+    if (format !== "json") {
+      output.info("Initializing project on Rush...");
+    }
+    try {
+      await client.post(
+        `/api/projects/${encodeURIComponent(data.projectId)}/init-clone`,
+        {
+          projectId: data.projectId,
+          sourceProjectId: data.projectId
+        }
+      );
+    } catch {
+      if (format !== "json") {
+        output.warn(
+          "Init-clone request failed \u2014 the pod may auto-initialize on startup"
+        );
+      }
+    }
+    if (format !== "json") {
+      output.info("Waiting for project to be ready...");
+    }
+    const maxWait = 15e4;
+    const pollInterval = 3e3;
+    const startTime = Date.now();
+    let ready = false;
+    while (Date.now() - startTime < maxWait) {
+      try {
+        const { data: readyData } = await client.get(
+          `/api/projects/${encodeURIComponent(data.projectId)}/pod-ready`
+        );
+        if (readyData?.data?.ready) {
+          ready = true;
+          break;
+        }
+      } catch {
+      }
+      await sleep(pollInterval);
+    }
+    const result = {
+      projectId: data.projectId,
+      previewUrl: data.podPreviewUrl,
+      chatUrl: data.podChatUrl,
+      status: ready ? "ready" : "timeout",
+      gitRemote: maskToken2(data.gitPushUrl)
+    };
+    if (format === "json") {
+      output.log(JSON.stringify(result, null, 2));
+    } else {
+      output.newline();
+      if (ready) {
+        output.success("Deployment complete!");
+      } else {
+        output.warn("Pod is still starting up \u2014 it may take another minute.");
+      }
+      output.log(`  ${chalk7.bold("Project ID:")}  ${result.projectId}`);
+      output.log(`  ${chalk7.bold("Preview:")}     ${result.previewUrl}`);
+      output.log(`  ${chalk7.bold("Chat:")}        ${result.chatUrl}`);
+      output.log(`  ${chalk7.bold("Git remote:")}  ${result.gitRemote}`);
+      output.newline();
+    }
+  });
+}
+
 // src/commands/task/index.ts
 var VALID_CATEGORIES = ["code", "image", "document", "other"];
 function sanitizeFilePath(filePath, outputDir) {
@@ -2869,6 +3547,7 @@ function buildCategorySummary(files) {
 }
 function registerTaskCommand(program) {
   const task = program.command("task").description("Create and manage tasks");
+  registerDeploySubcommand(task, program);
   task.command("create").description("Create a task asynchronously").requiredOption("-a, --agent <name>", "Agent name to execute the task").option("-p, --prompt <text>", "Task prompt").option("--skills <skills>", "Comma-separated skills to add", commaSplit).option("--mcp <servers>", "Comma-separated MCP servers to add", commaSplit).action(
     async (options) => {
       requireAuth();
@@ -3253,6 +3932,7 @@ function registerCommands(program) {
   registerAuthCommand(program);
   registerAgentCommand(program);
   registerTaskCommand(program);
+  registerCheckCommand(program);
   registerMcpCommand(program);
   registerPluginCommand(program);
   registerCompletionCommand(program);
@@ -3263,7 +3943,7 @@ function registerCommands(program) {
 // src/util/update-check.ts
 import { mkdir as mkdir3, readFile as readFile2, writeFile as writeFile2 } from "fs/promises";
 import { homedir as homedir9 } from "os";
-import { dirname as dirname3, join as join3 } from "path";
+import { dirname as dirname3, join as join9 } from "path";
 var CHECK_INTERVAL_MS = 24 * 60 * 60 * 1e3;
 var FETCH_TIMEOUT_MS = 3e3;
 var REGISTRY_URL = "https://registry.npmjs.org/rush-ai/latest";
@@ -3292,8 +3972,8 @@ async function writeLastCheck(checkFile) {
   }
 }
 async function checkForUpdate(currentVersion) {
-  const rushDir = join3(homedir9(), ".rush");
-  const checkFile = join3(rushDir, "update-check.json");
+  const rushDir = join9(homedir9(), ".rush");
+  const checkFile = join9(rushDir, "update-check.json");
   try {
     if (process.env.CI) return;
     let lastCheck = 0;
@@ -3322,28 +4002,28 @@ async function checkForUpdate(currentVersion) {
 
 // src/index.ts
 var BANNER = `
-  ${chalk6.bold.cyan("Rush CLI")} ${chalk6.dim(`v${VERSION}`)}
-  ${chalk6.dim("The command-line interface for the Rush AI platform")}
+  ${chalk8.bold.cyan("Rush CLI")} ${chalk8.dim(`v${VERSION}`)}
+  ${chalk8.dim("The command-line interface for the Rush AI platform")}
 `;
 function showWelcomeGuide() {
   const lines = [
     "",
-    `  ${chalk6.bold.cyan("Rush CLI")} ${chalk6.dim(`v${VERSION}`)}`,
+    `  ${chalk8.bold.cyan("Rush CLI")} ${chalk8.dim(`v${VERSION}`)}`,
     "",
-    chalk6.dim("  Quick start:"),
-    `    ${chalk6.cyan("rush-ai auth login")}          Log in to Rush platform`,
-    `    ${chalk6.cyan("rush-ai agent list")}          Browse available agents`,
-    `    ${chalk6.cyan("rush-ai task create -a <agent>")} Create a task`,
+    chalk8.dim("  Quick start:"),
+    `    ${chalk8.cyan("rush-ai auth login")}          Log in to Rush platform`,
+    `    ${chalk8.cyan("rush-ai agent list")}          Browse available agents`,
+    `    ${chalk8.cyan("rush-ai task create -a <agent>")} Create a task`,
     ""
   ];
   try {
     const method = getAuthMethod();
     if (method) {
-      lines.push(chalk6.dim("  Status:"), `    Logged in via ${method}`, "");
+      lines.push(chalk8.dim("  Status:"), `    Logged in via ${method}`, "");
     }
   } catch {
   }
-  lines.push(chalk6.dim("  Run rush-ai --help for all commands."), "");
+  lines.push(chalk8.dim("  Run rush-ai --help for all commands."), "");
   console.error(lines.join("\n"));
 }
 function createProgram() {