@jskit-ai/jskit-cli 0.2.128 → 0.2.130

package/src/server/commandHandlers/appCommandCatalog.js

@@ -90,7 +90,23 @@ const APP_COMMAND_DEFINITIONS = Object.freeze({
     defaults: Object.freeze([
       "Runtime and dev @jskit-ai dependencies are updated separately so package.json sections stay correct.",
       "Each package is moved to the latest available major.x range and npm saves the resolved exact version.",
-      "Managed migrations are refreshed afterwards unless --dry-run is used."
+      "Managed migrations and the composed CI workflow are refreshed afterwards unless --dry-run is used."
+    ])
+  }),
+  "sync-ci": Object.freeze({
+    name: "sync-ci",
+    summary: "Regenerate the JSKIT-managed GitHub verification workflow from installed package contracts.",
+    usage: "jskit app sync-ci [--force]",
+    options: Object.freeze([
+      Object.freeze({
+        label: "--force",
+        description: "Replace a modified workflow that is already recorded as JSKIT-managed."
+      })
+    ]),
+    defaults: Object.freeze([
+      "Recomposes CI requirements from installed package descriptors and records the generated content hash in .jskit/lock.json.",
+      "Refuses to replace a modified workflow unless --force is explicit; application-specific CI belongs in a separate workflow.",
+      "Never claims an unrecorded jskit-verify.yml or removes a customized legacy verify.yml."
     ])
   }),
   "link-local-packages": Object.freeze({
@@ -109,46 +125,6 @@ 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.",
@@ -241,6 +217,9 @@ function buildAppCommandOptionMeta(subcommandName = "") {
   if (definition.name === "adopt-managed-scripts") {
     optionMeta.force = { inputType: "flag" };
   }
+  if (definition.name === "sync-ci") {
+    optionMeta.force = { inputType: "flag" };
+  }
   if (definition.name === "update-packages" || definition.name === "release") {
     optionMeta.registry = { inputType: "text" };
   }
@@ -255,16 +234,6 @@ 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/syncCi.js

@@ -0,0 +1,40 @@
+async function runAppSyncCiCommand(ctx = {}, { appRoot = "", options = {}, stdout }) {
+  const {
+    createCliError,
+    synchronizeAppCiWorkflow
+  } = ctx;
+  const force = String(options?.inlineOptions?.force || "").trim().toLowerCase() === "true";
+  const result = await synchronizeAppCiWorkflow({
+    appRoot,
+    allowManagedOverwrite: force
+  });
+  if (!result.applicable) {
+    throw createCliError("jskit app sync-ci only works in a JSKIT app root.");
+  }
+
+  if (options.json) {
+    stdout.write(`${JSON.stringify({
+      path: result.path,
+      hash: result.hash,
+      changed: result.changed,
+      removedLegacyWorkflow: result.removedLegacyWorkflow,
+      replacedModifiedWorkflow: result.replacedModifiedWorkflow
+    }, null, 2)}\n`);
+    return 0;
+  }
+
+  if (result.replacedModifiedWorkflow) {
+    stdout.write(`Replaced the modified JSKIT-managed CI workflow: ${result.path}\n`);
+  } else if (result.changed) {
+    stdout.write(`Synchronized the JSKIT-managed CI workflow: ${result.path}\n`);
+  } else {
+    stdout.write(`The JSKIT-managed CI workflow is already current: ${result.path}\n`);
+  }
+  if (result.removedLegacyWorkflow) {
+    stdout.write("Removed the superseded .github/workflows/verify.yml scaffold.\n");
+  }
+  stdout.write(`Recorded content hash: ${result.hash}\n`);
+  return 0;
+}
+
+export { runAppSyncCiCommand };

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

@@ -32,9 +32,11 @@ function resolveInstallSpecs(packageNames = [], resolveMajorRange) {
 async function runAppUpdatePackagesCommand(ctx = {}, { appRoot = "", options = {}, stdout, stderr }) {
   const {
     createCliError,
-    loadAppPackageJson
+    loadAppPackageJson,
+    assertAppManagedCiWorkflowUnmodified
   } = ctx;
 
+  await assertAppManagedCiWorkflowUnmodified({ appRoot });
   const { packageJson } = await loadAppPackageJson(appRoot);
   const runtimePackages = collectJskitPackageNames(packageJson?.dependencies);
   const devPackages = collectJskitPackageNames(packageJson?.devDependencies);
@@ -93,6 +95,12 @@ async function runAppUpdatePackagesCommand(ctx = {}, { appRoot = "", options = {
       stderr,
       createCliError
     });
+    stdout.write("[jskit:update] synchronizing the managed CI workflow.\n");
+    await runLocalJskit(appRoot, ["app", "sync-ci"], {
+      stdout,
+      stderr,
+      createCliError
+    });
   }
 
   stdout.write("[jskit:update] done.\n");

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

@@ -8,7 +8,10 @@ const BASELINE_VERIFY_SCRIPTS = Object.freeze([
 ]);
 
 async function runAppVerifyCommand(ctx = {}, { appRoot = "", options = {}, stdout, stderr }) {
-  const { createCliError } = ctx;
+  const {
+    createCliError,
+    validateAppCiWorkflow
+  } = ctx;
   const inlineOptions =
     options?.inlineOptions && typeof options.inlineOptions === "object" ? options.inlineOptions : {};
   const against = String(inlineOptions.against || "").trim();
@@ -17,6 +20,14 @@ async function runAppVerifyCommand(ctx = {}, { appRoot = "", options = {}, stdou
     throw createCliError("jskit app verify does not support --dry-run.", { exitCode: 1 });
   }
 
+  const ciValidation = await validateAppCiWorkflow({ appRoot });
+  if (!ciValidation.valid) {
+    throw createCliError(
+      ciValidation.issues.map((issue) => issue.message).join("\n"),
+      { exitCode: 1 }
+    );
+  }
+
   for (const scriptName of BASELINE_VERIFY_SCRIPTS) {
     runExternalCommand("npm", ["run", "--if-present", scriptName], {
       cwd: appRoot,

package/src/server/commandHandlers/health.js

@@ -26,6 +26,7 @@ function createHealthCommands(ctx = {}) {
     loadAppLocalPackageRegistry,
     mergePackageRegistries,
     hydratePackageRegistryFromInstalledNodeModules,
+    validateManagedCiWorkflow,
     inspectPackageOfferings,
     fileExists,
     normalizeRelativePath,
@@ -2130,6 +2131,13 @@ function createHealthCommands(ctx = {}) {
       seedPackageIds: Object.keys(installed)
     });
 
+    const ciValidation = await validateManagedCiWorkflow({
+      appRoot,
+      lock,
+      packageRegistry: combinedPackageRegistry
+    });
+    issues.push(...ciValidation.issues.map((issue) => issue.message));
+
     for (const [packageId, lockEntryValue] of Object.entries(installed)) {
       const lockEntry = ensureObject(lockEntryValue);
       if (!combinedPackageRegistry.has(packageId)) {

package/src/server/commandHandlers/packageCommands/add.js

@@ -360,6 +360,9 @@ async function runPackageAddCommand(ctx = {}, { positional, options, cwd, io })
     resolvePackageOptions,
     applyPackageInstall,
     adoptAppLocalPackageDependencies,
+    assertManagedCiWorkflowUnmodified,
+    composeInstalledPackageCi,
+    synchronizeManagedCiWorkflow,
     writeJsonFile,
     readFileBufferIfExists,
     runNpmInstall,
@@ -485,6 +488,10 @@ async function runPackageAddCommand(ctx = {}, { positional, options, cwd, io })
   const combinedPackageRegistry = mergePackageRegistries(packageRegistry, appLocalRegistry);
   const { packageJsonPath, packageJson } = await loadAppPackageJson(appRoot);
   const { lockPath, lock } = await loadLockFile(appRoot);
+  await assertManagedCiWorkflowUnmodified({
+    appRoot,
+    lock
+  });
   const resolvedTargetPackageId = targetType === "package"
     ? await resolvePackageIdFromRegistryOrNodeModules({
         appRoot,
@@ -556,6 +563,19 @@ async function runPackageAddCommand(ctx = {}, { positional, options, cwd, io })
     combinedPackageRegistry,
     `${invocationMode} ${targetType} ${targetId}`
   );
+  for (const packageId of plannedInstalledPackageIds) {
+    const packageEntry = combinedPackageRegistry.get(packageId);
+    if (!packageEntry) {
+      throw createCliError(
+        `[ci:descriptor-missing] Installed package descriptor not found for ${packageId}. Restore the package in node_modules or the JSKIT catalog before changing installed package requirements.`
+      );
+    }
+  }
+  composeInstalledPackageCi({
+    lock,
+    packageRegistry: combinedPackageRegistry,
+    installedPackageIds: plannedInstalledPackageIds
+  });
 
   if (targetType === "bundle") {
     validateInlineOptionsForBundle({
@@ -766,6 +786,14 @@ async function runPackageAddCommand(ctx = {}, { positional, options, cwd, io })
     });
   }
 
+  await synchronizeManagedCiWorkflow({
+    appRoot,
+    lock,
+    packageRegistry: combinedPackageRegistry,
+    touchedFiles,
+    dryRun: options.dryRun === true
+  });
+
   const touchedFileList = sortStrings([...touchedFiles]);
   const successLabel = invocationMode === "generate"
     ? "Generated with"

package/src/server/commandHandlers/packageCommands/remove.js

@@ -27,6 +27,8 @@ async function runPackageRemoveCommand(ctx = {}, { positional, options, cwd, io
     removeEnvValue,
     writeFile,
     removeManagedViteProxyEntries,
+    assertManagedCiWorkflowUnmodified,
+    synchronizeManagedCiWorkflow,
     hashBuffer,
     rm,
     writeJsonFile,
@@ -45,6 +47,10 @@ async function runPackageRemoveCommand(ctx = {}, { positional, options, cwd, io
   const combinedPackageRegistry = mergePackageRegistries(packageRegistry, appLocalRegistry);
   const { packageJsonPath, packageJson } = await loadAppPackageJson(appRoot);
   const { lockPath, lock } = await loadLockFile(appRoot);
+  await assertManagedCiWorkflowUnmodified({
+    appRoot,
+    lock
+  });
   const installed = ensureObject(lock.installedPackages);
   await hydratePackageRegistryFromInstalledNodeModules({
     appRoot,
@@ -159,6 +165,13 @@ async function runPackageRemoveCommand(ctx = {}, { positional, options, cwd, io
   }
 
   delete installed[resolvedTargetId];
+  await synchronizeManagedCiWorkflow({
+    appRoot,
+    lock,
+    packageRegistry: combinedPackageRegistry,
+    touchedFiles,
+    dryRun: options.dryRun === true
+  });
   const touchedFileList = sortStrings([...touchedFiles]);
 
   if (!options.dryRun) {

package/src/server/core/argParser.js

@@ -137,11 +137,6 @@ 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);
       const hasInlineValue = withoutPrefix.includes("=");

package/src/server/core/buildCommandDeps.js

@@ -27,6 +27,13 @@ function createCommandHandlerDeps(deps = {}) {
     applyPackageMigrationsOnly: deps.applyPackageMigrationsOnly,
     applyPackagePositioning: deps.applyPackagePositioning,
     adoptAppLocalPackageDependencies: deps.adoptAppLocalPackageDependencies,
+    assertAppManagedCiWorkflowUnmodified: deps.assertAppManagedCiWorkflowUnmodified,
+    assertManagedCiWorkflowUnmodified: deps.assertManagedCiWorkflowUnmodified,
+    composeInstalledPackageCi: deps.composeInstalledPackageCi,
+    synchronizeAppCiWorkflow: deps.synchronizeAppCiWorkflow,
+    synchronizeManagedCiWorkflow: deps.synchronizeManagedCiWorkflow,
+    validateAppCiWorkflow: deps.validateAppCiWorkflow,
+    validateManagedCiWorkflow: deps.validateManagedCiWorkflow,
     loadAppPackageJson: deps.loadAppPackageJson,
     resolveLocalPackageId: deps.resolveLocalPackageId,
     createLocalPackageScaffoldFiles: deps.createLocalPackageScaffoldFiles,

package/src/server/core/createCliRunner.js

@@ -93,6 +93,15 @@ import {
 import {
   removeManagedViteProxyEntries
 } from "../cliRuntime/viteProxy.js";
+import {
+  assertAppManagedCiWorkflowUnmodified,
+  assertManagedCiWorkflowUnmodified,
+  composeInstalledPackageCi,
+  synchronizeAppCiWorkflow,
+  synchronizeManagedCiWorkflow,
+  validateAppCiWorkflow,
+  validateManagedCiWorkflow
+} from "../cliRuntime/ci/managedWorkflow.js";
 
 const commandHandlers = createCommandHandlers(
   createCommandHandlerDeps({
@@ -123,6 +132,13 @@ const commandHandlers = createCommandHandlers(
     applyPackageMigrationsOnly,
     applyPackagePositioning,
     adoptAppLocalPackageDependencies,
+    assertAppManagedCiWorkflowUnmodified,
+    assertManagedCiWorkflowUnmodified,
+    composeInstalledPackageCi,
+    synchronizeAppCiWorkflow,
+    synchronizeManagedCiWorkflow,
+    validateAppCiWorkflow,
+    validateManagedCiWorkflow,
     loadAppPackageJson,
     resolveLocalPackageId,
     createLocalPackageScaffoldFiles,

package/src/server/index.js

@@ -1,2 +1,13 @@
 export { runCli } from "./core/createCliRunner.js";
 export * from "./appBlueprint.js";
+export {
+  synchronizeAppCiWorkflow,
+  validateAppCiWorkflow
+} from "./cliRuntime/ci/managedWorkflow.js";
+export {
+  composeCiContributions
+} from "./cliRuntime/ci/composer.js";
+export {
+  JSKIT_CI_WORKFLOW_RELATIVE_PATH,
+  renderGithubWorkflow
+} from "./cliRuntime/ci/githubWorkflow.js";

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

@@ -1,215 +0,0 @@
-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 };