openrune 2.0.4 → 2.1.0

package/README.ko.md

@@ -34,6 +34,25 @@ Claude Code는 이미 서브에이전트, 훅, 스킬, 헤드리스 모드를
 
 ---
 
+## Agent Teams와 뭐가 다른가요?
+
+Claude Code의 Agent Teams는 런타임에 팀원을 생성합니다 — 강력하지만, 세션이 끝나면 사라집니다.
+
+Rune은 다른 접근을 합니다: **에이전트가 파일입니다.**
+
+| | Agent Teams | Rune |
+|---|---|---|
+| **영구 저장** | 세션 한정 — 완료되면 에이전트 소멸 | `.rune` 파일로 히스토리와 메모리가 영구 보존 |
+| **이동성** | 하나의 Claude Code 세션에 종속 | `.rune` 파일을 어디서든 공유, 버전 관리, 재사용 |
+| **스케줄링** | 수동 실행만 가능 | Cron, 파일 변경, git-commit 트리거 |
+| **권한** | 세션에서 상속 | 에이전트별 제어 (`fileWrite`, `bash`, `allowPaths`) |
+| **실행** | 대화형 | 헤드리스, 파이프라인, CI/CD 지원 |
+| **자기 수정** | 기본 제공 없음 | `rune loop` — 자동 리뷰-수정 반복 |
+
+Rune 에이전트는 세션, 머신, 팀을 넘어 살아남습니다. 한 번 만들면 영원히 실행.
+
+---
+
 ## Rune의 작동 방식
 
 Rune은 Claude API를 호출하거나, 인증 정보를 다루거나, Claude Code 내부를 래핑하지 않습니다. 모든 에이전트 호출은 공식 `claude` CLI에 대한 단순한 서브프로세스 호출입니다:
@@ -89,25 +108,6 @@ rune run reviewer.rune "Review the latest commit"
 
 ---
 
-## Agent Teams와 뭐가 다른가요?
-
-Claude Code의 Agent Teams는 런타임에 팀원을 생성합니다 — 강력하지만, 세션이 끝나면 사라집니다.
-
-Rune은 다른 접근을 합니다: **에이전트가 파일입니다.**
-
-| | Agent Teams | Rune |
-|---|---|---|
-| **영구 저장** | 세션 한정 — 완료되면 에이전트 소멸 | `.rune` 파일로 히스토리와 메모리가 영구 보존 |
-| **이동성** | 하나의 Claude Code 세션에 종속 | `.rune` 파일을 어디서든 공유, 버전 관리, 재사용 |
-| **스케줄링** | 수동 실행만 가능 | Cron, 파일 변경, git-commit 트리거 |
-| **권한** | 세션에서 상속 | 에이전트별 제어 (`fileWrite`, `bash`, `allowPaths`) |
-| **실행** | 대화형 | 헤드리스, 파이프라인, CI/CD 지원 |
-| **자기 수정** | 기본 제공 없음 | `rune loop` — 자동 리뷰-수정 반복 |
-
-Rune 에이전트는 세션, 머신, 팀을 넘어 살아남습니다. 한 번 만들면 영원히 실행.
-
----
-
 ## 핵심 개념
 
 ### 파일 하나 = 에이전트 하나

package/README.md

@@ -34,6 +34,25 @@ If you just want a one-off specialized agent inside a single session, Claude Cod
 
 ---
 
+## How is Rune different from Agent Teams?
+
+Claude Code's Agent Teams spawn teammates at runtime — powerful, but ephemeral. When the session ends, the agents are gone.
+
+Rune takes a different approach: **agents are files.**
+
+| | Agent Teams | Rune |
+|---|---|---|
+| **Persistence** | Session-only — agents disappear when done | `.rune` files persist forever with history and memory |
+| **Portability** | Tied to a single Claude Code session | Share, version-control, and reuse `.rune` files anywhere |
+| **Scheduling** | Manual execution only | Cron, file-change, and git-commit triggers |
+| **Permissions** | Inherited from session | Per-agent controls (`fileWrite`, `bash`, `allowPaths`) |
+| **Execution** | Interactive | Headless, pipelines, CI/CD-ready |
+| **Self-correction** | Not built-in | `rune loop` — automatic review-fix cycles |
+
+Rune agents survive across sessions, machines, and teams. Build once, run forever.
+
+---
+
 ## How Rune works
 
 Rune does not call the Claude API, handle any credentials, or wrap Claude Code's internals. Every agent invocation is a plain subprocess call to the official `claude` CLI:
@@ -89,25 +108,6 @@ That's it. You just built an agent.
 
 ---
 
-## How is Rune different from Agent Teams?
-
-Claude Code's Agent Teams spawn teammates at runtime — powerful, but ephemeral. When the session ends, the agents are gone.
-
-Rune takes a different approach: **agents are files.**
-
-| | Agent Teams | Rune |
-|---|---|---|
-| **Persistence** | Session-only — agents disappear when done | `.rune` files persist forever with history and memory |
-| **Portability** | Tied to a single Claude Code session | Share, version-control, and reuse `.rune` files anywhere |
-| **Scheduling** | Manual execution only | Cron, file-change, and git-commit triggers |
-| **Permissions** | Inherited from session | Per-agent controls (`fileWrite`, `bash`, `allowPaths`) |
-| **Execution** | Interactive | Headless, pipelines, CI/CD-ready |
-| **Self-correction** | Not built-in | `rune loop` — automatic review-fix cycles |
-
-Rune agents survive across sessions, machines, and teams. Build once, run forever.
-
----
-
 ## Core Concepts
 
 ### One file = one agent

package/bin/rune.js

@@ -19,6 +19,8 @@ switch (command) {
   case 'loop':    return loopRunes(args)
   case 'watch':   return watchRune(args[0], args.slice(1))
   case 'list':    return listRunes()
+  case 'backup':  return backupRune(args[0], args.slice(1))
+  case 'inbound': return inboundRune(args[0], args.slice(1))
   case 'open':
     console.log('  ℹ️  `rune open` has been removed from the CLI.')
     console.log('     For a GUI, use RuneChat: https://github.com/gilhyun/runechat')
@@ -982,6 +984,215 @@ function listRunes() {
   }
 }
 
+// ── backup ──────────────────────────────────────
+
+function backupRune(file, restArgs) {
+  if (!file) {
+    console.log('Usage: rune backup <file.rune> [--format md|json|rune] [--output <path>]')
+    console.log('')
+    console.log('Formats:')
+    console.log('  md     Markdown — readable conversation export (default)')
+    console.log('  json   JSON — full data including memory and metadata')
+    console.log('  rune   Clone — timestamped copy of the .rune file')
+    console.log('')
+    console.log('Examples:')
+    console.log('  rune backup reviewer.rune')
+    console.log('  rune backup reviewer.rune --format json')
+    console.log('  rune backup reviewer.rune --format rune --output backups/')
+    process.exit(1)
+  }
+
+  const filePath = path.resolve(process.cwd(), file)
+  if (!fs.existsSync(filePath)) {
+    console.error(`  ❌ File not found: ${filePath}`)
+    process.exit(1)
+  }
+
+  // Parse args
+  let format = 'md'
+  let outputPath = ''
+  for (let i = 0; i < restArgs.length; i++) {
+    if (restArgs[i] === '--format' && restArgs[i + 1]) { format = restArgs[++i] }
+    else if (restArgs[i] === '--output' && restArgs[i + 1]) { outputPath = restArgs[++i] }
+  }
+
+  const rune = JSON.parse(fs.readFileSync(filePath, 'utf-8'))
+  const ts = new Date().toISOString().replace(/[:.]/g, '-').slice(0, 19)
+  const baseName = rune.name || path.basename(file, '.rune')
+
+  let outFile, content
+
+  if (format === 'md') {
+    outFile = `${baseName}-backup-${ts}.md`
+    const lines = []
+    lines.push(`# ${rune.name} — Conversation Backup`)
+    lines.push(``)
+    lines.push(`- **Role**: ${rune.role || 'N/A'}`)
+    lines.push(`- **Created**: ${rune.createdAt || 'N/A'}`)
+    lines.push(`- **Exported**: ${new Date().toISOString()}`)
+    lines.push(`- **Messages**: ${(rune.history || []).length}`)
+    lines.push(``)
+
+    if (rune.memory && rune.memory.length > 0) {
+      lines.push(`## Memory`)
+      lines.push(``)
+      rune.memory.forEach((m, i) => lines.push(`${i + 1}. ${m}`))
+      lines.push(``)
+    }
+
+    if (rune.history && rune.history.length > 0) {
+      lines.push(`## Conversation`)
+      lines.push(``)
+      for (const msg of rune.history) {
+        const who = msg.role === 'user' ? '**User**' : '**Assistant**'
+        const time = msg.ts ? new Date(msg.ts).toLocaleString() : ''
+        lines.push(`### ${who} ${time ? `(${time})` : ''}`)
+        lines.push(``)
+        lines.push(msg.text)
+        lines.push(``)
+        lines.push(`---`)
+        lines.push(``)
+      }
+    }
+
+    content = lines.join('\n')
+
+  } else if (format === 'json') {
+    outFile = `${baseName}-backup-${ts}.json`
+    content = JSON.stringify({
+      ...rune,
+      _backup: {
+        exportedAt: new Date().toISOString(),
+        sourceFile: filePath,
+        messageCount: (rune.history || []).length,
+      }
+    }, null, 2)
+
+  } else if (format === 'rune') {
+    outFile = `${baseName}-backup-${ts}.rune`
+    content = JSON.stringify(rune, null, 2)
+
+  } else {
+    console.error(`  ❌ Unknown format: ${format}. Use: md, json, rune`)
+    process.exit(1)
+  }
+
+  // Resolve output path
+  if (outputPath) {
+    const resolved = path.resolve(process.cwd(), outputPath)
+    if (fs.existsSync(resolved) && fs.statSync(resolved).isDirectory()) {
+      outFile = path.join(resolved, outFile)
+    } else {
+      // Treat as file path
+      outFile = resolved
+    }
+  } else {
+    outFile = path.resolve(process.cwd(), outFile)
+  }
+
+  // Ensure parent dir exists
+  const outDir = path.dirname(outFile)
+  if (!fs.existsSync(outDir)) fs.mkdirSync(outDir, { recursive: true })
+
+  fs.writeFileSync(outFile, content)
+
+  const stats = {
+    messages: (rune.history || []).length,
+    memory: (rune.memory || []).length,
+    size: fs.statSync(outFile).size,
+  }
+
+  console.log(`📦 Backup created`)
+  console.log(`   Agent: ${rune.name} (${rune.role || 'N/A'})`)
+  console.log(`   Format: ${format}`)
+  console.log(`   Messages: ${stats.messages}, Memory: ${stats.memory}`)
+  console.log(`   Size: ${(stats.size / 1024).toFixed(1)} KB`)
+  console.log(`   Output: ${outFile}`)
+}
+
+
+// ── inbound ─────────────────────────────────────
+
+function inboundRune(file, restArgs) {
+  if (!file) {
+    console.log('Usage: rune inbound <file.rune> "message" [--run] [--auto] [--source <name>]')
+    console.log('')
+    console.log('Options:')
+    console.log('  --run              Send the message and immediately run the agent')
+    console.log('  --auto             Run in auto mode (agent can write files, run commands)')
+    console.log('  --source <name>    Label the message source (default: "external")')
+    console.log('')
+    console.log('Without --run, the message is queued in history for the next rune run.')
+    console.log('')
+    console.log('Examples:')
+    console.log('  rune inbound reviewer.rune "PR #42 is ready for review" --run')
+    console.log('  rune inbound coder.rune "Build failed, fix it" --run --auto')
+    console.log('  rune inbound monitor.rune "Deploy complete" --source deploy-bot')
+    console.log('  echo "Error log..." | rune inbound coder.rune --run --auto')
+    process.exit(1)
+  }
+
+  const filePath = path.resolve(process.cwd(), file)
+  if (!fs.existsSync(filePath)) {
+    console.error(`  ❌ File not found: ${filePath}`)
+    process.exit(1)
+  }
+
+  // Parse args
+  let message = ''
+  let shouldRun = false
+  let autoMode = false
+  let source = 'external'
+
+  for (let i = 0; i < restArgs.length; i++) {
+    if (restArgs[i] === '--run') { shouldRun = true }
+    else if (restArgs[i] === '--auto') { autoMode = true; shouldRun = true }
+    else if (restArgs[i] === '--source' && restArgs[i + 1]) { source = restArgs[++i] }
+    else if (!message) { message = restArgs[i] }
+  }
+
+  // Read from stdin if no message
+  if (!message && process.stdin.isTTY === false) {
+    message = fs.readFileSync('/dev/stdin', 'utf-8').trim()
+  }
+
+  if (!message) {
+    console.error('  ❌ No message provided. Pass a message string or pipe via stdin.')
+    process.exit(1)
+  }
+
+  const rune = JSON.parse(fs.readFileSync(filePath, 'utf-8'))
+
+  // Add message to history with source metadata
+  rune.history = rune.history || []
+  rune.history.push({
+    role: 'user',
+    text: message,
+    ts: Date.now(),
+    source,
+  })
+  fs.writeFileSync(filePath, JSON.stringify(rune, null, 2))
+
+  console.log(`📨 Message delivered to ${rune.name}`)
+  console.log(`   From: ${source}`)
+  console.log(`   Text: ${message.slice(0, 100)}${message.length > 100 ? '...' : ''}`)
+
+  if (!shouldRun) {
+    console.log(`   Status: Queued (will be seen on next rune run)`)
+    console.log(`\n   To run now: rune run ${file} "continue"`)
+    return
+  }
+
+  // Run the agent with the inbound message
+  console.log(`   Status: Running agent...\n`)
+
+  const runArgs = [file, message]
+  if (autoMode) runArgs.push('--auto')
+
+  return runRune(file, runArgs.slice(1))
+}
+
+
 // ── help ─────────────────────────────────────────
 
 function showHelp() {
@@ -1006,6 +1217,13 @@ Usage:
     --prompt "..."          Prompt to send when triggered
     --glob "*.ts"           File pattern (for file-change)
     --interval 5m           Schedule interval (for cron: 30s, 5m, 1h)
+  rune backup <file.rune>   Export agent conversation/data
+    --format md|json|rune   Output format (default: md)
+    --output <path>         Output file or directory
+  rune inbound <file.rune> "msg"   Send external message to agent
+    --run                   Immediately run the agent after delivery
+    --auto                  Run in auto mode (implies --run)
+    --source <name>         Label the message source (default: "external")
   rune list                 List .rune files in current directory
   rune help                 Show this help
 
@@ -1015,6 +1233,9 @@ Examples:
   rune pipe coder.rune reviewer.rune "Implement a login page"
   rune loop coder.rune reviewer.rune "Build a REST API" --until "no critical issues" --max-iterations 3 --auto
   rune watch reviewer.rune --on git-commit --prompt "Review this commit"
+  rune backup reviewer.rune --format md
+  rune inbound coder.rune "Build failed, fix it" --run --auto
+  echo "Error log..." | rune inbound coder.rune --run --auto
   echo "Fix the bug in auth.ts" | rune run backend.rune
 
 Looking for a GUI? Check out RuneChat: https://github.com/gilhyun/runechat

package/lib/index.js

@@ -120,4 +120,90 @@ async function pipe(runeFiles, prompt) {
   return { pipeline: results, finalOutput: currentInput }
 }
 
-module.exports = { load, pipe }
+/**
+ * Backup a .rune file to md/json/rune format
+ * @param {string} filePath - path to .rune file
+ * @param {object} opts - { format: 'md'|'json'|'rune' }
+ * @returns {{ content: string, filename: string }}
+ */
+function backup(filePath, opts = {}) {
+  const resolved = path.resolve(filePath)
+  if (!fs.existsSync(resolved)) {
+    throw new Error(`Rune file not found: ${resolved}`)
+  }
+
+  const rune = JSON.parse(fs.readFileSync(resolved, 'utf-8'))
+  const format = opts.format || 'md'
+  const ts = new Date().toISOString().replace(/[:.]/g, '-').slice(0, 19)
+  const baseName = rune.name || path.basename(filePath, '.rune')
+
+  if (format === 'md') {
+    const lines = []
+    lines.push(`# ${rune.name} — Conversation Backup\n`)
+    lines.push(`- **Role**: ${rune.role || 'N/A'}`)
+    lines.push(`- **Exported**: ${new Date().toISOString()}`)
+    lines.push(`- **Messages**: ${(rune.history || []).length}\n`)
+
+    if (rune.memory && rune.memory.length > 0) {
+      lines.push(`## Memory\n`)
+      rune.memory.forEach((m, i) => lines.push(`${i + 1}. ${m}`))
+      lines.push('')
+    }
+
+    if (rune.history && rune.history.length > 0) {
+      lines.push(`## Conversation\n`)
+      for (const msg of rune.history) {
+        const who = msg.role === 'user' ? '**User**' : '**Assistant**'
+        const time = msg.ts ? new Date(msg.ts).toLocaleString() : ''
+        lines.push(`### ${who} ${time ? `(${time})` : ''}\n`)
+        lines.push(msg.text)
+        lines.push('\n---\n')
+      }
+    }
+
+    return { content: lines.join('\n'), filename: `${baseName}-backup-${ts}.md` }
+  }
+
+  if (format === 'json') {
+    return {
+      content: JSON.stringify({ ...rune, _backup: { exportedAt: new Date().toISOString(), sourceFile: resolved } }, null, 2),
+      filename: `${baseName}-backup-${ts}.json`,
+    }
+  }
+
+  if (format === 'rune') {
+    return {
+      content: JSON.stringify(rune, null, 2),
+      filename: `${baseName}-backup-${ts}.rune`,
+    }
+  }
+
+  throw new Error(`Unknown format: ${format}`)
+}
+
+/**
+ * Send an inbound message to a .rune agent
+ * @param {string} filePath - path to .rune file
+ * @param {string} message - the message text
+ * @param {object} opts - { source: string }
+ */
+function inbound(filePath, message, opts = {}) {
+  const resolved = path.resolve(filePath)
+  if (!fs.existsSync(resolved)) {
+    throw new Error(`Rune file not found: ${resolved}`)
+  }
+
+  const rune = JSON.parse(fs.readFileSync(resolved, 'utf-8'))
+  rune.history = rune.history || []
+  rune.history.push({
+    role: 'user',
+    text: message,
+    ts: Date.now(),
+    source: opts.source || 'external',
+  })
+  fs.writeFileSync(resolved, JSON.stringify(rune, null, 2))
+
+  return { agent: rune.name, queued: true, historyLength: rune.history.length }
+}
+
+module.exports = { load, pipe, backup, inbound }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "openrune",
-  "version": "2.0.4",
+  "version": "2.1.0",
   "description": "Persistent AI agents for Claude Code — build once, run forever.",
   "keywords": ["ai", "agent", "claude", "claude-code", "cli", "toolkit", "automation"],
   "repository": {