@dfosco/storyboard-core 4.2.0-beta.3 → 4.2.0

package/src/cli/setup.js

@@ -5,11 +5,11 @@
  */
 
 import * as p from '@clack/prompts'
-import { existsSync, writeFileSync, mkdirSync } from 'fs'
+import { existsSync, writeFileSync, readFileSync, mkdirSync, readdirSync, symlinkSync } from 'fs'
 import path from 'path'
 import { execSync } from 'child_process'
 import { generateCaddyfile, isCaddyInstalled, isCaddyRunning, startCaddy, reloadCaddy } from './proxy.js'
-import { gettingStartedLines, dim, magenta, bold, green, yellow } from './intro.js'
+import { gettingStartedLines, dim, magenta, bold, yellow } from './intro.js'
 
 /**
  * Run a potentially slow task with a spinner that only appears after 500ms.
@@ -188,7 +188,7 @@ if (isInstalled('code')) {
 
 // 7. Asset directories
 {
-  const dirs = ['assets/canvas/images', '.storyboard']
+  const dirs = ['assets/canvas/images', 'assets/.storyboard-public/terminal-snapshots', '.storyboard', '.storyboard/terminals', '.storyboard/terminal-buffers', '.storyboard/logs']
   for (const dir of dirs) {
     if (!existsSync(dir)) {
       try { mkdirSync(dir, { recursive: true }) } catch { /* ignore */ }
@@ -211,6 +211,81 @@ if (isInstalled('code')) {
   p.log.success('Canvas asset directories ready')
 }
 
+// 7a. Scaffold .gitignore entries for private canvas images
+{
+  const gitignorePath = '.gitignore'
+  const privatePatterns = [
+    'src/canvas/images/~*',
+    'assets/canvas/images/~*',
+    'assets/canvas/snapshots/~*',
+    'assets/.storyboard-public/terminal-snapshots/~*',
+  ]
+  if (existsSync(gitignorePath)) {
+    try {
+      let content = readFileSync(gitignorePath, 'utf-8')
+      const missing = privatePatterns.filter(p => !content.includes(p))
+      if (missing.length > 0) {
+        const block = '\n# Private canvas images (tilde prefix = not committed)\n' + missing.join('\n') + '\n'
+        content = content.trimEnd() + '\n' + block
+        writeFileSync(gitignorePath, content, 'utf-8')
+        p.log.success('Added private image patterns to .gitignore')
+      }
+    } catch { /* ignore */ }
+  }
+}
+
+// 7b. Copilot agents
+{
+  const agentsDir = '.agents'
+  if (!existsSync(agentsDir)) {
+    try { mkdirSync(agentsDir, { recursive: true }) } catch { /* ignore */ }
+  }
+
+  const scaffoldAgents = path.resolve(import.meta.dirname, '..', '..', 'scaffold', 'agents')
+  if (existsSync(scaffoldAgents)) {
+    try {
+      const agentFiles = execSync(`ls "${scaffoldAgents}"`, { encoding: 'utf8' }).trim().split('\n').filter(Boolean)
+      for (const file of agentFiles) {
+        const dest = path.join(agentsDir, file)
+        if (!existsSync(dest)) {
+          run(`cp "${path.join(scaffoldAgents, file)}" "${dest}"`)
+        }
+      }
+      if (agentFiles.length > 0) {
+        p.log.success('Copilot agents scaffolded (.agents/)')
+      }
+    } catch { /* ignore */ }
+  }
+
+  // Create symlinks in each CLI's expected agent directory.
+  // Source of truth: .agents/*.agent.md
+  // Copilot CLI reads .github/agents/*.md
+  // Claude Code reads .claude/agents/*.md
+  // Codex CLI uses .codex/config.toml (no agent files needed)
+  try {
+    const agentFiles = readdirSync(agentsDir).filter(f => f.endsWith('.agent.md'))
+    const targets = [
+      { dir: path.join('.github', 'agents'), label: 'Copilot CLI' },
+      { dir: path.join('.claude', 'agents'), label: 'Claude Code' },
+    ]
+    for (const { dir, label } of targets) {
+      try { mkdirSync(dir, { recursive: true }) } catch { /* ignore */ }
+      let linked = 0
+      for (const file of agentFiles) {
+        const linkName = file.replace('.agent.md', '.md')
+        const linkPath = path.join(dir, linkName)
+        const target = path.relative(dir, path.join(agentsDir, file))
+        if (!existsSync(linkPath)) {
+          try { symlinkSync(target, linkPath); linked++ } catch { /* ignore */ }
+        }
+      }
+      if (linked > 0) {
+        p.log.success(`${label} agent symlinks created (${dir}/)`)
+      }
+    }
+  } catch { /* ignore */ }
+}
+
 // 8. Proxy
 if (isCaddyInstalled()) {
   const proxySpin = p.spinner()
@@ -220,18 +295,48 @@ if (isCaddyInstalled()) {
     reloadCaddy(caddyfilePath)
     proxySpin.stop('Proxy reloaded')
   } else {
-    proxySpin.start('Starting proxy (requires sudo for port 80)...')
+    proxySpin.start('Starting proxy...')
     startCaddy(caddyfilePath)
     proxySpin.stop('Proxy started')
   }
 }
 
 // 9. Install / sync dependencies
-await withSpin(
-  'Installing dependencies...',
-  'Dependencies installed',
-  () => { run('npm install', { stdio: 'ignore' }) }
-)
+// Skip npm install if a dev server is running — it would trigger Vite's
+// file watcher and restart the server on a different port.
+{
+  const { SERVER_PORT } = await import('../server/index.js')
+  const { readDevDomain: readDomain } = await import('./proxy.js')
+  const http = await import('node:http')
+
+  const devRunning = await new Promise((resolve) => {
+    const req = http.get(`http://localhost:${SERVER_PORT}/health`, (res) => {
+      if (res.statusCode !== 200) { resolve(false); return }
+      let data = ''
+      res.on('data', (chunk) => { data += chunk })
+      res.on('end', () => {
+        try {
+          const json = JSON.parse(data)
+          const ourDomain = readDomain()
+          resolve(json.ok === true && json.devDomain === ourDomain)
+        } catch { resolve(false) }
+      })
+    })
+    req.on('error', () => resolve(false))
+    req.setTimeout(1000, () => { req.destroy(); resolve(false) })
+  })
+
+  if (devRunning) {
+    p.log.info(dim('Skipping npm install — dev server is running (would cause restart)'))
+    p.log.info(dim('Run `npm install` manually after stopping the dev server if needed'))
+  } else {
+    await withSpin(
+      'Installing dependencies...',
+      'Dependencies installed',
+      () => { run('npm install', { stdio: 'ignore' }) }
+    )
+  }
+}
 
 p.note(
   [
@@ -242,7 +347,28 @@ p.note(
   'Getting started'
 )
 
-console.log()
-console.log(mascot())
+// Offer branch guide
+{
+  let currentBranchName = 'main'
+  try {
+    currentBranchName = execSync('git branch --show-current', { encoding: 'utf8' }).trim() || 'main'
+  } catch { /* empty */ }
+
+  const wantBranch = await p.select({
+    message: 'Want to work from a different branch?',
+    options: [
+      { value: true, label: 'Yes (help me create it)' },
+      { value: false, label: `No (stay on current branch ${bold(currentBranchName)})` },
+    ],
+    initialValue: false,
+  })
 
-p.outro('')
+  if (!p.isCancel(wantBranch) && wantBranch) {
+    const { runBranchGuide } = await import('./branch.js')
+    await runBranchGuide()
+  } else {
+    console.log()
+    console.log(mascot())
+    p.outro('')
+  }
+}

package/src/cli/terminal-commands.js

@@ -7,7 +7,7 @@
 
 import * as p from '@clack/prompts'
 import { execSync } from 'node:child_process'
-import { detectWorktreeName, getPort } from '../worktree/port.js'
+import { detectWorktreeName, resolveRunningPort } from '../worktree/port.js'
 import { readDevDomain } from './proxy.js'
 import { parseFlags } from './flags.js'
 import { dim, cyan, bold, yellow } from './intro.js'
@@ -78,17 +78,25 @@ function resolveSession(sessions, id) {
   return null
 }
 
-/** Detect the current tmux session name */
+/** Detect the current tmux session name (only if it's a storyboard session) */
 function getCurrentTmuxSession() {
   try {
-    return execSync('tmux display-message -p "#{session_name}" 2>/dev/null', {
+    const name = execSync('tmux display-message -p "#{session_name}" 2>/dev/null', {
       encoding: 'utf8', stdio: ['pipe', 'pipe', 'pipe'],
     }).trim()
+    // Only return if this is a storyboard terminal session
+    return name.startsWith('sb-') ? name : null
   } catch {
     return null
   }
 }
 
+/** Check if we're inside ANY tmux (storyboard or user's own) */
+function _isInsideTmux() {
+  return Boolean(process.env.TMUX)
+}
+void _isInsideTmux
+
 // ── Close (archive) ──
 
 async function closeSession(session, worktreeName, port) {
@@ -125,13 +133,15 @@ async function closeSession(session, worktreeName, port) {
 
 // ── Open (attach) ──
 
-async function openSession(session, worktreeName, port) {
+async function openSession(session, _worktreeName, _port) {
+  void _worktreeName
+  void _port
   p.intro(bold('Open session'))
 
   const label = session.name || session.tmuxName
-  const currentTmux = getCurrentTmuxSession()
+  const currentSb = getCurrentTmuxSession()
 
-  if (session.status === 'live' && session.tmuxName !== currentTmux) {
+  if (session.status === 'live' && session.tmuxName !== currentSb) {
     p.log.warn(
       `Session ${cyan(label)} is currently live on widget ${dim(session.widgetId)} ` +
       `in canvas ${cyan(session.canvasId)}.`
@@ -145,8 +155,9 @@ async function openSession(session, worktreeName, port) {
     }
   }
 
-  // If we're inside tmux, switch; otherwise attach
-  if (currentTmux) {
+  // If we're inside a storyboard tmux session, use switch-client.
+  // Otherwise always use attach-session (even if user has their own tmux).
+  if (currentSb) {
     p.outro(`Switching to ${bold(label)}...`)
     try {
       execSync(`tmux switch-client -t "${session.tmuxName}"`, { stdio: 'inherit' })
@@ -234,7 +245,7 @@ async function main() {
   }
 
   const worktreeName = detectWorktreeName()
-  const port = getPort(worktreeName)
+  const port = resolveRunningPort(worktreeName)
   const result = await fetchSessions(worktreeName, port)
 
   if (!result) {

package/src/cli/terminal-messaging.js

@@ -0,0 +1,231 @@
+/**
+ * Terminal Messaging CLI — send messages between terminals and save output.
+ *
+ * Commands:
+ *   storyboard terminal send <widgetId> "message"      Send a message to a terminal
+ *   storyboard terminal send --connected "message"      Send to connected peer
+ *   storyboard terminal output --summary "..." --content "..."  Save latest output
+ *   storyboard terminal status <widgetId>               Check terminal status
+ *   storyboard terminal read <widgetId>                 Read terminal buffer
+ */
+
+import { getServerUrl } from './serverUrl.js'
+
+function parseArgs(args) {
+  const result = { positional: [], flags: {} }
+  for (let i = 0; i < args.length; i++) {
+    if (args[i].startsWith('--')) {
+      const key = args[i].slice(2)
+      const next = args[i + 1]
+      if (next && !next.startsWith('--')) {
+        result.flags[key] = next
+        i++
+      } else {
+        result.flags[key] = true
+      }
+    } else {
+      result.positional.push(args[i])
+    }
+  }
+  return result
+}
+
+export async function handleSend() {
+  const args = process.argv.slice(4) // skip: node, sb, terminal, send
+  const { positional, flags } = parseArgs(args)
+
+  // Resolve sender identity from env
+  const senderWidgetId = process.env.STORYBOARD_WIDGET_ID || null
+
+  let targetWidgetId = null
+  let message = null
+
+  if (flags.connected) {
+    // Auto-resolve connected peer
+    if (!senderWidgetId) {
+      console.error('Error: --connected requires $STORYBOARD_WIDGET_ID to be set')
+      process.exit(1)
+    }
+    // Read own config to find connected agent/terminal peers
+    try {
+      const { readTerminalConfigById, initTerminalConfig } = await import('../canvas/terminal-config.js')
+      initTerminalConfig(process.cwd())
+      const config = readTerminalConfigById(senderWidgetId)
+      const peers = (config?.connectedWidgets || []).filter(
+        (w) => w.type === 'terminal' || w.type === 'agent'
+      )
+      if (peers.length === 0) {
+        console.error('No connected terminal/agent peers found')
+        process.exit(1)
+      }
+      if (peers.length > 1) {
+        console.error(`Multiple peers found. Specify one: ${peers.map((p) => p.id).join(', ')}`)
+        process.exit(1)
+      }
+      targetWidgetId = peers[0].id
+    } catch (err) {
+      console.error(`Error resolving connected peer: ${err.message}`)
+      process.exit(1)
+    }
+    message = typeof flags.connected === 'string' ? flags.connected : positional[0]
+  } else {
+    targetWidgetId = positional[0]
+    message = positional.slice(1).join(' ') || flags.message
+  }
+
+  if (!targetWidgetId || !message) {
+    console.error('Usage: storyboard terminal send <widgetId> "message"')
+    console.error('       storyboard terminal send --connected "message"')
+    process.exit(1)
+  }
+
+  const serverUrl = getServerUrl()
+  try {
+    const res = await fetch(`${serverUrl}/_storyboard/canvas/terminal/send`, {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({ widgetId: targetWidgetId, message, from: senderWidgetId }),
+      signal: AbortSignal.timeout(10000),
+    })
+    const data = await res.json()
+    if (data.success) {
+      if (data.queued) {
+        console.log(`Message queued for ${targetWidgetId} (agent not running, will deliver on start)`)
+      } else {
+        console.log(`Message delivered to ${targetWidgetId}`)
+      }
+    } else {
+      console.error(`Failed: ${data.error}`)
+      process.exit(1)
+    }
+  } catch (err) {
+    if (err.name === 'TimeoutError') {
+      console.error(`Error: request timed out — is the dev server running? (tried ${serverUrl})`)
+    } else {
+      console.error(`Error: ${err.message}`)
+    }
+    process.exit(1)
+  }
+}
+
+export async function handleOutput() {
+  const args = process.argv.slice(4) // skip: node, sb, terminal, output
+  const { flags } = parseArgs(args)
+
+  const widgetId = flags.widget || process.env.STORYBOARD_WIDGET_ID
+  const summary = flags.summary || ''
+  const content = flags.content || ''
+
+  if (!widgetId) {
+    console.error('Error: --widget <id> or $STORYBOARD_WIDGET_ID required')
+    process.exit(1)
+  }
+
+  const serverUrl = getServerUrl()
+  try {
+    const res = await fetch(`${serverUrl}/_storyboard/canvas/terminal/output`, {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({ widgetId, content, summary }),
+      signal: AbortSignal.timeout(10000),
+    })
+    const data = await res.json()
+    if (data.success) {
+      console.log('Output saved')
+    } else {
+      console.error(`Failed: ${data.error}`)
+      process.exit(1)
+    }
+  } catch (err) {
+    if (err.name === 'TimeoutError') {
+      console.error(`Error: request timed out — is the dev server running? (tried ${serverUrl})`)
+    } else {
+      console.error(`Error: ${err.message}`)
+    }
+    process.exit(1)
+  }
+}
+
+export async function handleStatus() {
+  const args = process.argv.slice(4) // skip: node, sb, terminal, status
+  const { positional } = parseArgs(args)
+
+  const widgetId = positional[0]
+  if (!widgetId) {
+    console.error('Usage: storyboard terminal status <widgetId>')
+    process.exit(1)
+  }
+
+  try {
+    const { readTerminalConfigById, initTerminalConfig } = await import('../canvas/terminal-config.js')
+    initTerminalConfig(process.cwd())
+    const config = readTerminalConfigById(widgetId)
+    if (!config) {
+      console.error(`No config found for ${widgetId}`)
+      process.exit(1)
+    }
+    console.log(JSON.stringify({
+      widgetId: config.widgetId,
+      displayName: config.displayName || null,
+      agentStatus: config.agentStatus || null,
+      latestOutput: config.latestOutput ? { summary: config.latestOutput.summary, updatedAt: config.latestOutput.updatedAt } : null,
+      pendingMessages: (config.pendingMessages || []).length,
+    }, null, 2))
+  } catch (err) {
+    console.error(`Error: ${err.message}`)
+    process.exit(1)
+  }
+}
+
+export async function handleRead() {
+  const args = process.argv.slice(4) // skip: node, sb, terminal, read
+  const { positional, flags } = parseArgs(args)
+
+  const widgetId = positional[0] || process.env.STORYBOARD_WIDGET_ID
+  if (!widgetId) {
+    console.error('Usage: storyboard terminal read <widgetId> [--length N]')
+    process.exit(1)
+  }
+
+  const length = flags.length ? parseInt(flags.length, 10) : undefined
+
+  // Try HTTP API first (dev server may have fresher data)
+  try {
+    const serverUrl = getServerUrl()
+    const qs = length ? `?length=${length}` : ''
+    const res = await fetch(`${serverUrl}/_storyboard/canvas/terminal-buffer/${encodeURIComponent(widgetId)}${qs}`, {
+      signal: AbortSignal.timeout(3000),
+    })
+    if (res.ok) {
+      const data = await res.json()
+      console.log(JSON.stringify(data, null, 2))
+      return
+    }
+  } catch {
+    // Server not reachable — read directly from file
+  }
+
+  // Fallback: read buffer file directly
+  try {
+    const { readFileSync, existsSync } = await import('node:fs')
+    const { join } = await import('node:path')
+    const bufferPath = join(process.cwd(), '.storyboard', 'terminal-buffers', `${widgetId}.buffer.json`)
+    if (!existsSync(bufferPath)) {
+      console.error(`No buffer found for ${widgetId}`)
+      process.exit(1)
+    }
+    const data = JSON.parse(readFileSync(bufferPath, 'utf8'))
+    if (length) {
+      if (data.scrollback && data.scrollback.length > length) {
+        data.scrollback = data.scrollback.slice(-length)
+      }
+      if (data.paneContent && data.paneContent.length > length) {
+        data.paneContent = data.paneContent.slice(-length)
+      }
+    }
+    console.log(JSON.stringify(data, null, 2))
+  } catch (err) {
+    console.error(`Error: ${err.message}`)
+    process.exit(1)
+  }
+}