moshi-opencode-hooks 1.0.0

package/.github/workflows/publish.yml

@@ -0,0 +1,25 @@
+name: Publish to npm
+
+on:
+  push:
+    tags:
+      - 'v*'
+
+jobs:
+  publish:
+    runs-on: ubuntu-latest
+    permissions:
+      contents: read
+      id-token: write
+    steps:
+      - uses: actions/checkout@v4
+      - uses: oven-sh/setup-bun@v2
+        with:
+          bun-version: latest
+      - run: bun install
+      - run: bun run build
+      - run: |
+          echo "//registry.npmjs.org/:_authToken=${NPM_TOKEN}" > .npmrc
+          npm publish --provenance --access public
+        env:
+          NPM_TOKEN: ${{ secrets.NPM_TOKEN }}

package/CLAUDE.md

@@ -0,0 +1,17 @@
+# moshi-opencode-hooks
+
+OpenCode plugin that sends events to Moshi for live activity integration.
+
+## Building
+
+```bash
+bun run index.ts  # Test run
+bun tsc --noEmit # Type check
+```
+
+## Publishing to npm
+
+```bash
+bun run build
+npm publish
+```

package/README.md

@@ -0,0 +1,38 @@
+# moshi-opencode-hooks
+
+OpenCode plugin for Moshi live activity integration. Provides real-time progress updates in the Moshi iOS app when using OpenCode.
+
+## Setup
+
+1. **Install the token** (if not already done with Claude Code):
+   ```bash
+   bunx moshi-hooks token Xjqyek7li0vXgBnIlvXEn3VJgdhWf8qW
+   ```
+
+2. **Add as npm plugin** in `~/.config/opencode/opencode.json`:
+   ```json
+   {
+     "$schema": "https://opencode.ai/config.json",
+     "plugin": ["moshi-opencode-hooks"]
+   }
+   ```
+
+   Or use a local path for development:
+   ```json
+   {
+     "$schema": "https://opencode.ai/config.json",
+     "plugin": ["/path/to/moshi-opencode-hooks"]
+   }
+   ```
+
+## Events Sent to Moshi
+
+- `tool.execute.before/after` - Tool execution (Bash, Edit, Write, Read, Glob, Grep, Task)
+- `permission.ask` - Permission prompts
+- `session.created` - Session start
+- `session.idle` - Task completion
+
+## Requirements
+
+- OpenCode
+- Moshi iOS app with Cloud Code hook token

package/bun.lock

@@ -0,0 +1,35 @@
+{
+  "lockfileVersion": 1,
+  "configVersion": 1,
+  "workspaces": {
+    "": {
+      "name": "moshi-opencode-hooks",
+      "dependencies": {
+        "@opencode-ai/plugin": "^1.2.27",
+      },
+      "devDependencies": {
+        "@types/bun": "latest",
+      },
+      "peerDependencies": {
+        "typescript": "^5",
+      },
+    },
+  },
+  "packages": {
+    "@opencode-ai/plugin": ["@opencode-ai/plugin@1.2.27", "", { "dependencies": { "@opencode-ai/sdk": "1.2.27", "zod": "4.1.8" } }, "sha512-h+8Bw9v9nghMg7T+SUCTzxlIhOrsTqXW7U0HVLGQST5DjbN7uyCUM51roZWZ8LRjGxzbzFhvPnY1bj8i+ioZyw=="],
+
+    "@opencode-ai/sdk": ["@opencode-ai/sdk@1.2.27", "", {}, "sha512-Wk0o/I+Fo+wE3zgvlJDs8Fb67KlKqX0PrV8dK5adSDkANq6r4Z25zXJg2iOir+a8ntg3rAcpel1OY4FV/TwRUA=="],
+
+    "@types/bun": ["@types/bun@1.3.11", "", { "dependencies": { "bun-types": "1.3.11" } }, "sha512-5vPne5QvtpjGpsGYXiFyycfpDF2ECyPcTSsFBMa0fraoxiQyMJ3SmuQIGhzPg2WJuWxVBoxWJ2kClYTcw/4fAg=="],
+
+    "@types/node": ["@types/node@25.5.0", "", { "dependencies": { "undici-types": "~7.18.0" } }, "sha512-jp2P3tQMSxWugkCUKLRPVUpGaL5MVFwF8RDuSRztfwgN1wmqJeMSbKlnEtQqU8UrhTmzEmZdu2I6v2dpp7XIxw=="],
+
+    "bun-types": ["bun-types@1.3.11", "", { "dependencies": { "@types/node": "*" } }, "sha512-1KGPpoxQWl9f6wcZh57LvrPIInQMn2TQ7jsgxqpRzg+l0QPOFvJVH7HmvHo/AiPgwXy+/Thf6Ov3EdVn1vOabg=="],
+
+    "typescript": ["typescript@5.9.3", "", { "bin": { "tsc": "bin/tsc", "tsserver": "bin/tsserver" } }, "sha512-jl1vZzPDinLr9eUt3J/t7V6FgNEw9QjvBPdysz9KfQDD41fQrC2Y4vKQdiaUpFT4bXlb1RHhLpp8wtm6M5TgSw=="],
+
+    "undici-types": ["undici-types@7.18.2", "", {}, "sha512-AsuCzffGHJybSaRrmr5eHr81mwJU3kjw6M+uprWvCXiNeN9SOGwQ3Jn8jb8m3Z6izVgknn1R0FTCEAP2QrLY/w=="],
+
+    "zod": ["zod@4.1.8", "", {}, "sha512-5R1P+WwQqmmMIEACyzSvo4JXHY5WiAFHRMg+zBZKgKS+Q1viRa0C1hmUKtHltoIFKtIdki3pRxkmpP74jnNYHQ=="],
+  }
+}

package/index.ts

@@ -0,0 +1,209 @@
+import { homedir } from "os"
+import { basename } from "path"
+import type { Plugin } from "@opencode-ai/plugin"
+
+const TOKEN_PATH = `${homedir()}/.config/moshi/token`
+const API_URL = "https://api.getmoshi.app/api/v1/agent-events"
+const INTERESTING_TOOLS = new Set(["bash", "edit", "write", "read", "glob", "grep", "task"])
+
+interface HookState {
+  model?: string
+  lastToolName?: string
+  lastStopTime?: number
+  sessionStartTime?: number
+}
+
+interface AgentEvent {
+  source: "opencode"
+  eventType: "user_prompt" | "pre_tool" | "post_tool" | "notification" | "stop" | "agent_turn_complete"
+  sessionId: string
+  category: "approval_required" | "task_complete" | "tool_running" | "tool_finished" | "info" | "error"
+  title: string
+  message: string
+  eventId: string
+  projectName?: string
+  modelName?: string
+  toolName?: string
+  contextPercent?: number
+}
+
+function statePath(sessionId: string): string {
+  return `/tmp/moshi-opencode-hook-${sessionId}.json`
+}
+
+async function readState(sessionId: string): Promise<HookState> {
+  try {
+    const file = Bun.file(statePath(sessionId))
+    if (!file.size) return {}
+    return await file.json()
+  } catch {
+    return {}
+  }
+}
+
+async function writeState(sessionId: string, patch: Partial<HookState>): Promise<void> {
+  const existing = await readState(sessionId)
+  await Bun.write(statePath(sessionId), JSON.stringify({ ...existing, ...patch }))
+}
+
+async function loadToken(): Promise<string | null> {
+  try {
+    const text = await Bun.file(TOKEN_PATH).text()
+    return text.trim() || null
+  } catch {
+    return null
+  }
+}
+
+async function sendEvent(token: string, event: AgentEvent): Promise<void> {
+  const body = JSON.stringify(event)
+  const headers = {
+    "Content-Type": "application/json",
+    "Authorization": `Bearer ${token}`,
+  }
+
+  try {
+    const res = await fetch(API_URL, {
+      method: "POST",
+      headers,
+      body,
+      signal: AbortSignal.timeout(5000),
+    })
+    if (!res.ok && res.status >= 500) {
+      console.error(`[moshi-hooks] API error: ${res.status}`)
+    }
+  } catch (err) {
+    console.error(`[moshi-hooks] Failed to send event:`, err)
+  }
+}
+
+function formatToolName(toolName: string): string {
+  return toolName.charAt(0).toUpperCase() + toolName.slice(1)
+}
+
+export const MoshiHooks: Plugin = async ({ client, directory }) => {
+  const setupEventSubscription = async () => {
+    try {
+      const events = await client.event.subscribe()
+      for await (const event of events.stream) {
+        const token = await loadToken()
+        if (!token) break
+
+        const sessionId = (event as any).sessionId ?? "unknown"
+        const projectName = directory ? basename(directory) : undefined
+        const state = await readState(sessionId)
+
+        if (event.type === "session.created") {
+          await writeState(sessionId, {
+            sessionStartTime: Date.now() / 1000,
+            model: (event as any).properties?.model,
+          })
+          continue
+        }
+
+        if (event.type === "session.idle") {
+          const now = Date.now() / 1000
+          if (state.lastStopTime && now - state.lastStopTime < 5) continue
+
+          await writeState(sessionId, { lastStopTime: now })
+
+          const evt: AgentEvent = {
+            source: "opencode",
+            eventType: "stop",
+            sessionId,
+            category: "task_complete",
+            title: "Task Complete",
+            message: "",
+            eventId: crypto.randomUUID(),
+            projectName,
+            modelName: state.model,
+            toolName: state.lastToolName,
+          }
+          await sendEvent(token, evt)
+        }
+      }
+    } catch (err) {
+      console.error(`[moshi-hooks] Event subscription error:`, err)
+    }
+  }
+
+  setupEventSubscription()
+
+  return {
+    "tool.execute.before": async (input, _output) => {
+      const token = await loadToken()
+      if (!token) return
+
+      const { tool, sessionID } = input
+      if (!tool || !INTERESTING_TOOLS.has(tool.toLowerCase())) return
+
+      await writeState(sessionID, { lastToolName: tool })
+
+      const state = await readState(sessionID)
+      const projectName = directory ? basename(directory) : undefined
+
+      const evt: AgentEvent = {
+        source: "opencode",
+        eventType: "pre_tool",
+        sessionId: sessionID,
+        category: "tool_running",
+        title: `Running ${formatToolName(tool)}`,
+        message: "",
+        eventId: crypto.randomUUID(),
+        projectName,
+        modelName: state.model,
+        toolName: tool,
+      }
+      await sendEvent(token, evt)
+    },
+
+    "tool.execute.after": async (input, output) => {
+      const token = await loadToken()
+      if (!token) return
+
+      const { tool, sessionID } = input
+      if (!tool || !INTERESTING_TOOLS.has(tool.toLowerCase())) return
+
+      const state = await readState(sessionID)
+      const projectName = directory ? basename(directory) : undefined
+
+      const evt: AgentEvent = {
+        source: "opencode",
+        eventType: "post_tool",
+        sessionId: sessionID,
+        category: "tool_finished",
+        title: `Finished ${formatToolName(tool)}`,
+        message: "",
+        eventId: crypto.randomUUID(),
+        projectName,
+        modelName: state.model,
+        toolName: tool,
+      }
+      await sendEvent(token, evt)
+    },
+
+    "permission.ask": async (input, output) => {
+      const token = await loadToken()
+      if (!token) return
+
+      const sessionID = (input as any).sessionID ?? "unknown"
+      const state = await readState(sessionID)
+      const projectName = directory ? basename(directory) : undefined
+
+      const prompt = (input as any).prompt ?? ""
+
+      const evt: AgentEvent = {
+        source: "opencode",
+        eventType: "notification",
+        sessionId: sessionID,
+        category: "approval_required",
+        title: "Permission Required",
+        message: prompt.slice(0, 256),
+        eventId: crypto.randomUUID(),
+        projectName,
+        modelName: state.model,
+      }
+      await sendEvent(token, evt)
+    },
+  }
+}

package/package.json

@@ -0,0 +1,31 @@
+{
+  "name": "moshi-opencode-hooks",
+  "version": "1.0.0",
+  "description": "OpenCode plugin for Moshi live activity integration",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/goniz/moshi-opencode-hooks"
+  },
+  "module": "index.ts",
+  "type": "module",
+  "main": "index.ts",
+  "bin": {
+    "moshi-opencode-hooks": "./src/cli.ts"
+  },
+  "exports": {
+    ".": "./index.ts"
+  },
+  "scripts": {
+    "build": "bun build index.ts --outdir=dist --target=bun --format=esm",
+    "typecheck": "bun tsc --noEmit"
+  },
+  "devDependencies": {
+    "@types/bun": "latest"
+  },
+  "peerDependencies": {
+    "typescript": "^5"
+  },
+  "dependencies": {
+    "@opencode-ai/plugin": "^1.2.27"
+  }
+}

package/src/cli.ts

@@ -0,0 +1,103 @@
+#!/usr/bin/env bun
+
+import { homedir } from "os"
+import { dirname } from "path"
+
+const TOKEN_PATH = `${homedir()}/.config/moshi/token`
+const OPENCODE_CONFIG_PATH = `${homedir()}/.config/opencode/opencode.json`
+const PLUGIN_SOURCE = "moshi-opencode-hooks"
+const HOOK_IDENTIFIER = "moshi-opencode-hooks"
+
+async function loadConfig(): Promise<Record<string, unknown>> {
+  try {
+    const file = Bun.file(OPENCODE_CONFIG_PATH)
+    if (!file.size) return {}
+    return await file.json()
+  } catch {
+    return {}
+  }
+}
+
+async function saveConfig(config: Record<string, unknown>): Promise<void> {
+  const { mkdir } = await import("fs/promises")
+  await mkdir(dirname(OPENCODE_CONFIG_PATH), { recursive: true })
+  await Bun.write(OPENCODE_CONFIG_PATH, JSON.stringify(config, null, 2) + "\n")
+}
+
+function isMoshiHook(entry: string): boolean {
+  return entry.includes(HOOK_IDENTIFIER) || entry.includes("moshi-opencode-hooks")
+}
+
+async function setup(): Promise<void> {
+  const config = await loadConfig()
+  const plugins: string[] = Array.isArray(config.plugin) ? config.plugin : []
+
+  const filtered = plugins.filter((p) => !isMoshiHook(p))
+  filtered.push(PLUGIN_SOURCE)
+
+  config.plugin = filtered
+  await saveConfig(config)
+  console.log(`moshi-opencode-hooks: registered in ${OPENCODE_CONFIG_PATH}`)
+}
+
+async function uninstall(): Promise<void> {
+  const config = await loadConfig()
+  const plugins: string[] = Array.isArray(config.plugin) ? config.plugin : []
+
+  const filtered = plugins.filter((p) => !isMoshiHook(p))
+  config.plugin = filtered
+
+  await saveConfig(config)
+  console.log(`moshi-opencode-hooks: removed from ${OPENCODE_CONFIG_PATH}`)
+}
+
+async function setToken(value: string): Promise<void> {
+  const { mkdir } = await import("fs/promises")
+  await mkdir(dirname(TOKEN_PATH), { recursive: true })
+  await Bun.write(TOKEN_PATH, value + "\n")
+  console.log(`moshi-opencode-hooks: token saved to ${TOKEN_PATH}`)
+}
+
+async function getToken(): Promise<void> {
+  try {
+    const text = await Bun.file(TOKEN_PATH).text()
+    console.log(text.trim() || `no token found (expected at ${TOKEN_PATH})`)
+  } catch {
+    console.log(`no token found (expected at ${TOKEN_PATH})`)
+  }
+}
+
+async function main() {
+  const subcommand = process.argv[2]
+
+  if (subcommand === "setup") {
+    await setup()
+    return
+  }
+
+  if (subcommand === "uninstall") {
+    await uninstall()
+    return
+  }
+
+  if (subcommand === "token") {
+    const value = process.argv[3]
+    if (value) {
+      await setToken(value)
+    } else {
+      await getToken()
+    }
+    return
+  }
+
+  console.log("Usage:")
+  console.log("  moshi-opencode-hooks setup       Register plugin")
+  console.log("  moshi-opencode-hooks uninstall   Remove plugin")
+  console.log("  moshi-opencode-hooks token [value]  Show or set API token")
+  process.exit(0)
+}
+
+main().catch((err) => {
+  console.error(`moshi-opencode-hooks: error:`, err)
+  process.exit(1)
+})

package/tsconfig.json

@@ -0,0 +1,29 @@
+{
+  "compilerOptions": {
+    // Environment setup & latest features
+    "lib": ["ESNext"],
+    "target": "ESNext",
+    "module": "Preserve",
+    "moduleDetection": "force",
+    "jsx": "react-jsx",
+    "allowJs": true,
+
+    // Bundler mode
+    "moduleResolution": "bundler",
+    "allowImportingTsExtensions": true,
+    "verbatimModuleSyntax": true,
+    "noEmit": true,
+
+    // Best practices
+    "strict": true,
+    "skipLibCheck": true,
+    "noFallthroughCasesInSwitch": true,
+    "noUncheckedIndexedAccess": true,
+    "noImplicitOverride": true,
+
+    // Some stricter flags (disabled by default)
+    "noUnusedLocals": false,
+    "noUnusedParameters": false,
+    "noPropertyAccessFromIndexSignature": false
+  }
+}