@hol-org/rb-client 0.1.175 → 0.1.176

package/dist/index.js

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hol-org/rb-client",
-  "version": "0.1.175",
+  "version": "0.1.176",
   "description": "Lightweight Registry Broker client for HOL registries.",
   "type": "module",
   "files": [