openrune 1.1.2 → 2.0.0

package/package.json

@@ -1,8 +1,8 @@
 {
   "name": "openrune",
-  "version": "1.1.2",
+  "version": "2.0.0",
   "description": "Persistent AI agents for Claude Code — build once, run forever.",
-  "keywords": ["ai", "agent", "claude", "desktop", "electron", "mcp", "claude-code", "toolkit", "automation"],
+  "keywords": ["ai", "agent", "claude", "claude-code", "cli", "toolkit", "automation"],
   "repository": {
     "type": "git",
     "url": "https://github.com/gilhyun/Rune.git"
@@ -10,48 +10,18 @@
   "homepage": "https://github.com/gilhyun/Rune",
   "license": "MIT",
   "author": "gilhyun",
-  "main": "bootstrap.js",
+  "main": "lib/index.js",
   "exports": {
     ".": "./lib/index.js"
   },
   "bin": {
     "rune": "bin/rune.js"
   },
-  "scripts": {
-    "pack": "electron-builder --dir",
-    "dist": "electron-builder",
-    "build:main": "esbuild src/main.ts --bundle --platform=node --outfile=dist/main.js --external:electron --external:node-pty && esbuild src/preload.ts --bundle --platform=node --outfile=dist/preload.js --external:electron && esbuild channel/rune-channel.ts --bundle --platform=node --outfile=dist/rune-channel.js",
-    "build:renderer": "cd renderer && npx vite build",
-    "build": "npm run build:main && npm run build:renderer",
-    "postinstall": "node bin/rune.js install",
-    "start": "npm run build && electron .",
-    "dev": "npm run build && electron ."
-  },
-  "devDependencies": {
-    "@types/node": "^22.0.0",
-    "@types/react": "^19.2.14",
-    "@types/react-dom": "^19.2.3",
-    "@types/ws": "^8.18.1",
-    "electron-builder": "^25.0.0",
-    "typescript": "^5.7.0"
-  },
-  "dependencies": {
-    "@electron/rebuild": "^3.7.1",
-    "@modelcontextprotocol/sdk": "^1.27.1",
-    "@tailwindcss/vite": "^4.2.2",
-    "@vitejs/plugin-react": "^6.0.1",
-    "@xterm/addon-fit": "^0.11.0",
-    "@xterm/xterm": "^6.0.0",
-    "clsx": "^2.1.1",
-    "electron": "^28.3.3",
-    "esbuild": "^0.27.4",
-    "lucide-react": "^0.577.0",
-    "node-pty": "^1.1.0",
-    "react": "^19.2.4",
-    "react-dom": "^19.2.4",
-    "sonner": "^2.0.7",
-    "tailwind-merge": "^3.5.0",
-    "tailwindcss": "^4.2.2",
-    "vite": "^8.0.1"
-  }
+  "files": [
+    "bin",
+    "lib",
+    "LICENSE",
+    "README.md",
+    "README.ko.md"
+  ]
 }

package/.claude-plugin/marketplace.json

@@ -1,17 +0,0 @@
-{
-  "$schema": "https://anthropic.com/claude-code/marketplace.schema.json",
-  "name": "rune",
-  "description": "Rune — File-based AI Agent Desktop App plugins",
-  "owner": {
-    "name": "gilhyun",
-    "email": "gilhyun@github.com"
-  },
-  "plugins": [
-    {
-      "name": "rune-channel",
-      "description": "Rune desktop app channel for Claude Code",
-      "source": "./",
-      "category": "development"
-    }
-  ]
-}

package/.claude-plugin/plugin.json

@@ -1,24 +0,0 @@
-{
-  "name": "rune-channel",
-  "version": "0.1.0",
-  "description": "Rune desktop app channel for Claude Code — bridges Claude Code with the Rune AI agent UI",
-  "author": {
-    "name": "gilhyun",
-    "url": "https://github.com/gilhyun"
-  },
-  "homepage": "https://github.com/gilhyun/Rune",
-  "repository": "https://github.com/gilhyun/Rune",
-  "license": "MIT",
-  "keywords": ["rune", "channel", "mcp", "desktop", "agent"],
-  "mcpServers": {
-    "rune-channel": {
-      "command": "node",
-      "args": ["${CLAUDE_PLUGIN_ROOT}/dist/rune-channel.js"]
-    }
-  },
-  "channels": [
-    {
-      "server": "rune-channel"
-    }
-  ]
-}

package/.mcp.json

@@ -1,16 +0,0 @@
-{
-  "mcpServers": {
-    "rune-channel": {
-      "command": "node",
-      "args": [
-        "/Users/gilhyun/IdeaProjects/Rune/dist/rune-channel.js"
-      ],
-      "env": {
-        "RUNE_FOLDER_PATH": "/Users/gilhyun/IdeaProjects/Rune",
-        "RUNE_CHANNEL_PORT": "51234",
-        "RUNE_AGENT_ROLE": "General assistant",
-        "RUNE_FILE_PATH": "/Users/gilhyun/IdeaProjects/Rune/Rune.rune"
-      }
-    }
-  }
-}

package/bootstrap.js

@@ -1,8 +0,0 @@
-// When loaded via Electron, start the desktop app
-// When loaded via require('openrune'), export the Node.js API
-try {
-  require('electron')
-  require('./dist/main.js')
-} catch {
-  module.exports = require('./lib/index.js')
-}

package/channel/rune-channel.ts

@@ -1,486 +0,0 @@
-import { Server } from '@modelcontextprotocol/sdk/server/index.js'
-import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js'
-import { ListToolsRequestSchema, CallToolRequestSchema } from '@modelcontextprotocol/sdk/types.js'
-import * as http from 'http'
-
-import * as fs from 'fs'
-
-const PORT = Number(process.env.RUNE_CHANNEL_PORT || 51234)
-const FOLDER_PATH = process.env.RUNE_FOLDER_PATH || ''
-const AGENT_ROLE = process.env.RUNE_AGENT_ROLE || ''
-const RUNE_FILE_PATH = process.env.RUNE_FILE_PATH || ''
-
-// ── .rune File I/O ──────────────────────────────
-interface RuneFile {
-  name: string
-  role: string
-  history?: { role: 'user' | 'assistant'; text: string; ts: number }[]
-  memory?: string[]
-  [key: string]: unknown
-}
-
-function readRuneFile(): RuneFile | null {
-  if (!RUNE_FILE_PATH) return null
-  try {
-    return JSON.parse(fs.readFileSync(RUNE_FILE_PATH, 'utf-8'))
-  } catch {
-    return null
-  }
-}
-
-function writeRuneFile(data: RuneFile) {
-  if (!RUNE_FILE_PATH) return
-  try {
-    fs.writeFileSync(RUNE_FILE_PATH, JSON.stringify(data, null, 2), 'utf-8')
-  } catch (e: any) {
-    console.error(`[rune-channel] Failed to write .rune file: ${e.message}`)
-  }
-}
-
-function buildSessionContext(): string {
-  const rune = readRuneFile()
-  if (!rune) return ''
-
-  const parts: string[] = []
-
-  // Memory
-  if (rune.memory && rune.memory.length > 0) {
-    parts.push('## Saved Memory')
-    parts.push('These are notes you saved from previous sessions:')
-    rune.memory.forEach((m, i) => parts.push(`${i + 1}. ${m}`))
-  }
-
-  // History: last 50 messages, recent 10 in full detail
-  if (rune.history && rune.history.length > 0) {
-    const TOTAL_LIMIT = 50
-    const FULL_DETAIL_COUNT = 10
-    const recent = rune.history.slice(-TOTAL_LIMIT)
-    const olderMessages = recent.slice(0, -FULL_DETAIL_COUNT)
-    const recentMessages = recent.slice(-FULL_DETAIL_COUNT)
-
-    parts.push('\n## Conversation History')
-    parts.push(`(${rune.history.length} total messages, showing last ${recent.length})`)
-
-    // Older messages: summarized (truncated to 500 chars)
-    if (olderMessages.length > 0) {
-      parts.push('\n### Earlier Context')
-      for (const msg of olderMessages) {
-        const who = msg.role === 'user' ? 'User' : 'You'
-        const text = msg.text.length > 500 ? msg.text.slice(0, 500) + '...' : msg.text
-        parts.push(`- **${who}**: ${text}`)
-      }
-    }
-
-    // Recent messages: full text (no truncation)
-    if (recentMessages.length > 0) {
-      parts.push('\n### Recent Messages (Full Detail)')
-      for (const msg of recentMessages) {
-        const who = msg.role === 'user' ? 'User' : 'You'
-        parts.push(`- **${who}**: ${msg.text}`)
-      }
-    }
-  }
-
-  return parts.join('\n')
-}
-
-// ── MCP Server ──────────────────────────────────
-
-const mcp = new Server(
-  { name: 'rune-channel', version: '0.1.0' },
-  {
-    capabilities: {
-      experimental: { 'claude/channel': {} },
-      tools: {},
-    },
-    instructions: `You are an AI agent running inside the Rune desktop app.
-
-## System Info
-- Current time: ${new Date().toISOString()} (${Intl.DateTimeFormat().resolvedOptions().timeZone})
-- Local time: ${new Date().toLocaleString('en-US', { timeZone: Intl.DateTimeFormat().resolvedOptions().timeZone, hour12: false })}
-- Working folder: ${FOLDER_PATH || '(none)'}
-${AGENT_ROLE ? `\n## Your Role\n${AGENT_ROLE}\n` : ''}
-Messages arrive as <channel source="rune-channel" type="..." request_id="...">.
-
-## Message types
-- type="chat": User message from the Rune chat UI. Always reply using the rune_reply tool with the request_id.
-
-## CRITICAL: ALL output MUST go through rune_reply
-You are connected to a desktop app UI. The user CANNOT see your regular text output — they can ONLY see messages sent via rune_reply.
-- NEVER output plain text without calling rune_reply. Any text not sent through rune_reply is invisible to the user.
-- For chat messages: call rune_reply with the request_id.
-- For proactive updates: call rune_reply WITHOUT request_id to push via SSE.
-- If you need to do multi-step work (fetch data, analyze, etc.), do all the work FIRST, then send ONE comprehensive rune_reply at the end.
-- Even error messages and status updates must go through rune_reply.
-
-## CRITICAL: Report ALL activities via rune_activity
-The user wants to see EVERYTHING you do — thinking, tool calls, and results — in real-time, just like the Claude Code VSCode plugin.
-- BEFORE you start working on a request, call rune_activity with type="thinking" and share your plan/reasoning.
-- BEFORE each tool call (Read, Edit, Bash, Write, Grep, Glob, etc.), call rune_activity with type="tool_use", tool name, and key args.
-- AFTER each tool call completes, call rune_activity with type="tool_result", tool name, and a brief summary of the result.
-- This makes your work transparent. Without rune_activity calls, the user sees a blank screen until rune_reply.
-- Keep thinking text concise but informative. For tool results, summarize key findings (1-2 sentences).
-- You MUST call rune_activity for EVERY tool you use. Do NOT skip any.
-
-## CRITICAL: Actions, Not Words
-When the user asks you to do something, ACTUALLY DO IT. Never just describe what you would do.
-- Read files, write code, run commands — take action.
-- Only explain when the user asks for an explanation.
-
-## Memory
-You have a rune_memory tool to save persistent notes across sessions.
-- Save important context: user preferences, project decisions, key findings, recurring patterns.
-- Memory is stored in the .rune file and provided to you at the start of each session.
-- Use it proactively when you learn something worth remembering.
-`,
-  }
-)
-
-// ── Pending Replies ──────────────────────────────
-
-const pendingReplies = new Map<string, (text: string) => void>()
-const sseClients = new Set<http.ServerResponse>()
-let mcpConnected = false
-let sessionStarted = false
-
-function broadcastSSE(data: Record<string, unknown>) {
-  const msg = `data: ${JSON.stringify(data)}\n\n`
-  for (const client of sseClients) {
-    try { client.write(msg) } catch {}
-  }
-}
-
-// ── Tools ────────────────────────────────────────
-
-mcp.setRequestHandler(ListToolsRequestSchema, async () => ({
-  tools: [
-    {
-      name: 'rune_reply',
-      description: 'Send a reply back to the Rune UI. Use this for every chat message. If request_id is omitted, the message is pushed as a proactive notification.',
-      inputSchema: {
-        type: 'object' as const,
-        properties: {
-          request_id: { type: 'string', description: 'The request_id from the incoming channel message. Omit to send a proactive push message.' },
-          text: { type: 'string', description: 'Your response in markdown' },
-        },
-        required: ['text'],
-      },
-    },
-    {
-      name: 'rune_activity',
-      description: 'Report your current activity to the Rune chat UI in real-time. Call this BEFORE and AFTER each action so the user can see what you are doing. This makes your work visible — without it, the user sees nothing until rune_reply.',
-      inputSchema: {
-        type: 'object' as const,
-        properties: {
-          type: {
-            type: 'string',
-            enum: ['thinking', 'tool_use', 'tool_result'],
-            description: 'thinking: share your reasoning/plan. tool_use: report a tool you are about to call. tool_result: report the result of a tool call.',
-          },
-          content: { type: 'string', description: 'For thinking: your reasoning text. For tool_result: a brief summary of what happened.' },
-          tool: { type: 'string', description: 'Tool name (e.g. Read, Edit, Bash, Grep, Write). Required for tool_use and tool_result.' },
-          args: {
-            type: 'object',
-            description: 'Key arguments for the tool call (e.g. {file_path: "/foo.ts"} or {command: "npm test"}). For tool_use only.',
-          },
-        },
-        required: ['type'],
-      },
-    },
-    {
-      name: 'rune_search_history',
-      description: 'Search past conversation history by keyword. Returns matching messages with surrounding context. Use this when the user references a past conversation or you need to recall previous discussions.',
-      inputSchema: {
-        type: 'object' as const,
-        properties: {
-          query: { type: 'string', description: 'Search keyword or phrase to find in past messages' },
-          limit: { type: 'number', description: 'Max number of results to return (default: 10)' },
-        },
-        required: ['query'],
-      },
-    },
-    {
-      name: 'rune_memory',
-      description: 'Save, list, or delete persistent memory notes in the .rune file. Use this to remember important context across sessions — user preferences, project decisions, key findings, etc. Memory persists even when the session ends.',
-      inputSchema: {
-        type: 'object' as const,
-        properties: {
-          action: { type: 'string', enum: ['save', 'list', 'delete'], description: 'save: add a new memory note. list: show all saved memories. delete: remove a memory by index (1-based).' },
-          text: { type: 'string', description: 'The memory note to save (required for "save" action)' },
-          index: { type: 'number', description: 'The 1-based index of the memory to delete (required for "delete" action)' },
-        },
-        required: ['action'],
-      },
-    },
-  ],
-}))
-
-mcp.setRequestHandler(CallToolRequestSchema, async (req) => {
-  const toolName = req.params.name
-
-  // Broadcast tool_start for non-internal tools
-  if (toolName !== 'rune_reply' && toolName !== 'rune_memory' && toolName !== 'rune_activity') {
-    const argsSummary: Record<string, unknown> = {}
-    const rawArgs = req.params.arguments as Record<string, unknown> | undefined
-    if (rawArgs) {
-      for (const [k, v] of Object.entries(rawArgs)) {
-        if (typeof v === 'string' && v.length > 80) argsSummary[k] = (v as string).slice(0, 80) + '…'
-        else argsSummary[k] = v
-      }
-    }
-    broadcastSSE({ type: 'tool_start', tool: toolName, args: argsSummary })
-  }
-
-  // rune_activity tool — real-time activity reporting
-  if (req.params.name === 'rune_activity') {
-    const { type: activityType, content, tool, args } = req.params.arguments as {
-      type: string; content?: string; tool?: string; args?: Record<string, unknown>
-    }
-    broadcastSSE({ type: 'activity', activityType, content, tool, args })
-    return { content: [{ type: 'text' as const, text: 'ok' }] }
-  }
-
-  if (req.params.name === 'rune_reply') {
-    const { request_id, text } = req.params.arguments as { request_id?: string; text: string }
-    if (request_id) {
-      const resolve = pendingReplies.get(request_id)
-      if (resolve) {
-        resolve(text)
-        pendingReplies.delete(request_id)
-      } else {
-        broadcastSSE({ type: 'push', text })
-      }
-    } else {
-      broadcastSSE({ type: 'push', text })
-    }
-    return { content: [{ type: 'text' as const, text: 'sent' }] }
-  }
-
-  // rune_search_history tool
-  if (req.params.name === 'rune_search_history') {
-    const { query, limit: maxResults } = req.params.arguments as { query: string; limit?: number }
-    const rune = readRuneFile()
-    if (!rune || !rune.history || rune.history.length === 0) {
-      return { content: [{ type: 'text' as const, text: 'No conversation history found.' }] }
-    }
-
-    const cap = maxResults || 10
-    const keywords = query.toLowerCase().split(/\s+/)
-    const scored: { idx: number; msg: typeof rune.history[0]; score: number }[] = []
-
-    for (let i = 0; i < rune.history.length; i++) {
-      const text = rune.history[i].text.toLowerCase()
-      let score = 0
-      for (const kw of keywords) {
-        if (text.includes(kw)) score++
-      }
-      if (score > 0) scored.push({ idx: i, msg: rune.history[i], score })
-    }
-
-    if (scored.length === 0) {
-      return { content: [{ type: 'text' as const, text: `No messages matching "${query}".` }] }
-    }
-
-    scored.sort((a, b) => b.score - a.score)
-    const results = scored.slice(0, cap)
-
-    const output = results.map(r => {
-      const who = r.msg.role === 'user' ? 'User' : 'Assistant'
-      const date = new Date(r.msg.ts).toLocaleString()
-      const text = r.msg.text.length > 300 ? r.msg.text.slice(0, 300) + '…' : r.msg.text
-      return `[#${r.idx + 1} | ${date} | ${who}]\n${text}`
-    }).join('\n\n---\n\n')
-
-    return { content: [{ type: 'text' as const, text: `Found ${scored.length} matches (showing top ${results.length}):\n\n${output}` }] }
-  }
-
-  // rune_memory tool
-  if (req.params.name === 'rune_memory') {
-    const { action, text, index } = req.params.arguments as { action: string; text?: string; index?: number }
-    const rune = readRuneFile()
-    if (!rune) {
-      return { content: [{ type: 'text' as const, text: 'No .rune file available' }], isError: true }
-    }
-    if (!rune.memory) rune.memory = []
-
-    if (action === 'save') {
-      if (!text) return { content: [{ type: 'text' as const, text: 'text is required for save action' }], isError: true }
-      rune.memory.push(text)
-      writeRuneFile(rune)
-      broadcastSSE({ type: 'memory_update' })
-      return { content: [{ type: 'text' as const, text: `Memory saved (${rune.memory.length} total)` }] }
-    }
-
-    if (action === 'list') {
-      if (rune.memory.length === 0) {
-        return { content: [{ type: 'text' as const, text: 'No memories saved yet.' }] }
-      }
-      const list = rune.memory.map((m, i) => `${i + 1}. ${m}`).join('\n')
-      return { content: [{ type: 'text' as const, text: `Saved memories:\n${list}` }] }
-    }
-
-    if (action === 'delete') {
-      if (!index || index < 1 || index > rune.memory.length) {
-        return { content: [{ type: 'text' as const, text: `Invalid index. Valid range: 1-${rune.memory.length}` }], isError: true }
-      }
-      const removed = rune.memory.splice(index - 1, 1)
-      writeRuneFile(rune)
-      broadcastSSE({ type: 'memory_update' })
-      return { content: [{ type: 'text' as const, text: `Deleted: "${removed[0]}" (${rune.memory.length} remaining)` }] }
-    }
-
-    return { content: [{ type: 'text' as const, text: `Unknown action: ${action}` }], isError: true }
-  }
-
-  // Unknown tool
-  return { content: [{ type: 'text' as const, text: `Unknown tool: ${toolName}` }], isError: true }
-})
-
-// ── Main ─────────────────────────────────────────
-
-async function main() {
-  const transport = new StdioServerTransport()
-  await mcp.connect(transport)
-  mcpConnected = true
-  console.error(`[rune-channel] MCP connected (port=${PORT}, folder=${FOLDER_PATH})`)
-
-  // Notify Claude about session start with history + memory context
-  setTimeout(() => {
-    const rune = readRuneFile()
-    const hasHistory = rune?.history && rune.history.length > 0
-    const sessionContext = buildSessionContext()
-    const contextBlock = sessionContext ? `\n\n${sessionContext}` : ''
-    const greetInstruction = hasHistory
-      ? ''
-      : `\n\nThis is a new conversation with no prior history. Greet the user briefly via rune_reply (no request_id). Introduce yourself based on your role and mention the working folder. Keep it short — 1-2 sentences.`
-    mcp.notification({
-      method: 'notifications/claude/channel',
-      params: {
-        content: `[SESSION_START] Channel connected. Folder: ${FOLDER_PATH || 'none'}${AGENT_ROLE ? `. Role: ${AGENT_ROLE}` : ''}${contextBlock}\n\nUse the rune_memory tool to save important context that should persist across sessions.${greetInstruction}`,
-        meta: { type: 'session_start' },
-      },
-    }).then(() => {
-      sessionStarted = true
-      broadcastSSE({ type: 'session_start' })
-    }).catch((e: any) => console.error(`[rune-channel] Startup notification failed: ${e.message}`))
-  }, 1000)
-
-  // Handle disconnect
-  function handleDisconnect(reason: string) {
-    if (!mcpConnected) return
-    console.error(`[rune-channel] ${reason}, shutting down`)
-    mcpConnected = false
-    broadcastSSE({ type: 'mcp_disconnected' })
-    setTimeout(() => process.exit(0), 500)
-  }
-
-  mcp.onclose = () => handleDisconnect('MCP connection closed')
-  process.stdin.on('end', () => handleDisconnect('stdin closed'))
-  process.stdin.on('error', () => handleDisconnect('stdin error'))
-
-  // ── HTTP server ─────────────────────────────────
-
-  let reqId = 0
-
-  const server = http.createServer(async (req, res) => {
-    // Hook events from Claude Code hooks system
-    if (req.method === 'POST' && req.url === '/hook') {
-      let body = ''
-      for await (const chunk of req) body += chunk
-      try {
-        const hookData = JSON.parse(body)
-        console.error(`[rune-channel] hook: ${hookData.hook_event_name} ${hookData.tool_name || ''}`)
-        broadcastSSE({ type: 'hook', event: hookData.hook_event_name, ...hookData })
-      } catch (e: any) {
-        console.error(`[rune-channel] hook parse error: ${e.message}`)
-      }
-      res.writeHead(200, { 'Content-Type': 'application/json' })
-      res.end('{"status":"ok"}')
-      return
-    }
-
-    // SSE endpoint
-    if (req.method === 'GET' && req.url === '/sse') {
-      res.writeHead(200, {
-        'Content-Type': 'text/event-stream',
-        'Cache-Control': 'no-cache',
-        Connection: 'keep-alive',
-        'Access-Control-Allow-Origin': '*',
-      })
-      res.write('data: {"type":"connected"}\n\n')
-      if (sessionStarted) {
-        res.write('data: {"type":"session_start"}\n\n')
-      }
-      sseClients.add(res)
-      console.error(`[rune-channel] SSE client connected (total: ${sseClients.size}, sessionStarted: ${sessionStarted})`)
-      req.on('close', () => {
-        sseClients.delete(res)
-        console.error(`[rune-channel] SSE client disconnected (total: ${sseClients.size})`)
-      })
-      return
-    }
-
-    // Health check
-    if (req.method === 'GET') {
-      res.writeHead(200, { 'Content-Type': 'application/json' })
-      res.end(JSON.stringify({ status: mcpConnected ? 'ok' : 'no-mcp', name: 'rune-channel', mcpConnected }))
-      return
-    }
-
-    // POST: chat message
-    try {
-      let body = ''
-      for await (const chunk of req) body += chunk
-      const { type, content } = JSON.parse(body) as { type: string; content: string }
-      const id = String(++reqId)
-
-      console.error(`[rune-channel] received ${type} message (id=${id}): ${content.slice(0, 100)}`)
-
-      // Push to Claude Code
-      try {
-        await mcp.notification({
-          method: 'notifications/claude/channel',
-          params: {
-            content,
-            meta: { type, request_id: id },
-          },
-        })
-      } catch (notifErr: any) {
-        console.error(`[rune-channel] MCP notification FAILED: ${notifErr.message}`)
-      }
-
-      // For chat messages, wait for reply
-      if (type === 'chat') {
-        const reply = await new Promise<string>((resolve) => {
-          pendingReplies.set(id, resolve)
-        })
-        res.writeHead(200, { 'Content-Type': 'text/plain; charset=utf-8' })
-        res.end(reply)
-        return
-      }
-
-      res.writeHead(200)
-      res.end('ok')
-    } catch (e: any) {
-      console.error(`[rune-channel] HTTP error: ${e.message}`)
-      res.writeHead(400, { 'Content-Type': 'application/json' })
-      res.end(JSON.stringify({ error: e.message }))
-    }
-  })
-
-  server.listen(PORT, '127.0.0.1', () => {
-    console.error(`[rune-channel] listening on http://127.0.0.1:${PORT}`)
-  })
-
-  // Graceful shutdown: close HTTP server to release port
-  const shutdown = () => {
-    console.error(`[rune-channel] shutting down, releasing port ${PORT}`)
-    server.close()
-    process.exit(0)
-  }
-  process.on('SIGTERM', shutdown)
-  process.on('SIGINT', shutdown)
-  process.on('SIGHUP', shutdown)
-}
-
-main()

package/electron-builder.yml

@@ -1,61 +0,0 @@
-appId: com.studio-h.rune
-productName: Rune
-copyright: Copyright © 2026 Studio-H
-
-directories:
-  output: release
-  buildResources: assets
-
-files:
-  - dist/**/*
-  - bootstrap.js
-  - package.json
-  - "!node_modules/**/*"
-  - node_modules/node-pty/**/*
-  - node_modules/@modelcontextprotocol/**/*
-
-asar: true
-
-mac:
-  category: public.app-category.developer-tools
-  target:
-    - target: dmg
-      arch: [arm64, x64]
-    - target: zip
-      arch: [arm64, x64]
-  entitlements: null
-  entitlementsInherit: null
-  hardenedRuntime: false
-  icon: assets/icon.icns
-  fileAssociations:
-    - ext: rune
-      name: Rune Agent File
-      description: Rune AI Agent Configuration
-      role: Editor
-      icon: assets/rune-file.icns
-
-dmg:
-  title: Rune
-  contents:
-    - x: 130
-      y: 220
-    - x: 410
-      y: 220
-      type: link
-      path: /Applications
-
-win:
-  target:
-    - nsis
-  fileAssociations:
-    - ext: rune
-      name: Rune Agent File
-      description: Rune AI Agent Configuration
-
-linux:
-  target:
-    - AppImage
-  fileAssociations:
-    - ext: rune
-      name: Rune Agent File
-      mimeType: application/x-rune