openrune 0.1.0

package/bootstrap.js

@@ -0,0 +1,4 @@
+// Simple entry point — just load the bundled main process
+// Note: require('electron') works because Electron intercepts
+// the npm package resolution and returns its built-in module
+require('./dist/main.js')

package/channel/rune-channel.ts

@@ -0,0 +1,467 @@
+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 summary (last 20 messages condensed)
+  if (rune.history && rune.history.length > 0) {
+    const recent = rune.history.slice(-20)
+    parts.push('\n## Recent Conversation History')
+    parts.push(`(${rune.history.length} total messages, showing last ${recent.length})`)
+    for (const msg of recent) {
+      const who = msg.role === 'user' ? 'User' : 'You'
+      const text = msg.text.length > 200 ? msg.text.slice(0, 200) + '...' : msg.text
+      parts.push(`- **${who}**: ${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

@@ -0,0 +1,61 @@
+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

package/finder-extension/FinderSync.swift

@@ -0,0 +1,47 @@
+import Cocoa
+import FinderSync
+
+class RuneFinderSync: FIFinderSync {
+    override init() {
+        super.init()
+        // Monitor all directories — menu appears everywhere in Finder
+        FIFinderSyncController.default().directoryURLs = [URL(fileURLWithPath: "/")]
+    }
+
+    override func menu(for menuKind: FIMenuKind) -> NSMenu {
+        let menu = NSMenu(title: "Rune")
+
+        // contextualMenuForContainer = background right-click (empty space)
+        // contextualMenuForItems = right-click on selected items
+        if menuKind == .contextualMenuForContainer || menuKind == .contextualMenuForItems {
+            let item = NSMenuItem(
+                title: "New Rune",
+                action: #selector(createRune(_:)),
+                keyEquivalent: ""
+            )
+            if #available(macOS 11.0, *) {
+                item.image = NSImage(systemSymbolName: "sparkles", accessibilityDescription: "Rune")
+            }
+            menu.addItem(item)
+        }
+
+        return menu
+    }
+
+    @objc func createRune(_ sender: AnyObject?) {
+        guard let target = FIFinderSyncController.default().targetedURL() else { return }
+        let dirPath = target.path
+
+        // Use shell to create .rune file and open it
+        let script = """
+        cd "\(dirPath)" && \
+        /usr/local/bin/rune new agent 2>/dev/null || \
+        ~/.rune/create-rune.sh "\(dirPath)" 2>/dev/null
+        """
+
+        let task = Process()
+        task.executableURL = URL(fileURLWithPath: "/bin/bash")
+        task.arguments = ["-c", script]
+        try? task.run()
+    }
+}

package/finder-extension/RuneFinderSync.appex/Contents/Info.plist

@@ -0,0 +1,27 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+	<key>CFBundleIdentifier</key>
+	<string>com.studio-h.rune.finder-sync</string>
+	<key>CFBundleName</key>
+	<string>RuneFinderSync</string>
+	<key>CFBundleDisplayName</key>
+	<string>Rune Finder Extension</string>
+	<key>CFBundleExecutable</key>
+	<string>RuneFinderSync</string>
+	<key>CFBundlePackageType</key>
+	<string>XPC!</string>
+	<key>CFBundleVersion</key>
+	<string>0.1.0</string>
+	<key>CFBundleShortVersionString</key>
+	<string>0.1.0</string>
+	<key>NSExtension</key>
+	<dict>
+		<key>NSExtensionPointIdentifier</key>
+		<string>com.apple.FinderSync</string>
+		<key>NSExtensionPrincipalClass</key>
+		<string>RuneFinderSync.RuneFinderSync</string>
+	</dict>
+</dict>
+</plist>

package/finder-extension/main.swift

@@ -0,0 +1,5 @@
+import Cocoa
+
+// NSExtension entry point for Finder Sync extension
+let app = NSApplication.shared
+NSApplicationMain(CommandLine.argc, CommandLine.unsafeArgv)

package/package.json

@@ -0,0 +1,53 @@
+{
+  "name": "openrune",
+  "version": "0.1.0",
+  "description": "Rune — File-based AI Agent Desktop App",
+  "keywords": ["ai", "agent", "claude", "desktop", "electron", "mcp", "claude-code"],
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/gilhyun/Rune.git"
+  },
+  "homepage": "https://github.com/gilhyun/Rune",
+  "license": "MIT",
+  "author": "gilhyun",
+  "main": "bootstrap.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": {
+    "@tailwindcss/vite": "^4.2.2",
+    "@types/node": "^22.0.0",
+    "@types/react": "^19.2.14",
+    "@types/react-dom": "^19.2.3",
+    "@types/ws": "^8.18.1",
+    "@vitejs/plugin-react": "^6.0.1",
+    "electron": "^28.3.3",
+    "esbuild": "^0.27.4",
+    "tailwindcss": "^4.2.2",
+    "typescript": "^5.7.0",
+    "electron-builder": "^25.0.0",
+    "vite": "^8.0.1"
+  },
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.27.1",
+    "@xterm/addon-fit": "^0.11.0",
+    "@xterm/xterm": "^6.0.0",
+    "clsx": "^2.1.1",
+    "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"
+  }
+}

package/renderer/index.html

@@ -0,0 +1,12 @@
+<!DOCTYPE html>
+<html lang="ko" class="dark">
+<head>
+  <meta charset="UTF-8" />
+  <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+  <title>Rune</title>
+</head>
+<body class="bg-background text-foreground overflow-hidden">
+  <div id="root"></div>
+  <script type="module" src="/src/main.tsx"></script>
+</body>
+</html>