@siglume/api-sdk 0.10.7 → 0.10.8

package/dist/cli/index.cjs

@@ -1248,6 +1248,56 @@ var init_operations = __esm({
 });
 
 // src/client.ts
+function validateManifestPersistenceContract(payload) {
+  const vertical = String(payload.store_vertical ?? "").trim().toLowerCase();
+  const persistence = payload.persistence;
+  if (persistence === void 0 || persistence === null) {
+    return;
+  }
+  if (!isRecord(persistence)) {
+    throw new SiglumeClientError("AppManifest.persistence must be an object.");
+  }
+  const mode = String(persistence.mode ?? (vertical === "game" ? "platform" : "none")).trim().toLowerCase();
+  if (!["none", "local", "platform", "developer_server"].includes(mode)) {
+    throw new SiglumeClientError(
+      "AppManifest.persistence.mode must be one of: none, local, platform, developer_server."
+    );
+  }
+  const schema = persistence.save_data_schema;
+  if (vertical === "game" && mode !== "none" && schema === void 0) {
+    throw new SiglumeClientError(
+      "AppManifest.persistence.save_data_schema is required when store_vertical='game' and persistence.mode is not 'none'."
+    );
+  }
+  if (schema !== void 0) {
+    validateSaveDataSchema(schema, "AppManifest.persistence.save_data_schema");
+  }
+}
+function validateSaveDataSchema(schema, fieldName) {
+  if (!isRecord(schema)) {
+    throw new SiglumeClientError(`${fieldName} must be a JSON Schema object.`);
+  }
+  const schemaSize = new TextEncoder().encode(JSON.stringify(schema)).length;
+  if (schemaSize > 8192) {
+    throw new SiglumeClientError(`${fieldName} must be at most 8192 bytes.`);
+  }
+  if (schema.type !== "object") {
+    throw new SiglumeClientError(`${fieldName}.type must be 'object'.`);
+  }
+  const properties = schema.properties;
+  if (!isRecord(properties) || Object.keys(properties).length === 0) {
+    throw new SiglumeClientError(`${fieldName}.properties must be a non-empty object.`);
+  }
+  if (schema.required !== void 0) {
+    if (!Array.isArray(schema.required) || !schema.required.every((item) => typeof item === "string")) {
+      throw new SiglumeClientError(`${fieldName}.required must be an array of strings when provided.`);
+    }
+    const missing = schema.required.filter((item) => !(item in properties));
+    if (missing.length > 0) {
+      throw new SiglumeClientError(`${fieldName}.required references undefined properties: ${missing.join(", ")}.`);
+    }
+  }
+}
 function buildToolManualQualityReport(payload) {
   const qualityBlock = isRecord(payload.quality) ? payload.quality : payload;
   const issues = [];
@@ -1322,6 +1372,8 @@ function buildUrl(baseUrl, path, params) {
   return url.toString();
 }
 function parseListing(data) {
+  const metadata = isRecord(data.metadata) ? data.metadata : {};
+  const persistence = isRecord(data.persistence) ? data.persistence : isRecord(metadata.persistence) ? metadata.persistence : {};
   return {
     listing_id: String(data.listing_id ?? data.id ?? ""),
     capability_key: String(data.capability_key ?? ""),
@@ -1344,14 +1396,59 @@ function parseListing(data) {
     seller_display_name: stringOrNull(data.seller_display_name),
     seller_homepage_url: stringOrNull(data.seller_homepage_url),
     seller_social_url: stringOrNull(data.seller_social_url),
+    publisher_type: stringOrNull(data.publisher_type),
+    publisher_company_id: stringOrNull(data.publisher_company_id),
+    company_id: stringOrNull(data.company_id),
+    company_name: stringOrNull(data.company_name),
+    company_publish_status: stringOrNull(data.company_publish_status),
+    company_terms_version: stringOrNull(data.company_terms_version),
     review_status: stringOrNull(data.review_status),
     review_note: stringOrNull(data.review_note),
     submission_blockers: Array.isArray(data.submission_blockers) ? data.submission_blockers.filter((item) => typeof item === "string") : [],
+    persistence: { ...persistence },
     created_at: stringOrNull(data.created_at),
     updated_at: stringOrNull(data.updated_at),
     raw: { ...data }
   };
 }
+function parseCompanyPublisher(data) {
+  const wallets = Array.isArray(data.settlement_wallets) ? data.settlement_wallets.filter((item) => isRecord(item)) : [];
+  return {
+    company_id: String(data.company_id ?? data.id ?? ""),
+    name: String(data.name ?? ""),
+    status: String(data.status ?? ""),
+    description: stringOrNull(data.description),
+    is_founder: Boolean(data.is_founder ?? false),
+    membership_role: stringOrNull(data.membership_role),
+    membership_status: stringOrNull(data.membership_status),
+    can_publish: Boolean(data.can_publish ?? true),
+    can_approve: Boolean(data.can_approve ?? false),
+    approval_required: Boolean(data.approval_required ?? false),
+    paid_listing_allowed: Boolean(data.paid_listing_allowed ?? false),
+    disabled_reasons: Array.isArray(data.disabled_reasons) ? data.disabled_reasons.filter((item) => typeof item === "string") : [],
+    company_terms_version: stringOrNull(data.company_terms_version),
+    active_listing_count: Number(data.active_listing_count ?? 0),
+    pending_approval_count: Number(data.pending_approval_count ?? 0),
+    settlement_wallet_ready: Boolean(data.settlement_wallet_ready ?? false),
+    settlement_wallets: wallets.map((item) => ({ ...item })),
+    raw: { ...data }
+  };
+}
+function parseCapabilitySaveState(data) {
+  return {
+    capability_key: String(data.capability_key ?? ""),
+    save_key: String(data.save_key ?? ""),
+    schema_version: String(data.schema_version ?? "1"),
+    revision: Number(data.revision ?? 0),
+    payload: toRecord(data.payload),
+    metadata: toRecord(data.metadata),
+    checksum: stringOrNull(data.checksum),
+    updated_at: stringOrNull(data.updated_at),
+    created_at: stringOrNull(data.created_at),
+    exists: Boolean(data.exists ?? false),
+    raw: { ...data }
+  };
+}
 function parseBundleMember(data) {
   return {
     capability_listing_id: String(data.capability_listing_id ?? ""),
@@ -2531,6 +2628,9 @@ var init_client = __esm({
           "support_contact",
           "seller_homepage_url",
           "seller_social_url",
+          "publisher_type",
+          "company_id",
+          "publisher_company_id",
           "store_vertical",
           "jurisdiction",
           "price_model",
@@ -2543,7 +2643,8 @@ var init_client = __esm({
           "dry_run_supported",
           "required_connected_accounts",
           "permission_scopes",
-          "compatibility_tags"
+          "compatibility_tags",
+          "persistence"
         ]) {
           const value = manifestPayload[fieldName];
           if (value !== void 0 && value !== null) {
@@ -2583,6 +2684,26 @@ var init_client = __esm({
             );
           }
         }
+        const explicitPublisherType = payload.publisher_type !== void 0 && payload.publisher_type !== null;
+        const companyId = String(payload.company_id ?? "").trim() || String(payload.publisher_company_id ?? "").trim();
+        const publisherType = String(payload.publisher_type ?? "user").trim().toLowerCase();
+        if (publisherType !== "user" && publisherType !== "company") {
+          throw new SiglumeClientError("AppManifest.publisher_type must be 'user' or 'company'.");
+        }
+        if (publisherType === "company" && !companyId) {
+          throw new SiglumeClientError("AppManifest.company_id is required when publisher_type='company'.");
+        }
+        if (publisherType === "user" && companyId) {
+          throw new SiglumeClientError("AppManifest.company_id cannot be combined with publisher_type='user'.");
+        }
+        if (explicitPublisherType || companyId) {
+          payload.publisher_type = publisherType;
+        }
+        if (companyId) {
+          payload.company_id = companyId;
+          payload.publisher_company_id = companyId;
+        }
+        validateManifestPersistenceContract(payload);
         if (payload.manifest && typeof payload.manifest === "object") {
           delete payload.manifest.version;
         }
@@ -2690,6 +2811,45 @@ var init_client = __esm({
         const [data] = await this.request("GET", `/market/capabilities/${listing_id}`);
         return parseListing(data);
       }
+      async list_company_publishers() {
+        const [data] = await this.request("GET", "/market/company-publishers");
+        return Array.isArray(data.items) ? data.items.filter((item) => isRecord(item)).map(parseCompanyPublisher) : [];
+      }
+      async request_company_publish_approval(listing_id, note) {
+        const [data] = await this.request("POST", `/market/capabilities/${listing_id}/company-publish-approval`, {
+          json_body: note ? { note } : {}
+        });
+        return parseListing(data);
+      }
+      async decide_company_publish_approval(listing_id, options) {
+        const [data] = await this.request("POST", `/market/capabilities/${listing_id}/company-publish-approval/decision`, {
+          json_body: {
+            decision: options.decision,
+            ...options.reason ? { reason: options.reason } : {}
+          }
+        });
+        return parseListing(data);
+      }
+      async get_capability_state(capability_key, save_key = "default") {
+        const [data] = await this.request("GET", `/market/capability-state/${capability_key}/${save_key}`);
+        return parseCapabilitySaveState(data);
+      }
+      async put_capability_state(capability_key, save_key = "default", payload = {}, options = {}) {
+        const body = {
+          payload: toRecord(payload),
+          schema_version: options.schema_version ?? "1",
+          metadata: toRecord(options.metadata)
+        };
+        if (options.expected_revision !== void 0 && options.expected_revision !== null) {
+          body.expected_revision = Math.trunc(options.expected_revision);
+        }
+        const [data] = await this.request("PUT", `/market/capability-state/${capability_key}/${save_key}`, { json_body: body });
+        return parseCapabilitySaveState(data);
+      }
+      async delete_capability_state(capability_key, save_key = "default") {
+        const [data] = await this.request("DELETE", `/market/capability-state/${capability_key}/${save_key}`);
+        return parseCapabilitySaveState(data);
+      }
       // ----- Capability bundles (v0.7 track 2) ---------------------------------
       async list_bundles(options = {}) {
         const params = {
@@ -7289,7 +7449,12 @@ function ensureManifestPublisherIdentity(project) {
   const sellerHomepageUrl = String(manifestPayload.seller_homepage_url ?? "").trim();
   const sellerSocialUrl = String(manifestPayload.seller_social_url ?? "").trim();
   const jurisdiction = String(manifestPayload.jurisdiction ?? "").trim();
+  const companyId = String(manifestPayload.company_id ?? "").trim() || String(manifestPayload.publisher_company_id ?? "").trim();
+  const publisherType = String(manifestPayload.publisher_type ?? "user").trim().toLowerCase();
   const issues = [];
+  if (companyId && publisherType !== "company") {
+    issues.push('manifest.company_id requires manifest.publisher_type to be "company"');
+  }
   if (!docsUrl) {
     issues.push("manifest.docs_url is required");
   } else if (looksLikePlaceholder(docsUrl)) {
@@ -7435,25 +7600,110 @@ ${errors.map((error) => `- ${error}`).join("\n")}`
   }
   return preflight;
 }
+function companyNameSlug(value) {
+  return value.normalize("NFKD").toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "");
+}
 async function runRegistration(path = ".", options = {}, deps = {}) {
   const project = await loadProject(path);
+  let requestedCompanyId = String(options.company_id ?? "").trim();
+  const requestedCompanySlug = String(options.company_slug ?? "").trim();
+  let companyPublisherCandidates = null;
+  if (requestedCompanySlug) {
+    if (requestedCompanyId) {
+      throw new SiglumeProjectError("--company and --company-slug cannot be combined.");
+    }
+    const slug = companyNameSlug(requestedCompanySlug);
+    if (!slug && requestedCompanySlug !== requestedCompanyId) {
+      throw new SiglumeProjectError(`Company slug ${requestedCompanySlug} is not slug-compatible; use --company <company_id> instead.`);
+    }
+  }
+  if (requestedCompanyId) {
+    project.manifest = {
+      ...project.manifest,
+      publisher_type: "company",
+      company_id: requestedCompanyId,
+      publisher_company_id: requestedCompanyId
+    };
+  }
   ensureExplicitToolManual(project);
   ensureManifestPublisherIdentity(project);
   ensureRuntimeValidationReady(project);
   ensureRequiredOauthCredentials(project);
   const canonicalOauthCredentials = canonicalOauthCredentialsPayload(project.oauth_credentials);
   const client = await createClient(deps);
+  if (requestedCompanySlug) {
+    const slug = companyNameSlug(requestedCompanySlug);
+    companyPublisherCandidates = await client.list_company_publishers();
+    const matches = companyPublisherCandidates.filter(
+      (item) => companyNameSlug(item.name || item.company_id) === slug || item.company_id === requestedCompanySlug
+    );
+    if (matches.length === 0) {
+      throw new SiglumeProjectError(`Company slug ${requestedCompanySlug} is not available to this API key.`);
+    }
+    if (matches.length > 1) {
+      throw new SiglumeProjectError(`Company slug ${requestedCompanySlug} is ambiguous; use --company <company_id> instead.`);
+    }
+    const match = matches[0];
+    if (!match) {
+      throw new SiglumeProjectError(`Company slug ${requestedCompanySlug} is not available to this API key.`);
+    }
+    if (match.can_publish === false) {
+      const disabledReasons = match.disabled_reasons ?? [];
+      const reasons = disabledReasons.length > 0 ? disabledReasons.join(", ") : "company publisher is disabled";
+      throw new SiglumeProjectError(`Company ${match.company_id} cannot publish: ${reasons}.`);
+    }
+    requestedCompanyId = match.company_id;
+    project.manifest = {
+      ...project.manifest,
+      publisher_type: "company",
+      company_id: requestedCompanyId,
+      publisher_company_id: requestedCompanyId
+    };
+  }
   const preflight = await registrationPreflight(project, client);
+  let companyPublisherPreflight = null;
+  const companyId = String(project.manifest.company_id ?? "").trim() || String(project.manifest.publisher_company_id ?? "").trim();
+  const publisherType = String(project.manifest.publisher_type ?? "user").toLowerCase();
+  if (publisherType === "company") {
+    if (!companyId) {
+      throw new SiglumeProjectError("Company registration requires --company <company_id> or manifest.company_id.");
+    }
+    const companies = companyPublisherCandidates ?? await client.list_company_publishers();
+    companyPublisherCandidates = companies;
+    const company = companies.find((item) => item.company_id === companyId);
+    if (!company) {
+      throw new SiglumeProjectError(`Company ${companyId} is not available to this API key.`);
+    }
+    if (company.can_publish === false) {
+      const disabledReasons = company.disabled_reasons ?? [];
+      const reasons = disabledReasons.length > 0 ? disabledReasons.join(", ") : "company publisher is disabled";
+      throw new SiglumeProjectError(`Company ${companyId} cannot publish: ${reasons}.`);
+    }
+    companyPublisherPreflight = company;
+  }
   let developerPortalPreflight = null;
   if (String(project.manifest.price_model ?? "free").toLowerCase() !== "free") {
-    const portal = await client.get_developer_portal();
-    const verifiedDestination = portal.payout_readiness?.verified_destination;
-    if (verifiedDestination !== true) {
-      throw new SiglumeProjectError(
-        "Paid API registration requires a verified Polygon payout destination. Open https://siglume.com/owner/credits/payout and confirm the embedded-wallet payout token, or call GET /v1/market/developer/portal until payout_readiness.verified_destination is true."
-      );
+    if (publisherType === "company") {
+      const company = companyPublisherPreflight;
+      if (!company) {
+        throw new SiglumeProjectError(`Company ${companyId} is not available to this API key.`);
+      }
+      if (company.settlement_wallet_ready !== true) {
+        throw new SiglumeProjectError(
+          `Paid company registration requires a verified company settlement wallet for ${company.name}. Open the company settings and complete settlement readiness before registering.`
+        );
+      }
+      developerPortalPreflight = { company_publisher: toJsonable(company) };
+    } else {
+      const portal = await client.get_developer_portal();
+      const verifiedDestination = portal.payout_readiness?.verified_destination;
+      if (verifiedDestination !== true) {
+        throw new SiglumeProjectError(
+          "Paid API registration requires a verified Polygon payout destination. Open https://siglume.com/owner/credits/payout and confirm the embedded-wallet payout token, or call GET /v1/market/developer/portal until payout_readiness.verified_destination is true."
+        );
+      }
+      developerPortalPreflight = toJsonable(portal);
     }
-    developerPortalPreflight = toJsonable(portal);
   }
   const receipt = await client.auto_register(project.manifest, project.tool_manual, {
     runtime_validation: project.runtime_validation,
@@ -7526,6 +7776,14 @@ async function getUsageReport(options, deps = {}) {
     count: items.length
   };
 }
+async function listCompanyPublishersReport(deps = {}) {
+  const client = await createClient(deps);
+  const companies = await client.list_company_publishers();
+  return {
+    companies: companies.map((item) => toJsonable(item)),
+    count: companies.length
+  };
+}
 async function diffJsonFiles(oldPath, newPath) {
   const oldPayload = await loadJsonDocument(oldPath);
   const newPayload = await loadJsonDocument(newPath);
@@ -8612,6 +8870,24 @@ function renderOperationTable(operations) {
     ...rows.map((row) => row.map((cell, index) => cell.padEnd(widths[index] ?? cell.length)).join("  "))
   ];
 }
+function renderCompanyTable(companies) {
+  const rows = companies.map((item) => [
+    String(item.company_id ?? item.id ?? ""),
+    String(item.name ?? ""),
+    String(item.membership_role ?? (item.is_founder ? "founder" : "")),
+    String(item.settlement_wallet_ready === true ? "ready" : "not_ready"),
+    String(item.pending_approval_count ?? 0)
+  ]);
+  const headers = ["company_id", "name", "role", "settlement", "pending"];
+  const widths = headers.map(
+    (header, index) => Math.max(header.length, ...rows.map((row) => row[index]?.length ?? 0))
+  );
+  return [
+    headers.map((header, index) => header.padEnd(widths[index] ?? header.length)).join("  "),
+    widths.map((width) => "-".repeat(width)).join("  "),
+    ...rows.map((row) => row.map((cell, index) => cell.padEnd(widths[index] ?? cell.length)).join("  "))
+  ];
+}
 async function runCli(argv, deps = {}) {
   const stdout = deps.stdout;
   const stderr = deps.stderr ?? console.error;
@@ -8768,7 +9044,21 @@ async function runCli(argv, deps = {}) {
     if (report.runtime_validation_path) emit(stdout, `runtime_validation_path: ${String(report.runtime_validation_path)}`);
     if (report.oauth_credentials_path) emit(stdout, `oauth_credentials_path: ${String(report.oauth_credentials_path)}`);
   });
-  program.command("register").option("--confirm", "explicitly confirm the registration; this is the default unless --draft-only is set", false).option("--draft-only", "create or refresh the draft without confirming publication", false).option("--submit-review", "legacy alias: publish immediately if your environment still routes through submit-review", false).option("--json", "emit machine-readable JSON", false).argument("[path]", ".", "project path").action(async (path, options) => {
+  program.command("companies").description("List Siglume companies available for company-name publishing.").option("--json", "emit machine-readable JSON", false).action(async (options) => {
+    const report = await listCompanyPublishersReport(deps);
+    if (options.json) {
+      emit(stdout, renderJson(report));
+      return;
+    }
+    const companies = Array.isArray(report.companies) ? report.companies.filter((item) => Boolean(item && typeof item === "object")) : [];
+    if (companies.length === 0) {
+      emit(stdout, "No company publishers available for this API key.");
+      return;
+    }
+    emit(stdout, "Company publishers");
+    renderCompanyTable(companies).forEach((line) => emit(stdout, line));
+  });
+  program.command("register").option("--confirm", "explicitly confirm the registration; this is the default unless --draft-only is set", false).option("--draft-only", "create or refresh the draft without confirming publication", false).option("--submit-review", "legacy alias: publish immediately if your environment still routes through submit-review", false).option("--company <companyId>", "publish under a Siglume company name; revenue is split equally among active members", "").option("--company-slug <slug>", "publish under a Siglume company by matching the slugified company name", "").option("--json", "emit machine-readable JSON", false).argument("[path]", ".", "project path").action(async (path, options) => {
     const draftOnly = Boolean(options.draftOnly);
     if (draftOnly && options.confirm) {
       throw new SiglumeProjectError("--draft-only cannot be combined with --confirm.");
@@ -8777,7 +9067,13 @@ async function runCli(argv, deps = {}) {
       throw new SiglumeProjectError("--draft-only cannot be combined with --submit-review.");
     }
     const shouldConfirm = Boolean(options.confirm) || !draftOnly && !options.submitReview;
-    const report = await runRegistration(path, { confirm: shouldConfirm, draft_only: draftOnly, submit_review: options.submitReview }, deps);
+    const report = await runRegistration(path, {
+      confirm: shouldConfirm,
+      draft_only: draftOnly,
+      submit_review: options.submitReview,
+      company_id: options.company,
+      company_slug: options.companySlug
+    }, deps);
     if (options.json) {
       emit(stdout, renderJson(report));
     } else {