opencode-sync-plugin 0.1.6 → 0.1.8

package/README.md

@@ -158,6 +158,8 @@ export const OpenCodeSyncPlugin: Plugin = async ({ project, client, $, directory
 };
 ```
 
+This plugin exports both a named and default export so OpenCode can load it from npm reliably.
+
 ## Troubleshooting
 
 ### OpenCode won't start or shows blank screen
@@ -189,6 +191,8 @@ rm -rf ~/.cache/opencode/node_modules/opencode-sync-plugin
 opencode
 ```
 
+If the issue persists, reinstall the latest version and clear the cache again.
+
 ### "Not authenticated" errors
 
 ```bash

package/dist/chunk-V6SCOAXD.js

@@ -0,0 +1,171 @@
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined") return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+
+// src/index.ts
+var configDir = null;
+var configFile = null;
+function getConfigPaths() {
+  if (!configDir) {
+    const { homedir } = __require("os");
+    const { join } = __require("path");
+    configDir = join(homedir(), ".config", "opencode-sync");
+    configFile = join(configDir, "config.json");
+  }
+  return { configDir, configFile };
+}
+function readConfigFile() {
+  try {
+    const { existsSync, readFileSync } = __require("fs");
+    const { configFile: configFile2 } = getConfigPaths();
+    if (!existsSync(configFile2)) return null;
+    const content = readFileSync(configFile2, "utf8");
+    return JSON.parse(content);
+  } catch {
+    return null;
+  }
+}
+function writeConfigFile(config) {
+  try {
+    const { existsSync, writeFileSync, mkdirSync } = __require("fs");
+    const { configDir: configDir2, configFile: configFile2 } = getConfigPaths();
+    if (!existsSync(configDir2)) {
+      mkdirSync(configDir2, { recursive: true });
+    }
+    writeFileSync(configFile2, JSON.stringify(config, null, 2), "utf8");
+  } catch {
+  }
+}
+function getConfig() {
+  const config = readConfigFile();
+  if (!config || !config.convexUrl) return null;
+  return config;
+}
+function setConfig(cfg) {
+  writeConfigFile(cfg);
+}
+function clearConfig() {
+  try {
+    const { existsSync, writeFileSync } = __require("fs");
+    const { configFile: configFile2 } = getConfigPaths();
+    if (existsSync(configFile2)) {
+      writeFileSync(configFile2, "{}", "utf8");
+    }
+  } catch {
+  }
+}
+var syncedMessages = /* @__PURE__ */ new Set();
+var syncedSessions = /* @__PURE__ */ new Set();
+function extractTextContent(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");
+  }
+  return "";
+}
+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 syncSessionBackground(session) {
+  const config = getConfig();
+  if (!config?.apiKey || !config?.convexUrl) return;
+  const siteUrl = config.convexUrl.replace(".convex.cloud", ".convex.site");
+  fetch(`${siteUrl}/sync/session`, {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json",
+      Authorization: `Bearer ${config.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
+    })
+  }).catch(() => {
+  });
+}
+function syncMessageBackground(sessionId, message) {
+  const config = getConfig();
+  if (!config?.apiKey || !config?.convexUrl) return;
+  const siteUrl = config.convexUrl.replace(".convex.cloud", ".convex.site");
+  fetch(`${siteUrl}/sync/message`, {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json",
+      Authorization: `Bearer ${config.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
+    })
+  }).catch(() => {
+  });
+}
+var OpenCodeSyncPlugin = async (ctx) => {
+  ctx.client.app.log({
+    service: "opencode-sync",
+    level: "info",
+    message: "Plugin loaded"
+  }).catch(() => {
+  });
+  return {
+    event: async (input) => {
+      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);
+            syncSessionBackground(session);
+          }
+        }
+        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;
+            }
+            syncedMessages.add(message.id);
+            syncMessageBackground(sessionId, message);
+          }
+        }
+      } catch {
+      }
+    }
+  };
+};
+var index_default = OpenCodeSyncPlugin;
+
+export {
+  getConfig,
+  setConfig,
+  clearConfig,
+  OpenCodeSyncPlugin,
+  index_default
+};

package/dist/cli.js

@@ -3,7 +3,7 @@ import {
   clearConfig,
   getConfig,
   setConfig
-} from "./chunk-46RJJUZ6.js";
+} from "./chunk-V6SCOAXD.js";
 
 // src/cli.ts
 import { readFileSync, existsSync } from "fs";

package/dist/index.d.ts

@@ -1,30 +1,3 @@
-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;
@@ -35,8 +8,26 @@ 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;
+declare const OpenCodeSyncPlugin: (ctx: {
+    client: {
+        app: {
+            log: (entry: {
+                service: string;
+                level: string;
+                message: string;
+            }) => Promise<void>;
+        };
+    };
+    directory: string;
+    worktree: string;
+}) => Promise<{
+    event: (input: {
+        event: {
+            type: string;
+            properties?: Record<string, unknown>;
+        };
+    }) => Promise<void>;
+}>;
 
-export { OpenCodeSyncPlugin, clearConfig, getConfig, setConfig };
+export { OpenCodeSyncPlugin, clearConfig, OpenCodeSyncPlugin as default, getConfig, setConfig };

package/dist/index.js

@@ -2,11 +2,13 @@ import {
   OpenCodeSyncPlugin,
   clearConfig,
   getConfig,
+  index_default,
   setConfig
-} from "./chunk-46RJJUZ6.js";
+} from "./chunk-V6SCOAXD.js";
 export {
   OpenCodeSyncPlugin,
   clearConfig,
+  index_default as default,
   getConfig,
   setConfig
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "opencode-sync-plugin",
-  "version": "0.1.6",
+  "version": "0.1.8",
   "description": "Sync your OpenCode sessions to the cloud",
   "type": "module",
   "main": "dist/index.js",

package/dist/chunk-46RJJUZ6.js

@@ -1,260 +0,0 @@
-// src/index.ts
-import { homedir } from "os";
-import { join } from "path";
-import { readFileSync, writeFileSync, mkdirSync, existsSync } from "fs";
-var CONFIG_DIR = join(homedir(), ".config", "opencode-sync");
-var CONFIG_FILE = join(CONFIG_DIR, "config.json");
-function readConfigFile() {
-  try {
-    if (!existsSync(CONFIG_FILE)) return null;
-    const content = readFileSync(CONFIG_FILE, "utf8");
-    return JSON.parse(content);
-  } catch {
-    return null;
-  }
-}
-function writeConfigFile(config) {
-  try {
-    if (!existsSync(CONFIG_DIR)) {
-      mkdirSync(CONFIG_DIR, { recursive: true });
-    }
-    writeFileSync(CONFIG_FILE, JSON.stringify(config, null, 2), "utf8");
-  } catch {
-  }
-}
-function getConfig() {
-  const config = readConfigFile();
-  if (!config || !config.convexUrl) return null;
-  return config;
-}
-function setConfig(cfg) {
-  writeConfigFile(cfg);
-}
-function clearConfig() {
-  try {
-    if (existsSync(CONFIG_FILE)) {
-      writeFileSync(CONFIG_FILE, "{}", "utf8");
-    }
-  } catch {
-  }
-}
-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
-};