@hashgraphonline/standards-sdk 0.1.175 → 0.1.176

package/dist/browser-root/standards-sdk.root-browser.js

@@ -7247,24 +7247,120 @@ const skillPublisherMetadataSchema = objectType({
 }).passthrough();
 const skillTrustTierSchema = enumType([
   "unpublished",
+  "unclaimed",
+  "validated",
   "published",
   "verified",
   "hardened"
 ]);
+const skillStatusDefaultVerificationSignals = {
+  publisherBound: false,
+  domainProof: false,
+  verifiedDomain: false,
+  previewValidated: false
+};
+const skillStatusDefaultProvenanceSignals = {
+  repoCommitIntegrity: false,
+  manifestIntegrity: false,
+  canonicalRelease: false,
+  previewAvailable: false,
+  previewAuthoritative: false
+};
 const skillStatusChecksSchema = objectType({
   repoCommitIntegrity: booleanType(),
   manifestIntegrity: booleanType(),
   domainProof: booleanType()
 }).passthrough();
 const skillStatusNextStepSchema = objectType({
+  kind: enumType([
+    "setup_validate",
+    "publish_first_release",
+    "verify_domain",
+    "harden_workflow",
+    "share_status"
+  ]).optional(),
+  priority: numberType().int().optional(),
   id: stringType(),
   label: stringType(),
   description: stringType(),
+  url: stringType().nullable().optional(),
   href: stringType().nullable().optional(),
   command: stringType().nullable().optional()
 }).passthrough();
+const skillPreviewSuggestedNextStepSchema = objectType({
+  id: stringType(),
+  label: stringType(),
+  description: stringType(),
+  command: stringType().optional(),
+  href: stringType().optional()
+}).passthrough();
+const skillPreviewReportSchema = objectType({
+  schema_version: literalType("skill-preview.v1"),
+  tool_version: stringType(),
+  preview_id: stringType(),
+  repo_url: stringType(),
+  repo_owner: stringType(),
+  repo_name: stringType(),
+  default_branch: stringType(),
+  commit_sha: stringType(),
+  ref: stringType(),
+  event_name: stringType(),
+  workflow_run_url: stringType(),
+  skill_dir: stringType(),
+  name: stringType(),
+  version: stringType(),
+  validation_status: literalType("passed"),
+  findings: arrayType(unknownType()),
+  package_summary: recordType(stringType(), unknownType()),
+  suggested_next_steps: arrayType(skillPreviewSuggestedNextStepSchema),
+  generated_at: stringType()
+}).passthrough();
+const skillPreviewRecordSchema = objectType({
+  id: stringType(),
+  previewId: stringType(),
+  source: literalType("github-oidc"),
+  report: skillPreviewReportSchema,
+  generatedAt: stringType(),
+  expiresAt: stringType(),
+  statusUrl: stringType(),
+  authoritative: booleanType()
+}).passthrough();
+const skillPreviewLookupResponseSchema = objectType({
+  found: booleanType(),
+  authoritative: booleanType(),
+  preview: skillPreviewRecordSchema.nullable(),
+  statusUrl: stringType().nullable(),
+  expiresAt: stringType().nullable()
+}).passthrough();
+const skillStatusPreviewMetadataSchema = objectType({
+  previewId: stringType(),
+  repoUrl: stringType(),
+  repoOwner: stringType(),
+  repoName: stringType(),
+  commitSha: stringType(),
+  ref: stringType(),
+  eventName: stringType(),
+  skillDir: stringType(),
+  generatedAt: stringType(),
+  expiresAt: stringType(),
+  statusUrl: stringType()
+}).passthrough();
+const skillStatusVerificationSignalsSchema = objectType({
+  publisherBound: booleanType(),
+  domainProof: booleanType(),
+  verifiedDomain: booleanType(),
+  previewValidated: booleanType()
+}).passthrough();
+const skillStatusProvenanceSignalsSchema = objectType({
+  repoCommitIntegrity: booleanType(),
+  manifestIntegrity: booleanType(),
+  canonicalRelease: booleanType(),
+  previewAvailable: booleanType(),
+  previewAuthoritative: booleanType()
+}).passthrough();
 const skillBadgeMetricSchema = enumType([
   "version",
+  "version_verification",
   "status",
   "verification",
   "repo_commit",
@@ -7285,7 +7381,65 @@ const skillStatusResponseSchema = objectType({
   badgeMetric: skillBadgeMetricSchema,
   checks: skillStatusChecksSchema,
   nextSteps: arrayType(skillStatusNextStepSchema),
-  publisher: skillPublisherMetadataSchema.nullable().optional()
+  verificationSignals: skillStatusVerificationSignalsSchema.default(
+    skillStatusDefaultVerificationSignals
+  ),
+  provenanceSignals: skillStatusProvenanceSignalsSchema.default(
+    skillStatusDefaultProvenanceSignals
+  ),
+  publisher: skillPublisherMetadataSchema.nullable().optional(),
+  preview: skillStatusPreviewMetadataSchema.nullable().optional(),
+  statusUrl: stringType().nullable().optional()
+}).passthrough();
+const skillInstallArtifactDescriptorSchema = objectType({
+  url: stringType(),
+  pointer: stringType().nullable(),
+  sha256: stringType().nullable()
+}).passthrough();
+const skillInstallResolverDescriptorSchema = objectType({
+  skillRef: stringType(),
+  skillMdUrl: stringType(),
+  manifestUrl: stringType()
+}).passthrough();
+const skillInstallBadgeDescriptorSchema = objectType({
+  apiUrl: stringType(),
+  imageUrl: stringType(),
+  markdown: stringType(),
+  html: stringType()
+}).passthrough();
+const skillInstallShareDescriptorSchema = objectType({
+  canonicalUrl: stringType().nullable(),
+  latestUrl: stringType().nullable(),
+  markdownLink: stringType().nullable(),
+  htmlLink: stringType().nullable(),
+  badge: skillInstallBadgeDescriptorSchema.nullable()
+}).passthrough();
+const skillInstallSnippetSetSchema = objectType({
+  cli: stringType(),
+  claude: stringType(),
+  cursor: stringType(),
+  codex: stringType(),
+  openclaw: stringType()
+}).passthrough();
+const skillInstallResponseSchema = objectType({
+  name: stringType(),
+  version: stringType(),
+  skillRef: stringType(),
+  network: unionType([literalType("mainnet"), literalType("testnet")]),
+  detailUrl: stringType().nullable(),
+  artifacts: objectType({
+    skillMd: skillInstallArtifactDescriptorSchema,
+    manifest: skillInstallArtifactDescriptorSchema
+  }).passthrough(),
+  resolvers: objectType({
+    pinned: skillInstallResolverDescriptorSchema,
+    latest: skillInstallResolverDescriptorSchema
+  }).passthrough(),
+  share: skillInstallShareDescriptorSchema,
+  snippets: skillInstallSnippetSetSchema
+}).passthrough();
+const skillInstallCopyTelemetryResponseSchema = objectType({
+  accepted: booleanType()
 }).passthrough();
 const skillBadgeStyleSchema = enumType([
   "flat",
@@ -9999,6 +10153,35 @@ async function getSkillStatus(client, params) {
     "skill status response"
   );
 }
+function buildRepoPreviewQuery(params) {
+  const repo = params.repo.trim();
+  const skillDir = params.skillDir.trim();
+  if (!repo) {
+    throw new Error("repo is required");
+  }
+  if (!skillDir) {
+    throw new Error("skillDir is required");
+  }
+  const query = new URLSearchParams();
+  query.set("repo", repo);
+  query.set("skillDir", skillDir);
+  if (params.ref?.trim()) {
+    query.set("ref", params.ref.trim());
+  }
+  return query.toString();
+}
+async function getSkillStatusByRepo(client, params) {
+  const query = buildRepoPreviewQuery(params);
+  const raw = await client.requestJson(
+    `/skills/status/by-repo?${query}`,
+    { method: "GET" }
+  );
+  return client.parseWithSchema(
+    raw,
+    skillStatusResponseSchema,
+    "skill status response"
+  );
+}
 async function listSkills(client, params = {}) {
   const query = new URLSearchParams();
   if (params.name) {
@@ -10332,6 +10515,109 @@ async function getSkillBadge(client, params) {
     "skill badge response"
   );
 }
+async function uploadSkillPreviewFromGithubOidc(client, payload) {
+  const token = payload.token.trim();
+  if (!token) {
+    throw new Error("token is required");
+  }
+  const raw = await client.requestJson(
+    "/skills/preview/github-oidc",
+    {
+      method: "POST",
+      body: payload.report,
+      headers: {
+        "content-type": "application/json",
+        authorization: `Bearer ${token}`
+      }
+    }
+  );
+  return client.parseWithSchema(
+    raw,
+    skillPreviewRecordSchema,
+    "skill preview record response"
+  );
+}
+async function getSkillPreview(client, params) {
+  const normalizedName = params.name.trim();
+  if (!normalizedName) {
+    throw new Error("name is required");
+  }
+  const query = new URLSearchParams();
+  query.set("name", normalizedName);
+  if (params.version?.trim()) {
+    query.set("version", params.version.trim());
+  }
+  const raw = await client.requestJson(
+    `/skills/preview?${query.toString()}`,
+    { method: "GET" }
+  );
+  return client.parseWithSchema(
+    raw,
+    skillPreviewLookupResponseSchema,
+    "skill preview response"
+  );
+}
+async function getSkillPreviewByRepo(client, params) {
+  const query = buildRepoPreviewQuery(params);
+  const raw = await client.requestJson(
+    `/skills/preview/by-repo?${query}`,
+    { method: "GET" }
+  );
+  return client.parseWithSchema(
+    raw,
+    skillPreviewLookupResponseSchema,
+    "skill preview by repo response"
+  );
+}
+async function getSkillPreviewById(client, previewId) {
+  const normalizedPreviewId = previewId.trim();
+  if (!normalizedPreviewId) {
+    throw new Error("previewId is required");
+  }
+  const raw = await client.requestJson(
+    `/skills/preview/${encodeURIComponent(normalizedPreviewId)}`,
+    { method: "GET" }
+  );
+  return client.parseWithSchema(
+    raw,
+    skillPreviewLookupResponseSchema,
+    "skill preview by id response"
+  );
+}
+async function getSkillInstall(client, skillRef) {
+  const normalizedSkillRef = skillRef.trim();
+  if (!normalizedSkillRef) {
+    throw new Error("skillRef is required");
+  }
+  const raw = await client.requestJson(
+    `/skills/${encodeURIComponent(normalizedSkillRef)}/install`,
+    { method: "GET" }
+  );
+  return client.parseWithSchema(
+    raw,
+    skillInstallResponseSchema,
+    "skill install response"
+  );
+}
+async function recordSkillInstallCopy(client, skillRef, payload = {}) {
+  const normalizedSkillRef = skillRef.trim();
+  if (!normalizedSkillRef) {
+    throw new Error("skillRef is required");
+  }
+  const raw = await client.requestJson(
+    `/skills/${encodeURIComponent(normalizedSkillRef)}/telemetry/install-copy`,
+    {
+      method: "POST",
+      body: payload,
+      headers: { "content-type": "application/json" }
+    }
+  );
+  return client.parseWithSchema(
+    raw,
+    skillInstallCopyTelemetryResponseSchema,
+    "skill install copy telemetry response"
+  );
+}
 async function listSkillTags(client) {
   const raw = await client.requestJson("/skills/tags", {
     method: "GET"
@@ -10897,6 +11183,27 @@ class RegistryBrokerClient {
   async getSkillBadge(params) {
     return getSkillBadge(this, params);
   }
+  async getSkillStatusByRepo(params) {
+    return getSkillStatusByRepo(this, params);
+  }
+  async uploadSkillPreviewFromGithubOidc(payload) {
+    return uploadSkillPreviewFromGithubOidc(this, payload);
+  }
+  async getSkillPreview(params) {
+    return getSkillPreview(this, params);
+  }
+  async getSkillPreviewByRepo(params) {
+    return getSkillPreviewByRepo(this, params);
+  }
+  async getSkillPreviewById(previewId) {
+    return getSkillPreviewById(this, previewId);
+  }
+  async getSkillInstall(skillRef) {
+    return getSkillInstall(this, skillRef);
+  }
+  async recordSkillInstallCopy(skillRef, payload) {
+    return recordSkillInstallCopy(this, skillRef, payload);
+  }
   async listSkillTags() {
     return listSkillTags(this);
   }