@canonmsg/claude-code-plugin 0.3.0

package/.claude-plugin/plugin.json

@@ -0,0 +1,25 @@
+{
+  "name": "Canon",
+  "description": "Connect Claude Code to Canon — messaging where AI agents are first-class citizens",
+  "version": "0.1.0",
+  "channels": [
+    {
+      "server": "canon-channel",
+      "userConfig": {
+        "api_key": {
+          "description": "Canon agent API key (agk_live_...)",
+          "sensitive": true
+        }
+      }
+    }
+  ],
+  "mcpServers": {
+    "canon-channel": {
+      "command": "node",
+      "args": ["${CLAUDE_PLUGIN_ROOT}/dist/server.js"],
+      "env": {
+        "CANON_PLUGIN_API_KEY": "${user_config.api_key}"
+      }
+    }
+  }
+}

package/README.md

@@ -0,0 +1,52 @@
+# Canon Plugin for Claude Code
+
+Connect Claude Code to [Canon](https://github.com/HeyBobChan/canon) — a messaging app where AI agents are first-class citizens. Control Claude Code from your phone.
+
+## Quick start
+
+```bash
+# Install
+npm install -g @canonmsg/claude-code-plugin
+
+# Register (approve in Canon app when prompted)
+canon-register --name "My Claude" --description "My Claude Code agent" --phone "+15551234567"
+
+# Run
+canon-claude
+```
+
+Send a message to your agent in the Canon app. Claude Code responds with full capabilities (file read/write, bash, etc.).
+
+## Features
+
+- **Two-way messaging** — Messages from Canon flow to Claude Code and back
+- **Session controls** — Switch model (Haiku/Sonnet/Opus) and permission mode from the app
+- **Live streaming** — See Claude's response as it types
+- **Interrupt** — Stop Claude mid-response from the app
+- **Context meter** — See context window usage in the app
+- **Max plan auth** — Uses your Claude subscription, no API key billing
+
+## Working directory
+
+```bash
+canon-claude --cwd /path/to/project
+```
+
+## Multiple agents
+
+```bash
+canon-register --name "Frontend" --description "React work" --phone "+1..." --profile frontend
+CANON_AGENT=frontend canon-claude --cwd ~/projects/frontend
+```
+
+## Channel mode (alternative)
+
+For a lighter integration without session controls, run Canon as a channel plugin inside your own Claude Code session. See [full setup guide](../../docs/claude-code-setup.md#channel-mode-alternative).
+
+## Development
+
+```bash
+cd packages/claude-code-plugin
+npm install
+npm run build
+```

package/dist/agent-profiles.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Shared agent profile management — loading, locking, and resolution.
+ * Used by both host.ts and server.ts.
+ */
+export interface AgentProfile {
+    apiKey: string;
+    agentId: string;
+    agentName: string;
+    registeredAt: string;
+}
+export declare const CANON_DIR: string;
+export declare const AGENTS_PATH: string;
+export declare const LOCKS_DIR: string;
+export declare function loadProfiles(): Record<string, AgentProfile>;
+export declare function isProcessAlive(pid: number): boolean;
+export declare function isProfileLocked(profile: string): {
+    locked: boolean;
+    pid?: number;
+};
+export declare function acquireLock(profile: string): void;
+export declare function releaseLock(profile: string): void;

package/dist/agent-profiles.js

@@ -0,0 +1,63 @@
+/**
+ * Shared agent profile management — loading, locking, and resolution.
+ * Used by both host.ts and server.ts.
+ */
+import { readFileSync, writeFileSync, unlinkSync, mkdirSync } from 'node:fs';
+import { join } from 'node:path';
+import { homedir } from 'node:os';
+// ── Paths ────────────────────────────────────────────────────────────
+export const CANON_DIR = join(homedir(), '.canon');
+export const AGENTS_PATH = join(CANON_DIR, 'agents.json');
+export const LOCKS_DIR = join(CANON_DIR, 'locks');
+// ── Profile loading ──────────────────────────────────────────────────
+export function loadProfiles() {
+    try {
+        return JSON.parse(readFileSync(AGENTS_PATH, 'utf-8'));
+    }
+    catch {
+        return {};
+    }
+}
+// ── Process locking ──────────────────────────────────────────────────
+export function isProcessAlive(pid) {
+    try {
+        process.kill(pid, 0);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+export function isProfileLocked(profile) {
+    const lockPath = join(LOCKS_DIR, `${profile}.lock`);
+    try {
+        const pid = parseInt(readFileSync(lockPath, 'utf-8').trim());
+        if (isProcessAlive(pid))
+            return { locked: true, pid };
+        // Stale lock — clean it up
+        try {
+            unlinkSync(lockPath);
+        }
+        catch { }
+    }
+    catch {
+        // No lock file
+    }
+    return { locked: false };
+}
+export function acquireLock(profile) {
+    mkdirSync(LOCKS_DIR, { recursive: true });
+    const lockPath = join(LOCKS_DIR, `${profile}.lock`);
+    const check = isProfileLocked(profile);
+    if (check.locked) {
+        throw new Error(`Agent "${profile}" is in use by another session (PID ${check.pid})`);
+    }
+    writeFileSync(lockPath, String(process.pid));
+}
+export function releaseLock(profile) {
+    const lockPath = join(LOCKS_DIR, `${profile}.lock`);
+    try {
+        unlinkSync(lockPath);
+    }
+    catch { }
+}

package/dist/approval-server.d.ts

@@ -0,0 +1,23 @@
+import type { ApprovalManager } from '@canonmsg/core';
+/**
+ * HTTP server that bridges Claude Code's PermissionRequest hook
+ * to Canon's ApprovalManager.
+ *
+ * Listens on localhost for POST /approve from Claude Code hooks.
+ */
+export declare class ApprovalHttpServer {
+    private server;
+    private manager;
+    private port;
+    private getConversationId;
+    constructor(manager: ApprovalManager, getConversationId: () => string | null, opts?: {
+        port?: number;
+    });
+    private static readonly MAX_PORT_RETRIES;
+    start(): Promise<number>;
+    stop(): Promise<void>;
+    private handleRequest;
+    private handleApproval;
+    private sendHookResponse;
+    private classifyRisk;
+}

package/dist/approval-server.js

@@ -0,0 +1,133 @@
+import { createServer } from 'node:http';
+/**
+ * HTTP server that bridges Claude Code's PermissionRequest hook
+ * to Canon's ApprovalManager.
+ *
+ * Listens on localhost for POST /approve from Claude Code hooks.
+ */
+export class ApprovalHttpServer {
+    server = null;
+    manager;
+    port;
+    getConversationId;
+    constructor(manager, getConversationId, opts) {
+        this.manager = manager;
+        this.getConversationId = getConversationId;
+        this.port = opts?.port ?? 19420;
+    }
+    static MAX_PORT_RETRIES = 10;
+    async start() {
+        const startPort = this.port;
+        return new Promise((resolve, reject) => {
+            this.server = createServer((req, res) => this.handleRequest(req, res));
+            this.server.on('error', (err) => {
+                if (err.code === 'EADDRINUSE') {
+                    this.port++;
+                    if (this.port - startPort >= ApprovalHttpServer.MAX_PORT_RETRIES) {
+                        reject(new Error(`No available port found in range ${startPort}–${this.port}`));
+                        return;
+                    }
+                    this.server.listen(this.port, '127.0.0.1');
+                }
+                else {
+                    reject(err);
+                }
+            });
+            this.server.listen(this.port, '127.0.0.1', () => {
+                console.error(`[canon] Approval server listening on 127.0.0.1:${this.port}`);
+                resolve(this.port);
+            });
+        });
+    }
+    async stop() {
+        return new Promise((resolve) => {
+            if (this.server) {
+                this.server.close(() => resolve());
+            }
+            else {
+                resolve();
+            }
+        });
+    }
+    handleRequest(req, res) {
+        if (req.method !== 'POST' || req.url !== '/approve') {
+            res.writeHead(404, { 'Content-Type': 'application/json' });
+            res.end(JSON.stringify({ error: 'Not found' }));
+            return;
+        }
+        let body = '';
+        req.on('data', (chunk) => {
+            body += chunk.toString();
+        });
+        req.on('end', () => {
+            this.handleApproval(body, res).catch((err) => {
+                console.error('[canon] Approval handler error:', err);
+                res.writeHead(500, { 'Content-Type': 'application/json' });
+                res.end(JSON.stringify({ error: 'Internal error' }));
+            });
+        });
+    }
+    async handleApproval(body, res) {
+        let payload;
+        try {
+            payload = JSON.parse(body);
+        }
+        catch {
+            res.writeHead(400, { 'Content-Type': 'application/json' });
+            res.end(JSON.stringify({ error: 'Invalid JSON' }));
+            return;
+        }
+        const toolName = payload.tool_name ?? 'Unknown';
+        const toolInput = payload.tool_input ?? {};
+        // Determine risk level
+        const riskLevel = this.classifyRisk(toolName, toolInput);
+        // Check session rules first (may resolve immediately)
+        const existingRule = this.manager.checkSessionRules(toolName);
+        if (existingRule) {
+            const decision = existingRule.type === 'deny-tool' ? 'deny' : 'allow';
+            this.sendHookResponse(res, decision);
+            return;
+        }
+        // Find the conversation to send the approval to
+        const conversationId = this.getConversationId();
+        if (!conversationId) {
+            console.error('[canon] No active conversation for approval — falling back to allow');
+            // Can't send approval message, fall through to terminal prompt
+            this.sendHookResponse(res, 'ask');
+            return;
+        }
+        try {
+            const result = await this.manager.requestApproval(conversationId, toolName, toolInput, { riskLevel });
+            this.sendHookResponse(res, result.decision);
+        }
+        catch (err) {
+            console.error('[canon] Approval request failed:', err);
+            // On error, fall back to terminal prompt
+            this.sendHookResponse(res, 'ask');
+        }
+    }
+    sendHookResponse(res, behavior) {
+        res.writeHead(200, { 'Content-Type': 'application/json' });
+        res.end(JSON.stringify({
+            hookSpecificOutput: {
+                hookEventName: 'PermissionRequest',
+                decision: { behavior },
+            },
+        }));
+    }
+    classifyRisk(toolName, toolInput) {
+        if (toolName !== 'Bash')
+            return 'normal';
+        const cmd = typeof toolInput.command === 'string' ? toolInput.command : '';
+        const destructivePatterns = [
+            /\brm\s+(-rf?|--force)/,
+            /\bgit\s+push\s+--force/,
+            /\bgit\s+reset\s+--hard/,
+            /\bdrop\s+(table|database)/i,
+            /\bformat\b/,
+        ];
+        return destructivePatterns.some((p) => p.test(cmd))
+            ? 'destructive'
+            : 'normal';
+    }
+}

package/dist/host.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};