@legionworks/facet 1.9.0 → 1.10.0

package/src/harness-adapters/mcp/server.ts

@@ -1,11 +1,15 @@
 import { mkdirSync } from "node:fs";
+import { resolve } from "node:path";
 
-import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
-import { z, ZodError } from "zod";
+import { Server } from "@modelcontextprotocol/sdk/server/index.js";
+import { toJsonSchemaCompat } from "@modelcontextprotocol/sdk/server/zod-json-schema-compat.js";
+import { CallToolRequestSchema, ListToolsRequestSchema } from "@modelcontextprotocol/sdk/types.js";
+import { type ZodType, ZodError } from "zod";
 import { FACET_VERSION } from "../../shared/version";
 
 import { buildFacetArgs, FacetBridgeError, invokeFacet } from "./cli-bridge";
 import {
+  CreateToolSchema,
   ExportToolSchema,
   OpenUrlToolSchema,
   PublishToolSchema,
@@ -41,12 +45,10 @@ function errorEnvelope(cause: unknown): FacetEnvelope<never> {
   return errEnvelope(requestId(), body);
 }
 
-const LooseToolInputSchema = z.record(z.unknown());
-
 function toolResult(envelope: FacetEnvelope<unknown>) {
   return {
     content: [{ type: "text" as const, text: JSON.stringify(envelope) }],
-    ...(envelope.ok ? {} : { isError: true }),
+    isError: !envelope.ok,
   };
 }
 
@@ -90,75 +92,96 @@ function publishSource(input: PublishToolInput): {
   });
 }
 
-export function createFacetMcpServer(): McpServer {
-  const server = new McpServer({ name: "facet", version: FACET_VERSION });
-
-  server.registerTool(
-    "facet_export",
-    {
-      description:
-        "Export source or stored render evidence into outDir. Check envelope.ok for transport success; a successful publish verdict remains a separate data.verdict.status decision.",
-      inputSchema: LooseToolInputSchema,
-    },
-    async (args) =>
-      withInput(args, ExportToolSchema.parse, async (input) => {
-        mkdirSync(input.outDir, { recursive: true });
-        return invoke(buildFacetArgs("export", input), { cwd: input.outDir });
-      }),
-  );
+function defineTool<T>(
+  schema: ZodType<T>,
+  description: string,
+  run: (input: T) => Promise<ReturnType<typeof toolResult>>,
+) {
+  return {
+    schema,
+    description,
+    execute: (args: unknown) => withInput(args, (input) => schema.parse(input), run),
+  };
+}
 
-  server.registerTool(
-    "facet_open_url",
-    {
-      description:
-        "Return a Facet gallery frameUrl without launching a browser. This always invokes facet open --no-launch; agents must not launch desktop display.",
-      inputSchema: LooseToolInputSchema,
-    },
-    async (args) =>
-      withInput(args, OpenUrlToolSchema.parse, async (input) =>
-        invoke(buildFacetArgs("open", input)),
-      ),
+export function createFacetMcpServer(): Server {
+  const server = new Server(
+    { name: "facet", version: FACET_VERSION },
+    { capabilities: { tools: {} } },
   );
-
-  server.registerTool(
-    "facet_publish",
-    {
-      description:
-        "Publish exactly one sourceText or local file. Check envelope.ok separately from data.verdict.status: stored verdict status error is not a transport failure.",
-      inputSchema: LooseToolInputSchema,
-    },
-    async (args) =>
-      withInput(args, PublishToolSchema.parse, async (input) => {
+  // The high-level SDK validates arguments before the handler and emits plain-text errors.
+  // Wire schemas and handler parsing are separate so invalid calls retain Facet envelopes.
+  const tools = {
+    facet_create: defineTool(
+      CreateToolSchema,
+      "Create an artifact from projectId, slug, and title before publishing source.",
+      async (input) => invoke(buildFacetArgs("create", input)),
+    ),
+    facet_export: defineTool(
+      ExportToolSchema,
+      "Export source or stored render evidence into outDir. Check envelope.ok for transport success; a successful publish verdict remains a separate data.verdict.status decision.",
+      async (input) => {
+        const outDir = resolve(input.outDir);
+        try {
+          mkdirSync(outDir, { recursive: true });
+        } catch (cause) {
+          throw new FacetBridgeError(
+            {
+              code: "output_unwritable",
+              message: `Cannot write export output: ${outDir}`,
+              retryable: false,
+              details: { out: outDir },
+            },
+            cause,
+          );
+        }
+        return invoke(buildFacetArgs("export", input), { cwd: outDir });
+      },
+    ),
+    facet_open_url: defineTool(
+      OpenUrlToolSchema,
+      "Return a Facet gallery frameUrl without launching a browser. This always invokes facet open --no-launch; agents must not launch desktop display.",
+      async (input) => invoke(buildFacetArgs("open", input)),
+    ),
+    facet_publish: defineTool(
+      PublishToolSchema,
+      "Publish exactly one sourceText or local file. Check envelope.ok separately from data.verdict.status: stored verdict status error is not a transport failure.",
+      async (input) => {
         const source = publishSource(input);
         return invoke(buildFacetArgs("publish", { ...input, ...source }), source);
+      },
+    ),
+    facet_read_back: defineTool(
+      ReadBackToolSchema,
+      "Read back the latest or revision-bound stored verdict at Tier 0, Tier 1, or visual. Tier 1 and visual need browser evidence; inspect envelope.ok before verdict status.",
+      async (input) => invoke(buildFacetArgs("read_back", input)),
+    ),
+    facet_status: defineTool(
+      StatusToolSchema,
+      "Read Facet status. Set start only when activation is intended; envelope.ok reports command transport and never replaces verdict.status inspection.",
+      async (input) => invoke(buildFacetArgs("status", input)),
+    ),
+  };
+  server.setRequestHandler(ListToolsRequestSchema, async () => ({
+    tools: Object.entries(tools).map(([name, tool]) => ({
+      name,
+      description: tool.description,
+      inputSchema: toJsonSchemaCompat(tool.schema, { pipeStrategy: "input" }),
+    })),
+  }));
+  server.setRequestHandler(CallToolRequestSchema, async ({ params }) => {
+    const tool = Object.hasOwn(tools, params.name)
+      ? tools[params.name as keyof typeof tools]
+      : null;
+    if (tool) return tool.execute(params.arguments);
+    return toolResult(
+      errEnvelope(requestId(), {
+        code: "invalid_request",
+        message: `Unknown MCP tool '${params.name}'`,
+        retryable: false,
       }),
-  );
-
-  server.registerTool(
-    "facet_read_back",
-    {
-      description:
-        "Read back the latest or revision-bound stored verdict at Tier 0, Tier 1, or visual. Tier 1 and visual need browser evidence; inspect envelope.ok before verdict status.",
-      inputSchema: LooseToolInputSchema,
-    },
-    async (args) =>
-      withInput(args, ReadBackToolSchema.parse, async (input) =>
-        invoke(buildFacetArgs("read_back", input)),
-      ),
-  );
-
-  server.registerTool(
-    "facet_status",
-    {
-      description:
-        "Read Facet status. Set start only when activation is intended; envelope.ok reports command transport and never replaces verdict.status inspection.",
-      inputSchema: LooseToolInputSchema,
-    },
-    async (args) =>
-      withInput(args, StatusToolSchema.parse, async (input) =>
-        invoke(buildFacetArgs("status", input)),
-      ),
-  );
+    );
+  });
 
   return server;
 }

package/src/harness-adapters/mcp/tool-schemas.ts

@@ -6,6 +6,13 @@ const RevisionShaSchema = z.string().regex(/^[a-f0-9]{64}$/);
 const ExecutionSchema = z.enum(["static", "interactive"]);
 const ReadBackTierSchema = z.union([z.literal(0), z.literal(1), z.literal("visual")]);
 
+export const CreateToolShape = {
+  projectId: z.string().min(1),
+  slug: z.string().min(1),
+  title: z.string().min(1),
+};
+export const CreateToolSchema = z.object(CreateToolShape).strict();
+
 export const PublishToolShape = {
   artifactId: z.string().min(1),
   type: ArtifactTypeSchema,

package/src/service/dispatcher.ts

@@ -513,6 +513,13 @@ export async function dispatch(
         nextCursor: null,
       };
     }
+    case "templates": {
+      return {
+        command: "templates",
+        requestId,
+        templates: deps.repository.listTemplates(command.limit),
+      };
+    }
     case "readBack": {
       const revision =
         command.revisionSha === undefined
@@ -642,6 +649,9 @@ export async function dispatch(
         revisionId: command.revisionId,
         name: command.name,
         promotedBy: command.promotedBy,
+        ...(command.allowUnverified !== undefined
+          ? { allowUnverified: command.allowUnverified }
+          : {}),
         ...(command.description !== undefined ? { description: command.description } : {}),
       });
       return { command: "promote", requestId, template };

package/src/service/router-guards.ts

@@ -222,6 +222,8 @@ export function statusFor(error: FacetError): number {
     case "tier0_unavailable":
       return 503;
     case "duplicate_revision":
+    case "template_name_taken":
+    case "promotion_refused":
     case "constraint":
     case "foreign_key":
     case "immutable_revision":

package/src/service/store/migrations.ts

@@ -12,8 +12,8 @@ import {
   V7_SCHEMA_FRAGMENT,
   V8_SCHEMA_FRAGMENT,
   V9_SCHEMA_FRAGMENT,
+  V10_SCHEMA_FRAGMENT,
 } from "./schema";
-import { CURRENT_STORAGE_VERSION } from "../../shared/storage-version";
 
 export interface MigrationOptions {
   readonly beforeRecordVersion?: (version: number) => void;
@@ -106,13 +106,23 @@ const MIGRATION_STEPS: readonly MigrationStep[] = [
     requiresForeignKeyDisable: true,
   },
   {
-    version: CURRENT_STORAGE_VERSION,
+    version: 9,
     apply: (db) => {
       db.exec(V9_SCHEMA_FRAGMENT);
     },
   },
+  {
+    version: 10,
+    apply: (db) => {
+      db.exec(V10_SCHEMA_FRAGMENT);
+    },
+  },
 ];
 
+export function latestMigrationVersion(): number {
+  return MIGRATION_STEPS.at(-1)?.version ?? 0;
+}
+
 export function runMigrations(db: Database, options: MigrationOptions = {}): void {
   try {
     db.exec(

package/src/service/store/repository-lifecycle.ts

@@ -2,6 +2,11 @@ import type { Database } from "bun:sqlite";
 
 import { type Template, TemplateSchema } from "../../shared/contracts/artifact";
 import { now } from "../../shared/util/time";
+import { FacetError } from "../../shared/errors/facet-error";
+import { PROMOTION_GATE } from "../../shared/contracts/promotion";
+import type { RenderStatus } from "../../shared/contracts/validation";
+import { verdictFromStoredRun } from "../stored-verdict";
+import type { ArtifactRepository } from "./repository";
 import { asStoreError, FacetStoreError } from "./database";
 
 export interface TemplateInput {
@@ -11,6 +16,7 @@ export interface TemplateInput {
   readonly description?: string | null;
   readonly promotedBy: string;
   readonly promotedAt?: string;
+  readonly promotionOverride?: string | null;
 }
 
 export interface PromoteRevisionInput {
@@ -20,6 +26,7 @@ export interface PromoteRevisionInput {
   readonly description?: string | null;
   readonly promotedBy: string;
   readonly promotedAt?: string;
+  readonly allowUnverified?: boolean;
 }
 
 export function evictRevisions(
@@ -59,23 +66,75 @@ export function evictRevisions(
   }
 }
 
-export function promoteRevision(db: Database, input: PromoteRevisionInput): Template {
-  const owner = db
-    .query("SELECT artifact_id FROM revisions WHERE id = ?")
-    .get(input.revisionId) as { artifact_id: string } | null;
-  if (!owner) throw new FacetStoreError("foreign_key", `Revision not found: ${input.revisionId}`);
-  // The template table has independent foreign keys on artifact_id and
-  // revision_id, not a composite ownership constraint, so an explicit
-  // artifactId that disagrees with the revision's real owner would
-  // otherwise insert silently — instantiation would then copy the wrong
-  // artifact's bytes under the caller-supplied artifact's identity.
-  if (input.artifactId !== undefined && input.artifactId !== owner.artifact_id) {
-    throw new FacetStoreError(
-      "foreign_key",
-      `Revision ${input.revisionId} belongs to artifact ${owner.artifact_id}, not ${input.artifactId}`,
-    );
-  }
-  return createTemplate(db, { ...input, artifactId: owner.artifact_id });
+export function promoteRevision(
+  db: Database,
+  repository: ArtifactRepository,
+  input: PromoteRevisionInput,
+): Template {
+  return db
+    .transaction(() => {
+      const owner = db
+        .query("SELECT artifact_id FROM revisions WHERE id = ?")
+        .get(input.revisionId) as { artifact_id: string } | null;
+      if (!owner)
+        throw new FacetStoreError("foreign_key", `Revision not found: ${input.revisionId}`);
+      // The template table has independent foreign keys on artifact_id and
+      // revision_id, not a composite ownership constraint, so an explicit
+      // artifactId that disagrees with the revision's real owner would
+      // otherwise insert silently — instantiation would then copy the wrong
+      // artifact's bytes under the caller-supplied artifact's identity.
+      if (input.artifactId !== undefined && input.artifactId !== owner.artifact_id) {
+        throw new FacetStoreError(
+          "foreign_key",
+          `Revision ${input.revisionId} belongs to artifact ${owner.artifact_id}, not ${input.artifactId}`,
+        );
+      }
+      const revision = repository.getRevisionById(input.revisionId);
+      if (revision === null)
+        throw new FacetStoreError("foreign_key", `Revision not found: ${input.revisionId}`);
+      const tier1 = repository.listRenderRuns({ revisionId: revision.id, tier: 1 })[0];
+      const tier0 = repository.listRenderRuns({ revisionId: revision.id, tier: 0 })[0];
+      // Read the marker from the reconstructed verdict object rather than
+      // the raw `insecure_json` column — `verdictFromStoredRun` is the single
+      // source of truth for cross-boundary reconstruction and keeps the
+      // precedence between status, tier, and marker consistent with the
+      // dispatcher's wire form.
+      const tier1Verdict = tier1 === undefined ? null : verdictFromStoredRun(revision, tier1);
+      const tier0Verdict = tier0 === undefined ? null : verdictFromStoredRun(revision, tier0);
+      const tier1Status = tier1Verdict === null ? null : tier1Verdict.status;
+      const tier0Status = tier0Verdict === null ? null : tier0Verdict.status;
+      // Level 3 opts out of the validation contract (publish skips Tier 0). A
+      // visual read-back still runs the browser, but a result carrying
+      // `insecure.level === 3` is not trusted verification for a template, so
+      // refuse even when the status alone would allow. Levels 1 and 2 keep the
+      // status decision: they run real validators under relaxed sandboxing.
+      const insecureLevel3 = tier1Verdict !== null && tier1Verdict.insecure?.level === 3;
+      const reason =
+        tier1Status === null
+          ? "no_visual_verification"
+          : tier0Status === "error"
+            ? "error"
+            : insecureLevel3
+              ? "insecure:unvalidated"
+              : PROMOTION_GATE[tier1Status as RenderStatus] === "allow"
+                ? null
+                : tier1Status;
+      if (reason !== null && input.allowUnverified !== true) {
+        throw new FacetError(
+          "promotion_refused",
+          `Promotion refused (${reason}). Run facet read-back --artifact-id ${owner.artifact_id} --tier visual on revision ${input.revisionId}, or pass --allow-unverified to record an override.`,
+          {
+            details: { revisionId: input.revisionId, reason, tier1Status, tier0Status },
+          },
+        );
+      }
+      return createTemplate(db, {
+        ...input,
+        artifactId: owner.artifact_id,
+        promotionOverride: reason,
+      });
+    })
+    .immediate();
 }
 
 export function createTemplate(db: Database, input: TemplateInput): Template {
@@ -88,10 +147,11 @@ export function createTemplate(db: Database, input: TemplateInput): Template {
     description: input.description ?? null,
     promotedBy: input.promotedBy,
     promotedAt,
+    promotionOverride: input.promotionOverride ?? null,
   };
   try {
     db.query(
-      "INSERT INTO templates(id, artifact_id, revision_id, name, description, promoted_by, promoted_at) VALUES (?, ?, ?, ?, ?, ?, ?)",
+      "INSERT INTO templates(id, artifact_id, revision_id, name, description, promoted_by, promoted_at, promotion_override) VALUES (?, ?, ?, ?, ?, ?, ?, ?)",
     ).run(
       value.id,
       value.artifactId,
@@ -100,10 +160,22 @@ export function createTemplate(db: Database, input: TemplateInput): Template {
       value.description,
       value.promotedBy,
       value.promotedAt,
+      value.promotionOverride,
     );
     return TemplateSchema.parse(value);
   } catch (error) {
-    throw asStoreError(error);
+    const mapped = asStoreError(error);
+    if (mapped.code === "template_name_taken") {
+      throw new FacetStoreError(
+        "template_name_taken",
+        `Template name already exists: ${input.name}`,
+        {
+          cause: error,
+          details: { name: input.name },
+        },
+      );
+    }
+    throw mapped;
   }
 }
 

package/src/service/store/repository.ts

@@ -32,6 +32,7 @@ import {
   type TemplateInput,
 } from "./repository-lifecycle";
 import { enforceEvidenceRetention, removeUnreferencedEvidence } from "./evidence-retention";
+import { latestStoredVerdict } from "../stored-verdict";
 
 interface ProjectInput {
   readonly projectRoot: string;
@@ -407,7 +408,7 @@ export class ArtifactRepository {
     try {
       const row = this.db
         .query(
-          "SELECT id, artifact_id, revision_id, name, description, promoted_by, promoted_at FROM templates WHERE name = ? ORDER BY promoted_at DESC LIMIT 1",
+          "SELECT id, artifact_id, revision_id, name, description, promoted_by, promoted_at, promotion_override FROM templates WHERE name = ? ORDER BY promoted_at DESC LIMIT 1",
         )
         .get(name) as {
         id: string;
@@ -417,6 +418,7 @@ export class ArtifactRepository {
         description: string | null;
         promoted_by: string;
         promoted_at: string;
+        promotion_override: string | null;
       } | null;
       if (!row) return null;
       return TemplateSchema.parse({
@@ -427,12 +429,68 @@ export class ArtifactRepository {
         description: row.description,
         promotedBy: row.promoted_by,
         promotedAt: row.promoted_at,
+        promotionOverride: row.promotion_override,
       });
     } catch (error) {
       throw asStoreError(error);
     }
   }
 
+  listTemplates(limit = DEFAULT_LIST_LIMIT): Array<{
+    name: string;
+    artifactId: string;
+    revisionId: string;
+    revisionSha: string;
+    promotedBy: string;
+    promotedAt: string;
+    promotionOverride: string | null;
+    sourceVerdict: {
+      status: import("../../shared/contracts/validation").RenderStatus;
+      tier: 0 | 1;
+    } | null;
+  }> {
+    const rows = this.db
+      .query(
+        "SELECT id, artifact_id, revision_id, name, description, promoted_by, promoted_at, promotion_override FROM templates ORDER BY promoted_at DESC, id DESC LIMIT ?",
+      )
+      .all(limit) as Array<{
+      id: string;
+      artifact_id: string;
+      revision_id: string;
+      name: string;
+      description: string | null;
+      promoted_by: string;
+      promoted_at: string;
+      promotion_override: string | null;
+    }>;
+    return rows.map((row) => {
+      const revision = this.getRevisionById(row.revision_id);
+      if (revision === null)
+        throw new FacetStoreError("foreign_key", `Template revision not found: ${row.revision_id}`);
+      const template = TemplateSchema.parse({
+        id: row.id,
+        artifactId: row.artifact_id,
+        revisionId: row.revision_id,
+        name: row.name,
+        description: row.description,
+        promotedBy: row.promoted_by,
+        promotedAt: row.promoted_at,
+        promotionOverride: row.promotion_override,
+      });
+      const verdict = latestStoredVerdict(this, revision);
+      return {
+        name: template.name,
+        artifactId: template.artifactId,
+        revisionId: template.revisionId,
+        revisionSha: revision.sha256,
+        promotedBy: template.promotedBy,
+        promotedAt: template.promotedAt,
+        promotionOverride: template.promotionOverride,
+        sourceVerdict: verdict === null ? null : { status: verdict.status, tier: verdict.tier },
+      };
+    });
+  }
+
   createArtifact(input: ArtifactInput): Artifact {
     const createdAt = now();
     const value = { id: crypto.randomUUID(), ...input, createdAt, updatedAt: createdAt };
@@ -715,7 +773,7 @@ export class ArtifactRepository {
   }
 
   promoteRevision(input: PromoteRevisionInput): Template {
-    return promoteLifecycleRevision(this.db, input);
+    return promoteLifecycleRevision(this.db, this, input);
   }
 
   instantiateTemplate(input: TemplateInput): Template {

package/src/service/store/schema.ts

@@ -216,3 +216,7 @@ export const V9_SCHEMA_FRAGMENT = `
 ALTER TABLE render_runs ADD COLUMN screenshot_format TEXT
   CHECK(screenshot_format IN ('png','webp'));
 `;
+
+export const V10_SCHEMA_FRAGMENT = `
+ALTER TABLE templates ADD COLUMN promotion_override TEXT;
+`;

package/src/service/stored-verdict.ts

@@ -39,6 +39,9 @@ export function withTolerantObserved(parsed: unknown): VerdictObserved {
     visibleSvgCount: num("visibleSvgCount", 0),
     opaqueRegionCount: num("opaqueRegionCount", 0),
     externalImageCount: num("externalImageCount", 0),
+    ...(typeof observed.emptyRendererRoot === "boolean"
+      ? { emptyRendererRoot: observed.emptyRendererRoot }
+      : {}),
     // errorCount is required on the schema; pre-arc rows that never
     // recorded it default to 0.
     errorCount: num("errorCount", 0),

package/src/shared/contracts/artifact.ts

@@ -94,5 +94,6 @@ export const TemplateSchema = z.object({
   description: z.string().nullable(),
   promotedBy: z.string().min(1),
   promotedAt: IsoTimestampSchema,
+  promotionOverride: z.string().nullable(),
 });
 export type Template = z.infer<typeof TemplateSchema>;

package/src/shared/contracts/commands/index.ts

@@ -33,6 +33,7 @@ import {
   CreateRequestSchema,
   InstantiateRequestSchema,
   ListRequestSchema,
+  TemplatesRequestSchema,
   OpenRequestSchema,
   PinRequestSchema,
   PromoteRequestSchema,
@@ -45,6 +46,7 @@ import {
   type CreateRequest,
   type InstantiateRequest,
   type ListRequest,
+  type TemplatesRequest,
   type OpenRequest,
   type PinRequest,
   type PromoteRequest,
@@ -58,6 +60,7 @@ import {
   CreateResultSchema,
   InstantiateResultSchema,
   ListResultSchema,
+  TemplatesResultSchema,
   OpenResultSchema,
   PinResultSchema,
   PromoteResultSchema,
@@ -72,6 +75,7 @@ import {
   type CreateResult,
   type InstantiateResult,
   type ListResult,
+  type TemplatesResult,
   type OpenResult,
   type PinResult,
   type PromoteResult,
@@ -98,6 +102,7 @@ export const CommandRequestSchema = z.discriminatedUnion("command", [
   CreateRequestSchema,
   PublishRequestSchema,
   ListRequestSchema,
+  TemplatesRequestSchema,
   ReadBackRequestSchema,
   StatusRequestSchema,
   OpenRequestSchema,
@@ -112,6 +117,7 @@ export const CommandResultSchema = z.discriminatedUnion("command", [
   CreateResultSchema,
   PublishResultSchema,
   ListResultSchema,
+  TemplatesResultSchema,
   ReadBackResultSchema,
   StatusResultSchema,
   OpenResultSchema,
@@ -145,6 +151,7 @@ export {
   PublishRequestSchema,
   PublishArtifactTypeSchema,
   ListRequestSchema,
+  TemplatesRequestSchema,
   ReadBackRequestSchema,
   StatusRequestSchema,
   OpenRequestSchema,
@@ -157,6 +164,7 @@ export {
   CreateResultSchema,
   PublishResultSchema,
   ListResultSchema,
+  TemplatesResultSchema,
   ReadBackResultSchema,
   StatusResultSchema,
   OpenResultSchema,
@@ -180,6 +188,7 @@ export type {
   CreateRequest,
   PublishRequest,
   ListRequest,
+  TemplatesRequest,
   ReadBackRequest,
   StatusRequest,
   OpenRequest,
@@ -191,6 +200,7 @@ export type {
   CreateResult,
   PublishResult,
   ListResult,
+  TemplatesResult,
   ReadBackResult,
   StatusResult,
   DoctorResult,

package/src/shared/contracts/commands/names.ts

@@ -9,6 +9,7 @@ export const CommandNameSchema = z.enum([
   "create",
   "publish",
   "list",
+  "templates",
   "readBack",
   "status",
   "open",
@@ -23,6 +24,7 @@ export const IMPLEMENTED_COMMANDS: readonly CommandName[] = [
   "create",
   "publish",
   "list",
+  "templates",
   "readBack",
   "status",
   "open",

package/src/shared/contracts/commands/requests.ts

@@ -82,6 +82,12 @@ export const ListRequestSchema = BaseRequestSchema.extend({
 });
 export type ListRequest = z.infer<typeof ListRequestSchema>;
 
+export const TemplatesRequestSchema = BaseRequestSchema.extend({
+  command: z.literal("templates"),
+  limit: z.number().int().positive().max(MAX_LIST_LIMIT).optional(),
+});
+export type TemplatesRequest = z.infer<typeof TemplatesRequestSchema>;
+
 export const ReadBackRequestSchema = BaseRequestSchema.extend({
   command: z.literal("readBack"),
   artifactId: z.string().min(1),
@@ -116,6 +122,7 @@ export const PromoteRequestSchema = BaseRequestSchema.extend({
   name: z.string().min(1),
   description: z.string().nullable().optional(),
   promotedBy: z.string().min(1),
+  allowUnverified: z.boolean().optional(),
 });
 export type PromoteRequest = z.infer<typeof PromoteRequestSchema>;