claude-code-sync 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Wayne Sutton
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,105 @@
+# claude-code-sync
+
+Sync your Claude Code sessions to [OpenSync](https://github.com/waynesutton/opensync) dashboard. Track coding sessions, analyze tool usage, and monitor token consumption across projects.
+
+## Installation
+
+```bash
+npm install -g claude-code-sync
+```
+
+## Quick Start
+
+### 1. Get Your API Key
+
+1. Log into your OpenSync dashboard
+2. Go to **Settings**
+3. Click **Generate API Key**
+4. Copy the key (starts with `osk_`)
+
+### 2. Configure the Plugin
+
+```bash
+claude-code-sync login
+```
+
+Enter when prompted:
+- **Convex URL**: Your deployment URL (e.g., `https://your-project.convex.cloud`)
+- **API Key**: Your API key from Settings (e.g., `osk_abc123...`)
+
+### 3. Add to Claude Code
+
+Add the plugin to your Claude Code configuration. Sessions will sync automatically.
+
+## CLI Commands
+
+| Command | Description |
+|---------|-------------|
+| `claude-code-sync login` | Configure Convex URL and API Key |
+| `claude-code-sync logout` | Clear stored credentials |
+| `claude-code-sync status` | Show connection status |
+| `claude-code-sync config` | Show current configuration |
+| `claude-code-sync set <key> <value>` | Update a config value |
+
+### Configuration Options
+
+| Option | Type | Default | Description |
+|--------|------|---------|-------------|
+| `autoSync` | boolean | `true` | Automatically sync sessions |
+| `syncToolCalls` | boolean | `true` | Include tool call details |
+| `syncThinking` | boolean | `false` | Include thinking traces |
+
+Set options with:
+
+```bash
+claude-code-sync set syncThinking true
+```
+
+## Environment Variables
+
+You can also configure via environment variables:
+
+```bash
+export CLAUDE_SYNC_CONVEX_URL="https://your-project.convex.cloud"
+export CLAUDE_SYNC_API_KEY="osk_your_api_key"
+export CLAUDE_SYNC_AUTO_SYNC="true"
+export CLAUDE_SYNC_TOOL_CALLS="true"
+export CLAUDE_SYNC_THINKING="false"
+```
+
+## What Gets Synced
+
+| Data | Description |
+|------|-------------|
+| Session metadata | Project path, working directory, git branch, timestamps |
+| User prompts | Your messages to Claude |
+| Assistant responses | Claude's responses |
+| Tool calls | Which tools were used and their outcomes |
+| Token usage | Input and output token counts |
+| Model info | Which Claude model was used |
+| Cost estimate | Estimated session cost |
+
+## Privacy
+
+- All data goes to YOUR Convex deployment
+- Sensitive fields are automatically redacted
+- Full file contents are not synced, only paths
+- Thinking traces are off by default
+- You control what gets synced via configuration
+
+## Requirements
+
+- Node.js 18 or later
+- Claude Code CLI
+- A deployed OpenSync backend
+
+## Links
+
+- [claude-code-sync Repository](https://github.com/waynesutton/claude-code-sync)
+- [OpenSync Backend](https://github.com/waynesutton/opensync)
+- [OpenSync Dashboard](https://opensyncsessions.netlify.app)
+- [npm Package](https://www.npmjs.com/package/claude-code-sync)
+
+## License
+
+MIT

package/dist/cli.d.ts

@@ -0,0 +1,11 @@
+#!/usr/bin/env node
+/**
+ * Claude Code Sync CLI
+ *
+ * Commands:
+ *   login   - Configure Convex URL and API Key
+ *   logout  - Clear stored credentials
+ *   status  - Show connection status
+ *   config  - Show current configuration
+ */
+export {};

package/dist/cli.js

@@ -0,0 +1,227 @@
+#!/usr/bin/env node
+"use strict";
+/**
+ * Claude Code Sync CLI
+ *
+ * Commands:
+ *   login   - Configure Convex URL and API Key
+ *   logout  - Clear stored credentials
+ *   status  - Show connection status
+ *   config  - Show current configuration
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+const commander_1 = require("commander");
+const readline = __importStar(require("readline"));
+const index_1 = require("./index");
+const program = new commander_1.Command();
+program
+    .name("claude-code-sync")
+    .description("Sync Claude Code sessions to OpenSync dashboard")
+    .version("0.1.0");
+// ============================================================================
+// Helper Functions
+// ============================================================================
+function prompt(question) {
+    const rl = readline.createInterface({
+        input: process.stdin,
+        output: process.stdout,
+    });
+    return new Promise((resolve) => {
+        rl.question(question, (answer) => {
+            rl.close();
+            resolve(answer.trim());
+        });
+    });
+}
+function maskApiKey(key) {
+    if (key.length <= 8)
+        return "****";
+    return key.substring(0, 4) + "****" + key.substring(key.length - 4);
+}
+// ============================================================================
+// Commands
+// ============================================================================
+program
+    .command("login")
+    .description("Configure Convex URL and API Key")
+    .action(async () => {
+    console.log("\n🔐 Claude Code Sync - Login\n");
+    console.log("Get your API key from your OpenSync dashboard:");
+    console.log("  1. Go to Settings");
+    console.log("  2. Click 'Generate API Key'");
+    console.log("  3. Copy the key (starts with osk_)\n");
+    const convexUrl = await prompt("Convex URL (e.g., https://your-project.convex.cloud): ");
+    if (!convexUrl) {
+        console.error("❌ Convex URL is required");
+        process.exit(1);
+    }
+    if (!convexUrl.includes("convex.cloud") && !convexUrl.includes("convex.site")) {
+        console.error("❌ Invalid Convex URL. Must contain convex.cloud or convex.site");
+        process.exit(1);
+    }
+    const apiKey = await prompt("API Key (osk_...): ");
+    if (!apiKey) {
+        console.error("❌ API Key is required");
+        process.exit(1);
+    }
+    if (!apiKey.startsWith("osk_")) {
+        console.error("❌ Invalid API Key. Must start with osk_");
+        process.exit(1);
+    }
+    const config = {
+        convexUrl,
+        apiKey,
+        autoSync: true,
+        syncToolCalls: true,
+        syncThinking: false,
+    };
+    // Test connection
+    console.log("\n⏳ Testing connection...");
+    const client = new index_1.SyncClient(config);
+    const connected = await client.testConnection();
+    if (!connected) {
+        console.error("❌ Could not connect to Convex backend");
+        console.error("   Check your URL and try again");
+        process.exit(1);
+    }
+    // Save config
+    (0, index_1.saveConfig)(config);
+    console.log("\n✅ Configuration saved!");
+    console.log(`   URL: ${convexUrl}`);
+    console.log(`   Key: ${maskApiKey(apiKey)}`);
+    console.log("\n📦 Add the plugin to your Claude Code config to start syncing.\n");
+});
+program
+    .command("logout")
+    .description("Clear stored credentials")
+    .action(() => {
+    (0, index_1.clearConfig)();
+    console.log("✅ Credentials cleared");
+});
+program
+    .command("status")
+    .description("Show connection status")
+    .action(async () => {
+    const config = (0, index_1.loadConfig)();
+    console.log("\n📊 Claude Code Sync - Status\n");
+    if (!config) {
+        console.log("❌ Not configured");
+        console.log("   Run 'claude-code-sync login' to set up\n");
+        process.exit(1);
+    }
+    console.log("Configuration:");
+    console.log(`  Convex URL: ${config.convexUrl}`);
+    console.log(`  API Key:    ${maskApiKey(config.apiKey)}`);
+    console.log(`  Auto Sync:  ${config.autoSync !== false ? "enabled" : "disabled"}`);
+    console.log(`  Tool Calls: ${config.syncToolCalls !== false ? "enabled" : "disabled"}`);
+    console.log(`  Thinking:   ${config.syncThinking ? "enabled" : "disabled"}`);
+    console.log("\n⏳ Testing connection...");
+    const client = new index_1.SyncClient(config);
+    const connected = await client.testConnection();
+    if (connected) {
+        console.log("✅ Connected to Convex backend\n");
+    }
+    else {
+        console.log("❌ Could not connect to Convex backend\n");
+        process.exit(1);
+    }
+});
+program
+    .command("config")
+    .description("Show current configuration")
+    .option("--json", "Output as JSON")
+    .action((options) => {
+    const config = (0, index_1.loadConfig)();
+    if (!config) {
+        if (options.json) {
+            console.log(JSON.stringify({ configured: false }));
+        }
+        else {
+            console.log("Not configured. Run 'claude-code-sync login' to set up.");
+        }
+        return;
+    }
+    if (options.json) {
+        console.log(JSON.stringify({
+            configured: true,
+            convexUrl: config.convexUrl,
+            apiKey: maskApiKey(config.apiKey),
+            autoSync: config.autoSync !== false,
+            syncToolCalls: config.syncToolCalls !== false,
+            syncThinking: config.syncThinking === true,
+        }, null, 2));
+    }
+    else {
+        console.log("\n📋 Current Configuration\n");
+        console.log(`Convex URL:  ${config.convexUrl}`);
+        console.log(`API Key:     ${maskApiKey(config.apiKey)}`);
+        console.log(`Auto Sync:   ${config.autoSync !== false}`);
+        console.log(`Tool Calls:  ${config.syncToolCalls !== false}`);
+        console.log(`Thinking:    ${config.syncThinking === true}`);
+        console.log(`\nConfig file: ~/.config/claude-code-sync/config.json\n`);
+    }
+});
+program
+    .command("set <key> <value>")
+    .description("Set a configuration value")
+    .action((key, value) => {
+    const config = (0, index_1.loadConfig)();
+    if (!config) {
+        console.error("Not configured. Run 'claude-code-sync login' first.");
+        process.exit(1);
+    }
+    const validKeys = ["autoSync", "syncToolCalls", "syncThinking"];
+    if (!validKeys.includes(key)) {
+        console.error(`Invalid key. Valid keys: ${validKeys.join(", ")}`);
+        process.exit(1);
+    }
+    const boolValue = value === "true" || value === "1" || value === "yes";
+    // Type-safe config update
+    if (key === "autoSync") {
+        config.autoSync = boolValue;
+    }
+    else if (key === "syncToolCalls") {
+        config.syncToolCalls = boolValue;
+    }
+    else if (key === "syncThinking") {
+        config.syncThinking = boolValue;
+    }
+    (0, index_1.saveConfig)(config);
+    console.log(`✅ Set ${key} = ${boolValue}`);
+});
+// Parse and run
+program.parse();
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"cli.js","sourceRoot":"","sources":["../src/cli.ts"],"names":[],"mappings":"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","sourcesContent":["#!/usr/bin/env node\n\n/**\n * Claude Code Sync CLI\n *\n * Commands:\n *   login   - Configure Convex URL and API Key\n *   logout  - Clear stored credentials\n *   status  - Show connection status\n *   config  - Show current configuration\n */\n\nimport { Command } from \"commander\";\nimport * as readline from \"readline\";\nimport {\n  loadConfig,\n  saveConfig,\n  clearConfig,\n  SyncClient,\n  Config,\n} from \"./index\";\n\nconst program = new Command();\n\nprogram\n  .name(\"claude-code-sync\")\n  .description(\"Sync Claude Code sessions to OpenSync dashboard\")\n  .version(\"0.1.0\");\n\n// ============================================================================\n// Helper Functions\n// ============================================================================\n\nfunction prompt(question: string): Promise<string> {\n  const rl = readline.createInterface({\n    input: process.stdin,\n    output: process.stdout,\n  });\n\n  return new Promise((resolve) => {\n    rl.question(question, (answer) => {\n      rl.close();\n      resolve(answer.trim());\n    });\n  });\n}\n\nfunction maskApiKey(key: string): string {\n  if (key.length <= 8) return \"****\";\n  return key.substring(0, 4) + \"****\" + key.substring(key.length - 4);\n}\n\n// ============================================================================\n// Commands\n// ============================================================================\n\nprogram\n  .command(\"login\")\n  .description(\"Configure Convex URL and API Key\")\n  .action(async () => {\n    console.log(\"\\n🔐 Claude Code Sync - Login\\n\");\n    console.log(\"Get your API key from your OpenSync dashboard:\");\n    console.log(\"  1. Go to Settings\");\n    console.log(\"  2. Click 'Generate API Key'\");\n    console.log(\"  3. Copy the key (starts with osk_)\\n\");\n\n    const convexUrl = await prompt(\"Convex URL (e.g., https://your-project.convex.cloud): \");\n\n    if (!convexUrl) {\n      console.error(\"❌ Convex URL is required\");\n      process.exit(1);\n    }\n\n    if (!convexUrl.includes(\"convex.cloud\") && !convexUrl.includes(\"convex.site\")) {\n      console.error(\"❌ Invalid Convex URL. Must contain convex.cloud or convex.site\");\n      process.exit(1);\n    }\n\n    const apiKey = await prompt(\"API Key (osk_...): \");\n\n    if (!apiKey) {\n      console.error(\"❌ API Key is required\");\n      process.exit(1);\n    }\n\n    if (!apiKey.startsWith(\"osk_\")) {\n      console.error(\"❌ Invalid API Key. Must start with osk_\");\n      process.exit(1);\n    }\n\n    const config: Config = {\n      convexUrl,\n      apiKey,\n      autoSync: true,\n      syncToolCalls: true,\n      syncThinking: false,\n    };\n\n    // Test connection\n    console.log(\"\\n⏳ Testing connection...\");\n    const client = new SyncClient(config);\n    const connected = await client.testConnection();\n\n    if (!connected) {\n      console.error(\"❌ Could not connect to Convex backend\");\n      console.error(\"   Check your URL and try again\");\n      process.exit(1);\n    }\n\n    // Save config\n    saveConfig(config);\n    console.log(\"\\n✅ Configuration saved!\");\n    console.log(`   URL: ${convexUrl}`);\n    console.log(`   Key: ${maskApiKey(apiKey)}`);\n    console.log(\"\\n📦 Add the plugin to your Claude Code config to start syncing.\\n\");\n  });\n\nprogram\n  .command(\"logout\")\n  .description(\"Clear stored credentials\")\n  .action(() => {\n    clearConfig();\n    console.log(\"✅ Credentials cleared\");\n  });\n\nprogram\n  .command(\"status\")\n  .description(\"Show connection status\")\n  .action(async () => {\n    const config = loadConfig();\n\n    console.log(\"\\n📊 Claude Code Sync - Status\\n\");\n\n    if (!config) {\n      console.log(\"❌ Not configured\");\n      console.log(\"   Run 'claude-code-sync login' to set up\\n\");\n      process.exit(1);\n    }\n\n    console.log(\"Configuration:\");\n    console.log(`  Convex URL: ${config.convexUrl}`);\n    console.log(`  API Key:    ${maskApiKey(config.apiKey)}`);\n    console.log(`  Auto Sync:  ${config.autoSync !== false ? \"enabled\" : \"disabled\"}`);\n    console.log(`  Tool Calls: ${config.syncToolCalls !== false ? \"enabled\" : \"disabled\"}`);\n    console.log(`  Thinking:   ${config.syncThinking ? \"enabled\" : \"disabled\"}`);\n\n    console.log(\"\\n⏳ Testing connection...\");\n    const client = new SyncClient(config);\n    const connected = await client.testConnection();\n\n    if (connected) {\n      console.log(\"✅ Connected to Convex backend\\n\");\n    } else {\n      console.log(\"❌ Could not connect to Convex backend\\n\");\n      process.exit(1);\n    }\n  });\n\nprogram\n  .command(\"config\")\n  .description(\"Show current configuration\")\n  .option(\"--json\", \"Output as JSON\")\n  .action((options: { json?: boolean }) => {\n    const config = loadConfig();\n\n    if (!config) {\n      if (options.json) {\n        console.log(JSON.stringify({ configured: false }));\n      } else {\n        console.log(\"Not configured. Run 'claude-code-sync login' to set up.\");\n      }\n      return;\n    }\n\n    if (options.json) {\n      console.log(\n        JSON.stringify(\n          {\n            configured: true,\n            convexUrl: config.convexUrl,\n            apiKey: maskApiKey(config.apiKey),\n            autoSync: config.autoSync !== false,\n            syncToolCalls: config.syncToolCalls !== false,\n            syncThinking: config.syncThinking === true,\n          },\n          null,\n          2\n        )\n      );\n    } else {\n      console.log(\"\\n📋 Current Configuration\\n\");\n      console.log(`Convex URL:  ${config.convexUrl}`);\n      console.log(`API Key:     ${maskApiKey(config.apiKey)}`);\n      console.log(`Auto Sync:   ${config.autoSync !== false}`);\n      console.log(`Tool Calls:  ${config.syncToolCalls !== false}`);\n      console.log(`Thinking:    ${config.syncThinking === true}`);\n      console.log(`\\nConfig file: ~/.config/claude-code-sync/config.json\\n`);\n    }\n  });\n\nprogram\n  .command(\"set <key> <value>\")\n  .description(\"Set a configuration value\")\n  .action((key: string, value: string) => {\n    const config = loadConfig();\n\n    if (!config) {\n      console.error(\"Not configured. Run 'claude-code-sync login' first.\");\n      process.exit(1);\n    }\n\n    const validKeys = [\"autoSync\", \"syncToolCalls\", \"syncThinking\"];\n    if (!validKeys.includes(key)) {\n      console.error(`Invalid key. Valid keys: ${validKeys.join(\", \")}`);\n      process.exit(1);\n    }\n\n    const boolValue = value === \"true\" || value === \"1\" || value === \"yes\";\n    \n    // Type-safe config update\n    if (key === \"autoSync\") {\n      config.autoSync = boolValue;\n    } else if (key === \"syncToolCalls\") {\n      config.syncToolCalls = boolValue;\n    } else if (key === \"syncThinking\") {\n      config.syncThinking = boolValue;\n    }\n\n    saveConfig(config);\n    console.log(`✅ Set ${key} = ${boolValue}`);\n  });\n\n// Parse and run\nprogram.parse();\n"]}

package/dist/index.d.ts

@@ -0,0 +1,137 @@
+/**
+ * Claude Code Sync Plugin
+ *
+ * Syncs Claude Code sessions to OpenSync dashboard.
+ * Uses API Key authentication (no browser OAuth required).
+ *
+ * Install: npm install -g claude-code-sync
+ * Configure: claude-code-sync login
+ */
+export interface Config {
+    convexUrl: string;
+    apiKey: string;
+    autoSync?: boolean;
+    syncToolCalls?: boolean;
+    syncThinking?: boolean;
+}
+export interface SessionData {
+    sessionId: string;
+    source: "claude-code";
+    title?: string;
+    projectPath?: string;
+    projectName?: string;
+    cwd?: string;
+    gitBranch?: string;
+    gitRepo?: string;
+    model?: string;
+    startType?: "new" | "resume" | "continue";
+    endReason?: "user_stop" | "max_turns" | "error" | "completed";
+    thinkingEnabled?: boolean;
+    permissionMode?: string;
+    mcpServers?: string[];
+    messageCount?: number;
+    toolCallCount?: number;
+    tokenUsage?: {
+        input: number;
+        output: number;
+    };
+    costEstimate?: number;
+    startedAt?: string;
+    endedAt?: string;
+}
+export interface MessageData {
+    sessionId: string;
+    messageId: string;
+    source: "claude-code";
+    role: "user" | "assistant" | "system";
+    content?: string;
+    thinkingContent?: string;
+    toolName?: string;
+    toolArgs?: Record<string, unknown>;
+    toolResult?: string;
+    durationMs?: number;
+    tokenCount?: number;
+    timestamp?: string;
+}
+export interface ToolUseData {
+    sessionId: string;
+    toolName: string;
+    toolArgs?: Record<string, unknown>;
+    result?: string;
+    success?: boolean;
+    durationMs?: number;
+    timestamp?: string;
+}
+export interface ClaudeCodeHooks {
+    SessionStart?: (data: SessionStartEvent) => void | Promise<void>;
+    UserPromptSubmit?: (data: UserPromptEvent) => void | Promise<void>;
+    PostToolUse?: (data: ToolUseEvent) => void | Promise<void>;
+    Stop?: (data: StopEvent) => void | Promise<void>;
+    SessionEnd?: (data: SessionEndEvent) => void | Promise<void>;
+}
+export interface SessionStartEvent {
+    sessionId: string;
+    cwd: string;
+    model: string;
+    startType: "new" | "resume" | "continue";
+    thinkingEnabled?: boolean;
+    permissionMode?: string;
+    mcpServers?: string[];
+}
+export interface UserPromptEvent {
+    sessionId: string;
+    prompt: string;
+    timestamp: string;
+}
+export interface ToolUseEvent {
+    sessionId: string;
+    toolName: string;
+    args: Record<string, unknown>;
+    result: string;
+    success: boolean;
+    durationMs: number;
+}
+export interface StopEvent {
+    sessionId: string;
+    response: string;
+    tokenUsage: {
+        input: number;
+        output: number;
+    };
+    durationMs: number;
+}
+export interface SessionEndEvent {
+    sessionId: string;
+    endReason: "user_stop" | "max_turns" | "error" | "completed";
+    messageCount: number;
+    toolCallCount: number;
+    totalTokenUsage: {
+        input: number;
+        output: number;
+    };
+    costEstimate: number;
+}
+export declare function loadConfig(): Config | null;
+export declare function saveConfig(config: Config): void;
+export declare function clearConfig(): void;
+export declare class SyncClient {
+    private config;
+    private sessionCache;
+    constructor(config: Config);
+    private request;
+    syncSession(session: SessionData): Promise<void>;
+    syncMessage(message: MessageData): Promise<void>;
+    syncBatch(sessions: SessionData[], messages: MessageData[]): Promise<void>;
+    testConnection(): Promise<boolean>;
+    getSessionState(sessionId: string): Partial<SessionData>;
+    updateSessionState(sessionId: string, updates: Partial<SessionData>): void;
+    clearSessionState(sessionId: string): void;
+}
+/**
+ * Claude Code Plugin Entry Point
+ *
+ * This function is called by Claude Code to register the plugin.
+ * It returns hook handlers that fire at key points in the session lifecycle.
+ */
+export declare function createPlugin(): ClaudeCodeHooks | null;
+export default createPlugin;

package/dist/index.js

@@ -0,0 +1,334 @@
+"use strict";
+/**
+ * Claude Code Sync Plugin
+ *
+ * Syncs Claude Code sessions to OpenSync dashboard.
+ * Uses API Key authentication (no browser OAuth required).
+ *
+ * Install: npm install -g claude-code-sync
+ * Configure: claude-code-sync login
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SyncClient = void 0;
+exports.loadConfig = loadConfig;
+exports.saveConfig = saveConfig;
+exports.clearConfig = clearConfig;
+exports.createPlugin = createPlugin;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const os = __importStar(require("os"));
+// ============================================================================
+// Configuration
+// ============================================================================
+const CONFIG_DIR = path.join(os.homedir(), ".config", "claude-code-sync");
+const CONFIG_FILE = path.join(CONFIG_DIR, "config.json");
+function loadConfig() {
+    // Check environment variables first
+    const envUrl = process.env.CLAUDE_SYNC_CONVEX_URL;
+    const envKey = process.env.CLAUDE_SYNC_API_KEY;
+    if (envUrl && envKey) {
+        return {
+            convexUrl: normalizeConvexUrl(envUrl),
+            apiKey: envKey,
+            autoSync: process.env.CLAUDE_SYNC_AUTO_SYNC !== "false",
+            syncToolCalls: process.env.CLAUDE_SYNC_TOOL_CALLS !== "false",
+            syncThinking: process.env.CLAUDE_SYNC_THINKING === "true",
+        };
+    }
+    // Fall back to config file
+    try {
+        if (fs.existsSync(CONFIG_FILE)) {
+            const data = fs.readFileSync(CONFIG_FILE, "utf-8");
+            const config = JSON.parse(data);
+            config.convexUrl = normalizeConvexUrl(config.convexUrl);
+            return config;
+        }
+    }
+    catch (error) {
+        console.error("Error loading config:", error);
+    }
+    return null;
+}
+function saveConfig(config) {
+    try {
+        if (!fs.existsSync(CONFIG_DIR)) {
+            fs.mkdirSync(CONFIG_DIR, { recursive: true });
+        }
+        fs.writeFileSync(CONFIG_FILE, JSON.stringify(config, null, 2));
+    }
+    catch (error) {
+        console.error("Error saving config:", error);
+        throw error;
+    }
+}
+function clearConfig() {
+    try {
+        if (fs.existsSync(CONFIG_FILE)) {
+            fs.unlinkSync(CONFIG_FILE);
+        }
+    }
+    catch (error) {
+        console.error("Error clearing config:", error);
+    }
+}
+function normalizeConvexUrl(url) {
+    // Convert .convex.cloud to .convex.site for API calls
+    return url.replace(".convex.cloud", ".convex.site");
+}
+// ============================================================================
+// Sync Client
+// ============================================================================
+class SyncClient {
+    config;
+    sessionCache = new Map();
+    constructor(config) {
+        this.config = config;
+    }
+    async request(endpoint, data) {
+        const url = `${this.config.convexUrl}${endpoint}`;
+        const response = await fetch(url, {
+            method: "POST",
+            headers: {
+                "Content-Type": "application/json",
+                Authorization: `Bearer ${this.config.apiKey}`,
+            },
+            body: JSON.stringify(data),
+        });
+        if (!response.ok) {
+            const text = await response.text();
+            throw new Error(`Sync failed: ${response.status} - ${text}`);
+        }
+        return response.json();
+    }
+    async syncSession(session) {
+        try {
+            await this.request("/sync/session", session);
+        }
+        catch (error) {
+            console.error("Failed to sync session:", error);
+        }
+    }
+    async syncMessage(message) {
+        try {
+            await this.request("/sync/message", message);
+        }
+        catch (error) {
+            console.error("Failed to sync message:", error);
+        }
+    }
+    async syncBatch(sessions, messages) {
+        try {
+            await this.request("/sync/batch", { sessions, messages });
+        }
+        catch (error) {
+            console.error("Failed to sync batch:", error);
+        }
+    }
+    async testConnection() {
+        try {
+            const url = `${this.config.convexUrl}/health`;
+            const response = await fetch(url);
+            return response.ok;
+        }
+        catch {
+            return false;
+        }
+    }
+    // Session state management
+    getSessionState(sessionId) {
+        return this.sessionCache.get(sessionId) || {};
+    }
+    updateSessionState(sessionId, updates) {
+        const current = this.sessionCache.get(sessionId) || {};
+        this.sessionCache.set(sessionId, { ...current, ...updates });
+    }
+    clearSessionState(sessionId) {
+        this.sessionCache.delete(sessionId);
+    }
+}
+exports.SyncClient = SyncClient;
+// ============================================================================
+// Plugin Export
+// ============================================================================
+/**
+ * Claude Code Plugin Entry Point
+ *
+ * This function is called by Claude Code to register the plugin.
+ * It returns hook handlers that fire at key points in the session lifecycle.
+ */
+function createPlugin() {
+    const config = loadConfig();
+    if (!config) {
+        console.log("[claude-code-sync] Not configured. Run 'claude-code-sync login' to set up.");
+        return null;
+    }
+    if (config.autoSync === false) {
+        console.log("[claude-code-sync] Auto-sync disabled in config.");
+        return null;
+    }
+    const client = new SyncClient(config);
+    let messageCounter = 0;
+    let toolCallCounter = 0;
+    console.log("[claude-code-sync] Plugin loaded. Sessions will sync to OpenSync.");
+    return {
+        /**
+         * Called when a new session starts
+         */
+        SessionStart: async (event) => {
+            messageCounter = 0;
+            toolCallCounter = 0;
+            const session = {
+                sessionId: event.sessionId,
+                source: "claude-code",
+                cwd: event.cwd,
+                model: event.model,
+                startType: event.startType,
+                thinkingEnabled: event.thinkingEnabled,
+                permissionMode: event.permissionMode,
+                mcpServers: event.mcpServers,
+                startedAt: new Date().toISOString(),
+            };
+            // Extract project info from cwd
+            if (event.cwd) {
+                session.projectPath = event.cwd;
+                session.projectName = path.basename(event.cwd);
+                // Try to get git info
+                try {
+                    const gitDir = path.join(event.cwd, ".git");
+                    if (fs.existsSync(gitDir)) {
+                        const headFile = path.join(gitDir, "HEAD");
+                        if (fs.existsSync(headFile)) {
+                            const head = fs.readFileSync(headFile, "utf-8").trim();
+                            if (head.startsWith("ref: refs/heads/")) {
+                                session.gitBranch = head.replace("ref: refs/heads/", "");
+                            }
+                        }
+                    }
+                }
+                catch {
+                    // Ignore git errors
+                }
+            }
+            client.updateSessionState(event.sessionId, session);
+            await client.syncSession(session);
+        },
+        /**
+         * Called when user submits a prompt
+         */
+        UserPromptSubmit: async (event) => {
+            messageCounter++;
+            const message = {
+                sessionId: event.sessionId,
+                messageId: `${event.sessionId}-msg-${messageCounter}`,
+                source: "claude-code",
+                role: "user",
+                content: event.prompt,
+                timestamp: event.timestamp || new Date().toISOString(),
+            };
+            await client.syncMessage(message);
+        },
+        /**
+         * Called after each tool use
+         */
+        PostToolUse: async (event) => {
+            if (!config.syncToolCalls)
+                return;
+            toolCallCounter++;
+            messageCounter++;
+            const message = {
+                sessionId: event.sessionId,
+                messageId: `${event.sessionId}-tool-${toolCallCounter}`,
+                source: "claude-code",
+                role: "assistant",
+                toolName: event.toolName,
+                toolArgs: event.args,
+                toolResult: event.result,
+                durationMs: event.durationMs,
+                timestamp: new Date().toISOString(),
+            };
+            await client.syncMessage(message);
+        },
+        /**
+         * Called when Claude stops responding
+         */
+        Stop: async (event) => {
+            messageCounter++;
+            const message = {
+                sessionId: event.sessionId,
+                messageId: `${event.sessionId}-msg-${messageCounter}`,
+                source: "claude-code",
+                role: "assistant",
+                content: event.response,
+                tokenCount: event.tokenUsage.input + event.tokenUsage.output,
+                durationMs: event.durationMs,
+                timestamp: new Date().toISOString(),
+            };
+            // Update session state with token usage
+            const currentState = client.getSessionState(event.sessionId);
+            const currentTokens = currentState.tokenUsage || { input: 0, output: 0 };
+            client.updateSessionState(event.sessionId, {
+                tokenUsage: {
+                    input: currentTokens.input + event.tokenUsage.input,
+                    output: currentTokens.output + event.tokenUsage.output,
+                },
+            });
+            await client.syncMessage(message);
+        },
+        /**
+         * Called when session ends
+         */
+        SessionEnd: async (event) => {
+            const currentState = client.getSessionState(event.sessionId);
+            const session = {
+                ...currentState,
+                sessionId: event.sessionId,
+                source: "claude-code",
+                endReason: event.endReason,
+                messageCount: event.messageCount,
+                toolCallCount: event.toolCallCount,
+                tokenUsage: event.totalTokenUsage,
+                costEstimate: event.costEstimate,
+                endedAt: new Date().toISOString(),
+            };
+            await client.syncSession(session);
+            client.clearSessionState(event.sessionId);
+            console.log(`[claude-code-sync] Session synced: ${event.messageCount} messages, ${event.toolCallCount} tool calls`);
+        },
+    };
+}
+// Default export for Claude Code plugin system
+exports.default = createPlugin;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":";AAAA;;;;;;;;GAQG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAoIH,gCA4BC;AAED,gCAUC;AAED,kCAQC;AAwGD,oCAqKC;AAjcD,uCAAyB;AACzB,2CAA6B;AAC7B,uCAAyB;AAyHzB,+EAA+E;AAC/E,gBAAgB;AAChB,+EAA+E;AAE/E,MAAM,UAAU,GAAG,IAAI,CAAC,IAAI,CAAC,EAAE,CAAC,OAAO,EAAE,EAAE,SAAS,EAAE,kBAAkB,CAAC,CAAC;AAC1E,MAAM,WAAW,GAAG,IAAI,CAAC,IAAI,CAAC,UAAU,EAAE,aAAa,CAAC,CAAC;AAEzD,SAAgB,UAAU;IACxB,oCAAoC;IACpC,MAAM,MAAM,GAAG,OAAO,CAAC,GAAG,CAAC,sBAAsB,CAAC;IAClD,MAAM,MAAM,GAAG,OAAO,CAAC,GAAG,CAAC,mBAAmB,CAAC;IAE/C,IAAI,MAAM,IAAI,MAAM,EAAE,CAAC;QACrB,OAAO;YACL,SAAS,EAAE,kBAAkB,CAAC,MAAM,CAAC;YACrC,MAAM,EAAE,MAAM;YACd,QAAQ,EAAE,OAAO,CAAC,GAAG,CAAC,qBAAqB,KAAK,OAAO;YACvD,aAAa,EAAE,OAAO,CAAC,GAAG,CAAC,sBAAsB,KAAK,OAAO;YAC7D,YAAY,EAAE,OAAO,CAAC,GAAG,CAAC,oBAAoB,KAAK,MAAM;SAC1D,CAAC;IACJ,CAAC;IAED,2BAA2B;IAC3B,IAAI,CAAC;QACH,IAAI,EAAE,CAAC,UAAU,CAAC,WAAW,CAAC,EAAE,CAAC;YAC/B,MAAM,IAAI,GAAG,EAAE,CAAC,YAAY,CAAC,WAAW,EAAE,OAAO,CAAC,CAAC;YACnD,MAAM,MAAM,GAAG,IAAI,CAAC,KAAK,CAAC,IAAI,CAAW,CAAC;YAC1C,MAAM,CAAC,SAAS,GAAG,kBAAkB,CAAC,MAAM,CAAC,SAAS,CAAC,CAAC;YACxD,OAAO,MAAM,CAAC;QAChB,CAAC;IACH,CAAC;IAAC,OAAO,KAAK,EAAE,CAAC;QACf,OAAO,CAAC,KAAK,CAAC,uBAAuB,EAAE,KAAK,CAAC,CAAC;IAChD,CAAC;IAED,OAAO,IAAI,CAAC;AACd,CAAC;AAED,SAAgB,UAAU,CAAC,MAAc;IACvC,IAAI,CAAC;QACH,IAAI,CAAC,EAAE,CAAC,UAAU,CAAC,UAAU,CAAC,EAAE,CAAC;YAC/B,EAAE,CAAC,SAAS,CAAC,UAAU,EAAE,EAAE,SAAS,EAAE,IAAI,EAAE,CAAC,CAAC;QAChD,CAAC;QACD,EAAE,CAAC,aAAa,CAAC,WAAW,EAAE,IAAI,CAAC,SAAS,CAAC,MAAM,EAAE,IAAI,EAAE,CAAC,CAAC,CAAC,CAAC;IACjE,CAAC;IAAC,OAAO,KAAK,EAAE,CAAC;QACf,OAAO,CAAC,KAAK,CAAC,sBAAsB,EAAE,KAAK,CAAC,CAAC;QAC7C,MAAM,KAAK,CAAC;IACd,CAAC;AACH,CAAC;AAED,SAAgB,WAAW;IACzB,IAAI,CAAC;QACH,IAAI,EAAE,CAAC,UAAU,CAAC,WAAW,CAAC,EAAE,CAAC;YAC/B,EAAE,CAAC,UAAU,CAAC,WAAW,CAAC,CAAC;QAC7B,CAAC;IACH,CAAC;IAAC,OAAO,KAAK,EAAE,CAAC;QACf,OAAO,CAAC,KAAK,CAAC,wBAAwB,EAAE,KAAK,CAAC,CAAC;IACjD,CAAC;AACH,CAAC;AAED,SAAS,kBAAkB,CAAC,GAAW;IACrC,sDAAsD;IACtD,OAAO,GAAG,CAAC,OAAO,CAAC,eAAe,EAAE,cAAc,CAAC,CAAC;AACtD,CAAC;AAED,+EAA+E;AAC/E,cAAc;AACd,+EAA+E;AAE/E,MAAa,UAAU;IACb,MAAM,CAAS;IACf,YAAY,GAAsC,IAAI,GAAG,EAAE,CAAC;IAEpE,YAAY,MAAc;QACxB,IAAI,CAAC,MAAM,GAAG,MAAM,CAAC;IACvB,CAAC;IAEO,KAAK,CAAC,OAAO,CAAC,QAAgB,EAAE,IAAa;QACnD,MAAM,GAAG,GAAG,GAAG,IAAI,CAAC,MAAM,CAAC,SAAS,GAAG,QAAQ,EAAE,CAAC;QAElD,MAAM,QAAQ,GAAG,MAAM,KAAK,CAAC,GAAG,EAAE;YAChC,MAAM,EAAE,MAAM;YACd,OAAO,EAAE;gBACP,cAAc,EAAE,kBAAkB;gBAClC,aAAa,EAAE,UAAU,IAAI,CAAC,MAAM,CAAC,MAAM,EAAE;aAC9C;YACD,IAAI,EAAE,IAAI,CAAC,SAAS,CAAC,IAAI,CAAC;SAC3B,CAAC,CAAC;QAEH,IAAI,CAAC,QAAQ,CAAC,EAAE,EAAE,CAAC;YACjB,MAAM,IAAI,GAAG,MAAM,QAAQ,CAAC,IAAI,EAAE,CAAC;YACnC,MAAM,IAAI,KAAK,CAAC,gBAAgB,QAAQ,CAAC,MAAM,MAAM,IAAI,EAAE,CAAC,CAAC;QAC/D,CAAC;QAED,OAAO,QAAQ,CAAC,IAAI,EAAE,CAAC;IACzB,CAAC;IAED,KAAK,CAAC,WAAW,CAAC,OAAoB;QACpC,IAAI,CAAC;YACH,MAAM,IAAI,CAAC,OAAO,CAAC,eAAe,EAAE,OAAO,CAAC,CAAC;QAC/C,CAAC;QAAC,OAAO,KAAK,EAAE,CAAC;YACf,OAAO,CAAC,KAAK,CAAC,yBAAyB,EAAE,KAAK,CAAC,CAAC;QAClD,CAAC;IACH,CAAC;IAED,KAAK,CAAC,WAAW,CAAC,OAAoB;QACpC,IAAI,CAAC;YACH,MAAM,IAAI,CAAC,OAAO,CAAC,eAAe,EAAE,OAAO,CAAC,CAAC;QAC/C,CAAC;QAAC,OAAO,KAAK,EAAE,CAAC;YACf,OAAO,CAAC,KAAK,CAAC,yBAAyB,EAAE,KAAK,CAAC,CAAC;QAClD,CAAC;IACH,CAAC;IAED,KAAK,CAAC,SAAS,CACb,QAAuB,EACvB,QAAuB;QAEvB,IAAI,CAAC;YACH,MAAM,IAAI,CAAC,OAAO,CAAC,aAAa,EAAE,EAAE,QAAQ,EAAE,QAAQ,EAAE,CAAC,CAAC;QAC5D,CAAC;QAAC,OAAO,KAAK,EAAE,CAAC;YACf,OAAO,CAAC,KAAK,CAAC,uBAAuB,EAAE,KAAK,CAAC,CAAC;QAChD,CAAC;IACH,CAAC;IAED,KAAK,CAAC,cAAc;QAClB,IAAI,CAAC;YACH,MAAM,GAAG,GAAG,GAAG,IAAI,CAAC,MAAM,CAAC,SAAS,SAAS,CAAC;YAC9C,MAAM,QAAQ,GAAG,MAAM,KAAK,CAAC,GAAG,CAAC,CAAC;YAClC,OAAO,QAAQ,CAAC,EAAE,CAAC;QACrB,CAAC;QAAC,MAAM,CAAC;YACP,OAAO,KAAK,CAAC;QACf,CAAC;IACH,CAAC;IAED,2BAA2B;IAC3B,eAAe,CAAC,SAAiB;QAC/B,OAAO,IAAI,CAAC,YAAY,CAAC,GAAG,CAAC,SAAS,CAAC,IAAI,EAAE,CAAC;IAChD,CAAC;IAED,kBAAkB,CAChB,SAAiB,EACjB,OAA6B;QAE7B,MAAM,OAAO,GAAG,IAAI,CAAC,YAAY,CAAC,GAAG,CAAC,SAAS,CAAC,IAAI,EAAE,CAAC;QACvD,IAAI,CAAC,YAAY,CAAC,GAAG,CAAC,SAAS,EAAE,EAAE,GAAG,OAAO,EAAE,GAAG,OAAO,EAAE,CAAC,CAAC;IAC/D,CAAC;IAED,iBAAiB,CAAC,SAAiB;QACjC,IAAI,CAAC,YAAY,CAAC,MAAM,CAAC,SAAS,CAAC,CAAC;IACtC,CAAC;CACF;AAjFD,gCAiFC;AAED,+EAA+E;AAC/E,gBAAgB;AAChB,+EAA+E;AAE/E;;;;;GAKG;AACH,SAAgB,YAAY;IAC1B,MAAM,MAAM,GAAG,UAAU,EAAE,CAAC;IAE5B,IAAI,CAAC,MAAM,EAAE,CAAC;QACZ,OAAO,CAAC,GAAG,CACT,4EAA4E,CAC7E,CAAC;QACF,OAAO,IAAI,CAAC;IACd,CAAC;IAED,IAAI,MAAM,CAAC,QAAQ,KAAK,KAAK,EAAE,CAAC;QAC9B,OAAO,CAAC,GAAG,CAAC,kDAAkD,CAAC,CAAC;QAChE,OAAO,IAAI,CAAC;IACd,CAAC;IAED,MAAM,MAAM,GAAG,IAAI,UAAU,CAAC,MAAM,CAAC,CAAC;IACtC,IAAI,cAAc,GAAG,CAAC,CAAC;IACvB,IAAI,eAAe,GAAG,CAAC,CAAC;IAExB,OAAO,CAAC,GAAG,CAAC,mEAAmE,CAAC,CAAC;IAEjF,OAAO;QACL;;WAEG;QACH,YAAY,EAAE,KAAK,EAAE,KAAwB,EAAE,EAAE;YAC/C,cAAc,GAAG,CAAC,CAAC;YACnB,eAAe,GAAG,CAAC,CAAC;YAEpB,MAAM,OAAO,GAAgB;gBAC3B,SAAS,EAAE,KAAK,CAAC,SAAS;gBAC1B,MAAM,EAAE,aAAa;gBACrB,GAAG,EAAE,KAAK,CAAC,GAAG;gBACd,KAAK,EAAE,KAAK,CAAC,KAAK;gBAClB,SAAS,EAAE,KAAK,CAAC,SAAS;gBAC1B,eAAe,EAAE,KAAK,CAAC,eAAe;gBACtC,cAAc,EAAE,KAAK,CAAC,cAAc;gBACpC,UAAU,EAAE,KAAK,CAAC,UAAU;gBAC5B,SAAS,EAAE,IAAI,IAAI,EAAE,CAAC,WAAW,EAAE;aACpC,CAAC;YAEF,gCAAgC;YAChC,IAAI,KAAK,CAAC,GAAG,EAAE,CAAC;gBACd,OAAO,CAAC,WAAW,GAAG,KAAK,CAAC,GAAG,CAAC;gBAChC,OAAO,CAAC,WAAW,GAAG,IAAI,CAAC,QAAQ,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC;gBAE/C,sBAAsB;gBACtB,IAAI,CAAC;oBACH,MAAM,MAAM,GAAG,IAAI,CAAC,IAAI,CAAC,KAAK,CAAC,GAAG,EAAE,MAAM,CAAC,CAAC;oBAC5C,IAAI,EAAE,CAAC,UAAU,CAAC,MAAM,CAAC,EAAE,CAAC;wBAC1B,MAAM,QAAQ,GAAG,IAAI,CAAC,IAAI,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;wBAC3C,IAAI,EAAE,CAAC,UAAU,CAAC,QAAQ,CAAC,EAAE,CAAC;4BAC5B,MAAM,IAAI,GAAG,EAAE,CAAC,YAAY,CAAC,QAAQ,EAAE,OAAO,CAAC,CAAC,IAAI,EAAE,CAAC;4BACvD,IAAI,IAAI,CAAC,UAAU,CAAC,kBAAkB,CAAC,EAAE,CAAC;gCACxC,OAAO,CAAC,SAAS,GAAG,IAAI,CAAC,OAAO,CAAC,kBAAkB,EAAE,EAAE,CAAC,CAAC;4BAC3D,CAAC;wBACH,CAAC;oBACH,CAAC;gBACH,CAAC;gBAAC,MAAM,CAAC;oBACP,oBAAoB;gBACtB,CAAC;YACH,CAAC;YAED,MAAM,CAAC,kBAAkB,CAAC,KAAK,CAAC,SAAS,EAAE,OAAO,CAAC,CAAC;YACpD,MAAM,MAAM,CAAC,WAAW,CAAC,OAAO,CAAC,CAAC;QACpC,CAAC;QAED;;WAEG;QACH,gBAAgB,EAAE,KAAK,EAAE,KAAsB,EAAE,EAAE;YACjD,cAAc,EAAE,CAAC;YAEjB,MAAM,OAAO,GAAgB;gBAC3B,SAAS,EAAE,KAAK,CAAC,SAAS;gBAC1B,SAAS,EAAE,GAAG,KAAK,CAAC,SAAS,QAAQ,cAAc,EAAE;gBACrD,MAAM,EAAE,aAAa;gBACrB,IAAI,EAAE,MAAM;gBACZ,OAAO,EAAE,KAAK,CAAC,MAAM;gBACrB,SAAS,EAAE,KAAK,CAAC,SAAS,IAAI,IAAI,IAAI,EAAE,CAAC,WAAW,EAAE;aACvD,CAAC;YAEF,MAAM,MAAM,CAAC,WAAW,CAAC,OAAO,CAAC,CAAC;QACpC,CAAC;QAED;;WAEG;QACH,WAAW,EAAE,KAAK,EAAE,KAAmB,EAAE,EAAE;YACzC,IAAI,CAAC,MAAM,CAAC,aAAa;gBAAE,OAAO;YAElC,eAAe,EAAE,CAAC;YAClB,cAAc,EAAE,CAAC;YAEjB,MAAM,OAAO,GAAgB;gBAC3B,SAAS,EAAE,KAAK,CAAC,SAAS;gBAC1B,SAAS,EAAE,GAAG,KAAK,CAAC,SAAS,SAAS,eAAe,EAAE;gBACvD,MAAM,EAAE,aAAa;gBACrB,IAAI,EAAE,WAAW;gBACjB,QAAQ,EAAE,KAAK,CAAC,QAAQ;gBACxB,QAAQ,EAAE,KAAK,CAAC,IAAI;gBACpB,UAAU,EAAE,KAAK,CAAC,MAAM;gBACxB,UAAU,EAAE,KAAK,CAAC,UAAU;gBAC5B,SAAS,EAAE,IAAI,IAAI,EAAE,CAAC,WAAW,EAAE;aACpC,CAAC;YAEF,MAAM,MAAM,CAAC,WAAW,CAAC,OAAO,CAAC,CAAC;QACpC,CAAC;QAED;;WAEG;QACH,IAAI,EAAE,KAAK,EAAE,KAAgB,EAAE,EAAE;YAC/B,cAAc,EAAE,CAAC;YAEjB,MAAM,OAAO,GAAgB;gBAC3B,SAAS,EAAE,KAAK,CAAC,SAAS;gBAC1B,SAAS,EAAE,GAAG,KAAK,CAAC,SAAS,QAAQ,cAAc,EAAE;gBACrD,MAAM,EAAE,aAAa;gBACrB,IAAI,EAAE,WAAW;gBACjB,OAAO,EAAE,KAAK,CAAC,QAAQ;gBACvB,UAAU,EAAE,KAAK,CAAC,UAAU,CAAC,KAAK,GAAG,KAAK,CAAC,UAAU,CAAC,MAAM;gBAC5D,UAAU,EAAE,KAAK,CAAC,UAAU;gBAC5B,SAAS,EAAE,IAAI,IAAI,EAAE,CAAC,WAAW,EAAE;aACpC,CAAC;YAEF,wCAAwC;YACxC,MAAM,YAAY,GAAG,MAAM,CAAC,eAAe,CAAC,KAAK,CAAC,SAAS,CAAC,CAAC;YAC7D,MAAM,aAAa,GAAG,YAAY,CAAC,UAAU,IAAI,EAAE,KAAK,EAAE,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,CAAC;YACzE,MAAM,CAAC,kBAAkB,CAAC,KAAK,CAAC,SAAS,EAAE;gBACzC,UAAU,EAAE;oBACV,KAAK,EAAE,aAAa,CAAC,KAAK,GAAG,KAAK,CAAC,UAAU,CAAC,KAAK;oBACnD,MAAM,EAAE,aAAa,CAAC,MAAM,GAAG,KAAK,CAAC,UAAU,CAAC,MAAM;iBACvD;aACF,CAAC,CAAC;YAEH,MAAM,MAAM,CAAC,WAAW,CAAC,OAAO,CAAC,CAAC;QACpC,CAAC;QAED;;WAEG;QACH,UAAU,EAAE,KAAK,EAAE,KAAsB,EAAE,EAAE;YAC3C,MAAM,YAAY,GAAG,MAAM,CAAC,eAAe,CAAC,KAAK,CAAC,SAAS,CAAC,CAAC;YAE7D,MAAM,OAAO,GAAgB;gBAC3B,GAAG,YAAY;gBACf,SAAS,EAAE,KAAK,CAAC,SAAS;gBAC1B,MAAM,EAAE,aAAa;gBACrB,SAAS,EAAE,KAAK,CAAC,SAAS;gBAC1B,YAAY,EAAE,KAAK,CAAC,YAAY;gBAChC,aAAa,EAAE,KAAK,CAAC,aAAa;gBAClC,UAAU,EAAE,KAAK,CAAC,eAAe;gBACjC,YAAY,EAAE,KAAK,CAAC,YAAY;gBAChC,OAAO,EAAE,IAAI,IAAI,EAAE,CAAC,WAAW,EAAE;aAClC,CAAC;YAEF,MAAM,MAAM,CAAC,WAAW,CAAC,OAAO,CAAC,CAAC;YAClC,MAAM,CAAC,iBAAiB,CAAC,KAAK,CAAC,SAAS,CAAC,CAAC;YAE1C,OAAO,CAAC,GAAG,CACT,sCAAsC,KAAK,CAAC,YAAY,cAAc,KAAK,CAAC,aAAa,aAAa,CACvG,CAAC;QACJ,CAAC;KACF,CAAC;AACJ,CAAC;AAED,+CAA+C;AAC/C,kBAAe,YAAY,CAAC","sourcesContent":["/**\n * Claude Code Sync Plugin\n *\n * Syncs Claude Code sessions to OpenSync dashboard.\n * Uses API Key authentication (no browser OAuth required).\n *\n * Install: npm install -g claude-code-sync\n * Configure: claude-code-sync login\n */\n\nimport * as fs from \"fs\";\nimport * as path from \"path\";\nimport * as os from \"os\";\n\n// ============================================================================\n// Types\n// ============================================================================\n\nexport interface Config {\n  convexUrl: string;\n  apiKey: string;\n  autoSync?: boolean;\n  syncToolCalls?: boolean;\n  syncThinking?: boolean;\n}\n\nexport interface SessionData {\n  sessionId: string;\n  source: \"claude-code\";\n  title?: string;\n  projectPath?: string;\n  projectName?: string;\n  cwd?: string;\n  gitBranch?: string;\n  gitRepo?: string;\n  model?: string;\n  startType?: \"new\" | \"resume\" | \"continue\";\n  endReason?: \"user_stop\" | \"max_turns\" | \"error\" | \"completed\";\n  thinkingEnabled?: boolean;\n  permissionMode?: string;\n  mcpServers?: string[];\n  messageCount?: number;\n  toolCallCount?: number;\n  tokenUsage?: {\n    input: number;\n    output: number;\n  };\n  costEstimate?: number;\n  startedAt?: string;\n  endedAt?: string;\n}\n\nexport interface MessageData {\n  sessionId: string;\n  messageId: string;\n  source: \"claude-code\";\n  role: \"user\" | \"assistant\" | \"system\";\n  content?: string;\n  thinkingContent?: string;\n  toolName?: string;\n  toolArgs?: Record<string, unknown>;\n  toolResult?: string;\n  durationMs?: number;\n  tokenCount?: number;\n  timestamp?: string;\n}\n\nexport interface ToolUseData {\n  sessionId: string;\n  toolName: string;\n  toolArgs?: Record<string, unknown>;\n  result?: string;\n  success?: boolean;\n  durationMs?: number;\n  timestamp?: string;\n}\n\n// Claude Code Hook Types\nexport interface ClaudeCodeHooks {\n  SessionStart?: (data: SessionStartEvent) => void | Promise<void>;\n  UserPromptSubmit?: (data: UserPromptEvent) => void | Promise<void>;\n  PostToolUse?: (data: ToolUseEvent) => void | Promise<void>;\n  Stop?: (data: StopEvent) => void | Promise<void>;\n  SessionEnd?: (data: SessionEndEvent) => void | Promise<void>;\n}\n\nexport interface SessionStartEvent {\n  sessionId: string;\n  cwd: string;\n  model: string;\n  startType: \"new\" | \"resume\" | \"continue\";\n  thinkingEnabled?: boolean;\n  permissionMode?: string;\n  mcpServers?: string[];\n}\n\nexport interface UserPromptEvent {\n  sessionId: string;\n  prompt: string;\n  timestamp: string;\n}\n\nexport interface ToolUseEvent {\n  sessionId: string;\n  toolName: string;\n  args: Record<string, unknown>;\n  result: string;\n  success: boolean;\n  durationMs: number;\n}\n\nexport interface StopEvent {\n  sessionId: string;\n  response: string;\n  tokenUsage: {\n    input: number;\n    output: number;\n  };\n  durationMs: number;\n}\n\nexport interface SessionEndEvent {\n  sessionId: string;\n  endReason: \"user_stop\" | \"max_turns\" | \"error\" | \"completed\";\n  messageCount: number;\n  toolCallCount: number;\n  totalTokenUsage: {\n    input: number;\n    output: number;\n  };\n  costEstimate: number;\n}\n\n// ============================================================================\n// Configuration\n// ============================================================================\n\nconst CONFIG_DIR = path.join(os.homedir(), \".config\", \"claude-code-sync\");\nconst CONFIG_FILE = path.join(CONFIG_DIR, \"config.json\");\n\nexport function loadConfig(): Config | null {\n  // Check environment variables first\n  const envUrl = process.env.CLAUDE_SYNC_CONVEX_URL;\n  const envKey = process.env.CLAUDE_SYNC_API_KEY;\n\n  if (envUrl && envKey) {\n    return {\n      convexUrl: normalizeConvexUrl(envUrl),\n      apiKey: envKey,\n      autoSync: process.env.CLAUDE_SYNC_AUTO_SYNC !== \"false\",\n      syncToolCalls: process.env.CLAUDE_SYNC_TOOL_CALLS !== \"false\",\n      syncThinking: process.env.CLAUDE_SYNC_THINKING === \"true\",\n    };\n  }\n\n  // Fall back to config file\n  try {\n    if (fs.existsSync(CONFIG_FILE)) {\n      const data = fs.readFileSync(CONFIG_FILE, \"utf-8\");\n      const config = JSON.parse(data) as Config;\n      config.convexUrl = normalizeConvexUrl(config.convexUrl);\n      return config;\n    }\n  } catch (error) {\n    console.error(\"Error loading config:\", error);\n  }\n\n  return null;\n}\n\nexport function saveConfig(config: Config): void {\n  try {\n    if (!fs.existsSync(CONFIG_DIR)) {\n      fs.mkdirSync(CONFIG_DIR, { recursive: true });\n    }\n    fs.writeFileSync(CONFIG_FILE, JSON.stringify(config, null, 2));\n  } catch (error) {\n    console.error(\"Error saving config:\", error);\n    throw error;\n  }\n}\n\nexport function clearConfig(): void {\n  try {\n    if (fs.existsSync(CONFIG_FILE)) {\n      fs.unlinkSync(CONFIG_FILE);\n    }\n  } catch (error) {\n    console.error(\"Error clearing config:\", error);\n  }\n}\n\nfunction normalizeConvexUrl(url: string): string {\n  // Convert .convex.cloud to .convex.site for API calls\n  return url.replace(\".convex.cloud\", \".convex.site\");\n}\n\n// ============================================================================\n// Sync Client\n// ============================================================================\n\nexport class SyncClient {\n  private config: Config;\n  private sessionCache: Map<string, Partial<SessionData>> = new Map();\n\n  constructor(config: Config) {\n    this.config = config;\n  }\n\n  private async request(endpoint: string, data: unknown): Promise<unknown> {\n    const url = `${this.config.convexUrl}${endpoint}`;\n\n    const response = await fetch(url, {\n      method: \"POST\",\n      headers: {\n        \"Content-Type\": \"application/json\",\n        Authorization: `Bearer ${this.config.apiKey}`,\n      },\n      body: JSON.stringify(data),\n    });\n\n    if (!response.ok) {\n      const text = await response.text();\n      throw new Error(`Sync failed: ${response.status} - ${text}`);\n    }\n\n    return response.json();\n  }\n\n  async syncSession(session: SessionData): Promise<void> {\n    try {\n      await this.request(\"/sync/session\", session);\n    } catch (error) {\n      console.error(\"Failed to sync session:\", error);\n    }\n  }\n\n  async syncMessage(message: MessageData): Promise<void> {\n    try {\n      await this.request(\"/sync/message\", message);\n    } catch (error) {\n      console.error(\"Failed to sync message:\", error);\n    }\n  }\n\n  async syncBatch(\n    sessions: SessionData[],\n    messages: MessageData[]\n  ): Promise<void> {\n    try {\n      await this.request(\"/sync/batch\", { sessions, messages });\n    } catch (error) {\n      console.error(\"Failed to sync batch:\", error);\n    }\n  }\n\n  async testConnection(): Promise<boolean> {\n    try {\n      const url = `${this.config.convexUrl}/health`;\n      const response = await fetch(url);\n      return response.ok;\n    } catch {\n      return false;\n    }\n  }\n\n  // Session state management\n  getSessionState(sessionId: string): Partial<SessionData> {\n    return this.sessionCache.get(sessionId) || {};\n  }\n\n  updateSessionState(\n    sessionId: string,\n    updates: Partial<SessionData>\n  ): void {\n    const current = this.sessionCache.get(sessionId) || {};\n    this.sessionCache.set(sessionId, { ...current, ...updates });\n  }\n\n  clearSessionState(sessionId: string): void {\n    this.sessionCache.delete(sessionId);\n  }\n}\n\n// ============================================================================\n// Plugin Export\n// ============================================================================\n\n/**\n * Claude Code Plugin Entry Point\n *\n * This function is called by Claude Code to register the plugin.\n * It returns hook handlers that fire at key points in the session lifecycle.\n */\nexport function createPlugin(): ClaudeCodeHooks | null {\n  const config = loadConfig();\n\n  if (!config) {\n    console.log(\n      \"[claude-code-sync] Not configured. Run 'claude-code-sync login' to set up.\"\n    );\n    return null;\n  }\n\n  if (config.autoSync === false) {\n    console.log(\"[claude-code-sync] Auto-sync disabled in config.\");\n    return null;\n  }\n\n  const client = new SyncClient(config);\n  let messageCounter = 0;\n  let toolCallCounter = 0;\n\n  console.log(\"[claude-code-sync] Plugin loaded. Sessions will sync to OpenSync.\");\n\n  return {\n    /**\n     * Called when a new session starts\n     */\n    SessionStart: async (event: SessionStartEvent) => {\n      messageCounter = 0;\n      toolCallCounter = 0;\n\n      const session: SessionData = {\n        sessionId: event.sessionId,\n        source: \"claude-code\",\n        cwd: event.cwd,\n        model: event.model,\n        startType: event.startType,\n        thinkingEnabled: event.thinkingEnabled,\n        permissionMode: event.permissionMode,\n        mcpServers: event.mcpServers,\n        startedAt: new Date().toISOString(),\n      };\n\n      // Extract project info from cwd\n      if (event.cwd) {\n        session.projectPath = event.cwd;\n        session.projectName = path.basename(event.cwd);\n\n        // Try to get git info\n        try {\n          const gitDir = path.join(event.cwd, \".git\");\n          if (fs.existsSync(gitDir)) {\n            const headFile = path.join(gitDir, \"HEAD\");\n            if (fs.existsSync(headFile)) {\n              const head = fs.readFileSync(headFile, \"utf-8\").trim();\n              if (head.startsWith(\"ref: refs/heads/\")) {\n                session.gitBranch = head.replace(\"ref: refs/heads/\", \"\");\n              }\n            }\n          }\n        } catch {\n          // Ignore git errors\n        }\n      }\n\n      client.updateSessionState(event.sessionId, session);\n      await client.syncSession(session);\n    },\n\n    /**\n     * Called when user submits a prompt\n     */\n    UserPromptSubmit: async (event: UserPromptEvent) => {\n      messageCounter++;\n\n      const message: MessageData = {\n        sessionId: event.sessionId,\n        messageId: `${event.sessionId}-msg-${messageCounter}`,\n        source: \"claude-code\",\n        role: \"user\",\n        content: event.prompt,\n        timestamp: event.timestamp || new Date().toISOString(),\n      };\n\n      await client.syncMessage(message);\n    },\n\n    /**\n     * Called after each tool use\n     */\n    PostToolUse: async (event: ToolUseEvent) => {\n      if (!config.syncToolCalls) return;\n\n      toolCallCounter++;\n      messageCounter++;\n\n      const message: MessageData = {\n        sessionId: event.sessionId,\n        messageId: `${event.sessionId}-tool-${toolCallCounter}`,\n        source: \"claude-code\",\n        role: \"assistant\",\n        toolName: event.toolName,\n        toolArgs: event.args,\n        toolResult: event.result,\n        durationMs: event.durationMs,\n        timestamp: new Date().toISOString(),\n      };\n\n      await client.syncMessage(message);\n    },\n\n    /**\n     * Called when Claude stops responding\n     */\n    Stop: async (event: StopEvent) => {\n      messageCounter++;\n\n      const message: MessageData = {\n        sessionId: event.sessionId,\n        messageId: `${event.sessionId}-msg-${messageCounter}`,\n        source: \"claude-code\",\n        role: \"assistant\",\n        content: event.response,\n        tokenCount: event.tokenUsage.input + event.tokenUsage.output,\n        durationMs: event.durationMs,\n        timestamp: new Date().toISOString(),\n      };\n\n      // Update session state with token usage\n      const currentState = client.getSessionState(event.sessionId);\n      const currentTokens = currentState.tokenUsage || { input: 0, output: 0 };\n      client.updateSessionState(event.sessionId, {\n        tokenUsage: {\n          input: currentTokens.input + event.tokenUsage.input,\n          output: currentTokens.output + event.tokenUsage.output,\n        },\n      });\n\n      await client.syncMessage(message);\n    },\n\n    /**\n     * Called when session ends\n     */\n    SessionEnd: async (event: SessionEndEvent) => {\n      const currentState = client.getSessionState(event.sessionId);\n\n      const session: SessionData = {\n        ...currentState,\n        sessionId: event.sessionId,\n        source: \"claude-code\",\n        endReason: event.endReason,\n        messageCount: event.messageCount,\n        toolCallCount: event.toolCallCount,\n        tokenUsage: event.totalTokenUsage,\n        costEstimate: event.costEstimate,\n        endedAt: new Date().toISOString(),\n      };\n\n      await client.syncSession(session);\n      client.clearSessionState(event.sessionId);\n\n      console.log(\n        `[claude-code-sync] Session synced: ${event.messageCount} messages, ${event.toolCallCount} tool calls`\n      );\n    },\n  };\n}\n\n// Default export for Claude Code plugin system\nexport default createPlugin;\n"]}

package/package.json

@@ -0,0 +1,51 @@
+{
+  "name": "claude-code-sync",
+  "version": "0.1.0",
+  "description": "Sync your Claude Code sessions to OpenSync dashboard",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "bin": {
+    "claude-code-sync": "dist/cli.js"
+  },
+  "scripts": {
+    "build": "tsc",
+    "dev": "tsc --watch",
+    "prepublishOnly": "npm run build",
+    "test": "echo \"No tests yet\" && exit 0"
+  },
+  "keywords": [
+    "claude",
+    "claude-code",
+    "sync",
+    "opensync",
+    "ai",
+    "coding",
+    "sessions",
+    "convex"
+  ],
+  "author": "Wayne Sutton",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/waynesutton/claude-code-sync.git"
+  },
+  "bugs": {
+    "url": "https://github.com/waynesutton/claude-code-sync/issues"
+  },
+  "homepage": "https://github.com/waynesutton/claude-code-sync#readme",
+  "dependencies": {
+    "commander": "^12.1.0",
+    "node-fetch": "^3.3.2"
+  },
+  "devDependencies": {
+    "@types/node": "^20.11.0",
+    "typescript": "^5.3.3"
+  },
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "files": [
+    "dist",
+    "README.md"
+  ]
+}