exportc 0.0.6 → 0.0.8

package/commands/deploy.js

@@ -1,4 +1,3 @@
-import * as p from "@clack/prompts";
 import pc from "picocolors";
 import fs from "node:fs";
 import path from "node:path";
@@ -10,49 +9,44 @@ export async function deploy(argv) {
 
   // Check if export directory exists
   if (!fs.existsSync(exportDir)) {
-    p.cancel(`No export/ directory found. Run ${pc.cyan("exportc init")} first.`);
+    console.error(pc.red("✗") + ` No export/ directory found. Run ${pc.cyan("exportc init")} first.`);
     process.exit(1);
   }
 
   // Check if dependencies are installed
   const nodeModules = path.join(exportDir, "node_modules");
   if (!fs.existsSync(nodeModules)) {
-    p.cancel(`Dependencies not installed. Run ${pc.cyan("cd export && npm install")} first.`);
+    console.error(pc.red("✗") + ` Dependencies not installed. Run ${pc.cyan("cd export && npm install")} first.`);
     process.exit(1);
   }
 
-  p.intro(pc.bgCyan(pc.black(" exportc deploy ")));
+  console.log(pc.cyan("exportc deploy"));
+  console.log();
 
   // Step 1: Build Vite
-  const s1 = p.spinner();
-  s1.start("Building with Vite...");
+  console.log("Building with Vite...");
 
   const viteBuild = spawn("npm", ["run", "build"], {
     cwd,
-    stdio: ["ignore", "pipe", "pipe"],
+    stdio: "inherit",
     shell: true,
   });
 
-  let viteBuildOutput = "";
-  viteBuild.stdout.on("data", (data) => { viteBuildOutput += data.toString(); });
-  viteBuild.stderr.on("data", (data) => { viteBuildOutput += data.toString(); });
-
   const viteExitCode = await new Promise((resolve) => {
     viteBuild.on("close", resolve);
     viteBuild.on("error", () => resolve(1));
   });
 
   if (viteExitCode !== 0) {
-    s1.stop("Vite build failed");
-    console.error(viteBuildOutput);
+    console.error(pc.red("✗") + " Vite build failed");
     process.exit(1);
   }
 
-  s1.stop("Vite build complete");
+  console.log(pc.green("✓") + " Vite build complete");
+  console.log();
 
   // Step 2: Deploy to Cloudflare Workers
-  const s2 = p.spinner();
-  s2.start("Deploying to Cloudflare Workers...");
+  console.log("Deploying to Cloudflare Workers...");
 
   const wranglerDeploy = spawn("npm", ["run", "deploy"], {
     cwd: exportDir,
@@ -66,29 +60,15 @@ export async function deploy(argv) {
   });
 
   if (wranglerExitCode !== 0) {
-    s2.stop("Deployment failed");
+    console.error(pc.red("✗") + " Deployment failed");
     process.exit(1);
   }
 
-  s2.stop("Deployed successfully!");
-
   // Read worker name from export/package.json
   const exportPkgPath = path.join(exportDir, "package.json");
   const exportPkg = JSON.parse(fs.readFileSync(exportPkgPath, "utf8"));
   const workerName = exportPkg.name;
 
-  p.note(
-    `Your app is now live at:
-${pc.cyan(`https://${workerName}.workers.dev/`)}
-
-${pc.bold("What was deployed:")}
-- Static assets (Vite build output)
-- Server exports (export/ directory)
-
-${pc.bold("Client imports will resolve to:")}
-${pc.cyan(`https://${workerName}.workers.dev/`)}`,
-    "Workers Sites"
-  );
-
-  p.outro("Done!");
+  console.log();
+  console.log(pc.green("✓") + " Deployed to " + pc.cyan(`https://${workerName}.workers.dev/`));
 }

package/commands/dev.js

@@ -1,4 +1,3 @@
-import * as p from "@clack/prompts";
 import pc from "picocolors";
 import fs from "node:fs";
 import path from "node:path";
@@ -10,48 +9,33 @@ export async function dev(argv) {
 
   // Check if export directory exists
   if (!fs.existsSync(exportDir)) {
-    p.cancel(`No export/ directory found. Run ${pc.cyan("exportc init")} first.`);
+    console.error(pc.red("✗") + ` No export/ directory found. Run ${pc.cyan("exportc init")} first.`);
     process.exit(1);
   }
 
   // Check if dependencies are installed
   const nodeModules = path.join(exportDir, "node_modules");
   if (!fs.existsSync(nodeModules)) {
-    p.cancel(`Dependencies not installed. Run ${pc.cyan("cd export && npm install")} first.`);
+    console.error(pc.red("✗") + ` Dependencies not installed. Run ${pc.cyan("cd export && npm install")} first.`);
     process.exit(1);
   }
 
-  p.intro(pc.bgCyan(pc.black(" exportc dev ")));
+  console.log(pc.cyan("exportc dev"));
+  console.log();
+  console.log("Starting Wrangler dev server...");
 
-  const s = p.spinner();
-  s.start("Starting export dev server...");
-
-  // Generate types first
-  const generateTypes = spawn("npm", ["run", "dev"], {
+  const wrangler = spawn("npm", ["run", "dev"], {
     cwd: exportDir,
     stdio: "inherit",
     shell: true,
   });
 
-  generateTypes.on("error", (err) => {
-    s.stop("Failed to start dev server");
-    console.error(pc.red(err.message));
+  wrangler.on("error", (err) => {
+    console.error(pc.red("✗") + " Failed to start dev server");
+    console.error(err.message);
     process.exit(1);
   });
 
-  s.stop("Export dev server started!");
-
-  p.note(
-    `Wrangler dev server is running at ${pc.cyan("http://localhost:8787")}
-
-${pc.bold("In your Vite app:")}
-${pc.cyan(`import { hello } from "export/";`)}
-${pc.cyan(`const message = await hello("World");`)}
-
-${pc.dim("Press Ctrl+C to stop")}`,
-    "Running"
-  );
-
   // Keep the process running
   await new Promise(() => {});
 }

package/commands/init.js

@@ -1,106 +1,53 @@
-import * as p from "@clack/prompts";
 import pc from "picocolors";
 import fs from "node:fs";
 import path from "node:path";
-import { fileURLToPath } from "node:url";
 import { execSync } from "node:child_process";
 
-const __dirname = path.dirname(fileURLToPath(import.meta.url));
-
 export async function init(argv) {
   const cwd = process.cwd();
-  const isNonInteractive = argv.yes || argv.y || process.env.CI === "true";
 
-  if (!isNonInteractive) {
-    p.intro(pc.bgCyan(pc.black(" exportc init ")));
-  }
+  console.log(pc.cyan("exportc init"));
+  console.log();
 
   // Check for Vite project
   const viteConfigFiles = ["vite.config.ts", "vite.config.js", "vite.config.mts", "vite.config.mjs"];
   const viteConfig = viteConfigFiles.find((f) => fs.existsSync(path.join(cwd, f)));
 
   if (!viteConfig) {
-    if (isNonInteractive) {
-      console.error("Error: No Vite config found. exportc currently only supports Vite projects.");
-      process.exit(1);
-    }
-    p.cancel("No Vite config found. exportc currently only supports Vite projects.");
+    console.error(pc.red("✗") + " No Vite config found. exportc only supports Vite projects.");
     process.exit(1);
   }
 
   // Check for package.json
   const pkgPath = path.join(cwd, "package.json");
   if (!fs.existsSync(pkgPath)) {
-    if (isNonInteractive) {
-      console.error("Error: No package.json found.");
-      process.exit(1);
-    }
-    p.cancel("No package.json found.");
+    console.error(pc.red("✗") + " No package.json found.");
     process.exit(1);
   }
 
   const pkg = JSON.parse(fs.readFileSync(pkgPath, "utf8"));
 
-  // Check if already initialized
-  const exportDir = path.join(cwd, "export");
-  if (fs.existsSync(exportDir) && !isNonInteractive) {
-    const overwrite = await p.confirm({
-      message: "export/ directory already exists. Continue and overwrite?",
-      initialValue: false,
-    });
-    if (p.isCancel(overwrite) || !overwrite) {
-      p.cancel("Operation cancelled.");
-      process.exit(0);
-    }
-  }
-
-  // Get worker name (use default in non-interactive mode)
-  const defaultWorkerName = pkg.name ? `${pkg.name}-api` : "my-api";
-  let workerName;
-
-  if (isNonInteractive) {
-    workerName = argv.name || defaultWorkerName;
-  } else {
-    workerName = await p.text({
-      message: "Worker name:",
-      placeholder: defaultWorkerName,
-      defaultValue: defaultWorkerName,
-      validate: (v) => {
-        if (!v) return "Worker name is required";
-        if (!/^[a-z0-9-]+$/.test(v)) return "Use lowercase letters, numbers, and hyphens only";
-      },
-    });
-
-    if (p.isCancel(workerName)) {
-      p.cancel("Operation cancelled.");
-      process.exit(0);
-    }
-  }
+  // Auto-generate worker name from package name
+  const workerName = argv.name || (pkg.name ? `${pkg.name}-api` : "my-api");
 
   // Check for TypeScript
   const isTypeScript = viteConfig.endsWith(".ts") || viteConfig.endsWith(".mts") ||
     fs.existsSync(path.join(cwd, "tsconfig.json"));
 
-  let s;
-  if (!isNonInteractive) {
-    s = p.spinner();
-    s.start("Initializing export...");
-  } else {
-    console.log("Initializing export...");
-  }
+  const exportDir = path.join(cwd, "export");
+  const ext = isTypeScript ? "ts" : "js";
 
   // Create export directory
+  console.log(pc.gray("Creating export directory..."));
   if (!fs.existsSync(exportDir)) {
     fs.mkdirSync(exportDir, { recursive: true });
   }
 
   // Create export/index.ts or index.js
-  const ext = isTypeScript ? "ts" : "js";
   const indexPath = path.join(exportDir, `index.${ext}`);
   if (!fs.existsSync(indexPath)) {
     const template = isTypeScript
-      ? `// Server-side exports - these will be available to your client code
-// Import from "export/" in your client code
+      ? `// Server-side exports - import from "export/" in your client code
 
 export async function hello(name: string): Promise<string> {
   return \`Hello, \${name}!\`;
@@ -126,8 +73,7 @@ export class Counter {
   }
 }
 `
-      : `// Server-side exports - these will be available to your client code
-// Import from "export/" in your client code
+      : `// Server-side exports - import from "export/" in your client code
 
 export async function hello(name) {
   return \`Hello, \${name}!\`;
@@ -156,8 +102,8 @@ export class Counter {
     fs.writeFileSync(indexPath, template);
   }
 
-  // Detect Vite build output directory from vite.config
-  let viteBuildOutDir = "dist"; // default
+  // Detect Vite build output directory
+  let viteBuildOutDir = "dist";
   const viteConfigPath = path.join(cwd, viteConfig);
   let viteConfigContent = fs.readFileSync(viteConfigPath, "utf8");
   const outDirMatch = viteConfigContent.match(/outDir:\s*['"]([^'"]+)['"]/);
@@ -172,7 +118,7 @@ export class Counter {
     private: true,
     type: "module",
     exports: "./",
-    main: `../${viteBuildOutDir}`, // Static assets from Vite build
+    main: `../${viteBuildOutDir}`,
     scripts: {
       dev: "generate-export-types && wrangler dev",
       deploy: "generate-export-types && wrangler deploy",
@@ -193,28 +139,21 @@ export class Counter {
 
   // Update main package.json
   pkg.scripts = pkg.scripts || {};
-
-  // Add export script: build + deploy as Workers Sites
   if (!pkg.scripts["export"]) {
     pkg.scripts["export"] = "vite build && cd export && npm run deploy";
   }
 
-  // Add exportc to devDependencies
   pkg.devDependencies = pkg.devDependencies || {};
   if (!pkg.devDependencies.exportc) {
-    pkg.devDependencies.exportc = "^0.0.2";
+    pkg.devDependencies.exportc = "^0.0.6";
   }
 
   fs.writeFileSync(pkgPath, JSON.stringify(pkg, null, 2) + "\n");
 
   // Update vite.config
-
-  // Check if export plugin is already added
   if (!viteConfigContent.includes("exportc/vite")) {
-    // Add import at the top
     const importStatement = `import { exportPlugin } from "exportc/vite";\n`;
 
-    // Find the first import or the start of the file
     const importMatch = viteConfigContent.match(/^(import\s+.+\s+from\s+['"].+['"];?\s*\n?)+/m);
     if (importMatch) {
       const insertPos = importMatch.index + importMatch[0].length;
@@ -226,16 +165,12 @@ export class Counter {
       viteConfigContent = importStatement + viteConfigContent;
     }
 
-    // Add plugin to defineConfig
-    // Look for plugins array
     if (viteConfigContent.includes("plugins:")) {
-      // Add to existing plugins array
       viteConfigContent = viteConfigContent.replace(
         /plugins:\s*\[/,
         "plugins: [exportPlugin(), "
       );
     } else {
-      // Add plugins array to defineConfig
       viteConfigContent = viteConfigContent.replace(
         /defineConfig\(\s*\{/,
         "defineConfig({\n  plugins: [exportPlugin()],"
@@ -245,7 +180,7 @@ export class Counter {
     fs.writeFileSync(viteConfigPath, viteConfigContent);
   }
 
-  // Create .gitignore entries for export directory
+  // Create .gitignore
   const exportGitignorePath = path.join(exportDir, ".gitignore");
   const gitignoreContent = `# Generated files
 .export-*.js
@@ -257,15 +192,11 @@ wrangler.toml
 `;
   fs.writeFileSync(exportGitignorePath, gitignoreContent);
 
-  // Create export-env.d.ts in main project for TypeScript support
+  // Create export-env.d.ts for TypeScript
   if (isTypeScript) {
     const envDtsPath = path.join(cwd, "export-env.d.ts");
     if (!fs.existsSync(envDtsPath)) {
-      const envDtsContent = `// Type declarations for export/ imports
-// This file is auto-generated by exportc. You can modify it to add custom types.
-
-// Re-export types from your export directory
-// Update this when you add new exports
+      const envDtsContent = `// Auto-generated by exportc - types are updated when you run npm run dev
 
 declare module "export/" {
   export function hello(name: string): Promise<string>;
@@ -277,17 +208,11 @@ declare module "export/" {
     [Symbol.dispose](): Promise<void>;
   }
 }
-
-// Add more module declarations for subpaths:
-// declare module "export/utils" {
-//   export function myUtil(): Promise<void>;
-// }
 `;
       fs.writeFileSync(envDtsPath, envDtsContent);
     }
 
-    // Update tsconfig to include the type declarations
-    // Modern Vite uses tsconfig.app.json for app code, older uses tsconfig.json directly
+    // Update tsconfig
     const tsconfigAppPath = path.join(cwd, "tsconfig.app.json");
     const tsconfigPath = path.join(cwd, "tsconfig.json");
     const targetTsconfig = fs.existsSync(tsconfigAppPath) ? tsconfigAppPath : tsconfigPath;
@@ -296,78 +221,41 @@ declare module "export/" {
       try {
         const tsconfigContent = fs.readFileSync(targetTsconfig, "utf8");
         const tsconfig = JSON.parse(tsconfigContent);
-
-        // Add export-env.d.ts to include if not already present
         tsconfig.include = tsconfig.include || [];
         if (!tsconfig.include.includes("export-env.d.ts")) {
           tsconfig.include.push("export-env.d.ts");
           fs.writeFileSync(targetTsconfig, JSON.stringify(tsconfig, null, 2) + "\n");
         }
       } catch {
-        // Ignore JSON parse errors (might have comments)
+        // Ignore JSON parse errors
       }
     }
   }
 
-  // Install dependencies in export directory
-  if (!isNonInteractive) {
-    s.stop("Files created!");
-    s.start("Installing dependencies...");
-  } else {
-    console.log("Installing dependencies...");
-  }
+  console.log(pc.green("✓") + " Created export/");
 
+  // Install dependencies in export/
+  console.log(pc.gray("Installing export dependencies..."));
   try {
-    execSync("npm install", {
-      cwd: exportDir,
-      stdio: isNonInteractive ? "inherit" : "pipe",
-    });
-  } catch (err) {
-    if (!isNonInteractive) {
-      s.stop("Failed to install dependencies");
-      p.log.error(`Run ${pc.cyan("cd export && npm install")} manually.`);
-    } else {
-      console.error("Failed to install dependencies. Run 'cd export && npm install' manually.");
-    }
+    execSync("npm install", { cwd: exportDir, stdio: "pipe" });
+    console.log(pc.green("✓") + " Installed export dependencies");
+  } catch {
+    console.log(pc.yellow("!") + " Failed to install export dependencies");
   }
 
-  if (!isNonInteractive) {
-    s.stop("Export initialized!");
-
-    const filesCreated = isTypeScript
-      ? `${pc.cyan("export/")}
-├── index.${ext}        ${pc.dim("# Your server exports")}
-├── package.json    ${pc.dim("# Worker configuration")}
-└── .gitignore
-
-${pc.cyan("export-env.d.ts")}     ${pc.dim("# Type declarations for export/ imports")}`
-      : `${pc.cyan("export/")}
-├── index.${ext}        ${pc.dim("# Your server exports")}
-├── package.json    ${pc.dim("# Worker configuration")}
-└── .gitignore`;
-
-    p.note(
-      `${filesCreated}
-
-${pc.bold("Next steps:")}
-
-1. Start development (Vite + Wrangler auto-start):
-   ${pc.cyan("npm run dev")}
-
-2. Import in your client code:
-   ${pc.cyan(`import { hello } from "export/";`)}
-   ${pc.cyan(`const message = await hello("World");`)}
-
-3. Deploy to Cloudflare Workers Sites:
-   ${pc.cyan("npm run export")}
-   ${pc.dim("# Builds Vite + deploys everything to Workers")}`,
-      "Ready"
-    );
-
-    p.outro(`Run ${pc.cyan("npm run dev")} to start!`);
-  } else {
-    console.log("Export initialized successfully!");
-    console.log("\nNext steps:");
-    console.log("  npm run dev");
+  // Install exportc in main project
+  console.log(pc.gray("Installing exportc..."));
+  try {
+    execSync("npm install", { cwd, stdio: "pipe" });
+    console.log(pc.green("✓") + " Installed exportc");
+  } catch {
+    console.log(pc.yellow("!") + " Failed to install. Run: npm install");
   }
+
+  // Done
+  console.log();
+  console.log(pc.green("Done!") + " Run " + pc.cyan("npm run dev") + " to start.");
+  console.log();
+  console.log(pc.gray("  import { hello } from \"export/\";"));
+  console.log(pc.gray("  await hello(\"World\");"));
 }

package/index.js

@@ -1,7 +1,6 @@
 #!/usr/bin/env node
 
 import mri from "mri";
-import * as p from "@clack/prompts";
 import pc from "picocolors";
 import { init } from "./commands/init.js";
 import { dev } from "./commands/dev.js";
@@ -11,36 +10,32 @@ const argv = mri(process.argv.slice(2), {
   alias: {
     h: "help",
     v: "version",
+    y: "yes",
   },
-  boolean: ["help", "version"],
+  boolean: ["help", "version", "yes"],
 });
 
 const command = argv._[0];
 
 const HELP = `
-${pc.bold("exportc")} - Add export to existing projects
+${pc.bold("exportc")} - Add export to existing Vite projects
 
 ${pc.bold("Usage:")}
   exportc <command> [options]
 
 ${pc.bold("Commands:")}
-  init          Initialize export in an existing Vite project
-  dev           Start development server (Vite + Wrangler)
+  init          Initialize export in a Vite project
+  dev           Start Wrangler dev server
   deploy        Deploy to Cloudflare Workers
 
 ${pc.bold("Options:")}
   -h, --help    Show this help message
   -v, --version Show version number
 
-${pc.bold("Examples:")}
+${pc.bold("Example:")}
   ${pc.dim("# Add export to your Vite project")}
   npx exportc init
-
-  ${pc.dim("# Start development")}
-  npx exportc dev
-
-  ${pc.dim("# Deploy to Cloudflare")}
-  npx exportc deploy
+  npm run dev
 `;
 
 if (argv.help || !command) {
@@ -70,6 +65,6 @@ if (!handler) {
 try {
   await handler(argv);
 } catch (err) {
-  p.cancel(err.message);
+  console.error(pc.red("Error:"), err.message);
   process.exit(1);
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "exportc",
-  "version": "0.0.6",
+  "version": "0.0.8",
   "description": "CLI to add export to existing projects",
   "scripts": {
     "test": "node --test test/init.test.mjs",
@@ -39,7 +39,6 @@
     "commands"
   ],
   "dependencies": {
-    "@clack/prompts": "^0.8.2",
     "mri": "^1.2.0",
     "picocolors": "^1.1.1"
   },