@jskit-ai/jskit-cli 0.2.136 → 0.2.139

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jskit-ai/jskit-cli",
-  "version": "0.2.136",
+  "version": "0.2.139",
   "description": "Bundle and package orchestration CLI for JSKIT apps.",
   "type": "module",
   "files": [
@@ -14,15 +14,16 @@
   "exports": {
     ".": "./src/index.js",
     "./server": "./src/server/index.js",
-    "./client": "./src/client/index.js"
+    "./client": "./src/client/index.js",
+    "./test/playwright": "./src/test/playwright.js"
   },
   "scripts": {
     "test": "node --test"
   },
   "dependencies": {
-    "@jskit-ai/jskit-catalog": "0.1.131",
-    "@jskit-ai/kernel": "0.1.121",
-    "@jskit-ai/shell-web": "0.1.120",
+    "@jskit-ai/jskit-catalog": "0.1.134",
+    "@jskit-ai/kernel": "0.1.122",
+    "@jskit-ai/shell-web": "0.1.123",
     "@vue/compiler-sfc": "^3.5.29",
     "ts-morph": "^28.0.0",
     "yaml": "^2.8.3"

package/src/server/cliRuntime/completion.js

@@ -18,11 +18,10 @@ import {
 } from "../core/commandCatalog.js";
 
 const WRAPPER_COMMANDS = new Set(["npx", "jsx"]);
-const KNOWN_GENERATE_FLAG_OPTIONS = Object.freeze(["dry-run", "run-npm-install", "devlinks", "json", "verbose"]);
+const KNOWN_GENERATE_FLAG_OPTIONS = Object.freeze(["dry-run", "run-npm-install", "json", "verbose"]);
 const BOOLEAN_OPTION_NAMES = new Set([
   "dry-run",
   "run-npm-install",
-  "devlinks",
   "full",
   "expanded",
   "details",
@@ -784,7 +783,6 @@ function buildCommandOptionMeta(command = "", catalogModule) {
     const labels = {
       dryRun: "dry-run",
       runNpmInstall: "run-npm-install",
-      devlinks: "devlinks",
       full: "full",
       expanded: "expanded",
       details: "details",

package/src/server/commandHandlers/app.js

@@ -9,7 +9,6 @@ import {
   resolveAppCommandDefinition
 } from "./appCommandCatalog.js";
 import { runAppAdoptManagedScriptsCommand } from "./appCommands/adoptManagedScripts.js";
-import { runAppLinkLocalPackagesCommand } from "./appCommands/linkLocalPackages.js";
 import { runAppMigrateSourceMutationsCommand } from "./appCommands/migrateSourceMutations.js";
 import { runAppReleaseCommand } from "./appCommands/release.js";
 import { runAppSyncCiCommand } from "./appCommands/syncCi.js";
@@ -147,9 +146,6 @@ function createAppCommands(ctx = {}) {
     if (definition.name === "sync-ci") {
       return runAppSyncCiCommand(ctx, { appRoot, options, stdout, stderr });
     }
-    if (definition.name === "link-local-packages") {
-      return runAppLinkLocalPackagesCommand(ctx, { appRoot, options, stdout, stderr });
-    }
     if (definition.name === "release") {
       return runAppReleaseCommand(ctx, { appRoot, options, stdout, stderr });
     }

package/src/server/commandHandlers/appCommandCatalog.js

@@ -1,7 +1,6 @@
 const APP_SCRIPT_WRAPPERS = Object.freeze({
   verify: "jskit app verify && npm run --if-present verify:app",
   "jskit:update": "jskit app update-packages",
-  devlinks: "jskit app link-local-packages",
   release: "jskit app release"
 });
 
@@ -12,9 +11,6 @@ const COPIED_APP_SCRIPT_VALUES = Object.freeze({
   "jskit:update": Object.freeze([
     "bash ./scripts/update-jskit-packages.sh"
   ]),
-  devlinks: Object.freeze([
-    "bash ./scripts/link-local-jskit-packages.sh"
-  ]),
   release: Object.freeze([
     "bash ./scripts/release.sh"
   ])
@@ -22,7 +18,6 @@ const COPIED_APP_SCRIPT_VALUES = Object.freeze({
 
 const COPIED_APP_SCRIPT_FILES = Object.freeze([
   "scripts/update-jskit-packages.sh",
-  "scripts/link-local-jskit-packages.sh",
   "scripts/release.sh"
 ]);
 
@@ -110,22 +105,6 @@ const APP_COMMAND_DEFINITIONS = Object.freeze({
       "Never claims an unrecorded jskit-verify.yml or removes a customized legacy verify.yml."
     ])
   }),
-  "link-local-packages": Object.freeze({
-    name: "link-local-packages",
-    summary: "Link local @jskit-ai workspace packages into the current app for live development.",
-    usage: "jskit app link-local-packages [--repo-root <path>]",
-    options: Object.freeze([
-      Object.freeze({
-        label: "--repo-root <path>",
-        description: "Explicit jskit-ai monorepo checkout to link from. If omitted, JSKIT_REPO_ROOT or nearby jskit-ai directories are used."
-      })
-    ]),
-    defaults: Object.freeze([
-      "Links packages from both the monorepo packages/ and tooling/ directories.",
-      "Refreshes node_modules/.bin entries for linked packages that publish binaries.",
-      "Clears node_modules/.vite so Vite does not keep stale prebundled paths."
-    ])
-  }),
   release: Object.freeze({
     name: "release",
     summary: "Run the JSKIT release helper for an app repository.",
@@ -232,9 +211,6 @@ function buildAppCommandOptionMeta(subcommandName = "") {
     optionMeta.feature = { inputType: "text" };
     optionMeta["auth-mode"] = { inputType: "text" };
   }
-  if (definition.name === "link-local-packages") {
-    optionMeta["repo-root"] = { inputType: "text" };
-  }
   return optionMeta;
 }
 

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

@@ -1,6 +1,6 @@
 import { spawn, spawnSync } from "node:child_process";
 import path from "node:path";
-import { access, mkdir, readFile, readdir, rm, symlink } from "node:fs/promises";
+import { access } from "node:fs/promises";
 
 function normalizeText(value = "") {
   return String(value || "").trim();
@@ -247,6 +247,7 @@ async function runLocalJskitAsync(
   appRoot,
   args = [],
   {
+    env = {},
     stdout,
     stderr,
     createCliError,
@@ -262,6 +263,7 @@ async function runLocalJskitAsync(
 
   return runExternalCommandAsync(localJskitBin, args, {
     cwd: appRoot,
+    env,
     stdout,
     stderr,
     quiet,
@@ -269,141 +271,6 @@ async function runLocalJskitAsync(
   });
 }
 
-async function resolveLocalRepoRoot({ appRoot = "", explicitRepoRoot = "" } = {}) {
-  const explicit = normalizeText(explicitRepoRoot);
-  if (explicit) {
-    return explicit;
-  }
-
-  const envRepoRoot = normalizeText(process.env.JSKIT_REPO_ROOT);
-  if (envRepoRoot) {
-    return envRepoRoot;
-  }
-
-  let currentDirectory = path.dirname(appRoot);
-  while (true) {
-    const candidateRoot = path.join(currentDirectory, "jskit-ai");
-    if (await fileExists(path.join(candidateRoot, "packages")) && await fileExists(path.join(candidateRoot, "tooling"))) {
-      return candidateRoot;
-    }
-    const parentDirectory = path.dirname(currentDirectory);
-    if (parentDirectory === currentDirectory) {
-      return "";
-    }
-    currentDirectory = parentDirectory;
-  }
-}
-
-async function discoverLocalPackageMap(repoRoot = "") {
-  const packageMap = new Map();
-  const parentDirectories = [
-    path.join(repoRoot, "packages"),
-    path.join(repoRoot, "tooling")
-  ];
-
-  for (const parentDirectory of parentDirectories) {
-    if (!(await fileExists(parentDirectory))) {
-      continue;
-    }
-
-    const entries = await readdir(parentDirectory, { withFileTypes: true });
-    entries.sort((left, right) => left.name.localeCompare(right.name));
-
-    for (const entry of entries) {
-      if (!entry.isDirectory() || entry.name.startsWith(".")) {
-        continue;
-      }
-
-      const packageRoot = path.join(parentDirectory, entry.name);
-      const packageJsonPath = path.join(packageRoot, "package.json");
-      if (!(await fileExists(packageJsonPath))) {
-        continue;
-      }
-
-      let packageJson = {};
-      try {
-        packageJson = JSON.parse(await readFile(packageJsonPath, "utf8"));
-      } catch {
-        continue;
-      }
-
-      const packageId = normalizeText(packageJson?.name);
-      if (!packageId.startsWith("@jskit-ai/")) {
-        continue;
-      }
-
-      const packageDirName = packageId.slice("@jskit-ai/".length);
-      if (!packageDirName || packageDirName.includes("/")) {
-        continue;
-      }
-
-      if (!packageMap.has(packageDirName)) {
-        packageMap.set(packageDirName, packageRoot);
-      }
-    }
-  }
-
-  return packageMap;
-}
-
-async function linkPackageBinEntries({
-  appRoot,
-  packageDirName,
-  sourceDir,
-  stdout
-} = {}) {
-  const packageJsonPath = path.join(sourceDir, "package.json");
-  if (!(await fileExists(packageJsonPath))) {
-    return;
-  }
-
-  let packageJson = {};
-  try {
-    packageJson = JSON.parse(await readFile(packageJsonPath, "utf8"));
-  } catch {
-    return;
-  }
-
-  const rawBin = packageJson?.bin;
-  let binEntries = [];
-  if (typeof rawBin === "string") {
-    binEntries = [[packageDirName, rawBin]];
-  } else if (rawBin && typeof rawBin === "object" && !Array.isArray(rawBin)) {
-    binEntries = Object.entries(rawBin);
-  }
-
-  if (binEntries.length < 1) {
-    return;
-  }
-
-  const binDirectory = path.join(appRoot, "node_modules", ".bin");
-  const packageRoot = path.join(appRoot, "node_modules", "@jskit-ai", packageDirName);
-  await mkdir(binDirectory, { recursive: true });
-
-  for (const [rawBinName, rawBinTarget] of binEntries) {
-    const binName = normalizeText(rawBinName);
-    const binTarget = normalizeText(rawBinTarget);
-    if (!binName || !binTarget) {
-      continue;
-    }
-
-    const absoluteTarget = path.join(packageRoot, binTarget);
-    if (!(await fileExists(absoluteTarget))) {
-      continue;
-    }
-
-    const binPath = path.join(binDirectory, binName);
-    await rm(binPath, { recursive: true, force: true });
-    const relativeTarget = path.relative(binDirectory, absoluteTarget) || absoluteTarget;
-    await symlink(relativeTarget, binPath);
-    stdout?.write(`[link-local] linked bin ${binName} -> ${relativeTarget}\n`);
-  }
-}
-
-function resolveSymlinkType() {
-  return process.platform === "win32" ? "junction" : "dir";
-}
-
 export {
   fileExists,
   normalizeText,
@@ -414,9 +281,5 @@ export {
   formatUtcReleaseTimestamp,
   resolveLocalJskitBin,
   runLocalJskit,
-  runLocalJskitAsync,
-  resolveLocalRepoRoot,
-  discoverLocalPackageMap,
-  linkPackageBinEntries,
-  resolveSymlinkType
+  runLocalJskitAsync
 };

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

@@ -33,6 +33,8 @@ const DEPENDENCY_SECTIONS = Object.freeze([
   })
 ]);
 const JSKIT_PACKAGE_PATTERN = /^@jskit-ai\/[a-z0-9._-]+$/iu;
+const JSKIT_CLI_PACKAGE = "@jskit-ai/jskit-cli";
+const UPDATE_PACKAGES_BOOTSTRAPPED_ENV = "JSKIT_UPDATE_PACKAGES_BOOTSTRAPPED";
 const PROGRESS_INTERVAL_MS = 5_000;
 
 function collectJskitPackageNames(packageMap = {}) {
@@ -513,6 +515,68 @@ async function runAppUpdatePackagesCommand(ctx = {}, { appRoot = "", options = {
     stdout?.write("[jskit:update] dry-run mode enabled.\n");
   }
 
+  const cliSection = DEPENDENCY_SECTIONS.find((section) =>
+    Object.prototype.hasOwnProperty.call(packageJson?.[section.name] || {}, JSKIT_CLI_PACKAGE)
+  );
+  if (
+    !dryRun &&
+    cliSection &&
+    process.env[UPDATE_PACKAGES_BOOTSTRAPPED_ENV] !== "1"
+  ) {
+    await resolveLatestVersions([JSKIT_CLI_PACKAGE], latestVersions, {
+      appRoot,
+      createCliError,
+      registryArgs,
+      stderr,
+      stdout
+    });
+    const latestCliVersion = latestVersions.get(JSKIT_CLI_PACKAGE);
+    let installedCliVersion = "";
+    try {
+      installedCliVersion = String(
+        (await readJson(path.join(appRoot, "node_modules", "@jskit-ai", "jskit-cli", "package.json")))?.version || ""
+      ).trim();
+    } catch (error) {
+      if (error?.code !== "ENOENT") {
+        throw error;
+      }
+    }
+
+    if (installedCliVersion !== latestCliVersion) {
+      stdout?.write(`[jskit:update] bootstrapping ${JSKIT_CLI_PACKAGE}@${latestCliVersion}.\n`);
+      await runExternalCommandAsync(
+        "npm",
+        [
+          "install",
+          ...cliSection.installArgs,
+          ...registryArgs,
+          `${JSKIT_CLI_PACKAGE}@${latestCliVersion}`
+        ],
+        {
+          cwd: appRoot,
+          stdout,
+          stderr,
+          createCliError
+        }
+      );
+    }
+
+    stdout?.write("[jskit:update] handing the update to the current local CLI.\n");
+    await runLocalJskitAsync(
+      appRoot,
+      ["app", "update-packages", ...registryArgs],
+      {
+        env: {
+          [UPDATE_PACKAGES_BOOTSTRAPPED_ENV]: "1"
+        },
+        stdout,
+        stderr,
+        createCliError
+      }
+    );
+    return 0;
+  }
+
   await runWithProgress(
     async () => {
       const updatedRootPackages = await updateRootPackages({

package/src/server/commandHandlers/mobileCommandCatalog.js

@@ -2,12 +2,8 @@ const MOBILE_COMMAND_DEFINITIONS = Object.freeze({
   sync: Object.freeze({
     name: "sync",
     summary: "Build the JSKIT web client and sync the Android Capacitor shell.",
-    usage: "jskit mobile android sync [--dry-run] [--devlinks]",
+    usage: "jskit mobile android sync [--dry-run]",
     options: Object.freeze([
-      Object.freeze({
-        label: "--devlinks",
-        description: "If sync needs to run npm install first, also run npm run --if-present devlinks afterward."
-      }),
       Object.freeze({
         label: "--dry-run",
         description: "Preview the build and Capacitor sync commands without writing dist output or mutating the Android shell."

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

@@ -134,18 +134,11 @@ async function runLocalProjectBinary(binaryName, args = [], {
 
 async function installAppDependenciesForHook({
   appRoot,
-  appPackageJson,
   io,
   pathModule = path,
   createCliError,
-  dryRun = false,
-  runDevlinks = false
+  dryRun = false
 } = {}) {
-  const packageScripts =
-    appPackageJson?.scripts && typeof appPackageJson.scripts === "object"
-      ? appPackageJson.scripts
-      : {};
-
   await runLocalProjectBinary("npm", ["install"], {
     appRoot,
     io,
@@ -154,17 +147,6 @@ async function installAppDependenciesForHook({
     explanation: "[mobile] Installing app dependencies for the mobile shell:",
     dryRun
   });
-
-  if (runDevlinks === true && Object.prototype.hasOwnProperty.call(packageScripts, "devlinks")) {
-    await runLocalProjectBinary("npm", ["run", "--if-present", "devlinks"], {
-      appRoot,
-      io,
-      pathModule,
-      createCliError,
-      explanation: "[mobile] Refreshing local JSKIT package links:",
-      dryRun
-    });
-  }
 }
 
 async function resolvePackageOptionInputForInstall({
@@ -248,8 +230,7 @@ function createInstallHookHelpers({
   ctx,
   appRoot,
   io,
-  appPackageJson,
-  commandOptions = {}
+  appPackageJson
 } = {}) {
   return Object.freeze({
     ensureManagedMobileConfig: async ({ dryRun = false } = {}) =>
@@ -263,12 +244,10 @@ function createInstallHookHelpers({
     installAppDependencies: async ({ dryRun = false } = {}) =>
       await installAppDependenciesForHook({
         appRoot,
-        appPackageJson,
         io,
         pathModule: ctx.path,
         createCliError: ctx.createCliError,
-        dryRun,
-        runDevlinks: commandOptions.devlinks === true
+        dryRun
       }),
     runProjectBinary: async (binaryName, args = [], { dryRun = false, explanation = "" } = {}) =>
       await runLocalProjectBinary(binaryName, args, {
@@ -649,8 +628,7 @@ async function runPackageAddCommand(ctx = {}, { positional, options, cwd, io })
     ctx,
     appRoot,
     io,
-    appPackageJson: packageJson,
-    commandOptions: options
+    appPackageJson: packageJson
   });
 
   for (const packageId of packagesToInstall) {

package/src/server/core/argParser.js

@@ -14,7 +14,6 @@ function parseArgs(argv, { createCliError } = {}) {
       options: {
         dryRun: false,
         runNpmInstall: false,
-        devlinks: false,
         full: false,
         expanded: false,
         details: false,
@@ -41,7 +40,6 @@ function parseArgs(argv, { createCliError } = {}) {
   const options = {
     dryRun: false,
     runNpmInstall: false,
-    devlinks: false,
     full: false,
     expanded: false,
     details: false,
@@ -73,10 +71,6 @@ function parseArgs(argv, { createCliError } = {}) {
       options.runNpmInstall = true;
       continue;
     }
-    if (token === "--devlinks") {
-      options.devlinks = true;
-      continue;
-    }
     if (token === "--full") {
       options.full = true;
       continue;

package/src/server/core/commandCatalog.js

@@ -1,7 +1,6 @@
 const OPTION_FLAG_LABELS = Object.freeze({
   dryRun: "--dry-run",
   runNpmInstall: "--run-npm-install",
-  devlinks: "--devlinks",
   full: "--full",
   expanded: "--expanded",
   details: "--details",
@@ -136,7 +135,7 @@ const COMMAND_DESCRIPTORS = Object.freeze({
     parameters: Object.freeze([
       Object.freeze({
         name: "<subcommand>",
-        description: "verify | update-packages | link-local-packages | release | adopt-managed-scripts | migrate-source-mutations."
+        description: "verify | update-packages | release | adopt-managed-scripts | migrate-source-mutations."
       })
     ]),
     defaults: Object.freeze([
@@ -189,13 +188,12 @@ const COMMAND_DESCRIPTORS = Object.freeze({
     defaults: Object.freeze([
       "Install the shell first with jskit add package @jskit-ai/mobile-capacitor.",
       "Use jskit mobile <platform> help for platform-specific usage.",
-      "--dry-run is accepted by jskit mobile android sync/run/build.",
-      "--devlinks runs npm run --if-present devlinks after jskit mobile android sync maintenance for development-only relinking."
+      "--dry-run is accepted by jskit mobile android sync/run/build."
     ]),
     fullUse: "jskit mobile <platform> <subcommand> [help] [--dry-run] [--<option> <value>...]",
     showHelpOnBareInvocation: true,
     handlerName: "commandMobile",
-    allowedFlagKeys: Object.freeze(["dryRun", "devlinks"]),
+    allowedFlagKeys: Object.freeze(["dryRun"]),
     inlineOptionMode: "delegate",
     allowedValueOptionNames: Object.freeze([]),
     canDelegateInlineOptions: (positional = []) => Array.isArray(positional) && positional.length > 0
@@ -298,14 +296,13 @@ const COMMAND_DESCRIPTORS = Object.freeze({
       "No npm install runs unless --run-npm-install is passed.",
       "Short ids resolve to @jskit-ai/<id> when available.",
       "Running without args lists bundles and runtime packages.",
-      "Existing matching version is skipped unless options force reapply.",
-      "--devlinks runs npm run --if-present devlinks after install when the app defines that script."
+      "Existing matching version is skipped unless options force reapply."
     ]),
     fullUse:
-      "jskit add <package|bundle> <id> [--<option> <value>...] [--dry-run] [--run-npm-install] [--devlinks] [--json] [--verbose]",
+      "jskit add <package|bundle> <id> [--<option> <value>...] [--dry-run] [--run-npm-install] [--json] [--verbose]",
     showHelpOnBareInvocation: false,
     handlerName: "commandAdd",
-    allowedFlagKeys: Object.freeze(["dryRun", "runNpmInstall", "devlinks", "json", "verbose"]),
+    allowedFlagKeys: Object.freeze(["dryRun", "runNpmInstall", "json", "verbose"]),
     inlineOptionMode: "delegate",
     allowedValueOptionNames: Object.freeze([]),
     canDelegateInlineOptions: canDelegateAddInlineOptions

package/src/test/playwright.js

@@ -0,0 +1,95 @@
+const DEFAULT_LOCAL_BASE_URL = "http://127.0.0.1:4173";
+const DEFAULT_SMOKE_PATH = "/home";
+const DEFAULT_VIEWPORTS = Object.freeze([
+  Object.freeze({ name: "compact", width: 390, height: 844 }),
+  Object.freeze({ name: "medium", width: 768, height: 1024 }),
+  Object.freeze({ name: "expanded", width: 1280, height: 900 })
+]);
+
+function normalizeBaseUrl(value) {
+  return String(value || "").trim().replace(/\/+$/u, "");
+}
+
+function createJskitPlaywrightConfig({ env = process.env } = {}) {
+  const managedBaseUrl = normalizeBaseUrl(env.PLAYWRIGHT_BASE_URL);
+  const baseURL = managedBaseUrl || DEFAULT_LOCAL_BASE_URL;
+  const storageState = String(env.JSKIT_PLAYWRIGHT_STORAGE_STATE || "").trim();
+
+  return {
+    testDir: "./tests/e2e",
+    timeout: 60_000,
+    expect: {
+      timeout: 10_000
+    },
+    use: {
+      baseURL,
+      headless: true,
+      ...(storageState ? { storageState } : {})
+    },
+    ...(managedBaseUrl ? {} : {
+      webServer: {
+        command: "npm run build && node ./bin/server.js",
+        env: {
+          PORT: "4173"
+        },
+        url: `${baseURL}/api/health`,
+        reuseExistingServer: true,
+        timeout: 180_000
+      }
+    })
+  };
+}
+
+async function expectNoHorizontalOverflow(page, expect) {
+  const metrics = await page.evaluate(() => ({
+    clientWidth: document.documentElement.clientWidth,
+    scrollWidth: document.documentElement.scrollWidth
+  }));
+
+  expect(metrics.scrollWidth).toBeLessThanOrEqual(metrics.clientWidth + 1);
+}
+
+async function expectVisibleTapTargets(page, expect) {
+  const heights = await page.locator("a[href], button, [role='button'], .v-btn, .v-list-item").evaluateAll(
+    (elements) => elements
+      .filter((element) => {
+        const rect = element.getBoundingClientRect();
+        const style = window.getComputedStyle(element);
+        return style.display !== "none" && style.visibility !== "hidden" && rect.width > 0 && rect.height > 0;
+      })
+      .map((element) => element.getBoundingClientRect().height)
+  );
+
+  for (const height of heights) {
+    expect(height).toBeGreaterThanOrEqual(48);
+  }
+}
+
+function runGeneratedAppSmoke({ test, expect, expectedText } = {}) {
+  if (!test || !expect || !String(expectedText || "").trim()) {
+    throw new Error("runGeneratedAppSmoke requires Playwright test, expect, and expectedText.");
+  }
+
+  const smokePath = String(process.env.JSKIT_PLAYWRIGHT_SMOKE_PATH || DEFAULT_SMOKE_PATH);
+
+  test.describe("generated app responsive smoke", () => {
+    for (const viewport of DEFAULT_VIEWPORTS) {
+      test(`${viewport.name} home route renders without horizontal overflow`, async ({ page }) => {
+        await page.setViewportSize({ width: viewport.width, height: viewport.height });
+        await page.goto(smokePath);
+        await expect(page.locator("body")).toBeVisible();
+        await expect(page.getByText(expectedText)).toBeVisible();
+        await expect(page.locator(".generated-ui-screen").first()).toBeVisible();
+        await expectVisibleTapTargets(page, expect);
+        await expectNoHorizontalOverflow(page, expect);
+      });
+    }
+  });
+}
+
+export {
+  createJskitPlaywrightConfig,
+  DEFAULT_LOCAL_BASE_URL,
+  DEFAULT_VIEWPORTS,
+  runGeneratedAppSmoke
+};

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

@@ -1,197 +0,0 @@
-import path from "node:path";
-import { lstat, mkdir, readFile, readlink, rm, symlink } from "node:fs/promises";
-import {
-  discoverLocalPackageMap,
-  fileExists,
-  linkPackageBinEntries,
-  resolveLocalRepoRoot,
-  resolveSymlinkType
-} from "./shared.js";
-
-const COMPANION_PACKAGES = Object.freeze([
-  Object.freeze({
-    packageName: "json-rest-schema",
-    repoDirName: "json-rest-schema"
-  }),
-  Object.freeze({
-    packageName: "json-rest-stores",
-    repoDirName: "json-rest-stores"
-  })
-]);
-
-function collectDeclaredPackageNames(packageJson = {}) {
-  const names = new Set();
-  const sections = [
-    packageJson?.dependencies,
-    packageJson?.devDependencies,
-    packageJson?.optionalDependencies,
-    packageJson?.peerDependencies
-  ];
-
-  for (const section of sections) {
-    if (!section || typeof section !== "object" || Array.isArray(section)) {
-      continue;
-    }
-
-    for (const packageName of Object.keys(section)) {
-      const normalizedPackageName = String(packageName || "").trim();
-      if (normalizedPackageName) {
-        names.add(normalizedPackageName);
-      }
-    }
-  }
-
-  return names;
-}
-
-async function verifySymlinkTarget(targetPath = "", sourceDir = "", {
-  packageName = ""
-} = {}) {
-  const stats = await lstat(targetPath);
-  if (!stats.isSymbolicLink()) {
-    throw new Error(`[link-local] expected ${packageName || targetPath} to be a symlink after linking.`);
-  }
-
-  const linkedTarget = await readlink(targetPath);
-  if (linkedTarget !== sourceDir) {
-    throw new Error(
-      `[link-local] expected ${packageName || targetPath} to link to ${sourceDir}, got ${linkedTarget}.`
-    );
-  }
-}
-
-async function replaceWithSymlink(targetPath = "", sourceDir = "", {
-  packageName = ""
-} = {}) {
-  await mkdir(path.dirname(targetPath), { recursive: true });
-  await rm(targetPath, { recursive: true, force: true });
-  await symlink(sourceDir, targetPath, resolveSymlinkType());
-  await verifySymlinkTarget(targetPath, sourceDir, {
-    packageName
-  });
-}
-
-async function maybeLinkCompanionPackages({
-  appRoot = "",
-  repoRoot = "",
-  stdout,
-  createCliError
-}) {
-  const companionRoot = path.dirname(repoRoot);
-  const appPackageJsonPath = path.join(appRoot, "package.json");
-  let appPackageJson = {};
-  try {
-    appPackageJson = JSON.parse(await readFile(appPackageJsonPath, "utf8"));
-  } catch {
-    appPackageJson = {};
-  }
-  const declaredPackageNames = collectDeclaredPackageNames(appPackageJson);
-  let linkedCount = 0;
-
-  for (const companion of COMPANION_PACKAGES) {
-    if (!declaredPackageNames.has(companion.packageName)) {
-      continue;
-    }
-
-    const sourceDir = path.join(companionRoot, companion.repoDirName);
-    const packageJsonPath = path.join(sourceDir, "package.json");
-    if (!(await fileExists(packageJsonPath))) {
-      throw createCliError(
-        `[link-local] companion package ${companion.packageName} is declared by the app but local source was not found at ${sourceDir}.`,
-        { exitCode: 1 }
-      );
-    }
-
-    let packageJson = {};
-    try {
-      packageJson = JSON.parse(await readFile(packageJsonPath, "utf8"));
-    } catch {
-      continue;
-    }
-
-    if (String(packageJson?.name || "").trim() !== companion.packageName) {
-      throw createCliError(
-        `[link-local] companion source at ${sourceDir} does not match expected package ${companion.packageName}.`,
-        { exitCode: 1 }
-      );
-    }
-
-    const appTargetPath = path.join(appRoot, "node_modules", companion.packageName);
-    await replaceWithSymlink(appTargetPath, sourceDir, {
-      packageName: companion.packageName
-    });
-    stdout.write(`[link-local] linked ${companion.packageName} -> ${sourceDir}\n`);
-    linkedCount += 1;
-
-    const repoTargetPath = path.join(repoRoot, "node_modules", companion.packageName);
-    await replaceWithSymlink(repoTargetPath, sourceDir, {
-      packageName: `${companion.packageName} (repo root)`
-    });
-    stdout.write(`[link-local] linked repo companion ${companion.packageName} -> ${sourceDir}\n`);
-    linkedCount += 1;
-  }
-
-  return linkedCount;
-}
-
-async function runAppLinkLocalPackagesCommand(ctx = {}, { appRoot = "", options = {}, stdout }) {
-  const { createCliError } = ctx;
-  const explicitRepoRoot = String(options?.inlineOptions?.["repo-root"] || "").trim();
-  const scopeDirectory = path.join(appRoot, "node_modules", "@jskit-ai");
-  const viteCacheDirectory = path.join(appRoot, "node_modules", ".vite");
-
-  if (!(await fileExists(scopeDirectory))) {
-    throw createCliError(`[link-local] @jskit-ai scope not found at ${scopeDirectory} (run npm install first).`, {
-      exitCode: 1
-    });
-  }
-
-  const repoRoot = await resolveLocalRepoRoot({ appRoot, explicitRepoRoot });
-  if (!repoRoot) {
-    throw createCliError("[link-local] no JSKIT repository found. Set JSKIT_REPO_ROOT or use --repo-root.", {
-      exitCode: 1
-    });
-  }
-
-  if (!(await fileExists(path.join(repoRoot, "packages"))) || !(await fileExists(path.join(repoRoot, "tooling")))) {
-    throw createCliError(`[link-local] JSKIT repo root is not valid: ${repoRoot}`, {
-      exitCode: 1
-    });
-  }
-
-  const packageMap = await discoverLocalPackageMap(repoRoot);
-  let linkedCount = 0;
-  await mkdir(scopeDirectory, { recursive: true });
-
-  for (const [packageDirName, sourceDir] of [...packageMap.entries()].sort((left, right) => left[0].localeCompare(right[0]))) {
-    const targetPath = path.join(scopeDirectory, packageDirName);
-    await replaceWithSymlink(targetPath, sourceDir, {
-      packageName: `@jskit-ai/${packageDirName}`
-    });
-    stdout.write(`[link-local] linked @jskit-ai/${packageDirName} -> ${sourceDir}\n`);
-    await linkPackageBinEntries({
-      appRoot,
-      packageDirName,
-      sourceDir,
-      stdout
-    });
-    linkedCount += 1;
-  }
-
-  linkedCount += await maybeLinkCompanionPackages({
-    appRoot,
-    repoRoot,
-    stdout,
-    createCliError
-  });
-
-  if (await fileExists(viteCacheDirectory)) {
-    await rm(viteCacheDirectory, { recursive: true, force: true });
-    stdout.write(`[link-local] cleared Vite cache at ${viteCacheDirectory}\n`);
-  }
-
-  stdout.write(`[link-local] done. linked=${linkedCount}\n`);
-  return 0;
-}
-
-export { runAppLinkLocalPackagesCommand };