opencode-synced 0.1.0 → 0.1.1

package/README.md

@@ -37,13 +37,25 @@ opencode
 
 ## Configure
 
-Run `/sync-init` to get started. This will:
+### First machine (create new sync repo)
 
-1. Detect your GitHub username from the CLI
-2. Create a private repo (`my-opencode-config` by default) if it doesn't exist
-3. Clone the repo and set up sync
+Run `/sync-init` to create a new sync repo:
 
-That's it! Your config will now sync automatically on startup.
+1. Detects your GitHub username
+2. Creates a private repo (`my-opencode-config` by default)
+3. Clones the repo and pushes your current config
+
+### Additional machines (link to existing repo)
+
+Run `/sync-link` to connect to your existing sync repo:
+
+1. Searches your GitHub for common sync repo names (prioritizes `my-opencode-config`)
+2. Clones and applies the synced config
+3. **Overwrites local config** with synced content (preserves your local overrides file)
+
+If auto-detection fails, specify the repo name: `/sync-link my-opencode-config`
+
+After linking, restart OpenCode to apply the synced settings.
 
 ### Custom repo name or org
 
@@ -136,12 +148,15 @@ Overrides are merged into the runtime config and re-applied to `opencode.json(c)
 
 ## Usage
 
-- `/sync-init` to set up sync (creates repo if needed)
-- `/sync-status` for repo status and last sync
-- `/sync-pull` to fetch and apply remote config
-- `/sync-push` to commit and push local changes
-- `/sync-enable-secrets` to opt in to secrets sync
-- `/sync-resolve` to automatically resolve uncommitted changes using AI
+| Command | Description |
+|---------|-------------|
+| `/sync-init` | Create a new sync repo (first machine) |
+| `/sync-link` | Link to existing sync repo (additional machines) |
+| `/sync-status` | Show repo status and last sync times |
+| `/sync-pull` | Fetch and apply remote config |
+| `/sync-push` | Commit and push local changes |
+| `/sync-enable-secrets` | Enable secrets sync (private repos only) |
+| `/sync-resolve` | Auto-resolve uncommitted changes using AI |
 
 <details>
 <summary>Manual sync (without slash commands)</summary>
@@ -177,8 +192,62 @@ git pull --rebase
 
 Then re-run `/sync-pull` or `/sync-push`.
 
+## Removal
+
+<details>
+<summary>How to completely remove and delete opencode-synced</summary>
+
+Run this one-liner to remove the plugin from your config, delete local sync files, and delete the GitHub repository:
+
+```bash
+bun -e '
+  const fs = require("node:fs"), path = require("node:path"), os = require("node:os"), { spawnSync } = require("node:child_process");
+  const isWin = os.platform() === "win32", home = os.homedir();
+  const configDir = isWin ? path.join(process.env.APPDATA, "opencode") : path.join(home, ".config", "opencode");
+  const dataDir = isWin ? path.join(process.env.LOCALAPPDATA, "opencode") : path.join(home, ".local", "share", "opencode");
+  ["opencode.json", "opencode.jsonc"].forEach(f => {
+    const p = path.join(configDir, f);
+    if (fs.existsSync(p)) {
+      const c = fs.readFileSync(p, "utf8"), u = c.replace(/"opencode-synced"\s*,?\s*/g, "").replace(/,\s*\]/g, "]");
+      if (c !== u) fs.writeFileSync(p, u);
+    }
+  });
+  const scp = path.join(configDir, "opencode-synced.jsonc");
+  if (fs.existsSync(scp)) {
+    try {
+      const c = JSON.parse(fs.readFileSync(scp, "utf8").replace(/\/\/.*/g, ""));
+      if (c.repo?.owner && c.repo?.name) {
+        const res = spawnSync("gh", ["repo", "delete", `${c.repo.owner}/${c.repo.name}`, "--yes"], { stdio: "inherit" });
+        if (res.status !== 0) console.log("\nNote: Repository delete failed. If it is a permission error, run: gh auth refresh -s delete_repo\n");
+      }
+    } catch (e) {}
+  }
+  [scp, path.join(configDir, "opencode-synced.overrides.jsonc"), path.join(dataDir, "sync-state.json"), path.join(dataDir, "opencode-synced")].forEach(p => {
+    if (fs.existsSync(p)) fs.rmSync(p, { recursive: true, force: true });
+  });
+  console.log("opencode-synced removed.");
+'
+```
+
+### Manual steps
+1. Remove `"opencode-synced"` from the `plugin` array in `~/.config/opencode/opencode.json` (or `.jsonc`).
+2. Delete the local configuration and state:
+   ```bash
+   rm ~/.config/opencode/opencode-synced.jsonc
+   rm ~/.local/share/opencode/sync-state.json
+   rm -rf ~/.local/share/opencode/opencode-synced
+   ```
+3. (Optional) Delete the backup repository on GitHub via the web UI or `gh repo delete`.
+
+</details>
+
 ## Development
 
 - `bun run build`
 - `bun run test`
 - `bun run lint`
+
+
+## Prefer a CLI version?
+
+I stumbled upon [opencodesync](https://www.npmjs.com/package/opencodesync) while publishing this plugin.

package/dist/index.js

@@ -10,6 +10,9 @@ var __export = (target, all) => {
     });
 };
 
+// src/index.ts
+import path5 from "path";
+
 // node_modules/zod/v4/classic/external.js
 var exports_external = {};
 __export(exports_external, {
@@ -12330,9 +12333,6 @@ function tool(input) {
   return input;
 }
 tool.schema = exports_external;
-// src/index.ts
-import path5 from "path";
-
 // src/sync/config.ts
 import { promises as fs } from "fs";
 import path from "path";
@@ -12722,120 +12722,6 @@ function buildSyncPlan(config2, locations, repoRoot, platform = process.platform
   };
 }
 
-// src/sync/utils.ts
-function unwrapData(response) {
-  if (!response || typeof response !== "object")
-    return null;
-  const maybeError = response.error;
-  if (maybeError)
-    return null;
-  if ("data" in response) {
-    const data = response.data;
-    if (data !== undefined)
-      return data;
-    return null;
-  }
-  return response;
-}
-function extractTextFromResponse(response) {
-  if (!response || typeof response !== "object")
-    return null;
-  const parts = response.parts ?? response.info?.parts ?? [];
-  const textPart = parts.find((part) => part.type === "text" && part.text);
-  return textPart?.text?.trim() ?? null;
-}
-async function resolveSmallModel(client) {
-  try {
-    const response = await client.config.get();
-    const config2 = unwrapData(response);
-    if (!config2)
-      return null;
-    const modelValue = config2.small_model ?? config2.model;
-    if (!modelValue)
-      return null;
-    const [providerID, modelID] = modelValue.split("/", 2);
-    if (!providerID || !modelID)
-      return null;
-    return { providerID, modelID };
-  } catch {
-    return null;
-  }
-}
-
-// src/sync/commit.ts
-async function generateCommitMessage(ctx, repoDir, fallbackDate = new Date) {
-  const fallback = `Sync OpenCode config (${formatDate(fallbackDate)})`;
-  const diffSummary = await getDiffSummary(ctx.$, repoDir);
-  if (!diffSummary)
-    return fallback;
-  const model = await resolveSmallModel(ctx.client);
-  if (!model)
-    return fallback;
-  const prompt = [
-    "Generate a concise single-line git commit message (max 72 chars).",
-    "Focus on OpenCode config sync changes.",
-    "Return only the message, no quotes.",
-    "",
-    "Diff summary:",
-    diffSummary
-  ].join(`
-`);
-  let sessionId = null;
-  try {
-    const sessionResult = await ctx.client.session.create({ body: { title: "opencode-synced" } });
-    const session = unwrapData(sessionResult);
-    sessionId = session?.id ?? null;
-    if (!sessionId)
-      return fallback;
-    const response = await ctx.client.session.prompt({
-      path: { id: sessionId },
-      body: {
-        model,
-        parts: [{ type: "text", text: prompt }]
-      }
-    });
-    const message = extractTextFromResponse(unwrapData(response) ?? response);
-    if (!message)
-      return fallback;
-    const sanitized = sanitizeMessage(message);
-    return sanitized || fallback;
-  } catch {
-    return fallback;
-  } finally {
-    if (sessionId) {
-      try {
-        await ctx.client.session.delete({ path: { id: sessionId } });
-      } catch {}
-    }
-  }
-}
-function sanitizeMessage(message) {
-  const firstLine = message.split(`
-`)[0].trim();
-  const trimmed = firstLine.replace(/^["'`]+|["'`]+$/g, "").trim();
-  if (!trimmed)
-    return "";
-  if (trimmed.length <= 72)
-    return trimmed;
-  return trimmed.slice(0, 72).trim();
-}
-async function getDiffSummary($, repoDir) {
-  try {
-    const nameStatus = await $`git -C ${repoDir} diff --name-status`.text();
-    const stats = await $`git -C ${repoDir} diff --stat`.text();
-    return [nameStatus.trim(), stats.trim()].filter(Boolean).join(`
-`);
-  } catch {
-    return "";
-  }
-}
-function formatDate(date5) {
-  const year = String(date5.getFullYear());
-  const month = String(date5.getMonth() + 1).padStart(2, "0");
-  const day = String(date5.getDate()).padStart(2, "0");
-  return `${year}-${month}-${day}`;
-}
-
 // src/sync/apply.ts
 import { promises as fs2 } from "fs";
 import path3 from "path";
@@ -13018,7 +12904,7 @@ function isDeepEqual(left, right) {
     if (leftKeys.length !== rightKeys.length)
       return false;
     for (const key of leftKeys) {
-      if (!Object.prototype.hasOwnProperty.call(right, key))
+      if (!Object.hasOwn(right, key))
         return false;
       if (!isDeepEqual(left[key], right[key])) {
         return false;
@@ -13029,6 +12915,147 @@ function isDeepEqual(left, right) {
   return false;
 }
 
+// src/sync/utils.ts
+var SERVICE_NAME = "opencode-synced";
+function createLogger(client) {
+  return {
+    debug: (message, extra) => log(client, "debug", message, extra),
+    info: (message, extra) => log(client, "info", message, extra),
+    warn: (message, extra) => log(client, "warn", message, extra),
+    error: (message, extra) => log(client, "error", message, extra)
+  };
+}
+function log(client, level, message, extra) {
+  client.app.log({
+    body: {
+      service: SERVICE_NAME,
+      level,
+      message,
+      extra
+    }
+  }).catch((err) => {
+    const errorMsg = err instanceof Error ? err.message : String(err);
+    showToast(client, `Logging failed: ${errorMsg}`, "error");
+  });
+}
+async function showToast(client, message, variant) {
+  await client.tui.showToast({
+    body: { title: "opencode-synced plugin", message, variant }
+  });
+}
+function unwrapData(response) {
+  if (!response || typeof response !== "object")
+    return null;
+  const maybeError = response.error;
+  if (maybeError)
+    return null;
+  if ("data" in response) {
+    const data = response.data;
+    if (data !== undefined)
+      return data;
+    return null;
+  }
+  return response;
+}
+function extractTextFromResponse(response) {
+  if (!response || typeof response !== "object")
+    return null;
+  const parts = response.parts ?? response.info?.parts ?? [];
+  const textPart = parts.find((part) => part.type === "text" && part.text);
+  return textPart?.text?.trim() ?? null;
+}
+async function resolveSmallModel(client) {
+  try {
+    const response = await client.config.get();
+    const config2 = unwrapData(response);
+    if (!config2)
+      return null;
+    const modelValue = config2.small_model ?? config2.model;
+    if (!modelValue)
+      return null;
+    const [providerID, modelID] = modelValue.split("/", 2);
+    if (!providerID || !modelID)
+      return null;
+    return { providerID, modelID };
+  } catch {
+    return null;
+  }
+}
+
+// src/sync/commit.ts
+async function generateCommitMessage(ctx, repoDir, fallbackDate = new Date) {
+  const fallback = `Sync OpenCode config (${formatDate(fallbackDate)})`;
+  const diffSummary = await getDiffSummary(ctx.$, repoDir);
+  if (!diffSummary)
+    return fallback;
+  const model = await resolveSmallModel(ctx.client);
+  if (!model)
+    return fallback;
+  const prompt = [
+    "Generate a concise single-line git commit message (max 72 chars).",
+    "Focus on OpenCode config sync changes.",
+    "Return only the message, no quotes.",
+    "",
+    "Diff summary:",
+    diffSummary
+  ].join(`
+`);
+  let sessionId = null;
+  try {
+    const sessionResult = await ctx.client.session.create({ body: { title: "opencode-synced" } });
+    const session = unwrapData(sessionResult);
+    sessionId = session?.id ?? null;
+    if (!sessionId)
+      return fallback;
+    const response = await ctx.client.session.prompt({
+      path: { id: sessionId },
+      body: {
+        model,
+        parts: [{ type: "text", text: prompt }]
+      }
+    });
+    const message = extractTextFromResponse(unwrapData(response) ?? response);
+    if (!message)
+      return fallback;
+    const sanitized = sanitizeMessage(message);
+    return sanitized || fallback;
+  } catch {
+    return fallback;
+  } finally {
+    if (sessionId) {
+      try {
+        await ctx.client.session.delete({ path: { id: sessionId } });
+      } catch {}
+    }
+  }
+}
+function sanitizeMessage(message) {
+  const firstLine = message.split(`
+`)[0].trim();
+  const trimmed = firstLine.replace(/^["'`]+|["'`]+$/g, "").trim();
+  if (!trimmed)
+    return "";
+  if (trimmed.length <= 72)
+    return trimmed;
+  return trimmed.slice(0, 72).trim();
+}
+async function getDiffSummary($, repoDir) {
+  try {
+    const nameStatus = await $`git -C ${repoDir} diff --name-status`.quiet().text();
+    const stats = await $`git -C ${repoDir} diff --stat`.quiet().text();
+    return [nameStatus.trim(), stats.trim()].filter(Boolean).join(`
+`);
+  } catch {
+    return "";
+  }
+}
+function formatDate(date5) {
+  const year = String(date5.getFullYear());
+  const month = String(date5.getMonth() + 1).padStart(2, "0");
+  const day = String(date5.getDate()).padStart(2, "0");
+  return `${year}-${month}-${day}`;
+}
+
 // src/sync/repo.ts
 import { promises as fs3 } from "fs";
 import path4 from "path";
@@ -13060,7 +13087,7 @@ async function ensureRepoCloned($, config2, repoDir) {
   await fs3.mkdir(path4.dirname(repoDir), { recursive: true });
   const repoIdentifier = resolveRepoIdentifier(config2);
   try {
-    await $`gh repo clone ${repoIdentifier} ${repoDir}`;
+    await $`gh repo clone ${repoIdentifier} ${repoDir}`.quiet();
   } catch (error45) {
     throw new SyncCommandError(`Failed to clone repo: ${formatError2(error45)}`);
   }
@@ -13069,7 +13096,7 @@ async function ensureRepoPrivate($, config2) {
   const repoIdentifier = resolveRepoIdentifier(config2);
   let output;
   try {
-    output = await $`gh repo view ${repoIdentifier} --json isPrivate`.text();
+    output = await $`gh repo view ${repoIdentifier} --json isPrivate`.quiet().text();
   } catch (error45) {
     throw new RepoVisibilityError(`Unable to verify repo visibility: ${formatError2(error45)}`);
   }
@@ -13092,7 +13119,7 @@ function parseRepoVisibility(output) {
 }
 async function fetchAndFastForward($, repoDir, branch) {
   try {
-    await $`git -C ${repoDir} fetch --prune`;
+    await $`git -C ${repoDir} fetch --prune`.quiet();
   } catch (error45) {
     throw new SyncCommandError(`Failed to fetch repo: ${formatError2(error45)}`);
   }
@@ -13108,7 +13135,7 @@ async function fetchAndFastForward($, repoDir, branch) {
   }
   if (behind > 0) {
     try {
-      await $`git -C ${repoDir} merge --ff-only ${remoteRef}`;
+      await $`git -C ${repoDir} merge --ff-only ${remoteRef}`.quiet();
       return { updated: true, branch };
     } catch (error45) {
       throw new SyncCommandError(`Failed to fast-forward: ${formatError2(error45)}`);
@@ -13127,22 +13154,22 @@ async function hasLocalChanges($, repoDir) {
 }
 async function commitAll($, repoDir, message) {
   try {
-    await $`git -C ${repoDir} add -A`;
-    await $`git -C ${repoDir} commit -m ${message}`;
+    await $`git -C ${repoDir} add -A`.quiet();
+    await $`git -C ${repoDir} commit -m ${message}`.quiet();
   } catch (error45) {
     throw new SyncCommandError(`Failed to commit changes: ${formatError2(error45)}`);
   }
 }
 async function pushBranch($, repoDir, branch) {
   try {
-    await $`git -C ${repoDir} push -u origin ${branch}`;
+    await $`git -C ${repoDir} push -u origin ${branch}`.quiet();
   } catch (error45) {
     throw new SyncCommandError(`Failed to push changes: ${formatError2(error45)}`);
   }
 }
 async function getCurrentBranch($, repoDir) {
   try {
-    const output = await $`git -C ${repoDir} rev-parse --abbrev-ref HEAD`.text();
+    const output = await $`git -C ${repoDir} rev-parse --abbrev-ref HEAD`.quiet().text();
     const branch = output.trim();
     if (!branch || branch === "HEAD")
       return "main";
@@ -13155,17 +13182,17 @@ async function checkoutBranch($, repoDir, branch) {
   const exists = await hasLocalBranch($, repoDir, branch);
   try {
     if (exists) {
-      await $`git -C ${repoDir} checkout ${branch}`;
+      await $`git -C ${repoDir} checkout ${branch}`.quiet();
       return;
     }
-    await $`git -C ${repoDir} checkout -b ${branch}`;
+    await $`git -C ${repoDir} checkout -b ${branch}`.quiet();
   } catch (error45) {
     throw new SyncCommandError(`Failed to checkout branch: ${formatError2(error45)}`);
   }
 }
 async function hasLocalBranch($, repoDir, branch) {
   try {
-    await $`git -C ${repoDir} show-ref --verify refs/heads/${branch}`;
+    await $`git -C ${repoDir} show-ref --verify refs/heads/${branch}`.quiet();
     return true;
   } catch {
     return false;
@@ -13173,7 +13200,7 @@ async function hasLocalBranch($, repoDir, branch) {
 }
 async function hasRemoteRef($, repoDir, branch) {
   try {
-    await $`git -C ${repoDir} show-ref --verify refs/remotes/origin/${branch}`;
+    await $`git -C ${repoDir} show-ref --verify refs/remotes/origin/${branch}`.quiet();
     return true;
   } catch {
     return false;
@@ -13181,7 +13208,7 @@ async function hasRemoteRef($, repoDir, branch) {
 }
 async function getAheadBehind($, repoDir, remoteRef) {
   try {
-    const output = await $`git -C ${repoDir} rev-list --left-right --count HEAD...${remoteRef}`.text();
+    const output = await $`git -C ${repoDir} rev-list --left-right --count HEAD...${remoteRef}`.quiet().text();
     const [aheadRaw, behindRaw] = output.trim().split(/\s+/);
     const ahead = Number(aheadRaw ?? 0);
     const behind = Number(behindRaw ?? 0);
@@ -13192,7 +13219,7 @@ async function getAheadBehind($, repoDir, remoteRef) {
 }
 async function getStatusLines($, repoDir) {
   try {
-    const output = await $`git -C ${repoDir} status --porcelain`.text();
+    const output = await $`git -C ${repoDir} status --porcelain`.quiet().text();
     return output.split(`
 `).map((line) => line.trim()).filter(Boolean);
   } catch {
@@ -13206,7 +13233,7 @@ function formatError2(error45) {
 }
 async function repoExists($, repoIdentifier) {
   try {
-    await $`gh repo view ${repoIdentifier} --json name`;
+    await $`gh repo view ${repoIdentifier} --json name`.quiet();
     return true;
   } catch {
     return false;
@@ -13214,27 +13241,63 @@ async function repoExists($, repoIdentifier) {
 }
 async function getAuthenticatedUser($) {
   try {
-    const output = await $`gh api user --jq .login`.text();
+    const output = await $`gh api user --jq .login`.quiet().text();
     return output.trim();
   } catch (error45) {
     throw new SyncCommandError(`Failed to detect GitHub user. Ensure gh is authenticated: ${formatError2(error45)}`);
   }
 }
+var LIKELY_SYNC_REPO_NAMES = [
+  "my-opencode-config",
+  "opencode-config",
+  "opencode-sync",
+  "opencode-synced",
+  "dotfiles-opencode"
+];
+async function findSyncRepo($, repoName) {
+  const owner = await getAuthenticatedUser($);
+  if (repoName) {
+    const exists = await repoExists($, `${owner}/${repoName}`);
+    if (exists) {
+      const isPrivate = await checkRepoPrivate($, `${owner}/${repoName}`);
+      return { owner, name: repoName, isPrivate };
+    }
+    return null;
+  }
+  for (const name of LIKELY_SYNC_REPO_NAMES) {
+    const exists = await repoExists($, `${owner}/${name}`);
+    if (exists) {
+      const isPrivate = await checkRepoPrivate($, `${owner}/${name}`);
+      return { owner, name, isPrivate };
+    }
+  }
+  return null;
+}
+async function checkRepoPrivate($, repoIdentifier) {
+  try {
+    const output = await $`gh repo view ${repoIdentifier} --json isPrivate`.quiet().text();
+    return parseRepoVisibility(output);
+  } catch {
+    return false;
+  }
+}
 
 // src/sync/service.ts
 function createSyncService(ctx) {
   const locations = resolveSyncLocations();
+  const log2 = createLogger(ctx.client);
   return {
     startupSync: async () => {
       const config2 = await loadSyncConfig(locations);
       if (!config2) {
-        await showToast(ctx, "Configure opencode-synced with /sync-init.", "info");
+        await showToast(ctx.client, "Configure opencode-synced with /sync-init.", "info");
         return;
       }
       try {
-        await runStartup(ctx, locations, config2);
+        await runStartup(ctx, locations, config2, log2);
       } catch (error45) {
-        await showToast(ctx, formatError3(error45), "error");
+        log2.error("Startup sync failed", { error: formatError3(error45) });
+        await showToast(ctx.client, formatError3(error45), "error");
       }
     },
     status: async () => {
@@ -13301,6 +13364,18 @@ function createSyncService(ctx) {
       const repoRoot = resolveRepoRoot(config2, locations);
       await ensureRepoCloned(ctx.$, config2, repoRoot);
       await ensureSecretsPolicy(ctx, config2);
+      if (created) {
+        const overrides = await loadOverrides(locations);
+        const plan = buildSyncPlan(config2, locations, repoRoot);
+        await syncLocalToRepo(plan, overrides);
+        const dirty = await hasLocalChanges(ctx.$, repoRoot);
+        if (dirty) {
+          const branch = resolveRepoBranch(config2);
+          await commitAll(ctx.$, repoRoot, "Initial sync from opencode-synced");
+          await pushBranch(ctx.$, repoRoot, branch);
+          await writeState(locations, { lastPush: new Date().toISOString() });
+        }
+      }
       const lines = [
         "opencode-synced configured.",
         `Repo: ${repoIdentifier}${created ? " (created)" : ""}`,
@@ -13308,6 +13383,55 @@ function createSyncService(ctx) {
         `Local repo: ${repoRoot}`
       ];
       return lines.join(`
+`);
+    },
+    link: async (options) => {
+      const found = await findSyncRepo(ctx.$, options.repo);
+      if (!found) {
+        const searchedFor = options.repo ? `"${options.repo}"` : "common sync repo names (my-opencode-config, opencode-config, etc.)";
+        const lines2 = [
+          `Could not find an existing sync repo. Searched for: ${searchedFor}`,
+          "",
+          "To link to an existing repo, run:",
+          "  /sync-link <repo-name>",
+          "",
+          "To create a new sync repo, run:",
+          "  /sync-init"
+        ];
+        return lines2.join(`
+`);
+      }
+      const config2 = normalizeSyncConfig({
+        repo: { owner: found.owner, name: found.name },
+        includeSecrets: false,
+        includeSessions: false,
+        includePromptStash: false,
+        extraSecretPaths: []
+      });
+      await writeSyncConfig(locations, config2);
+      const repoRoot = resolveRepoRoot(config2, locations);
+      await ensureRepoCloned(ctx.$, config2, repoRoot);
+      const branch = await resolveBranch(ctx, config2, repoRoot);
+      await fetchAndFastForward(ctx.$, repoRoot, branch);
+      const overrides = await loadOverrides(locations);
+      const plan = buildSyncPlan(config2, locations, repoRoot);
+      await syncRepoToLocal(plan, overrides);
+      await writeState(locations, {
+        lastPull: new Date().toISOString(),
+        lastRemoteUpdate: new Date().toISOString()
+      });
+      const lines = [
+        `Linked to existing sync repo: ${found.owner}/${found.name}`,
+        "",
+        "Your local OpenCode config has been OVERWRITTEN with the synced config.",
+        "Your local overrides file was preserved and applied on top.",
+        "",
+        "Restart OpenCode to apply the new settings.",
+        "",
+        found.isPrivate ? "To enable secrets sync, run: /sync-enable-secrets" : "Note: Repo is public. Secrets sync is disabled."
+      ];
+      await showToast(ctx.client, "Config synced. Restart OpenCode to apply.", "info");
+      return lines.join(`
 `);
     },
     pull: async () => {
@@ -13331,7 +13455,7 @@ function createSyncService(ctx) {
         lastPull: new Date().toISOString(),
         lastRemoteUpdate: new Date().toISOString()
       });
-      await showToast(ctx, "Config updated. Restart OpenCode to apply.", "info");
+      await showToast(ctx.client, "Config updated. Restart OpenCode to apply.", "info");
       return "Remote config applied. Restart OpenCode to use new settings.";
     },
     push: async () => {
@@ -13380,35 +13504,39 @@ function createSyncService(ctx) {
       const status = await getRepoStatus(ctx.$, repoRoot);
       const decision = await analyzeAndDecideResolution({ client: ctx.client, $: ctx.$ }, repoRoot, status.changes);
       if (decision.action === "commit") {
-        const message = decision.message;
+        const message = decision.message ?? "Sync: Auto-resolved uncommitted changes";
         await commitAll(ctx.$, repoRoot, message);
         return `Resolved by committing changes: ${message}`;
       }
       if (decision.action === "reset") {
         try {
-          await ctx.$`git -C ${repoRoot} reset --hard HEAD`;
-          await ctx.$`git -C ${repoRoot} clean -fd`;
+          await ctx.$`git -C ${repoRoot} reset --hard HEAD`.quiet();
+          await ctx.$`git -C ${repoRoot} clean -fd`.quiet();
           return "Resolved by discarding all uncommitted changes.";
         } catch (error45) {
           throw new SyncCommandError(`Failed to reset changes: ${formatError3(error45)}`);
         }
       }
-      return "Unable to automatically resolve. Please manually resolve in: " + repoRoot;
+      return `Unable to automatically resolve. Please manually resolve in: ${repoRoot}`;
     }
   };
 }
-async function runStartup(ctx, locations, config2) {
+async function runStartup(ctx, locations, config2, log2) {
   const repoRoot = resolveRepoRoot(config2, locations);
+  log2.debug("Starting sync", { repoRoot });
   await ensureRepoCloned(ctx.$, config2, repoRoot);
   await ensureSecretsPolicy(ctx, config2);
   const branch = await resolveBranch(ctx, config2, repoRoot);
+  log2.debug("Resolved branch", { branch });
   const dirty = await hasLocalChanges(ctx.$, repoRoot);
   if (dirty) {
-    await showToast(ctx, `Uncommitted changes detected. Run /sync-resolve to auto-fix, or manually resolve in: ${repoRoot}`, "warning");
+    log2.warn("Uncommitted changes detected", { repoRoot });
+    await showToast(ctx.client, `Uncommitted changes detected. Run /sync-resolve to auto-fix, or manually resolve in: ${repoRoot}`, "warning");
     return;
   }
   const update = await fetchAndFastForward(ctx.$, repoRoot, branch);
   if (update.updated) {
+    log2.info("Pulled remote changes", { branch });
     const overrides2 = await loadOverrides(locations);
     const plan2 = buildSyncPlan(config2, locations, repoRoot);
     await syncRepoToLocal(plan2, overrides2);
@@ -13416,16 +13544,19 @@ async function runStartup(ctx, locations, config2) {
       lastPull: new Date().toISOString(),
       lastRemoteUpdate: new Date().toISOString()
     });
-    await showToast(ctx, "Config updated. Restart OpenCode to apply.", "info");
+    await showToast(ctx.client, "Config updated. Restart OpenCode to apply.", "info");
     return;
   }
   const overrides = await loadOverrides(locations);
   const plan = buildSyncPlan(config2, locations, repoRoot);
   await syncLocalToRepo(plan, overrides);
   const changes = await hasLocalChanges(ctx.$, repoRoot);
-  if (!changes)
+  if (!changes) {
+    log2.debug("No local changes to push");
     return;
+  }
   const message = await generateCommitMessage({ client: ctx.client, $: ctx.$ }, repoRoot);
+  log2.info("Pushing local changes", { message });
   await commitAll(ctx.$, repoRoot, message);
   await pushBranch(ctx.$, repoRoot, branch);
   await writeState(locations, {
@@ -13496,14 +13627,11 @@ async function createRepo($, config2, isPrivate) {
   }
   const visibility = isPrivate ? "--private" : "--public";
   try {
-    await $`gh repo create ${owner}/${name} ${visibility} --confirm`;
+    await $`gh repo create ${owner}/${name} ${visibility} --confirm`.quiet();
   } catch (error45) {
     throw new SyncCommandError(`Failed to create repo: ${formatError3(error45)}`);
   }
 }
-async function showToast(ctx, message, variant) {
-  await ctx.client.tui.showToast({ body: { message: `opencode-synced: ${message}`, variant } });
-}
 function formatError3(error45) {
   if (error45 instanceof Error)
     return error45.message;
@@ -13511,7 +13639,7 @@ function formatError3(error45) {
 }
 async function analyzeAndDecideResolution(ctx, repoRoot, changes) {
   try {
-    const diff = await ctx.$`git -C ${repoRoot} diff HEAD`.text();
+    const diff = await ctx.$`git -C ${repoRoot} diff HEAD`.quiet().text();
     const statusOutput = changes.join(`
 `);
     const prompt = [
@@ -13641,7 +13769,7 @@ var OpencodeConfigSync = async (ctx) => {
   const syncTool = tool({
     description: "Manage OpenCode config sync with a GitHub repo",
     args: {
-      command: tool.schema.enum(["status", "init", "pull", "push", "enable-secrets", "resolve"]).describe("Sync command to execute"),
+      command: tool.schema.enum(["status", "init", "link", "pull", "push", "enable-secrets", "resolve"]).describe("Sync command to execute"),
       repo: tool.schema.string().optional().describe("Repo owner/name or URL"),
       owner: tool.schema.string().optional().describe("Repo owner"),
       name: tool.schema.string().optional().describe("Repo name"),
@@ -13676,6 +13804,11 @@ var OpencodeConfigSync = async (ctx) => {
             localRepoPath: args.localRepoPath
           });
         }
+        if (args.command === "link") {
+          return await service.link({
+            repo: args.repo ?? args.name
+          });
+        }
         if (args.command === "pull") {
           return await service.pull();
         }
@@ -13697,7 +13830,9 @@ var OpencodeConfigSync = async (ctx) => {
       }
     }
   });
-  service.startupSync();
+  setTimeout(() => {
+    service.startupSync();
+  }, 1000);
   return {
     tool: {
       opencode_sync: syncTool

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "opencode-synced",
-  "version": "0.1.0",
+  "version": "0.1.1",
   "description": "Sync global OpenCode config across machines via GitHub.",
   "author": {
     "name": "Ian Hildebrand"
@@ -26,25 +26,29 @@
     "@opencode-ai/plugin": "1.0.85"
   },
   "devDependencies": {
-    "@eslint/js": "^9.39.1",
+    "@biomejs/biome": "2.3.10",
+    "@commitlint/cli": "^20.2.0",
+    "@commitlint/config-conventional": "^20.2.0",
     "@types/node": "^20.11.5",
-    "@typescript-eslint/eslint-plugin": "8.47.0",
-    "@typescript-eslint/parser": "8.47.0",
     "bun-types": "latest",
-    "eslint": "^9.39.1",
-    "eslint-config-prettier": "10.1.8",
-    "eslint-plugin-prettier": "^5.1.3",
-    "prettier": "^3.2.4",
+    "husky": "^9.1.7",
+    "lint-staged": "^16.2.7",
     "typescript": "^5.9.2",
-    "typescript-eslint": "^8.47.0",
     "vitest": "^3.2.4"
   },
   "scripts": {
     "build": "rm -rf dist && bun build ./src/index.ts --outdir dist --target bun && tsc -p tsconfig.build.json && cp -r src/command dist/command",
     "test": "vitest run",
     "test:watch": "vitest",
-    "lint": "eslint .",
-    "lint:fix": "eslint . --fix",
-    "format": "prettier --write ."
+    "lint": "biome lint .",
+    "lint:fix": "biome lint --write .",
+    "format": "biome format --write .",
+    "check": "biome check --write .",
+    "prepare": "husky"
+  },
+  "lint-staged": {
+    "*.{js,ts,json}": [
+      "biome check --write --no-errors-on-unmatched"
+    ]
   }
 }

package/dist/command/sync-enable-secrets.md

@@ -1,5 +0,0 @@
----
-description: Enable secrets sync (private repo required)
----
-Use the opencode_sync tool with command "enable-secrets".
-If the user supplies extra secret paths, pass them via extraSecretPaths.

package/dist/command/sync-init.md

@@ -1,11 +0,0 @@
----
-description: Initialize opencode-synced configuration
----
-
-Use the opencode_sync tool with command "init".
-The repo will be created automatically if it doesn't exist (private by default).
-Default repo name is "my-opencode-config" with owner auto-detected from GitHub CLI.
-If the user wants a custom repo name, pass name="custom-name".
-If the user wants an org-owned repo, pass owner="org-name".
-If the user wants a public repo, pass private=false.
-Include includeSecrets if the user explicitly opts in.

package/dist/command/sync-pull.md

@@ -1,5 +0,0 @@
----
-description: Pull and apply synced OpenCode config
----
-Use the opencode_sync tool with command "pull".
-If updates are applied, remind the user to restart OpenCode.

package/dist/command/sync-push.md

@@ -1,4 +0,0 @@
----
-description: Push local OpenCode config to the sync repo
----
-Use the opencode_sync tool with command "push".

package/dist/command/sync-resolve.md

@@ -1,5 +0,0 @@
----
-description: Resolve uncommitted changes in sync repo
----
-
-Use the opencode_sync tool with command "resolve" to automatically resolve uncommitted changes in the local sync repository using AI.

package/dist/command/sync-status.md

@@ -1,5 +0,0 @@
----
-description: Show opencode-synced status
----
-
-Use the opencode_sync tool with command "status" and report the results.

package/dist/index.d.ts

@@ -1,2 +0,0 @@
-import type { Plugin } from '@opencode-ai/plugin';
-export declare const OpencodeConfigSync: Plugin;

package/dist/sync/apply.d.ts

@@ -1,3 +0,0 @@
-import type { SyncPlan } from './paths.ts';
-export declare function syncRepoToLocal(plan: SyncPlan, overrides: Record<string, unknown> | null): Promise<void>;
-export declare function syncLocalToRepo(plan: SyncPlan, overrides: Record<string, unknown> | null): Promise<void>;

package/dist/sync/commit.d.ts

@@ -1,9 +0,0 @@
-import type { PluginInput } from '@opencode-ai/plugin';
-type CommitClient = PluginInput['client'];
-type Shell = PluginInput['$'];
-interface CommitContext {
-    client: CommitClient;
-    $: Shell;
-}
-export declare function generateCommitMessage(ctx: CommitContext, repoDir: string, fallbackDate?: Date): Promise<string>;
-export {};

package/dist/sync/config.d.ts

@@ -1,35 +0,0 @@
-import type { SyncLocations } from './paths.ts';
-export interface SyncRepoConfig {
-    url?: string;
-    owner?: string;
-    name?: string;
-    branch?: string;
-}
-export interface SyncConfig {
-    repo?: SyncRepoConfig;
-    localRepoPath?: string;
-    includeSecrets?: boolean;
-    includeSessions?: boolean;
-    includePromptStash?: boolean;
-    extraSecretPaths?: string[];
-}
-export interface SyncState {
-    lastPull?: string;
-    lastPush?: string;
-    lastRemoteUpdate?: string;
-}
-export declare function pathExists(filePath: string): Promise<boolean>;
-export declare function normalizeSyncConfig(config: SyncConfig): SyncConfig;
-export declare function loadSyncConfig(locations: SyncLocations): Promise<SyncConfig | null>;
-export declare function writeSyncConfig(locations: SyncLocations, config: SyncConfig): Promise<void>;
-export declare function loadOverrides(locations: SyncLocations): Promise<Record<string, unknown> | null>;
-export declare function loadState(locations: SyncLocations): Promise<SyncState>;
-export declare function writeState(locations: SyncLocations, state: SyncState): Promise<void>;
-export declare function applyOverridesToRuntimeConfig(config: Record<string, unknown>, overrides: Record<string, unknown>): void;
-export declare function deepMerge<T>(base: T, override: unknown): T;
-export declare function stripOverrides(localConfig: Record<string, unknown>, overrides: Record<string, unknown>, baseConfig: Record<string, unknown> | null): Record<string, unknown>;
-export declare function parseJsonc<T>(content: string): T;
-export declare function writeJsonFile(filePath: string, data: unknown, options?: {
-    jsonc: boolean;
-    mode?: number;
-}): Promise<void>;

package/dist/sync/config.test.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/sync/errors.d.ts

@@ -1,19 +0,0 @@
-export declare class SyncError extends Error {
-    readonly code: string;
-    constructor(code: string, message: string);
-}
-export declare class SyncConfigMissingError extends SyncError {
-    constructor(message: string);
-}
-export declare class RepoDivergedError extends SyncError {
-    constructor(message: string);
-}
-export declare class RepoPrivateRequiredError extends SyncError {
-    constructor(message: string);
-}
-export declare class RepoVisibilityError extends SyncError {
-    constructor(message: string);
-}
-export declare class SyncCommandError extends SyncError {
-    constructor(message: string);
-}

package/dist/sync/paths.d.ts

@@ -1,47 +0,0 @@
-import type { SyncConfig } from './config.ts';
-export interface XdgPaths {
-    homeDir: string;
-    configDir: string;
-    dataDir: string;
-    stateDir: string;
-}
-export interface SyncLocations {
-    xdg: XdgPaths;
-    configRoot: string;
-    syncConfigPath: string;
-    overridesPath: string;
-    statePath: string;
-    defaultRepoDir: string;
-}
-export type SyncItemType = 'file' | 'dir';
-export interface SyncItem {
-    localPath: string;
-    repoPath: string;
-    type: SyncItemType;
-    isSecret: boolean;
-    isConfigFile: boolean;
-}
-export interface ExtraSecretPlan {
-    allowlist: string[];
-    manifestPath: string;
-    entries: Array<{
-        sourcePath: string;
-        repoPath: string;
-    }>;
-}
-export interface SyncPlan {
-    items: SyncItem[];
-    extraSecrets: ExtraSecretPlan;
-    repoRoot: string;
-    homeDir: string;
-    platform: NodeJS.Platform;
-}
-export declare function resolveHomeDir(env?: NodeJS.ProcessEnv, platform?: NodeJS.Platform): string;
-export declare function resolveXdgPaths(env?: NodeJS.ProcessEnv, platform?: NodeJS.Platform): XdgPaths;
-export declare function resolveSyncLocations(env?: NodeJS.ProcessEnv, platform?: NodeJS.Platform): SyncLocations;
-export declare function expandHome(inputPath: string, homeDir: string): string;
-export declare function normalizePath(inputPath: string, homeDir: string, platform?: NodeJS.Platform): string;
-export declare function isSamePath(left: string, right: string, homeDir: string, platform?: NodeJS.Platform): boolean;
-export declare function encodeSecretPath(inputPath: string): string;
-export declare function resolveRepoRoot(config: SyncConfig | null, locations: SyncLocations): string;
-export declare function buildSyncPlan(config: SyncConfig, locations: SyncLocations, repoRoot: string, platform?: NodeJS.Platform): SyncPlan;

package/dist/sync/paths.test.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/sync/repo.d.ts

@@ -1,25 +0,0 @@
-import type { PluginInput } from '@opencode-ai/plugin';
-import type { SyncConfig } from './config.ts';
-export interface RepoStatus {
-    branch: string;
-    changes: string[];
-}
-export interface RepoUpdateResult {
-    updated: boolean;
-    branch: string;
-}
-type Shell = PluginInput['$'];
-export declare function isRepoCloned(repoDir: string): Promise<boolean>;
-export declare function resolveRepoIdentifier(config: SyncConfig): string;
-export declare function resolveRepoBranch(config: SyncConfig, fallback?: string): string;
-export declare function ensureRepoCloned($: Shell, config: SyncConfig, repoDir: string): Promise<void>;
-export declare function ensureRepoPrivate($: Shell, config: SyncConfig): Promise<void>;
-export declare function parseRepoVisibility(output: string): boolean;
-export declare function fetchAndFastForward($: Shell, repoDir: string, branch: string): Promise<RepoUpdateResult>;
-export declare function getRepoStatus($: Shell, repoDir: string): Promise<RepoStatus>;
-export declare function hasLocalChanges($: Shell, repoDir: string): Promise<boolean>;
-export declare function commitAll($: Shell, repoDir: string, message: string): Promise<void>;
-export declare function pushBranch($: Shell, repoDir: string, branch: string): Promise<void>;
-export declare function repoExists($: Shell, repoIdentifier: string): Promise<boolean>;
-export declare function getAuthenticatedUser($: Shell): Promise<string>;
-export {};

package/dist/sync/repo.test.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/sync/service.d.ts

@@ -1,27 +0,0 @@
-import type { PluginInput } from '@opencode-ai/plugin';
-type SyncServiceContext = Pick<PluginInput, 'client' | '$'>;
-interface InitOptions {
-    repo?: string;
-    owner?: string;
-    name?: string;
-    url?: string;
-    branch?: string;
-    includeSecrets?: boolean;
-    includeSessions?: boolean;
-    includePromptStash?: boolean;
-    create?: boolean;
-    private?: boolean;
-    extraSecretPaths?: string[];
-    localRepoPath?: string;
-}
-export interface SyncService {
-    startupSync: () => Promise<void>;
-    status: () => Promise<string>;
-    init: (_options: InitOptions) => Promise<string>;
-    pull: () => Promise<string>;
-    push: () => Promise<string>;
-    enableSecrets: (_extraSecretPaths?: string[]) => Promise<string>;
-    resolve: () => Promise<string>;
-}
-export declare function createSyncService(ctx: SyncServiceContext): SyncService;
-export {};

package/dist/sync/utils.d.ts

@@ -1,9 +0,0 @@
-import type { PluginInput } from '@opencode-ai/plugin';
-type Client = PluginInput['client'];
-export declare function unwrapData<T>(response: unknown): T | null;
-export declare function extractTextFromResponse(response: unknown): string | null;
-export declare function resolveSmallModel(client: Client): Promise<{
-    providerID: string;
-    modelID: string;
-} | null>;
-export {};