opencode-sync-plugin 0.1.0

package/README.md

@@ -0,0 +1,160 @@
+# opencode-sync-plugin
+
+Sync your OpenCode sessions to the cloud. Search, share, and access your coding history from anywhere.
+
+## Installation
+
+### From npm
+
+```bash
+npm install -g opencode-sync-plugin
+```
+
+### From source
+
+```bash
+git clone https://github.com/waynesutton/opencode-sync-plugin
+cd opencode-sync-plugin
+npm install
+npm run build
+```
+
+## Setup
+
+### 1. Get your credentials
+
+You need two things from your OpenSync deployment:
+
+- **Convex URL**: Your deployment URL from the Convex dashboard (e.g., `https://your-project-123.convex.cloud`)
+- **API Key**: Generated in the OpenSync dashboard at **Settings > API Key** (starts with `osk_`)
+
+The plugin automatically converts the `.cloud` URL to `.site` for API calls.
+
+### 2. Configure the plugin
+
+```bash
+opencode-sync login
+```
+
+Follow the prompts:
+
+1. Enter your Convex URL
+2. Enter your API Key
+
+No browser authentication required.
+
+### 3. Add to OpenCode
+
+Add the plugin to your `opencode.json`:
+
+```json
+{
+  "$schema": "https://opencode.ai/config.json",
+  "plugin": ["opencode-sync-plugin"]
+}
+```
+
+Or add globally at `~/.config/opencode/opencode.json`.
+
+## How it works
+
+The plugin hooks into OpenCode events and syncs data automatically:
+
+| Event | Action |
+|-------|--------|
+| `session.created` | Creates session record in cloud |
+| `session.updated` | Updates session metadata |
+| `session.idle` | Final sync with token counts and cost |
+| `message.updated` | Syncs user and assistant messages |
+| `message.part.updated` | Syncs completed message parts |
+
+Data is stored in your Convex deployment. You can view, search, and share sessions via the web UI.
+
+## CLI Commands
+
+| Command | Description |
+|---------|-------------|
+| `opencode-sync login` | Configure with Convex URL and API Key |
+| `opencode-sync logout` | Clear stored credentials |
+| `opencode-sync status` | Show authentication status |
+| `opencode-sync config` | Show current configuration |
+
+## Configuration storage
+
+Credentials are stored at:
+
+```
+~/.config/opencode-sync/
+  config.json       # Convex URL, API Key
+```
+
+## Plugin architecture
+
+This plugin follows the [OpenCode plugin specification](https://opencode.ai/docs/plugins/):
+
+```typescript
+import type { Plugin } from "@opencode-ai/plugin";
+
+export const OpenCodeSyncPlugin: Plugin = async ({ project, client, $, directory, worktree }) => {
+  // Initialize plugin
+  await client.app.log({
+    service: "opencode-sync",
+    level: "info",
+    message: "Plugin initialized",
+  });
+
+  return {
+    // Subscribe to events
+    event: async ({ event }) => {
+      if (event.type === "session.created") {
+        // Sync session to cloud
+      }
+      if (event.type === "message.updated") {
+        // Sync message to cloud
+      }
+    },
+  };
+};
+```
+
+## Troubleshooting
+
+### "Not authenticated" errors
+
+```bash
+opencode-sync login
+```
+
+### Invalid API Key
+
+1. Go to your OpenSync dashboard
+2. Navigate to Settings
+3. Generate a new API Key
+4. Run `opencode-sync login` with the new key
+
+### Check status
+
+```bash
+opencode-sync status
+```
+
+### View logs
+
+Plugin logs are available in OpenCode's log output. Look for entries with `service: "opencode-sync"`.
+
+## Development
+
+```bash
+# Install dependencies
+npm install
+
+# Build
+npm run build
+
+# Watch mode
+npm run dev
+```
+
+## License
+
+MIT

package/dist/chunk-LXC2JAKD.js

@@ -0,0 +1,242 @@
+// src/index.ts
+import Conf from "conf";
+import { homedir } from "os";
+import { join } from "path";
+var config = new Conf({
+  projectName: "opencode-sync",
+  cwd: join(homedir(), ".config", "opencode-sync"),
+  configName: "config"
+});
+function getConfig() {
+  const url = config.get("convexUrl");
+  const key = config.get("apiKey");
+  if (!url) return null;
+  return { convexUrl: url, apiKey: key || "" };
+}
+function setConfig(cfg) {
+  config.set("convexUrl", cfg.convexUrl);
+  config.set("apiKey", cfg.apiKey);
+}
+function clearConfig() {
+  config.clear();
+}
+function getApiKey() {
+  const cfg = getConfig();
+  if (!cfg || !cfg.apiKey) return null;
+  return cfg.apiKey;
+}
+function normalizeToSiteUrl(url) {
+  if (url.includes(".convex.cloud")) {
+    return url.replace(".convex.cloud", ".convex.site");
+  }
+  return url;
+}
+function getSiteUrl() {
+  const cfg = getConfig();
+  if (!cfg || !cfg.convexUrl) return null;
+  return normalizeToSiteUrl(cfg.convexUrl);
+}
+async function syncSession(session, client) {
+  const apiKey = getApiKey();
+  const siteUrl = getSiteUrl();
+  if (!apiKey || !siteUrl) {
+    await client.app.log({
+      service: "opencode-sync",
+      level: "warn",
+      message: "Not authenticated. Run: opencode-sync login"
+    });
+    return;
+  }
+  try {
+    const response = await fetch(`${siteUrl}/sync/session`, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        Authorization: `Bearer ${apiKey}`
+      },
+      body: JSON.stringify({
+        externalId: session.id,
+        title: session.title || extractTitle(session),
+        projectPath: session.cwd,
+        projectName: session.cwd?.split("/").pop(),
+        model: session.model,
+        provider: session.provider,
+        promptTokens: session.usage?.promptTokens || 0,
+        completionTokens: session.usage?.completionTokens || 0,
+        cost: session.usage?.cost || 0
+      })
+    });
+    if (!response.ok) {
+      const errorText = await response.text();
+      await client.app.log({
+        service: "opencode-sync",
+        level: "error",
+        message: `Session sync failed: ${errorText}`
+      });
+    }
+  } catch (e) {
+    await client.app.log({
+      service: "opencode-sync",
+      level: "error",
+      message: `Session sync error: ${e}`
+    });
+  }
+}
+async function syncMessage(sessionId, message, client) {
+  const apiKey = getApiKey();
+  const siteUrl = getSiteUrl();
+  if (!apiKey || !siteUrl) return;
+  const parts = extractParts(message.content);
+  try {
+    const response = await fetch(`${siteUrl}/sync/message`, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        Authorization: `Bearer ${apiKey}`
+      },
+      body: JSON.stringify({
+        sessionExternalId: sessionId,
+        externalId: message.id,
+        role: message.role,
+        textContent: extractTextContent(message.content),
+        model: message.model,
+        promptTokens: message.usage?.promptTokens,
+        completionTokens: message.usage?.completionTokens,
+        durationMs: message.duration,
+        parts
+      })
+    });
+    if (!response.ok) {
+      const errorText = await response.text();
+      await client.app.log({
+        service: "opencode-sync",
+        level: "error",
+        message: `Message sync failed: ${errorText}`
+      });
+    }
+  } catch (e) {
+    await client.app.log({
+      service: "opencode-sync",
+      level: "error",
+      message: `Message sync error: ${e}`
+    });
+  }
+}
+function extractTitle(session) {
+  const firstMessage = session.messages?.find((m) => m.role === "user");
+  if (firstMessage) {
+    const text = extractTextContent(firstMessage.content);
+    if (text) {
+      return text.slice(0, 100) + (text.length > 100 ? "..." : "");
+    }
+  }
+  return "Untitled Session";
+}
+function extractTextContent(content) {
+  if (typeof content === "string") return content;
+  if (Array.isArray(content)) {
+    return content.filter((p) => p.type === "text").map((p) => p.text).join("\n");
+  }
+  return "";
+}
+function extractParts(content) {
+  if (typeof content === "string") {
+    return [{ type: "text", content }];
+  }
+  if (Array.isArray(content)) {
+    return content.map((part) => {
+      if (part.type === "text") {
+        return { type: "text", content: part.text };
+      }
+      if (part.type === "tool_use" || part.type === "tool-call") {
+        const toolPart = part;
+        return {
+          type: "tool-call",
+          content: { name: toolPart.name, args: toolPart.input || toolPart.args || {} }
+        };
+      }
+      if (part.type === "tool_result" || part.type === "tool-result") {
+        const resultPart = part;
+        return {
+          type: "tool-result",
+          content: { result: resultPart.content || resultPart.result }
+        };
+      }
+      return { type: part.type, content: part };
+    });
+  }
+  return [];
+}
+var syncedMessages = /* @__PURE__ */ new Set();
+var syncedSessions = /* @__PURE__ */ new Set();
+var OpenCodeSyncPlugin = async ({ project, client, $, directory, worktree }) => {
+  const cfg = getConfig();
+  if (!cfg || !cfg.apiKey) {
+    await client.app.log({
+      service: "opencode-sync",
+      level: "warn",
+      message: "Not configured. Run: opencode-sync login"
+    });
+  } else {
+    await client.app.log({
+      service: "opencode-sync",
+      level: "info",
+      message: "Plugin initialized",
+      extra: { directory, worktree }
+    });
+  }
+  return {
+    // Handle all events via generic event handler
+    event: async ({ event }) => {
+      const props = event.properties;
+      if (event.type === "session.created") {
+        const session = props;
+        if (session?.id && !syncedSessions.has(session.id)) {
+          syncedSessions.add(session.id);
+          await syncSession(session, client);
+        }
+      }
+      if (event.type === "session.updated") {
+        const session = props;
+        if (session?.id) {
+          await syncSession(session, client);
+        }
+      }
+      if (event.type === "session.idle") {
+        const session = props;
+        if (session?.id) {
+          await syncSession(session, client);
+        }
+      }
+      if (event.type === "message.updated") {
+        const messageProps = props;
+        const sessionId = messageProps?.sessionId;
+        const message = messageProps?.message;
+        if (sessionId && message?.id && !syncedMessages.has(message.id)) {
+          syncedMessages.add(message.id);
+          await syncMessage(sessionId, message, client);
+        }
+      }
+      if (event.type === "message.part.updated") {
+        const messageProps = props;
+        const sessionId = messageProps?.sessionId;
+        const message = messageProps?.message;
+        if (sessionId && message?.id) {
+          if (message.status === "completed" || message.role === "user") {
+            if (!syncedMessages.has(message.id)) {
+              syncedMessages.add(message.id);
+              await syncMessage(sessionId, message, client);
+            }
+          }
+        }
+      }
+    }
+  };
+};
+
+export {
+  getConfig,
+  setConfig,
+  clearConfig,
+  OpenCodeSyncPlugin
+};

package/dist/cli.d.ts

@@ -0,0 +1 @@
+#!/usr/bin/env node

package/dist/cli.js

@@ -0,0 +1,136 @@
+#!/usr/bin/env node
+import {
+  clearConfig,
+  getConfig,
+  setConfig
+} from "./chunk-LXC2JAKD.js";
+
+// src/cli.ts
+var args = process.argv.slice(2);
+var command = args[0];
+async function main() {
+  switch (command) {
+    case "login":
+      await login();
+      break;
+    case "logout":
+      logout();
+      break;
+    case "status":
+      status();
+      break;
+    case "config":
+      showConfig();
+      break;
+    default:
+      help();
+  }
+}
+async function login() {
+  console.log("\n  OpenSync Login\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. Should end with .convex.cloud or .convex.site");
+    process.exit(1);
+  }
+  const apiKey = await prompt("API Key (from Settings page, starts with osk_): ");
+  if (!apiKey) {
+    console.error("API Key is required");
+    process.exit(1);
+  }
+  if (!apiKey.startsWith("osk_")) {
+    console.error("Invalid API Key format. Should start with 'osk_'");
+    process.exit(1);
+  }
+  const siteUrl = convexUrl.replace(".convex.cloud", ".convex.site");
+  console.log("\nVerifying credentials...");
+  try {
+    const response = await fetch(`${siteUrl}/health`);
+    if (!response.ok) {
+      console.error("\nFailed to connect to OpenSync backend.");
+      console.error("Please verify your Convex URL is correct.");
+      process.exit(1);
+    }
+    setConfig({ convexUrl, apiKey });
+    console.log("\nLogin successful!\n");
+    console.log("  Convex URL:", convexUrl);
+    console.log("  API Key:", apiKey.slice(0, 8) + "..." + apiKey.slice(-4));
+    console.log("\n  Add the plugin to your opencode.json:");
+    console.log('  { "plugin": ["opencode-sync-plugin"] }\n');
+  } catch (e) {
+    console.error("\nFailed to connect to OpenSync backend.");
+    console.error("Please verify your Convex URL is correct.");
+    process.exit(1);
+  }
+}
+function logout() {
+  clearConfig();
+  console.log("\nLogged out successfully\n");
+}
+function status() {
+  const config = getConfig();
+  console.log("\n  OpenSync Status\n");
+  if (!config) {
+    console.log("  Status: Not configured\n");
+    console.log("  Run: opencode-sync login\n");
+    return;
+  }
+  if (!config.apiKey) {
+    console.log("  Status: Not authenticated\n");
+    console.log("  Convex URL:", config.convexUrl);
+    console.log("\n  Run: opencode-sync login\n");
+    return;
+  }
+  console.log("  Status: Configured\n");
+  console.log("  Convex URL:", config.convexUrl);
+  console.log("  API Key:", config.apiKey.slice(0, 8) + "..." + config.apiKey.slice(-4));
+  console.log();
+}
+function showConfig() {
+  const config = getConfig();
+  console.log("\n  OpenSync Config\n");
+  if (!config) {
+    console.log("  No configuration found.\n");
+    console.log("  Run: opencode-sync login\n");
+    return;
+  }
+  console.log("  Convex URL:", config.convexUrl);
+  console.log("  API Key:", config.apiKey ? config.apiKey.slice(0, 8) + "..." + config.apiKey.slice(-4) : "Not set");
+  console.log();
+}
+function help() {
+  console.log(`
+  OpenSync CLI
+
+  Usage: opencode-sync <command>
+
+  Commands:
+    login   Configure with Convex URL and API Key
+    logout  Clear stored credentials
+    status  Show current authentication status
+    config  Show current configuration
+
+  Setup:
+    1. Go to your OpenSync dashboard Settings page
+    2. Generate an API Key (starts with osk_)
+    3. Run: opencode-sync login
+    4. Enter your Convex URL and API Key
+    5. Add plugin to opencode.json: { "plugin": ["opencode-sync-plugin"] }
+`);
+}
+function prompt(question) {
+  return new Promise((resolve) => {
+    process.stdout.write(question);
+    let input = "";
+    process.stdin.setEncoding("utf8");
+    process.stdin.once("data", (data) => {
+      input = data.toString().trim();
+      resolve(input);
+    });
+  });
+}
+main().catch(console.error);

package/dist/index.d.ts

@@ -0,0 +1,42 @@
+interface PluginClient {
+    app: {
+        log: (entry: {
+            service: string;
+            level: "debug" | "info" | "warn" | "error";
+            message: string;
+            extra?: Record<string, unknown>;
+        }) => Promise<void>;
+    };
+}
+interface PluginContext {
+    project: unknown;
+    client: PluginClient;
+    $: unknown;
+    directory: string;
+    worktree: string;
+}
+interface PluginEvent {
+    type: string;
+    properties?: Record<string, unknown>;
+}
+interface PluginHooks {
+    event?: (input: {
+        event: PluginEvent;
+    }) => Promise<void>;
+}
+type Plugin = (ctx: PluginContext) => Promise<PluginHooks>;
+interface Config {
+    convexUrl: string;
+    apiKey: string;
+}
+declare function getConfig(): Config | null;
+declare function setConfig(cfg: Config): void;
+declare function clearConfig(): void;
+/**
+ * OpenCode Sync Plugin
+ * Syncs sessions and messages to cloud storage via Convex backend
+ * Authentication: API Key (osk_*) from OpenSync Settings page
+ */
+declare const OpenCodeSyncPlugin: Plugin;
+
+export { OpenCodeSyncPlugin, clearConfig, getConfig, setConfig };

package/dist/index.js

@@ -0,0 +1,12 @@
+import {
+  OpenCodeSyncPlugin,
+  clearConfig,
+  getConfig,
+  setConfig
+} from "./chunk-LXC2JAKD.js";
+export {
+  OpenCodeSyncPlugin,
+  clearConfig,
+  getConfig,
+  setConfig
+};

package/package.json

@@ -0,0 +1,54 @@
+{
+  "name": "opencode-sync-plugin",
+  "version": "0.1.0",
+  "description": "Sync your OpenCode sessions to the cloud",
+  "type": "module",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "exports": {
+    ".": {
+      "import": "./dist/index.js",
+      "types": "./dist/index.d.ts"
+    }
+  },
+  "bin": {
+    "opencode-sync": "dist/cli.js"
+  },
+  "scripts": {
+    "build": "tsup src/index.ts src/cli.ts --format esm --dts --clean",
+    "dev": "tsup src/index.ts src/cli.ts --format esm --dts --watch"
+  },
+  "files": [
+    "dist"
+  ],
+  "keywords": [
+    "opencode",
+    "opencode-plugin",
+    "ai",
+    "sync",
+    "sessions",
+    "convex"
+  ],
+  "author": "waynesutton",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/waynesutton/opencode-sync-plugin"
+  },
+  "license": "MIT",
+  "dependencies": {
+    "conf": "^12.0.0"
+  },
+  "devDependencies": {
+    "@types/node": "^20.0.0",
+    "tsup": "^8.0.0",
+    "typescript": "^5.3.0"
+  },
+  "peerDependencies": {
+    "@opencode-ai/plugin": ">=0.1.0"
+  },
+  "peerDependenciesMeta": {
+    "@opencode-ai/plugin": {
+      "optional": true
+    }
+  }
+}