@opencode-manager/ocm-cli 0.1.3 → 0.2.0

package/README.md

@@ -34,24 +34,31 @@ ocm
 ocm status
 ocm list
 ocm use <repoId|name>
-ocm push [--force] [--create] [--yes]
-ocm pull [--force]
+ocm push [--force] [--create] [--yes] [--full]
+ocm pull [--force] [--full]
 ocm logout
 ```
 
-Running `ocm` with no command tries to match the current git repo's `origin`
-against ready Manager repos. If one repo matches, it attaches OpenCode to that
-Manager repo. If no repo matches, it falls back to the last selected repo, then
-to local `opencode`.
+Running `ocm` with no command computes the current git repo's OpenCode project
+id (the same identity OpenCode uses: normalized origin remote hash, else the
+cached id, else the root commit) and matches it against ready Manager repos. If
+one repo matches, it attaches OpenCode to that Manager repo. If no repo matches,
+it falls back to the last selected repo, then to local `opencode`.
 
 `ocm use <repoId|name>` selects a Manager repo, remembers it as the last repo,
 and attaches OpenCode to it.
 
-`ocm push` uploads the current git repo to the matching Manager repo. Use
-`--create` to create a Manager repo when no origin match exists, and `--yes` to
+`ocm push` syncs the current git repo to the matching Manager repo using a fast
+git bundle + working-tree patch by default. Pass `--full` to use the legacy
+tarball mirror. If the fast path fails, `ocm` prompts before reverting to the
+tarball mirror (and proceeds automatically when there is no TTY to prompt). Use
+`--create` to create a Manager repo when no project match exists, and `--yes` to
 confirm creation in non-interactive shells.
 
-`ocm pull` replaces the current working tree with the matching Manager repo. It
+`ocm pull` syncs the matching Manager repo over the current working tree using a
+fast git bundle + working-tree patch by default. Pass `--full` to use the legacy
+tarball mirror. If the fast path fails, `ocm` prompts before reverting to the
+tarball mirror (and proceeds automatically when there is no TTY to prompt). It
 refuses to overwrite uncommitted local changes unless `--force` is passed.
 
 ## OpenCode plugin
@@ -69,6 +76,6 @@ export default [ocm]
 ## Requirements
 
 - `opencode` available on `PATH`
-- `git` and `tar` available on `PATH`
+- `git` and `tar` (with gzip support, i.e. the `-z` flag) available on `PATH`
 - macOS `security` CLI for Keychain-backed token storage
 - An OpenCode Manager URL and bearer token

package/dist/ocm.js

@@ -95,6 +95,9 @@ function deleteToken(account) {
 }
 
 // src/manager-api.ts
+import { createReadStream } from "fs";
+import { Readable } from "stream";
+
 class ManagerApiError extends Error {
   status;
   code;
@@ -165,12 +168,12 @@ class ManagerApi {
     if (!res.ok)
       throw await formatErrorResponse(res, `mirror part ${index}`);
   }
-  async mirrorCommit(repoId, uploadId, totalParts) {
+  async mirrorCommit(repoId, uploadId, totalParts, gzip) {
     const url = `${this.baseUrl}/api/internal/repos/${repoId}/mirror/commit`;
     const res = await fetch(url, {
       method: "POST",
       headers: { ...this.headers(), "Content-Type": "application/json" },
-      body: JSON.stringify({ uploadId, totalParts })
+      body: JSON.stringify({ uploadId, totalParts, gzip })
     });
     if (!res.ok)
       throw await formatErrorResponse(res, "mirror commit");
@@ -180,32 +183,112 @@ class ManagerApi {
     const url = `${this.baseUrl}/api/internal/repos/${repoId}/mirror/uploads/${uploadId}`;
     await fetch(url, { method: "DELETE", headers: this.headers() }).catch(() => {});
   }
-  async mirrorDown(repoId) {
-    const res = await fetch(`${this.baseUrl}/api/internal/repos/${repoId}/mirror`, {
+  async mirrorDown(repoId, gzip) {
+    const query = gzip ? "?compress=gzip" : "";
+    const res = await fetch(`${this.baseUrl}/api/internal/repos/${repoId}/mirror${query}`, {
       headers: this.headers()
     });
     if (!res.ok)
       throw await formatErrorResponse(res, "mirror download");
     return res.body;
   }
+  async mirrorPatch(repoId, body) {
+    const res = await fetch(`${this.baseUrl}/api/internal/repos/${repoId}/mirror/patch`, {
+      method: "POST",
+      headers: { ...this.headers(), "Content-Type": "application/json" },
+      body: JSON.stringify({ baseHead: body.baseHead, patch: body.patch, force: body.force === true })
+    });
+    if (!res.ok)
+      throw await formatErrorResponse(res, "mirror patch");
+    return await res.json();
+  }
+  async mirrorUploadBundle(repoId, bundlePath, opts) {
+    const query = opts.force === true ? "?force=1" : "";
+    const headers = { ...this.headers(), "Content-Type": "application/octet-stream" };
+    if (opts.branch)
+      headers["X-OCM-Branch"] = opts.branch;
+    const body = Readable.toWeb(createReadStream(bundlePath));
+    const res = await fetch(`${this.baseUrl}/api/internal/repos/${repoId}/mirror/bundle${query}`, {
+      method: "POST",
+      headers,
+      body,
+      duplex: "half"
+    });
+    if (!res.ok)
+      throw await formatErrorResponse(res, "mirror bundle upload");
+    return await res.json();
+  }
+  async mirrorHead(repoId) {
+    const res = await fetch(`${this.baseUrl}/api/internal/repos/${repoId}/mirror/head`, {
+      headers: this.headers()
+    });
+    if (!res.ok)
+      throw await formatErrorResponse(res, "mirror head");
+    return await res.json();
+  }
+  async mirrorContains(repoId, sha) {
+    const res = await fetch(`${this.baseUrl}/api/internal/repos/${repoId}/mirror/contains/${sha}`, {
+      headers: this.headers()
+    });
+    if (!res.ok)
+      throw await formatErrorResponse(res, "mirror contains");
+    return await res.json();
+  }
+  async mirrorDownloadBundle(repoId) {
+    const res = await fetch(`${this.baseUrl}/api/internal/repos/${repoId}/mirror/bundle`, {
+      headers: this.headers()
+    });
+    if (!res.ok)
+      throw await formatErrorResponse(res, "mirror bundle download");
+    return res.body;
+  }
+  async mirrorPatchSnapshot(repoId) {
+    const res = await fetch(`${this.baseUrl}/api/internal/repos/${repoId}/mirror/patch`, {
+      headers: this.headers()
+    });
+    if (!res.ok)
+      throw await formatErrorResponse(res, "mirror patch snapshot");
+    return await res.json();
+  }
 }
 
 // src/mirror.ts
 import { spawnSync as spawnSync3, spawn } from "child_process";
-import { existsSync as existsSync2, statSync } from "fs";
+import { createWriteStream, existsSync as existsSync3 } from "fs";
 import * as fsp from "fs/promises";
-import { Readable } from "stream";
-import { join as join2, dirname as dirname2 } from "path";
-import { tmpdir } from "os";
+import { Readable as Readable2 } from "stream";
+import { pipeline } from "stream/promises";
+import { join as join3, dirname as dirname2 } from "path";
+import { tmpdir as tmpdir2 } from "os";
 
 // src/local-repo.ts
 import { spawnSync as spawnSync2 } from "child_process";
-function git(cwd, args) {
-  const res = spawnSync2("git", args, { cwd, encoding: "utf-8" });
+import { copyFileSync, existsSync as existsSync2, rmSync } from "fs";
+import { join as join2 } from "path";
+import { tmpdir } from "os";
+function spawnGit(cwd, args, opts = {}) {
+  return spawnSync2("git", args, { cwd, input: opts.input, encoding: "utf-8", env: opts.env ?? process.env });
+}
+function git(cwd, args, env = process.env) {
+  const res = spawnGit(cwd, args, { env });
   if (res.status !== 0)
     return null;
   return (res.stdout ?? "").trim();
 }
+function gitRaw(cwd, args, env = process.env) {
+  const res = spawnGit(cwd, args, { env });
+  if (res.status !== 0)
+    return null;
+  return res.stdout ?? "";
+}
+function runGit(cwd, args, input, env = process.env) {
+  const res = spawnGit(cwd, args, { input, env });
+  if (res.status !== 0) {
+    const stderr = (res.stderr ?? "").trim();
+    throw new Error(`git ${args.join(" ")} failed${stderr ? `: ${stderr}` : ""}`);
+  }
+  return res.stdout ?? "";
+}
 function getRepoRoot(cwd) {
   return git(cwd, ["rev-parse", "--show-toplevel"]);
 }
@@ -226,22 +309,136 @@ function getDirtyPaths(dir) {
   }
   return paths;
 }
-function normalizeUrl(url) {
-  return url.trim().replace(/\.git$/, "").replace(/^git@([^:]+):/, "ssh://git@$1/").replace(/\/+$/, "").toLowerCase();
-}
 function getBranchName(dir) {
-  return git(dir, ["rev-parse", "--abbrev-ref", "HEAD"]);
+  const branch = git(dir, ["rev-parse", "--abbrev-ref", "HEAD"]);
+  return branch && branch !== "HEAD" ? branch : null;
 }
-function urlsEqual(a, b) {
-  if (!a || !b)
-    return false;
-  return normalizeUrl(a) === normalizeUrl(b);
+function getWorkingTreeDiff(dir) {
+  return gitRaw(dir, ["diff", "--binary", "HEAD", "--"]) ?? "";
+}
+function getHeadSha(dir) {
+  return git(dir, ["rev-parse", "HEAD"]);
+}
+function hasCommit(dir, sha) {
+  return git(dir, ["cat-file", "-e", `${sha}^{commit}`]) !== null;
+}
+function isAncestor(dir, ancestor, descendant) {
+  return spawnGit(dir, ["merge-base", "--is-ancestor", ancestor, descendant]).status === 0;
+}
+function countCommitsAhead(dir, from, to) {
+  const out = git(dir, ["rev-list", "--count", `${from}..${to}`]);
+  const n = out ? Number(out) : NaN;
+  return Number.isInteger(n) ? n : -1;
+}
+function getMirrorPatch(dir) {
+  const untracked = gitRaw(dir, ["ls-files", "--others", "--exclude-standard", "-z"])?.split("\x00").filter(Boolean) ?? [];
+  if (untracked.length === 0)
+    return getWorkingTreeDiff(dir);
+  const indexPath = git(dir, ["rev-parse", "--git-path", "index"]);
+  const tempIndex = join2(tmpdir(), `ocm-index-${Date.now()}-${Math.random().toString(36).slice(2)}`);
+  const env = { ...process.env, GIT_INDEX_FILE: tempIndex };
+  try {
+    if (indexPath && existsSync2(indexPath)) {
+      copyFileSync(indexPath, tempIndex);
+    }
+    const add = spawnSync2("git", ["add", "-N", "--", ...untracked], { cwd: dir, encoding: "utf-8", env });
+    if (add.status !== 0)
+      return getWorkingTreeDiff(dir);
+    return gitRaw(dir, ["diff", "--binary", "HEAD", "--"], env) ?? "";
+  } finally {
+    rmSync(tempIndex, { force: true });
+  }
+}
+
+// ../shared/src/project-id-resolver.ts
+import { execFile } from "child_process";
+import { createHash } from "crypto";
+import { readFile } from "fs/promises";
+import path from "path";
+function git2(cwd, args) {
+  return new Promise((resolve) => {
+    execFile("git", args, { cwd }, (error, stdout) => {
+      resolve(error ? null : stdout.trim());
+    });
+  });
+}
+function trimSlashes(value, leading, trailing) {
+  let start = 0;
+  let end = value.length;
+  if (leading)
+    while (start < end && value[start] === "/")
+      start++;
+  if (trailing)
+    while (end > start && value[end - 1] === "/")
+      end--;
+  return value.slice(start, end);
+}
+function gitRemoteParts(host, name) {
+  let pathname = trimSlashes(name, true, false);
+  if (pathname.endsWith(".git"))
+    pathname = pathname.slice(0, -4);
+  else if (pathname.endsWith(".git/"))
+    pathname = pathname.slice(0, -5);
+  pathname = trimSlashes(pathname, false, true);
+  if (!host || !pathname)
+    return;
+  return `${host.toLowerCase()}/${pathname}`;
+}
+function normalizeGitRemote(input) {
+  const value = input.trim();
+  if (!value)
+    return;
+  try {
+    const parsed = new URL(value);
+    if (parsed.protocol === "file:")
+      return;
+    return gitRemoteParts(parsed.hostname, parsed.pathname);
+  } catch {
+    const scp = value.match(/^([^@/:]+@)?([^/:]+):(.+)$/);
+    if (scp)
+      return gitRemoteParts(scp[2], scp[3]);
+    return;
+  }
+}
+function gitRemoteProjectId(originUrl) {
+  const normalized = normalizeGitRemote(originUrl);
+  if (!normalized)
+    return;
+  return createHash("sha1").update(`git-remote:${normalized}`).digest("hex");
+}
+async function resolveOpenCodeProjectId(repoDir) {
+  const worktree = await git2(repoDir, ["rev-parse", "--show-toplevel"]);
+  if (!worktree)
+    return null;
+  const origin = await git2(worktree, ["remote", "get-url", "origin"]);
+  if (origin) {
+    const id = gitRemoteProjectId(origin);
+    if (id)
+      return id;
+  }
+  const commonDir = await git2(repoDir, ["rev-parse", "--path-format=absolute", "--git-common-dir"]);
+  if (commonDir) {
+    try {
+      const cached = (await readFile(path.join(commonDir, "opencode"), "utf-8")).trim();
+      if (cached)
+        return cached;
+    } catch {}
+  }
+  const rootsOutput = await git2(worktree, ["rev-list", "--max-parents=0", "HEAD"]);
+  if (rootsOutput) {
+    const root = rootsOutput.split(`
+`).map((line) => line.trim()).filter(Boolean).sort()[0];
+    if (root)
+      return root;
+  }
+  return null;
 }
 
 // src/mirror.ts
 var HARDCODED_EXCLUDES = ["node_modules", "dist", ".next", ".venv", "__pycache__", ".turbo", ".DS_Store", "._*"];
 var PART_RETRIES = 3;
 var PART_BACKOFF_MS = [500, 2000, 8000];
+var MIRROR_GZIP = true;
 function getGitignoreExclusions(repoRoot) {
   const res = spawnSync3("git", ["ls-files", "--others", "--ignored", "--exclude-standard", "--directory"], {
     cwd: repoRoot,
@@ -253,44 +450,20 @@ function getGitignoreExclusions(repoRoot) {
 `).filter((line) => line.length > 0);
 }
 async function carryOverIgnored(fromDir, toDir) {
-  if (!existsSync2(fromDir))
+  if (!existsSync3(fromDir))
     return;
   for (const rel of getGitignoreExclusions(fromDir)) {
     const clean = rel.replace(/\/+$/, "");
     if (!clean)
       continue;
-    const src = join2(fromDir, clean);
-    const dest = join2(toDir, clean);
-    if (!existsSync2(src) || existsSync2(dest))
+    const src = join3(fromDir, clean);
+    const dest = join3(toDir, clean);
+    if (!existsSync3(src) || existsSync3(dest))
       continue;
     await fsp.mkdir(dirname2(dest), { recursive: true });
     await fsp.rename(src, dest).catch(() => {});
   }
 }
-function listIncludedFiles(repoRoot) {
-  const tracked = spawnSync3("git", ["ls-files", "-z"], { cwd: repoRoot, encoding: "utf-8" });
-  const untracked = spawnSync3("git", ["ls-files", "--others", "--exclude-standard", "-z"], { cwd: repoRoot, encoding: "utf-8" });
-  const split = (out) => (out ?? "").split("\x00").filter((p) => p.length > 0);
-  const all = [...split(tracked.stdout), ...split(untracked.stdout)];
-  return all.filter((p) => {
-    const top = p.split("/")[0] ?? p;
-    return !HARDCODED_EXCLUDES.includes(top);
-  });
-}
-function estimateTarSize(repoRoot) {
-  const files = listIncludedFiles(repoRoot);
-  let total = 0;
-  for (const rel of files) {
-    let size = 0;
-    try {
-      size = statSync(join2(repoRoot, rel)).size;
-    } catch {
-      continue;
-    }
-    total += 512 + Math.ceil(size / 512) * 512;
-  }
-  return total + 1024;
-}
 
 class MirrorAbort extends Error {
   constructor(message) {
@@ -298,15 +471,47 @@ class MirrorAbort extends Error {
     this.name = "MirrorAbort";
   }
 }
-function prepareMirror(cwd, remotes) {
+async function prepareMirror(cwd, remotes) {
   const repoRoot = getRepoRoot(cwd);
   if (!repoRoot)
     throw new MirrorAbort("not in a git repository");
-  const localOrigin = getOriginUrl(repoRoot);
-  if (!localOrigin)
-    throw new MirrorAbort("no origin URL found");
-  const matched = remotes.filter((r) => urlsEqual(localOrigin, r.originUrl));
-  return { repoRoot, localOrigin, matched };
+  const localProjectId = await resolveOpenCodeProjectId(repoRoot);
+  if (!localProjectId)
+    throw new MirrorAbort("could not resolve an OpenCode project id for this repository");
+  const matched = remotes.filter((r) => r.projectId && r.projectId === localProjectId);
+  return { repoRoot, localProjectId, matched };
+}
+async function checkPushDivergence(repoRoot, api, repoId) {
+  const info = await api.mirrorHead(repoId);
+  const { head: serverHead, branch: serverBranch, dirty: serverDirty } = info;
+  const localHead = getHeadSha(repoRoot);
+  if (!serverHead || serverHead === localHead) {
+    return { serverHead, serverBranch, serverDirty, diverged: false, lostCommits: 0 };
+  }
+  if (!hasCommit(repoRoot, serverHead)) {
+    return { serverHead, serverBranch, serverDirty, diverged: true, lostCommits: -1 };
+  }
+  if (localHead && isAncestor(repoRoot, serverHead, localHead)) {
+    return { serverHead, serverBranch, serverDirty, diverged: false, lostCommits: 0 };
+  }
+  const lostCommits = localHead ? countCommitsAhead(repoRoot, localHead, serverHead) : -1;
+  return { serverHead, serverBranch, serverDirty, diverged: true, lostCommits };
+}
+async function checkPullDivergence(repoRoot, api, repoId) {
+  const localHead = getHeadSha(repoRoot);
+  if (!localHead)
+    return { diverged: false, lostCommits: 0, serverHead: null };
+  const { contained } = await api.mirrorContains(repoId, localHead);
+  if (contained)
+    return { diverged: false, lostCommits: 0, serverHead: null };
+  let serverHead = null;
+  let lostCommits = -1;
+  try {
+    serverHead = (await api.mirrorHead(repoId)).head;
+    if (serverHead)
+      lostCommits = countCommitsAhead(repoRoot, serverHead, localHead);
+  } catch {}
+  return { diverged: true, lostCommits, serverHead };
 }
 function delay(ms) {
   return new Promise((resolve) => setTimeout(resolve, ms));
@@ -370,15 +575,16 @@ function createPartFlusher(api, repoId, uploadId, chunkSize) {
 async function mirrorUp(plan, opts) {
   const repoId = opts.create ? 0 : plan.matched[0].repoId;
   const begin = await opts.api.mirrorBegin(repoId, { force: opts.force, create: opts.create });
-  const totalBytes = estimateTarSize(plan.repoRoot);
   let bytesSent = 0;
   const tarArgs = ["-c", "-C", plan.repoRoot];
+  if (MIRROR_GZIP)
+    tarArgs.unshift("-z");
   for (const dir of HARDCODED_EXCLUDES)
     tarArgs.push("--exclude", dir);
   const ignoredPaths = getGitignoreExclusions(plan.repoRoot);
   let excludeFile = null;
   if (ignoredPaths.length > 0) {
-    excludeFile = join2(tmpdir(), `ocm-exclude-${Date.now()}-${Math.random().toString(36).slice(2)}.txt`);
+    excludeFile = join3(tmpdir2(), `ocm-exclude-${Date.now()}-${Math.random().toString(36).slice(2)}.txt`);
     await fsp.writeFile(excludeFile, ignoredPaths.join(`
 `));
     tarArgs.push("--exclude-from", excludeFile);
@@ -406,12 +612,12 @@ async function mirrorUp(plan, opts) {
     for await (const chunk of child.stdout) {
       await flusher.push(chunk);
       bytesSent += chunk.length;
-      opts.onProgress?.({ phase: "uploading", bytesSent, totalBytes });
+      opts.onProgress?.({ bytesSent });
     }
     await tarExit;
     const totalParts = await flusher.finish();
-    opts.onProgress?.({ phase: "committing", bytesSent, totalBytes });
-    const result = await opts.api.mirrorCommit(begin.repoId, begin.uploadId, totalParts);
+    opts.onProgress?.({ bytesSent });
+    const result = await opts.api.mirrorCommit(begin.repoId, begin.uploadId, totalParts, MIRROR_GZIP);
     return result;
   } catch (err) {
     if (!child.killed)
@@ -431,8 +637,11 @@ async function mirrorDown(repoId, repoRoot, api, opts = { force: false }) {
   const staging = `${repoRoot}.ocm-recv-${Date.now()}`;
   await fsp.mkdir(staging, { recursive: true });
   try {
-    const tarball = await api.mirrorDown(repoId);
-    const child = spawn("tar", ["-x", "-f", "-", "-C", staging], { stdio: ["pipe", "pipe", "pipe"] });
+    const tarball = await api.mirrorDown(repoId, MIRROR_GZIP);
+    const tarArgs = ["-x", "-f", "-", "-C", staging];
+    if (MIRROR_GZIP)
+      tarArgs.unshift("-z");
+    const child = spawn("tar", tarArgs, { stdio: ["pipe", "pipe", "pipe"] });
     const stderrChunks = [];
     child.stderr.on("data", (chunk) => stderrChunks.push(chunk));
     const tarDone = new Promise((resolve, reject) => {
@@ -446,7 +655,7 @@ async function mirrorDown(repoId, repoRoot, api, opts = { force: false }) {
       });
       child.on("error", reject);
     });
-    const stdinWritable = Readable.fromWeb(tarball);
+    const stdinWritable = Readable2.fromWeb(tarball);
     let received = 0;
     stdinWritable.on("data", (chunk) => {
       received += chunk.length;
@@ -456,16 +665,16 @@ async function mirrorDown(repoId, repoRoot, api, opts = { force: false }) {
     await tarDone;
     const backupDir = `${repoRoot}.ocm-backup-${Date.now()}`;
     await fsp.mkdir(backupDir, { recursive: true });
-    if (existsSync2(repoRoot)) {
+    if (existsSync3(repoRoot)) {
       const entries = await fsp.readdir(repoRoot);
       for (const entry of entries) {
-        await fsp.rename(join2(repoRoot, entry), join2(backupDir, entry));
+        await fsp.rename(join3(repoRoot, entry), join3(backupDir, entry));
       }
     }
     try {
       const stagingEntries = await fsp.readdir(staging);
       for (const entry of stagingEntries) {
-        await fsp.rename(join2(staging, entry), join2(repoRoot, entry));
+        await fsp.rename(join3(staging, entry), join3(repoRoot, entry));
       }
       await carryOverIgnored(backupDir, repoRoot);
       await fsp.rm(backupDir, { recursive: true, force: true }).catch(() => {});
@@ -473,7 +682,7 @@ async function mirrorDown(repoId, repoRoot, api, opts = { force: false }) {
     } catch (swapError) {
       const backupEntries = await fsp.readdir(backupDir).catch(() => []);
       for (const entry of backupEntries) {
-        await fsp.rename(join2(backupDir, entry), join2(repoRoot, entry)).catch(() => {});
+        await fsp.rename(join3(backupDir, entry), join3(repoRoot, entry)).catch(() => {});
       }
       await fsp.rm(backupDir, { recursive: true, force: true }).catch(() => {});
       throw swapError;
@@ -483,6 +692,97 @@ async function mirrorDown(repoId, repoRoot, api, opts = { force: false }) {
     throw error;
   }
 }
+async function mirrorUpPatch(plan, opts) {
+  const repoId = plan.matched[0].repoId;
+  const patch = getMirrorPatch(plan.repoRoot);
+  return opts.api.mirrorPatch(repoId, { baseHead: getHeadSha(plan.repoRoot), patch, force: opts.force });
+}
+function applyPatch(repoRoot, patch) {
+  if (!patch)
+    return;
+  const child = spawnSync3("git", ["apply", "--binary", "--whitespace=nowarn", "-"], {
+    cwd: repoRoot,
+    input: patch,
+    encoding: "utf-8"
+  });
+  if (child.status !== 0) {
+    const stderr = (child.stderr ?? "").trim();
+    throw new Error(`git apply failed${stderr ? `: ${stderr}` : ""}`);
+  }
+}
+async function createLocalBundle(repoRoot) {
+  const bundlePath = join3(tmpdir2(), `ocm-bundle-${Date.now()}-${Math.random().toString(36).slice(2)}.bundle`);
+  runGit(repoRoot, ["bundle", "create", bundlePath, "--all"]);
+  return bundlePath;
+}
+function importLocalBundle(repoRoot, bundlePath, branch) {
+  runGit(repoRoot, ["fetch", bundlePath, "+refs/heads/*:refs/remotes/ocm-sync/*", "+refs/tags/*:refs/tags/*"]);
+  const refs = runGit(repoRoot, ["for-each-ref", "--format=%(refname:strip=3) %(objectname)", "refs/remotes/ocm-sync"]);
+  const updates = [];
+  for (const line of refs.split(`
+`)) {
+    const trimmed = line.trim();
+    if (!trimmed)
+      continue;
+    const firstSpace = trimmed.indexOf(" ");
+    if (firstSpace === -1)
+      continue;
+    const name = trimmed.slice(0, firstSpace);
+    if (name === "HEAD")
+      continue;
+    const sha = trimmed.slice(firstSpace + 1);
+    updates.push(`update refs/heads/${name} ${sha}
+`);
+  }
+  if (updates.length > 0) {
+    runGit(repoRoot, ["update-ref", "--stdin"], updates.join(""));
+  }
+  if (branch) {
+    runGit(repoRoot, ["checkout", branch]);
+    const head = runGit(repoRoot, ["rev-parse", `refs/remotes/ocm-sync/${branch}`]).trim();
+    if (head)
+      runGit(repoRoot, ["reset", "--hard", head]);
+  }
+  try {
+    const syncRefsOut = runGit(repoRoot, ["for-each-ref", "--format=%(refname)", "refs/remotes/ocm-sync"]);
+    const deletes = syncRefsOut.split(`
+`).map((l) => l.trim()).filter(Boolean).map((ref) => `delete ${ref}
+`);
+    if (deletes.length > 0) {
+      runGit(repoRoot, ["update-ref", "--stdin"], deletes.join(""));
+    }
+  } catch {}
+}
+async function writeBundleStream(repoId, api) {
+  const bundlePath = join3(tmpdir2(), `ocm-bundle-down-${Date.now()}-${Math.random().toString(36).slice(2)}.bundle`);
+  const stream = await api.mirrorDownloadBundle(repoId);
+  await pipeline(Readable2.fromWeb(stream), createWriteStream(bundlePath));
+  return bundlePath;
+}
+async function mirrorUpFast(plan, opts) {
+  const repoId = plan.matched[0].repoId;
+  const bundlePath = await createLocalBundle(plan.repoRoot);
+  try {
+    await opts.api.mirrorUploadBundle(repoId, bundlePath, { branch: getBranchName(plan.repoRoot), force: opts.force });
+    const patchResult = await mirrorUpPatch(plan, opts);
+    return { repoId: patchResult.repoId, branch: patchResult.branch, head: patchResult.head, created: false };
+  } finally {
+    await fsp.rm(bundlePath, { force: true }).catch(() => {});
+  }
+}
+async function mirrorDownFast(repoId, repoRoot, api, opts = { force: false }) {
+  if (!opts.force && getDirtyPaths(repoRoot).size > 0) {
+    throw new MirrorAbort("working tree has uncommitted changes; rerun with --force");
+  }
+  const snapshot = await api.mirrorPatchSnapshot(repoId);
+  const bundlePath = await writeBundleStream(repoId, api);
+  try {
+    importLocalBundle(repoRoot, bundlePath, snapshot.branch);
+    applyPatch(repoRoot, snapshot.patch);
+  } finally {
+    await fsp.rm(bundlePath, { force: true }).catch(() => {});
+  }
+}
 
 // src/progress.ts
 var FRAMES = ["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"];
@@ -501,31 +801,10 @@ function formatBytes(bytes) {
 function createProgressReporter(label, out = process.stderr, now = Date.now) {
   let finished = false;
   let lastRenderAt = -Infinity;
-  let lastBucket = -1;
   let lastNonTtyTickAt = -Infinity;
   let frameIndex = 0;
   const isTTY = out.isTTY === true;
   return {
-    update(current, total) {
-      if (finished)
-        return;
-      if (isTTY) {
-        const t = now();
-        if (t - lastRenderAt < 80)
-          return;
-        lastRenderAt = t;
-        const pct = total > 0 ? Math.min(99, Math.floor(current / total * 100)) : 0;
-        out.write(`\r\x1B[K${label}: ${pct}% (${formatBytes(current)} / ${formatBytes(total)})`);
-      } else {
-        const pct = total > 0 ? Math.min(99, Math.floor(current / total * 100)) : 0;
-        const bucket = Math.floor(pct / 10);
-        if (bucket === lastBucket)
-          return;
-        lastBucket = bucket;
-        out.write(`${label}: ${pct}% (${formatBytes(current)} / ${formatBytes(total)})
-`);
-      }
-    },
     tick(bytes) {
       if (finished)
         return;
@@ -558,14 +837,15 @@ function createProgressReporter(label, out = process.stderr, now = Date.now) {
 // src/resolve-target.ts
 function resolveTarget(input) {
   const repoRoot = getRepoRoot(input.cwd);
-  const localOrigin = repoRoot ? getOriginUrl(repoRoot) : null;
-  if (repoRoot && localOrigin) {
-    const matches = input.repos.filter((r) => urlsEqual(localOrigin, r.originUrl));
-    if (matches.length === 1) {
-      return { kind: "cwd-match", repo: matches[0], repoRoot };
-    }
-    if (matches.length > 1) {
-      return { kind: "cwd-ambiguous", matches, localOrigin, repoRoot };
+  if (repoRoot) {
+    if (input.localProjectId) {
+      const matches = input.repos.filter((r) => r.projectId && r.projectId === input.localProjectId);
+      if (matches.length === 1) {
+        return { kind: "cwd-match", repo: matches[0], repoRoot };
+      }
+      if (matches.length > 1) {
+        return { kind: "cwd-ambiguous", matches, localProjectId: input.localProjectId, repoRoot };
+      }
     }
     return { kind: "local", reason: "no-match", repoRoot };
   }
@@ -585,7 +865,7 @@ function toTarget(last) {
 // package.json
 var package_default = {
   name: "@opencode-manager/ocm-cli",
-  version: "0.1.3",
+  version: "0.2.0",
   description: "OpenCode Manager CLI: attach a local OpenCode TUI to a Manager-hosted repo.",
   license: "MIT",
   repository: {
@@ -611,21 +891,27 @@ var package_default = {
     build: "bun scripts/build.ts",
     postinstall: "node scripts/postinstall.mjs || true",
     typecheck: "tsc --noEmit",
+    lint: "eslint . --ext .ts",
+    "lint:fix": "eslint . --ext .ts --fix",
     test: "bun scripts/build.ts && vitest run",
     "test:watch": "vitest",
     prepublishOnly: "bun scripts/build.ts"
   },
   dependencies: {},
   devDependencies: {
+    "@eslint/js": "^9.36.0",
+    "@opencode-manager/shared": "workspace:*",
     "@types/node": "^22.0.0",
+    eslint: "^9.39.1",
     typescript: "^5.5.0",
+    "typescript-eslint": "^8.45.0",
     vitest: "^3.1.0"
   }
 };
 
 // bin/ocm.ts
 var VERSION = package_default.version;
-var USAGE = `ocm - OpenCode Manager workspace launcher
+var USAGE = `ocm v${VERSION} - OpenCode Manager workspace launcher
 
 Usage:
   ocm                       Attach to the Manager repo matching $PWD's git origin,
@@ -636,8 +922,8 @@ Usage:
   ocm status                Show current manager URL, repo, and whether token is set
   ocm list                  List ready repos from the manager
   ocm use <repoId|name>     Attach to a specific repo and remember it as last
-  ocm push [--force] [--create] [--yes]   Mirror $PWD to the matching Manager repo (or create one)
-  ocm pull [--force]                      Mirror the matching Manager repo over $PWD
+  ocm push [--force] [--create] [--yes] [--full]   Mirror $PWD to the matching Manager repo (fast patch sync by default)
+  ocm pull [--force] [--full]                      Mirror the matching Manager repo over $PWD (fast patch sync by default)
   ocm --version             Show the installed ocm version
   ocm --help                Show this help
 `;
@@ -650,6 +936,52 @@ function info(msg) {
   process.stdout.write(`${msg}
 `);
 }
+function promptYesNo(question) {
+  process.stderr.write(`${question} [y/N] `);
+  const res = spawnSync4("bash", ["-c", 'read LINE && printf "%s" "$LINE"'], {
+    stdio: ["inherit", "pipe", "inherit"],
+    encoding: "utf-8"
+  });
+  const answer = (res.stdout ?? "").trim().toLowerCase();
+  return answer === "y" || answer === "yes";
+}
+function confirmFullFallback() {
+  if (!process.stdin.isTTY)
+    return;
+  if (!promptYesNo("Fall back to a full mirror? This replaces the entire server working tree (no merge, no conflict resolution).")) {
+    die("aborted");
+  }
+}
+function confirmOverwrite(headline, reasons, question, note) {
+  process.stderr.write(`ocm: warning: ${headline}
+`);
+  for (const reason of reasons)
+    process.stderr.write(`  - ${reason}
+`);
+  if (note)
+    process.stderr.write(`  ${note}
+`);
+  if (!process.stdin.isTTY) {
+    die("refusing to discard work; re-run with --force to override");
+  }
+  if (!promptYesNo(question)) {
+    die("aborted");
+  }
+  return true;
+}
+function guardDivergentPush(repoName, div) {
+  const reasons = [];
+  if (div.diverged) {
+    reasons.push(div.lostCommits >= 0 ? `the server is ${div.lostCommits} commit(s) ahead of your local branch` : "the server has commit(s) not present in your local branch");
+  }
+  if (div.serverDirty)
+    reasons.push("the server has uncommitted changes");
+  return confirmOverwrite(`pushing to ${repoName} will discard server-side work:`, reasons, "Overwrite server-side work and push anyway?", "This work is likely from OpenCode agent sessions on the manager.");
+}
+function guardDivergentPull(repoName, div) {
+  const reasons = [div.lostCommits >= 0 ? `your local branch is ${div.lostCommits} commit(s) ahead of ${repoName}` : `your local branch has commit(s) not present on ${repoName}`];
+  return confirmOverwrite(`pulling ${repoName} will discard local commits:`, reasons, "Discard local commits and pull anyway?");
+}
 function requireState() {
   const state = readState();
   if (!state || !state.managerUrl) {
@@ -810,6 +1142,7 @@ async function cmdUse(args) {
   attach(state.managerUrl, token, repo);
 }
 async function cmdDefault() {
+  info(`ocm v${VERSION}`);
   const state = requireState();
   const token = requireToken(state);
   const last = state.lastRepoId !== undefined && state.lastRepoDir ? {
@@ -818,12 +1151,14 @@ async function cmdDefault() {
     directory: state.lastRepoDir,
     branch: state.lastRepoBranch ?? null
   } : undefined;
+  info("connecting...");
   const repos = await fetchRepos(state.managerUrl, token);
-  const result = resolveTarget({ cwd: process.cwd(), repos, last });
+  const localProjectId = await resolveOpenCodeProjectId(process.cwd());
+  const result = resolveTarget({ cwd: process.cwd(), repos, localProjectId, last });
   switch (result.kind) {
     case "cwd-match": {
       const repo = result.repo;
-      info(`attaching to ${repo.name} (matched $PWD origin)`);
+      info(`attaching to ${repo.name}`);
       writeState({
         ...state,
         lastRepoId: repo.repoId,
@@ -834,12 +1169,16 @@ async function cmdDefault() {
       attach(state.managerUrl, token, toManagerRepo(repo));
       return;
     }
-    case "last":
-      attach(state.managerUrl, token, toManagerRepo(result.repo));
+    case "last": {
+      const repo = result.repo;
+      info(`attaching to ${repo.name} (last used)`);
+      attach(state.managerUrl, token, toManagerRepo(repo));
       return;
+    }
     case "cwd-ambiguous": {
       const names = result.matches.map((r) => `${r.name} (id=${r.repoId})`).join(", ");
-      die(`multiple Manager repos match origin ${result.localOrigin}: ${names}; disambiguate with \`ocm use <repoId>\``);
+      die(`multiple Manager repos match project ${result.localProjectId}: ${names}; disambiguate with \`ocm use <repoId>\``);
+      break;
     }
     case "local":
       runLocalOpencode(result.reason);
@@ -869,6 +1208,7 @@ async function cmdPush(args) {
   let force = false;
   let create = false;
   let yes = false;
+  let full = false;
   for (const arg of args) {
     if (arg === "--force")
       force = true;
@@ -876,68 +1216,87 @@ async function cmdPush(args) {
       create = true;
     else if (arg === "--yes")
       yes = true;
+    else if (arg === "--full")
+      full = true;
   }
   const state = requireState();
   const token = requireToken(state);
   const api = new ManagerApi(state.managerUrl, token);
   const repos = await fetchRepos(state.managerUrl, token);
-  const progress = createProgressReporter("push");
-  const onProgress = (p) => {
-    if (p.phase === "committing")
-      progress.tick(p.bytesSent);
-    else if (p.totalBytes > 0)
-      progress.update(p.bytesSent, p.totalBytes);
-    else
-      progress.tick(p.bytesSent);
-  };
   const remotes = repos.map((r) => ({
     repoId: r.repoId,
     name: r.name,
-    originUrl: r.originUrl ?? null,
+    projectId: r.projectId ?? null,
     branch: r.branch
   }));
-  const plan = prepareMirror(process.cwd(), remotes);
+  const plan = await prepareMirror(process.cwd(), remotes);
   if (plan.matched.length === 0) {
     if (!create) {
-      die(`no matching Manager repo for origin ${plan.localOrigin}. Re-run with --create to create one.`);
+      die(`no matching Manager repo for project ${plan.localProjectId}. Re-run with --create to create one.`);
     }
     const name = basename(plan.repoRoot);
     const branch = getBranchName(plan.repoRoot);
+    const originUrl = getOriginUrl(plan.repoRoot);
     if (process.stdin.isTTY && !yes) {
-      process.stderr.write(`Create Manager repo "${name}" by uploading ${plan.repoRoot} (origin: ${plan.localOrigin})? [y/N] `);
-      const res = spawnSync4("bash", ["-c", 'read LINE && printf "%s" "$LINE"'], {
-        stdio: ["inherit", "pipe", "inherit"],
-        encoding: "utf-8"
-      });
-      const answer = (res.stdout ?? "").trim().toLowerCase();
-      if (answer !== "y" && answer !== "yes") {
+      if (!promptYesNo(`Create Manager repo "${name}" by uploading ${plan.repoRoot} (project: ${plan.localProjectId})?`)) {
         die("aborted");
       }
     } else if (!process.stdin.isTTY && !yes) {
       die("stdin is not a TTY; pass --yes to confirm creation");
     }
+    const progress = createProgressReporter("push");
+    const onProgress = (p) => progress.tick(p.bytesSent);
     const result = await mirrorUp(plan, {
       api,
       force,
-      create: { name, originUrl: plan.localOrigin, branch },
+      create: { name, originUrl, branch },
       onProgress
     });
     progress.done();
     info(`pushed ${plan.repoRoot} -> ${result.created ? "created" : "updated"} (repoId=${result.repoId}, branch=${result.branch})`);
   } else if (plan.matched.length === 1) {
+    if (!force) {
+      try {
+        const divergence = await checkPushDivergence(plan.repoRoot, api, plan.matched[0].repoId);
+        if (divergence.diverged || divergence.serverDirty) {
+          force = guardDivergentPush(plan.matched[0].name, divergence);
+        }
+      } catch (error) {
+        if (!(error instanceof ManagerApiError && error.status === 404))
+          throw error;
+      }
+    }
+    if (!full) {
+      try {
+        const result2 = await mirrorUpFast(plan, { api, force });
+        info(`pushed ${plan.repoRoot} -> ${plan.matched[0].name} via bundle (repoId=${result2.repoId}, branch=${result2.branch})`);
+        return;
+      } catch (error) {
+        if (error instanceof MirrorAbort)
+          throw error;
+        process.stderr.write(`ocm: patch push failed: ${error instanceof Error ? error.message : String(error)}
+`);
+        confirmFullFallback();
+      }
+    }
+    const progress = createProgressReporter("push");
+    const onProgress = (p) => progress.tick(p.bytesSent);
     const result = await mirrorUp(plan, { api, force, onProgress });
     progress.done();
     info(`pushed ${plan.repoRoot} -> ${plan.matched[0].name} (repoId=${result.repoId}, branch=${result.branch})`);
   } else {
     const names = plan.matched.map((r) => `${r.name} (id=${r.repoId})`).join(", ");
-    die(`multiple Manager repos match origin ${plan.localOrigin}: ${names}; disambiguate with \`ocm push <repoId>\``);
+    die(`multiple Manager repos match project ${plan.localProjectId}: ${names}; disambiguate with \`ocm push <repoId>\``);
   }
 }
 async function cmdPull(args) {
   let force = false;
+  let full = false;
   for (const arg of args) {
     if (arg === "--force")
       force = true;
+    else if (arg === "--full")
+      full = true;
   }
   const state = requireState();
   const token = requireToken(state);
@@ -946,16 +1305,40 @@ async function cmdPull(args) {
   const remotes = repos.map((r) => ({
     repoId: r.repoId,
     name: r.name,
-    originUrl: r.originUrl ?? null,
+    projectId: r.projectId ?? null,
     branch: r.branch
   }));
-  const plan = prepareMirror(process.cwd(), remotes);
+  const plan = await prepareMirror(process.cwd(), remotes);
   if (plan.matched.length === 0) {
-    die(`no matching Manager repo for origin ${plan.localOrigin}.`);
+    die(`no matching Manager repo for project ${plan.localProjectId}.`);
   }
   if (plan.matched.length > 1) {
     const names = plan.matched.map((r) => `${r.name} (id=${r.repoId})`).join(", ");
-    die(`multiple Manager repos match origin ${plan.localOrigin}: ${names}; disambiguate with \`ocm pull <repoId>\``);
+    die(`multiple Manager repos match project ${plan.localProjectId}: ${names}; disambiguate with \`ocm pull <repoId>\``);
+  }
+  if (!force) {
+    try {
+      const divergence = await checkPullDivergence(plan.repoRoot, api, plan.matched[0].repoId);
+      if (divergence.diverged) {
+        force = guardDivergentPull(plan.matched[0].name, divergence);
+      }
+    } catch (error) {
+      if (!(error instanceof ManagerApiError && error.status === 404))
+        throw error;
+    }
+  }
+  if (!full) {
+    try {
+      await mirrorDownFast(plan.matched[0].repoId, plan.repoRoot, api, { force });
+      info(`pulled ${plan.matched[0].name} -> ${plan.repoRoot} via bundle`);
+      return;
+    } catch (error) {
+      if (error instanceof MirrorAbort && !error.message.includes("falling back"))
+        throw error;
+      process.stderr.write(`ocm: patch pull failed: ${error instanceof Error ? error.message : String(error)}
+`);
+      confirmFullFallback();
+    }
   }
   const progress = createProgressReporter("pull");
   try {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@opencode-manager/ocm-cli",
-  "version": "0.1.3",
+  "version": "0.2.0",
   "description": "OpenCode Manager CLI: attach a local OpenCode TUI to a Manager-hosted repo.",
   "license": "MIT",
   "repository": {
@@ -24,14 +24,20 @@
   ],
   "dependencies": {},
   "devDependencies": {
+    "@eslint/js": "^9.36.0",
     "@types/node": "^22.0.0",
+    "eslint": "^9.39.1",
     "typescript": "^5.5.0",
-    "vitest": "^3.1.0"
+    "typescript-eslint": "^8.45.0",
+    "vitest": "^3.1.0",
+    "@opencode-manager/shared": "1.0.0"
   },
   "scripts": {
     "build": "bun scripts/build.ts",
     "postinstall": "node scripts/postinstall.mjs || true",
     "typecheck": "tsc --noEmit",
+    "lint": "eslint . --ext .ts",
+    "lint:fix": "eslint . --ext .ts --fix",
     "test": "bun scripts/build.ts && vitest run",
     "test:watch": "vitest"
   }