@jskit-ai/kernel 0.1.147 → 0.1.149

package/internal/node/installedPackageDescriptor.js

@@ -1,125 +0,0 @@
-import path from "node:path";
-import { pathToFileURL } from "node:url";
-import { normalizeObject } from "../../shared/support/normalize.js";
-import { fileExists } from "./fileSystem.js";
-
-function resolveNodeModulesDescriptorCandidatePaths({ appRoot, packageId }) {
-  const packageDescriptorPath = path.join(packageId, "package.descriptor.mjs");
-  const candidatePaths = [];
-  let currentRoot = path.resolve(appRoot);
-
-  while (true) {
-    const nodeModulesRoot =
-      path.basename(currentRoot) === "node_modules" ? currentRoot : path.join(currentRoot, "node_modules");
-    candidatePaths.push(path.join(nodeModulesRoot, packageDescriptorPath));
-
-    const parentRoot = path.dirname(currentRoot);
-    if (parentRoot === currentRoot) {
-      break;
-    }
-    currentRoot = parentRoot;
-  }
-
-  return candidatePaths;
-}
-
-function resolveDescriptorCandidatePaths({ appRoot, packageId, installedPackageState }) {
-  const normalizedAppRoot = String(appRoot || "").trim();
-  if (!normalizedAppRoot) {
-    throw new TypeError("resolveDescriptorCandidatePaths requires appRoot.");
-  }
-
-  const normalizedPackageId = String(packageId || "").trim();
-  if (!normalizedPackageId) {
-    throw new TypeError("resolveDescriptorCandidatePaths requires packageId.");
-  }
-
-  const source = normalizeObject(installedPackageState?.source);
-  const descriptorPathFromSource = String(source.descriptorPath || "").trim();
-  const packagePathFromSource = String(source.packagePath || "").trim();
-  const jskitRoot = path.join(normalizedAppRoot, "node_modules", "@jskit-ai", "jskit-cli");
-
-  const candidatePaths = resolveNodeModulesDescriptorCandidatePaths({
-    appRoot: normalizedAppRoot,
-    packageId: normalizedPackageId
-  });
-  if (packagePathFromSource) {
-    candidatePaths.push(path.resolve(normalizedAppRoot, packagePathFromSource, "package.descriptor.mjs"));
-  }
-  if (descriptorPathFromSource) {
-    candidatePaths.push(path.resolve(normalizedAppRoot, descriptorPathFromSource));
-    candidatePaths.push(path.resolve(jskitRoot, descriptorPathFromSource));
-  }
-
-  const uniqueCandidatePaths = [];
-  const seenPaths = new Set();
-  for (const candidatePath of candidatePaths) {
-    const normalizedCandidatePath = String(candidatePath || "").trim();
-    if (!normalizedCandidatePath || seenPaths.has(normalizedCandidatePath)) {
-      continue;
-    }
-    seenPaths.add(normalizedCandidatePath);
-    uniqueCandidatePaths.push(normalizedCandidatePath);
-  }
-
-  return uniqueCandidatePaths;
-}
-
-async function resolveDescriptorPathForInstalledPackage({ appRoot, packageId, installedPackageState, required = false }) {
-  const candidatePaths = resolveDescriptorCandidatePaths({
-    appRoot,
-    packageId,
-    installedPackageState
-  });
-
-  for (const candidatePath of candidatePaths) {
-    if (await fileExists(candidatePath)) {
-      return candidatePath;
-    }
-  }
-
-  if (required === true) {
-    throw new Error(`Unable to resolve package descriptor for ${String(packageId || "").trim()}.`);
-  }
-
-  return "";
-}
-
-function normalizeDescriptorPayload(descriptorModule) {
-  return normalizeObject(descriptorModule?.default);
-}
-
-async function loadInstalledPackageDescriptor({ appRoot, packageId, installedPackageState, required = false }) {
-  const descriptorPath = await resolveDescriptorPathForInstalledPackage({
-    appRoot,
-    packageId,
-    installedPackageState,
-    required
-  });
-
-  if (!descriptorPath) {
-    return Object.freeze({
-      descriptorPath: "",
-      descriptor: Object.freeze({})
-    });
-  }
-
-  try {
-    const descriptorModule = await import(pathToFileURL(descriptorPath).href);
-    return Object.freeze({
-      descriptorPath,
-      descriptor: normalizeDescriptorPayload(descriptorModule)
-    });
-  } catch (error) {
-    if (required === true) {
-      throw error;
-    }
-
-    return Object.freeze({
-      descriptorPath: "",
-      descriptor: Object.freeze({})
-    });
-  }
-}
-
-export { loadInstalledPackageDescriptor, resolveDescriptorPathForInstalledPackage };

package/server/platform/providerRuntime/lockfile.js

@@ -1,27 +0,0 @@
-import path from "node:path";
-import { readFile } from "node:fs/promises";
-import { fileExists } from "../../../internal/node/fileSystem.js";
-
-async function readLockFromApp({ appRoot, lockPath = ".jskit/lock.json" } = {}) {
-  if (!appRoot || typeof appRoot !== "string") {
-    throw new TypeError("readLockFromApp requires appRoot.");
-  }
-
-  const absoluteLockPath = path.resolve(appRoot, String(lockPath || ".jskit/lock.json"));
-  if (!(await fileExists(absoluteLockPath))) {
-    throw new Error(`Lock file not found: ${absoluteLockPath}`);
-  }
-
-  const source = await readFile(absoluteLockPath, "utf8");
-  const lock = JSON.parse(source);
-  if (!lock || typeof lock !== "object") {
-    throw new TypeError(`Invalid lock file payload at ${absoluteLockPath}.`);
-  }
-
-  return {
-    lock,
-    lockPath: absoluteLockPath
-  };
-}
-
-export { readLockFromApp };

package/shared/support/packageDescriptor.test.js

@@ -1,147 +0,0 @@
-import assert from "node:assert/strict";
-import { mkdir, mkdtemp, rm, writeFile } from "node:fs/promises";
-import { tmpdir } from "node:os";
-import path from "node:path";
-import test from "node:test";
-
-import { loadInstalledPackageDescriptor, resolveDescriptorPathForInstalledPackage } from "../../internal/node/installedPackageDescriptor.js";
-
-async function createFixtureRoot(prefix) {
-  return mkdtemp(path.join(tmpdir(), prefix));
-}
-
-async function writeDescriptorFile(filePath, descriptorSource) {
-  await mkdir(path.dirname(filePath), { recursive: true });
-  await writeFile(filePath, descriptorSource, "utf8");
-}
-
-test("resolveDescriptorPathForInstalledPackage returns empty string when descriptor is missing and required=false", async () => {
-  const appRoot = await createFixtureRoot("kernel-package-descriptor-missing-");
-  try {
-    const descriptorPath = await resolveDescriptorPathForInstalledPackage({
-      appRoot,
-      packageId: "@example/missing",
-      installedPackageState: {},
-      required: false
-    });
-    assert.equal(descriptorPath, "");
-  } finally {
-    await rm(appRoot, { recursive: true, force: true });
-  }
-});
-
-test("resolveDescriptorPathForInstalledPackage throws when descriptor is missing and required=true", async () => {
-  const appRoot = await createFixtureRoot("kernel-package-descriptor-required-");
-  try {
-    await assert.rejects(
-      () =>
-        resolveDescriptorPathForInstalledPackage({
-          appRoot,
-          packageId: "@example/missing",
-          installedPackageState: {},
-          required: true
-        }),
-      /Unable to resolve package descriptor for @example\/missing\./
-    );
-  } finally {
-    await rm(appRoot, { recursive: true, force: true });
-  }
-});
-
-test("resolveDescriptorPathForInstalledPackage resolves descriptor using source.packagePath", async () => {
-  const appRoot = await createFixtureRoot("kernel-package-descriptor-package-path-");
-  try {
-    const descriptorPath = path.join(appRoot, "packages", "local-example", "package.descriptor.mjs");
-    await writeDescriptorFile(descriptorPath, "export default { packageId: \"@local/example\" };\n");
-
-    const resolvedDescriptorPath = await resolveDescriptorPathForInstalledPackage({
-      appRoot,
-      packageId: "@local/example",
-      installedPackageState: {
-        source: {
-          packagePath: "packages/local-example"
-        }
-      },
-      required: true
-    });
-    assert.equal(resolvedDescriptorPath, descriptorPath);
-  } finally {
-    await rm(appRoot, { recursive: true, force: true });
-  }
-});
-
-test("resolveDescriptorPathForInstalledPackage resolves descriptor from ancestor node_modules", async () => {
-  const installRoot = await createFixtureRoot("kernel-package-descriptor-hoisted-");
-  try {
-    const appRoot = path.join(installRoot, "node_modules", "@example", "app");
-    const descriptorPath = path.join(
-      installRoot,
-      "node_modules",
-      "@jskit-ai",
-      "shell-web",
-      "package.descriptor.mjs"
-    );
-    await mkdir(appRoot, { recursive: true });
-    await writeDescriptorFile(descriptorPath, "export default { packageId: \"@jskit-ai/shell-web\" };\n");
-
-    const resolvedDescriptorPath = await resolveDescriptorPathForInstalledPackage({
-      appRoot,
-      packageId: "@jskit-ai/shell-web",
-      installedPackageState: {},
-      required: true
-    });
-    assert.equal(resolvedDescriptorPath, descriptorPath);
-  } finally {
-    await rm(installRoot, { recursive: true, force: true });
-  }
-});
-
-test("resolveDescriptorPathForInstalledPackage resolves descriptor using jskit-cli descriptorPath fallback", async () => {
-  const appRoot = await createFixtureRoot("kernel-package-descriptor-jskit-root-");
-  try {
-    const descriptorPath = path.join(
-      appRoot,
-      "node_modules",
-      "@jskit-ai",
-      "jskit-cli",
-      "descriptors",
-      "example.descriptor.mjs"
-    );
-    await writeDescriptorFile(descriptorPath, "export default { packageId: \"@example/test\" };\n");
-
-    const resolvedDescriptorPath = await resolveDescriptorPathForInstalledPackage({
-      appRoot,
-      packageId: "@example/test",
-      installedPackageState: {
-        source: {
-          descriptorPath: "descriptors/example.descriptor.mjs"
-        }
-      },
-      required: true
-    });
-    assert.equal(resolvedDescriptorPath, descriptorPath);
-  } finally {
-    await rm(appRoot, { recursive: true, force: true });
-  }
-});
-
-test("loadInstalledPackageDescriptor loads descriptor payload once resolved", async () => {
-  const appRoot = await createFixtureRoot("kernel-package-descriptor-load-");
-  try {
-    const descriptorPath = path.join(appRoot, "node_modules", "@example", "ready", "package.descriptor.mjs");
-    await writeDescriptorFile(descriptorPath, "export default { packageId: \"@example/ready\", version: \"1.0.0\" };\n");
-
-    const descriptorRecord = await loadInstalledPackageDescriptor({
-      appRoot,
-      packageId: "@example/ready",
-      installedPackageState: {},
-      required: true
-    });
-
-    assert.equal(descriptorRecord.descriptorPath, descriptorPath);
-    assert.equal(descriptorRecord.descriptor.packageId, "@example/ready");
-    assert.equal(descriptorRecord.descriptor.version, "1.0.0");
-  } finally {
-    await rm(appRoot, { recursive: true, force: true });
-  }
-});