@dashai/cli 0.5.1 → 0.7.0

package/dist/bin.js

@@ -1,7 +1,7 @@
 #!/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, Option } from 'commander';
@@ -1873,7 +1873,7 @@ async function selectWorkspace(opts) {
   if (workspaces.length === 1) {
     return workspaces[0];
   }
-  if (process.stdout.isTTY) {
+  if (opts.interactive && process.stdout.isTTY) {
     const choice = await select({
       message: "Which workspace should this module live in?",
       options: workspaces.map((w) => ({
@@ -3223,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");
   });
@@ -3426,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`;
@@ -3884,6 +3884,336 @@ 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/register.ts
+init_config();
+init_output();
+init_manifest_io();
+init_workspaces();
+init_api_client();
+var MODULE_KINDS = ["ai_builder", "hand_authored", "custom"];
+async function moduleRegisterCommand(opts) {
+  let manifest;
+  try {
+    manifest = readManifest(opts.dir);
+  } catch (err) {
+    fail(`Could not read module.json: ${err.message}`);
+    return 1;
+  }
+  if (!manifest) {
+    fail(
+      `No module.json found${opts.dir ? ` in ${opts.dir}` : " in the current directory"}. Run ${code("dashwise module convert")} (existing app) or ${code("dashwise init")} (new) first.`
+    );
+    return 1;
+  }
+  const slug = manifest.module?.slug;
+  if (!slug || typeof slug !== "string") {
+    fail("module.json is missing `module.slug`.");
+    return 1;
+  }
+  const name = opts.name ?? (typeof manifest.module?.name === "string" ? manifest.module.name : slug);
+  const moduleKind = MODULE_KINDS.includes(
+    manifest.module_kind
+  ) ? manifest.module_kind : void 0;
+  const description = typeof manifest.module?.description === "string" ? manifest.module.description : void 0;
+  if (!isLoggedIn()) {
+    fail(`Not logged in. Run ${code("dashwise login")} first.`);
+    return 1;
+  }
+  const cfg = readConfig();
+  if (!cfg) {
+    fail(`CLI config missing. Run ${code("dashwise login")}.`);
+    return 1;
+  }
+  let workspace2;
+  try {
+    workspace2 = await selectWorkspace({
+      apiUrl: resolveApiUrl(),
+      apiToken: cfg.token,
+      ...opts.workspace !== void 0 ? { flag: opts.workspace } : {},
+      interactive: true
+    });
+  } catch (err) {
+    fail(`Workspace selection failed: ${err.message}`);
+    return 1;
+  }
+  info(
+    `Registering "${name}" (slug: ${code(slug)}) in workspace ${code(workspace2.slug)} (id=${workspace2.id})\u2026`
+  );
+  let response;
+  try {
+    response = await createDevInstallation(
+      {
+        slug,
+        name,
+        ...description !== void 0 ? { description } : {},
+        workspaceId: workspace2.id,
+        ...moduleKind !== void 0 ? { moduleKind } : {}
+      },
+      { baseUrl: resolveApiUrl(), auth: { token: cfg.token } }
+    );
+  } catch (err) {
+    if (err instanceof ApiError) {
+      if (err.code === "SLUG_ALREADY_EXISTS") {
+        fail(
+          `A module with slug "${slug}" already exists. Pick a different slug in module.json, or run ${code("dashwise module destroy-dev-install")} to reclaim it.`
+        );
+      } else if (err.code === "FORBIDDEN") {
+        fail(`Not a member of workspace "${workspace2.slug}". Join it, then retry.`);
+      } else {
+        fail(`Registration failed (${err.code || err.status}): ${err.message}`);
+      }
+      return 1;
+    }
+    fail(`Registration failed: ${err.message}`);
+    return 1;
+  }
+  try {
+    upsertModuleEntry(slug, {
+      runtimeToken: response.runtime_token,
+      installationId: response.installation.id,
+      expiresAt: response.runtime_token_expires_at
+    });
+  } catch (err) {
+    warn(
+      `Registered (installation id=${response.installation.id}) but failed to cache the runtime token: ${err.message}
+  Runtime token (save this manually): ${response.runtime_token}
+  Expires: ${response.runtime_token_expires_at}`
+    );
+    return 0;
+  }
+  success(
+    `Registered "${name}" \u2192 module #${response.module.id}, dev install #${response.installation.id}. Runtime token cached.`
+  );
+  info(
+    `Next: ${code("dashwise dev")} to run it against DashWise, or ${code("dashwise module publish")} to deploy. Add tables with ${code("dashwise table create")}.`
+  );
+  return 0;
+}
+
 // src/commands/module/generate.ts
 init_api_client();
 init_output();
@@ -6126,7 +6456,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
@@ -6220,7 +6550,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) {
@@ -6414,6 +6744,29 @@ 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("register [dir]").description(
+  "Link an existing local module (a directory with module.json \u2014 e.g. after `module convert`) to DashWise: creates the backend module record + a dev install and caches the runtime token, so `dashwise dev` / `publish` work. Requires login."
+).option("--workspace <slug-or-id>", "Target workspace (default: interactive picker).").option("--name <name>", "Override the module name (default: module.json name).").action(
+  async (dir, cmdOpts) => {
+    process.exitCode = await moduleRegisterCommand({
+      ...dir !== void 0 ? { dir } : {},
+      ...cmdOpts.workspace !== void 0 ? { workspace: cmdOpts.workspace } : {},
+      ...cmdOpts.name !== void 0 ? { name: cmdOpts.name } : {}
+    });
+  }
+);
 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 } : {},
@@ -6779,7 +7132,7 @@ fieldCmd.command("set-type <table-slug> <field-slug> <new-type>").description(
   }
 })();
 function getVersion() {
-  return "0.5.1";
+  return "0.7.0";
 }
 function parseIntOption(value) {
   const n = Number.parseInt(value, 10);