@dashai/cli 0.5.0 → 0.6.0

package/dist/bin.js

@@ -1,10 +1,10 @@
 #!/usr/bin/env node
 import { existsSync, readFileSync, writeFileSync, rmSync, mkdirSync, watch, readdirSync, chmodSync, renameSync, mkdtempSync, statSync } from 'fs';
 import { tmpdir, platform, homedir } from 'os';
-import { resolve, join, dirname, relative } from 'path';
+import { resolve, join, dirname, basename, relative } from 'path';
 import pc from 'picocolors';
 import { intro, log, select, isCancel, cancel, spinner, outro, text, multiselect, confirm } from '@clack/prompts';
-import { Command } from 'commander';
+import { Command, Option } from 'commander';
 import { spawn, spawnSync } from 'child_process';
 import open from 'open';
 import * as tar from 'tar';
@@ -394,6 +394,9 @@ var init_output = __esm({
 });
 
 // src/lib/scaffold.ts
+function isDeployTarget(value) {
+  return DEPLOY_TARGETS.includes(value);
+}
 function manifestJson(opts) {
   const kind = opts.kind ?? "hand_authored";
   const manifest = {
@@ -1017,6 +1020,7 @@ function appApiAuthSignInTs() {
 // the DashWise FE \`/login?return_to=...\` automatically \u2014 you don't
 // need to handle the "user not logged in" case here.
 import { NextResponse } from 'next/server';
+import { getPublicOrigin } from '@/lib/request-origin';
 
 export function GET(request: Request) {
   const url = new URL(request.url);
@@ -1042,8 +1046,10 @@ export function GET(request: Request) {
 
   // Absolute URL for return_to so the backend knows which host to
   // bounce back to (the callback path is fixed at /api/auth/callback
-  // by SDK convention).
-  const moduleOrigin = url.origin;
+  // by SDK convention). \`getPublicOrigin\` reads \`X-Forwarded-Host\`
+  // when present so the redirect URL points at the public domain,
+  // not the internal Node origin behind reverse proxies.
+  const moduleOrigin = getPublicOrigin(request);
   const absoluteReturnTo = \`\${moduleOrigin}\${returnTo}\`;
 
   let ssoStart;
@@ -1077,12 +1083,17 @@ function appApiAuthCallbackTs() {
 //      (e.g. \`access_denied\`, \`server_error\`, \`invalid_request\`).
 import { NextResponse } from 'next/server';
 import { exchangeCode } from '@dashai/sdk/auth/server';
+import { getPublicOrigin } from '@/lib/request-origin';
 
 export async function GET(request: Request) {
   const url = new URL(request.url);
+  // Resolve the public origin once \u2014 all redirects below are
+  // back to this module, and behind a reverse proxy url.origin is
+  // the internal Node origin (localhost:<PORT>), not the public host.
+  const publicOrigin = getPublicOrigin(request);
   const error = url.searchParams.get('error');
   if (error) {
-    const target = new URL('/sign-in-error', url.origin);
+    const target = new URL('/sign-in-error', publicOrigin);
     target.searchParams.set('code', error);
     const description = url.searchParams.get('error_description');
     if (description) target.searchParams.set('description', description);
@@ -1091,19 +1102,19 @@ export async function GET(request: Request) {
   const code = url.searchParams.get('code');
   const returnTo = url.searchParams.get('return_to') ?? '/';
   if (!code) {
-    const target = new URL('/sign-in-error', url.origin);
+    const target = new URL('/sign-in-error', publicOrigin);
     target.searchParams.set('code', 'missing_code');
     return NextResponse.redirect(target);
   }
   try {
     await exchangeCode(code); // sets the dashwise.session cookie
   } catch (err) {
-    const target = new URL('/sign-in-error', url.origin);
+    const target = new URL('/sign-in-error', publicOrigin);
     target.searchParams.set('code', 'exchange_failed');
     target.searchParams.set('description', (err as Error).message);
     return NextResponse.redirect(target);
   }
-  return NextResponse.redirect(new URL(returnTo, url.origin));
+  return NextResponse.redirect(new URL(returnTo, publicOrigin));
 }
 `;
 }
@@ -1116,10 +1127,14 @@ function appApiAuthSignOutTs() {
 // to follow with GET (not re-POST), landing on the public '/' page.
 import { NextResponse } from 'next/server';
 import { signOut } from '@dashai/sdk/auth/server';
+import { getPublicOrigin } from '@/lib/request-origin';
 
 export async function POST(request: Request) {
   await signOut();
-  return NextResponse.redirect(new URL('/', request.url), 303);
+  // Build the redirect against the public origin so we don't land
+  // the user on \`http://localhost:<PORT>/\` when running behind a
+  // reverse proxy (Railway/Vercel/Fly).
+  return NextResponse.redirect(new URL('/', getPublicOrigin(request)), 303);
 }
 `;
 }
@@ -1293,6 +1308,36 @@ export function cn(...inputs: ClassValue[]) {
 }
 `;
 }
+function libRequestOriginTs() {
+  return `/**
+ * Resolve the **public** origin of an incoming request.
+ *
+ * Behind a reverse proxy (Railway, Vercel, Fly, Cloudflare, an
+ * nginx in front of a Node container, etc.) \`new URL(request.url)\`
+ * reports the *internal* origin the Node process is bound to \u2014
+ * usually \`http://localhost:<PORT>\` \u2014 not the public URL the
+ * browser hit. The proxy preserves the public origin in
+ * \`X-Forwarded-*\` headers; we read those first.
+ *
+ * Falls back to \`new URL(request.url).origin\` for local dev where
+ * there's no proxy in front of Next.js.
+ *
+ * Both \`x-forwarded-proto\` and \`x-forwarded-host\` can be
+ * comma-separated when multiple proxies chain; the leftmost entry
+ * is the original client-facing one per RFC 7239 conventions.
+ */
+export function getPublicOrigin(request: Request): string {
+  const forwardedProto = request.headers.get('x-forwarded-proto');
+  const forwardedHost = request.headers.get('x-forwarded-host');
+  if (forwardedProto && forwardedHost) {
+    const proto = forwardedProto.split(',')[0].trim();
+    const host = forwardedHost.split(',')[0].trim();
+    return \`\${proto}://\${host}\`;
+  }
+  return new URL(request.url).origin;
+}
+`;
+}
 function componentsUiButtonTsx() {
   return `import * as React from "react";
 import { cva, type VariantProps } from "class-variance-authority";
@@ -1750,9 +1795,63 @@ Format (reverse chronological, newest first):
 schema mutation.
 `;
 }
-var SCAFFOLD_DEFAULT_API_URL;
+function railwayJson(_opts) {
+  return JSON.stringify(
+    {
+      $schema: "https://railway.com/railway.schema.json",
+      build: {
+        builder: "NIXPACKS"
+      },
+      deploy: {
+        restartPolicyType: "ON_FAILURE",
+        restartPolicyMaxRetries: 3
+      }
+    },
+    null,
+    2
+  ) + "\n";
+}
+function vercelJson(_opts) {
+  return JSON.stringify(
+    {
+      $schema: "https://openapi.vercel.sh/vercel.json",
+      framework: "nextjs"
+    },
+    null,
+    2
+  ) + "\n";
+}
+function flyToml(opts) {
+  return `# fly.toml \u2014 generated by \`dashwise init --deploy-target fly\`.
+# Run \`fly launch --no-deploy --copy-config\` to register this app with
+# Fly; the launcher will read this file and prompt for anything missing.
+#
+# Edit \`app\` if the slug is already taken globally on fly.io.
+# Edit \`primary_region\` for non-US-East deploys (https://fly.io/docs/reference/regions/).
+
+app = "${opts.slug}"
+primary_region = "iad"
+
+[build]
+
+[http_service]
+  internal_port = 3000
+  force_https = true
+  auto_stop_machines = "stop"
+  auto_start_machines = true
+  min_machines_running = 0
+  processes = ["app"]
+
+[[vm]]
+  cpu_kind = "shared"
+  cpus = 1
+  memory_mb = 256
+`;
+}
+var DEPLOY_TARGETS, SCAFFOLD_DEFAULT_API_URL;
 var init_scaffold = __esm({
   "src/lib/scaffold.ts"() {
+    DEPLOY_TARGETS = ["railway", "vercel", "fly"];
     SCAFFOLD_DEFAULT_API_URL = "http://localhost:3000";
   }
 });
@@ -1854,6 +1953,12 @@ async function moduleInitCommand(slugArg, options) {
     );
     return 1;
   }
+  if (options.deployTarget !== void 0 && !isDeployTarget(options.deployTarget)) {
+    fail(
+      `Invalid --deploy-target ${code(options.deployTarget)} \u2014 must be one of ${DEPLOY_TARGETS.map((t) => code(t)).join(", ")}.`
+    );
+    return 1;
+  }
   const kind = options.simple ? "hand_authored" : "custom";
   const scaffoldOpts = {
     slug,
@@ -1886,6 +1991,7 @@ async function moduleInitCommand(slugArg, options) {
       ["postcss.config.mjs", postcssConfigMjs()],
       ["app/globals.css", globalsCss()],
       ["lib/utils.ts", libUtilsTs()],
+      ["lib/request-origin.ts", libRequestOriginTs()],
       ["components/theme-provider.tsx", componentsThemeProviderTsx()],
       ["components/ui/button.tsx", componentsUiButtonTsx()],
       ["components/ui/card.tsx", componentsUiCardTsx()],
@@ -1904,6 +2010,19 @@ async function moduleInitCommand(slugArg, options) {
       ["app/page.tsx", appPageTsx(scaffoldOpts)]
     );
   }
+  if (options.deployTarget !== void 0) {
+    switch (options.deployTarget) {
+      case "railway":
+        files.push(["railway.json", railwayJson()]);
+        break;
+      case "vercel":
+        files.push(["vercel.json", vercelJson()]);
+        break;
+      case "fly":
+        files.push(["fly.toml", flyToml(scaffoldOpts)]);
+        break;
+    }
+  }
   for (const [relPath, content] of files) {
     const absPath = join(dir, relPath);
     const parentDir = join(absPath, "..");
@@ -3104,13 +3223,13 @@ async function resolveDevPort(requested) {
 }
 async function isPortFree(port) {
   const { createServer } = await import('net');
-  return new Promise((resolve11) => {
+  return new Promise((resolve12) => {
     const server = createServer();
     server.once("error", () => {
-      resolve11(false);
+      resolve12(false);
     });
     server.once("listening", () => {
-      server.close(() => resolve11(true));
+      server.close(() => resolve12(true));
     });
     server.listen(port, "0.0.0.0");
   });
@@ -3307,7 +3426,7 @@ async function loginCommand(options) {
   return 0;
 }
 function sleep(ms) {
-  return new Promise((resolve11) => setTimeout(resolve11, ms));
+  return new Promise((resolve12) => setTimeout(resolve12, ms));
 }
 function formatSeconds(seconds) {
   if (seconds < 60) return `${seconds}s`;
@@ -3765,6 +3884,230 @@ function isPlausibleRepoUrl(url) {
   return /^git@[^:]+:[^/]+\/.+/.test(url);
 }
 
+// src/commands/module/convert.ts
+init_scaffold();
+var SDK_DEP_RANGE = "^0.8.0";
+var SCAN_DIRS = ["app", "src", "pages", "lib", "components"];
+var SCAN_EXTENSIONS = [".ts", ".tsx", ".js", ".jsx", ".mjs"];
+var MAX_SCAN_FILES = 2e3;
+function deriveSlug(input) {
+  return input.toLowerCase().replace(/^@[^/]+\//, "").replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "").slice(0, 63);
+}
+function convertModule(opts) {
+  const dir = resolve(opts.dir);
+  const pkgPath = join(dir, "package.json");
+  if (!existsSync(pkgPath)) {
+    throw new Error(
+      "No package.json found \u2014 run `dashwise module convert` inside a Next.js project."
+    );
+  }
+  const pkg = JSON.parse(readFileSync(pkgPath, "utf-8"));
+  const nextConfigFile = ["next.config.mjs", "next.config.js", "next.config.ts"].find(
+    (f) => existsSync(join(dir, f))
+  );
+  const looksNext = Boolean(pkg.dependencies?.next || pkg.devDependencies?.next) || nextConfigFile !== void 0 || existsSync(join(dir, "app")) || existsSync(join(dir, "src", "app"));
+  if (!looksNext) {
+    throw new Error(
+      "This does not look like a Next.js app (no `next` dependency, next.config, or app/ directory)."
+    );
+  }
+  const slug = opts.slug ?? deriveSlug(pkg.name ?? basename(dir));
+  if (!isValidSlug(slug)) {
+    throw new Error(
+      `Could not derive a valid module slug ("${slug}"). Pass --slug (must match /^[a-z][a-z0-9_-]*$/).`
+    );
+  }
+  const name = opts.name ?? pkg.name ?? slug;
+  const sopts = {
+    slug,
+    name,
+    kind: "custom",
+    ...opts.repositoryUrl ? { repositoryUrl: opts.repositoryUrl } : {}
+  };
+  const created = [];
+  const skipped = [];
+  const warnings = [];
+  const writeIfMissing = (rel, content) => {
+    const p = join(dir, rel);
+    if (existsSync(p)) {
+      skipped.push(rel);
+      return;
+    }
+    mkdirSync(dirname(p), { recursive: true });
+    writeFileSync(p, content, "utf-8");
+    created.push(rel);
+  };
+  writeIfMissing("module.json", manifestJson(sopts));
+  writeIfMissing("middleware.ts", middlewareTs());
+  writeIfMissing("app/api/auth/sign-in/route.ts", appApiAuthSignInTs());
+  writeIfMissing("app/api/auth/callback/route.ts", appApiAuthCallbackTs());
+  writeIfMissing("app/api/auth/sign-out/route.ts", appApiAuthSignOutTs());
+  writeIfMissing("app/sign-in-error/page.tsx", appSignInErrorPageTsx());
+  writeIfMissing(".env.local.example", envLocalExample());
+  const layoutFile = [
+    "app/layout.tsx",
+    "app/layout.jsx",
+    "src/app/layout.tsx"
+  ].find((f) => existsSync(join(dir, f)));
+  if (!layoutFile) {
+    writeIfMissing("app/layout.tsx", appLayoutCustomTsx(sopts));
+  } else if (!readFileSync(join(dir, layoutFile), "utf-8").includes("AuthProvider")) {
+    warnings.push(
+      `${layoutFile}: wrap your tree in <AuthProvider> from "@dashai/sdk/auth/client" so client components can read the session.`
+    );
+  } else {
+    skipped.push(layoutFile);
+  }
+  if (!nextConfigFile) {
+    writeIfMissing("next.config.mjs", standaloneNextConfig());
+  } else if (!readFileSync(join(dir, nextConfigFile), "utf-8").includes("standalone")) {
+    warnings.push(
+      `${nextConfigFile}: add \`output: 'standalone'\` \u2014 required for the module runtime bundle.`
+    );
+  }
+  if (!pkg.dependencies?.["@dashai/sdk"]) {
+    pkg.dependencies = { ...pkg.dependencies ?? {}, "@dashai/sdk": SDK_DEP_RANGE };
+    writeFileSync(pkgPath, JSON.stringify(pkg, null, 2) + "\n", "utf-8");
+    created.push("package.json (added @dashai/sdk)");
+  }
+  const outboundApis = scanOutboundHosts(dir);
+  const runtimeBlockAdded = normalizeManifest(join(dir, "module.json"), {
+    outboundApis
+  });
+  return {
+    slug,
+    name,
+    created,
+    skipped,
+    warnings,
+    outboundApis,
+    runtimeBlockAdded
+  };
+}
+function standaloneNextConfig() {
+  return `/** @type {import("next").NextConfig} */
+const nextConfig = {
+  output: 'standalone',
+  typescript: { ignoreBuildErrors: true },
+  eslint: { ignoreDuringBuilds: true },
+};
+export default nextConfig;
+`;
+}
+function normalizeManifest(manifestPath2, opts) {
+  const manifest = JSON.parse(readFileSync(manifestPath2, "utf-8"));
+  let runtimeAdded = false;
+  if (manifest.module_kind === void 0) manifest.module_kind = "custom";
+  let runtime = manifest.runtime;
+  if (manifest.module_kind === "custom" && !runtime) {
+    runtime = {
+      type: "nextjs",
+      kind: "machine",
+      machine_size: "shared-cpu-1x",
+      server_actions: true
+    };
+    manifest.runtime = runtime;
+    runtimeAdded = true;
+  }
+  if (runtime && opts.outboundApis.length > 0) {
+    const existing = Array.isArray(runtime.outbound_apis) ? runtime.outbound_apis : [];
+    runtime.outbound_apis = Array.from(
+      /* @__PURE__ */ new Set([...existing, ...opts.outboundApis])
+    ).sort();
+  }
+  writeFileSync(manifestPath2, JSON.stringify(manifest, null, 2) + "\n", "utf-8");
+  return runtimeAdded;
+}
+function scanOutboundHosts(dir) {
+  const hosts = /* @__PURE__ */ new Set();
+  let scanned = 0;
+  const hostRe = /https:\/\/([a-zA-Z0-9.-]+)/g;
+  const walk2 = (abs) => {
+    if (scanned >= MAX_SCAN_FILES) return;
+    let entries;
+    try {
+      entries = readdirSync(abs);
+    } catch {
+      return;
+    }
+    for (const entry of entries) {
+      if (entry === "node_modules" || entry.startsWith(".")) continue;
+      const p = join(abs, entry);
+      let st;
+      try {
+        st = statSync(p);
+      } catch {
+        continue;
+      }
+      if (st.isDirectory()) {
+        walk2(p);
+      } else if (SCAN_EXTENSIONS.some((e) => entry.endsWith(e))) {
+        if (scanned >= MAX_SCAN_FILES) return;
+        scanned++;
+        let body;
+        try {
+          body = readFileSync(p, "utf-8");
+        } catch {
+          continue;
+        }
+        for (const m of body.matchAll(hostRe)) {
+          const host = m[1].toLowerCase();
+          if (host === "localhost" || host.endsWith(".local")) continue;
+          if (host.includes("dashwise")) continue;
+          if (/^\d+\.\d+\.\d+\.\d+$/.test(host)) continue;
+          hosts.add(host);
+        }
+      }
+    }
+  };
+  for (const d of SCAN_DIRS) {
+    const abs = join(dir, d);
+    if (existsSync(abs)) walk2(abs);
+  }
+  return Array.from(hosts).sort();
+}
+async function moduleConvertCommand(opts) {
+  try {
+    const result = convertModule({
+      dir: opts.dir ?? process.cwd(),
+      ...opts.slug !== void 0 ? { slug: opts.slug } : {},
+      ...opts.name !== void 0 ? { name: opts.name } : {},
+      ...opts.git !== void 0 ? { repositoryUrl: opts.git } : {}
+    });
+    console.log(`Converted "${result.name}" (slug: ${result.slug}) to a DashWise module.
+`);
+    if (result.created.length) {
+      console.log("  Created:");
+      for (const f of result.created) console.log(`    + ${f}`);
+    }
+    if (result.skipped.length) {
+      console.log("  Left as-is:");
+      for (const f of result.skipped) console.log(`    \xB7 ${f}`);
+    }
+    if (result.runtimeBlockAdded) {
+      console.log("  + module.json: added runtime block (nextjs/machine)");
+    }
+    if (result.outboundApis.length) {
+      console.log(
+        `  + module.json runtime.outbound_apis: ${result.outboundApis.join(", ")}`
+      );
+    }
+    if (result.warnings.length) {
+      console.log("\n  Manual steps needed:");
+      for (const w of result.warnings) console.log(`    ! ${w}`);
+    }
+    console.log(
+      "\nNext: `npm install`, then `dashwise dev` to run it against DashWise, or `dashwise module publish` to deploy."
+    );
+    return 0;
+  } catch (err) {
+    console.error(
+      `convert failed: ${err instanceof Error ? err.message : String(err)}`
+    );
+    return 1;
+  }
+}
+
 // src/commands/module/generate.ts
 init_api_client();
 init_output();
@@ -5243,6 +5586,9 @@ function surfacePullFailure(err) {
   return 1;
 }
 
+// src/bin.ts
+init_scaffold();
+
 // src/commands/api-keys.ts
 init_api_client();
 init_config();
@@ -6004,7 +6350,7 @@ function formatTimestamp(iso) {
   return iso.slice(0, 19).replace("T", " ");
 }
 function sleep2(ms) {
-  return new Promise((resolve11) => setTimeout(resolve11, ms));
+  return new Promise((resolve12) => setTimeout(resolve12, ms));
 }
 
 // src/commands/module/action-log.ts
@@ -6098,7 +6444,7 @@ async function runTail2(installationId, options) {
       }
       dim(`(tail: transient error \u2014 ${err.message})`);
     }
-    await new Promise((resolve11) => setTimeout(resolve11, POLL_INTERVAL_MS2));
+    await new Promise((resolve12) => setTimeout(resolve12, POLL_INTERVAL_MS2));
   }
 }
 function printTable(rows) {
@@ -6253,6 +6599,11 @@ var initOptions = (cmd) => cmd.option("--dir <path>", "Override the target direc
 ).option(
   "--no-provision",
   "Skip the `POST /api/installations/dev` step. Local scaffold is still written; you can provision later by re-running `dashwise init --force` (or, once it ships, `dashwise module provision-dev-install`)."
+).addOption(
+  new Option(
+    "--deploy-target <platform>",
+    "Emit a platform deploy config file alongside the scaffold (railway.json | vercel.json | fly.toml). Default: none (clean repo). Pair with `dashwise env export --format <platform>` to push env vars after provisioning."
+  ).choices([...DEPLOY_TARGETS])
 );
 var initAction = async (slugArg, cmdOpts) => {
   process.exitCode = await moduleInitCommand(slugArg, {
@@ -6264,7 +6615,8 @@ var initAction = async (slugArg, cmdOpts) => {
     ...cmdOpts.git !== void 0 ? { git: cmdOpts.git } : {},
     ...cmdOpts.description !== void 0 ? { description: cmdOpts.description } : {},
     ...cmdOpts.workspace !== void 0 ? { workspace: cmdOpts.workspace } : {},
-    ...cmdOpts.provision !== void 0 ? { provision: cmdOpts.provision } : {}
+    ...cmdOpts.provision !== void 0 ? { provision: cmdOpts.provision } : {},
+    ...cmdOpts.deployTarget !== void 0 ? { deployTarget: cmdOpts.deployTarget } : {}
   });
 };
 initOptions(
@@ -6286,6 +6638,18 @@ moduleCmd.command("connect-git <repo-url>").description("Link the local module t
     });
   }
 );
+moduleCmd.command("convert [dir]").description(
+  "Convert an EXISTING Next.js app into a DashWise module \u2014 idempotently inject module.json, auth wiring, the SDK dep, and output:standalone. Creates missing files; warns (never overwrites) for an existing layout/next.config/module.json."
+).option("--slug <slug>", "Module slug (default: derived from package.json name / dir).").option("--name <name>", "Human-readable module name (default: package.json name).").option("--git <url>", "Git repository URL \u2014 written to module.json#repository.url.").action(
+  async (dir, cmdOpts) => {
+    process.exitCode = await moduleConvertCommand({
+      ...dir !== void 0 ? { dir } : {},
+      ...cmdOpts.slug !== void 0 ? { slug: cmdOpts.slug } : {},
+      ...cmdOpts.name !== void 0 ? { name: cmdOpts.name } : {},
+      ...cmdOpts.git !== void 0 ? { git: cmdOpts.git } : {}
+    });
+  }
+);
 moduleCmd.command("generate").description("Regenerate typed wrappers from the local module.json into node_modules/@dashai/generated/.").option("--dir <path>", "Project root (default: current directory).").option("--dry-run", "Print summary without writing files.").action(async (cmdOpts) => {
   process.exitCode = await moduleGenerateCommand({
     ...cmdOpts.dir !== void 0 ? { dir: cmdOpts.dir } : {},
@@ -6651,7 +7015,7 @@ fieldCmd.command("set-type <table-slug> <field-slug> <new-type>").description(
   }
 })();
 function getVersion() {
-  return "0.5.0";
+  return "0.6.0";
 }
 function parseIntOption(value) {
   const n = Number.parseInt(value, 10);