Power your agent
คำสั่งของผู้เผยแพร่เอง ไม่ใช่เอนด์พอยต์ของ PlugMCP
Host a copy with our keys and logs.
npx -y @pascal-app/[email protected]Claude Code ไม่มีลิงก์ติดตั้งสำหรับคำสั่งแบบโลคัล ให้คัดลอกคำสั่งด้านล่างแล้วรันในเทอร์มินัล
claude mcp add pascal-app-cli -- npx -y @pascal-app/cli@1.1.4รันในเทอร์มินัล
{ "mcpServers": { "pascal-app-cli": { "command": "npx", "args": [ "-y", "@pascal-app/[email protected]" ] } }}claude_desktop_config.json
URL แบบรีโมตหรือคำสั่งบนเครื่องของคุณ? การติดตั้งสองแบบต่างกันอย่างไร
รันบน PlugMCP
A new server you create. It is not this listing's official endpoint. Use the publisher install when you want their URL and their credentials.
เปิดExplore the live demo — a real home reconstructed in detail, from its rooms and finishes to the structure and systems behind the walls. This hosted preview explores the direction of the next Pascal editor; the experience shown here is not yet part of the open-source editor release.
| Exploded view — see how the home fits together | Cut view — slice through the building |
|---|---|
 |  |
| X-ray — reveal the modeled systems | Walkthrough — step inside at eye level |
 |  |
| Interactions — open doors and explore | Environment — change the light and atmosphere |
 |  |
We are exploring what this could make possible for facility management, home services, architecture, home building, and infrastructure. Join the discussion on X and tell us where you would use it.
Making a video, tutorial, article, or social post about Pascal? You are welcome to use and edit this footage, including in monetized content, under CC BY 4.0. Credit Pascal, link the license, and note your edits; no separate permission is needed.
Node.js 22.23.4+ on 22.x, 24.22.1+ on 24.x, or 26.12.1+ can create a persistent local Pascal installation without cloning this repository:
npx @pascal-app/cli editor
The CLI starts the editor and an authenticated MCP service in the background, selects
collision-free loopback ports, and keeps projects in ~/.pascal/data/pascal.db. The npm
package holds the CLI and that MCP service; the web editor runtime is downloaded once per
version on the first command that starts the editor and verified against a digest published
inside the package. Configure an agent to launch pascal mcp connect, which needs neither
the editor process nor that download. Install the pascal command with
npm install --global @pascal-app/cli. See Run Pascal locally
for pnpm/Bun commands, project management, MCP setup, updates, storage paths, and
troubleshooting.
Use one active agent client per local CLI service. The standalone local HTTP runtime shares active scene state between clients; use separate PASCAL_HOME directories and service processes when independent concurrent work is required.
The editor ships as one container, ghcr.io/pascalorg/pascal-editor, tagged with the
same version as the npm packages (latest follows stable releases). Projects live in
SQLite under /data; one admin password protects the instance; PASCAL_PUBLIC_URL is
read at runtime, so the same image serves any domain.
docker run -d -p 3000:3000 -v pascal-data:/data \
-e PASCAL_ADMIN_PASSWORD=change-me \
-e PASCAL_PUBLIC_URL=https://pascal.example.com \
ghcr.io/pascalorg/pascal-editor:latest
See SETUP.md, "Self-hosting" for the compose file, the variables, agent access and public embeds.
Install Pascal's public agent workflows from this repository with skills.sh:
npx skills add pascalorg/editor \
--skill pascal-3d \
--skill furniture-fit
Claude Code users can install the same canonical skill source as a plugin:
/plugin marketplace add pascalorg/editor
/plugin install pascal-agent-skills@pascal
The Claude plugin also supplies the local pascal mcp connect server. Install and start the Pascal CLI first, and keep pascal on the PATH used to launch Claude Code. This local connector needs no Pascal account or API key and does not upload projects automatically. Its plugin root is this repository's skills/ directory, so an install copies only the skill bundles and their plugin metadata rather than the repository.
The plugin bundles two servers: the local pascal connector above and a hosted pascal-hosted server for https://editor.pascal.app/api/mcp, which prompts for an optional Pascal API key at enable time and stores it in the OS keychain. Leave the key empty to run local-only.
Claude Code 2.1.258 loads both the user-scoped pascal server created by pascal mcp setup claude and the plugin-provided server. Remove the manual entry before reloading or restarting Claude Code so only the plugin owns the connection lifecycle:
claude mcp remove --scope user pascal
Use /mcp to remove or disable any project- or local-scoped Pascal connection too. Leaving both connections active violates the one-active-agent-client-per-local-service requirement. When the intended project is hosted in a Pascal account or organization, disable the plugin-provided local server in /mcp and configure the hosted endpoint from the skill setup guide instead.
Codex users can install the same plugin from the repository marketplace:
codex plugin marketplace add pascalorg/editor
codex plugin add pascal-agent-skills@pascal
OpenClaw installation becomes available after the skills are published under Pascal's ClawHub publisher. See skills/README.md for the owner-qualified install and verification commands.
pascal-3d covers safe local or hosted MCP setup and verified scene work. furniture-fit produces a bounded, evidence-based footprint assessment without claiming unsupported height, swing, or delivery checks. See skills/README.md for package details and validation.
The skills inspect the connected MCP tool schemas before using optional fields. A capability present in this repository may be absent from an older installed or hosted release; the agent should report the narrower supported result instead of assuming source-only inputs are available.
These workflows require a connected Pascal MCP server for their tool-backed actions. An OpenAI directory submission must therefore use With MCP and submit the production hosted MCP endpoint together with the skills. The repository package does not prove that the endpoint, OAuth flow, reviewer credentials, domain verification, or portal scan is ready for review.
Also listed on Smithery.
server.json is Pascal's manifest for the official MCP Registry, named
app.pascal/editor. It lists the @pascal-app/mcp npm package and the hosted Streamable HTTP
endpoint, which signs in with OAuth. Its version is the @pascal-app/mcp package version:
bun scripts/sync-agent-versions.ts rewrites it, and the Cursor plugin's CLI pin, from the
package versions, and CI fails when they drift. Each stable release publishes it to the registry
after npm has the package. The signing key is CI's own pascal.app DNS key, stored only as a secret of
the mcp-registry environment (limited to main), never as a repository secret; see
wiki/npm-release.md.
The viewer runtime and built-in node definitions are separate packages. Install the full built-in
viewer set, then load the built-in plugin once before mounting <Viewer>. Capture sessions are an
optional extension shipped inside those packages as the @pascal-app/core/capture and
@pascal-app/viewer/capture subpaths:
npm install @pascal-app/core @pascal-app/viewer @pascal-app/editor @pascal-app/nodes
import { loadPlugin } from '@pascal-app/core'
import { builtinPlugin } from '@pascal-app/nodes'
await loadPlugin(builtinPlugin)
See the @pascal-app/viewer quick start for a React example,
and @pascal-app/editor to embed the full editor: its loading
surface, tool-menu placement, light or dark chrome, views and selection helpers.
This is a Turborepo monorepo with the reusable editor packages, the standalone app, and the CLI that distributes it:
editor/
├── apps/
│ └── editor/ # Next.js application
├── packages/
│ ├── core/ # Schemas, scene state, registry contracts, capture contracts
│ ├── viewer/ # 3D rendering runtime, shared systems, capture runtime
│ ├── editor/ # Editing tools and UI components
│ ├── nodes/ # Built-in node definitions, renderers, and systems
│ ├── cli/ # Persistent local editor installer and process manager
│ ├── mcp/ # Model Context Protocol server and scene storage
│ └── ui/ # Shared UI components
The viewer renders the scene with sensible defaults. The editor extends it with interactive tools, selection management, and editing capabilities.
Each package has its own Zustand store for managing state:
Access patterns:
// Subscribe to state changes (React component)
const nodes = useScene((state) => state.nodes)
const levelId = useViewer((state) => state.selection.levelId)
const activeTool = useEditor((state) => state.tool)
// Access state outside React (callbacks, systems)
const node = useScene.getState().nodes[id]
useViewer.getState().setSelection({ levelId: 'level_123' })
Nodes are the data primitives that describe the 3D scene. All nodes extend BaseNode:
BaseNode {
id: string // Auto-generated with type prefix (e.g., "wall_abc123")
type: string // Discriminator for type-safe handling
parentId: string | null // Parent node reference
visible: boolean
camera?: Camera // Optional saved camera position
metadata?: JSON // Arbitrary metadata (e.g., { isTransient: true })
}
Node Hierarchy:
Site
└── Building
└── Level
├── Wall → Item (doors, windows)
├── Slab
├── Ceiling → Item (lights)
├── Roof
├── Zone
├── Scan (3D reference)
└── Guide (2D reference)
Nodes are stored in a flat dictionary (Record<id, Node>), not a nested tree. Parent-child relationships are defined via parentId and children arrays.
The scene is managed by a Zustand store in @pascal-app/core:
useScene.getState() = {
nodes: Record<id, AnyNode>, // All nodes
rootNodeIds: string[], // Top-level nodes (sites)
dirtyNodes: Set<string>, // Nodes pending system updates
createNode(node, parentId),
updateNode(id, updates),
deleteNode(id),
}
Middleware:
The registry maps node IDs to their Three.js objects for fast lookup:
sceneRegistry = {
nodes: Map<id, Object3D>, // ID → 3D object
byType: {
wall: Set<id>,
item: Set<id>,
zone: Set<id>,
// ...
}
}
Renderers register their refs using the useRegistry hook:
const ref = useRef<Mesh>(null!)
useRegistry(node.id, 'wall', ref)
This allows systems to access 3D objects directly without traversing the scene graph.
Renderers are React components that create Three.js objects for each node type:
SceneRenderer
└── NodeRenderer (dispatches by type)
├── BuildingRenderer
├── LevelRenderer
├── WallRenderer
├── SlabRenderer
├── ZoneRenderer
├── ItemRenderer
└── ...
Pattern:
useRegistryExample (simplified):
const WallRenderer = ({ node }) => {
const ref = useRef<Mesh>(null!)
useRegistry(node.id, 'wall', ref)
return (
<mesh ref={ref}>
<boxGeometry args={[0, 0, 0]} /> {/* Replaced by WallSystem */}
<meshStandardMaterial />
{node.children.map(id => <NodeRenderer key={id} nodeId={id} />)}
</mesh>
)
}
Systems are React components that run in the render loop (useFrame) to update geometry and transforms. They process dirty nodes marked by the store.
Core Systems (in @pascal-app/core):
Viewer Systems (in @pascal-app/viewer):
Processing Pattern:
useFrame(() => {
for (const id of dirtyNodes) {
const obj = sceneRegistry.nodes.get(id)
const node = useScene.getState().nodes[id]
// Update geometry, transforms, etc.
updateGeometry(obj, node)
dirtyNodes.delete(id)
}
})
When a node changes, it's marked as dirty in useScene.getState().dirtyNodes. Systems check this set each frame and only recompute geometry for dirty nodes.
// Automatic: createNode, updateNode, deleteNode mark nodes dirty
useScene.getState().updateNode(wallId, { thickness: 0.2 })
// → wallId added to dirtyNodes
// → WallSystem regenerates geometry next frame
// → wallId removed from dirtyNodes
Manual marking:
useScene.getState().dirtyNodes.add(wallId)
Inter-component communication uses a typed event emitter (mitt):
// Node events
emitter.on('wall:click', (event) => { ... })
emitter.on('item:enter', (event) => { ... })
emitter.on('zone:context-menu', (event) => { ... })
// Grid events (background)
emitter.on('grid:click', (event) => { ... })
// Event payload
NodeEvent {
node: AnyNode
position: [x, y, z]
localPosition: [x, y, z]
normal?: [x, y, z]
stopPropagation: () => void
}
Handles collision detection and placement validation:
spatialGridManager.canPlaceOnFloor(levelId, position, dimensions, rotation)
spatialGridManager.canPlaceOnWall(wallId, t, height, dimensions)
spatialGridManager.getSlabElevationAt(levelId, x, z)
Used by item placement tools to validate positions and calculate slab elevations.
The editor extends the viewer with:
Tools are activated via the toolbar and handle user input for specific operations:
The editor uses a custom selection manager with hierarchical navigation:
Site → Building → Level → Zone → Items
Each depth level has its own selection strategy for hover/click behavior.
ZoneSystem - Controls zone visibility based on level modeUser Action (click, drag)
↓
Tool Handler
↓
useScene.createNode() / updateNode()
↓
Node added/updated in store
Node marked dirty
↓
React re-renders NodeRenderer
useRegistry() registers 3D object
↓
System detects dirty node (useFrame)
Updates geometry via sceneRegistry
Clears dirty flag
The editor is extensible: a plugin ships node kinds (schema, 3D/2D rendering, placement tools, inspector parametrics) and left-rail panels through the same Plugin manifest the built-ins use — there is no separate internal API.
Plugin shape, panel contributions, discovery, lifecycle, and what's in/out of v1.pascalorg/plugin-trees: a standalone plugin with procedural trees, flowers, grass, and a presets panel. Clone it as a starting point.Run the development server from the root directory to enable hot reload for all packages:
# Install dependencies
bun install
# Run development server (builds packages + starts editor with watch mode)
bun dev
# This will:
# 1. Build @pascal-app/core and @pascal-app/viewer
# 2. Start watching both packages for changes
# 3. Start the Next.js editor dev server
# Open http://localhost:3002
Important: Always run bun dev from the root directory to ensure the package watchers are running. This enables hot reload when you edit files in packages/core/src/ or packages/viewer/src/.
# Build all packages
turbo build
# Build specific package
turbo build --filter=@pascal-app/core
Releases run from .github/workflows/release.yml (workflow_dispatch, with
bump and dry-run inputs). Every package shares one version: the workflow
bumps all eight, rewrites the internal @pascal-app/* ranges, checks that each
one already exists on npm (a package never published fails the run before
anything is built), builds, publishes in dependency order (core →
geometry-script → viewer → editor → nodes → mcp → ifc-converter →
cli), then commits the release and pushes one tag per package with the release
deploy key, which the main ruleset lets through. A dry run validates the builds
without touching the registry. Releasing to npm covers
authentication, adding a package, the deploy key, recovering a partial run,
publishing by hand and the follow-ups.
Bug fixes, features, docs and ideas are all welcome. Start with CONTRIBUTING.md for setup, code style and the PR flow.
pascalorg/plugin-trees is a worked example
Run the open-source Pascal 3D editor, local projects, and MCP agent tools from your terminal
{ "mcpServers": { "pascal-app-cli": { "command": "npx", "args": [ "-y", "@pascal-app/[email protected]" ] } }}เครื่องมือ
ยังไม่มีรายการเครื่องมือ เซิร์ฟเวอร์แบบรีโมตจะได้รายการหลังการตรวจสอบสถานะครั้งแรก
FAQ
คัดลอกคอนฟิก stdio สำหรับ Cursor, Claude Desktop, Claude Code หรือ VS Code ได้ในหน้านี้ คอนฟิกนี้ใช้การติดตั้งของผู้เผยแพร่ ไม่ใช่พร็อกซีของ PlugMCP
ระเบียนนี้ไม่ได้ระบุตัวแปรสภาพแวดล้อมที่จำเป็น
@pascal App/cli ทำงานแบบโลคัลผ่าน stdio
ตรวจสอบล่าสุดเมื่อ 2026-11-15 Run the open-source Pascal 3D editor, local projects, and MCP agent tools from your terminal