@jskit-ai/jskit-cli 0.2.34 → 0.2.37

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jskit-ai/jskit-cli",
-  "version": "0.2.34",
+  "version": "0.2.37",
   "description": "Bundle and package orchestration CLI for JSKIT apps.",
   "type": "module",
   "files": [
@@ -20,8 +20,8 @@
     "test": "node --test"
   },
   "dependencies": {
-    "@jskit-ai/jskit-catalog": "0.1.34",
-    "@jskit-ai/kernel": "0.1.26"
+    "@jskit-ai/jskit-catalog": "0.1.37",
+    "@jskit-ai/kernel": "0.1.29"
   },
   "engines": {
     "node": "20.x"

package/src/server/cliRuntime/packageTemplateResolution.js

@@ -1,4 +1,9 @@
-import { readdir } from "node:fs/promises";
+import { spawn } from "node:child_process";
+import {
+  mkdir,
+  readdir,
+  writeFile
+} from "node:fs/promises";
 import path from "node:path";
 import { createCliError } from "../shared/cliError.js";
 import { CLI_PACKAGE_ROOT } from "../shared/pathResolution.js";
@@ -8,8 +13,150 @@ import {
 } from "./ioAndMigrations.js";
 
 const LOCAL_WORKSPACE_PACKAGE_ROOTS = new Map();
+const MATERIALIZED_PACKAGE_ROOTS = new Map();
 let LOCAL_WORKSPACE_PACKAGE_ID_INDEX = null;
 
+function isInternalCatalogPackageEntry(packageEntry = {}) {
+  return (
+    String(packageEntry?.sourceType || "").trim() === "catalog" &&
+    String(packageEntry?.packageId || "").trim().startsWith("@jskit-ai/")
+  );
+}
+
+function encodePackageCacheSegment(value = "") {
+  return encodeURIComponent(String(value || "").trim() || "unknown");
+}
+
+function buildMaterializedCacheKey(packageEntry = {}) {
+  const packageId = String(packageEntry?.packageId || "").trim();
+  const version = String(packageEntry?.version || "").trim() || "latest";
+  return `${packageId}@${version}`;
+}
+
+function buildMaterializedInstallRoot({ appRoot, packageEntry }) {
+  const packageId = String(packageEntry?.packageId || "").trim();
+  const version = String(packageEntry?.version || "").trim() || "latest";
+  return path.resolve(
+    String(appRoot || "").trim(),
+    ".jskit",
+    "cache",
+    "package-sources",
+    encodePackageCacheSegment(packageId),
+    encodePackageCacheSegment(version)
+  );
+}
+
+async function ensureMaterializedInstallWorkspace(installRoot) {
+  await mkdir(installRoot, { recursive: true });
+  const packageJsonPath = path.join(installRoot, "package.json");
+  if (await fileExists(packageJsonPath)) {
+    return;
+  }
+
+  await writeFile(
+    packageJsonPath,
+    `${JSON.stringify(
+      {
+        name: "jskit-package-source-cache",
+        private: true,
+        type: "module"
+      },
+      null,
+      2
+    )}\n`,
+    "utf8"
+  );
+}
+
+async function installCatalogPackageIntoCache({ installRoot, packageEntry }) {
+  const packageId = String(packageEntry?.packageId || "").trim();
+  const version = String(packageEntry?.version || "").trim();
+  const packageSpec = version ? `${packageId}@${version}` : packageId;
+  await ensureMaterializedInstallWorkspace(installRoot);
+
+  await new Promise((resolve, reject) => {
+    const child = spawn(
+      "npm",
+      [
+        "install",
+        "--no-save",
+        "--ignore-scripts",
+        "--package-lock=false",
+        "--no-audit",
+        "--no-fund",
+        packageSpec
+      ],
+      {
+        cwd: installRoot,
+        stdio: ["ignore", "pipe", "pipe"]
+      }
+    );
+
+    let stderr = "";
+    child.stderr.on("data", (chunk) => {
+      stderr += String(chunk || "");
+    });
+
+    child.on("error", (error) => {
+      reject(
+        createCliError(
+          `Unable to materialize template source for ${packageId}: ${String(error?.message || error || "unknown error")}`
+        )
+      );
+    });
+    child.on("exit", (code) => {
+      if (code === 0) {
+        resolve();
+        return;
+      }
+
+      const detail = stderr.trim();
+      reject(
+        createCliError(
+          `Unable to materialize template source for ${packageId}. npm install failed` +
+            `${detail ? `: ${detail}` : "."}`
+        )
+      );
+    });
+  });
+}
+
+async function materializeCatalogPackageRoot({
+  packageEntry,
+  appRoot,
+  installCatalogPackage = installCatalogPackageIntoCache
+} = {}) {
+  if (!isInternalCatalogPackageEntry(packageEntry)) {
+    return "";
+  }
+
+  const packageId = String(packageEntry?.packageId || "").trim();
+  const cacheKey = buildMaterializedCacheKey(packageEntry);
+  if (MATERIALIZED_PACKAGE_ROOTS.has(cacheKey)) {
+    return MATERIALIZED_PACKAGE_ROOTS.get(cacheKey);
+  }
+
+  const installRoot = buildMaterializedInstallRoot({ appRoot, packageEntry });
+  const candidateRoot = path.join(installRoot, "node_modules", ...packageId.split("/"));
+  const descriptorPath = path.join(candidateRoot, "package.descriptor.mjs");
+
+  if (!(await fileExists(descriptorPath))) {
+    await installCatalogPackage({
+      installRoot,
+      packageEntry
+    });
+  }
+
+  if (!(await fileExists(descriptorPath))) {
+    throw createCliError(
+      `Unable to resolve template source for ${packageId} after materialization. Missing package.descriptor.mjs in cache.`
+    );
+  }
+
+  MATERIALIZED_PACKAGE_ROOTS.set(cacheKey, candidateRoot);
+  return candidateRoot;
+}
+
 async function resolvePackageRootFromNodeModules({ appRoot, packageId }) {
   const normalizedAppRoot = path.resolve(String(appRoot || "").trim());
   const normalizedPackageId = String(packageId || "").trim();
@@ -93,7 +240,11 @@ async function resolvePackageRootFromLocalWorkspace({ packageId }) {
   return packageRoot;
 }
 
-async function resolvePackageTemplateRoot({ packageEntry, appRoot }) {
+async function resolvePackageTemplateRoot({
+  packageEntry,
+  appRoot,
+  materializeCatalogRoot = materializeCatalogPackageRoot
+} = {}) {
   const packageRoot = String(packageEntry?.rootDir || "").trim();
   if (packageRoot) {
     return packageRoot;
@@ -114,6 +265,14 @@ async function resolvePackageTemplateRoot({ packageEntry, appRoot }) {
     return localWorkspacePackageRoot;
   }
 
+  const materializedCatalogPackageRoot = await materializeCatalogRoot({
+    packageEntry,
+    appRoot
+  });
+  if (materializedCatalogPackageRoot) {
+    return materializedCatalogPackageRoot;
+  }
+
   throw createCliError(
     `Unable to resolve local template source for ${String(packageEntry?.packageId || "unknown package")}. ` +
       "Install it in node_modules or ensure it exists in the local jskit-ai workspace."
@@ -122,10 +281,12 @@ async function resolvePackageTemplateRoot({ packageEntry, appRoot }) {
 
 async function cleanupMaterializedPackageRoots() {
   LOCAL_WORKSPACE_PACKAGE_ROOTS.clear();
+  MATERIALIZED_PACKAGE_ROOTS.clear();
   LOCAL_WORKSPACE_PACKAGE_ID_INDEX = null;
 }
 
 export {
   cleanupMaterializedPackageRoots,
+  materializeCatalogPackageRoot,
   resolvePackageTemplateRoot
 };

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

@@ -75,6 +75,7 @@ async function runPackageGenerateCommand(
     mergePackageRegistries,
     resolvePackageIdFromRegistryOrNodeModules,
     hydratePackageRegistryFromInstalledNodeModules,
+    resolvePackageTemplateRoot,
     resolvePackageKind,
     resolveGeneratorPrimarySubcommand,
     hasGeneratorSubcommandDefinition,
@@ -231,8 +232,20 @@ async function runPackageGenerateCommand(
       });
     }
 
-    return runGeneratorSubcommand({
+    const templateRoot = await resolvePackageTemplateRoot({
       packageEntry,
+      appRoot
+    });
+    const executablePackageEntry =
+      templateRoot === packageEntry.rootDir
+        ? packageEntry
+        : {
+            ...packageEntry,
+            rootDir: templateRoot
+          };
+
+    return runGeneratorSubcommand({
+      packageEntry: executablePackageEntry,
       subcommandName,
       subcommandArgs,
       inlineOptions: options.inlineOptions,

package/src/server/core/buildCommandDeps.js

@@ -16,6 +16,7 @@ function createCommandHandlerDeps(deps = {}) {
     resolveInstalledPackageIdInput: deps.resolveInstalledPackageIdInput,
     resolveInstalledNodeModulePackageEntry: deps.resolveInstalledNodeModulePackageEntry,
     hydratePackageRegistryFromInstalledNodeModules: deps.hydratePackageRegistryFromInstalledNodeModules,
+    resolvePackageTemplateRoot: deps.resolvePackageTemplateRoot,
     validateInlineOptionsForPackage: deps.validateInlineOptionsForPackage,
     resolveLocalDependencyOrder: deps.resolveLocalDependencyOrder,
     validatePlannedCapabilityClosure: deps.validatePlannedCapabilityClosure,

package/src/server/core/createCliRunner.js

@@ -70,6 +70,7 @@ import {
   validateInlineOptionsForPackage
 } from "../cliRuntime/packageOptions.js";
 import {
+  resolvePackageTemplateRoot,
   cleanupMaterializedPackageRoots
 } from "../cliRuntime/packageTemplateResolution.js";
 import {
@@ -100,6 +101,7 @@ const commandHandlers = createCommandHandlers(
     resolveInstalledPackageIdInput,
     resolveInstalledNodeModulePackageEntry,
     hydratePackageRegistryFromInstalledNodeModules,
+    resolvePackageTemplateRoot,
     validateInlineOptionsForPackage,
     resolveLocalDependencyOrder,
     validatePlannedCapabilityClosure,