@frontman-ai/nextjs 0.1.0

package/dist/cli.js

@@ -0,0 +1,1062 @@
+#!/usr/bin/env node
+import * as Process from 'process';
+import * as Fs2 from 'fs';
+import * as Nodepath2 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 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 isNone(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/FrontmanNextjs__Cli__Templates.res.mjs
+function middlewareTemplate(host) {
+  return `import { createMiddleware } from '@frontman-ai/nextjs';
+import { NextRequest, NextResponse } from 'next/server';
+
+const frontman = createMiddleware({
+  host: '` + host + `',
+});
+
+export async function middleware(req: NextRequest) {
+  const response = await frontman(req);
+  if (response) return response;
+  return NextResponse.next();
+}
+
+export const config = {
+  matcher: ['/__frontman/:path*'],
+};
+`;
+}
+function proxyTemplate(host) {
+  return `import { createMiddleware } from '@frontman-ai/nextjs';
+import { NextRequest, NextResponse } from 'next/server';
+
+const frontman = createMiddleware({
+  host: '` + host + `',
+});
+
+export function proxy(req: NextRequest): NextResponse | Promise<NextResponse> {
+  if (req.nextUrl.pathname.startsWith('/__frontman')) {
+    return frontman(req) || NextResponse.next();
+  }
+  return NextResponse.next();
+}
+`;
+}
+function instrumentationTemplate() {
+  return `export async function register() {
+  if (process.env.NEXT_RUNTIME === 'nodejs') {
+    const { NodeSDK } = await import('@opentelemetry/sdk-node');
+    const { setup } = await import('@frontman-ai/nextjs/Instrumentation');
+    const [logProcessor, spanProcessor] = setup();
+    new NodeSDK({
+      logRecordProcessors: [logProcessor],
+      spanProcessors: [spanProcessor],
+    }).start();
+  }
+}
+`;
+}
+function middlewareManualSetup(fileName) {
+  return `
+Error: ` + fileName + ` already exists and requires manual modification.
+
+Please add the following to your ` + fileName + `:
+
+  1. Import at the top of the file:
+     import { createMiddleware } from '@frontman-ai/nextjs';
+
+  2. Create the middleware instance:
+     const frontman = createMiddleware({
+       host: 'YOUR_FRONTMAN_HOST',
+     });
+
+  3. In your middleware function, add before other logic:
+     const response = await frontman(req);
+     if (response) return response;
+
+  4. Add to your matcher config:
+     matcher: ['/__frontman/:path*', ...yourExistingMatchers],
+
+For full documentation, see: https://frontman.dev/docs/nextjs
+`;
+}
+function instrumentationManualSetup(fileName) {
+  return `
+Error: ` + fileName + ` already exists and requires manual modification.
+
+Please add the following to your ` + fileName + `:
+
+  1. Inside your register() function, add:
+     if (process.env.NEXT_RUNTIME === 'nodejs') {
+       const { setup } = await import('@frontman-ai/nextjs/Instrumentation');
+       const [logProcessor, spanProcessor] = setup();
+
+       // Add to your NodeSDK configuration:
+       // logRecordProcessors: [logProcessor, ...yourExistingProcessors],
+       // spanProcessors: [spanProcessor, ...yourExistingProcessors],
+     }
+
+For full documentation, see: https://frontman.dev/docs/nextjs
+`;
+}
+var ErrorMessages = {
+  middlewareManualSetup,
+  proxyManualSetup: `
+Error: proxy.ts already exists and requires manual modification.
+
+Please add the following to your proxy.ts:
+
+  1. Import at the top of the file:
+     import { createMiddleware } from '@frontman-ai/nextjs';
+
+  2. Create the middleware instance:
+     const frontman = createMiddleware({
+       host: 'YOUR_FRONTMAN_HOST',
+     });
+
+  3. In your proxy function, add at the beginning:
+     if (req.nextUrl.pathname.startsWith('/__frontman')) {
+       return frontman(req) || NextResponse.next();
+     }
+
+For full documentation, see: https://frontman.dev/docs/nextjs
+`,
+  instrumentationManualSetup
+};
+function fileCreated(fileName) {
+  return `Created: ` + fileName;
+}
+function fileSkipped(fileName) {
+  return `Skipped: ` + fileName + ` (already configured for Frontman)`;
+}
+function hostUpdated(fileName, oldHost, newHost) {
+  return `Updated: ` + fileName + ` (host changed from '` + oldHost + `' to '` + newHost + `')`;
+}
+function installComplete(host) {
+  return `
+Frontman setup complete!
+
+Next steps:
+  1. Start your Next.js dev server: npm run dev
+  2. Open your browser to: http://localhost:3000/__frontman
+  3. Your app is now connected to: ` + host + `
+
+For documentation, visit: https://frontman.dev/docs
+`;
+}
+var SuccessMessages = {
+  fileCreated,
+  fileSkipped,
+  hostUpdated,
+  installComplete,
+  dryRunHeader: `
+DRY RUN MODE - No files will be created
+
+The following changes would be made:
+`
+};
+
+// src/cli/FrontmanNextjs__Cli__Files.res.mjs
+var hostPattern = /host:\s*['\"]([^'\"]+)['\"]/;
+function updateHostInContent(content, newHost) {
+  return content.replace(hostPattern, `host: '` + newHost + `'`);
+}
+async function readFile(path) {
+  try {
+    return await Fs2.promises.readFile(path, "utf8");
+  } catch (exn) {
+    return;
+  }
+}
+async function writeFile(path, content) {
+  try {
+    await Fs2.promises.writeFile(path, content, "utf8");
+    return {
+      TAG: "Ok",
+      _0: void 0
+    };
+  } catch (exn) {
+    return {
+      TAG: "Error",
+      _0: `Failed to write ` + path
+    };
+  }
+}
+async function handleMiddleware(projectDir, host, existingFile, dryRun) {
+  let filePath = Nodepath2.join(projectDir, "middleware.ts");
+  let fileName = "middleware.ts";
+  if (typeof existingFile !== "object") {
+    if (existingFile !== "NotFound") {
+      return {
+        TAG: "Ok",
+        _0: {
+          TAG: "ManualEditRequired",
+          _0: ErrorMessages.middlewareManualSetup(fileName)
+        }
+      };
+    }
+    if (dryRun) {
+      return {
+        TAG: "Ok",
+        _0: {
+          TAG: "Created",
+          _0: fileName
+        }
+      };
+    }
+    let content = middlewareTemplate(host);
+    let e = await writeFile(filePath, content);
+    if (e.TAG === "Ok") {
+      return {
+        TAG: "Ok",
+        _0: {
+          TAG: "Created",
+          _0: fileName
+        }
+      };
+    } else {
+      return {
+        TAG: "Error",
+        _0: e._0
+      };
+    }
+  } else {
+    let existingHost = existingFile.host;
+    if (existingHost === host) {
+      return {
+        TAG: "Ok",
+        _0: {
+          TAG: "Skipped",
+          _0: fileName
+        }
+      };
+    }
+    if (dryRun) {
+      return {
+        TAG: "Ok",
+        _0: {
+          TAG: "Updated",
+          fileName,
+          oldHost: existingHost,
+          newHost: host
+        }
+      };
+    }
+    let content$1 = await readFile(filePath);
+    if (content$1 === void 0) {
+      return {
+        TAG: "Error",
+        _0: `Failed to read ` + fileName
+      };
+    }
+    let newContent = updateHostInContent(content$1, host);
+    let e$1 = await writeFile(filePath, newContent);
+    if (e$1.TAG === "Ok") {
+      return {
+        TAG: "Ok",
+        _0: {
+          TAG: "Updated",
+          fileName,
+          oldHost: existingHost,
+          newHost: host
+        }
+      };
+    } else {
+      return {
+        TAG: "Error",
+        _0: e$1._0
+      };
+    }
+  }
+}
+async function handleProxy(projectDir, host, existingFile, dryRun) {
+  let filePath = Nodepath2.join(projectDir, "proxy.ts");
+  let fileName = "proxy.ts";
+  if (typeof existingFile !== "object") {
+    if (existingFile !== "NotFound") {
+      return {
+        TAG: "Ok",
+        _0: {
+          TAG: "ManualEditRequired",
+          _0: ErrorMessages.proxyManualSetup
+        }
+      };
+    }
+    if (dryRun) {
+      return {
+        TAG: "Ok",
+        _0: {
+          TAG: "Created",
+          _0: fileName
+        }
+      };
+    }
+    let content = proxyTemplate(host);
+    let e = await writeFile(filePath, content);
+    if (e.TAG === "Ok") {
+      return {
+        TAG: "Ok",
+        _0: {
+          TAG: "Created",
+          _0: fileName
+        }
+      };
+    } else {
+      return {
+        TAG: "Error",
+        _0: e._0
+      };
+    }
+  } else {
+    let existingHost = existingFile.host;
+    if (existingHost === host) {
+      return {
+        TAG: "Ok",
+        _0: {
+          TAG: "Skipped",
+          _0: fileName
+        }
+      };
+    }
+    if (dryRun) {
+      return {
+        TAG: "Ok",
+        _0: {
+          TAG: "Updated",
+          fileName,
+          oldHost: existingHost,
+          newHost: host
+        }
+      };
+    }
+    let content$1 = await readFile(filePath);
+    if (content$1 === void 0) {
+      return {
+        TAG: "Error",
+        _0: `Failed to read ` + fileName
+      };
+    }
+    let newContent = updateHostInContent(content$1, host);
+    let e$1 = await writeFile(filePath, newContent);
+    if (e$1.TAG === "Ok") {
+      return {
+        TAG: "Ok",
+        _0: {
+          TAG: "Updated",
+          fileName,
+          oldHost: existingHost,
+          newHost: host
+        }
+      };
+    } else {
+      return {
+        TAG: "Error",
+        _0: e$1._0
+      };
+    }
+  }
+}
+async function handleInstrumentation(projectDir, hasSrcDir, existingFile, dryRun) {
+  let filePath = hasSrcDir ? Nodepath2.join(projectDir, "src", "instrumentation.ts") : Nodepath2.join(projectDir, "instrumentation.ts");
+  let fileName = hasSrcDir ? "src/instrumentation.ts" : "instrumentation.ts";
+  if (typeof existingFile === "object") {
+    return {
+      TAG: "Ok",
+      _0: {
+        TAG: "Skipped",
+        _0: fileName
+      }
+    };
+  }
+  if (existingFile !== "NotFound") {
+    return {
+      TAG: "Ok",
+      _0: {
+        TAG: "ManualEditRequired",
+        _0: ErrorMessages.instrumentationManualSetup(fileName)
+      }
+    };
+  }
+  if (dryRun) {
+    return {
+      TAG: "Ok",
+      _0: {
+        TAG: "Created",
+        _0: fileName
+      }
+    };
+  }
+  if (hasSrcDir) {
+    let srcDir = Nodepath2.join(projectDir, "src");
+    await Fs2.promises.mkdir(srcDir, {
+      recursive: true
+    });
+  }
+  let content = instrumentationTemplate();
+  let e = await writeFile(filePath, content);
+  if (e.TAG === "Ok") {
+    return {
+      TAG: "Ok",
+      _0: {
+        TAG: "Created",
+        _0: fileName
+      }
+    };
+  } else {
+    return {
+      TAG: "Error",
+      _0: e._0
+    };
+  }
+}
+function formatResult(result) {
+  switch (result.TAG) {
+    case "Created":
+      return SuccessMessages.fileCreated(result._0);
+    case "Updated":
+      return SuccessMessages.hostUpdated(result.fileName, result.oldHost, result.newHost);
+    case "Skipped":
+      return SuccessMessages.fileSkipped(result._0);
+    case "ManualEditRequired":
+      return result._0;
+  }
+}
+function isManualEditRequired(result) {
+  return result.TAG === "ManualEditRequired";
+}
+
+// ../../node_modules/@rescript/runtime/lib/es6/Stdlib_Int.js
+function fromString(x, radix) {
+  let maybeInt = parseInt(x);
+  if (Number.isNaN(maybeInt) || maybeInt > 2147483647 || maybeInt < -2147483648) {
+    return;
+  } else {
+    return maybeInt | 0;
+  }
+}
+
+// ../../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/FrontmanNextjs__Cli__Detect.res.mjs
+async function fileExists(path) {
+  try {
+    await Fs2.promises.access(path);
+    return true;
+  } catch (exn) {
+    return false;
+  }
+}
+async function dirExists(path) {
+  try {
+    await Fs2.promises.access(path);
+    return (await Fs2.promises.stat(path)).isDirectory();
+  } catch (exn) {
+    return false;
+  }
+}
+async function readFile2(path) {
+  try {
+    return await Fs2.promises.readFile(path, "utf8");
+  } catch (exn) {
+    return;
+  }
+}
+async function detectNextVersion(projectDir) {
+  let nextPkgPath = Nodepath2.join(projectDir, "node_modules", "next", "package.json");
+  let content = await readFile2(nextPkgPath);
+  if (content === void 0) {
+    return;
+  }
+  try {
+    let json = JSON.parse(content);
+    let match = flatMap(Decode.object(json), (obj) => obj["version"]);
+    if (match === void 0) {
+      return;
+    }
+    if (typeof match !== "string") {
+      return;
+    }
+    let parts = match.split(".");
+    let match$1 = parts[0];
+    let match$2 = parts[1];
+    if (match$1 === void 0) {
+      return;
+    }
+    if (match$2 === void 0) {
+      return;
+    }
+    let major = getOr(fromString(match$1, void 0), 0);
+    let minorClean = getOr(match$2.split("-")[0], "0");
+    let minor = getOr(fromString(minorClean, void 0), 0);
+    return {
+      major,
+      minor,
+      raw: match
+    };
+  } catch (exn) {
+    return;
+  }
+}
+async function detectPackageManager(projectDir) {
+  let bunLock = Nodepath2.join(projectDir, "bun.lockb");
+  let pnpmLock = Nodepath2.join(projectDir, "pnpm-lock.yaml");
+  let yarnLock = Nodepath2.join(projectDir, "yarn.lock");
+  let npmLock = Nodepath2.join(projectDir, "package-lock.json");
+  if (await fileExists(bunLock)) {
+    return "Bun";
+  } else if (await fileExists(pnpmLock)) {
+    return "Pnpm";
+  } else if (await fileExists(yarnLock)) {
+    return "Yarn";
+  } else {
+    await fileExists(npmLock);
+    return "Npm";
+  }
+}
+var frontmanImportPattern = /@frontman-ai\/nextjs/;
+var hostPattern2 = /host:\s*['\"]([^'\"]+)['\"]/;
+async function analyzeFile(filePath) {
+  let content = await readFile2(filePath);
+  if (content === void 0) {
+    return "NotFound";
+  }
+  if (!frontmanImportPattern.test(content)) {
+    return "NeedsManualEdit";
+  }
+  let result = hostPattern2.exec(content);
+  if (result == null) {
+    return {
+      TAG: "HasFrontman",
+      host: ""
+    };
+  }
+  let maybeHost = flatMap(result.slice(1)[0], (x) => x);
+  if (maybeHost !== void 0) {
+    return {
+      TAG: "HasFrontman",
+      host: maybeHost
+    };
+  } else {
+    return {
+      TAG: "HasFrontman",
+      host: ""
+    };
+  }
+}
+async function detectSrcDir(projectDir) {
+  return await dirExists(Nodepath2.join(projectDir, "src"));
+}
+async function hasPackageJson(projectDir) {
+  return await fileExists(Nodepath2.join(projectDir, "package.json"));
+}
+async function detect(projectDir) {
+  let hasPackage = await hasPackageJson(projectDir);
+  if (!hasPackage) {
+    return {
+      TAG: "Error",
+      _0: "No package.json found. Please run from your Next.js project root."
+    };
+  }
+  let nextVersion = await detectNextVersion(projectDir);
+  if (isNone(nextVersion)) {
+    return {
+      TAG: "Error",
+      _0: "Could not find Next.js in node_modules. Please run 'npm install' first or verify this is a Next.js project."
+    };
+  }
+  let middlewarePath = Nodepath2.join(projectDir, "middleware.ts");
+  let proxyPath = Nodepath2.join(projectDir, "proxy.ts");
+  let hasSrcDir = await detectSrcDir(projectDir);
+  let instrumentationPath = hasSrcDir ? Nodepath2.join(projectDir, "src", "instrumentation.ts") : Nodepath2.join(projectDir, "instrumentation.ts");
+  let middleware = await analyzeFile(middlewarePath);
+  let proxy = await analyzeFile(proxyPath);
+  let instrumentation = await analyzeFile(instrumentationPath);
+  let packageManager = await detectPackageManager(projectDir);
+  return {
+    TAG: "Ok",
+    _0: {
+      nextVersion,
+      middleware,
+      proxy,
+      instrumentation,
+      hasSrcDir,
+      packageManager
+    }
+  };
+}
+function isNextJs16Plus(info) {
+  let match = info.nextVersion;
+  if (match !== void 0) {
+    return match.major >= 16;
+  } else {
+    return false;
+  }
+}
+function getPackageManagerCommand(pm) {
+  switch (pm) {
+    case "Npm":
+      return "npm";
+    case "Yarn":
+      return "yarn";
+    case "Pnpm":
+      return "pnpm";
+    case "Bun":
+      return "bun";
+  }
+}
+function getInstallArgs(pm, isDevOpt) {
+  switch (pm) {
+    case "Npm":
+      {
+        return ["install"];
+      }
+    case "Yarn":
+      {
+        return ["add"];
+      }
+    case "Pnpm":
+      {
+        return ["add"];
+      }
+    case "Bun":
+      {
+        return ["add"];
+      }
+  }
+}
+
+// src/cli/FrontmanNextjs__Cli__Install.res.mjs
+async function installDependencies(projectDir, packageManager, dryRun) {
+  if (dryRun) {
+    console.log("Would install: @frontman-ai/nextjs @opentelemetry/sdk-node");
+    return {
+      TAG: "Ok",
+      _0: void 0
+    };
+  }
+  let pm = getPackageManagerCommand(packageManager);
+  let args = getInstallArgs(packageManager);
+  let packages = [
+    "@frontman-ai/nextjs",
+    "@opentelemetry/sdk-node"
+  ];
+  let cmd = pm + ` ` + args.join(" ") + ` ` + packages.join(" ");
+  console.log(`Installing dependencies with ` + pm + `...`);
+  let err = await execWithOptions(cmd, {
+    cwd: projectDir
+  });
+  if (err.TAG === "Ok") {
+    console.log("Dependencies installed successfully");
+    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 processFileResult(result, manualSteps) {
+  if (result.TAG === "Ok") {
+    let fileResult = result._0;
+    console.log(formatResult(fileResult));
+    if (isManualEditRequired(fileResult) && fileResult.TAG === "ManualEditRequired") {
+      manualSteps.push(fileResult._0);
+    }
+    return {
+      TAG: "Ok",
+      _0: void 0
+    };
+  }
+  let msg = result._0;
+  console.error(`Error: ` + msg);
+  return {
+    TAG: "Error",
+    _0: msg
+  };
+}
+async function run(options) {
+  let projectDir = getOr(options.prefix, process.cwd());
+  let host = options.server;
+  console.log("");
+  console.log("  Frontman Installer");
+  console.log(`  Server: ` + host);
+  console.log("");
+  if (options.dryRun) {
+    console.log(SuccessMessages.dryRunHeader);
+  }
+  let msg = await detect(projectDir);
+  if (msg.TAG === "Ok") {
+    let info = msg._0;
+    let version = getOr(map(info.nextVersion, (v) => v.raw), "unknown");
+    let isNext16Plus = isNextJs16Plus(info);
+    console.log(`Detected Next.js ` + version);
+    console.log("");
+    if (!options.skipDeps) {
+      let msg$1 = await installDependencies(projectDir, info.packageManager, options.dryRun);
+      if (msg$1.TAG !== "Ok") {
+        console.error(msg$1._0);
+      }
+    }
+    let manualSteps = [];
+    let middlewareResult = isNext16Plus ? await handleProxy(projectDir, host, info.proxy, options.dryRun) : await handleMiddleware(projectDir, host, info.middleware, options.dryRun);
+    let msg$2 = processFileResult(middlewareResult, manualSteps);
+    if (msg$2.TAG !== "Ok") {
+      return {
+        TAG: "Failure",
+        _0: msg$2._0
+      };
+    }
+    let instrumentationResult = await handleInstrumentation(projectDir, info.hasSrcDir, info.instrumentation, options.dryRun);
+    let msg$3 = processFileResult(instrumentationResult, manualSteps);
+    if (msg$3.TAG === "Ok") {
+      if (manualSteps.length !== 0) {
+        console.log("");
+        console.log("Manual steps required:");
+        manualSteps.forEach((step) => {
+          console.log(step);
+        });
+        return {
+          TAG: "PartialSuccess",
+          manualStepsRequired: manualSteps
+        };
+      } else {
+        if (!options.dryRun) {
+          console.log(SuccessMessages.installComplete(host));
+        }
+        return "Success";
+      }
+    } else {
+      return {
+        TAG: "Failure",
+        _0: msg$3._0
+      };
+    }
+  }
+  let msg$4 = msg._0;
+  console.error(`Error: ` + msg$4);
+  return {
+    TAG: "Failure",
+    _0: msg$4
+  };
+}
+
+// src/cli/FrontmanNextjs__Cli.res.mjs
+var helpText = `
+Frontman NextJS CLI
+
+Usage:
+  frontman-nextjs <command> [options]
+
+Commands:
+  install    Install Frontman in a Next.js project
+
+Options:
+  --server <host>   Frontman server host (required for install)
+  --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/nextjs install --server frontman.company.com
+  npx @frontman-ai/nextjs install --server dev.frontman.io --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 = args.server;
+      if (server !== void 0) {
+        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("Error: --server <host> is required for install command");
+        console.log("");
+        console.log("Usage: npx @frontman-ai/nextjs install --server <host>");
+        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();