@native-marketing/sdk 0.3.6 → 0.3.7

package/dist/http.js

@@ -66,31 +66,6 @@ function guardHttpMethods(client, validate) {
   });
 }
 
-// packages/api-client/src/client.ts
-function createContentFactoryClient(options = {}) {
-  const baseUrl = options.baseUrl ?? "/api/v1";
-  const policy = httpRequestPolicy(
-    baseUrl,
-    options.fetch ?? ((request) => globalThis.fetch(request))
-  );
-  const client = createClient({
-    baseUrl,
-    credentials: "include",
-    redirect: "error",
-    fetch: policy.fetch
-  });
-  client.use({
-    onRequest({ request }) {
-      if (!["POST", "DELETE"].includes(request.method) || request.body !== null) return request;
-      const headers = new Headers(request.headers);
-      headers.set("content-type", "application/json");
-      headers.delete("content-length");
-      return new Request(request, { headers, body: "{}" });
-    }
-  });
-  return guardHttpMethods(client, policy.validateInit);
-}
-
 // packages/contracts/src/business-code.ts
 import { z } from "zod";
 var businessCodeKindSchema = z.enum([
@@ -686,6 +661,175 @@ function readingDocument(content) {
   return { body, title };
 }
 
+// packages/contracts/src/client-lifecycle.ts
+import { z as z5 } from "zod";
+
+// packages/contracts/src/generated/client-release.ts
+var nativeClientRelease = {
+  schemaVersion: 1,
+  product: "native-marketing",
+  version: "0.3.7",
+  packages: {
+    sdk: "@native-marketing/sdk",
+    cli: "@native-marketing/cli"
+  },
+  contractVersion: 1,
+  minimumClientVersion: "0.3.6",
+  apiMajor: 1,
+  nodeMajor: 24,
+  changes: [
+    "Unified SDK, CLI and MCP release discovery and compatibility checks.",
+    "Configurable CLI update notifications, pins and compatible automatic updates.",
+    "Upgrade verification and explicit continuation without replaying business commands."
+  ]
+};
+
+// packages/contracts/src/client-lifecycle.ts
+var releaseVersionSchema = z5.string().max(128).regex(
+  /^(0|[1-9]\d*)\.(0|[1-9]\d*)\.(0|[1-9]\d*)(?:-((?:0|[1-9]\d*|\d*[A-Za-z-][0-9A-Za-z-]*)(?:\.(?:0|[1-9]\d*|\d*[A-Za-z-][0-9A-Za-z-]*))*))?(?:\+[0-9A-Za-z-]+(?:\.[0-9A-Za-z-]+)*)?$/
+);
+var clientIdentitySchema = z5.object({
+  version: releaseVersionSchema,
+  contractVersion: z5.number().int().positive(),
+  apiMajor: z5.number().int().positive()
+});
+var clientReleaseSchema = z5.object({
+  schemaVersion: z5.literal(1),
+  product: z5.literal("native-marketing"),
+  version: releaseVersionSchema,
+  packages: z5.object({
+    sdk: z5.literal("@native-marketing/sdk"),
+    cli: z5.literal("@native-marketing/cli")
+  }),
+  contractVersion: z5.number().int().positive(),
+  minimumClientVersion: releaseVersionSchema,
+  apiMajor: z5.number().int().positive(),
+  nodeMajor: z5.number().int().positive(),
+  changes: z5.array(z5.string().min(1).max(240)).max(8).default([])
+});
+var updatePolicySchema = z5.object({
+  mode: z5.enum(["off", "notify", "auto"]).default("notify"),
+  channel: z5.enum(["latest", "next", "beta"]).default("latest"),
+  pin: releaseVersionSchema.nullable().default(null),
+  intervalHours: z5.number().int().min(1).max(168).default(24)
+}).strict();
+var defaultUpdatePolicy = updatePolicySchema.parse({});
+function compareReleaseVersions(left, right) {
+  const parse = (raw) => releaseVersionSchema.parse(raw).split("+")[0].split(/-(.*)/s);
+  const a = parse(left), b = parse(right);
+  const numbers = (x, y) => BigInt(x) < BigInt(y) ? -1 : BigInt(x) > BigInt(y) ? 1 : 0;
+  const ac = a[0].split("."), bc = b[0].split(".");
+  for (let i = 0; i < 3; i++) {
+    const order = numbers(ac[i], bc[i]);
+    if (order) return order;
+  }
+  if (a[1] === b[1]) return 0;
+  if (!a[1] || !b[1]) return a[1] ? -1 : 1;
+  const ap = a[1].split("."), bp = b[1].split(".");
+  for (let i = 0; i < Math.max(ap.length, bp.length); i++) {
+    const x = ap[i], y = bp[i];
+    if (x === void 0 || y === void 0) return x === void 0 ? -1 : 1;
+    if (x === y) continue;
+    const xn = /^\d+$/.test(x), yn = /^\d+$/.test(y);
+    return xn && yn ? numbers(x, y) : xn !== yn ? xn ? -1 : 1 : x < y ? -1 : 1;
+  }
+  return 0;
+}
+function assessNativeCompatibility(client, server) {
+  client = clientIdentitySchema.parse(client);
+  const result = (status, reason) => ({ status, reason, client, server: server ?? null });
+  if (!server) return result("UNKNOWN", "SERVER_METADATA_UNAVAILABLE");
+  server = clientReleaseSchema.parse(server);
+  if (client.contractVersion !== server.contractVersion)
+    return result("INCOMPATIBLE", "CONTRACT_MISMATCH");
+  if (client.apiMajor !== server.apiMajor) return result("INCOMPATIBLE", "API_MISMATCH");
+  if (compareReleaseVersions(client.version, server.minimumClientVersion) < 0)
+    return result("INCOMPATIBLE", "CLIENT_TOO_OLD");
+  return compareReleaseVersions(client.version, server.version) < 0 ? result("UPGRADE_RECOMMENDED", "NEWER_CLIENT_AVAILABLE") : result("COMPATIBLE", "CURRENT");
+}
+
+// packages/contracts/src/client-update-policy.ts
+import { z as z6 } from "zod";
+var registryReleaseSchema = z6.object({
+  name: z6.enum(["@native-marketing/sdk", "@native-marketing/cli"]),
+  version: releaseVersionSchema,
+  deprecated: z6.string().optional(),
+  nativeMarketing: z6.object({
+    contractVersion: z6.number().int().positive(),
+    apiMajor: z6.number().int().positive(),
+    nodeMajor: z6.number().int().positive(),
+    changes: z6.array(z6.string().min(1).max(240)).max(8).optional()
+  }).optional(),
+  dist: z6.object({
+    integrity: z6.string().max(512).regex(/^sha512-[A-Za-z0-9+/]{86}==$/)
+  })
+});
+var clientUpdateStateSchema = z6.object({
+  schemaVersion: z6.literal(1),
+  policy: updatePolicySchema,
+  lastCheck: z6.object({
+    at: z6.number().int().nonnegative(),
+    selector: z6.string().max(160),
+    target: registryReleaseSchema
+  }).strict().optional(),
+  lastAttempt: z6.object({ at: z6.number().int().nonnegative(), selector: z6.string().max(160) }).strict().optional()
+}).strict();
+function planNativeUpdate(input) {
+  const target = registryReleaseSchema.parse(input.target);
+  const current = releaseVersionSchema.parse(input.currentVersion ?? nativeClientRelease.version);
+  const policy = updatePolicySchema.parse(input.policy ?? {});
+  const spec = `${target.name}@${target.version}`;
+  const cli = target.name === nativeClientRelease.packages.cli;
+  const result = (status, reason, eligible = false) => ({
+    package: target.name,
+    currentVersion: current,
+    targetVersion: target.version,
+    status,
+    reason,
+    eligibleForAutoUpdate: eligible,
+    policy,
+    commands: {
+      npm: [
+        "npm",
+        "install",
+        ...cli ? ["--global"] : ["--save-exact"],
+        spec,
+        "--ignore-scripts",
+        "--registry=https://registry.npmjs.org/",
+        "--@native-marketing:registry=https://registry.npmjs.org/"
+      ],
+      pnpm: ["pnpm", "add", ...cli ? ["--global"] : ["--save-exact"], spec, "--ignore-scripts"],
+      yarn: cli ? null : ["yarn", "add", "--exact", spec]
+    }
+  });
+  if (policy.pin && policy.pin !== target.version) return result("BLOCKED", "PIN_MISMATCH");
+  if (!policy.pin && policy.channel === "latest" && target.version.split("+")[0].includes("-"))
+    return result("BLOCKED", "CHANNEL_MISMATCH");
+  const order = compareReleaseVersions(target.version, current);
+  if (order < 0) return result("BLOCKED", "DOWNGRADE_FORBIDDEN");
+  if (target.deprecated !== void 0) return result("BLOCKED", "DEPRECATED");
+  if (!target.nativeMarketing) return result("BLOCKED", "METADATA_UNAVAILABLE");
+  const metadata = target.nativeMarketing;
+  if (metadata.nodeMajor !== (input.nodeMajor ?? nativeClientRelease.nodeMajor))
+    return result("BLOCKED", "NODE_MISMATCH");
+  if (metadata.contractVersion !== nativeClientRelease.contractVersion || metadata.apiMajor !== nativeClientRelease.apiMajor)
+    return result("BLOCKED", "CONTRACT_MISMATCH");
+  if (input.server && assessNativeCompatibility(
+    {
+      version: target.version,
+      contractVersion: metadata.contractVersion,
+      apiMajor: metadata.apiMajor
+    },
+    input.server
+  ).status === "INCOMPATIBLE")
+    return result("BLOCKED", "SERVER_INCOMPATIBLE");
+  if (order === 0) return result("CURRENT", "CURRENT");
+  const from = current.split(/[.+-]/), to = target.version.split(/[.+-]/);
+  const compatibleLine = from[0] === to[0] && (from[0] !== "0" || from[1] === to[1]);
+  const stable = !current.split("+")[0].includes("-") && !target.version.split("+")[0].includes("-");
+  return compatibleLine && stable ? result("UPDATE_AVAILABLE", "COMPATIBLE_UPDATE", true) : result("UPDATE_AVAILABLE", "REVIEW_REQUIRED");
+}
+
 // packages/api-client/src/errors.ts
 var ApiClientError = class extends Error {
   constructor(status, code, message, requestId) {
@@ -710,6 +854,102 @@ function requireApiData(result) {
   );
 }
 
+// packages/api-client/src/client-version.ts
+function getNativeClientVersion() {
+  return clientReleaseSchema.parse(nativeClientRelease);
+}
+async function checkNativeHttpVersion(options = {}) {
+  const base = options.baseUrl ?? "/api/v1";
+  const policy = httpRequestPolicy(base, options.fetch ?? ((request) => fetch(request)));
+  const timeout = options.timeoutMs ?? 5e3;
+  if (!Number.isInteger(timeout) || timeout < 100 || timeout > 12e4)
+    throw new TypeError("Timeout must be 100\u2013120000 milliseconds.");
+  const endpoint = new URL(
+    `${base.replace(/\/+$/, "")}/client-release`,
+    globalThis.location?.origin
+  );
+  let server;
+  try {
+    const response = await policy.fetch(
+      new Request(endpoint, {
+        credentials: "omit",
+        redirect: "error",
+        signal: AbortSignal.timeout(timeout)
+      })
+    );
+    if (response.status !== 404) {
+      if (!response.ok || !response.body) throw new Error();
+      const reader = response.body.getReader();
+      const decoder = new TextDecoder("utf-8", { fatal: true });
+      let size = 0, raw = "";
+      try {
+        for (; ; ) {
+          const { value, done } = await reader.read();
+          if (done) break;
+          size += value.byteLength;
+          if (size > 32 * 1024) throw new Error();
+          raw += decoder.decode(value, { stream: true });
+        }
+        raw += decoder.decode();
+      } finally {
+        await reader.cancel().catch(() => void 0);
+        reader.releaseLock();
+      }
+      server = clientReleaseSchema.parse(JSON.parse(raw));
+    }
+  } catch {
+    throw new ApiClientError(
+      0,
+      "VERSION_CHECK_UNAVAILABLE",
+      "Cannot verify the configured service release."
+    );
+  }
+  const compatibility = assessNativeCompatibility(nativeClientRelease, server);
+  if (compatibility.status === "INCOMPATIBLE" || options.requireCompatibility && compatibility.status === "UNKNOWN")
+    throw new ApiClientError(
+      0,
+      "CLIENT_INCOMPATIBLE",
+      "The client cannot confirm compatibility with this service."
+    );
+  return { client: getNativeClientVersion(), compatibility };
+}
+
+// packages/api-client/src/client.ts
+function createContentFactoryClient(options = {}) {
+  const baseUrl = options.baseUrl ?? "/api/v1";
+  const policy = httpRequestPolicy(
+    baseUrl,
+    options.fetch ?? ((request) => globalThis.fetch(request))
+  );
+  let versionCheck;
+  const client = createClient({
+    baseUrl,
+    credentials: "include",
+    redirect: "error",
+    fetch: async (request) => {
+      if (options.compatibility) {
+        versionCheck ??= checkNativeHttpVersion({
+          baseUrl,
+          ...options.fetch ? { fetch: options.fetch } : {},
+          requireCompatibility: options.compatibility === "require"
+        });
+        await versionCheck;
+      }
+      return policy.fetch(request);
+    }
+  });
+  client.use({
+    onRequest({ request }) {
+      if (!["POST", "DELETE"].includes(request.method) || request.body !== null) return request;
+      const headers = new Headers(request.headers);
+      headers.set("content-type", "application/json");
+      headers.delete("content-length");
+      return new Request(request, { headers, body: "{}" });
+    }
+  });
+  return guardHttpMethods(client, policy.validateInit);
+}
+
 // packages/api-client/src/personal-survey.ts
 var personalSurveyInputLimits = {
   professionalIdentity: 2e3,
@@ -1320,9 +1560,13 @@ function suggestProjectKey(name) {
 }
 export {
   ApiClientError,
+  assessNativeCompatibility,
+  checkNativeHttpVersion,
   contentProgramInputLimits,
   createContentFactoryClient,
+  defaultUpdatePolicy,
   distributionDestinationInputLimits,
+  getNativeClientVersion,
   humanActionInputLimits,
   matchesHumanRequirementMedia,
   mediaInputLimits,
@@ -1330,6 +1574,7 @@ export {
   personalIpDefinitionInputLimits,
   personalSurveyInputLimits,
   personalSurveyToResponses,
+  planNativeUpdate,
   programActivationRequirements,
   programGoalMetricDefinitions,
   publicationInputLimits,