@jskit-ai/jskit-cli 0.2.108 → 0.2.110

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jskit-ai/jskit-cli",
-  "version": "0.2.108",
+  "version": "0.2.110",
   "description": "Bundle and package orchestration CLI for JSKIT apps.",
   "type": "module",
   "files": [
@@ -20,9 +20,9 @@
     "test": "node --test"
   },
   "dependencies": {
-    "@jskit-ai/jskit-catalog": "0.1.103",
-    "@jskit-ai/kernel": "0.1.95",
-    "@jskit-ai/shell-web": "0.1.94",
+    "@jskit-ai/jskit-catalog": "0.1.105",
+    "@jskit-ai/kernel": "0.1.98",
+    "@jskit-ai/shell-web": "0.1.97",
     "@vue/compiler-sfc": "^3.5.29",
     "ts-morph": "^28.0.0"
   },

package/src/server/commandHandlers/app.js

@@ -10,6 +10,7 @@ import {
 } from "./appCommandCatalog.js";
 import { runAppAdoptManagedScriptsCommand } from "./appCommands/adoptManagedScripts.js";
 import { runAppLinkLocalPackagesCommand } from "./appCommands/linkLocalPackages.js";
+import { runAppPreparePreviewUserCommand } from "./appCommands/preparePreviewUser.js";
 import { runAppReleaseCommand } from "./appCommands/release.js";
 import { runAppUpdatePackagesCommand } from "./appCommands/updatePackages.js";
 import { runAppVerifyCommand } from "./appCommands/verify.js";
@@ -151,6 +152,9 @@ function createAppCommands(ctx = {}) {
     if (definition.name === "adopt-managed-scripts") {
       return runAppAdoptManagedScriptsCommand(ctx, { appRoot, options, stdout, stderr });
     }
+    if (definition.name === "prepare-preview-user") {
+      return runAppPreparePreviewUserCommand(ctx, { appRoot, options, stdout, stderr });
+    }
 
     throw createCliError(`Unhandled app subcommand: ${definition.name}.`, {
       renderUsage: () => renderAppHelp(stderr, definition)

package/src/server/commandHandlers/appCommandCatalog.js

@@ -109,6 +109,46 @@ const APP_COMMAND_DEFINITIONS = Object.freeze({
       "Clears node_modules/.vite so Vite does not keep stale prebundled paths."
     ])
   }),
+  "prepare-preview-user": Object.freeze({
+    name: "prepare-preview-user",
+    summary: "Prepare the JSKIT preview auth user and optional first workspace.",
+    usage: "jskit app prepare-preview-user [--profile-file <path>] [--email <email>] [--username <username>] [--display-name <name>] [--auth-provider <provider>] [--auth-provider-user-sid <sid>] [--ensure-workspace]",
+    options: Object.freeze([
+      Object.freeze({
+        label: "--profile-file <path>",
+        description: "JSON profile path to write for the preview auth bridge. Defaults to VIBE64_PREVIEW_AUTH_PROFILE_FILE."
+      }),
+      Object.freeze({
+        label: "--email <email>",
+        description: "Email address for the preview user."
+      }),
+      Object.freeze({
+        label: "--username <username>",
+        description: "Preferred username for the preview user."
+      }),
+      Object.freeze({
+        label: "--display-name <name>",
+        description: "Display name for the preview user."
+      }),
+      Object.freeze({
+        label: "--auth-provider <provider>",
+        description: "Auth provider id stored on the preview user."
+      }),
+      Object.freeze({
+        label: "--auth-provider-user-sid <sid>",
+        description: "Provider user id stored on the preview user."
+      }),
+      Object.freeze({
+        label: "--ensure-workspace",
+        description: "When workspace tables and tenancy config exist, ensure the preview user owns a first workspace."
+      })
+    ]),
+    defaults: Object.freeze([
+      "Runs after migrations and before the app server starts.",
+      "Exits successfully without changes when the app has no knexfile.js or users table.",
+      "Uses the app knexfile and app-local JSKIT package provisioning contracts instead of booting the HTTP server."
+    ])
+  }),
   release: Object.freeze({
     name: "release",
     summary: "Run the JSKIT release helper for an app repository.",
@@ -198,6 +238,15 @@ function buildAppCommandOptionMeta(subcommandName = "") {
   if (definition.name === "link-local-packages") {
     optionMeta["repo-root"] = { inputType: "text" };
   }
+  if (definition.name === "prepare-preview-user") {
+    optionMeta["profile-file"] = { inputType: "text" };
+    optionMeta.email = { inputType: "text" };
+    optionMeta.username = { inputType: "text" };
+    optionMeta["display-name"] = { inputType: "text" };
+    optionMeta["auth-provider"] = { inputType: "text" };
+    optionMeta["auth-provider-user-sid"] = { inputType: "text" };
+    optionMeta["ensure-workspace"] = { inputType: "flag" };
+  }
 
   return optionMeta;
 }

package/src/server/commandHandlers/appCommands/preparePreviewUser.js

@@ -0,0 +1,215 @@
+import { access, mkdir, writeFile } from "node:fs/promises";
+import { createRequire } from "node:module";
+import path from "node:path";
+import { pathToFileURL } from "node:url";
+import { loadAppConfigFromAppRoot } from "@jskit-ai/kernel/server/support";
+
+const TENANCY_MODE_NONE = "none";
+
+function normalizeText(value = "") {
+  return String(value || "").trim();
+}
+
+function normalizeLowerText(value = "") {
+  return normalizeText(value).toLowerCase();
+}
+
+function profileFromOptions(options = {}) {
+  const inlineOptions = options?.inlineOptions && typeof options.inlineOptions === "object" ? options.inlineOptions : {};
+  const profile = {};
+
+  const email = normalizeLowerText(inlineOptions.email || process.env.JSKIT_PREVIEW_USER_EMAIL);
+  const authProvider = normalizeLowerText(inlineOptions["auth-provider"] || process.env.JSKIT_PREVIEW_AUTH_PROVIDER);
+  const username = normalizeLowerText(inlineOptions.username || process.env.JSKIT_PREVIEW_USER_USERNAME);
+  const displayName = normalizeText(inlineOptions["display-name"] || process.env.JSKIT_PREVIEW_USER_DISPLAY_NAME);
+  const authProviderUserSid = normalizeText(
+    inlineOptions["auth-provider-user-sid"] || process.env.JSKIT_PREVIEW_AUTH_PROVIDER_USER_SID
+  );
+
+  if (authProvider) {
+    profile.authProvider = authProvider;
+  }
+  if (authProviderUserSid) {
+    profile.authProviderUserSid = authProviderUserSid;
+  }
+  if (displayName) {
+    profile.displayName = displayName;
+  }
+  if (email) {
+    profile.email = email;
+  }
+  if (username) {
+    profile.username = username;
+  }
+
+  return profile;
+}
+
+async function fileExists(filePath = "") {
+  try {
+    await access(filePath);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+function createAppRequire(appRoot = "") {
+  return createRequire(path.join(appRoot, "package.json"));
+}
+
+async function importFreshModule(filePath = "") {
+  return import(`${pathToFileURL(filePath).href}?mtime=${Date.now()}`);
+}
+
+async function loadKnexConfig(appRoot = "") {
+  const knexfilePath = path.join(appRoot, "knexfile.js");
+  if (!(await fileExists(knexfilePath))) {
+    return null;
+  }
+
+  const requireFromApp = createAppRequire(appRoot);
+  const moduleValue = requireFromApp("knex");
+  const createKnex =
+    typeof moduleValue === "function"
+      ? moduleValue
+      : typeof moduleValue?.default === "function"
+        ? moduleValue.default
+        : null;
+  if (!createKnex) {
+    throw new Error("App-local knex package resolved but did not expose a callable factory.");
+  }
+
+  const knexfileModule = await importFreshModule(knexfilePath);
+  const exported = knexfileModule.default || knexfileModule.config || knexfileModule;
+  const knexfile = typeof exported === "function" ? await exported() : exported;
+  const environment = normalizeText(process.env.NODE_ENV) || "development";
+
+  return {
+    createKnex,
+    knexConfig: knexfile?.[environment] || knexfile
+  };
+}
+
+async function importAppPackageExport(appRoot = "", specifier = "", { required = true } = {}) {
+  const requireFromApp = createAppRequire(appRoot);
+  let resolvedPath = "";
+  try {
+    resolvedPath = requireFromApp.resolve(specifier);
+  } catch {
+    if (!required) {
+      return null;
+    }
+    throw new Error(
+      `Unable to load app-local ${specifier}. Upgrade the installed JSKIT package that owns this preview provisioning contract.`
+    );
+  }
+  return importFreshModule(resolvedPath);
+}
+
+async function writeProfile(profileFile = "", authProfile = {}) {
+  if (!profileFile) {
+    return false;
+  }
+  await mkdir(path.dirname(profileFile), { recursive: true });
+  await writeFile(profileFile, `${JSON.stringify(authProfile, null, 2)}\n`, "utf8");
+  return true;
+}
+
+function isTrueOption(value) {
+  const normalized = normalizeLowerText(value);
+  return value === true || normalized === "true" || normalized === "1" || normalized === "yes";
+}
+
+function normalizeTenancyMode(value = "") {
+  const normalized = normalizeLowerText(value);
+  return normalized === "personal" || normalized === "workspaces" ? normalized : TENANCY_MODE_NONE;
+}
+
+async function hasWorkspaceTables(db) {
+  return (
+    (await db.schema.hasTable("workspaces")) &&
+    (await db.schema.hasTable("workspace_memberships")) &&
+    (await db.schema.hasTable("workspace_settings"))
+  );
+}
+
+async function runAppPreparePreviewUserCommand(_ctx = {}, { appRoot = "", options = {}, stdout = process.stdout }) {
+  const inlineOptions = options?.inlineOptions && typeof options.inlineOptions === "object" ? options.inlineOptions : {};
+  const profileFile = normalizeText(inlineOptions["profile-file"] || process.env.VIBE64_PREVIEW_AUTH_PROFILE_FILE);
+  const ensureWorkspace = isTrueOption(inlineOptions["ensure-workspace"]);
+  const loadedKnex = await loadKnexConfig(appRoot);
+  if (!loadedKnex) {
+    stdout.write("[jskit:preview] skipped: knexfile.js was not found.\n");
+    return 0;
+  }
+
+  const db = loadedKnex.createKnex(loadedKnex.knexConfig);
+  try {
+    if (!(await db.schema.hasTable("users"))) {
+      stdout.write("[jskit:preview] skipped: users table was not found.\n");
+      return 0;
+    }
+
+    const usersPreviewModule = await importAppPackageExport(
+      appRoot,
+      "@jskit-ai/users-core/server/previewUserProvisioning"
+    );
+    if (typeof usersPreviewModule?.ensurePreviewUser !== "function") {
+      throw new Error("@jskit-ai/users-core preview provisioning export is missing ensurePreviewUser().");
+    }
+
+    const userResult = await usersPreviewModule.ensurePreviewUser(db, profileFromOptions(options));
+    if (userResult?.skipped) {
+      stdout.write(`[jskit:preview] skipped: ${userResult.skipped}.\n`);
+      return 0;
+    }
+
+    const authProfile = userResult.profile;
+    let workspace = null;
+
+    if (ensureWorkspace) {
+      const appConfig = await loadAppConfigFromAppRoot({ appRoot });
+      const tenancyMode = normalizeTenancyMode(appConfig?.tenancyMode);
+      if (tenancyMode === TENANCY_MODE_NONE) {
+        stdout.write("[jskit:preview] skipped workspace: workspace tenancy is disabled.\n");
+      } else if (!(await hasWorkspaceTables(db))) {
+        throw new Error(
+          `Workspace tenancy is "${tenancyMode}", but workspace tables were not found. Run migrations before prepare-preview-user.`
+        );
+      } else {
+        const workspacesPreviewModule = await importAppPackageExport(
+          appRoot,
+          "@jskit-ai/workspaces-core/server/previewWorkspaceProvisioning"
+        );
+        if (typeof workspacesPreviewModule?.ensurePreviewWorkspace !== "function") {
+          throw new Error("@jskit-ai/workspaces-core preview provisioning export is missing ensurePreviewWorkspace().");
+        }
+
+        const workspaceResult = await workspacesPreviewModule.ensurePreviewWorkspace(db, userResult.user, authProfile, {
+          appConfig,
+          tenancyMode
+        });
+        workspace = workspaceResult?.workspace || null;
+        if (workspaceResult?.skipped) {
+          stdout.write(`[jskit:preview] skipped workspace: ${workspaceResult.skipped}.\n`);
+        }
+      }
+    }
+
+    const outputProfile = {
+      ...authProfile,
+      ...(workspace ? { workspace } : {})
+    };
+    await writeProfile(profileFile, outputProfile);
+    stdout.write(`[jskit:preview] user is ready: ${outputProfile.email} (${outputProfile.id}).\n`);
+    if (workspace) {
+      stdout.write(`[jskit:preview] workspace is ready: ${workspace.slug} (${workspace.id}).\n`);
+    }
+    return 0;
+  } finally {
+    await db.destroy();
+  }
+}
+
+export { runAppPreparePreviewUserCommand };

package/src/server/core/argParser.js

@@ -137,6 +137,10 @@ function parseArgs(argv, { createCliError } = {}) {
       options.inlineOptions["skip-main-sync"] = "true";
       continue;
     }
+    if (token === "--ensure-workspace") {
+      options.inlineOptions["ensure-workspace"] = "true";
+      continue;
+    }
 
     if (token.startsWith("--")) {
       const withoutPrefix = token.slice(2);