@dfosco/storyboard 0.7.0 → 0.8.1

package/scripts/aggregate-artifacts.mjs

@@ -0,0 +1,257 @@
+#!/usr/bin/env node
+
+import fs from 'fs'
+import path from 'path'
+import process from 'process'
+
+const INDEX_FILENAME = 'artifacts.index.json'
+const TMP_FILENAME = '.artifacts.index.json.tmp'
+const SCHEMA_VERSION = 1
+
+function compareBranchNames(a, b) {
+  if (a.branch === 'main' && b.branch !== 'main') return -1
+  if (b.branch === 'main' && a.branch !== 'main') return 1
+  return String(a.branch || '').localeCompare(String(b.branch || ''))
+}
+
+function withTrailingSlash(folder) {
+  if (!folder) return ''
+  return folder.endsWith('/') ? folder : `${folder}/`
+}
+
+function generatedAtMs(manifest) {
+  const value = Date.parse(manifest?.generatedAt || '')
+  return Number.isNaN(value) ? 0 : value
+}
+
+function deriveFolder(manifest, dir, ghPagesDir) {
+  if (dir === ghPagesDir) return ''
+  if (typeof manifest.folder === 'string') return manifest.folder
+  return path.basename(dir)
+}
+
+function deriveBranch(manifest, folder) {
+  if (!folder) return 'main'
+  if (typeof manifest.branch === 'string' && manifest.branch) return manifest.branch
+  return manifest.deployBranch || folder.replace(/^branch--/, '')
+}
+
+function deriveDeployBranch(manifest, branch, folder) {
+  if (!folder || branch === 'main') return 'main'
+  if (typeof manifest.deployBranch === 'string' && manifest.deployBranch) return manifest.deployBranch
+  return folder.replace(/^branch--/, '')
+}
+
+function readManifest(dir) {
+  const manifestPath = path.join(dir, 'artifacts.json')
+  const label = path.basename(dir) || dir
+
+  let raw
+  try {
+    raw = fs.readFileSync(manifestPath, 'utf8')
+  } catch (err) {
+    if (err?.code === 'ENOENT') {
+      console.info(`[aggregate-artifacts] Skipping ${label}: artifacts.json not found`)
+      return { manifest: null, readError: false }
+    }
+    console.warn(`[aggregate-artifacts] Skipping ${label}: could not read artifacts.json (${err.message})`)
+    return { manifest: null, readError: true }
+  }
+
+  let manifest
+  try {
+    manifest = JSON.parse(raw)
+  } catch (err) {
+    console.warn(`[aggregate-artifacts] Skipping ${label}: malformed artifacts.json (${err.message})`)
+    return { manifest: null, readError: false }
+  }
+
+  if (manifest?.schemaVersion !== SCHEMA_VERSION) {
+    console.warn(`[aggregate-artifacts] Skipping ${label}: unsupported schemaVersion ${manifest?.schemaVersion}`)
+    return { manifest: null, readError: false }
+  }
+
+  return { manifest, readError: false }
+}
+
+function listManifestDirs(ghPagesDir) {
+  const entries = fs.readdirSync(ghPagesDir, { withFileTypes: true })
+  const branchDirs = entries
+    .filter(entry => entry.isDirectory() && entry.name.startsWith('branch--'))
+    .map(entry => path.join(ghPagesDir, entry.name))
+    .sort((a, b) => path.basename(a).localeCompare(path.basename(b)))
+
+  return [ghPagesDir, ...branchDirs]
+}
+
+function collectManifests(ghPagesDir) {
+  const manifestsByFolder = new Map()
+  let readErrorCount = 0
+
+  for (const dir of listManifestDirs(ghPagesDir)) {
+    const { manifest, readError } = readManifest(dir)
+    if (readError) readErrorCount += 1
+    if (!manifest) continue
+
+    const folder = deriveFolder(manifest, dir, ghPagesDir)
+    const current = { manifest, dir, folder }
+    const previous = manifestsByFolder.get(folder)
+
+    if (!previous) {
+      manifestsByFolder.set(folder, current)
+      continue
+    }
+
+    const previousBranch = deriveBranch(previous.manifest, previous.folder)
+    const currentBranch = deriveBranch(manifest, folder)
+    const keepCurrent = generatedAtMs(manifest) > generatedAtMs(previous.manifest)
+    const keptBranch = keepCurrent ? currentBranch : previousBranch
+
+    console.warn(
+      `[aggregate-artifacts] Branch folder collision for "${folder || '(root)'}" between "${previousBranch}" and "${currentBranch}"; keeping "${keptBranch}"`,
+    )
+
+    if (keepCurrent) manifestsByFolder.set(folder, current)
+  }
+
+  if (readErrorCount > 1) {
+    throw new Error(`Failed to read ${readErrorCount} artifacts manifests; preserving existing ${INDEX_FILENAME}`)
+  }
+
+  const manifests = [...manifestsByFolder.values()]
+  if (manifests.length === 0) {
+    throw new Error(`No readable artifacts.json manifests found; preserving existing ${INDEX_FILENAME}`)
+  }
+
+  return manifests
+}
+
+function addPrototype(index, manifestInfo, item) {
+  const id = item?.artifactId || item?.id
+  if (!id) return
+
+  const { manifest, folder } = manifestInfo
+  const branch = deriveBranch(manifest, folder)
+  const key = String(id)
+
+  if (!index.prototypes[key]) {
+    index.prototypes[key] = { id: key, branches: [] }
+  }
+
+  index.prototypes[key].branches.push({
+    branch,
+    folder: withTrailingSlash(folder),
+    title: item.title ?? item.id ?? key,
+    route: item.route ?? null,
+    isExternal: Boolean(item.isExternal),
+    externalUrl: item.externalUrl ?? null,
+    folderName: item.folder ?? null,
+    sha: manifest.sha ?? null,
+    lastModified: item.lastModified ?? null,
+  })
+}
+
+function addCanvas(index, manifestInfo, item) {
+  const id = item?.artifactId || item?.id
+  if (!id) return
+
+  const { manifest, folder } = manifestInfo
+  const branch = deriveBranch(manifest, folder)
+  const key = String(id)
+
+  if (!index.canvases[key]) {
+    index.canvases[key] = { id: key, branches: [] }
+  }
+
+  index.canvases[key].branches.push({
+    branch,
+    folder: withTrailingSlash(folder),
+    name: item.name ?? item.id ?? key,
+    route: item.route ?? null,
+    folderName: item.folder ?? null,
+    sha: manifest.sha ?? null,
+    lastModified: item.lastModified ?? null,
+  })
+}
+
+function sortArtifactMap(map) {
+  const sorted = {}
+
+  for (const key of Object.keys(map).sort((a, b) => a.localeCompare(b))) {
+    sorted[key] = {
+      ...map[key],
+      branches: [...map[key].branches].sort(compareBranchNames),
+    }
+  }
+
+  return sorted
+}
+
+function buildIndex(manifests) {
+  const index = {
+    schemaVersion: SCHEMA_VERSION,
+    generatedAt: new Date().toISOString(),
+    branches: [],
+    prototypes: {},
+    canvases: {},
+  }
+
+  for (const manifestInfo of manifests) {
+    const { manifest, folder } = manifestInfo
+    const branch = deriveBranch(manifest, folder)
+    const deployBranch = deriveDeployBranch(manifest, branch, folder)
+
+    index.branches.push({ branch, deployBranch, folder })
+
+    for (const item of Array.isArray(manifest.prototypes) ? manifest.prototypes : []) {
+      addPrototype(index, manifestInfo, item)
+    }
+
+    for (const item of Array.isArray(manifest.canvases) ? manifest.canvases : []) {
+      addCanvas(index, manifestInfo, item)
+    }
+  }
+
+  index.branches = [...index.branches].sort(compareBranchNames)
+  index.prototypes = sortArtifactMap(index.prototypes)
+  index.canvases = sortArtifactMap(index.canvases)
+
+  return index
+}
+
+function writeIndex(ghPagesDir, index) {
+  const targetPath = path.join(ghPagesDir, INDEX_FILENAME)
+  const tmpPath = path.join(ghPagesDir, TMP_FILENAME)
+  const contents = `${JSON.stringify(index, null, 2)}\n`
+
+  fs.writeFileSync(tmpPath, contents, 'utf8')
+  fs.renameSync(tmpPath, targetPath)
+
+  return targetPath
+}
+
+function aggregateArtifacts(ghPagesDir) {
+  const resolvedDir = path.resolve(ghPagesDir)
+  const manifests = collectManifests(resolvedDir)
+  const index = buildIndex(manifests)
+  return writeIndex(resolvedDir, index)
+}
+
+function main() {
+  const ghPagesDir = process.argv[2]
+
+  if (!ghPagesDir) {
+    console.error('Usage: node aggregate-artifacts.mjs <gh-pages-dir>')
+    process.exit(1)
+  }
+
+  try {
+    const targetPath = aggregateArtifacts(ghPagesDir)
+    console.info(`[aggregate-artifacts] Wrote ${targetPath}`)
+  } catch (err) {
+    console.error(`[aggregate-artifacts] ${err.message}`)
+    process.exit(1)
+  }
+}
+
+main()

package/src/core/artifact/operations.js

@@ -128,8 +128,6 @@ function createPrototype(values, root) {
     ? path.join(prototypesDir, `${values.folder}.folder`, values.name)
     : path.join(prototypesDir, values.name)
 
-  fs.mkdirSync(targetDir, { recursive: true })
-
   const files = []
   const relDir = path.relative(root, targetDir)
 
@@ -148,6 +146,22 @@ function createPrototype(values, root) {
     return { success: false, errors: [{ message: partialError }] }
   }
 
+  // Pre-resolve the partial's component file *before* writing anything.
+  // If the partial's template/recipe directory is missing or empty we'd
+  // otherwise leave an orphan .prototype.json on disk and Vite would
+  // then try (and fail) to lazy-load a non-existent index.jsx. Validate
+  // first, write second.
+  let componentFile = null
+  if (partialEntry && !values.url) {
+    const partialDir = path.join(root, 'src', partialEntry.baseDir, partialEntry.name)
+    componentFile = findComponentFile(partialDir)
+    if (!componentFile) {
+      return { success: false, errors: [{ message: `No .jsx or .tsx file found in src/${partialEntry.baseDir}/${partialEntry.name}/` }] }
+    }
+  }
+
+  fs.mkdirSync(targetDir, { recursive: true })
+
   // Write .prototype.json (with $global from partial when applicable)
   const protoFile = `${values.name}.prototype.json`
   const protoBody = JSON.parse(prototypeJson(values))
@@ -159,22 +173,14 @@ function createPrototype(values, root) {
 
   // Write index.jsx (only for non-external prototypes)
   if (!values.url) {
-    let body
-    if (partialEntry) {
-      const partialDir = path.join(root, 'src', partialEntry.baseDir, partialEntry.name)
-      const componentFile = findComponentFile(partialDir)
-      if (!componentFile) {
-        return { success: false, errors: [{ message: `No .jsx or .tsx file found in src/${partialEntry.baseDir}/${partialEntry.name}/` }] }
-      }
-      body = renderPartialIndexJsx({
+    const body = partialEntry
+      ? renderPartialIndexJsx({
         partialEntry,
         componentFile,
         componentName: toPascalCase(values.name),
         title: values.title || values.name,
       })
-    } else {
-      body = prototypeIndexJsx(values.name)
-    }
+      : prototypeIndexJsx(values.name)
     fs.writeFileSync(path.join(targetDir, 'index.jsx'), body, 'utf-8')
     files.push(`${relDir}/index.jsx`)
   }

package/src/core/autosync/server.test.js

@@ -21,7 +21,7 @@ describe('autosync scope helpers', () => {
     expect(matchesAutosyncScope('canvas', 'src/canvas/notes.txt')).toBe(true)
     expect(matchesAutosyncScope('canvas', 'assets/canvas/images/photo.png')).toBe(true)
     expect(matchesAutosyncScope('canvas', 'assets/canvas/snapshots/snapshot-widget--latest.webp')).toBe(true)
-    expect(matchesAutosyncScope('canvas', 'assets/.storyboard-public/terminal-snapshots/agent-abc.snapshot.json')).toBe(true)
+    expect(matchesAutosyncScope('canvas', 'assets/.storyboard-public/terminal-snapshots/agents.snapshot.json')).toBe(true)
     expect(matchesAutosyncScope('canvas', 'src/prototypes/demo/default.flow.json')).toBe(false)
   })
 

package/src/core/canvas/githubEmbeds.js

@@ -153,6 +153,10 @@ function toContext(target) {
 
 function buildPullRequestSnapshot(target, pr) {
   const number = pr?.number ?? target.number
+  const merged = Boolean(pr?.merged_at || pr?.merged)
+  const draft = Boolean(pr?.draft)
+  const rawState = pr?.state === 'closed' ? 'closed' : 'open'
+  const state = merged ? 'merged' : (draft && rawState === 'open' ? 'draft' : rawState)
   return {
     kind: 'pull_request',
     parentKind: 'pull_request',
@@ -164,6 +168,14 @@ function buildPullRequestSnapshot(target, pr) {
     createdAt: pr?.created_at ?? null,
     updatedAt: pr?.updated_at ?? null,
     url: target.url,
+    state,
+    merged,
+    draft,
+    baseRef: typeof pr?.base?.ref === 'string' ? pr.base.ref : null,
+    headRef: typeof pr?.head?.ref === 'string' ? pr.head.ref : null,
+    additions: typeof pr?.additions === 'number' ? pr.additions : null,
+    deletions: typeof pr?.deletions === 'number' ? pr.deletions : null,
+    changedFiles: typeof pr?.changed_files === 'number' ? pr.changed_files : null,
   }
 }
 

package/src/core/canvas/githubEmbeds.test.js

@@ -202,6 +202,76 @@ describe('fetchGitHubEmbedSnapshot', () => {
     expect(graphqlArgs.slice(0, 2)).toEqual(['api', 'graphql'])
   })
 
+  it('hydrates pull request snapshot metadata (state, branches, diff)', () => {
+    ghExec
+      .mockReturnValueOnce('gh version 2.58.0')
+      .mockReturnValueOnce(JSON.stringify({
+        number: 79,
+        title: 'fix(viewfinder): eliminate FOUC',
+        body: 'A PR body',
+        state: 'closed',
+        merged: true,
+        merged_at: '2026-04-10T00:00:00Z',
+        draft: false,
+        user: { login: 'dfosco' },
+        created_at: '2026-04-01T00:00:00Z',
+        updated_at: '2026-04-10T00:00:00Z',
+        base: { ref: '3.11.0' },
+        head: { ref: '3.11.0--fix-viewfinder-fouc' },
+        additions: 63,
+        deletions: 18,
+        changed_files: 4,
+      }))
+
+    const snapshot = fetchGitHubEmbedSnapshot('https://github.com/dfosco/storyboard/pull/79')
+
+    expect(snapshot).toMatchObject({
+      kind: 'pull_request',
+      parentKind: 'pull_request',
+      title: '#79 fix(viewfinder): eliminate FOUC',
+      state: 'merged',
+      merged: true,
+      draft: false,
+      baseRef: '3.11.0',
+      headRef: '3.11.0--fix-viewfinder-fouc',
+      additions: 63,
+      deletions: 18,
+      changedFiles: 4,
+    })
+  })
+
+  it('marks draft PRs and unmerged closed PRs correctly', () => {
+    ghExec
+      .mockReturnValueOnce('gh version 2.58.0')
+      .mockReturnValueOnce(JSON.stringify({
+        number: 5,
+        title: 'WIP: refactor',
+        state: 'open',
+        draft: true,
+        merged: false,
+        user: { login: 'dfosco' },
+      }))
+
+    const draftSnap = fetchGitHubEmbedSnapshot('https://github.com/dfosco/storyboard/pull/5')
+    expect(draftSnap.state).toBe('draft')
+    expect(draftSnap.draft).toBe(true)
+    expect(draftSnap.merged).toBe(false)
+
+    ghExec
+      .mockReturnValueOnce('gh version 2.58.0')
+      .mockReturnValueOnce(JSON.stringify({
+        number: 6,
+        state: 'closed',
+        merged: false,
+        merged_at: null,
+        user: { login: 'dfosco' },
+      }))
+
+    const closedSnap = fetchGitHubEmbedSnapshot('https://github.com/dfosco/storyboard/pull/6')
+    expect(closedSnap.state).toBe('closed')
+    expect(closedSnap.merged).toBe(false)
+  })
+
   it('rejects issue comment URLs when comment parent does not match', () => {
     ghExec
       .mockReturnValueOnce('gh version 2.58.0')
@@ -270,8 +340,7 @@ describe('fetchGitHubEmbedSnapshot', () => {
     })
   })
 
-  it('hydrates PR top-level comment snapshot metadata', () => {
-    ghExec
+  it('hydrates PR top-level comment snapshot metadata', () => {    ghExec
       .mockReturnValueOnce('gh version 2.58.0')
       .mockReturnValueOnce(JSON.stringify({
         body: 'Looks good!',

package/src/core/canvas/hot-pool.js

@@ -551,8 +551,8 @@ export class HotPool {
             const paneContent = execSync(
               // H1: include scrollback so the readiness echo can still be
               // matched after the agent's TUI repaints over it.
-              `tmux capture-pane -t "${tmuxName}" -p -S -200`,
-              { encoding: 'utf8', timeout: 1000 }
+              `tmux capture-pane -t "${tmuxName}" -p -S -200 2>/dev/null`,
+              { encoding: 'utf8', timeout: 1000, stdio: ['ignore', 'pipe', 'ignore'] }
             )
             // Strip ANSI escape sequences — agent CLIs use heavy formatting
             // eslint-disable-next-line no-control-regex
@@ -580,14 +580,13 @@ export class HotPool {
       return this.#tmuxSessionExists(tmuxName)
     }
 
-    // Send postStartup command (e.g. "/allow-all on")
+    // postStartup is NOT sent here intentionally. It's deferred to widget
+    // handoff (see terminal-server.js warm path) so it runs *after* the
+    // identity/role injection — mode-toggling slash commands like
+    // `/autopilot` must come last so canvas context lands in conversation
+    // history before the agent enters autopilot mode.
     if (postStartup) {
-      try {
-        await new Promise(r => setTimeout(r, 500))
-        execSync(`tmux send-keys -t "${tmuxName}" -l ${JSON.stringify(postStartup)}`, { stdio: 'ignore' })
-        execSync(`tmux send-keys -t "${tmuxName}" Enter`, { stdio: 'ignore' })
-        this.#log(`⊕ AGENT ${sessionId} postStartup sent: ${postStartup}`)
-      } catch { /* empty */ }
+      this.#log(`⊕ AGENT ${sessionId} postStartup "${postStartup}" deferred to widget handoff`)
     }
 
     this.#log(`⊕ AGENT ${sessionId} ready (${signalFilePath ? 'file' : 'signal'}: "${readinessSignal || 'file'}")`)
@@ -615,8 +614,8 @@ export class HotPool {
     if (this.#agentConfig?.startupCommand) {
       try {
         const cmd = execSync(
-          `tmux display-message -t "${session.tmuxName}" -p "#{pane_current_command}"`,
-          { encoding: 'utf8', timeout: 1000 }
+          `tmux display-message -t "${session.tmuxName}" -p "#{pane_current_command}" 2>/dev/null`,
+          { encoding: 'utf8', timeout: 1000, stdio: ['ignore', 'pipe', 'ignore'] }
         ).trim()
         // Agent exited if the pane is back to a shell
         const shells = ['zsh', 'bash', 'sh', 'fish']

package/src/core/canvas/materializer.js

@@ -7,17 +7,36 @@
  * Event types:
  *   canvas_created   — full initial state (first line)
  *   widget_added     — append a widget
- *   widget_updated   — patch widget props
- *   widget_moved     — update widget position
- *   widget_removed   — remove a widget by id
- *   settings_updated — patch canvas-level settings
- *   source_updated   — replace the sources array
- *   widgets_replaced — replace the entire widgets array (bulk update)
+ *   widget_updated   — patch widget props (may carry `prevProps` for undo)
+ *   widget_moved     — update widget position (may carry `prevPosition` for undo)
+ *   widget_removed   — remove a widget by id (carries `widget` for undo;
+ *                      legacy events only had `widgetId`)
+ *   settings_updated — patch canvas-level settings (may carry `prevSettings` for undo)
+ *   source_updated   — replace the sources array (may carry `prevSources` for undo)
+ *   widgets_replaced — replace the entire widgets array (compaction only, not undoable)
  *   connector_added  — append a connector between two widgets
- *   connector_removed — remove a connector by id
- *   connectors_replaced — replace the entire connectors array (bulk update, used by undo/redo)
- *   connector_waypoints_set     — set/replace manual routing waypoints on a connector
- *   connector_waypoints_cleared — drop manual routing, revert to auto-routing
+ *   connector_removed — remove a connector by id (carries `connector` for undo;
+ *                       legacy events only had `connectorId`)
+ *   connectors_replaced — replace the entire connectors array (compaction only, not undoable)
+ *   connector_waypoints_set     — set/replace manual routing waypoints (may carry `prevWaypoints`)
+ *   connector_waypoints_cleared — drop manual routing (may carry `prevWaypoints`)
+ *   connector_updated — patch connector anchors/meta (may carry `prevUpdates` for undo)
+ *
+ * Event metadata (all events):
+ *   id        — short random id stamped by the server, used by undo/redo
+ *               to target a specific event. Legacy events without an id are
+ *               non-undoable but materialize normally.
+ *   meta.kind — present on undo/redo emissions ('undo' | 'redo'). The
+ *               materializer ignores meta; it's informational for tools
+ *               and a future timeline UI.
+ *   meta.of   — the id of the event this undo/redo targets.
+ *
+ * Undo model: the materializer never "skips" events. Undo is a normal
+ * forward event (a real `widget_added`/`widget_removed`/`widget_updated`)
+ * that happens to carry meta.kind === 'undo'. Folding is one pass, no
+ * special cases. Inverse payloads (`prevProps`, `prevPosition`, full
+ * `widget`/`connector` on removes, etc.) are read only by the server's
+ * POST /undo and POST /redo endpoints when computing the inverse event.
  */
 
 /**
@@ -134,13 +153,16 @@ export function materialize(events) {
       }
 
       case 'widget_removed': {
+        // Back-compat: legacy events only had `widgetId`; new events carry
+        // the full `widget` object so undo can re-add without history walk.
+        const removedId = evt.widget?.id ?? evt.widgetId
         state.widgets = (state.widgets || []).filter(
-          (w) => w.id !== evt.widgetId,
+          (w) => w.id !== removedId,
         )
         // Cascade: remove connectors referencing the deleted widget
         if (state.connectors?.length) {
           state.connectors = state.connectors.filter(
-            (c) => c.start.widgetId !== evt.widgetId && c.end.widgetId !== evt.widgetId,
+            (c) => c.start.widgetId !== removedId && c.end.widgetId !== removedId,
           )
         }
         break
@@ -179,8 +201,12 @@ export function materialize(events) {
       }
 
       case 'connector_removed': {
+        // Back-compat: legacy events only had `connectorId`; new events
+        // carry the full `connector` object so undo can re-add without
+        // history walk.
+        const removedId = evt.connector?.id ?? evt.connectorId
         state.connectors = (state.connectors || []).filter(
-          (c) => c.id !== evt.connectorId,
+          (c) => c.id !== removedId,
         )
         break
       }