opencode-sync-plugin 0.2.6 → 0.2.8

package/README.md

@@ -27,7 +27,7 @@ npm run build
 
 ### 1. Get your credentials
 
-You need two things from your OpenSync deployment:
+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_`)
@@ -117,7 +117,9 @@ Data is stored in your Convex deployment. You can view, search, and share sessio
 | `opencode-sync login` | Configure with Convex URL and API Key |
 | `opencode-sync verify` | Verify credentials and OpenCode config |
 | `opencode-sync sync` | Test connectivity and create a test session |
-| `opencode-sync sync --all` | Sync all local OpenCode sessions to the cloud |
+| `opencode-sync sync --new` | Sync only new sessions (uses local tracking) |
+| `opencode-sync sync --all` | Sync all sessions (queries backend, skips existing) |
+| `opencode-sync sync --force` | Clear tracking and resync all sessions |
 | `opencode-sync logout` | Clear stored credentials |
 | `opencode-sync status` | Show authentication status |
 | `opencode-sync config` | Show current configuration |

package/dist/chunk-6K7TIEXR.js

@@ -0,0 +1,81 @@
+// src/config.ts
+import { existsSync, readFileSync, writeFileSync, mkdirSync } from "fs";
+import { homedir } from "os";
+import { join } from "path";
+var CONFIG_DIR = join(homedir(), ".opensync");
+var CONFIG_FILE = join(CONFIG_DIR, "credentials.json");
+var SYNCED_SESSIONS_FILE = join(CONFIG_DIR, "synced-sessions.json");
+function getConfig() {
+  try {
+    if (!existsSync(CONFIG_FILE)) return null;
+    const content = readFileSync(CONFIG_FILE, "utf8");
+    const config = JSON.parse(content);
+    if (!config || !config.convexUrl) return null;
+    return config;
+  } catch (e) {
+    console.error("Error reading config:", e);
+    return null;
+  }
+}
+function setConfig(cfg) {
+  try {
+    if (!existsSync(CONFIG_DIR)) {
+      mkdirSync(CONFIG_DIR, { recursive: true });
+    }
+    writeFileSync(CONFIG_FILE, JSON.stringify(cfg, null, 2), "utf8");
+  } catch (e) {
+    console.error("Error saving config:", e);
+  }
+}
+function clearConfig() {
+  try {
+    if (existsSync(CONFIG_FILE)) {
+      writeFileSync(CONFIG_FILE, "{}", "utf8");
+    }
+  } catch (e) {
+    console.error("Error clearing config:", e);
+  }
+}
+function getSyncedSessions() {
+  try {
+    if (!existsSync(SYNCED_SESSIONS_FILE)) return /* @__PURE__ */ new Set();
+    const content = readFileSync(SYNCED_SESSIONS_FILE, "utf8");
+    const data = JSON.parse(content);
+    return new Set(Array.isArray(data.sessionIds) ? data.sessionIds : []);
+  } catch {
+    return /* @__PURE__ */ new Set();
+  }
+}
+function addSyncedSessions(sessionIds) {
+  try {
+    if (!existsSync(CONFIG_DIR)) {
+      mkdirSync(CONFIG_DIR, { recursive: true });
+    }
+    const existing = getSyncedSessions();
+    for (const id of sessionIds) {
+      existing.add(id);
+    }
+    const data = { sessionIds: Array.from(existing), lastUpdated: Date.now() };
+    writeFileSync(SYNCED_SESSIONS_FILE, JSON.stringify(data, null, 2), "utf8");
+  } catch (e) {
+    console.error("Error saving synced sessions:", e);
+  }
+}
+function clearSyncedSessions() {
+  try {
+    if (existsSync(SYNCED_SESSIONS_FILE)) {
+      writeFileSync(SYNCED_SESSIONS_FILE, JSON.stringify({ sessionIds: [], lastUpdated: Date.now() }), "utf8");
+    }
+  } catch (e) {
+    console.error("Error clearing synced sessions:", e);
+  }
+}
+
+export {
+  getConfig,
+  setConfig,
+  clearConfig,
+  getSyncedSessions,
+  addSyncedSessions,
+  clearSyncedSessions
+};

package/dist/cli.js

@@ -1,9 +1,12 @@
 #!/usr/bin/env node
 import {
+  addSyncedSessions,
   clearConfig,
+  clearSyncedSessions,
   getConfig,
+  getSyncedSessions,
   setConfig
-} from "./chunk-JPPDGYOB.js";
+} from "./chunk-6K7TIEXR.js";
 
 // src/cli.ts
 import { readFileSync, existsSync, readdirSync } from "fs";
@@ -204,6 +207,8 @@ function showConfig() {
 }
 async function sync() {
   const syncAll = args.includes("--all");
+  const syncNew = args.includes("--new");
+  const syncForce = args.includes("--force");
   const config = getConfig();
   if (!config || !config.apiKey || !config.convexUrl) {
     console.log("\n  Status: Not configured\n");
@@ -211,8 +216,13 @@ async function sync() {
     return;
   }
   const siteUrl = config.convexUrl.replace(".convex.cloud", ".convex.site");
-  if (syncAll) {
-    await syncAllSessions(siteUrl, config.apiKey);
+  if (syncForce) {
+    clearSyncedSessions();
+    await syncAllSessions(siteUrl, config.apiKey, "force");
+  } else if (syncAll) {
+    await syncAllSessions(siteUrl, config.apiKey, "all");
+  } else if (syncNew) {
+    await syncAllSessions(siteUrl, config.apiKey, "new");
   } else {
     await syncConnectivityTest(siteUrl, config.apiKey);
   }
@@ -277,8 +287,27 @@ async function syncConnectivityTest(siteUrl, apiKey) {
     console.log();
   }
 }
-async function syncAllSessions(siteUrl, apiKey) {
-  console.log("\n  OpenSync: Syncing All Local Sessions\n");
+async function fetchBackendSessionIds(siteUrl, apiKey) {
+  try {
+    const res = await fetch(`${siteUrl}/sync/sessions/list`, {
+      method: "GET",
+      headers: {
+        Authorization: `Bearer ${apiKey}`
+      }
+    });
+    if (res.ok) {
+      const data = await res.json();
+      return new Set(Array.isArray(data.sessionIds) ? data.sessionIds : []);
+    }
+  } catch {
+  }
+  return /* @__PURE__ */ new Set();
+}
+async function syncAllSessions(siteUrl, apiKey, mode) {
+  const modeLabel = mode === "force" ? "Force Syncing" : mode === "new" ? "Syncing New" : "Syncing All";
+  console.log(`
+  OpenSync: ${modeLabel} Local Sessions
+`);
   const opencodePath = join(homedir(), ".local", "share", "opencode", "storage");
   const sessionPath = join(opencodePath, "session");
   const messagePath = join(opencodePath, "message");
@@ -309,15 +338,39 @@ async function syncAllSessions(siteUrl, apiKey) {
     console.log("  Error reading sessions:", e instanceof Error ? e.message : String(e));
     return;
   }
-  console.log(`  Found ${sessions.length} sessions
-`);
+  console.log(`  Found ${sessions.length} local sessions`);
   if (sessions.length === 0) {
     return;
   }
-  let syncedSessions = 0;
+  let alreadySynced = /* @__PURE__ */ new Set();
+  if (mode === "all") {
+    console.log("  Checking backend for existing sessions...");
+    alreadySynced = await fetchBackendSessionIds(siteUrl, apiKey);
+    if (alreadySynced.size > 0) {
+      console.log(`  Found ${alreadySynced.size} already synced on backend`);
+    }
+  } else if (mode === "new") {
+    alreadySynced = getSyncedSessions();
+    if (alreadySynced.size > 0) {
+      console.log(`  Found ${alreadySynced.size} in local tracking file`);
+    }
+  }
+  const sessionsToSync = sessions.filter((s) => !alreadySynced.has(s.data.id));
+  const skippedCount = sessions.length - sessionsToSync.length;
+  if (skippedCount > 0) {
+    console.log(`  Skipping ${skippedCount} already synced sessions`);
+  }
+  console.log(`  Will sync ${sessionsToSync.length} sessions
+`);
+  if (sessionsToSync.length === 0) {
+    console.log("  All sessions already synced. Use --force to resync.\n");
+    return;
+  }
+  let syncedSessionCount = 0;
   let syncedMessages = 0;
   let failedSessions = 0;
-  for (const session of sessions) {
+  const newlySyncedIds = [];
+  for (const session of sessionsToSync) {
     const { data } = session;
     process.stdout.write(`  Syncing: ${data.title || data.slug || data.id}... `);
     let totalPromptTokens = 0;
@@ -380,7 +433,8 @@ async function syncAllSessions(siteUrl, apiKey) {
         failedSessions++;
         continue;
       }
-      syncedSessions++;
+      syncedSessionCount++;
+      newlySyncedIds.push(data.id);
       let msgCount = 0;
       for (const msg of messages) {
         try {
@@ -415,10 +469,16 @@ async function syncAllSessions(siteUrl, apiKey) {
       failedSessions++;
     }
   }
+  if (newlySyncedIds.length > 0) {
+    addSyncedSessions(newlySyncedIds);
+  }
   console.log();
   console.log(`  Summary:`);
-  console.log(`    Sessions synced: ${syncedSessions}`);
+  console.log(`    Sessions synced: ${syncedSessionCount}`);
   console.log(`    Messages synced: ${syncedMessages}`);
+  if (skippedCount > 0) {
+    console.log(`    Skipped: ${skippedCount}`);
+  }
   if (failedSessions > 0) {
     console.log(`    Failed: ${failedSessions}`);
   }
@@ -433,14 +493,16 @@ function help() {
   Usage: opencode-sync <command> [options]
 
   Commands:
-    login        Configure with Convex URL and API Key
-    verify       Verify credentials and OpenCode config
-    sync         Test connectivity and create a test session
-    sync --all   Sync all local OpenCode sessions to the cloud
-    logout       Clear stored credentials
-    status       Show current authentication status
-    config       Show current configuration
-    version      Show version number
+    login         Configure with Convex URL and API Key
+    verify        Verify credentials and OpenCode config
+    sync          Test connectivity and create a test session
+    sync --new    Sync only sessions not in local tracking file
+    sync --all    Sync all sessions (checks backend, skips existing)
+    sync --force  Clear tracking and resync all sessions
+    logout        Clear stored credentials
+    status        Show current authentication status
+    config        Show current configuration
+    version       Show version number
     help         Show this help message
 
   Setup:
@@ -451,7 +513,12 @@ function help() {
     5. Add plugin to opencode.json (see instructions after login)
     6. Run: opencode-sync verify
     7. Run: opencode-sync sync (to test connectivity)
-    8. Run: opencode-sync sync --all (to sync existing sessions)
+    8. Run: opencode-sync sync --new (to sync new sessions only)
+
+  Sync Modes:
+    --new    Fast: uses local tracking, skips previously synced
+    --all    Accurate: queries backend, skips existing on server
+    --force  Full: clears tracking and resyncs everything
 `);
 }
 function prompt(question) {

package/dist/config.d.ts

@@ -5,5 +5,8 @@ interface Config {
 declare function getConfig(): Config | null;
 declare function setConfig(cfg: Config): void;
 declare function clearConfig(): void;
+declare function getSyncedSessions(): Set<string>;
+declare function addSyncedSessions(sessionIds: string[]): void;
+declare function clearSyncedSessions(): void;
 
-export { clearConfig, getConfig, setConfig };
+export { addSyncedSessions, clearConfig, clearSyncedSessions, getConfig, getSyncedSessions, setConfig };

package/dist/config.js

@@ -1,10 +1,16 @@
 import {
+  addSyncedSessions,
   clearConfig,
+  clearSyncedSessions,
   getConfig,
+  getSyncedSessions,
   setConfig
-} from "./chunk-JPPDGYOB.js";
+} from "./chunk-6K7TIEXR.js";
 export {
+  addSyncedSessions,
   clearConfig,
+  clearSyncedSessions,
   getConfig,
+  getSyncedSessions,
   setConfig
 };

package/dist/index.d.ts

@@ -1,10 +1,5 @@
-declare const OpenCodeSyncPlugin: (_ctx: Record<string, unknown>) => Promise<{
-    event: (input: {
-        event: {
-            type: string;
-            properties?: Record<string, unknown>;
-        };
-    }) => Promise<void>;
-}>;
+import { Plugin } from '@opencode-ai/plugin';
 
-export { OpenCodeSyncPlugin as default };
+declare const OpenCodeSyncPlugin: Plugin;
+
+export { OpenCodeSyncPlugin, OpenCodeSyncPlugin as default };

package/dist/index.js

@@ -1,104 +1,210 @@
 import {
   getConfig
-} from "./chunk-JPPDGYOB.js";
+} from "./chunk-6K7TIEXR.js";
 
 // src/index.ts
-var syncedMessages = /* @__PURE__ */ new Set();
 var syncedSessions = /* @__PURE__ */ new Set();
-function extractText(content) {
-  if (typeof content === "string") return content;
-  if (Array.isArray(content)) {
-    return content.filter((p) => p.type === "text" && p.text).map((p) => p.text).join("\n");
+var syncedMessages = /* @__PURE__ */ new Set();
+var messagePartsText = /* @__PURE__ */ new Map();
+var messageMetadata = /* @__PURE__ */ new Map();
+var syncTimeouts = /* @__PURE__ */ new Map();
+var DEBOUNCE_MS = 800;
+function inferRole(textContent) {
+  const assistantPatterns = [
+    /^(I'll|Let me|Here's|I can|I've|I'm going to|I will|Sure|Certainly|Of course)/i,
+    /```[\s\S]+```/,
+    // Code blocks
+    /^(Yes|No),?\s+(I|you|we|this|that)/i,
+    // Answering patterns
+    /\*\*[^*]+\*\*/,
+    // Bold markdown (explanations)
+    /^\d+\.\s+\*\*/
+    // Numbered lists with bold
+  ];
+  const userPatterns = [
+    /\?$/,
+    // Questions
+    /^(create|fix|add|update|show|make|build|implement|write|delete|remove|change|modify|help|can you|please|I want|I need)/i,
+    /^@/
+    // File references
+  ];
+  for (const pattern of assistantPatterns) {
+    if (pattern.test(textContent)) {
+      return "assistant";
+    }
   }
-  return "";
-}
-function getTitle(session) {
-  const first = session.messages?.find((m) => m.role === "user");
-  if (first) {
-    const text = extractText(first.content);
-    if (text) return text.slice(0, 100) + (text.length > 100 ? "..." : "");
+  for (const pattern of userPatterns) {
+    if (pattern.test(textContent)) {
+      return "user";
+    }
   }
-  return "Untitled Session";
+  return textContent.length > 500 ? "assistant" : "user";
 }
 function doSyncSession(session) {
   try {
     const config = getConfig();
-    if (!config?.apiKey || !config?.convexUrl) return;
+    if (!config?.apiKey || !config?.convexUrl) {
+      console.error("[opencode-sync] Missing config - cannot sync session");
+      return;
+    }
     const url = config.convexUrl.replace(".convex.cloud", ".convex.site");
+    console.log("[opencode-sync] Syncing session:", session.id);
+    const projectPath = session.path?.cwd || session.cwd || session.directory;
+    const modelId = session.modelID || session.model?.modelID || session.model;
+    const providerId = session.providerID || session.model?.providerID || session.provider;
+    const promptTokens = session.tokens?.input || session.usage?.promptTokens || 0;
+    const completionTokens = session.tokens?.output || session.usage?.completionTokens || 0;
+    const cost = session.cost || session.usage?.cost || 0;
     fetch(`${url}/sync/session`, {
       method: "POST",
-      headers: { "Content-Type": "application/json", Authorization: `Bearer ${config.apiKey}` },
+      headers: {
+        "Content-Type": "application/json",
+        Authorization: `Bearer ${config.apiKey}`
+      },
       body: JSON.stringify({
         externalId: session.id,
-        title: session.title || getTitle(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
+        title: session.title || "Untitled Session",
+        projectPath,
+        projectName: projectPath?.split("/").pop(),
+        model: modelId,
+        provider: providerId,
+        promptTokens,
+        completionTokens,
+        cost
       })
-    }).catch(() => {
-    });
-  } catch {
+    }).then((r) => r.json()).then((data) => console.log("[opencode-sync] Session sync response:", data)).catch((err) => console.error("[opencode-sync] Session sync error:", err));
+  } catch (err) {
+    console.error("[opencode-sync] doSyncSession error:", err);
   }
 }
-function doSyncMessage(sessionId, message) {
+function doSyncMessage(sessionId, messageId, role, textContent, metadata) {
   try {
     const config = getConfig();
-    if (!config?.apiKey || !config?.convexUrl) return;
+    if (!config?.apiKey || !config?.convexUrl) {
+      console.error("[opencode-sync] Missing config - cannot sync message");
+      return;
+    }
+    if (!textContent || textContent.trim().length === 0) {
+      console.log("[opencode-sync] Skipping empty message:", messageId);
+      return;
+    }
+    const finalRole = role === "unknown" || !role ? inferRole(textContent) : role;
     const url = config.convexUrl.replace(".convex.cloud", ".convex.site");
+    console.log(
+      "[opencode-sync] Syncing message:",
+      messageId,
+      "role:",
+      finalRole,
+      "text length:",
+      textContent.length
+    );
+    let durationMs;
+    if (metadata?.time?.completed && metadata?.time?.created) {
+      durationMs = metadata.time.completed - metadata.time.created;
+    }
     fetch(`${url}/sync/message`, {
       method: "POST",
-      headers: { "Content-Type": "application/json", Authorization: `Bearer ${config.apiKey}` },
+      headers: {
+        "Content-Type": "application/json",
+        Authorization: `Bearer ${config.apiKey}`
+      },
       body: JSON.stringify({
         sessionExternalId: sessionId,
-        externalId: message.id,
-        role: message.role,
-        textContent: extractText(message.content),
-        model: message.model,
-        promptTokens: message.usage?.promptTokens,
-        completionTokens: message.usage?.completionTokens,
-        durationMs: message.duration
+        externalId: messageId,
+        role: finalRole,
+        textContent,
+        model: metadata?.modelID,
+        promptTokens: metadata?.tokens?.input,
+        completionTokens: metadata?.tokens?.output,
+        durationMs
       })
-    }).catch(() => {
-    });
-  } catch {
+    }).then((r) => r.json()).then((data) => console.log("[opencode-sync] Message sync response:", data)).catch((err) => console.error("[opencode-sync] Message sync error:", err));
+  } catch (err) {
+    console.error("[opencode-sync] doSyncMessage error:", err);
   }
 }
-var OpenCodeSyncPlugin = async (_ctx) => {
+function trySyncMessage(messageId) {
+  if (syncedMessages.has(messageId)) return;
+  const metadata = messageMetadata.get(messageId);
+  const textParts = messagePartsText.get(messageId);
+  if (!metadata || !textParts || textParts.length === 0) return;
+  const textContent = textParts.join("");
+  if (!textContent.trim()) return;
+  syncedMessages.add(messageId);
+  doSyncMessage(metadata.sessionId, messageId, metadata.role, textContent, metadata.info);
+  messagePartsText.delete(messageId);
+  messageMetadata.delete(messageId);
+}
+function scheduleSyncMessage(messageId) {
+  const existing = syncTimeouts.get(messageId);
+  if (existing) clearTimeout(existing);
+  const timeout = setTimeout(() => {
+    syncTimeouts.delete(messageId);
+    trySyncMessage(messageId);
+  }, DEBOUNCE_MS);
+  syncTimeouts.set(messageId, timeout);
+}
+var OpenCodeSyncPlugin = async (input) => {
+  console.log("[opencode-sync] Plugin initialized for project:", input.project?.id);
   return {
-    event: async (input) => {
+    event: async ({ event }) => {
       try {
-        const { event } = input;
         const props = event.properties;
         if (event.type === "session.created" || event.type === "session.updated" || event.type === "session.idle") {
-          const session = props;
-          if (session?.id) {
-            if (event.type === "session.created" && syncedSessions.has(session.id)) return;
-            if (event.type === "session.created") syncedSessions.add(session.id);
-            doSyncSession(session);
+          const sessionId = props?.id;
+          if (sessionId) {
+            if (event.type === "session.created") {
+              if (syncedSessions.has(sessionId)) return;
+              syncedSessions.add(sessionId);
+            }
+            doSyncSession(props);
+          }
+        }
+        if (event.type === "message.updated") {
+          const info = props?.info;
+          if (info?.id && info?.sessionID && info?.role) {
+            console.log("[opencode-sync] Message metadata received:", info.id, "role:", info.role);
+            messageMetadata.set(info.id, {
+              role: info.role,
+              sessionId: info.sessionID,
+              info
+            });
+            if (messagePartsText.has(info.id)) {
+              scheduleSyncMessage(info.id);
+            }
           }
         }
-        if (event.type === "message.updated" || event.type === "message.part.updated") {
-          const messageProps = props;
-          const sessionId = messageProps?.sessionId;
-          const message = messageProps?.message;
-          if (sessionId && message?.id && !syncedMessages.has(message.id)) {
-            if (event.type === "message.part.updated" && message.status !== "completed" && message.role !== "user") {
-              return;
+        if (event.type === "message.part.updated") {
+          const part = props?.part;
+          if (part?.type === "text" && part?.messageID && part?.sessionID) {
+            const messageId = part.messageID;
+            const text = part.text || "";
+            console.log(
+              "[opencode-sync] Text part received for message:",
+              messageId,
+              "length:",
+              text.length
+            );
+            messagePartsText.set(messageId, [text]);
+            if (!messageMetadata.has(messageId)) {
+              messageMetadata.set(messageId, {
+                role: "unknown",
+                // Will be inferred or updated from message.updated
+                sessionId: part.sessionID,
+                info: {}
+              });
             }
-            syncedMessages.add(message.id);
-            doSyncMessage(sessionId, message);
+            scheduleSyncMessage(messageId);
           }
         }
-      } catch {
+      } catch (err) {
+        console.error("[opencode-sync] Event handler error:", err);
       }
     }
   };
 };
 var index_default = OpenCodeSyncPlugin;
 export {
+  OpenCodeSyncPlugin,
   index_default as default
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "opencode-sync-plugin",
-  "version": "0.2.6",
+  "version": "0.2.8",
   "description": "Sync your OpenCode sessions to the cloud",
   "type": "module",
   "main": "dist/index.js",
@@ -36,12 +36,13 @@
   },
   "license": "MIT",
   "devDependencies": {
+    "@opencode-ai/plugin": "^1.1.25",
     "@types/node": "^20.0.0",
     "tsup": "^8.0.0",
     "typescript": "^5.3.0"
   },
   "peerDependencies": {
-    "@opencode-ai/plugin": ">=0.1.0"
+    "@opencode-ai/plugin": ">=1.0.0"
   },
   "peerDependenciesMeta": {
     "@opencode-ai/plugin": {

package/dist/chunk-JPPDGYOB.js

@@ -1,43 +0,0 @@
-// src/config.ts
-import { existsSync, readFileSync, writeFileSync, mkdirSync } from "fs";
-import { homedir } from "os";
-import { join } from "path";
-var CONFIG_DIR = join(homedir(), ".opensync");
-var CONFIG_FILE = join(CONFIG_DIR, "credentials.json");
-function getConfig() {
-  try {
-    if (!existsSync(CONFIG_FILE)) return null;
-    const content = readFileSync(CONFIG_FILE, "utf8");
-    const config = JSON.parse(content);
-    if (!config || !config.convexUrl) return null;
-    return config;
-  } catch (e) {
-    console.error("Error reading config:", e);
-    return null;
-  }
-}
-function setConfig(cfg) {
-  try {
-    if (!existsSync(CONFIG_DIR)) {
-      mkdirSync(CONFIG_DIR, { recursive: true });
-    }
-    writeFileSync(CONFIG_FILE, JSON.stringify(cfg, null, 2), "utf8");
-  } catch (e) {
-    console.error("Error saving config:", e);
-  }
-}
-function clearConfig() {
-  try {
-    if (existsSync(CONFIG_FILE)) {
-      writeFileSync(CONFIG_FILE, "{}", "utf8");
-    }
-  } catch (e) {
-    console.error("Error clearing config:", e);
-  }
-}
-
-export {
-  getConfig,
-  setConfig,
-  clearConfig
-};