pmx-canvas 0.3.3 → 0.3.4

package/src/server/operations/composites.ts

@@ -94,12 +94,6 @@ export interface CompositeToolDefinition {
    * raise a loud error instead of silently no-op'ing.
    */
   resolveOp?: (input: { kind: string; action: string }) => string | undefined;
-  /**
-   * Two-discriminator extension: human-readable `(kind, action)` for a member op
-   * (the inverse of `resolveOp`), used to build that op's deprecation note. The
-   * `kind` field-collision is resolved here (see `gateFieldRemap`).
-   */
-  describeOp?: (opName: string) => { kind: string; action: string } | undefined;
   /**
    * Field-name remap applied to the composite's advertised schema and undone at
    * dispatch. Resolves a collision between a discriminator name and a member-op
@@ -131,7 +125,7 @@ function resolveGateOp(input: { kind: string; action: string }): string | undefi
   return undefined;
 }
 
-/** The 9 gate ops, in (kind, action) order — single source for memberOps + describeOp. */
+/** The 9 gate ops, in (kind, action) order — single source for memberOps. */
 const GATE_OPS: Array<{ op: string; kind: string; action: string }> = GATE_KINDS.flatMap((kind) =>
   GATE_ACTIONS.map((action) => {
     const op = resolveGateOp({ kind, action });
@@ -143,11 +137,6 @@ const GATE_OPS: Array<{ op: string; kind: string; action: string }> = GATE_KINDS
   }),
 );
 
-function describeGateOp(opName: string): { kind: string; action: string } | undefined {
-  const match = GATE_OPS.find((entry) => entry.op === opName);
-  return match ? { kind: match.kind, action: match.action } : undefined;
-}
-
 export const compositeToolDefinitions: CompositeToolDefinition[] = [
   {
     toolName: 'canvas_node',
@@ -289,7 +278,6 @@ export const compositeToolDefinitions: CompositeToolDefinition[] = [
     },
     memberOps: GATE_OPS.map((entry) => entry.op),
     resolveOp: resolveGateOp,
-    describeOp: describeGateOp,
     // ax.approval.request defines its own optional `action` field (a
     // machine-readable identifier the gate guards) — it collides with the gate
     // lifecycle `action` discriminator. Namespace it to `approvalAction` in the

package/src/server/operations/invoker.ts

@@ -68,19 +68,26 @@ export class HttpOperationInvoker implements OperationInvoker {
     const response = await fetch(url, init);
     const text = await response.text();
     let parsed: unknown = null;
+    let parsedAsJson = false;
     if (text.length > 0) {
       try {
         parsed = JSON.parse(text) as unknown;
+        parsedAsJson = true;
       } catch {
         parsed = { error: text };
       }
     }
     if (!response.ok) {
-      if (route.errorBodyAsResult) return parsed;
+      // errorBodyAsResult carries the route's STRUCTURED partial-failure
+      // envelope (e.g. canvas_batch { ok:false, failedIndex, ... }) through as
+      // a result. A non-JSON error body (an HTML 502 from a proxy, a foreign
+      // service) is not that envelope — fall through to the throw path so the
+      // caller still fails loudly with a nonzero exit.
+      if (route.errorBodyAsResult && parsedAsJson) return parsed;
       const message =
-        parsed !== null && typeof parsed === 'object' && 'error' in parsed
+        parsedAsJson && parsed !== null && typeof parsed === 'object' && 'error' in parsed
           ? String((parsed as { error?: unknown }).error)
-          : `HTTP ${response.status}`;
+          : `HTTP ${response.status}${text.length > 0 ? `: ${text.slice(0, 200)}` : ''}`;
       throw new OperationError(message, toOperationErrorStatus(response.status));
     }
     return parsed;

package/src/server/operations/mcp.ts

@@ -11,7 +11,7 @@ import { z, type ZodRawShape, type ZodTypeAny } from 'zod';
 import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
 import { getOperation, listOperations } from './registry.js';
 import type { OperationInvoker } from './invoker.js';
-import { OperationError, type OperationMcpToolHost } from './types.js';
+import { OperationError, type Operation, type OperationMcpToolHost } from './types.js';
 import { compositeFoldedOpNames, compositeToolDefinitions, type CompositeToolDefinition } from './composites.js';
 
 export interface OperationToolHost extends OperationMcpToolHost {
@@ -176,6 +176,43 @@ function stripCompositeDiscriminators(
   return out;
 }
 
+/**
+ * Per-op cache of the MCP arg names its extraShape marks REQUIRED (a schema
+ * that rejects `undefined`). These are the standalone tools' old contracts,
+ * which buildCompositeShape flattens to all-optional — the composite handler
+ * re-enforces them at dispatch so a missing required field fails loudly and
+ * names the field, instead of failing deep in the handler or silently
+ * no-oping (the `q`-vs-`query` zero-results trap from the 0.3.1 test report).
+ */
+const requiredFieldsCache = new WeakMap<object, string[]>();
+
+// Advertised input aliases that satisfy a required extraShape field: the op's
+// handler accepts either name, so the pre-dispatch check must too. (The only
+// such collision across all 15 composites — edges.ts advertises `edge_id` as a
+// legacy alias for `id` and its handler reads `edge_id ?? id`.)
+const REQUIRED_FIELD_ALIASES: Record<string, Record<string, readonly string[]>> = {
+  'edge.remove': { id: ['edge_id'] },
+};
+
+function requiredFieldSatisfied(opName: string, field: string, rest: Record<string, unknown>): boolean {
+  if (rest[field] !== undefined) return true;
+  const aliases = REQUIRED_FIELD_ALIASES[opName]?.[field] ?? [];
+  return aliases.some((alias) => rest[alias] !== undefined);
+}
+
+function requiredMcpFields(op: Operation): string[] {
+  const tool = op.mcp;
+  if (!tool?.extraShape) return [];
+  let keys = requiredFieldsCache.get(tool);
+  if (!keys) {
+    keys = Object.entries(tool.extraShape)
+      .filter(([, schema]) => !(schema as ZodTypeAny).safeParse(undefined).success)
+      .map(([key]) => key);
+    requiredFieldsCache.set(tool, keys);
+  }
+  return keys;
+}
+
 /**
  * Register composite (action-discriminated) MCP tools (plan-006). Each action
  * dispatches to a registered operation, reusing that op's `mcp.buildInput` and
@@ -188,6 +225,12 @@ export function registerCompositeTools(
   definitions: CompositeToolDefinition[] = compositeToolDefinitions,
 ): void {
   for (const def of definitions) {
+    // Public composite name for each op field (inverse of fieldRemap), so
+    // required-field errors name the argument the agent actually sends.
+    const publicFieldName = new Map<string, string>();
+    for (const [publicKey, opField] of Object.entries(def.fieldRemap ?? {})) {
+      publicFieldName.set(opField, publicKey);
+    }
     server.tool(def.toolName, def.description, buildCompositeShape(def), async (input: Record<string, unknown>) => {
       try {
         const host = await getHost();
@@ -197,6 +240,13 @@ export function registerCompositeTools(
         // and undo any field remap; the rest is the op's raw MCP args — the same
         // value the standalone tool would receive.
         const rest = stripCompositeDiscriminators(def, input);
+        const missing = requiredMcpFields(op).filter((field) => !requiredFieldSatisfied(opName, field, rest));
+        if (missing.length > 0) {
+          const named = missing.map((field) => `"${publicFieldName.get(field) ?? field}"`).join(', ');
+          throw new OperationError(
+            `${def.toolName} action "${String(input.action)}" requires ${named}. Unknown parameters are ignored — check the argument names.`,
+          );
+        }
         const opInput = op.mcp?.buildInput ? op.mcp.buildInput(rest) : rest;
         const result = await host.invoker().invoke(opName, opInput);
         if (op.mcp?.formatResult) {

package/src/server/operations/ops/app.ts

@@ -405,6 +405,11 @@ const webArtifactOperation = defineOperation<z.infer<typeof webArtifactSchema>,
   http: {
     method: 'POST',
     path: '/api/canvas/web-artifact',
+    // Build failures throw OperationError, served as { ok:false, error }. The
+    // CLI prints that failure envelope on STDOUT and exits 1
+    // (cli-node.test.ts:2502-2548 pins it), so the HTTP invoker must return
+    // the non-2xx body instead of throwing — mirrors canvas.batch/webview.start.
+    errorBodyAsResult: true,
   },
   mcp: {
     toolName: 'canvas_build_web_artifact',

package/src/server/server.ts

@@ -61,6 +61,7 @@ import { resolveNodeAxCapabilities } from './ax-interaction.js';
 import { normalizeCanvasTheme, type CanvasTheme } from './canvas-db.js';
 import { validateLocalImageFile } from './image-source.js';
 import {
+  cancelCodeGraphRecompute,
   primeCanvasRuntimeBackends,
   setCanvasLayoutUpdateEmitter,
   syncCanvasRuntimeBackends,
@@ -3015,6 +3016,7 @@ export function stopCanvasServer(): void {
   intentRegistry.reset();
   canvasState.close();
   closeAllMcpAppSessions();
+  cancelCodeGraphRecompute();
   setCanvasLayoutUpdateEmitter(null);
   void closeCanvasAutomationWebViewInternal().catch((error) => {
     logWorkbenchWarning('stopCanvasServer closeCanvasAutomationWebViewInternal', error);

package/src/shared/ax-surface-protocol.ts

@@ -0,0 +1,22 @@
+/**
+ * Wire-protocol source tags for sandboxed-surface ↔ canvas postMessage traffic
+ * (plan-009 M2): one module owns the strings that used to be spread across the
+ * client node components, the server-side surface script generators, the
+ * ext-app script builders, and the json-render viewer. These are the trust
+ * boundary between opaque-origin iframes and the canvas — a typo'd tag fails
+ * SILENTLY (the listener just ignores the message), so single-siting them is a
+ * correctness measure, not cosmetics. The values are a persisted wire contract
+ * with already-generated surface documents: never change them.
+ */
+
+/** A sandboxed surface emitting an AX interaction to the parent canvas. */
+export const AX_SURFACE_EMIT_SOURCE = 'pmx-canvas-ax';
+
+/** The parent canvas acking an AX interaction back to the emitting surface (#55). */
+export const AX_SURFACE_ACK_SOURCE = 'pmx-canvas-ax-ack';
+
+/** Parent→surface pushes (theme updates, live AX state) into html/viewer iframes. */
+export const HTML_SURFACE_PUSH_SOURCE = 'pmx-canvas-html-node';
+
+/** Ext-app boot beacon: the iframe's scripts executed (WebKit watchdog liveness). */
+export const EXT_APP_BOOT_BEACON_SOURCE = 'pmx-canvas-ext-app-alive';

package/dist/types/client/canvas/ContextPinHud.d.ts

@@ -1 +0,0 @@
-export declare function ContextPinHud(): import("preact/src").JSX.Element | null;

package/src/client/canvas/ContextPinHud.tsx

@@ -1,17 +0,0 @@
-import { clearContextPins, contextPinnedNodeIds } from '../state/canvas-store';
-
-export function ContextPinHud() {
-  const count = contextPinnedNodeIds.value.size;
-  if (count === 0) return null;
-
-  return (
-    <div class="context-pin-hud">
-      <span class="context-pin-hud-label">
-        {'\u2726'} {count} in context
-      </span>
-      <button type="button" class="context-pin-hud-clear" onClick={clearContextPins} title="Clear all context pins">
-        ×
-      </button>
-    </div>
-  );
-}