vibe64 0.1.21

package/packages/vibe64-adapters/src/server/adapters/nextjs/launchTargets.js

@@ -0,0 +1,124 @@
+import {
+  createVibe64WebLaunchTargetTerminalSpec
+} from "@local/studio-terminal-core/server/launchTargetTerminal";
+import {
+  detectPackageManager,
+  packageBinCommand,
+  packageScript,
+  readPackageJson,
+  runScriptCommand
+} from "../../nodePackage.js";
+function launchModeForTarget(launchTargetId = "") {
+  return launchTargetId === "dev" ? "development" : "production";
+}
+
+function nextCommandOrPackageScript(packageJson = {}, packageManagerName = "npm", {
+  args = [],
+  binArgs = [],
+  scriptName = ""
+} = {}) {
+  return packageScript(packageJson, scriptName)
+    ? runScriptCommand(packageManagerName, scriptName, args)
+    : packageBinCommand(packageManagerName, "next", binArgs.length ? binArgs : [scriptName, ...args]);
+}
+
+function nextjsLaunchTarget(id, label) {
+  return {
+    id,
+    label
+  };
+}
+
+async function listNextjsLaunchTargets({
+  session = {}
+} = {}) {
+  const worktreePath = String(session.metadata?.worktree_path || "").trim();
+  if (!worktreePath || !await readPackageJson(worktreePath)) {
+    return [];
+  }
+  return [
+    nextjsLaunchTarget("built", "Run built version"),
+    nextjsLaunchTarget("dev", "Run dev version")
+  ];
+}
+
+async function createNextjsLaunchDescriptor({
+  mode = "production",
+  port,
+  worktreePath = ""
+} = {}) {
+  const packageJson = await readPackageJson(worktreePath);
+  const packageManager = await detectPackageManager(worktreePath, packageJson || {});
+  const buildCommand = nextCommandOrPackageScript(packageJson || {}, packageManager.name, {
+    scriptName: "build"
+  });
+  const serverArgs = ["-H", "0.0.0.0", "-p", String(port)];
+  const serverCommand = mode === "development"
+    ? nextCommandOrPackageScript(packageJson || {}, packageManager.name, {
+        args: serverArgs,
+        scriptName: "dev"
+      })
+    : nextCommandOrPackageScript(packageJson || {}, packageManager.name, {
+        args: serverArgs,
+        scriptName: "start"
+      });
+
+  return {
+    commands: [
+      mode === "production"
+        ? {
+            command: buildCommand,
+            label: "Building Next.js app.",
+            networkEnv: false
+          }
+        : null,
+      {
+        command: serverCommand,
+        label: "Starting Next.js launch server.",
+        networkEnv: true
+      }
+    ].filter(Boolean),
+    metadata: {
+      buildCommand: mode === "production" ? buildCommand : "",
+      commandSource: "next",
+      mode,
+      packageManager: packageManager.name,
+      serverCommand
+    },
+    urlPath: "/"
+  };
+}
+
+function createNextjsLaunchTargetTerminalSpec({
+  context = {},
+  launchTargetId = "",
+  session = {},
+  targetRoot = ""
+} = {}) {
+  if (!["built", "dev"].includes(launchTargetId)) {
+    return {
+      ok: false,
+      message: `Unknown Next.js launch target: ${launchTargetId || "(empty)"}.`
+    };
+  }
+  const launchTargetRoot = targetRoot || session.targetRoot || "";
+  return createVibe64WebLaunchTargetTerminalSpec({
+    adapterId: "nextjs",
+    launchTarget: context.launchTarget || nextjsLaunchTarget(launchTargetId, launchTargetId),
+    resolveLaunch: ({ port, worktreePath }) => createNextjsLaunchDescriptor({
+      config: context.config || session.config || {},
+      mode: launchModeForTarget(launchTargetId),
+      port,
+      targetRoot: launchTargetRoot,
+      worktreePath
+    }),
+    session,
+    targetRoot: launchTargetRoot
+  });
+}
+
+export {
+  createNextjsLaunchTargetTerminalSpec,
+  createNextjsLaunchDescriptor,
+  listNextjsLaunchTargets
+};

package/packages/vibe64-adapters/src/server/adapters/nextjs/manifest.js

@@ -0,0 +1,47 @@
+import {
+  deepFreeze
+} from "@local/vibe64-core/server/deepFreeze";
+import {
+  VIBE64_APPLICATION_TYPE_PHONE,
+  VIBE64_APPLICATION_TYPE_WEB
+} from "../../applicationTypes.js";
+import {
+  createNextjsTargetAdapter
+} from "./index.js";
+
+const NEXTJS_ADAPTER_MANIFEST = deepFreeze({
+  applicationTypes: [
+    {
+      explanation: "React web apps and full-stack products built around the standard Next.js ecosystem.",
+      id: VIBE64_APPLICATION_TYPE_WEB,
+      priority: 90
+    },
+    {
+      explanation: "Mobile-first React web apps that can be wrapped with Capacitor when native packaging is needed.",
+      id: VIBE64_APPLICATION_TYPE_PHONE,
+      priority: 80
+    }
+  ],
+  bestFor: "General-purpose React products, SaaS apps, dashboards, content sites, and greenfield projects that should stay close to the standard Next.js ecosystem.",
+  createAdapter: createNextjsTargetAdapter,
+  description: "Next.js is the React framework for App Router and Pages Router applications. The adapter understands package managers, router layout, database/runtime choices, seed options, launch modes, and framework checks.",
+  enabled: true,
+  id: "nextjs",
+  label: "Next.js",
+  outcome: "Studio can seed or inspect a Next.js app, configure TypeScript or JavaScript, Tailwind, Prisma or Drizzle, PostgreSQL or MySQL, then drive Codex with prompts tailored to that stack.",
+  projectUrl: "https://nextjs.org",
+  projectUrlLabel: "Open Next.js project",
+  summary: "The mainstream React framework for full-stack web applications.",
+  techStack: [
+    "React",
+    "Next.js",
+    "App Router",
+    "TypeScript",
+    "Tailwind CSS",
+    "Prisma or Drizzle"
+  ]
+});
+
+export {
+  NEXTJS_ADAPTER_MANIFEST
+};

package/packages/vibe64-adapters/src/server/adapters/nextjs/prepareWorktree.sh

@@ -0,0 +1,8 @@
+#!/usr/bin/env sh
+set -e
+
+for file in .env .env.development .env.development.local .env.local .env.production .env.production.local .env.test .env.test.local; do
+  if [ -f "$VIBE64_TARGET_ROOT/$file" ] && [ ! -e "$VIBE64_WORKTREE_PATH/$file" ]; then
+    cp -p "$VIBE64_TARGET_ROOT/$file" "$VIBE64_WORKTREE_PATH/$file"
+  fi
+done

package/packages/vibe64-adapters/src/server/adapters/nextjs/prompts/execute_plan.txt

@@ -0,0 +1,9 @@
+{{systemStandard}}
+
+Next.js selected blueprint:
+{{adapter.promptContext.environment_blueprint}}
+
+Next.js-specific implementation guidance:
+- Preserve the project's routing convention, file organization, package manager, lint/build scripts, and selected blueprint.
+- Keep client-only code, server-only code, route handlers, Server Actions, and environment access in the correct runtime boundary.
+- If database support is selected, use `DATABASE_URL` through server-only code and avoid leaking secrets to client components.

package/packages/vibe64-adapters/src/server/adapters/nextjs/prompts/generic.txt

@@ -0,0 +1,9 @@
+{{systemStandard}}
+
+Next.js selected blueprint:
+{{adapter.promptContext.environment_blueprint}}
+
+Next.js-specific guidance:
+- Treat this as a Next.js project using the selected blueprint above.
+- Respect App Router vs Pages Router, Server Components vs Client Components, route handlers, Server Actions, package scripts, and deployment/runtime boundaries.
+- If a database runtime is selected, keep secrets in environment configuration and keep database access in server-only code.

package/packages/vibe64-adapters/src/server/adapters/nextjs/prompts/make_plan.txt

@@ -0,0 +1,11 @@
+{{systemStandard}}
+
+Create the implementation plan for this Next.js project.
+
+Next.js selected blueprint:
+{{adapter.promptContext.environment_blueprint}}
+
+Next.js-specific planning guidance:
+- Account for App Router vs Pages Router, Server Components vs Client Components, route handlers, Server Actions, package scripts, and the existing application state.
+- If the selected database runtime is not `none`, plan around `DATABASE_URL` in `.env.local` and keep database access in server-only code.
+- Include the focused verification path needed for the selected stack.

package/packages/vibe64-adapters/src/server/adapters/nextjs/prompts/prepare_for_merge.txt

@@ -0,0 +1,9 @@
+{{systemStandard}}
+
+Next.js selected blueprint:
+{{adapter.promptContext.environment_blueprint}}
+
+Next.js-specific merge-preparation guidance:
+- Use the recorded PR URL and inspect only what is needed to decide whether the Next.js work is mergeable.
+- Resolve local merge blockers, failing focused checks, routing/runtime boundary issues, environment problems, or selected-blueprint inconsistencies when they are clearly in scope.
+- Report whether the PR is ready and which Next.js checks or risks remain.

package/packages/vibe64-adapters/src/server/adapters/nextjs/prompts/run_deep_ui_check.txt

@@ -0,0 +1,9 @@
+{{systemStandard}}
+
+Next.js selected blueprint:
+{{adapter.promptContext.environment_blueprint}}
+
+Next.js-specific deep UI guidance:
+- Inspect the user-facing Next.js behavior affected by the change.
+- Check routing, loading/error states, responsive layout, form behavior, data fetching boundaries, and Server Component vs Client Component usage.
+- Fix clear UI defects directly when they are in scope and report anything blocked by runtime or environment setup.

package/packages/vibe64-adapters/src/server/adapters/nextjs/prompts/run_deslop.txt

@@ -0,0 +1,9 @@
+{{systemStandard}}
+
+Next.js selected blueprint:
+{{adapter.promptContext.environment_blueprint}}
+
+Next.js-specific review/deslop guidance:
+- Review routing conventions, server/client component boundaries, route handlers, Server Actions, environment variables, package scripts, and selected database/data-layer choices.
+- Remove unclear or duplicated code when the fix is obvious and scoped.
+- Keep generated or seeded project structure consistent with the selected blueprint.

package/packages/vibe64-adapters/src/server/adapters/nextjs/prompts/update_project_knowledge.txt

@@ -0,0 +1,9 @@
+{{systemStandard}}
+
+Next.js selected blueprint:
+{{adapter.promptContext.environment_blueprint}}
+
+Next.js-specific project-knowledge guidance:
+- Update the project knowledge artifact referenced by the adapter prompt context.
+- Preserve useful facts about routing mode, language, styling, data layer, database runtime, package scripts, and deployment/runtime decisions.
+- Remove stale claims and keep the artifact concise enough to maintain.

package/packages/vibe64-adapters/src/server/adapters/nextjs/setupDoctorPlugin.js

@@ -0,0 +1,405 @@
+import {
+  blockedDoctorCheck as blockedCheck,
+  createDoctorRepair,
+  failDoctorCheck as failCheck,
+  hardStopDoctorCheck as hardStopCheck,
+  passDoctorCheck as passCheck
+} from "@local/vibe64-core/server/doctorCheckItems";
+import {
+  createDoctorPluginToolkit
+} from "@local/setup-doctor-core/server/doctorPluginToolkit";
+import {
+  shellQuote
+} from "@local/studio-terminal-core/server/shellCommands";
+import {
+  STUDIO_BASE_TOOLCHAIN_IMAGE
+} from "@local/studio-terminal-core/server/studioRuntimeIdentity";
+import {
+  createRuntimeContainerDoctorEntries
+} from "@local/studio-terminal-core/server/runtimeContainers";
+import {
+  writableHostUserDockerArgs
+} from "@local/studio-terminal-core/server/dockerRuntime";
+import {
+  checkNodePackageManagerToolchain
+} from "../../nodePackageDoctor.js";
+import {
+  checkExactEnvValues
+} from "../../adapterHelpers/setupEnvFiles.js";
+import {
+  readTargetPackageJson
+} from "../../adapterHelpers/setupNodePackages.js";
+import {
+  checkNodePackageManager,
+  checkNodeWebRouterMarkers,
+  nodePackageUsesNext,
+  packageDependencySummary,
+  selectedNodePackageManager
+} from "../../adapterHelpers/setupNodeWebChecks.js";
+import {
+  selectedNextjsPackageManager as selectedPackageManager,
+  selectedNextjsSeedBundler,
+  selectedNextjsSeedImportAlias,
+  selectedNextjsSeedLanguage,
+  selectedNextjsSeedLinter,
+  selectedNextjsSeedSourceLayout,
+  selectedNextjsSeedStyling
+} from "./config.js";
+import {
+  createNextjsRuntimeContainers,
+  expectedNextjsDatabaseUrl,
+  nextjsDatabaseEnvWriteScript,
+  selectedNextjsDatabaseRuntime,
+  startNextjsRuntimeRepair
+} from "./databaseRuntime.js";
+
+function createNextAppUseFlag(packageManager = "npm") {
+  return {
+    bun: "--use-bun",
+    npm: "--use-npm",
+    pnpm: "--use-pnpm",
+    yarn: "--use-yarn"
+  }[packageManager] || "--use-npm";
+}
+
+function createNextAppSeedFlags(config = {}) {
+  const language = selectedNextjsSeedLanguage(config);
+  const styling = selectedNextjsSeedStyling(config);
+  const linter = selectedNextjsSeedLinter(config);
+  const sourceLayout = selectedNextjsSeedSourceLayout(config);
+  const bundler = selectedNextjsSeedBundler(config);
+  const linterFlag = {
+    biome: "--biome",
+    eslint: "--eslint",
+    none: "--no-linter"
+  }[linter];
+  return [
+    "--yes",
+    "--reset-preferences",
+    language === "javascript" ? "--javascript" : "--typescript",
+    styling === "none" ? "--no-tailwind" : "--tailwind",
+    linterFlag,
+    "--app",
+    sourceLayout === "root" ? "--no-src-dir" : "--src-dir",
+    bundler === "webpack" ? "--webpack" : "--turbopack",
+    "--import-alias",
+    selectedNextjsSeedImportAlias(config),
+    "--disable-git"
+  ];
+}
+
+function createNextAppCommand({
+  appDir = "$app_dir",
+  config = {}
+} = {}) {
+  const packageManager = selectedPackageManager(config);
+  const appDirArg = appDir === "$app_dir" ? "\"$app_dir\"" : shellQuote(appDir);
+  const flags = [
+    ...createNextAppSeedFlags(config),
+    createNextAppUseFlag(packageManager)
+  ].map(shellQuote).join(" ");
+  if (packageManager === "pnpm") {
+    return `corepack pnpm create next-app ${appDirArg} ${flags}`;
+  }
+  if (packageManager === "yarn") {
+    return `corepack yarn create next-app ${appDirArg} ${flags}`;
+  }
+  if (packageManager === "bun") {
+    return `bunx create-next-app@latest ${appDirArg} ${flags}`;
+  }
+  return `npx --yes create-next-app@latest ${appDirArg} ${flags}`;
+}
+
+function createNextAppScript(config = {}, {
+  targetRoot = ""
+} = {}) {
+  const databaseEnvScript = selectedNextjsDatabaseRuntime(config) === "none"
+    ? ""
+    : nextjsDatabaseEnvWriteScript({
+        config,
+        targetRoot
+      });
+  return [
+    "set -e",
+    "set -x",
+    "tmp_dir=\"$(mktemp -d)\"",
+    "app_dir=\"$tmp_dir/app\"",
+    "cleanup() { rm -rf \"$tmp_dir\"; }",
+    "trap cleanup EXIT",
+    createNextAppCommand({
+      config
+    }),
+    "cp -a \"$app_dir/.\" .",
+    databaseEnvScript
+  ].join("\n");
+}
+
+function createNextAppRepair(config = {}) {
+  return createDoctorRepair({
+    actionId: "terminal-create-next-app",
+    autoRun: true,
+    command: createNextAppCommand({
+      appDir: "<temporary-directory>/app",
+      config
+    }),
+    kind: "terminal",
+    label: "Create Next.js app"
+  });
+}
+
+async function checkPackageJson(toolkit, targetRoot, context = {}) {
+  const result = await toolkit.readTargetJson("package.json", {
+    targetRoot
+  });
+  if (!result.ok) {
+    const nonGitEntries = (context.nonGitEntries || []).filter((entry) => entry !== "node_modules");
+    if (nonGitEntries.length) {
+      return hardStopCheck({
+        id: "nextjs-package-json",
+        label: "package.json",
+        expected: "A package.json exists or the target has no app-owned files.",
+        observed: `package.json is missing, but files exist:\n${nonGitEntries.join("\n")}`,
+        explanation: "Studio will not run create-next-app over existing app files because it cannot know their ownership."
+      });
+    }
+    return blockedCheck({
+      id: "nextjs-package-json",
+      label: "package.json",
+      expected: "A readable package.json exists in the target project.",
+      observed: result.missing ? "package.json is missing." : result.error,
+      explanation: "Seed a Next.js app before installing dependencies or running workflow commands.",
+      repair: createNextAppRepair(context.config)
+    });
+  }
+  return passCheck({
+    id: "nextjs-package-json",
+    label: "package.json",
+    expected: "A readable package.json exists in the target project.",
+    observed: result.path,
+    explanation: "The target has package metadata for Next.js setup."
+  });
+}
+
+async function checkNextDependency(toolkit, targetRoot) {
+  const packageJson = await readTargetPackageJson(targetRoot, toolkit);
+  if (!packageJson) {
+    return failCheck({
+      id: "nextjs-dependency",
+      label: "Next.js dependency",
+      expected: "package.json declares next or a Next.js package script.",
+      observed: "package.json is missing.",
+      explanation: "Seed or restore package.json before Next.js dependency checks run."
+    });
+  }
+  if (nodePackageUsesNext(packageJson)) {
+    return passCheck({
+      id: "nextjs-dependency",
+      label: "Next.js dependency",
+      expected: "package.json declares next or a Next.js package script.",
+      observed: "Next.js dependency or script is present.",
+      explanation: "The target is configured for Next.js commands."
+    });
+  }
+  return failCheck({
+    id: "nextjs-dependency",
+    label: "Next.js dependency",
+    expected: "package.json declares next or a Next.js package script.",
+    observed: `Dependencies: ${packageDependencySummary(packageJson)}`,
+    explanation: "This package is not recognisable as a Next.js project."
+  });
+}
+
+async function setupPackageManager(toolkit, targetRoot, config = {}) {
+  return selectedNodePackageManager(toolkit, targetRoot, {
+    fallback: selectedPackageManager(config)
+  });
+}
+
+async function checkPackageManagerToolchain(toolkit, targetRoot, config = {}) {
+  return checkNodePackageManagerToolchain(toolkit, {
+    id: "nextjs-package-manager-toolchain",
+    label: "Package manager command",
+    packageManager: await setupPackageManager(toolkit, targetRoot, config),
+    targetRoot
+  });
+}
+
+function seedDatabaseEnvRepair(targetRoot, config, toolkit) {
+  return toolkit.shellTerminalAction({
+    actionId: "terminal-seed-nextjs-db-env",
+    autoRun: true,
+    commandPreview: "write Next.js DATABASE_URL defaults",
+    cwd: targetRoot,
+    label: "Seed database .env.local",
+    script: () => nextjsDatabaseEnvWriteScript({
+      config,
+      targetRoot
+    })
+  }).repair({
+    config,
+    targetRoot
+  });
+}
+
+async function checkDatabaseEnv(toolkit, targetRoot, config = {}) {
+  const runtime = selectedNextjsDatabaseRuntime(config);
+  if (runtime === "none") {
+    return passCheck({
+      id: "nextjs-database-env",
+      label: "Database environment",
+      expected: "DATABASE_URL is required only when a managed database is selected.",
+      observed: "No managed database selected.",
+      explanation: "This Next.js target does not need database environment defaults."
+    });
+  }
+  const expected = expectedNextjsDatabaseUrl(runtime, targetRoot);
+  const seedRepair = seedDatabaseEnvRepair(targetRoot, config, toolkit);
+  return checkExactEnvValues(toolkit, {
+    expected: ".env.local declares the DATABASE_URL for the selected managed database.",
+    expectedValues: {
+      DATABASE_URL: expected
+    },
+    explanation: "Next.js apps conventionally read database connection strings from environment variables; Studio needs the target to point at the managed runtime container.",
+    id: "nextjs-database-env",
+    label: "Database environment",
+    missingObserved: "DATABASE_URL is missing or points somewhere else.",
+    passObserved: "DATABASE_URL matches the selected Vibe64-managed database.",
+    relativePath: ".env.local",
+    repair: seedRepair,
+    repairs: [
+      seedRepair,
+      startNextjsRuntimeRepair({
+        config,
+        targetRoot
+      })
+    ].filter(Boolean),
+    targetRoot
+  });
+}
+
+function runtimeContainerEntries(toolkit, context = {}, fallbackTargetRoot = "") {
+  const targetRoot = context.targetRoot || fallbackTargetRoot;
+  return createRuntimeContainerDoctorEntries(toolkit, createNextjsRuntimeContainers({
+    config: context.config || {},
+    targetRoot
+  }), {
+    adapterId: "nextjs",
+    targetRoot
+  });
+}
+
+function createNextjsSetupDoctorPlugin({
+  configEnvironment = {},
+  runCommand,
+  startTerminalSession,
+  studioRoot = "",
+  targetRoot = "",
+  terminalNamespace = ""
+} = {}) {
+  const toolkit = createDoctorPluginToolkit({
+    startTerminalSession,
+    runCommand,
+    studioRoot,
+    targetRoot,
+    terminalEnv: configEnvironment,
+    terminalNamespace
+  });
+  const createNextAppTerminal = toolkit.toolchainTerminalAction({
+    actionId: "terminal-create-next-app",
+    autoRun: true,
+    commandArgs: (context = {}) => ["bash", "-lc", createNextAppScript(context.config, {
+      targetRoot: context.targetRoot || targetRoot
+    })],
+    commandPreview: (context = {}) => createNextAppRepair(context.config).commandPreview,
+    extraArgs: writableHostUserDockerArgs({
+      env: {
+        npm_config_cache: "/tmp/npm-cache"
+      }
+    }),
+    image: STUDIO_BASE_TOOLCHAIN_IMAGE,
+    label: "Create Next.js app",
+    targetRoot: ({ targetRoot: contextTargetRoot = "" } = {}) => contextTargetRoot || targetRoot
+  });
+
+  return toolkit.plugin({
+    id: "nextjs-target-runtime",
+    label: "Next.js target runtime",
+    checks(context = {}) {
+      const checkTargetRoot = context.targetRoot || targetRoot;
+      const containers = runtimeContainerEntries(toolkit, context, targetRoot);
+      return [
+        {
+          expected: "The selected package manager runs inside the managed base toolchain.",
+          id: "nextjs-package-manager-toolchain",
+          label: "Package manager command",
+          run: () => checkPackageManagerToolchain(toolkit, checkTargetRoot, context.config || {})
+        },
+        {
+          expected: "A readable package.json exists in the target project.",
+          id: "nextjs-package-json",
+          label: "package.json",
+          run: () => checkPackageJson(toolkit, checkTargetRoot, context)
+        },
+        {
+          expected: "An app/, src/app/, pages/, or src/pages/ router directory exists.",
+          id: "nextjs-router",
+          label: "Router files",
+          run: () => checkNodeWebRouterMarkers(toolkit, checkTargetRoot, {
+            explanation: "Next.js projects use App Router and/or Pages Router directories.",
+            id: "nextjs-router",
+            label: "Router files",
+            missingObserved: "No Next.js router directory was found."
+          })
+        },
+        {
+          expected: "package.json declares next or a Next.js package script.",
+          id: "nextjs-dependency",
+          label: "Next.js dependency",
+          run: () => checkNextDependency(toolkit, checkTargetRoot)
+        },
+        {
+          expected: "Studio can identify the package manager used by the target.",
+          id: "nextjs-package-manager",
+          label: "Package manager",
+          run: () => checkNodePackageManager(toolkit, checkTargetRoot, {
+            explanation: "Next.js workflow commands will use this package manager for install and CLI execution.",
+            id: "nextjs-package-manager",
+            label: "Package manager"
+          })
+        },
+        {
+          expected: "Next.js database environment matches the selected managed database.",
+          id: "nextjs-database-env",
+          label: "Database environment",
+          run: () => checkDatabaseEnv(toolkit, checkTargetRoot, context.config || {})
+        },
+        ...containers.checks
+      ];
+    },
+    terminalActions(context = {}) {
+      return [
+        createNextAppTerminal,
+        toolkit.shellTerminalAction({
+          actionId: "terminal-seed-nextjs-db-env",
+          autoRun: true,
+          commandPreview: "write Next.js DATABASE_URL defaults",
+          cwd: context.targetRoot || targetRoot,
+          env: configEnvironment,
+          label: "Seed database .env.local",
+          script: () => nextjsDatabaseEnvWriteScript({
+            config: context.config || {},
+            targetRoot: context.targetRoot || targetRoot
+          })
+        }),
+        ...runtimeContainerEntries(toolkit, context, targetRoot).terminalActions
+      ];
+    }
+  });
+}
+
+export {
+  createNextAppCommand,
+  createNextAppRepair,
+  createNextAppScript,
+  createNextjsSetupDoctorPlugin
+};