@jskit-ai/kernel 0.1.244 → 0.1.246

package/client/mobileLaunchRouting.test.js

@@ -1,230 +0,0 @@
-import assert from "node:assert/strict";
-import test from "node:test";
-import { normalizeIncomingAppUrl, registerMobileLaunchRouting } from "./mobileLaunchRouting.js";
-
-test("normalizeIncomingAppUrl normalizes custom-scheme auth callback routes into router paths", () => {
-  const normalized = normalizeIncomingAppUrl("convict://auth/login?code=abc&oauthProvider=google", {
-    enabled: true,
-    auth: {
-      customScheme: "convict"
-    }
-  });
-
-  assert.equal(normalized, "/auth/login?code=abc&oauthProvider=google");
-});
-
-test("normalizeIncomingAppUrl normalizes custom-scheme workspace routes", () => {
-  const normalized = normalizeIncomingAppUrl("convict://w/acme/workouts/2026-05-07?tab=today", {
-    enabled: true,
-    auth: {
-      customScheme: "convict"
-    }
-  });
-
-  assert.equal(normalized, "/w/acme/workouts/2026-05-07?tab=today");
-});
-
-test("normalizeIncomingAppUrl normalizes allowed HTTPS app links", () => {
-  const normalized = normalizeIncomingAppUrl("https://app.example.com/auth/login?code=abc", {
-    enabled: true,
-    auth: {
-      appLinkDomains: ["app.example.com"]
-    }
-  });
-
-  assert.equal(normalized, "/auth/login?code=abc");
-});
-
-test("normalizeIncomingAppUrl accepts same-origin HTTP URLs when explicitly allowed", () => {
-  const normalized = normalizeIncomingAppUrl(
-    "http://192.168.1.10:5173/w/acme",
-    {
-      enabled: true
-    },
-    {
-      allowedHttpOrigins: ["http://192.168.1.10:5173"]
-    }
-  );
-
-  assert.equal(normalized, "/w/acme");
-});
-
-test("normalizeIncomingAppUrl rejects unowned schemes and domains", () => {
-  assert.equal(
-    normalizeIncomingAppUrl("otherapp://auth/login?code=abc", {
-      enabled: true,
-      auth: {
-        customScheme: "convict"
-      }
-    }),
-    ""
-  );
-
-  assert.equal(
-    normalizeIncomingAppUrl("https://evil.example.com/auth/login?code=abc", {
-      enabled: true,
-      auth: {
-        appLinkDomains: ["app.example.com"]
-      }
-    }),
-    ""
-  );
-});
-
-test("registerMobileLaunchRouting initializes and applies the initial launch URL", async () => {
-  const replaceCalls = [];
-  const runtime = registerMobileLaunchRouting({
-    router: {
-      currentRoute: {
-        value: {
-          fullPath: "/home"
-        }
-      },
-      async replace(target) {
-        replaceCalls.push(target);
-      }
-    },
-    mobileConfig: {
-      enabled: true,
-      auth: {
-        customScheme: "convict"
-      }
-    },
-    getInitialLaunchUrl: async () => "convict://auth/login?code=abc"
-  });
-
-  const targetPath = await runtime.initialize();
-
-  assert.equal(targetPath, "/auth/login?code=abc");
-  assert.deepEqual(replaceCalls, ["/auth/login?code=abc"]);
-});
-
-test("registerMobileLaunchRouting subscribes to later launch URLs and routes them", async () => {
-  const replaceCalls = [];
-  let listener = null;
-  const runtime = registerMobileLaunchRouting({
-    router: {
-      currentRoute: {
-        value: {
-          fullPath: "/home"
-        }
-      },
-      async replace(target) {
-        replaceCalls.push(target);
-      }
-    },
-    mobileConfig: {
-      enabled: true,
-      auth: {
-        customScheme: "convict"
-      }
-    },
-    subscribeToLaunchUrls(handler) {
-      listener = handler;
-      return () => {
-        listener = null;
-      };
-    }
-  });
-
-  assert.equal(typeof listener, "function");
-  listener("convict://w/acme");
-  await Promise.resolve();
-  await Promise.resolve();
-  assert.deepEqual(replaceCalls, ["/w/acme"]);
-
-  runtime.dispose();
-  assert.equal(listener, null);
-});
-
-test("registerMobileLaunchRouting lets a resolver override the final route target", async () => {
-  const replaceCalls = [];
-  const runtime = registerMobileLaunchRouting({
-    router: {
-      currentRoute: {
-        value: {
-          fullPath: "/home"
-        }
-      },
-      async replace(target) {
-        replaceCalls.push(target);
-      }
-    },
-    mobileConfig: {
-      enabled: true,
-      auth: {
-        customScheme: "convict"
-      }
-    },
-    getInitialLaunchUrl: async () => "convict://auth/login?code=abc",
-    resolveTargetPath({ originalUrl, normalizedTargetPath, reason }) {
-      assert.equal(originalUrl, "convict://auth/login?code=abc");
-      assert.equal(normalizedTargetPath, "/auth/login?code=abc");
-      assert.equal(reason, "initial-launch");
-      return "/w/acme";
-    }
-  });
-
-  const targetPath = await runtime.initialize();
-
-  assert.equal(targetPath, "/w/acme");
-  assert.deepEqual(replaceCalls, ["/w/acme"]);
-});
-
-test("registerMobileLaunchRouting forwards unknown deep-link paths to the normal router", async () => {
-  const replaceCalls = [];
-  const runtime = registerMobileLaunchRouting({
-    router: {
-      currentRoute: {
-        value: {
-          fullPath: "/home"
-        }
-      },
-      async replace(target) {
-        replaceCalls.push(target);
-      }
-    },
-    mobileConfig: {
-      enabled: true,
-      auth: {
-        customScheme: "convict"
-      }
-    },
-    getInitialLaunchUrl: async () => "convict://w/acme/does-not-exist"
-  });
-
-  const targetPath = await runtime.initialize();
-
-  assert.equal(targetPath, "/w/acme/does-not-exist");
-  assert.deepEqual(replaceCalls, ["/w/acme/does-not-exist"]);
-});
-
-test("registerMobileLaunchRouting no-ops when mobile config is disabled", async () => {
-  const replaceCalls = [];
-  const runtime = registerMobileLaunchRouting({
-    router: {
-      currentRoute: {
-        value: {
-          fullPath: "/home"
-        }
-      },
-      async replace(target) {
-        replaceCalls.push(target);
-      }
-    },
-    mobileConfig: {
-      enabled: false,
-      auth: {
-        customScheme: "convict"
-      }
-    },
-    getInitialLaunchUrl: async () => "convict://auth/login?code=abc",
-    subscribeToLaunchUrls() {
-      throw new Error("subscribeToLaunchUrls should not be called when mobile is disabled");
-    }
-  });
-
-  const targetPath = await runtime.initialize();
-  assert.equal(targetPath, "");
-  assert.deepEqual(replaceCalls, []);
-});

package/server/http/lib/controller.js

@@ -1,183 +0,0 @@
-const DEFAULT_DOMAIN_ERROR_STATUS_BY_CODE = Object.freeze({
-  domain_validation_failed: 422,
-  validation_failed: 422,
-  invalid_input: 422,
-  duplicate: 409,
-  conflict: 409,
-  not_found: 404,
-  forbidden: 403,
-  unauthorized: 401,
-  rate_limited: 429
-});
-
-function normalizeStatus(status, fallbackStatus) {
-  const numeric = Number(status);
-  if (Number.isInteger(numeric) && numeric >= 100 && numeric <= 599) {
-    return numeric;
-  }
-
-  const fallbackNumeric = Number(fallbackStatus);
-  if (Number.isInteger(fallbackNumeric) && fallbackNumeric >= 100 && fallbackNumeric <= 599) {
-    return fallbackNumeric;
-  }
-
-  return 500;
-}
-
-function normalizeCode(code) {
-  const normalized = String(code || "")
-    .trim()
-    .toLowerCase();
-  return normalized || "";
-}
-
-function resolveDomainErrorStatus({
-  status,
-  code,
-  domainErrorStatusByCode = DEFAULT_DOMAIN_ERROR_STATUS_BY_CODE,
-  fallbackStatus = 422
-} = {}) {
-  const explicitStatus = Number(status);
-  if (Number.isInteger(explicitStatus) && explicitStatus >= 100 && explicitStatus <= 599) {
-    return explicitStatus;
-  }
-
-  const normalizedCode = normalizeCode(code);
-  if (normalizedCode) {
-    const mapSource =
-      domainErrorStatusByCode && typeof domainErrorStatusByCode === "object"
-        ? domainErrorStatusByCode
-        : DEFAULT_DOMAIN_ERROR_STATUS_BY_CODE;
-    const mappedStatus = Number(mapSource[normalizedCode]);
-    if (Number.isInteger(mappedStatus) && mappedStatus >= 100 && mappedStatus <= 599) {
-      return mappedStatus;
-    }
-  }
-
-  return normalizeStatus(fallbackStatus, 422);
-}
-
-function ensureReply(reply, methodName) {
-  if (!reply || typeof reply.code !== "function" || typeof reply.send !== "function") {
-    throw new TypeError(`${methodName} requires a Fastify reply-like object with code() and send().`);
-  }
-}
-
-function applyHeaders(reply, headers) {
-  if (!headers || typeof headers !== "object" || typeof reply.header !== "function") {
-    return;
-  }
-
-  for (const [name, value] of Object.entries(headers)) {
-    reply.header(name, value);
-  }
-}
-
-class BaseController {
-  constructor({ domainErrorStatusByCode = DEFAULT_DOMAIN_ERROR_STATUS_BY_CODE } = {}) {
-    this.domainErrorStatusByCode =
-      domainErrorStatusByCode && typeof domainErrorStatusByCode === "object"
-        ? { ...DEFAULT_DOMAIN_ERROR_STATUS_BY_CODE, ...domainErrorStatusByCode }
-        : { ...DEFAULT_DOMAIN_ERROR_STATUS_BY_CODE };
-  }
-
-  ok(reply, payload, { status = 200, headers = null } = {}) {
-    ensureReply(reply, "BaseController.ok");
-    applyHeaders(reply, headers);
-
-    const normalizedStatus = normalizeStatus(status, 200);
-    reply.code(normalizedStatus);
-
-    if (normalizedStatus === 204) {
-      return reply.send();
-    }
-
-    return reply.send(payload);
-  }
-
-  created(reply, payload, { headers = null } = {}) {
-    return this.ok(reply, payload, {
-      status: 201,
-      headers
-    });
-  }
-
-  noContent(reply, { headers = null } = {}) {
-    return this.ok(reply, undefined, {
-      status: 204,
-      headers
-    });
-  }
-
-  fail(
-    reply,
-    { status, code, message = "Request failed.", details, fieldErrors, headers = null, fallbackStatus = 422 } = {}
-  ) {
-    ensureReply(reply, "BaseController.fail");
-
-    const resolvedStatus = resolveDomainErrorStatus({
-      status,
-      code,
-      domainErrorStatusByCode: this.domainErrorStatusByCode,
-      fallbackStatus
-    });
-
-    const payload = {
-      error: String(message || "Request failed.")
-    };
-
-    const normalizedCode = normalizeCode(code);
-    if (normalizedCode) {
-      payload.code = String(code || "").trim();
-    }
-
-    if (details !== undefined) {
-      payload.details = details;
-    }
-
-    if (fieldErrors !== undefined) {
-      payload.fieldErrors = fieldErrors;
-      if (payload.details === undefined) {
-        payload.details = { fieldErrors };
-      }
-    }
-
-    applyHeaders(reply, headers);
-    reply.code(resolvedStatus);
-    return reply.send(payload);
-  }
-
-  sendActionResult(
-    reply,
-    result,
-    { successStatus = 200, defaultErrorStatus = 422, defaultErrorMessage = "Request failed." } = {}
-  ) {
-    if (!result || typeof result !== "object") {
-      throw new TypeError("BaseController.sendActionResult requires an object result.");
-    }
-
-    if (result.ok === true) {
-      const payload = Object.prototype.hasOwnProperty.call(result, "data") ? result.data : undefined;
-      return this.ok(reply, payload, {
-        status: result.status ?? successStatus,
-        headers: result.headers
-      });
-    }
-
-    if (result.ok === false) {
-      return this.fail(reply, {
-        status: result.status,
-        code: result.code,
-        message: result.message || defaultErrorMessage,
-        details: result.details,
-        fieldErrors: result.fieldErrors,
-        headers: result.headers,
-        fallbackStatus: defaultErrorStatus
-      });
-    }
-
-    throw new TypeError("BaseController.sendActionResult expects result.ok to be true or false.");
-  }
-}
-
-export { BaseController, DEFAULT_DOMAIN_ERROR_STATUS_BY_CODE, resolveDomainErrorStatus };

package/server/http/lib/controller.test.js

@@ -1,143 +0,0 @@
-import assert from "node:assert/strict";
-import test from "node:test";
-
-import { BaseController, resolveDomainErrorStatus } from "./controller.js";
-
-function createReplyStub() {
-  const state = {
-    statusCode: 200,
-    payload: undefined,
-    headers: {}
-  };
-
-  return {
-    state,
-    code(statusCode) {
-      state.statusCode = Number(statusCode);
-      return this;
-    },
-    header(name, value) {
-      state.headers[name] = value;
-      return this;
-    },
-    send(payload) {
-      state.payload = payload;
-      return this;
-    }
-  };
-}
-
-test("resolveDomainErrorStatus prefers explicit status", () => {
-  const status = resolveDomainErrorStatus({
-    status: 418,
-    code: "duplicate"
-  });
-
-  assert.equal(status, 418);
-});
-
-test("resolveDomainErrorStatus maps known domain codes", () => {
-  assert.equal(resolveDomainErrorStatus({ code: "duplicate" }), 409);
-  assert.equal(resolveDomainErrorStatus({ code: "domain_validation_failed" }), 422);
-  assert.equal(resolveDomainErrorStatus({ code: "not_found" }), 404);
-});
-
-test("BaseController.sendActionResult sends success payload and headers", () => {
-  const controller = new BaseController();
-  const reply = createReplyStub();
-
-  controller.sendActionResult(reply, {
-    ok: true,
-    data: { ok: true, value: 42 },
-    status: 201,
-    headers: {
-      "x-test": "success"
-    }
-  });
-
-  assert.equal(reply.state.statusCode, 201);
-  assert.deepEqual(reply.state.payload, { ok: true, value: 42 });
-  assert.equal(reply.state.headers["x-test"], "success");
-});
-
-test("BaseController.sendActionResult maps domain failure", () => {
-  const controller = new BaseController();
-  const reply = createReplyStub();
-
-  controller.sendActionResult(reply, {
-    ok: false,
-    code: "duplicate",
-    details: ["already exists"]
-  });
-
-  assert.equal(reply.state.statusCode, 409);
-  assert.deepEqual(reply.state.payload, {
-    error: "Request failed.",
-    code: "duplicate",
-    details: ["already exists"]
-  });
-});
-
-test("BaseController supports module-specific domain error codes through overrides", () => {
-  const controller = new BaseController({
-    domainErrorStatusByCode: {
-      duplicate_contact: 409
-    }
-  });
-  const reply = createReplyStub();
-
-  controller.sendActionResult(reply, {
-    ok: false,
-    code: "duplicate_contact",
-    details: ["already exists"]
-  });
-
-  assert.equal(reply.state.statusCode, 409);
-});
-
-test("BaseController.fail includes fieldErrors and default details shape", () => {
-  const controller = new BaseController();
-  const reply = createReplyStub();
-
-  controller.fail(reply, {
-    code: "domain_validation_failed",
-    message: "Validation failed.",
-    fieldErrors: {
-      email: "Invalid email."
-    }
-  });
-
-  assert.equal(reply.state.statusCode, 422);
-  assert.deepEqual(reply.state.payload, {
-    error: "Validation failed.",
-    code: "domain_validation_failed",
-    fieldErrors: {
-      email: "Invalid email."
-    },
-    details: {
-      fieldErrors: {
-        email: "Invalid email."
-      }
-    }
-  });
-});
-
-test("BaseController.noContent sends HTTP 204", () => {
-  const controller = new BaseController();
-  const reply = createReplyStub();
-
-  controller.noContent(reply);
-
-  assert.equal(reply.state.statusCode, 204);
-  assert.equal(reply.state.payload, undefined);
-});
-
-test("BaseController.sendActionResult rejects invalid result shape", () => {
-  const controller = new BaseController();
-  const reply = createReplyStub();
-
-  assert.throws(
-    () => controller.sendActionResult(reply, { data: { ok: true } }),
-    /expects result\.ok to be true or false/
-  );
-});

package/server/http/lib/index.js

@@ -1,5 +0,0 @@
-export { HttpKernelError, RouteDefinitionError, RouteRegistrationError } from "./errors.js";
-export { HttpRouter, createRouter, joinPath } from "./router.js";
-export { defineRouteValidator, compileRouteValidator, resolveRouteValidatorOptions } from "./routeValidator.js";
-export { BaseController, DEFAULT_DOMAIN_ERROR_STATUS_BY_CODE, resolveDomainErrorStatus } from "./controller.js";
-export { defaultMissingHandler, registerRoutes } from "./routeRegistration.js";

package/server/runtime/canonicalJson.js

@@ -1,74 +0,0 @@
-import crypto from "node:crypto";
-
-function isPlainObject(value) {
-  return Boolean(value) && typeof value === "object" && !Array.isArray(value) && value.constructor === Object;
-}
-
-function sortValue(value) {
-  if (Array.isArray(value)) {
-    return value.map(sortValue);
-  }
-
-  if (isPlainObject(value)) {
-    const sorted = {};
-    for (const key of Object.keys(value).sort()) {
-      const next = value[key];
-      if (next === undefined) {
-        continue;
-      }
-      sorted[key] = sortValue(next);
-    }
-    return sorted;
-  }
-
-  return value;
-}
-
-function toCanonicalJson(value) {
-  return JSON.stringify(sortValue(value));
-}
-
-function toSha256Hex(value) {
-  const source = String(value || "");
-  return crypto.createHash("sha256").update(source).digest("hex");
-}
-
-function toHmacSha256Hex(secret, value) {
-  const normalizedSecret = String(secret || "").trim();
-  if (!normalizedSecret) {
-    throw new Error("HMAC secret is required.");
-  }
-
-  return crypto
-    .createHmac("sha256", normalizedSecret)
-    .update(String(value || ""))
-    .digest("hex");
-}
-
-function safeParseJson(value, fallback = null) {
-  if (value == null) {
-    return fallback;
-  }
-
-  if (typeof value === "object") {
-    return value;
-  }
-
-  const text = String(value || "").trim();
-  if (!text) {
-    return fallback;
-  }
-
-  try {
-    return JSON.parse(text);
-  } catch {
-    return fallback;
-  }
-}
-
-const __testables = {
-  isPlainObject,
-  sortValue
-};
-
-export { toCanonicalJson, toSha256Hex, toHmacSha256Hex, safeParseJson, __testables };