@jskit-ai/create-app 0.1.26 → 0.1.27

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jskit-ai/create-app",
-  "version": "0.1.26",
+  "version": "0.1.27",
   "description": "Scaffold minimal JSKIT app shells.",
   "type": "module",
   "files": [

package/src/server/index.js

@@ -53,7 +53,7 @@ function buildInitialBundleCommands(initialBundles) {
 
   const commands = [];
   if (normalizedPreset === "auth") {
-    commands.push("npx jskit add auth-base --no-install");
+    commands.push("npx jskit add auth-base");
   }
 
   return commands;
@@ -634,7 +634,7 @@ export async function runCli(
       } else {
         stdout.write("First of all run npm install.:\n");
         stdout.write("Then add framework capabilities:\n");
-        stdout.write("- npx jskit add auth-base --no-install\n");
+        stdout.write("- npx jskit add auth-base\n");
         stdout.write("- npx jskit list\n");
         stdout.write("Run server and client to see it in action:\n");
         stdout.write("- npm run dev\n");

package/templates/base-shell/README.md

@@ -29,5 +29,5 @@ App configuration files:
 ## Add Capabilities
 
 ```bash
-npx jskit add auth-base --no-install
+npx jskit add auth-base
 ```

package/templates/base-shell/packages/main/src/server/support/loadAppConfig.js

@@ -1,54 +1,8 @@
-import { access, constants as fsConstants } from "node:fs/promises";
-import path from "node:path";
-import { fileURLToPath, pathToFileURL } from "node:url";
-
-async function fileExists(absolutePath) {
-  try {
-    await access(absolutePath, fsConstants.F_OK);
-    return true;
-  } catch {
-    return false;
-  }
-}
-
-async function resolveAppRootFrom(moduleDirectory) {
-  let currentDirectory = path.resolve(moduleDirectory);
-
-  while (true) {
-    const candidateConfigPath = path.join(currentDirectory, "config", "public.js");
-    if (await fileExists(candidateConfigPath)) {
-      return currentDirectory;
-    }
-
-    const parentDirectory = path.dirname(currentDirectory);
-    if (parentDirectory === currentDirectory) {
-      throw new Error("Unable to locate app root (missing config/public.js).");
-    }
-    currentDirectory = parentDirectory;
-  }
-}
-
-async function loadConfigModule(absolutePath) {
-  if (!(await fileExists(absolutePath))) {
-    return {};
-  }
-
-  const loadedModule = await import(pathToFileURL(absolutePath).href);
-  const loadedConfig = loadedModule?.config;
-  return loadedConfig && typeof loadedConfig === "object" && !Array.isArray(loadedConfig) ? loadedConfig : {};
-}
+import { loadAppConfigFromModuleUrl } from "@jskit-ai/kernel/server/support";
 
 async function loadAppConfig({ moduleUrl = import.meta.url } = {}) {
-  const moduleDirectory = path.dirname(fileURLToPath(moduleUrl));
-  const appRoot = await resolveAppRootFrom(moduleDirectory);
-  const [publicConfig, serverConfig] = await Promise.all([
-    loadConfigModule(path.join(appRoot, "config", "public.js")),
-    loadConfigModule(path.join(appRoot, "config", "server.js"))
-  ]);
-
-  return Object.freeze({
-    ...publicConfig,
-    ...serverConfig
+  return loadAppConfigFromModuleUrl({
+    moduleUrl
   });
 }
 

package/templates/base-shell/scripts/link-local-jskit-packages.sh

@@ -87,8 +87,7 @@ for (const parentDirectory of parentDirectories) {
 
     const packageRoot = path.join(parentDirectory, entry.name);
     const packageJsonPath = path.join(packageRoot, "package.json");
-    const descriptorPath = path.join(packageRoot, "package.descriptor.mjs");
-    if (!fs.existsSync(packageJsonPath) || !fs.existsSync(descriptorPath)) {
+    if (!fs.existsSync(packageJsonPath)) {
       continue;
     }
 
@@ -120,6 +119,68 @@ for (const [packageDirName, packageRoot] of packageMap.entries()) {
 NODE
 }
 
+link_package_bin_entries() {
+  local package_dir_name="$1"
+  local source_dir="$2"
+
+  node - "$APP_ROOT" "$package_dir_name" "$source_dir" <<'NODE'
+const fs = require("node:fs");
+const path = require("node:path");
+
+const appRoot = process.argv[2];
+const packageDirName = process.argv[3];
+const sourceDir = process.argv[4];
+
+const packageJsonPath = path.join(sourceDir, "package.json");
+if (!fs.existsSync(packageJsonPath)) {
+  process.exit(0);
+}
+
+let packageJson = {};
+try {
+  packageJson = JSON.parse(fs.readFileSync(packageJsonPath, "utf8"));
+} catch {
+  process.exit(0);
+}
+
+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) {
+  process.exit(0);
+}
+
+const binDir = path.join(appRoot, "node_modules", ".bin");
+const packageRoot = path.join(appRoot, "node_modules", "@jskit-ai", packageDirName);
+fs.mkdirSync(binDir, { recursive: true });
+
+for (const [rawBinName, rawBinTarget] of binEntries) {
+  const binName = String(rawBinName || "").trim();
+  const binTarget = String(rawBinTarget || "").trim();
+  if (!binName || !binTarget) {
+    continue;
+  }
+
+  const absoluteTarget = path.join(packageRoot, binTarget);
+  if (!fs.existsSync(absoluteTarget)) {
+    continue;
+  }
+
+  const binPath = path.join(binDir, binName);
+  fs.rmSync(binPath, { force: true, recursive: true });
+
+  const relativeTarget = path.relative(binDir, absoluteTarget) || absoluteTarget;
+  fs.symlinkSync(relativeTarget, binPath);
+  process.stdout.write(`[link-local] linked bin ${binName} -> ${relativeTarget}\n`);
+}
+NODE
+}
+
 linked_count=0
 
 mkdir -p "$SCOPE_DIR"
@@ -132,6 +193,7 @@ while IFS=$'\t' read -r package_dir_name source_dir; do
   rm -rf "$target_path"
   ln -s "$source_dir" "$target_path"
   echo "[link-local] linked @jskit-ai/$package_dir_name -> $source_dir"
+  link_package_bin_entries "$package_dir_name" "$source_dir"
   linked_count=$((linked_count + 1))
 done < <(discover_local_package_map)
 

package/templates/base-shell/scripts/update-jskit-packages.sh

@@ -113,7 +113,7 @@ if [[ "$dry_run_enabled" != "true" ]]; then
   echo "[jskit:update] generating managed migrations for changed packages."
   (
     cd "$APP_ROOT"
-    npx jskit migrations changed --no-install
+    npx jskit migrations changed
   )
 fi
 

package/templates/base-shell/server.js

@@ -10,9 +10,11 @@ import {
   resolveRuntimeProfileFromSurface,
   tryCreateProviderRuntimeFromApp
 } from "@jskit-ai/kernel/server/platform";
+import { matchesPathPrefix, normalizePathname } from "@jskit-ai/kernel/shared/surface/paths";
 import { surfaceRuntime } from "./server/lib/surfaceRuntime.js";
 
 const SPA_INDEX_FILE = "index.html";
+const API_BASE_PATH = "/api";
 const STATIC_GLOBAL_UI_PATHS = Object.freeze([
   "/assets",
   "/favicon.svg",
@@ -24,19 +26,18 @@ const STATIC_GLOBAL_UI_PATHS = Object.freeze([
 function toRequestPathname(urlValue) {
   const rawUrl = String(urlValue || "").trim() || "/";
   try {
-    return new URL(rawUrl, "http://localhost").pathname || "/";
+    return normalizePathname(new URL(rawUrl, "http://localhost").pathname || "/");
   } catch {
-    return rawUrl.split("?")[0] || "/";
+    return normalizePathname(rawUrl.split("?")[0] || "/");
   }
 }
 
 function isApiPath(pathname) {
-  const normalizedPathname = String(pathname || "").trim() || "/";
-  return normalizedPathname === "/api" || normalizedPathname.startsWith("/api/");
+  return matchesPathPrefix(pathname, API_BASE_PATH);
 }
 
 function hasFileExtension(pathname) {
-  return path.extname(String(pathname || "").trim()) !== "";
+  return path.extname(normalizePathname(pathname)) !== "";
 }
 
 function resolveGlobalUiPaths(runtimeGlobalUiPaths = []) {
@@ -48,10 +49,7 @@ function resolveGlobalUiPaths(runtimeGlobalUiPaths = []) {
 }
 
 function resolveStaticFilePath(pathname) {
-  const normalizedPathname = String(pathname || "").trim() || "/";
-  if (!normalizedPathname.startsWith("/")) {
-    return "";
-  }
+  const normalizedPathname = normalizePathname(pathname);
 
   const relativePath = normalizedPathname.replace(/^\/+/, "");
   if (!relativePath || relativePath.endsWith("/")) {