@drawcall/design 0.5.8 → 0.5.11

package/dist/command.js

@@ -0,0 +1,311 @@
+import { createRequire } from "node:module";
+import { getConfigPath as getAuthConfigPath, runDeviceLogin, saveAuthToken, signOut, } from "@drawcall/auth";
+import { Command, Option } from "commander";
+import { clearConfig, saveConfig } from "./config.js";
+import { getCliClient } from "./cli-client.js";
+import { readImageInput } from "./image.js";
+import { cliDesignSkill } from "./skill.generated.js";
+import { parseFrameSize } from "./target.js";
+import { createClient, DEFAULT_BASE_URL } from "./v1/client.js";
+import { designIdSchema, marketAssetSchema } from "./v1/schemas.js";
+export function createDesignCommand(options = {}) {
+    const program = new Command()
+        .name(options.name ?? "design")
+        .description("Design 3D assets on Drawcall Design")
+        .version(options.version ?? readPackageVersion())
+        .addOption(new Option("--api <url>", "Design API URL").default(process.env.DESIGN_API_URL, "from DESIGN_API_URL / config / default"))
+        .addOption(new Option("-p, --project <id>", "Project ID"));
+    program
+        .command("skill")
+        .description("Print the Drawcall Design skill")
+        .action(() => {
+        process.stdout.write(cliDesignSkill);
+    });
+    if (options.includeAuthCommands ?? true)
+        addAuthCommands(program);
+    const project = program.command("project").description("Manage projects");
+    project
+        .command("list")
+        .description("List projects")
+        .action(async (_options, command) => {
+        const client = await clientFor(command);
+        const projects = await client.project.list();
+        if (projects.length === 0) {
+            console.log("No projects.");
+            return;
+        }
+        for (const item of projects)
+            console.log(`${item.id}\t${item.name}`);
+    });
+    project
+        .command("create")
+        .description("Create a project")
+        .argument("<name>", "Project name")
+        .action(async (name, _options, command) => {
+        const client = await clientFor(command);
+        const created = await client.project.create({ name });
+        console.log(`Created ${created.id}\t${created.name}`);
+    });
+    project
+        .command("delete")
+        .description("Delete a project")
+        .argument("<project-id>", "Project ID")
+        .option("-y, --yes", "Confirm deletion", false)
+        .action(async (projectId, options, command) => {
+        requireConfirmation(options.yes);
+        const id = designIdSchema.parse(projectId);
+        const client = await clientFor(command);
+        await client.project.delete({ project: id });
+        console.log(`Deleted ${id}.`);
+    });
+    const frame = program.command("frame").description("Manage frames");
+    frame
+        .command("list")
+        .description("List frames in the selected project")
+        .action(async (_options, command) => {
+        const client = await clientFor(command);
+        const frames = await client.frame.list({ project: projectId(command) });
+        if (frames.length === 0) {
+            console.log("No frames.");
+            return;
+        }
+        for (const item of frames) {
+            console.log(`${item.id}\t${item.name}\t${item.type}\t${item.width}x${item.height}`);
+        }
+    });
+    frame
+        .command("create")
+        .description("Create a GLTS, image, or pinned Market frame")
+        .argument("<name>", "Frame name")
+        .requiredOption("-t, --type <type>", "glts, image, or market")
+        .option("-s, --size <width>x<height>", "GLTS viewport size")
+        .option("--image <url-or-path>", "Image URL or local PNG, JPEG, or WebP")
+        .option("--asset <name@version>", "Exact public Market asset version")
+        .action(async (name, options, command) => {
+        const project = projectId(command);
+        const input = await createFrameInput(project, name, options);
+        const client = await clientFor(command);
+        const created = await client.frame.create(input);
+        console.log(`Created ${created.id}\t${created.name}\t${created.type}`);
+        console.log(`Path /${created.id}/`);
+    });
+    frame
+        .command("rename")
+        .description("Rename a frame")
+        .argument("<frame-id>", "Frame ID")
+        .argument("<name>", "New frame name")
+        .action(async (frameId, name, _options, command) => {
+        const id = designIdSchema.parse(frameId);
+        const client = await clientFor(command);
+        const renamed = await client.frame.rename({
+            project: projectId(command),
+            frame: id,
+            name,
+        });
+        console.log(`Renamed ${renamed.id}\t${renamed.name}.`);
+    });
+    frame
+        .command("delete")
+        .description("Delete frames")
+        .argument("<frame-id...>", "Frame IDs")
+        .option("-y, --yes", "Confirm deletion", false)
+        .action(async (frameIds, options, command) => {
+        requireConfirmation(options.yes);
+        const project = projectId(command);
+        const client = await clientFor(command);
+        for (const frameId of frameIds) {
+            const id = designIdSchema.parse(frameId);
+            await client.frame.delete({ project, frame: id });
+            console.log(`Deleted ${id}.`);
+        }
+    });
+    frame
+        .command("screenshot")
+        .description("Render frames and print their screenshot URLs")
+        .argument("<frame-id...>", "Frame IDs")
+        .action(async (frameIds, _options, command) => {
+        const project = projectId(command);
+        const client = await clientFor(command);
+        for (const frameId of frameIds) {
+            const id = designIdSchema.parse(frameId);
+            const result = await client.frame.screenshot({ project, frame: id });
+            console.log(`${id}\t${result.url}`);
+        }
+    });
+    program
+        .command("ls")
+        .description("List paths in the selected project filesystem")
+        .argument("[path]", "Absolute directory path", "/")
+        .action(async (path, _options, command) => {
+        const client = await clientFor(command);
+        const result = await client.filesystem.list({
+            project: projectId(command),
+            path,
+        });
+        for (const item of result.paths)
+            console.log(item);
+    });
+    program
+        .command("read")
+        .description("Read a project file")
+        .argument("<path>", "Absolute project path")
+        .action(async (path, _options, command) => {
+        const client = await clientFor(command);
+        const file = await client.filesystem.read({
+            project: projectId(command),
+            path,
+        });
+        if (file.type === "text") {
+            process.stdout.write(file.text);
+            return;
+        }
+        console.log(file.url);
+    });
+    program
+        .command("write")
+        .description("Create or overwrite a text project file")
+        .argument("<path>", "Absolute project path")
+        .argument("[text]", "Inline text; omit or use - to read stdin")
+        .action(async (path, text, _options, command) => {
+        const client = await clientFor(command);
+        await client.filesystem.write({
+            project: projectId(command),
+            path,
+            text: text === undefined || text === "-" ? await readStdin() : text,
+        });
+        console.log(`Wrote ${path}.`);
+    });
+    program
+        .command("edit")
+        .description("Replace text that occurs exactly once in a project file")
+        .argument("<path>", "Absolute project path")
+        .argument("<old-text>", "Text that must occur exactly once")
+        .argument("<new-text>", "Replacement text")
+        .action(async (path, oldText, newText, _options, command) => {
+        const client = await clientFor(command);
+        await client.filesystem.edit({
+            project: projectId(command),
+            path,
+            oldText,
+            newText,
+        });
+        console.log(`Edited ${path}.`);
+    });
+    program
+        .command("delete")
+        .description("Delete a project file")
+        .argument("<path>", "Absolute project path")
+        .option("-y, --yes", "Confirm deletion", false)
+        .action(async (path, options, command) => {
+        requireConfirmation(options.yes);
+        const client = await clientFor(command);
+        await client.filesystem.delete({ project: projectId(command), path });
+        console.log(`Deleted ${path}.`);
+    });
+    return program;
+}
+function addAuthCommands(program) {
+    program
+        .command("login")
+        .description("Sign in with your Drawcall account")
+        .action(async (_options, command) => {
+        const baseUrlOverride = apiOption(command);
+        const baseUrl = baseUrlOverride ?? DEFAULT_BASE_URL;
+        const token = await runDeviceLogin();
+        const client = createClient({ baseUrl, authToken: token });
+        const user = await client.user.me();
+        if (baseUrlOverride)
+            await saveConfig({ baseUrl });
+        else
+            await clearConfig();
+        await saveAuthToken(token);
+        console.log(`Signed in as ${user.email}. Credentials saved to ${getAuthConfigPath()}.`);
+    });
+    program
+        .command("logout")
+        .description("Sign out")
+        .action(async () => {
+        const authExisted = await signOut();
+        const configExisted = await clearConfig();
+        console.log(authExisted || configExisted ? "Signed out." : "Already signed out.");
+    });
+}
+async function createFrameInput(project, name, options) {
+    if (options.type === "glts") {
+        if (options.image !== undefined || options.asset !== undefined) {
+            throw new Error("GLTS frames do not accept --image or --asset");
+        }
+        if (options.size === undefined) {
+            throw new Error("GLTS frames require --size <width>x<height>");
+        }
+        return {
+            project,
+            name,
+            type: "glts",
+            ...parseFrameSize(options.size),
+        };
+    }
+    if (options.type === "image") {
+        if (options.size !== undefined || options.asset !== undefined) {
+            throw new Error("Image frames do not accept --size or --asset");
+        }
+        if (options.image === undefined)
+            throw new Error("Image frames require --image");
+        return {
+            project,
+            name,
+            type: "image",
+            image: await readImageInput(options.image),
+        };
+    }
+    if (options.type === "market") {
+        if (options.size !== undefined || options.image !== undefined) {
+            throw new Error("Market frames do not accept --size or --image");
+        }
+        if (options.asset === undefined)
+            throw new Error("Market frames require --asset");
+        return {
+            project,
+            name,
+            type: "market",
+            asset: marketAssetSchema.parse(options.asset),
+        };
+    }
+    throw new Error("--type must be glts, image, or market");
+}
+async function clientFor(command) {
+    return getCliClient(apiOption(command));
+}
+function apiOption(command) {
+    const value = command.optsWithGlobals().api;
+    return typeof value === "string" ? value : undefined;
+}
+function projectId(command) {
+    const value = command.optsWithGlobals().project;
+    if (typeof value !== "string") {
+        throw new Error("Select a project with -p, --project <project-id>.");
+    }
+    return designIdSchema.parse(value);
+}
+function requireConfirmation(confirmed) {
+    if (!confirmed)
+        throw new Error("Destructive commands require --yes.");
+}
+async function readStdin() {
+    const chunks = [];
+    for await (const chunk of process.stdin) {
+        chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk));
+    }
+    return Buffer.concat(chunks).toString("utf8");
+}
+function readPackageVersion() {
+    const manifest = createRequire(import.meta.url)("../package.json");
+    if (!manifest ||
+        typeof manifest !== "object" ||
+        Array.isArray(manifest) ||
+        !("version" in manifest) ||
+        typeof manifest.version !== "string") {
+        throw new Error("@drawcall/design package.json is missing a valid version");
+    }
+    return manifest.version;
+}

package/dist/config.d.ts

@@ -1,6 +1,6 @@
 import { z } from "zod";
 declare const configSchema: z.ZodObject<{
-    authToken: z.ZodString;
+    authToken: z.ZodOptional<z.ZodString>;
     baseUrl: z.ZodOptional<z.ZodString>;
 }, z.core.$strip>;
 export type Config = z.infer<typeof configSchema>;

package/dist/config.js

@@ -3,7 +3,7 @@ import * as os from "node:os";
 import * as path from "node:path";
 import { z } from "zod";
 const configSchema = z.object({
-    authToken: z.string().min(1),
+    authToken: z.string().min(1).optional(),
     baseUrl: z.string().url().optional(),
 });
 function configDirectory() {

package/dist/index.d.ts

@@ -1,8 +1,2 @@
-export * as v1 from "./v1/index.js";
-export { cliDesignSkill, mcpDesignSkill } from "./skill.generated.js";
-export { frameCreationCapabilities, type FrameCreationCapability, type FrameCreationCapabilityId, type FrameCreationInput, } from "./v1/capabilities.js";
-export { cameraPoseSchema, IMAGE_GENERATION_MODEL, IMAGE_GENERATION_PROVIDER, } from "./v1/schemas.js";
-export { parseFrameSize } from "./target.js";
-export { projectFrameLayoutSchema, projectFrameRecordSchema, projectGltsFrameRecordSchema, projectImageFrameRecordSchema, projectMarketFileSchema, projectMarketFrameRecordSchema, projectPresenceClientMessageSchema, projectPresenceServerMessageSchema, projectStateSchema, type ProjectFrameLayout, type ProjectFrameRecord, type ProjectGltsFrameRecord, type ProjectImageFrameRecord, type ProjectMarketFile, type ProjectMarketFrameRecord, type ProjectPresenceClientMessage, type ProjectPresenceServerMessage, type ProjectState, } from "./project-state.js";
-export { cameraCaptureCommandSchema, cameraCaptureResultSchema, cameraMessageTypes, cameraSetCommandSchema, gltsExportCancelCommandSchema, gltsExportCancelledResultSchema, gltsExportCommandSchema, gltsExportFrameMessageSchema, gltsExportMessageTypes, gltsExportParentMessageSchema, gltsExportResultSchema, gltsRuntimeExportFormatSchema, immersiveCommandSchema, immersiveFrameMessageSchema, immersiveMessageTypes, immersiveModeSchema, inspectionCommandSchema, inspectionFrameMessageSchema, inspectionMessageTypes, projectSyncUrl, sourceFileChangeSchema, sourceFileMessageTypes, sourceFileReloadResultSchema, sourceFilesChangedMessageSchema, type GltsExportCancelCommand, type GltsExportCancelledResult, type GltsExportCommand, type GltsExportFrameMessage, type GltsExportParentMessage, type GltsExportResult, type GltsRuntimeExportFormat, type CameraCaptureCommand, type CameraSetCommand, type CameraCaptureFailure, type CameraCaptureResult, type InspectionAppliedMessage, type InspectionCommand, type InspectionFrameMessage, type ImmersiveCommand, type ImmersiveFrameMessage, type ImmersiveMode, type SourceFileChange, type SourceFileReloadResult, type SourceFilesChangedMessage, } from "./protocol.js";
-export type { BinaryFile, CameraPose, CreateFrame, CreateProjectFromBrief, CreateGltsFrame, CreateImageFrame, CreateMarketFrame, GenerateImageFrame, DesignFile, FileList, FileMutation, FrameExport, Frame, GltsFrame, GltsFrameExport, ImageFrame, ImageFrameExport, ImageGenerationOperation, ImageGenerationProvenance, ImageGenerationResult, MarketFrame, MarketFrameExport, Project, ProjectDerivationStatus, Screenshot, TextFile, User, } from "./v1/schemas.js";
+export * from "./browser.js";
+export { createDesignCommand, type DesignCommandOptions } from "./command.js";

package/dist/index.js

@@ -1,7 +1,2 @@
-export * as v1 from "./v1/index.js";
-export { cliDesignSkill, mcpDesignSkill } from "./skill.generated.js";
-export { frameCreationCapabilities, } from "./v1/capabilities.js";
-export { cameraPoseSchema, IMAGE_GENERATION_MODEL, IMAGE_GENERATION_PROVIDER, } from "./v1/schemas.js";
-export { parseFrameSize } from "./target.js";
-export { projectFrameLayoutSchema, projectFrameRecordSchema, projectGltsFrameRecordSchema, projectImageFrameRecordSchema, projectMarketFileSchema, projectMarketFrameRecordSchema, projectPresenceClientMessageSchema, projectPresenceServerMessageSchema, projectStateSchema, } from "./project-state.js";
-export { cameraCaptureCommandSchema, cameraCaptureResultSchema, cameraMessageTypes, cameraSetCommandSchema, gltsExportCancelCommandSchema, gltsExportCancelledResultSchema, gltsExportCommandSchema, gltsExportFrameMessageSchema, gltsExportMessageTypes, gltsExportParentMessageSchema, gltsExportResultSchema, gltsRuntimeExportFormatSchema, immersiveCommandSchema, immersiveFrameMessageSchema, immersiveMessageTypes, immersiveModeSchema, inspectionCommandSchema, inspectionFrameMessageSchema, inspectionMessageTypes, projectSyncUrl, sourceFileChangeSchema, sourceFileMessageTypes, sourceFileReloadResultSchema, sourceFilesChangedMessageSchema, } from "./protocol.js";
+export * from "./browser.js";
+export { createDesignCommand } from "./command.js";

package/dist/mcp/client.d.ts

@@ -0,0 +1,3 @@
+import type { DesignV1Client } from "../v1/client.js";
+import type { DesignMcpOperations } from "./types.js";
+export declare function createDesignMcpOperations(client: DesignV1Client, fetcher?: typeof globalThis.fetch): DesignMcpOperations;

package/dist/mcp/client.js

@@ -0,0 +1,38 @@
+export function createDesignMcpOperations(client, fetcher = globalThis.fetch) {
+    return {
+        listProjects: () => client.project.list(),
+        createProject: (name) => client.project.create({ name }),
+        deleteProject: (project) => client.project.delete({ project }),
+        listFrames: (project) => client.frame.list({ project }),
+        createFrame: (input) => client.frame.create(input),
+        generateImage: (input) => client.frame.generateImage(input),
+        renameFrame: (project, frame, name) => client.frame.rename({ project, frame, name }),
+        deleteFrame: (project, frame) => client.frame.delete({ project, frame }),
+        listFiles: (project, path) => client.filesystem.list({
+            project,
+            ...(path === undefined ? {} : { path }),
+        }),
+        readFile: (project, path) => client.filesystem.read({ project, path }),
+        writeFile: (project, path, text) => client.filesystem.write({ project, path, text }),
+        editFile: (project, path, oldText, newText) => client.filesystem.edit({ project, path, oldText, newText }),
+        deleteFile: (project, path) => client.filesystem.delete({ project, path }),
+        screenshot: async (project, frame) => {
+            const screenshot = await client.frame.screenshot({ project, frame });
+            const response = await fetcher(screenshot.url);
+            if (!response.ok) {
+                throw new Error(`Could not read screenshot ${screenshot.url}: ${response.status} ${response.statusText}`);
+            }
+            const mediaType = response.headers
+                .get("content-type")
+                ?.split(";", 1)[0]
+                ?.trim();
+            if (mediaType !== screenshot.mediaType) {
+                throw new Error(`Screenshot ${screenshot.url} returned ${mediaType ?? "no media type"}; expected ${screenshot.mediaType}`);
+            }
+            return {
+                ...screenshot,
+                png: new Uint8Array(await response.arrayBuffer()),
+            };
+        },
+    };
+}

package/dist/mcp/file.d.ts

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

package/dist/mcp/file.js

@@ -0,0 +1,60 @@
+import { fileTextSchema } from "../v1/schemas.js";
+import { fileResult, result } from "./result.js";
+import { directoryPathSchema, fileInput, projectInput } from "./schema.js";
+export function registerFileTools(server, design, run) {
+    server.registerTool("list_files", {
+        description: "Return canonical project-absolute paths. Omit path to list the entire project; otherwise use /<frame-id> without a trailing slash. Pass returned file paths unchanged to file tools.",
+        inputSchema: projectInput.extend({
+            path: directoryPathSchema.optional(),
+        }),
+        annotations: {
+            readOnlyHint: true,
+            destructiveHint: false,
+            openWorldHint: false,
+            idempotentHint: true,
+        },
+    }, async ({ project, path }) => result(await run("list_files", () => design.listFiles(project, path))));
+    server.registerTool("read_file", {
+        description: "Read one canonical project-absolute path returned by list_files. The path includes the frame ID; this tool does not accept a frame argument. Binary files return their hosted URL and media type.",
+        inputSchema: fileInput,
+        annotations: {
+            readOnlyHint: true,
+            destructiveHint: false,
+            openWorldHint: false,
+            idempotentHint: true,
+        },
+    }, async ({ project, path }) => {
+        const file = await run("read_file", () => design.readFile(project, path));
+        return file.type === "text" ? fileResult(file) : result(file);
+    });
+    server.registerTool("write_file", {
+        description: "Create or replace one .glts file at a canonical project-absolute path. The path includes the frame ID; this tool does not accept a frame argument.",
+        inputSchema: fileInput.extend({ text: fileTextSchema }),
+        annotations: {
+            readOnlyHint: false,
+            destructiveHint: true,
+            openWorldHint: true,
+        },
+    }, async ({ project, path, text }) => result(await run("write_file", () => design.writeFile(project, path, text))));
+    server.registerTool("edit_file", {
+        description: "Replace oldText when it occurs exactly once at a canonical project-absolute .glts path. The path includes the frame ID; this tool does not accept a frame argument.",
+        inputSchema: fileInput.extend({
+            oldText: fileTextSchema.min(1),
+            newText: fileTextSchema,
+        }),
+        annotations: {
+            readOnlyHint: false,
+            destructiveHint: true,
+            openWorldHint: true,
+        },
+    }, async ({ project, path, oldText, newText }) => result(await run("edit_file", () => design.editFile(project, path, oldText, newText))));
+    server.registerTool("delete_file", {
+        description: "Permanently delete one .glts file at a canonical project-absolute path. The path includes the frame ID; this tool does not accept a frame argument.",
+        inputSchema: fileInput,
+        annotations: {
+            readOnlyHint: false,
+            destructiveHint: true,
+            openWorldHint: true,
+        },
+    }, async ({ project, path }) => result(await run("delete_file", () => design.deleteFile(project, path))));
+}

package/dist/mcp/frame.d.ts

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

package/dist/mcp/frame.js

@@ -0,0 +1,90 @@
+import { frameNameSchema, generateImageFrameSchema } from "../v1/schemas.js";
+import { base64, result } from "./result.js";
+import { createFrameSchema, frameCreationInput, frameInput, projectInput, } from "./schema.js";
+export function registerFrameTools(server, design, run) {
+    server.registerTool("list_frames", {
+        description: "List frames. Use their immutable ids for frame commands and filesystem paths.",
+        inputSchema: projectInput,
+        annotations: {
+            readOnlyHint: true,
+            destructiveHint: false,
+            openWorldHint: false,
+            idempotentHint: true,
+        },
+    }, async ({ project }) => result({
+        frames: await run("list_frames", () => design.listFrames(project)),
+    }));
+    server.registerTool("create_frame", {
+        description: "Create a frame in a Drawcall Design project. Use type=glts for reusable 3D objects and scenes, then write its source with write_file. Use type=image only for an existing public image URL and type=market only for an exact public Market asset.",
+        inputSchema: createFrameSchema,
+        annotations: {
+            readOnlyHint: false,
+            destructiveHint: false,
+            openWorldHint: true,
+            idempotentHint: false,
+        },
+    }, async (input) => result({
+        frame: await run("create_frame", () => design.createFrame(frameCreationInput(input))),
+    }));
+    server.registerTool("generate_image", {
+        description: "Generate a 2D image or reference frame from text and up to four same-project image frame references. Use only when the user asks for a 2D image, picture, concept, or reference; do not use for 3D objects, scenes, or reusable GLTS assets. For edit, target is reference 0. New frames are the default; result=replace explicitly replaces the target image while preserving its frame ID, name, and layout.",
+        inputSchema: generateImageFrameSchema,
+        annotations: {
+            readOnlyHint: false,
+            destructiveHint: true,
+            openWorldHint: true,
+            idempotentHint: false,
+        },
+    }, async (input) => result({
+        frame: await run("generate_image", () => design.generateImage(input)),
+    }));
+    server.registerTool("rename_frame", {
+        description: "Rename a frame. Its immutable frame id does not change.",
+        inputSchema: frameInput.extend({ name: frameNameSchema }),
+        annotations: {
+            readOnlyHint: false,
+            destructiveHint: false,
+            openWorldHint: false,
+        },
+    }, async ({ project, frame, name }) => result({
+        frame: await run("rename_frame", () => design.renameFrame(project, frame, name)),
+    }));
+    server.registerTool("delete_frame", {
+        description: "Permanently delete a frame.",
+        inputSchema: frameInput,
+        annotations: {
+            readOnlyHint: false,
+            destructiveHint: true,
+            openWorldHint: true,
+            idempotentHint: false,
+        },
+    }, async ({ project, frame }) => result(await run("delete_frame", () => design.deleteFrame(project, frame))));
+    server.registerTool("get_frame_screenshot", {
+        description: "Render a DPR-1 PNG screenshot of a frame.",
+        inputSchema: frameInput,
+        annotations: {
+            readOnlyHint: true,
+            destructiveHint: false,
+            openWorldHint: false,
+            idempotentHint: true,
+        },
+    }, async ({ project, frame }) => {
+        const screenshot = await run("get_frame_screenshot", () => design.screenshot(project, frame));
+        const structuredContent = {
+            url: screenshot.url,
+            width: screenshot.width,
+            height: screenshot.height,
+            mediaType: screenshot.mediaType,
+        };
+        return {
+            content: [
+                {
+                    type: "image",
+                    data: base64(screenshot.png),
+                    mimeType: screenshot.mediaType,
+                },
+            ],
+            structuredContent,
+        };
+    });
+}

package/dist/mcp/index.d.ts

@@ -0,0 +1,3 @@
+export { createDesignMcpOperations } from "./client.js";
+export { registerDesignTools } from "./register.js";
+export type { DesignMcpOperationRunner, DesignMcpOperations, DesignMcpServer, DesignMcpScreenshot, DesignMcpToolResult, } from "./types.js";

package/dist/mcp/index.js

@@ -0,0 +1,2 @@
+export { createDesignMcpOperations } from "./client.js";
+export { registerDesignTools } from "./register.js";

package/dist/mcp/project.d.ts

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

package/dist/mcp/project.js

@@ -0,0 +1,39 @@
+import { z } from "zod";
+import { projectNameSchema } from "../v1/schemas.js";
+import { result } from "./result.js";
+import { projectInput } from "./schema.js";
+export function registerProjectTools(server, design, run) {
+    server.registerTool("list_projects", {
+        description: "List projects available to the current Drawcall account.",
+        annotations: {
+            readOnlyHint: true,
+            destructiveHint: false,
+            openWorldHint: false,
+            idempotentHint: true,
+        },
+    }, async () => result({
+        projects: await run("list_projects", () => design.listProjects()),
+    }));
+    server.registerTool("create_project", {
+        description: "Create a project. Use its returned immutable id in every later call.",
+        inputSchema: z.object({ name: projectNameSchema }).strict(),
+        annotations: {
+            readOnlyHint: false,
+            destructiveHint: false,
+            openWorldHint: false,
+            idempotentHint: false,
+        },
+    }, async ({ name }) => result({
+        project: await run("create_project", () => design.createProject(name)),
+    }));
+    server.registerTool("delete_project", {
+        description: "Permanently delete a project and its frames.",
+        inputSchema: projectInput,
+        annotations: {
+            readOnlyHint: false,
+            destructiveHint: true,
+            openWorldHint: true,
+            idempotentHint: false,
+        },
+    }, async ({ project }) => result(await run("delete_project", () => design.deleteProject(project))));
+}

package/dist/mcp/register.d.ts

@@ -0,0 +1,2 @@
+import type { DesignMcpOperationRunner, DesignMcpOperations, DesignMcpServer } from "./types.js";
+export declare function registerDesignTools(server: DesignMcpServer, design: DesignMcpOperations, run?: DesignMcpOperationRunner): void;

package/dist/mcp/register.js

@@ -0,0 +1,13 @@
+import { registerFileTools } from "./file.js";
+import { registerFrameTools } from "./frame.js";
+import { registerProjectTools } from "./project.js";
+import { registerSkillTool } from "./skill.js";
+export function registerDesignTools(server, design, run = runOperation) {
+    registerSkillTool(server);
+    registerProjectTools(server, design, run);
+    registerFrameTools(server, design, run);
+    registerFileTools(server, design, run);
+}
+function runOperation(_name, operation) {
+    return operation();
+}

package/dist/mcp/result.d.ts

@@ -0,0 +1,5 @@
+import type { TextFile } from "../v1/schemas.js";
+import type { DesignMcpToolResult } from "./types.js";
+export declare function result<Structured extends Record<string, unknown>>(structuredContent: Structured): DesignMcpToolResult;
+export declare function fileResult(file: TextFile): DesignMcpToolResult;
+export declare function base64(bytes: Uint8Array): string;

package/dist/mcp/result.js

@@ -0,0 +1,18 @@
+export function result(structuredContent) {
+    return {
+        content: [{ type: "text", text: JSON.stringify(structuredContent) }],
+        structuredContent,
+    };
+}
+export function fileResult(file) {
+    return {
+        content: [{ type: "text", text: file.text }],
+    };
+}
+export function base64(bytes) {
+    let binary = "";
+    for (let offset = 0; offset < bytes.length; offset += 32_768) {
+        binary += String.fromCharCode(...bytes.subarray(offset, offset + 32_768));
+    }
+    return btoa(binary);
+}