@jskit-ai/create-app 0.1.26 → 0.1.28

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jskit-ai/create-app",
-  "version": "0.1.26",
+  "version": "0.1.28",
   "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

@@ -15,6 +15,12 @@ Refresh JSKIT dependencies to the latest published versions:
 npm run jskit:update
 ```
 
+Automate update + PR + merge release flow:
+
+```bash
+npm run release
+```
+
 ## Server
 
 ```bash
@@ -29,5 +35,5 @@ App configuration files:
 ## Add Capabilities
 
 ```bash
-npx jskit add auth-base --no-install
+npx jskit add auth-base
 ```

package/templates/base-shell/package.json

@@ -27,6 +27,7 @@
     "test": "node --test",
     "test:client": "vitest run tests/client",
     "verify": "npm run lint && npm run test && npm run test:client && npm run build && npx jskit doctor",
+    "release": "bash ./scripts/release.sh",
     "jskit:update": "bash ./scripts/update-jskit-packages.sh"
   },
   "dependencies": {

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/release.sh

@@ -0,0 +1,95 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+APP_ROOT="$(cd "$(dirname "${BASH_SOURCE[0]}")/.." && pwd)"
+
+require_command() {
+  local name="$1"
+  if ! command -v "$name" >/dev/null 2>&1; then
+    echo "[release] required command not found: $name" >&2
+    exit 1
+  fi
+}
+
+ensure_clean_worktree() {
+  if [[ -n "$(git status --porcelain)" ]]; then
+    echo "[release] worktree is not clean. Commit/stash first." >&2
+    exit 1
+  fi
+}
+
+ensure_on_main() {
+  local current_branch
+  current_branch="$(git rev-parse --abbrev-ref HEAD)"
+  if [[ "$current_branch" != "main" ]]; then
+    echo "[release] current branch is \"$current_branch\". Switch to main first." >&2
+    exit 1
+  fi
+}
+
+main() {
+  require_command git
+  require_command npm
+  require_command gh
+
+  cd "$APP_ROOT"
+
+  if ! gh auth status >/dev/null 2>&1; then
+    echo "[release] gh is not authenticated. Run: gh auth login" >&2
+    exit 1
+  fi
+
+  ensure_clean_worktree
+  ensure_on_main
+
+  echo "[release] syncing local main..."
+  git fetch origin main
+  git pull --ff-only origin main
+
+  echo "[release] running package refresh..."
+  npm run jskit:update
+
+  if [[ -z "$(git status --porcelain)" ]]; then
+    echo "[release] no changes produced by jskit:update. Nothing to release."
+    exit 0
+  fi
+
+  local timestamp
+  local pretty_time
+  local branch
+  local commit_message
+  local pr_title
+  local pr_url
+
+  timestamp="$(date -u +%Y%m%d-%H%M%S)"
+  pretty_time="$(date -u +'%Y-%m-%d %H:%M UTC')"
+  branch="release/${timestamp}"
+  commit_message="chore: release ${pretty_time}"
+  pr_title="Release ${pretty_time}"
+
+  echo "[release] creating branch ${branch}..."
+  git checkout -b "$branch"
+
+  git add -A
+  git commit -m "$commit_message"
+  git push -u origin "$branch"
+
+  pr_url="$(
+    gh pr create \
+      --base main \
+      --head "$branch" \
+      --title "$pr_title" \
+      --body "Automated release commit generated by \`npm run release\`."
+  )"
+
+  echo "[release] created PR: $pr_url"
+  gh pr merge "$pr_url" --merge --delete-branch
+
+  echo "[release] merged. syncing local main..."
+  git checkout main
+  git pull --ff-only origin main
+
+  echo "[release] done."
+}
+
+main "$@"

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("/")) {