Wawa
e618175bba
Wholesale swap of packages/{core,viewer,editor,mcp} and apps/editor with the
versions from the private editor repo, which is the production source of truth.
Setup changes:
- packages/{core,viewer,editor} versions held at 0.7.0 baseline (matching
the most recent published release) so a bump=minor publishes 0.8.0
- packages/mcp held at 0.1.1 (never published; first publish will go through
the new release.yml flow)
- peerDependencies and devDependencies for inter-package @pascal-app/*
references pinned to ^0.7.0 instead of '*' / 'workspace:*' so they are
valid for npm consumers
- Root package.json: TypeScript bumped to 6.0.2, added overrides for
@types/react, @types/react-dom, @types/three to prevent JSX namespace
fragmentation across the workspace
- release.yml extended to also publish editor and mcp; 'both' option renamed
to 'all'; added a sync step that updates inter-package peerDeps/devDeps to
match the new versions on every bump (so viewer/editor/mcp tarballs always
reference the version of core they were built against)
- Root scripts gained release:editor and release:mcp shortcuts
Verification:
- bun install --frozen-lockfile is consistent
- packages/{core,viewer,mcp} build cleanly, dist/index.d.ts emitted
- packages/editor check-types reports 21 pre-existing errors, identical to
what private-editor currently reports
Open PRs against editor-v2 will need rebasing/conflict resolution.
86 lines
2.8 KiB
TypeScript
86 lines
2.8 KiB
TypeScript
import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js'
|
|
import { z } from 'zod'
|
|
import type { SceneOperations } from '../../operations'
|
|
import { ErrorCode, throwMcpError } from '../errors'
|
|
import { currentLevelContext, projectStatusPayload } from './metadata'
|
|
|
|
export const createProjectInput = {
|
|
name: z.string().min(1).max(200),
|
|
id: z.string().min(1).max(64).optional(),
|
|
isPrivate: z.boolean().default(true),
|
|
}
|
|
|
|
export const createProjectOutput = {
|
|
id: z.string(),
|
|
projectId: z.string(),
|
|
name: z.string(),
|
|
editorUrl: z.string(),
|
|
url: z.string(),
|
|
ownerId: z.string().nullable(),
|
|
thumbnailUrl: z.string().nullable(),
|
|
publishedVersion: z.number().nullable(),
|
|
latestVersion: z.number().nullable(),
|
|
draftVersion: z.number().nullable(),
|
|
browserVisibleVersion: z.number().nullable(),
|
|
version: z.number(),
|
|
isEmpty: z.boolean(),
|
|
sizeBytes: z.number(),
|
|
nodeCount: z.number(),
|
|
graphHash: z.string().nullable(),
|
|
createdAt: z.string(),
|
|
updatedAt: z.string(),
|
|
levelIds: z.array(z.string()),
|
|
defaultLevelId: z.string().nullable(),
|
|
nextStep: z.string(),
|
|
}
|
|
|
|
export function registerCreateProject(server: McpServer, operations: SceneOperations): void {
|
|
server.registerTool(
|
|
'create_project',
|
|
{
|
|
title: 'Create project',
|
|
description:
|
|
'Create a browser-visible Pascal project for the authenticated user. Use this before save_scene when the user asks for a new project.',
|
|
inputSchema: createProjectInput,
|
|
outputSchema: createProjectOutput,
|
|
},
|
|
async ({ name, id, isPrivate }) => {
|
|
if (!operations.canCreateProject) {
|
|
throwMcpError(
|
|
ErrorCode.InvalidRequest,
|
|
'create_project_unavailable: this MCP store cannot create hosted projects',
|
|
)
|
|
}
|
|
try {
|
|
const status = await operations.createProject({
|
|
name,
|
|
...(id !== undefined ? { id } : {}),
|
|
isPrivate,
|
|
})
|
|
operations.setActiveScene({
|
|
id: status.id,
|
|
name: status.name,
|
|
projectId: status.projectId,
|
|
ownerId: status.ownerId,
|
|
thumbnailUrl: status.thumbnailUrl,
|
|
version: status.version,
|
|
})
|
|
const payload = {
|
|
...projectStatusPayload(
|
|
status,
|
|
'The project is now bound to this MCP session. Open editorUrl now; semantic tools will update the browser-visible draft. Call save_scene with saveMode: "checkpoint" only when you want a meaningful version.',
|
|
),
|
|
...currentLevelContext(operations),
|
|
}
|
|
return {
|
|
content: [{ type: 'text' as const, text: JSON.stringify(payload) }],
|
|
structuredContent: payload,
|
|
}
|
|
} catch (err) {
|
|
const msg = err instanceof Error ? err.message : String(err)
|
|
throwMcpError(ErrorCode.InvalidRequest, msg)
|
|
}
|
|
},
|
|
)
|
|
}
|