@drawcall/design 0.5.9 → 0.5.12

package/dist/mcp/schema.js

@@ -0,0 +1,108 @@
+import { z } from "zod";
+import { MAX_FRAME_DIMENSION, designIdSchema, frameNameSchema, imageUrlSchema, marketAssetSchema, projectDirectoryPathSchema, projectFilePathSchema, } from "../v1/schemas.js";
+export const projectIdSchema = designIdSchema.describe("Exact project ID returned by list_projects");
+export const frameIdSchema = designIdSchema.describe("Exact frame ID returned by list_frames");
+export const directoryPathSchema = projectDirectoryPathSchema.describe("Project-absolute directory path without a trailing slash; omit it to list the entire project");
+export const filePathSchema = projectFilePathSchema.describe("Project-absolute file path returned by list_files, including the frame ID; pass it unchanged");
+const sizeSchema = z.coerce.number().int().min(1).max(MAX_FRAME_DIMENSION);
+const positionSchema = z.coerce.number().finite();
+// Some MCP clients lose property types in discriminated unions and serialize
+// every create_frame argument as a string. Keep the wire schema flat.
+export const createFrameSchema = z
+    .object({
+    project: projectIdSchema,
+    name: frameNameSchema,
+    type: z.enum(["glts", "image", "market"]),
+    width: sizeSchema.optional(),
+    height: sizeSchema.optional(),
+    image: imageUrlSchema.optional(),
+    asset: marketAssetSchema.optional(),
+    x: positionSchema.optional(),
+    y: positionSchema.optional(),
+})
+    .strict()
+    .superRefine((input, context) => {
+    const require = (key) => {
+        if (input[key] !== undefined)
+            return;
+        context.addIssue({
+            code: "custom",
+            path: [key],
+            message: `${key} is required for a ${input.type} frame`,
+        });
+    };
+    const reject = (key) => {
+        if (input[key] === undefined)
+            return;
+        context.addIssue({
+            code: "custom",
+            path: [key],
+            message: `${key} is not valid for a ${input.type} frame`,
+        });
+    };
+    switch (input.type) {
+        case "glts":
+            require("width");
+            require("height");
+            reject("image");
+            reject("asset");
+            break;
+        case "image":
+            require("image");
+            reject("width");
+            reject("height");
+            reject("asset");
+            break;
+        case "market":
+            require("asset");
+            reject("width");
+            reject("height");
+            reject("image");
+            break;
+    }
+});
+export const projectInput = z.object({ project: projectIdSchema }).strict();
+export const frameInput = projectInput.extend({ frame: frameIdSchema });
+export const fileInput = projectInput.extend({ path: filePathSchema });
+export function frameCreationInput(input) {
+    const position = {
+        ...(input.x === undefined ? {} : { x: input.x }),
+        ...(input.y === undefined ? {} : { y: input.y }),
+    };
+    switch (input.type) {
+        case "glts":
+            if (input.width === undefined || input.height === undefined) {
+                throw new Error("Validated GLTS frame input is missing dimensions");
+            }
+            return {
+                project: input.project,
+                name: input.name,
+                type: input.type,
+                width: input.width,
+                height: input.height,
+                ...position,
+            };
+        case "image":
+            if (input.image === undefined) {
+                throw new Error("Validated image frame input is missing an image");
+            }
+            return {
+                project: input.project,
+                name: input.name,
+                type: input.type,
+                image: input.image,
+                ...position,
+            };
+        case "market":
+            if (input.asset === undefined) {
+                throw new Error("Validated Market frame input is missing an asset");
+            }
+            return {
+                project: input.project,
+                name: input.name,
+                type: input.type,
+                asset: input.asset,
+                ...position,
+            };
+    }
+}

package/dist/mcp/skill.d.ts

@@ -0,0 +1,2 @@
+import type { DesignMcpServer } from "./types.js";
+export declare function registerSkillTool(server: DesignMcpServer): void;

package/dist/mcp/skill.js

@@ -0,0 +1,14 @@
+import { z } from "zod";
+import { mcpDesignSkill } from "../skill.generated.js";
+export function registerSkillTool(server) {
+    server.registerTool("get_skill", {
+        description: "Return instructions for building and composing 3D GLTS assets in Drawcall Design. Read it before creating or changing GLTS files.",
+        inputSchema: z.object({}).strict(),
+        annotations: {
+            readOnlyHint: true,
+            destructiveHint: false,
+            openWorldHint: false,
+            idempotentHint: true,
+        },
+    }, async () => ({ content: [{ type: "text", text: mcpDesignSkill }] }));
+}

package/dist/mcp/types.d.ts

@@ -0,0 +1,54 @@
+import type { CreateFrame, DesignFile, FileList, FileMutation, Frame, GenerateImageFrame, Project, Screenshot } from "../v1/schemas.js";
+import type { z } from "zod";
+export interface DesignMcpToolResult {
+    [key: string]: unknown;
+    content: Array<{
+        type: "text";
+        text: string;
+    } | {
+        type: "image";
+        data: string;
+        mimeType: string;
+    }>;
+    structuredContent?: Record<string, unknown>;
+}
+interface DesignMcpToolAnnotations {
+    readOnlyHint?: boolean;
+    destructiveHint?: boolean;
+    idempotentHint?: boolean;
+    openWorldHint?: boolean;
+}
+interface DesignMcpToolConfig<Input extends z.ZodType | undefined> {
+    description?: string;
+    inputSchema?: Input;
+    annotations?: DesignMcpToolAnnotations;
+}
+type DesignMcpToolHandler<Input extends z.ZodType | undefined> = Input extends z.ZodType ? (input: z.output<Input>) => Promise<DesignMcpToolResult> : () => Promise<DesignMcpToolResult>;
+export interface DesignMcpServer {
+    registerTool<Input extends z.ZodType | undefined = undefined>(name: string, config: DesignMcpToolConfig<Input>, handler: DesignMcpToolHandler<Input>): unknown;
+}
+export interface DesignMcpScreenshot extends Screenshot {
+    png: Uint8Array;
+}
+export type DesignMcpOperationRunner = <Result>(name: string, operation: () => Promise<Result>) => Promise<Result>;
+export interface DesignMcpOperations {
+    listProjects(): Promise<Project[]>;
+    createProject(name: string): Promise<Project>;
+    deleteProject(project: string): Promise<{
+        id: string;
+    }>;
+    listFrames(project: string): Promise<Frame[]>;
+    createFrame(input: CreateFrame): Promise<Frame>;
+    generateImage(input: GenerateImageFrame): Promise<Frame>;
+    renameFrame(project: string, frame: string, name: string): Promise<Frame>;
+    deleteFrame(project: string, frame: string): Promise<{
+        id: string;
+    }>;
+    listFiles(project: string, path?: string): Promise<FileList>;
+    readFile(project: string, path: string): Promise<DesignFile>;
+    writeFile(project: string, path: string, text: string): Promise<FileMutation>;
+    editFile(project: string, path: string, oldText: string, newText: string): Promise<FileMutation>;
+    deleteFile(project: string, path: string): Promise<FileMutation>;
+    screenshot(project: string, frame: string): Promise<DesignMcpScreenshot>;
+}
+export {};

package/dist/mcp/types.js

@@ -0,0 +1 @@
+export {};

package/dist/options.d.ts

@@ -0,0 +1,2 @@
+import type { Command } from "commander";
+export declare function apiOption(command: Command): string | undefined;

package/dist/options.js

@@ -0,0 +1,4 @@
+export function apiOption(command) {
+    const value = command.optsWithGlobals().api;
+    return typeof value === "string" ? value : undefined;
+}

package/dist/standalone.d.ts

@@ -0,0 +1,3 @@
+import type { Command } from "commander";
+import { type DesignCommandOptions } from "./command.js";
+export declare function createDesignCli(options?: DesignCommandOptions): Command;

package/dist/standalone.js

@@ -0,0 +1,7 @@
+import { createLoginCommand, createLogoutCommand } from "./auth.js";
+import { createDesignCommand } from "./command.js";
+export function createDesignCli(options = {}) {
+    return createDesignCommand(options)
+        .addCommand(createLoginCommand())
+        .addCommand(createLogoutCommand());
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@drawcall/design",
-  "version": "0.5.9",
+  "version": "0.5.12",
   "description": "Typed API and remote CLI for Drawcall Design",
   "repository": {
     "type": "git",
@@ -8,19 +8,15 @@
     "directory": "packages/design"
   },
   "type": "module",
+  "main": "./dist/index.js",
+  "browser": "./dist/browser.js",
   "types": "./dist/index.d.ts",
-  "exports": {
-    ".": {
-      "types": "./dist/index.d.ts",
-      "import": "./dist/index.js"
-    }
-  },
   "files": [
     "dist",
     "skills"
   ],
   "bin": {
-    "design": "./dist/cli.js"
+    "design": "dist/cli.js"
   },
   "scripts": {
     "generate": "node scripts/generate-skill.mjs",
@@ -34,15 +30,23 @@
     "typecheck": "tsc --noEmit"
   },
   "dependencies": {
+    "@drawcall/auth": "^0.1.0",
     "@orpc/client": "^1.14.13",
     "@orpc/contract": "^1.14.13",
     "@orpc/openapi-client": "^1.14.13",
     "commander": "^14.0.3",
-    "open": "^10.1.0",
-    "openid-client": "^6.8.4",
     "zod": "^4.3.6"
   },
+  "peerDependencies": {
+    "@modelcontextprotocol/server": "^2.0.0"
+  },
+  "peerDependenciesMeta": {
+    "@modelcontextprotocol/server": {
+      "optional": true
+    }
+  },
   "devDependencies": {
+    "@modelcontextprotocol/server": "^2.0.0",
     "@types/node": "^25.6.0",
     "prettier": "^3.6.2",
     "tsx": "^4.21.0",