@frontman-ai/vite 0.1.0 → 0.1.2

package/README.md

@@ -0,0 +1,235 @@
+# @frontman-ai/vite
+
+Vite integration for Frontman - provides AI-powered development tools for any Vite-based application (React, Vue, Svelte, SolidJS, vanilla, etc.).
+
+## Installation
+
+### Quick Install (Recommended)
+
+The fastest way to install Frontman is using our CLI installer:
+
+```bash
+npx @frontman-ai/vite install
+
+# Or with a custom server host
+npx @frontman-ai/vite install --server frontman.company.com
+```
+
+The installer will:
+- Detect your Vite project and package manager
+- Install `@frontman-ai/vite` as a dev dependency
+- Add `frontmanPlugin()` to your `vite.config.ts` plugins array (or create one)
+
+### CLI Options
+
+```bash
+npx @frontman-ai/vite install [options]
+
+Options:
+  --server <host>   Frontman server host (default: api.frontman.sh)
+  --prefix <path>   Target directory (default: current directory)
+  --dry-run         Preview changes without writing files
+  --skip-deps       Skip dependency installation
+  --help            Show help message
+```
+
+### Manual Installation
+
+If you prefer to set things up manually or need to integrate with an existing configuration:
+
+```bash
+npm install -D @frontman-ai/vite
+```
+
+Then follow the [Manual Setup](#manual-setup) instructions below.
+
+## Quick Start
+
+After running the installer, you're ready to go! Start your Vite dev server:
+
+```bash
+npm run dev
+```
+
+Then open your browser to `http://localhost:5173/frontman` to access the Frontman UI.
+
+## Manual Setup
+
+Add the plugin to your `vite.config.ts`:
+
+```typescript
+import { defineConfig } from 'vite';
+import { frontmanPlugin } from '@frontman-ai/vite';
+
+export default defineConfig({
+  plugins: [
+    frontmanPlugin(),
+  ],
+});
+```
+
+That's it! The plugin hooks into Vite's dev server and serves the Frontman UI at `/frontman`.
+
+## Adding to Existing Config
+
+If you already have a `vite.config.ts` with plugins, add `frontmanPlugin()` to your existing plugins array:
+
+```typescript
+import { defineConfig } from 'vite';
+import react from '@vitejs/plugin-react';
+import { frontmanPlugin } from '@frontman-ai/vite';
+
+export default defineConfig({
+  plugins: [
+    frontmanPlugin(),
+    react(),
+    // ...your other plugins
+  ],
+});
+```
+
+### Installer shows "manual modification required"
+
+This happens when the installer can't find a `plugins: [` array in your Vite config. Manually add the import and plugin as shown above.
+
+## Configuration Options
+
+```typescript
+import { frontmanPlugin } from '@frontman-ai/vite';
+
+frontmanPlugin({
+  // All options are optional
+  isDev: true,                    // Development mode (default: NODE_ENV !== "production")
+  basePath: 'frontman',           // Base path for Frontman routes (default: "frontman")
+  host: 'frontman.local:4000',    // Frontman server host (default: env FRONTMAN_HOST or "frontman.local:4000")
+  clientUrl: 'https://...',       // Custom client bundle URL
+  clientCssUrl: 'https://...',    // Custom client CSS URL
+  entrypointUrl: 'http://...',    // Custom entrypoint URL for the API
+  isLightTheme: false,            // Use light theme (default: false / dark)
+  projectRoot: '.',               // Project root directory (default: env PROJECT_ROOT or cwd)
+  sourceRoot: '.',                // Source root for resolving file paths (default: projectRoot)
+});
+```
+
+### Understanding the `host` Option
+
+The `host` option specifies the Frontman server that the client UI will connect to for AI capabilities. When you visit `/frontman` in your Vite app:
+
+1. The plugin serves the Frontman UI HTML
+2. The UI loads the client JavaScript with `?host=<your-host>`
+3. The client establishes a WebSocket connection to `wss://<host>/socket`
+4. AI interactions and tool calls flow through this connection
+
+The plugin itself doesn't connect to the Frontman server - it only passes the host to the client.
+
+**Examples:**
+- Production: `host: 'api.frontman.sh'` → client connects to `wss://api.frontman.sh/socket`
+- Local dev: `host: 'frontman.local:4000'` → client connects to `wss://frontman.local:4000/socket`
+
+## Supported Frameworks
+
+This plugin works with any Vite-based project:
+
+- React (via `@vitejs/plugin-react`)
+- Vue (via `@vitejs/plugin-vue`)
+- Svelte (via `@sveltejs/vite-plugin-svelte`)
+- SolidJS (via `vite-plugin-solid`)
+- Vanilla JS/TS
+- Any other Vite-compatible framework
+
+| Version | Status |
+|---------|--------|
+| Vite 5.x | Fully supported |
+| Vite 6.x | Fully supported |
+
+## Architecture
+
+```
+Vite Dev Server
+│
+├─> configureServer hook
+│   └─> frontmanPlugin registers Connect middleware
+│       └─> Adapts Node.js req/res ↔ Web API Request/Response
+│
+├─> GET /frontman
+│   └─> Serves Frontman UI (HTML + client bundle)
+│       └─> Client connects to Frontman server via WebSocket
+│
+├─> GET /frontman/tools
+│   └─> Returns tool definitions from ToolRegistry
+│       └─> Core tools (file read, write, search, etc.)
+│
+├─> POST /frontman/tools/call
+│   └─> Executes tool → returns SSE stream with results
+│
+└─> POST /frontman/resolve-source-location
+    └─> Resolves source maps to original component locations
+```
+
+### Key Technical Details
+
+**Node.js ↔ Web API Adapter**
+- Vite's dev server uses Node.js `IncomingMessage`/`ServerResponse`
+- Frontman middleware uses Web API `Request`/`Response`
+- The plugin adapts between the two, including SSE stream piping
+
+**Available Endpoints**
+
+| Route | Method | Description |
+|-------|--------|-------------|
+| `GET /frontman` | GET | Serves the Frontman UI |
+| `GET /frontman/tools` | GET | Returns available tool definitions |
+| `POST /frontman/tools/call` | POST | Executes a tool call (SSE response) |
+| `POST /frontman/resolve-source-location` | POST | Resolves source maps to original locations |
+| `OPTIONS /frontman/*` | OPTIONS | CORS preflight handling |
+
+Non-frontman routes pass through to Vite's normal dev server handling.
+
+## Troubleshooting
+
+### Frontman UI not loading
+
+**Check 1: Verify the plugin is registered**
+Make sure `frontmanPlugin()` is in your `vite.config.ts` plugins array and your dev server is running.
+
+**Check 2: Check the URL**
+The default path is `http://localhost:5173/frontman`. If you changed the `basePath` option, use that path instead.
+
+**Check 3: Check for port conflicts**
+If Vite is running on a different port, use that port in the URL (e.g., `http://localhost:3000/frontman`).
+
+### Installer shows "manual modification required"
+
+This happens when the installer can't find a `plugins: [` array in your Vite config to inject into. Manually add the import and plugin call as shown in [Manual Setup](#manual-setup).
+
+### CORS errors in browser console
+
+The plugin includes CORS headers for all `/frontman/*` routes. If you're seeing CORS errors, verify the request is going to the correct Vite dev server URL.
+
+## API
+
+### `frontmanPlugin(options?)`
+
+Creates a Vite plugin that serves the Frontman UI and tool endpoints on the dev server.
+
+```typescript
+import { frontmanPlugin } from '@frontman-ai/vite';
+
+const plugin = frontmanPlugin({
+  host: string,                // Frontman server host (default: env FRONTMAN_HOST or "frontman.local:4000")
+  basePath: string,            // Base path (default: "frontman")
+  isDev: boolean,              // Dev mode (default: NODE_ENV !== "production")
+  projectRoot: string,         // Project root (default: env PROJECT_ROOT or cwd)
+  sourceRoot: string,          // Source root (default: projectRoot)
+  clientUrl: string,           // Custom client bundle URL
+  clientCssUrl: string,        // Custom client CSS URL
+  entrypointUrl: string,       // Custom entrypoint URL
+  isLightTheme: boolean,       // Light theme (default: false)
+});
+```
+
+**Returns:** A Vite plugin object with `name: "frontman"` and a `configureServer` hook.
+
+## License
+
+Apache-2.0

package/dist/cli.js

@@ -0,0 +1,836 @@
+#!/usr/bin/env node
+import * as Process from 'process';
+import * as Fs from 'fs';
+import * as Nodepath from 'path';
+
+// ../../node_modules/@rescript/runtime/lib/es6/Primitive_option.js
+function some(x) {
+  if (x === void 0) {
+    return {
+      BS_PRIVATE_NESTED_SOME_NONE: 0
+    };
+  } else if (x !== null && x.BS_PRIVATE_NESTED_SOME_NONE !== void 0) {
+    return {
+      BS_PRIVATE_NESTED_SOME_NONE: x.BS_PRIVATE_NESTED_SOME_NONE + 1 | 0
+    };
+  } else {
+    return x;
+  }
+}
+function fromNullable(x) {
+  if (x == null) {
+    return;
+  } else {
+    return some(x);
+  }
+}
+function valFromOption(x) {
+  if (x === null || x.BS_PRIVATE_NESTED_SOME_NONE === void 0) {
+    return x;
+  }
+  let depth = x.BS_PRIVATE_NESTED_SOME_NONE;
+  if (depth === 0) {
+    return;
+  } else {
+    return {
+      BS_PRIVATE_NESTED_SOME_NONE: depth - 1 | 0
+    };
+  }
+}
+
+// ../../node_modules/@rescript/runtime/lib/es6/Stdlib_Option.js
+function mapOr(opt, $$default, f) {
+  if (opt !== void 0) {
+    return f(valFromOption(opt));
+  } else {
+    return $$default;
+  }
+}
+function map(opt, f) {
+  if (opt !== void 0) {
+    return some(f(valFromOption(opt)));
+  }
+}
+function flatMap(opt, f) {
+  if (opt !== void 0) {
+    return f(valFromOption(opt));
+  }
+}
+function getOr(opt, $$default) {
+  if (opt !== void 0) {
+    return valFromOption(opt);
+  } else {
+    return $$default;
+  }
+}
+function isSome(x) {
+  return x !== void 0;
+}
+
+// ../../node_modules/@rescript/runtime/lib/es6/Primitive_exceptions.js
+function isExtension(e) {
+  if (e == null) {
+    return false;
+  } else {
+    return typeof e.RE_EXN_ID === "string";
+  }
+}
+function internalToException(e) {
+  if (isExtension(e)) {
+    return e;
+  } else {
+    return {
+      RE_EXN_ID: "JsExn",
+      _1: e
+    };
+  }
+}
+
+// ../bindings/src/ChildProcess.res.mjs
+var execPromise = (async function(command, options) {
+  const { exec } = await import('child_process');
+  const { promisify } = await import('util');
+  const execP = promisify(exec);
+  return await execP(command, options);
+});
+var bufferToString = (function(value) {
+  if (value == null) return "";
+  if (typeof value === "string") return value;
+  if (Buffer.isBuffer(value)) return value.toString("utf8");
+  return String(value);
+});
+async function execWithOptions(command, options) {
+  try {
+    let newrecord = { ...options };
+    newrecord.maxBuffer = getOr(options.maxBuffer, 52428800);
+    let result = await execPromise(command, newrecord);
+    return {
+      TAG: "Ok",
+      _0: {
+        stdout: bufferToString(result.stdout),
+        stderr: bufferToString(result.stderr)
+      }
+    };
+  } catch (raw_exn) {
+    let exn = internalToException(raw_exn);
+    let actualError = getOr(fromNullable(exn._1), exn);
+    return {
+      TAG: "Error",
+      _0: {
+        code: fromNullable(actualError.code),
+        stdout: getOr(map(fromNullable(actualError.stdout), bufferToString), ""),
+        stderr: getOr(map(fromNullable(actualError.stderr), bufferToString), "")
+      }
+    };
+  }
+}
+
+// src/cli/FrontmanVite__Cli__Style.res.mjs
+var esc = "\x1B";
+function purple(text) {
+  return esc + `[38;2;152;93;247m` + text + esc + `[0m`;
+}
+function purpleBold(text) {
+  return esc + `[1;38;2;152;93;247m` + text + esc + `[0m`;
+}
+function purpleDim(text) {
+  return esc + `[38;2;128;81;205m` + text + esc + `[0m`;
+}
+function green(text) {
+  return esc + `[32m` + text + esc + `[0m`;
+}
+function yellow(text) {
+  return esc + `[33m` + text + esc + `[0m`;
+}
+function yellowBold(text) {
+  return esc + `[1;33m` + text + esc + `[0m`;
+}
+function bold(text) {
+  return esc + `[1m` + text + esc + `[0m`;
+}
+function dim(text) {
+  return esc + `[2m` + text + esc + `[0m`;
+}
+var check = green("\u2714");
+var warn = yellow("\u26A0");
+var bullet = purple("\u25B8");
+var divider = purple("\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501");
+
+// ../../node_modules/@rescript/runtime/lib/es6/Stdlib_JSON.js
+function bool(json) {
+  if (typeof json === "boolean") {
+    return json;
+  }
+}
+function $$null(json) {
+  if (json === null) {
+    return null;
+  }
+}
+function string(json) {
+  if (typeof json === "string") {
+    return json;
+  }
+}
+function float(json) {
+  if (typeof json === "number") {
+    return json;
+  }
+}
+function object(json) {
+  if (typeof json === "object" && json !== null && !Array.isArray(json)) {
+    return json;
+  }
+}
+function array(json) {
+  if (Array.isArray(json)) {
+    return json;
+  }
+}
+var Decode = {
+  bool,
+  $$null,
+  string,
+  float,
+  object,
+  array
+};
+
+// src/cli/FrontmanVite__Cli__Detect.res.mjs
+async function fileExists(path) {
+  try {
+    await Fs.promises.access(path);
+    return true;
+  } catch (exn) {
+    return false;
+  }
+}
+async function readFile(path) {
+  try {
+    return await Fs.promises.readFile(path, "utf8");
+  } catch (exn) {
+    return;
+  }
+}
+async function detectPackageManager(projectDir) {
+  let checkDir = async (dir) => {
+    let bunLockb = Nodepath.join(dir, "bun.lockb");
+    let bunLock = Nodepath.join(dir, "bun.lock");
+    let denoLock = Nodepath.join(dir, "deno.lock");
+    let pnpmLock = Nodepath.join(dir, "pnpm-lock.yaml");
+    let yarnLock = Nodepath.join(dir, "yarn.lock");
+    let npmLock = Nodepath.join(dir, "package-lock.json");
+    if (await fileExists(bunLockb) || await fileExists(bunLock)) {
+      return "Bun";
+    } else if (await fileExists(denoLock)) {
+      return "Deno";
+    } else if (await fileExists(pnpmLock)) {
+      return "Pnpm";
+    } else if (await fileExists(yarnLock)) {
+      return "Yarn";
+    } else if (await fileExists(npmLock)) {
+      return "Npm";
+    } else {
+      return;
+    }
+  };
+  let pm = await checkDir(projectDir);
+  if (pm !== void 0) {
+    return pm;
+  }
+  let parentDir = Nodepath.dirname(projectDir);
+  if (parentDir === projectDir) {
+    return "Npm";
+  }
+  let pm$1 = await checkDir(parentDir);
+  if (pm$1 !== void 0) {
+    return pm$1;
+  }
+  let grandparentDir = Nodepath.dirname(parentDir);
+  if (grandparentDir === parentDir) {
+    return "Npm";
+  }
+  let pm$2 = await checkDir(grandparentDir);
+  if (pm$2 !== void 0) {
+    return pm$2;
+  } else {
+    return "Npm";
+  }
+}
+var frontmanImportPattern = /@frontman-ai\/vite|frontman-vite|frontmanPlugin/;
+async function findViteConfig(projectDir) {
+  let candidates = [
+    "vite.config.ts",
+    "vite.config.js",
+    "vite.config.mts",
+    "vite.config.mjs"
+  ];
+  let check2 = async (remaining) => {
+    let fileName = remaining[0];
+    if (fileName === void 0) {
+      return;
+    }
+    let filePath = Nodepath.join(projectDir, fileName);
+    let content = await readFile(filePath);
+    if (content !== void 0) {
+      return [
+        fileName,
+        content
+      ];
+    }
+    let rest = remaining.slice(1, remaining.length);
+    return await check2(rest);
+  };
+  return await check2(candidates);
+}
+async function analyzeViteConfig(projectDir) {
+  let match = await findViteConfig(projectDir);
+  if (match === void 0) {
+    return [
+      "NotFound",
+      "vite.config.ts"
+    ];
+  }
+  let content = match[1];
+  let fileName = match[0];
+  if (frontmanImportPattern.test(content)) {
+    return [
+      "HasFrontman",
+      fileName
+    ];
+  }
+  let filePath = Nodepath.join(projectDir, fileName);
+  return [
+    {
+      TAG: "NeedsFrontman",
+      filePath,
+      content
+    },
+    fileName
+  ];
+}
+async function hasPackageJson(projectDir) {
+  return await fileExists(Nodepath.join(projectDir, "package.json"));
+}
+async function hasViteDependency(projectDir) {
+  let pkgPath = Nodepath.join(projectDir, "package.json");
+  let content = await readFile(pkgPath);
+  if (content === void 0) {
+    return false;
+  }
+  try {
+    let json = JSON.parse(content);
+    let obj = Decode.object(json);
+    if (obj === void 0) {
+      return false;
+    }
+    let checkDeps = (key) => mapOr(flatMap(obj[key], Decode.object), false, (deps) => isSome(deps["vite"]));
+    if (checkDeps("dependencies")) {
+      return true;
+    } else {
+      return checkDeps("devDependencies");
+    }
+  } catch (exn) {
+    return false;
+  }
+}
+async function detect(projectDir) {
+  let hasPackage = await hasPackageJson(projectDir);
+  if (!hasPackage) {
+    return {
+      TAG: "Error",
+      _0: "No package.json found. Please run from your Vite project root."
+    };
+  }
+  let hasVite = await hasViteDependency(projectDir);
+  if (!hasVite) {
+    return {
+      TAG: "Error",
+      _0: "Could not find vite in package.json. Please verify this is a Vite project."
+    };
+  }
+  let match = await analyzeViteConfig(projectDir);
+  let packageManager = await detectPackageManager(projectDir);
+  return {
+    TAG: "Ok",
+    _0: {
+      viteConfig: match[0],
+      packageManager,
+      viteConfigFileName: match[1]
+    }
+  };
+}
+function getPackageManagerCommand(pm) {
+  switch (pm) {
+    case "Npm":
+      return "npm";
+    case "Yarn":
+      return "npx yarn";
+    case "Pnpm":
+      return "npx pnpm";
+    case "Bun":
+      return "bun";
+    case "Deno":
+      return "deno";
+  }
+}
+function getDevCommand(pm) {
+  switch (pm) {
+    case "Npm":
+      return "npm run dev";
+    case "Yarn":
+      return "yarn dev";
+    case "Pnpm":
+      return "pnpm dev";
+    case "Bun":
+      return "bun dev";
+    case "Deno":
+      return "deno task dev";
+  }
+}
+function getInstallArgs(pm) {
+  switch (pm) {
+    case "Npm":
+      return [
+        "install",
+        "-D"
+      ];
+    case "Yarn":
+      return [
+        "add",
+        "-D"
+      ];
+    case "Pnpm":
+      return [
+        "add",
+        "--save-dev"
+      ];
+    case "Bun":
+    case "Deno":
+      return [
+        "add",
+        "--dev"
+      ];
+  }
+}
+
+// src/cli/FrontmanVite__Cli__Templates.res.mjs
+function banner() {
+  let l1 = purpleBold("   ___              _                       ");
+  let l2 = purpleBold("  | __| _ ___ _ _ | |_ _ __  __ _ _ _  ");
+  let l3 = purpleBold("  | _| '_/ _ \\ ' \\|  _| '  \\/ _` | ' \\ ");
+  let l4 = purpleBold("  |_||_| \\___/_||_|\\__|_|_|_\\__,_|_||_|");
+  let tagline = purpleDim("  AI that sees your DOM and edits your frontend");
+  return `
+` + l1 + `
+` + l2 + `
+` + l3 + `
+` + l4 + `
+
+` + tagline + `
+`;
+}
+function viteConfig(fileName) {
+  let bar = yellow("|");
+  return `  ` + bar + `
+  ` + bar + `  ` + yellowBold(fileName) + ` needs manual modification.
+  ` + bar + `
+  ` + bar + `  ` + purple("1.") + ` Add import at the top of the file:
+  ` + bar + `
+  ` + bar + `     ` + dim("import { frontmanPlugin } from '@frontman-ai/vite';") + `
+  ` + bar + `
+  ` + bar + `  ` + purple("2.") + ` Add ` + bold("frontmanPlugin()") + ` to your plugins array:
+  ` + bar + `
+  ` + bar + `     ` + dim("plugins: [") + `
+  ` + bar + `     ` + dim("  frontmanPlugin(),") + `
+  ` + bar + `     ` + dim("  // ...your other plugins") + `
+  ` + bar + `     ` + dim("],") + `
+  ` + bar + `
+  ` + bar + `  ` + bold("Docs:") + ` ` + dim("https://frontman.sh/docs/vite") + `
+  ` + bar;
+}
+var ManualInstructions = {
+  viteConfig
+};
+function fileCreated(fileName) {
+  return `  ` + check + ` Created ` + bold(fileName);
+}
+function fileUpdated(fileName) {
+  return `  ` + check + ` Updated ` + bold(fileName) + ` ` + dim("(added frontmanPlugin)");
+}
+function fileSkipped(fileName) {
+  return `  ` + purple("\u2013") + ` Skipped ` + bold(fileName) + ` ` + dim("(already configured)");
+}
+function manualEditRequired(fileName) {
+  return `  ` + warn + `  ` + bold(fileName) + ` requires manual setup ` + dim("(see details below)");
+}
+function installComplete(devCommand, port) {
+  return `
+  ` + purpleBold("Frontman setup complete!") + `
+
+  ` + purpleBold("Next steps:") + `
+    ` + purple("1.") + ` Start your dev server   ` + dim(devCommand) + `
+    ` + purple("2.") + ` Open your browser to    ` + dim(`http://localhost:` + port + `/frontman`) + `
+
+  ` + purple("\u250C\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2510") + `
+  ` + purple("\u2502") + `                                               ` + purple("\u2502") + `
+  ` + purple("\u2502") + `   Questions? Comments? Need support?          ` + purple("\u2502") + `
+  ` + purple("\u2502") + `                                               ` + purple("\u2502") + `
+  ` + purple("\u2502") + `       Join us on Discord:                     ` + purple("\u2502") + `
+  ` + purple("\u2502") + `       ` + purpleDim("https://discord.gg/J77jBzMM") + `             ` + purple("\u2502") + `
+  ` + purple("\u2502") + `                                               ` + purple("\u2502") + `
+  ` + purple("\u2514\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2518") + `
+`;
+}
+var dryRunHeader = `  ` + warn + `  ` + yellowBold("DRY RUN MODE") + ` ` + dim("\u2014 No files will be created") + `
+`;
+var SuccessMessages = {
+  fileCreated,
+  fileUpdated,
+  fileSkipped,
+  manualEditRequired,
+  installComplete,
+  dryRunHeader
+};
+var importLine = `import { frontmanPlugin } from '@frontman-ai/vite';`;
+
+// src/cli/FrontmanVite__Cli__Install.res.mjs
+async function installDependencies(projectDir, packageManager, dryRun) {
+  let pm = getPackageManagerCommand(packageManager);
+  let args = getInstallArgs(packageManager);
+  let packages = ["@frontman-ai/vite"];
+  let packages$1;
+  packages$1 = packageManager === "Deno" ? packages.map((p) => "npm:" + p) : packages;
+  let cmd = pm + ` ` + args.join(" ") + ` ` + packages$1.join(" ");
+  if (dryRun) {
+    console.log(`  ` + dim(`Would run: ` + cmd));
+    return {
+      TAG: "Ok",
+      _0: void 0
+    };
+  }
+  console.log(`  ` + purple("Installing dependencies with " + pm + "..."));
+  let err = await execWithOptions(cmd, {
+    cwd: projectDir
+  });
+  if (err.TAG === "Ok") {
+    console.log(`  ` + check + ` Dependencies installed`);
+    return {
+      TAG: "Ok",
+      _0: void 0
+    };
+  }
+  let err$1 = err._0;
+  let stderr = err$1.stderr === "" ? "Unknown error" : err$1.stderr;
+  return {
+    TAG: "Error",
+    _0: `Failed to install dependencies: ` + stderr
+  };
+}
+function injectFrontmanPlugin(content) {
+  let pluginsPattern = /plugins\s*:\s*\[/;
+  if (!pluginsPattern.test(content)) {
+    return {
+      TAG: "Error",
+      _0: "Could not find a `plugins: [` array in your Vite config"
+    };
+  }
+  let importStatement = importLine + "\n";
+  let lines = content.split("\n");
+  let lastImportIdx = {
+    contents: -1
+  };
+  lines.forEach((line, idx) => {
+    let trimmed = line.trim();
+    if (trimmed.startsWith("import ") || trimmed.startsWith("import{")) {
+      lastImportIdx.contents = idx;
+      return;
+    }
+  });
+  let contentWithImport;
+  if (lastImportIdx.contents >= 0) {
+    let before = lines.slice(0, lastImportIdx.contents + 1 | 0).join("\n");
+    let after = lines.slice(lastImportIdx.contents + 1 | 0, lines.length).join("\n");
+    contentWithImport = before + "\n" + importStatement + after;
+  } else {
+    contentWithImport = importStatement + "\n" + content;
+  }
+  let result = contentWithImport.replace(/plugins\s*:\s*\[/, "plugins: [\n    frontmanPlugin(),");
+  return {
+    TAG: "Ok",
+    _0: result
+  };
+}
+async function handleViteConfig(projectDir, info, dryRun) {
+  let match = info.viteConfig;
+  if (typeof match !== "object") {
+    if (match === "NotFound") {
+      let fileName = "vite.config.ts";
+      let filePath = Nodepath.join(projectDir, fileName);
+      if (dryRun) {
+        console.log(`  ` + dim(`Would create: ` + fileName));
+        return {
+          TAG: "Ok",
+          _0: void 0
+        };
+      } else {
+        await Fs.promises.writeFile(filePath, `import { defineConfig } from 'vite';
+import { frontmanPlugin } from '@frontman-ai/vite';
+
+export default defineConfig({
+  plugins: [
+    frontmanPlugin(),
+  ],
+});
+`, "utf8");
+        console.log(SuccessMessages.fileCreated(fileName));
+        return {
+          TAG: "Ok",
+          _0: void 0
+        };
+      }
+    }
+    console.log(SuccessMessages.fileSkipped(info.viteConfigFileName));
+    return {
+      TAG: "Ok",
+      _0: void 0
+    };
+  } else {
+    if (dryRun) {
+      console.log(`  ` + dim(`Would modify: ` + info.viteConfigFileName));
+      return {
+        TAG: "Ok",
+        _0: void 0
+      };
+    }
+    let newContent = injectFrontmanPlugin(match.content);
+    if (newContent.TAG === "Ok") {
+      await Fs.promises.writeFile(match.filePath, newContent._0, "utf8");
+      console.log(SuccessMessages.fileUpdated(info.viteConfigFileName));
+      return {
+        TAG: "Ok",
+        _0: void 0
+      };
+    }
+    console.log(SuccessMessages.manualEditRequired(info.viteConfigFileName));
+    return {
+      TAG: "Error",
+      _0: ManualInstructions.viteConfig(info.viteConfigFileName)
+    };
+  }
+}
+async function run(options) {
+  let projectDir = getOr(options.prefix, process.cwd());
+  console.log(banner());
+  console.log(`  ` + bullet + ` ` + bold("Server:") + `   ` + options.server);
+  if (options.dryRun) {
+    console.log("");
+    console.log(SuccessMessages.dryRunHeader);
+  }
+  let msg = await detect(projectDir);
+  if (msg.TAG === "Ok") {
+    let info = msg._0;
+    console.log(`  ` + bullet + ` ` + bold("Detected:") + ` Vite project`);
+    console.log("");
+    if (!options.skipDeps) {
+      let msg$1 = await installDependencies(projectDir, info.packageManager, options.dryRun);
+      if (msg$1.TAG !== "Ok") {
+        console.error(`  ` + warn + `  ` + msg$1._0);
+      }
+      console.log("");
+    }
+    let manualSteps = [];
+    let details = await handleViteConfig(projectDir, info, options.dryRun);
+    if (details.TAG !== "Ok") {
+      manualSteps.push(details._0);
+    }
+    if (manualSteps.length !== 0) {
+      console.log("");
+      console.log(`  ` + divider);
+      console.log("");
+      console.log(`  ` + yellowBold("Manual steps required:"));
+      console.log("");
+      manualSteps.forEach((step) => {
+        console.log(step);
+      });
+      console.log("");
+      return {
+        TAG: "PartialSuccess",
+        manualStepsRequired: manualSteps
+      };
+    }
+    if (!options.dryRun) {
+      let devCommand = getDevCommand(info.packageManager);
+      console.log("");
+      console.log(`  ` + divider);
+      console.log(SuccessMessages.installComplete(devCommand, "5173"));
+    }
+    return "Success";
+  }
+  let msg$2 = msg._0;
+  console.error(`  ` + warn + `  ` + bold("Error:") + ` ` + msg$2);
+  return {
+    TAG: "Failure",
+    _0: msg$2
+  };
+}
+
+// src/cli/FrontmanVite__Cli.res.mjs
+var helpText = `
+Frontman Vite CLI
+
+Usage:
+  @frontman-ai/vite <command> [options]
+
+Commands:
+  install    Install Frontman in a Vite project
+
+Options:
+  --server <host>   Frontman server host (default: api.frontman.sh)
+  --prefix <path>   Target directory (default: current directory)
+  --dry-run         Preview changes without writing files
+  --skip-deps       Skip dependency installation
+  --help            Show this help message
+
+Examples:
+  npx @frontman-ai/vite install
+  npx @frontman-ai/vite install --server frontman.company.com
+  npx @frontman-ai/vite install --dry-run
+`;
+function parseArgs(argv) {
+  let args = argv.slice(2, argv.length);
+  let _remaining = args;
+  let _result = {
+    command: void 0,
+    server: void 0,
+    prefix: void 0,
+    dryRun: false,
+    skipDeps: false,
+    help: false
+  };
+  while (true) {
+    let result = _result;
+    let remaining = _remaining;
+    let arg = remaining[0];
+    if (arg === void 0) {
+      return result;
+    }
+    let rest = remaining.slice(1, remaining.length);
+    switch (arg) {
+      case "--dry-run":
+        _result = {
+          command: result.command,
+          server: result.server,
+          prefix: result.prefix,
+          dryRun: true,
+          skipDeps: result.skipDeps,
+          help: result.help
+        };
+        _remaining = rest;
+        continue;
+      case "--prefix":
+        let value = rest[0];
+        let nextRest = rest.slice(1, rest.length);
+        _result = {
+          command: result.command,
+          server: result.server,
+          prefix: value,
+          dryRun: result.dryRun,
+          skipDeps: result.skipDeps,
+          help: result.help
+        };
+        _remaining = nextRest;
+        continue;
+      case "--server":
+        let value$1 = rest[0];
+        let nextRest$1 = rest.slice(1, rest.length);
+        _result = {
+          command: result.command,
+          server: value$1,
+          prefix: result.prefix,
+          dryRun: result.dryRun,
+          skipDeps: result.skipDeps,
+          help: result.help
+        };
+        _remaining = nextRest$1;
+        continue;
+      case "--skip-deps":
+        _result = {
+          command: result.command,
+          server: result.server,
+          prefix: result.prefix,
+          dryRun: result.dryRun,
+          skipDeps: true,
+          help: result.help
+        };
+        _remaining = rest;
+        continue;
+      case "--help":
+      case "-h":
+        break;
+      case "install":
+        _result = {
+          command: "install",
+          server: result.server,
+          prefix: result.prefix,
+          dryRun: result.dryRun,
+          skipDeps: result.skipDeps,
+          help: result.help
+        };
+        _remaining = rest;
+        continue;
+      default:
+        _remaining = rest;
+        continue;
+    }
+    _result = {
+      command: result.command,
+      server: result.server,
+      prefix: result.prefix,
+      dryRun: result.dryRun,
+      skipDeps: result.skipDeps,
+      help: true
+    };
+    _remaining = rest;
+    continue;
+  }
+}
+async function main() {
+  let args = parseArgs(process.argv);
+  if (args.help) {
+    console.log(helpText);
+    Process.exit(0);
+  }
+  let cmd = args.command;
+  if (cmd !== void 0) {
+    if (cmd === "install") {
+      let server = getOr(args.server, "api.frontman.sh");
+      let result = await run({
+        server,
+        prefix: args.prefix,
+        dryRun: args.dryRun,
+        skipDeps: args.skipDeps
+      });
+      if (typeof result !== "object") {
+        Process.exit(0);
+        return;
+      }
+      if (result.TAG === "PartialSuccess") {
+        Process.exit(0);
+        return;
+      }
+      Process.exit(1);
+      return;
+    } else {
+      console.error(`Unknown command: ` + cmd);
+      console.log(helpText);
+      Process.exit(1);
+      return;
+    }
+  } else {
+    console.log(helpText);
+    Process.exit(0);
+    return;
+  }
+}
+main();

package/dist/index.d.ts

@@ -20,20 +20,22 @@ import * as FrontmanCore__ToolRegistry$FrontmanFrontmanCore from '@frontman/fron
 // Generated by ReScript, PLEASE EDIT WITH CARE
 
 
+let productionHost = "api.frontman.sh";
+
 let host = process.env["FRONTMAN_HOST"];
 
 let defaultHost = host !== undefined ? host : "frontman.local:4000";
 
 function makeFromObject(config) {
-  let isDev = Stdlib_Option.getOr(config.isDev, Stdlib_Option.mapOr(process.env["NODE_ENV"], true, env => env === "development"));
+  let host = Stdlib_Option.getOr(config.host, defaultHost);
+  let isDev = Stdlib_Option.getOr(config.isDev, host !== productionHost);
   let projectRoot = Stdlib_Option.getOr(Stdlib_Option.orElse(config.projectRoot, Stdlib_Option.orElse(process.env["PROJECT_ROOT"], process.env["PWD"])), ".");
   let sourceRoot = Stdlib_Option.getOr(config.sourceRoot, projectRoot);
   let basePath = Stdlib_Option.getOr(config.basePath, "frontman");
   let serverName = Stdlib_Option.getOr(config.serverName, "frontman-vite");
   let serverVersion = Stdlib_Option.getOr(config.serverVersion, "1.0.0");
-  let host = Stdlib_Option.getOr(config.host, defaultHost);
   let isLightTheme = Stdlib_Option.getOr(config.isLightTheme, false);
-  let baseUrl = Stdlib_Option.getOr(process.env["FRONTMAN_CLIENT_URL"], isDev ? "http://localhost:5173/src/Main.res.mjs" : "https://frontman.dev/frontman.es.js");
+  let baseUrl = Stdlib_Option.getOr(process.env["FRONTMAN_CLIENT_URL"], isDev ? "http://localhost:5173/src/Main.res.mjs" : "https://app.frontman.sh/frontman.es.js");
   let url = new URL(baseUrl);
   let clientUrl = Stdlib_Option.getOr(config.clientUrl, (url.searchParams.set("clientName", "vite"), url.searchParams.set("host", host), url.href));
   let parsedUrl = new URL(clientUrl);

package/dist/index.js

@@ -110,18 +110,19 @@ function orElse(opt, other) {
 }
 
 // src/FrontmanVite__Config.res.mjs
+var productionHost = "api.frontman.sh";
 var host = process.env["FRONTMAN_HOST"];
 var defaultHost = host !== void 0 ? host : "frontman.local:4000";
 function makeFromObject(config) {
-  let isDev = getOr(config.isDev, mapOr(process.env["NODE_ENV"], true, (env) => env === "development"));
+  let host2 = getOr(config.host, defaultHost);
+  let isDev = getOr(config.isDev, host2 !== productionHost);
   let projectRoot = getOr(orElse(config.projectRoot, orElse(process.env["PROJECT_ROOT"], process.env["PWD"])), ".");
   let sourceRoot = getOr(config.sourceRoot, projectRoot);
   let basePath = getOr(config.basePath, "frontman");
   let serverName = getOr(config.serverName, "frontman-vite");
   let serverVersion = getOr(config.serverVersion, "1.0.0");
-  let host2 = getOr(config.host, defaultHost);
   let isLightTheme = getOr(config.isLightTheme, false);
-  let baseUrl = getOr(process.env["FRONTMAN_CLIENT_URL"], isDev ? "http://localhost:5173/src/Main.res.mjs" : "https://frontman.dev/frontman.es.js");
+  let baseUrl = getOr(process.env["FRONTMAN_CLIENT_URL"], isDev ? "http://localhost:5173/src/Main.res.mjs" : "https://app.frontman.sh/frontman.es.js");
   let url2 = new URL(baseUrl);
   let clientUrl = getOr(config.clientUrl, (url2.searchParams.set("clientName", "vite"), url2.searchParams.set("host", host2), url2.href));
   let parsedUrl = new URL(clientUrl);

package/package.json

@@ -3,7 +3,7 @@
 	"publishConfig": {
 		"access": "public"
 	},
-	"version": "0.1.0",
+	"version": "0.1.2",
 	"description": "Vite integration for Frontman - AI-powered development tools",
 	"license": "Apache-2.0",
 	"author": "Frontman AI",
@@ -34,6 +34,10 @@
 			"default": "./dist/index.js"
 		}
 	},
+	"bin": {
+		"frontman-vite": "./dist/cli.js",
+		"@frontman-ai/vite": "./dist/cli.js"
+	},
 	"files": [
 		"dist",
 		"README.md"