@domino-sdk/relay-cli 0.1.0

package/dist/index.js

@@ -0,0 +1,428 @@
+// src/index.ts
+import {
+  projectDeploymentSchema,
+  deploymentPreviewSchema,
+  publishDeploymentSchema,
+  deploymentResultSchema,
+  catalogDeploymentPreviewSchema,
+  questCatalogSchema,
+  questDraftSchema,
+  questPublicationPreviewSchema,
+  catalogDeploymentSchema,
+  saveQuestDraftSchema,
+  publishQuestDraftSchema
+} from "@domino-sdk/relay";
+import { z as z2 } from "zod";
+
+// src/hosting.ts
+import { z } from "zod";
+import { identifier } from "@domino-sdk/relay";
+var repositorySchema = z.object({
+  id: z.string().uuid(),
+  organization: identifier,
+  project: identifier,
+  remote: z.string().url(),
+  defaultBranch: z.string(),
+  status: z.enum(["provisioning", "ready"])
+});
+var createRepositorySchema = z.object({
+  starter: z.literal("campaign").default("campaign")
+}).strict();
+var deviceStartSchema = z.object({
+  challenge: z.string().regex(/^[a-f0-9]{64}$/)
+}).strict();
+var deviceRedeemSchema = z.object({
+  id: z.string().uuid(),
+  verifier: z.string().min(43).max(128)
+}).strict();
+var deviceApproveSchema = z.object({
+  id: z.string().uuid(),
+  code: z.string().regex(/^[A-F0-9]{4}-[A-F0-9]{4}$/)
+}).strict();
+var commitSchema = z.string().regex(/^[a-f0-9]{40}$/);
+var stageRequestSchema = z.object({
+  commit: commitSchema,
+  requestId: z.string().uuid()
+}).strict();
+var buildIdentitySchema = z.object({
+  id: z.string().uuid(),
+  repository: z.string().uuid(),
+  organization: identifier,
+  project: identifier,
+  commit: commitSchema,
+  createdAt: z.number(),
+  actor: z.string()
+});
+var buildPhaseSchema = z.enum([
+  "queued",
+  "source",
+  "install",
+  "check",
+  "build",
+  "deploy",
+  "ready",
+  "failed"
+]);
+var buildStatusSchema = z.object({
+  phase: buildPhaseSchema,
+  updatedAt: z.number(),
+  message: z.string()
+});
+var assetPathSchema = z.string().max(512).refine(
+  (path) => path.startsWith("/") && !/[\\\u0000-\u001f?#%]/.test(path) && path.slice(1).split("/").every((part) => part.length > 0 && !part.startsWith(".")) && !path.startsWith("/relay/") && !path.startsWith("/__domino/"),
+  "Expected a public asset path without hidden or reserved segments"
+);
+var buildArtifactsSchema = z.object({
+  format: z.literal(1),
+  assets: z.array(
+    z.object({
+      path: assetPathSchema,
+      content: z.string().max(14e6).regex(
+        /^(?:[A-Za-z0-9+/]{4})*(?:[A-Za-z0-9+/]{2}==|[A-Za-z0-9+/]{3}=)?$/
+      ),
+      size: z.number().int().min(0).max(1e7)
+    }).strict()
+  ).min(1).max(500),
+  quests: z.unknown(),
+  catalog: z.unknown()
+}).strict().superRefine((value, ctx) => {
+  if (new Set(value.assets.map((a) => a.path)).size !== value.assets.length)
+    ctx.addIssue({ code: "custom", message: "Duplicate asset paths" });
+  if (!value.assets.some((a) => a.path === "/index.html"))
+    ctx.addIssue({
+      code: "custom",
+      message: "Build must include index.html"
+    });
+  if (value.assets.reduce((sum, a) => sum + a.size, 0) > 1e7)
+    ctx.addIssue({ code: "custom", message: "Staging assets exceed 10 MB" });
+});
+
+// src/index.ts
+import {
+  walletConnectionSchema,
+  solanaBalanceSchema,
+  collectionPreviewSchema,
+  collectionBeginSchema,
+  collectionResolveSchema,
+  pickupCatalogSchema,
+  pickupAvailabilitySchema,
+  configurePickupSchema,
+  entitlementSchema,
+  identifier as identifier2,
+  snapshotSchema,
+  memberProgressSchema
+} from "@domino-sdk/relay";
+var environmentSchema = z2.enum(["test", "live"]);
+var roleSchema = z2.enum(["editor", "reviewer", "staff"]);
+var permissionSchema = z2.enum([
+  "read",
+  "publish",
+  "review",
+  "confirm",
+  "handover",
+  "inventory",
+  "access"
+]);
+var rolePermissions = {
+  editor: ["read", "publish", "inventory"],
+  reviewer: ["read", "review"],
+  staff: ["read", "confirm", "handover"]
+};
+var projectSchema = z2.object({
+  id: z2.string().min(1),
+  organization: identifier2,
+  project: identifier2,
+  name: z2.string(),
+  subtitle: z2.string(),
+  initials: z2.string(),
+  color: z2.string(),
+  permissions: z2.array(permissionSchema),
+  environments: z2.array(environmentSchema)
+});
+var projectInputSchema = z2.object({ project: identifier2, name: z2.string().trim().min(1).max(80) }).strict();
+var grantSchema = z2.object({
+  subject: z2.string().min(1).max(200),
+  roles: z2.array(roleSchema),
+  environments: z2.array(environmentSchema)
+}).strict();
+var accessSchema = z2.object({
+  actor: z2.string(),
+  organization: z2.string(),
+  admin: z2.boolean(),
+  local: z2.boolean(),
+  projects: z2.array(projectSchema)
+});
+var querySchema = z2.object({
+  q: z2.string().max(200).default(""),
+  filter: z2.string().max(50).default("all"),
+  offset: z2.coerce.number().int().min(0).max(1e6).default(0),
+  limit: z2.coerce.number().int().min(1).max(100).default(25)
+});
+var accountProfileSchema = z2.object({
+  name: z2.string().optional(),
+  email: z2.string().optional(),
+  emailVerified: z2.boolean().default(false),
+  imageUrl: z2.string().url().optional()
+});
+var memberAccountSchema = z2.object({
+  provider: z2.string(),
+  subject: z2.string(),
+  signInEnabled: z2.boolean(),
+  profile: accountProfileSchema.optional()
+});
+var operationSchema = z2.object({
+  target: z2.string(),
+  paused: z2.boolean(),
+  revision: z2.number().int(),
+  reason: z2.string(),
+  actor: z2.string().nullable(),
+  changedAt: z2.number()
+});
+var operationInputSchema = z2.object({
+  target: z2.union([
+    z2.literal("redemptions"),
+    z2.string().regex(/^quest:[\w-]+$/)
+  ]),
+  paused: z2.boolean(),
+  revision: z2.number().int().nonnegative(),
+  reason: z2.string().trim().min(1).max(500),
+  actionId: identifier2
+}).strict();
+var memberSchema = z2.object({
+  id: z2.string(),
+  accounts: z2.array(memberAccountSchema).default([]),
+  attempts: z2.number(),
+  completions: z2.number(),
+  rewards: z2.number(),
+  lastActivity: z2.number().nullable()
+});
+var metricsSchema = z2.object({
+  quests: z2.number(),
+  members: z2.number(),
+  attempts: z2.number(),
+  completions: z2.number(),
+  review: z2.number(),
+  failed: z2.number(),
+  entitlements: z2.number()
+});
+var readinessSchema = z2.object({
+  checks: z2.array(
+    z2.object({
+      id: z2.string(),
+      status: z2.enum(["ready", "blocked"]),
+      title: z2.string(),
+      detail: z2.string()
+    })
+  )
+});
+var inventorySchema = z2.object({
+  item: z2.string(),
+  available: z2.number(),
+  reserved: z2.number(),
+  allocated: z2.number().default(0)
+});
+var auditRecordSchema = z2.object({
+  id: z2.string(),
+  action: z2.string(),
+  actor: z2.string().nullable(),
+  detail: z2.string(),
+  at: z2.number(),
+  attempt: z2.string().nullable()
+});
+var pageSchema = z2.object({
+  snapshot: snapshotSchema,
+  members: z2.array(memberSchema),
+  metrics: metricsSchema,
+  total: z2.number(),
+  offset: z2.number(),
+  limit: z2.number(),
+  inventory: z2.array(inventorySchema),
+  operations: z2.array(operationSchema).default([]),
+  audit: z2.array(auditRecordSchema).default([]),
+  questCounts: z2.record(z2.string(), z2.number())
+});
+var memberDetailSchema = z2.object({
+  snapshot: snapshotSchema,
+  member: memberSchema,
+  progress: memberProgressSchema,
+  passes: z2.array(
+    z2.object({
+      provider: z2.string(),
+      event: z2.string(),
+      subject: z2.string(),
+      attempt: identifier2.nullable()
+    })
+  ).default([]),
+  wallet: z2.object({
+    connection: walletConnectionSchema.nullable(),
+    observation: z2.object({ attempt: identifier2, balance: solanaBalanceSchema }).nullable()
+  }).default({ connection: null, observation: null })
+});
+var stockInputSchema = z2.object({
+  item: identifier2,
+  quantity: z2.number().int().positive().max(1e6),
+  actionId: identifier2
+}).strict();
+var tokenInputSchema = z2.object({
+  name: z2.string().trim().min(1).max(80),
+  project: identifier2,
+  environment: environmentSchema,
+  permissions: z2.array(permissionSchema).min(1),
+  days: z2.number().int().min(1).max(90).default(30)
+}).strict();
+var tokenSchema = z2.object({
+  id: z2.string(),
+  name: z2.string(),
+  project: z2.string(),
+  environment: environmentSchema,
+  permissions: z2.array(permissionSchema),
+  expiresAt: z2.number()
+});
+function createManagementClient(options) {
+  async function raw(path, init) {
+    const headers = new Headers(init?.headers);
+    const token = await options.getToken?.();
+    if (token) headers.set("Authorization", `Bearer ${token}`);
+    if (options.organization)
+      headers.set("X-Relay-Organization", options.organization);
+    if (options.project) headers.set("X-Relay-Project", options.project);
+    if (options.environment)
+      headers.set("X-Relay-Environment", options.environment);
+    const response = await fetch(`${options.baseUrl}/management/v1${path}`, {
+      ...init,
+      headers
+    });
+    if (!response.ok) {
+      const error = z2.object({ error: z2.string() }).safeParse(await response.json().catch(() => null));
+      throw new Error(
+        error.success ? error.data.error : `Request failed (${response.status})`
+      );
+    }
+    return response;
+  }
+  async function request(path, schema, input, method = "POST") {
+    const response = await raw(
+      path,
+      input === void 0 ? void 0 : {
+        method,
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify(input)
+      }
+    );
+    return schema.parse(await response.json());
+  }
+  return {
+    raw,
+    request,
+    deployments: {
+      preview: (input) => request(
+        "/deployments/preview",
+        deploymentPreviewSchema,
+        projectDeploymentSchema.parse(input)
+      ),
+      publish: (input) => request(
+        "/deployments/publish",
+        deploymentResultSchema,
+        publishDeploymentSchema.parse(input)
+      )
+    },
+    catalog: {
+      read: () => request("/catalog", questCatalogSchema),
+      previewDeployment: (input) => request(
+        "/catalog/deploy/preview",
+        catalogDeploymentPreviewSchema,
+        catalogDeploymentSchema.parse(input)
+      ),
+      deploy: (input) => request(
+        "/catalog/deploy",
+        questCatalogSchema,
+        catalogDeploymentSchema.parse(input)
+      ),
+      saveDraft: (input) => request(
+        "/catalog/drafts",
+        questDraftSchema,
+        saveQuestDraftSchema.parse(input)
+      ),
+      preview: (input) => request(
+        "/catalog/preview",
+        questPublicationPreviewSchema,
+        publishQuestDraftSchema.parse(input)
+      ),
+      publish: (input) => request(
+        "/catalog/publish",
+        questPublicationPreviewSchema,
+        publishQuestDraftSchema.parse(input)
+      )
+    },
+    collection: {
+      resolve: (code) => request(
+        "/collection/resolve",
+        collectionPreviewSchema,
+        collectionResolveSchema.parse({ code })
+      ),
+      begin: (input) => request(
+        "/collection/begin",
+        entitlementSchema,
+        collectionBeginSchema.parse(input)
+      )
+    },
+    inventory: {
+      catalog: () => request("/pickup-inventory", z2.array(pickupCatalogSchema)),
+      configure: (input) => request(
+        "/pickup-inventory",
+        pickupCatalogSchema,
+        configurePickupSchema.parse(input)
+      ),
+      availability: (entitlement) => request(
+        `/pickup-inventory/${encodeURIComponent(entitlement)}`,
+        pickupAvailabilitySchema
+      )
+    },
+    readiness: () => request("/readiness", readinessSchema),
+    access: () => request("/access", accessSchema),
+    createProject: (input) => request("/projects", projectSchema, input),
+    page: (page, query) => request(
+      `/${page}?${new URLSearchParams(Object.entries(query).map(([k, v]) => [k, String(v)]))}`,
+      pageSchema
+    ),
+    member: (id) => request(`/members/${encodeURIComponent(id)}`, memberDetailSchema)
+  };
+}
+export {
+  accessSchema,
+  accountProfileSchema,
+  assetPathSchema,
+  auditRecordSchema,
+  buildArtifactsSchema,
+  buildIdentitySchema,
+  buildPhaseSchema,
+  buildStatusSchema,
+  commitSchema,
+  createManagementClient,
+  createRepositorySchema,
+  deviceApproveSchema,
+  deviceRedeemSchema,
+  deviceStartSchema,
+  environmentSchema,
+  grantSchema,
+  inventorySchema,
+  memberAccountSchema,
+  memberDetailSchema,
+  memberSchema,
+  metricsSchema,
+  operationInputSchema,
+  operationSchema,
+  pageSchema,
+  permissionSchema,
+  projectInputSchema,
+  projectSchema,
+  querySchema,
+  readinessSchema,
+  repositorySchema,
+  rolePermissions,
+  roleSchema,
+  stageRequestSchema,
+  stockInputSchema,
+  tokenInputSchema,
+  tokenSchema
+};

package/package.json

@@ -0,0 +1,41 @@
+{
+  "name": "@domino-sdk/relay-cli",
+  "type": "module",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    }
+  },
+  "dependencies": {
+    "commander": "15.0.0",
+    "zod": "4.3.6",
+    "@domino-sdk/relay": "0.1.0"
+  },
+  "version": "0.1.0",
+  "bin": {
+    "domino": "./cli.mjs"
+  },
+  "license": "UNLICENSED",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/GetDomino/relay.git",
+    "directory": "packages/management"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "engines": {
+    "node": ">=24 <25"
+  },
+  "files": [
+    "dist",
+    "cli",
+    "cli.mjs"
+  ],
+  "description": "Domino CLI and agent skills for Relay projects",
+  "scripts": {
+    "typecheck": "tsc --noEmit",
+    "build": "tsup src/index.ts --format esm --dts --clean"
+  }
+}