@1agh/maude 0.30.0 → 0.32.0

package/apps/studio/acp/transcript.ts

@@ -0,0 +1,149 @@
+// Repo-level chat transcripts (`<designRoot>/_chat/<chatId>.jsonl`). The bridge
+// appends raw per-update lines; these readers turn them into the chat list (for
+// the switcher) and clean per-turn messages (for hydrating the thread on open).
+
+import { existsSync, readdirSync, readFileSync, rmSync, statSync } from 'node:fs';
+import { join } from 'node:path';
+
+export interface ChatSummary {
+  id: string;
+  title: string;
+  updated: number; // mtime ms
+}
+
+export interface ChatMessagePart {
+  type: 'text' | 'tool';
+  text?: string;
+  toolName?: string;
+  done?: boolean;
+}
+export interface ChatMessage {
+  role: 'user' | 'assistant';
+  parts: ChatMessagePart[];
+}
+
+function chatDir(designRoot: string): string {
+  return join(designRoot, '_chat');
+}
+
+function readLines(file: string): Array<Record<string, unknown>> {
+  try {
+    return readFileSync(file, 'utf8')
+      .split('\n')
+      .filter(Boolean)
+      .map((l) => {
+        try {
+          return JSON.parse(l) as Record<string, unknown>;
+        } catch {
+          return null;
+        }
+      })
+      .filter((x): x is Record<string, unknown> => x !== null);
+  } catch {
+    return [];
+  }
+}
+
+/** First user line, truncated — the chat's display title. */
+function deriveTitle(lines: Array<Record<string, unknown>>): string {
+  const firstUser = lines.find((l) => l.role === 'user' && typeof l.text === 'string');
+  const text = (firstUser?.text as string) ?? '';
+  const trimmed = text.replace(/\s+/g, ' ').trim();
+  return trimmed ? trimmed.slice(0, 60) : 'New chat';
+}
+
+/** List chats newest-first. */
+export function listChats(designRoot: string): ChatSummary[] {
+  const dir = chatDir(designRoot);
+  if (!existsSync(dir)) return [];
+  const out: ChatSummary[] = [];
+  for (const name of readdirSync(dir)) {
+    if (!name.endsWith('.jsonl')) continue;
+    const file = join(dir, name);
+    let updated = 0;
+    try {
+      updated = statSync(file).mtimeMs;
+    } catch {
+      /* skip unreadable */
+    }
+    const lines = readLines(file);
+    if (lines.length === 0) continue;
+    out.push({ id: name.replace(/\.jsonl$/, ''), title: deriveTitle(lines), updated });
+  }
+  return out.sort((a, b) => b.updated - a.updated);
+}
+
+/** Delete a chat's transcript. Returns true if a file was removed. */
+export function deleteChat(designRoot: string, chatId: string): boolean {
+  const file = join(chatDir(designRoot), `${chatId}.jsonl`);
+  if (!existsSync(file)) return false;
+  try {
+    rmSync(file);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * Convert the raw transcript into clean per-turn messages: user lines become
+ * user messages; the agent updates between them aggregate into one assistant
+ * message (text + tool parts; `available_commands_update` / `usage_update` /
+ * thoughts dropped — chrome noise, not the conversation).
+ */
+export function readChatMessages(designRoot: string, chatId: string): ChatMessage[] {
+  const file = join(chatDir(designRoot), `${chatId}.jsonl`);
+  if (!existsSync(file)) return [];
+  const lines = readLines(file);
+  const messages: ChatMessage[] = [];
+  let assistant: ChatMessage | null = null;
+  const toolIndex = new Map<string, number>();
+
+  const flush = () => {
+    if (assistant?.parts.length) messages.push(assistant);
+    assistant = null;
+    toolIndex.clear();
+  };
+
+  for (const line of lines) {
+    if (line.role === 'user' && typeof line.text === 'string') {
+      flush();
+      messages.push({ role: 'user', parts: [{ type: 'text', text: line.text }] });
+      continue;
+    }
+    if (line.role === 'stop') {
+      flush();
+      continue;
+    }
+    if (line.role !== 'agent') continue;
+    const update = line.update as Record<string, unknown> | undefined;
+    if (!update) continue;
+    if (!assistant) assistant = { role: 'assistant', parts: [] };
+    const kind = update.sessionUpdate;
+    if (kind === 'agent_message_chunk') {
+      const content = update.content as { type?: string; text?: string } | undefined;
+      if (content?.type !== 'text' || typeof content.text !== 'string') continue;
+      const last = assistant.parts[assistant.parts.length - 1];
+      if (last && last.type === 'text') last.text = (last.text ?? '') + content.text;
+      else assistant.parts.push({ type: 'text', text: content.text });
+    } else if (kind === 'tool_call') {
+      const id = String(update.toolCallId ?? '');
+      toolIndex.set(id, assistant.parts.length);
+      assistant.parts.push({
+        type: 'tool',
+        toolName: String(update.title ?? update.kind ?? 'tool'),
+        done: false,
+      });
+    } else if (kind === 'tool_call_update') {
+      const id = String(update.toolCallId ?? '');
+      const idx = toolIndex.get(id);
+      const status = update.status;
+      if (idx != null && (status === 'completed' || status === 'failed')) {
+        const part = assistant.parts[idx];
+        if (part) part.done = true;
+      }
+    }
+  }
+  flush();
+  return messages;
+}

package/apps/studio/annotations-layer.tsx

@@ -161,6 +161,7 @@ import {
   uploadAsset,
   useCanvasMediaDrop,
 } from './use-canvas-media-drop.tsx';
+import { useChromeVisibility } from './use-chrome-visibility.tsx';
 import { useCollab } from './use-collab.tsx';
 import { useSelectionSetOptional } from './use-selection-set.tsx';
 import { type ShapeKind, useToolMode } from './use-tool-mode.tsx';
@@ -720,7 +721,11 @@ export function AnnotationsLayer() {
   const vpRef = useRef(vp);
   vpRef.current = vp;
   const visibilityCtx = useAnnotationsVisibility();
-  const visible = visibilityCtx?.visible ?? true;
+  const chrome = useChromeVisibility();
+  // Presentation Mode hides annotations without mutating the user's own
+  // visibility toggle — render/input gate folds `present` in, the stored value
+  // (visibilityCtx.visible) is left untouched so exiting restores it.
+  const visible = (visibilityCtx?.visible ?? true) && !(chrome?.present ?? false);
   const setVisible = useCallback(
     (next: boolean | ((cur: boolean) => boolean)) => {
       if (!visibilityCtx) return;

package/apps/studio/api.ts

@@ -3,7 +3,7 @@
 
 import crypto from 'node:crypto';
 import type { Dirent } from 'node:fs';
-import { mkdir, readdir, readFile, rename, stat as statp } from 'node:fs/promises';
+import { mkdir, readdir, readFile, rename, rm, stat as statp } from 'node:fs/promises';
 import path from 'node:path';
 
 import { renderBriefBoard, validateCanvasName } from './canvas-create.ts';
@@ -15,7 +15,10 @@ import {
 } from './canvas-edit.ts';
 import type { Context } from './context.ts';
 
-const SKIP_DIRS = new Set([
+// Directories that never hold user-facing canvases. Exported so the
+// external-canvas watcher (`canvas-list-watch.ts`) shares one source instead of
+// a hand-synced copy. (activity.ts still carries its own historical mirror.)
+export const SKIP_DIRS = new Set([
   'node_modules',
   '.git',
   '.next',
@@ -62,6 +65,31 @@ export async function findHtmlFiles(absRoot: string, prefixUnderRepo: string): P
   return out;
 }
 
+/**
+ * Canonical canvas slug from a (repo- or design-root-relative) canvas path.
+ * Pure — the `fileSlug` closure inside `createApi` delegates here, and the
+ * external-canvas watcher (`canvas-list-watch.ts`) imports it so both creation
+ * paths derive identical `canvas-list-update` slugs. Strips an optional
+ * `<designRel>/` prefix, then `/`→`-`, whitespace→`_`, drops the `.tsx`/`.html`
+ * extension, and lowercases.
+ */
+export function canvasSlugFromRel(file: string, designRel: string): string {
+  let p = String(file).replace(/^\/+|\/+$/g, '');
+  try {
+    p = decodeURIComponent(p);
+  } catch {
+    /* ignore */
+  }
+  const prefix = `${designRel.replace(/^\/+|\/+$/g, '')}/`;
+  if (p.startsWith(prefix)) p = p.slice(prefix.length);
+  return p
+    .replace(/\//g, '-')
+    .replace(/\s+/g, '_')
+    .replace(/\.(tsx|html)$/i, '')
+    .replace(/^\.+/, '')
+    .toLowerCase();
+}
+
 async function findFiles(absRoot: string, prefix: string, exts: string[]): Promise<string[]> {
   const out: string[] = [];
   let entries: Dirent[];
@@ -328,20 +356,7 @@ export function createApi(ctx: Context, hooks: ApiHooks): Api {
   const { paths, cfg } = ctx;
 
   function fileSlug(file: string): string {
-    let p = String(file).replace(/^\/+|\/+$/g, '');
-    try {
-      p = decodeURIComponent(p);
-    } catch {
-      /* ignore */
-    }
-    const prefix = `${paths.designRel.replace(/^\/+|\/+$/g, '')}/`;
-    if (p.startsWith(prefix)) p = p.slice(prefix.length);
-    return p
-      .replace(/\//g, '-')
-      .replace(/\s+/g, '_')
-      .replace(/\.(tsx|html)$/i, '')
-      .replace(/^\.+/, '')
-      .toLowerCase();
+    return canvasSlugFromRel(file, paths.designRel);
   }
 
   async function fileForSlug(slug: string): Promise<string | null> {
@@ -637,21 +652,28 @@ export function createApi(ctx: Context, hooks: ApiHooks): Api {
     }
   }
 
-  // ---------- Canvas meta sidecar (Phase 4 T5) ----------
+  // ---------- Canvas meta sidecar (Phase 4 T5; split DDR-115) ----------
   //
   // Each canvas under `<designRoot>/ui/<name>.tsx` has a sibling
-  // `<name>.meta.json`. Phase 4 stores `layout` (per-artboard world-coord
-  // rects) and `viewport` (last pan/zoom) inside that file so the canvas
-  // runtime can restore state on reload. The PATCH path is intentionally
-  // merge-shallow on top-level keys — never clobber `title`, `sections`,
-  // `ai_context`, or any other authoring metadata.
+  // `<name>.meta.json` — the SHARED, versioned document (title, sections,
+  // `layout` per-artboard world-coord rects, css_mode, …). The PATCH path is
+  // intentionally merge-shallow on top-level keys — never clobber `title`,
+  // `sections`, `ai_context`, or any other authoring metadata.
+  //
+  // DDR-115 — the PER-USER camera (`viewport` pan/zoom) NO LONGER lives in
+  // `.meta.json`. It churns on every mouse pan/zoom, so persisting it inline
+  // dirtied a tracked file. It now lives in a gitignored per-machine view file
+  // (`canvasViewPath` below). PATCH splits the lanes (viewport → view file,
+  // layout → meta); GET merges them back so the client (`window.__canvas_meta__`)
+  // is unchanged. `last_modified` is stamped into meta ONLY on a real shared
+  // (layout) change — never on a viewport-only patch.
 
   /**
-   * Resolve `file` (a path relative to repoRoot like `.design/ui/Foo.tsx`)
-   * into the absolute path of its sibling `.meta.json` sidecar. Refuses
-   * paths that escape repoRoot.
+   * Resolve `file` (a path relative to repoRoot like `.design/ui/Foo.tsx`) into
+   * the absolute path of the canvas SOURCE file. Refuses traversal, paths that
+   * escape repoRoot, and non-canvas extensions. Returns null on rejection.
    */
-  function canvasMetaPath(file: string): string | null {
+  function canvasSourceAbs(file: string): string | null {
     let p = String(file).replace(/^\/+/, '');
     try {
       p = decodeURIComponent(p);
@@ -663,29 +685,133 @@ export function createApi(ctx: Context, hooks: ApiHooks): Api {
     if (!abs.startsWith(`${paths.repoRoot}/`)) return null;
     const ext = path.extname(abs).toLowerCase();
     if (ext !== '.tsx' && ext !== '.html') return null;
-    return abs.replace(/\.(tsx|html)$/i, '.meta.json');
+    return abs;
+  }
+
+  /**
+   * Resolve `file` into the absolute path of its sibling `.meta.json` sidecar.
+   * Same containment guard as `canvasSourceAbs` (refuses paths that escape
+   * repoRoot / non-canvas extensions).
+   */
+  function canvasMetaPath(file: string): string | null {
+    const abs = canvasSourceAbs(file);
+    return abs ? abs.replace(/\.(tsx|html)$/i, '.meta.json') : null;
+  }
+
+  // ---------- Per-machine canvas view / camera (DDR-115) ----------
+  //
+  // The canvas pan/zoom ("camera") is PER-USER runtime state, separate from the
+  // shared `.meta.json` document. It lives in `_canvas-state/<slug>.view.json`
+  // ({ viewport }) — gitignored, swept on delete, export-excluded. DISTINCT from
+  // the legacy `_canvas-state/<slug>.json` ({ sections, viewport:{x,y,scale} })
+  // store: that uses `scale` clamped 0.05–8, this uses `zoom` clamped 0.1–4, so
+  // overloading one file would let the two writers clobber each other's shape.
+
+  /** Validate a candidate viewport — finite x/y, zoom clamped [0.1, 4] (the
+   *  Phase 4 rule). Returns the normalized viewport, or null when invalid. */
+  function normalizeViewport(v: unknown): { x: number; y: number; zoom: number } | null {
+    if (!v || typeof v !== 'object' || Array.isArray(v)) return null;
+    const vv = v as { x?: unknown; y?: unknown; zoom?: unknown };
+    if (
+      Number.isFinite(vv.x as number) &&
+      Number.isFinite(vv.y as number) &&
+      Number.isFinite(vv.zoom as number)
+    ) {
+      const zoom = Math.min(4, Math.max(0.1, vv.zoom as number));
+      return { x: vv.x as number, y: vv.y as number, zoom };
+    }
+    return null;
+  }
+
+  /** Per-machine view file for a canvas: `_canvas-state/<slug>.view.json`. Gated
+   *  by the same containment guard as the meta sidecar (traversal / repoRoot /
+   *  canvas-ext). Returns null when `file` is not a valid canvas path. */
+  function canvasViewPath(file: string): string | null {
+    if (!canvasMetaPath(file)) return null; // reuse the containment + ext gate
+    return path.join(paths.canvasStateDir, `${fileSlug(file)}.view.json`);
+  }
+
+  async function loadCanvasView(
+    file: string
+  ): Promise<{ viewport?: { x: number; y: number; zoom: number } } | null> {
+    const viewAbs = canvasViewPath(file);
+    if (!viewAbs) return null;
+    try {
+      const obj = JSON.parse(await Bun.file(viewAbs).text());
+      if (obj && typeof obj === 'object' && !Array.isArray(obj)) {
+        const vp = normalizeViewport((obj as { viewport?: unknown }).viewport);
+        return vp ? { viewport: vp } : {};
+      }
+      return null;
+    } catch {
+      return null;
+    }
+  }
+
+  /** Persist the per-user camera. Validates + clamps; best-effort (mkdir the
+   *  bucket if absent). Returns the normalized viewport on write, null when the
+   *  path is rejected or the viewport is invalid (no write). */
+  async function saveCanvasView(
+    file: string,
+    viewport: unknown
+  ): Promise<{ x: number; y: number; zoom: number } | null> {
+    const viewAbs = canvasViewPath(file);
+    if (!viewAbs) return null;
+    const vp = normalizeViewport(viewport);
+    if (!vp) return null;
+    try {
+      await mkdir(paths.canvasStateDir, { recursive: true });
+      await Bun.write(viewAbs, `${JSON.stringify({ viewport: vp }, null, 2)}\n`);
+      return vp;
+    } catch {
+      return null;
+    }
   }
 
   async function loadCanvasMeta(file: string): Promise<Record<string, unknown> | null> {
     const metaAbs = canvasMetaPath(file);
     if (!metaAbs) return null;
+    let obj: Record<string, unknown> = {};
+    let hadMeta = false;
     try {
-      const raw = await Bun.file(metaAbs).text();
-      const obj = JSON.parse(raw);
-      return obj && typeof obj === 'object' && !Array.isArray(obj)
-        ? (obj as Record<string, unknown>)
-        : null;
+      const parsed = JSON.parse(await Bun.file(metaAbs).text());
+      if (parsed && typeof parsed === 'object' && !Array.isArray(parsed)) {
+        obj = parsed as Record<string, unknown>;
+        hadMeta = true;
+      }
     } catch {
-      return null;
+      // No meta on disk — fall through to a possible view-only result.
     }
+    // DDR-115 — never surface the per-user camera or the local write-timestamp
+    // from the on-disk meta: `viewport` is stale (the live camera lives in the
+    // view file), `last_modified` is local bookkeeping. Strip both, then overlay
+    // the current camera so the shell's `window.__canvas_meta__.viewport` still
+    // restores on reload — the client stays unchanged. (`= undefined` over
+    // `delete` — JSON.stringify/Response.json drop undefined keys, matching the
+    // codebase convention + biome's noDelete.)
+    obj.viewport = undefined;
+    obj.last_modified = undefined;
+    const view = await loadCanvasView(file);
+    if (view?.viewport) obj.viewport = view.viewport;
+    // Preserve the historic contract: no meta AND no camera → null (GET → {},
+    // PATCH-on-rejected-path → 404). A view-only canvas still returns its camera.
+    if (!hadMeta && !view?.viewport) return null;
+    return obj;
   }
 
   /**
-   * Shallow-merge `patch` onto the existing meta sidecar and write back. Only
-   * the Phase 4 keys `layout` + `viewport` are accepted from untrusted clients;
-   * the rest of meta (title, sections, brief, ai_context, …) is preserved.
-   * Returns the merged meta on success, null when the canvas has no meta or
-   * the patch is rejected.
+   * Apply a `patch` from the (untrusted) client, splitting the two lanes
+   * (DDR-115):
+   *   - `viewport` → the per-machine view file (`saveCanvasView`); NEVER the
+   *     versioned meta. A viewport-only patch leaves `.meta.json` byte-unchanged
+   *     (no `last_modified` bump) — this is the mouse-move churn killer.
+   *   - `layout`   → the shared `.meta.json`, shallow-merged so `title`,
+   *     `sections`, `ai_context`, … are preserved; `last_modified` is stamped
+   *     ONLY here (a real shared change the user wants committable).
+   * Returns the same coherent object a GET would produce (shared meta + camera),
+   * or null only when the path itself is rejected (traversal / bad ext) so the
+   * route maps it to 404. A viewport-only patch on a canvas that has no meta yet
+   * still succeeds (writes only the view file) and returns `{ viewport }`.
    */
   async function patchCanvasMeta(
     file: string,
@@ -694,43 +820,63 @@ export function createApi(ctx: Context, hooks: ApiHooks): Api {
     const metaAbs = canvasMetaPath(file);
     if (!metaAbs) return null;
     if (!patch || typeof patch !== 'object' || Array.isArray(patch)) return null;
-    let current: Record<string, unknown> = {};
-    try {
-      const raw = await Bun.file(metaAbs).text();
-      const parsed = JSON.parse(raw);
-      if (parsed && typeof parsed === 'object' && !Array.isArray(parsed)) {
-        current = parsed as Record<string, unknown>;
+
+    // DDR-115 security (F-A2) — the PATCH lanes are reachable from the untrusted
+    // canvas origin (DDR-054). Refuse to mint per-canvas state (view file or
+    // `.meta.json`) for a canvas that doesn't exist, so a malicious origin can't
+    // spray arbitrary-slug files/inodes via fabricated `file` paths. A valid
+    // patch only ever targets a canvas the user actually has; `.meta.json` may
+    // still be absent (first layout/viewport write), but the source must exist.
+    const srcAbs = canvasSourceAbs(file);
+    if (!srcAbs || !(await Bun.file(srcAbs).exists())) return null;
+
+    // --- Per-user camera lane: viewport → view file, never the versioned meta.
+    if (patch.viewport !== undefined) {
+      if (patch.viewport === null) {
+        // Explicit clear — best-effort remove the view file.
+        const viewAbs = canvasViewPath(file);
+        if (viewAbs) {
+          try {
+            await rm(viewAbs);
+          } catch {
+            /* absent / unreadable — nothing to clear */
+          }
+        }
+      } else {
+        // saveCanvasView validates + clamps; an invalid viewport is a silent no-op.
+        await saveCanvasView(file, patch.viewport);
       }
-    } catch {
-      // No existing meta — create one with just the Phase 4 keys.
     }
-    const next = { ...current };
-    // Whitelist of patchable top-level keys.
+
+    // --- Shared document lane: layout → versioned meta, stamps last_modified. ---
     if (patch.layout !== undefined) {
+      let current: Record<string, unknown> = {};
+      try {
+        const parsed = JSON.parse(await Bun.file(metaAbs).text());
+        if (parsed && typeof parsed === 'object' && !Array.isArray(parsed)) {
+          current = parsed as Record<string, unknown>;
+        }
+      } catch {
+        // No existing meta — create one with just the layout key.
+      }
+      const next = { ...current };
       if (patch.layout === null) {
         next.layout = undefined;
       } else if (typeof patch.layout === 'object' && !Array.isArray(patch.layout)) {
         next.layout = patch.layout;
       }
+      // Defensive: a stale inline viewport must never persist in the versioned
+      // file (the camera lane owns it now). JSON.stringify drops undefined keys.
+      next.viewport = undefined;
+      next.last_modified = new Date().toISOString();
+      // Trailing newline — consistent with canvas-create.ts + sync/codec.ts
+      // (mergeSharedMetaIntoLocal), so a layout edit doesn't churn the newline.
+      await Bun.write(metaAbs, `${JSON.stringify(next, null, 2)}\n`);
     }
-    if (patch.viewport !== undefined) {
-      if (patch.viewport === null) {
-        next.viewport = undefined;
-      } else if (typeof patch.viewport === 'object' && !Array.isArray(patch.viewport)) {
-        const v = patch.viewport as { x?: unknown; y?: unknown; zoom?: unknown };
-        if (
-          Number.isFinite(v.x as number) &&
-          Number.isFinite(v.y as number) &&
-          Number.isFinite(v.zoom as number)
-        ) {
-          const zoom = Math.min(4, Math.max(0.1, v.zoom as number));
-          next.viewport = { x: v.x as number, y: v.y as number, zoom };
-        }
-      }
-    }
-    next.last_modified = new Date().toISOString();
-    await Bun.write(metaAbs, JSON.stringify(next, null, 2));
-    return next;
+
+    // Return the merged view (shared meta + camera) — identical to GET, so the
+    // client gets a coherent object regardless of which lane(s) the patch hit.
+    return await loadCanvasMeta(file);
   }
 
   // ---------- Annotations sidecar (Phase 5) ----------
@@ -930,6 +1076,12 @@ export function createApi(ctx: Context, hooks: ApiHooks): Api {
       path.join(groupAbs, `${v.name}.meta.json`),
       `${JSON.stringify(meta, null, 2)}\n`
     );
+    // Phase 30 — same-machine live tree refresh. Other tabs on THIS dev-server
+    // re-read the (branch-scoped, on-disk) canvas list so a freshly-created
+    // canvas appears without a reload. Cross-machine peers get the new canvas
+    // via git "Get latest" — the file travels through git, this event is only a
+    // "refresh your list" nudge for online local tabs (loopback inspector WS).
+    ctx.bus.emit('canvas-list-update', { action: 'added', rel, slug });
     // designRel-prefixed path — matches the file-tree `file.path` shape so the
     // client can open it directly after reloadTree().
     return { ok: true, file: path.posix.join(paths.designRel, rel), rel, slug };
@@ -1031,6 +1183,11 @@ export function createApi(ctx: Context, hooks: ApiHooks): Api {
       path.join(paths.canvasStateDir, `${slug}.json`),
       `_canvas-state__${slug}.json`
     );
+    // DDR-115 — the per-machine camera view file.
+    await moveIfExists(
+      path.join(paths.canvasStateDir, `${slug}.view.json`),
+      `_canvas-state__${slug}.view.json`
+    );
     await moveIfExists(path.join(paths.commentsDir, `${slug}.json`), `_comments__${slug}.json`);
 
     await Bun.write(
@@ -1038,6 +1195,8 @@ export function createApi(ctx: Context, hooks: ApiHooks): Api {
       `${JSON.stringify({ canvas: rel, slug, deletedAt: new Date().toISOString(), trashed }, null, 2)}\n`
     );
 
+    // Phase 30 — live tree refresh for other local tabs (see createCanvas).
+    ctx.bus.emit('canvas-list-update', { action: 'removed', rel, slug });
     return {
       ok: true,
       rel,

package/apps/studio/bin/chat-open.sh

@@ -0,0 +1,44 @@
+#!/usr/bin/env bash
+# chat-open.sh — Phase 31 (DDR-123). Backs `/design:chat` (via `maude design
+# chat-open`): asks the running dev-server to surface the native ACP chat
+# sidepanel by POSTing /_api/acp/focus. The server emits a bus event the shell
+# (app.jsx, native-only) turns into "open the Assistant panel".
+#
+# Reads:  $DESIGN_ROOT/_server.json  (port the running server wrote)
+# Usage:  chat-open.sh [--root <repo>]
+# Exits:  0 on success, 1 if no live server / focus request failed.
+set -euo pipefail
+
+REPO="${CLAUDE_PROJECT_DIR:-$(pwd)}"
+while [ $# -gt 0 ]; do
+  case "$1" in
+    --root) REPO="$2"; shift 2 ;;
+    *) shift ;;
+  esac
+done
+
+DESIGN_ROOT="$REPO/.design"
+STATE="$DESIGN_ROOT/_server.json"
+
+if [ ! -f "$STATE" ]; then
+  echo "chat-open: no running dev server ($STATE missing). Open Maude first." >&2
+  exit 1
+fi
+
+if command -v jq >/dev/null 2>&1; then
+  PORT="$(jq -r '.port // empty' "$STATE" 2>/dev/null)"
+else
+  PORT="$(sed -nE 's/.*"port"[[:space:]]*:[[:space:]]*([0-9]+).*/\1/p' "$STATE" 2>/dev/null | head -n1)"
+fi
+
+if [ -z "${PORT:-}" ]; then
+  echo "chat-open: could not read the server port from $STATE." >&2
+  exit 1
+fi
+
+if curl -fsS -X POST "http://127.0.0.1:${PORT}/_api/acp/focus" >/dev/null 2>&1; then
+  echo "→ opened the Assistant panel in Maude (port ${PORT})."
+else
+  echo "chat-open: focus request to the dev server failed (port ${PORT})." >&2
+  exit 1
+fi