@hol-org/rb-client 0.1.175 → 0.1.176

package/dist/index.cjs

@@ -1380,24 +1380,120 @@ var skillPublisherMetadataSchema = import_zod2.z.object({
 }).passthrough();
 var skillTrustTierSchema = import_zod2.z.enum([
   "unpublished",
+  "unclaimed",
+  "validated",
   "published",
   "verified",
   "hardened"
 ]);
+var skillStatusDefaultVerificationSignals = {
+  publisherBound: false,
+  domainProof: false,
+  verifiedDomain: false,
+  previewValidated: false
+};
+var skillStatusDefaultProvenanceSignals = {
+  repoCommitIntegrity: false,
+  manifestIntegrity: false,
+  canonicalRelease: false,
+  previewAvailable: false,
+  previewAuthoritative: false
+};
 var skillStatusChecksSchema = import_zod2.z.object({
   repoCommitIntegrity: import_zod2.z.boolean(),
   manifestIntegrity: import_zod2.z.boolean(),
   domainProof: import_zod2.z.boolean()
 }).passthrough();
 var skillStatusNextStepSchema = import_zod2.z.object({
+  kind: import_zod2.z.enum([
+    "setup_validate",
+    "publish_first_release",
+    "verify_domain",
+    "harden_workflow",
+    "share_status"
+  ]).optional(),
+  priority: import_zod2.z.number().int().optional(),
   id: import_zod2.z.string(),
   label: import_zod2.z.string(),
   description: import_zod2.z.string(),
+  url: import_zod2.z.string().nullable().optional(),
   href: import_zod2.z.string().nullable().optional(),
   command: import_zod2.z.string().nullable().optional()
 }).passthrough();
+var skillPreviewSuggestedNextStepSchema = import_zod2.z.object({
+  id: import_zod2.z.string(),
+  label: import_zod2.z.string(),
+  description: import_zod2.z.string(),
+  command: import_zod2.z.string().optional(),
+  href: import_zod2.z.string().optional()
+}).passthrough();
+var skillPreviewReportSchema = import_zod2.z.object({
+  schema_version: import_zod2.z.literal("skill-preview.v1"),
+  tool_version: import_zod2.z.string(),
+  preview_id: import_zod2.z.string(),
+  repo_url: import_zod2.z.string(),
+  repo_owner: import_zod2.z.string(),
+  repo_name: import_zod2.z.string(),
+  default_branch: import_zod2.z.string(),
+  commit_sha: import_zod2.z.string(),
+  ref: import_zod2.z.string(),
+  event_name: import_zod2.z.string(),
+  workflow_run_url: import_zod2.z.string(),
+  skill_dir: import_zod2.z.string(),
+  name: import_zod2.z.string(),
+  version: import_zod2.z.string(),
+  validation_status: import_zod2.z.literal("passed"),
+  findings: import_zod2.z.array(import_zod2.z.unknown()),
+  package_summary: import_zod2.z.record(import_zod2.z.string(), import_zod2.z.unknown()),
+  suggested_next_steps: import_zod2.z.array(skillPreviewSuggestedNextStepSchema),
+  generated_at: import_zod2.z.string()
+}).passthrough();
+var skillPreviewRecordSchema = import_zod2.z.object({
+  id: import_zod2.z.string(),
+  previewId: import_zod2.z.string(),
+  source: import_zod2.z.literal("github-oidc"),
+  report: skillPreviewReportSchema,
+  generatedAt: import_zod2.z.string(),
+  expiresAt: import_zod2.z.string(),
+  statusUrl: import_zod2.z.string(),
+  authoritative: import_zod2.z.boolean()
+}).passthrough();
+var skillPreviewLookupResponseSchema = import_zod2.z.object({
+  found: import_zod2.z.boolean(),
+  authoritative: import_zod2.z.boolean(),
+  preview: skillPreviewRecordSchema.nullable(),
+  statusUrl: import_zod2.z.string().nullable(),
+  expiresAt: import_zod2.z.string().nullable()
+}).passthrough();
+var skillStatusPreviewMetadataSchema = import_zod2.z.object({
+  previewId: import_zod2.z.string(),
+  repoUrl: import_zod2.z.string(),
+  repoOwner: import_zod2.z.string(),
+  repoName: import_zod2.z.string(),
+  commitSha: import_zod2.z.string(),
+  ref: import_zod2.z.string(),
+  eventName: import_zod2.z.string(),
+  skillDir: import_zod2.z.string(),
+  generatedAt: import_zod2.z.string(),
+  expiresAt: import_zod2.z.string(),
+  statusUrl: import_zod2.z.string()
+}).passthrough();
+var skillStatusVerificationSignalsSchema = import_zod2.z.object({
+  publisherBound: import_zod2.z.boolean(),
+  domainProof: import_zod2.z.boolean(),
+  verifiedDomain: import_zod2.z.boolean(),
+  previewValidated: import_zod2.z.boolean()
+}).passthrough();
+var skillStatusProvenanceSignalsSchema = import_zod2.z.object({
+  repoCommitIntegrity: import_zod2.z.boolean(),
+  manifestIntegrity: import_zod2.z.boolean(),
+  canonicalRelease: import_zod2.z.boolean(),
+  previewAvailable: import_zod2.z.boolean(),
+  previewAuthoritative: import_zod2.z.boolean()
+}).passthrough();
 var skillBadgeMetricSchema = import_zod2.z.enum([
   "version",
+  "version_verification",
   "status",
   "verification",
   "repo_commit",
@@ -1418,7 +1514,65 @@ var skillStatusResponseSchema = import_zod2.z.object({
   badgeMetric: skillBadgeMetricSchema,
   checks: skillStatusChecksSchema,
   nextSteps: import_zod2.z.array(skillStatusNextStepSchema),
-  publisher: skillPublisherMetadataSchema.nullable().optional()
+  verificationSignals: skillStatusVerificationSignalsSchema.default(
+    skillStatusDefaultVerificationSignals
+  ),
+  provenanceSignals: skillStatusProvenanceSignalsSchema.default(
+    skillStatusDefaultProvenanceSignals
+  ),
+  publisher: skillPublisherMetadataSchema.nullable().optional(),
+  preview: skillStatusPreviewMetadataSchema.nullable().optional(),
+  statusUrl: import_zod2.z.string().nullable().optional()
+}).passthrough();
+var skillInstallArtifactDescriptorSchema = import_zod2.z.object({
+  url: import_zod2.z.string(),
+  pointer: import_zod2.z.string().nullable(),
+  sha256: import_zod2.z.string().nullable()
+}).passthrough();
+var skillInstallResolverDescriptorSchema = import_zod2.z.object({
+  skillRef: import_zod2.z.string(),
+  skillMdUrl: import_zod2.z.string(),
+  manifestUrl: import_zod2.z.string()
+}).passthrough();
+var skillInstallBadgeDescriptorSchema = import_zod2.z.object({
+  apiUrl: import_zod2.z.string(),
+  imageUrl: import_zod2.z.string(),
+  markdown: import_zod2.z.string(),
+  html: import_zod2.z.string()
+}).passthrough();
+var skillInstallShareDescriptorSchema = import_zod2.z.object({
+  canonicalUrl: import_zod2.z.string().nullable(),
+  latestUrl: import_zod2.z.string().nullable(),
+  markdownLink: import_zod2.z.string().nullable(),
+  htmlLink: import_zod2.z.string().nullable(),
+  badge: skillInstallBadgeDescriptorSchema.nullable()
+}).passthrough();
+var skillInstallSnippetSetSchema = import_zod2.z.object({
+  cli: import_zod2.z.string(),
+  claude: import_zod2.z.string(),
+  cursor: import_zod2.z.string(),
+  codex: import_zod2.z.string(),
+  openclaw: import_zod2.z.string()
+}).passthrough();
+var skillInstallResponseSchema = import_zod2.z.object({
+  name: import_zod2.z.string(),
+  version: import_zod2.z.string(),
+  skillRef: import_zod2.z.string(),
+  network: import_zod2.z.union([import_zod2.z.literal("mainnet"), import_zod2.z.literal("testnet")]),
+  detailUrl: import_zod2.z.string().nullable(),
+  artifacts: import_zod2.z.object({
+    skillMd: skillInstallArtifactDescriptorSchema,
+    manifest: skillInstallArtifactDescriptorSchema
+  }).passthrough(),
+  resolvers: import_zod2.z.object({
+    pinned: skillInstallResolverDescriptorSchema,
+    latest: skillInstallResolverDescriptorSchema
+  }).passthrough(),
+  share: skillInstallShareDescriptorSchema,
+  snippets: skillInstallSnippetSetSchema
+}).passthrough();
+var skillInstallCopyTelemetryResponseSchema = import_zod2.z.object({
+  accepted: import_zod2.z.boolean()
 }).passthrough();
 var skillBadgeStyleSchema = import_zod2.z.enum([
   "flat",
@@ -4176,6 +4330,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) {
@@ -4509,6 +4692,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"
@@ -5076,6 +5362,27 @@ var RegistryBrokerClient = 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);
   }