@teammy/cli 0.1.1 → 0.1.3

package/README.md

@@ -2,27 +2,27 @@
 
 成员设备上的命令行客户端，需要 Node.js 22.13+，推荐 Node.js 24。
 
-0.1.1 与服务端版本保持一致，沿用 0.1.0 的完整目录发布、后台升级修复、Hook 清理与 Agent 采集能力。
+0.1.2 支持通过网页确认连接身份，并在确认后接管已有 workspaces 目录；保留后台同步、升级修复和 Hook 采集能力。
 
 客户端与服务端保持配套版本，支持多项目后台同步、根 README / `_template/` 公共资料分发，以及 `workspaces/.teammy-local.json` 中的 `files.ignore` 忽略规则。规则相对本人目录，下一轮检查生效，不删除已共享历史。公共资料由项目设置指定的一位成员维护。自动任务整理在服务端运行。
 
 ```sh
-npm install -g @teammy/cli@0.1.1
+npm install -g @teammy/cli@0.1.2
 ```
 
 ```sh
-teammy connect --url http://teammy.internal:14317 --project PROJECT_ID --member alice
+teammy connect --url http://teammy.internal:14317 --project PROJECT_ID
 teammy status
 teammy sync off
 teammy sync on
 teammy logs
 ```
 
-在项目目录执行 connect，创建 `./workspaces` 和本人 ID 子目录、维护 `.gitignore`，自动在后台下载同事资料并上传本人文件。命令退出后可以关闭终端；已开启的项目在下次登录系统时恢复，手动 off 的项目保持停止。日常使用不需要重复 connect。
+在项目目录执行 connect，创建 `./workspaces` 和本人 ID 子目录、维护 `.gitignore`，自动在后台下载同事资料并上传本人文件。若仓库已有未绑定的 `workspaces/`，会显示本地和远端版本日期，默认回车确认后完整下载服务端资料并替换当前目录（含本人目录），再开始同步；输入 `n` 取消，脚本可显式使用 `--yes`。已被 Git 追踪的文件允许接入，不自动修改 Git 索引。命令退出后可以关闭终端；已开启的项目在下次登录系统时恢复，手动 off 的项目保持停止。日常使用不需要重复 connect。
 
-已有同名目录、文件或符号链接时拒绝接入；不自动合并已有资料。Git 已追踪该路径时也会拒绝，不修改 Git 索引。可以先自行改名保存旧目录，接入成功后将本人的文件复制到 `workspaces/<ID>/`。
+默认打开网页确认用户 ID；无桌面的开发机可复制终端链接，在自己的电脑上完成确认，不需要 SSH 隧道或本地回调端口。脚本继续使用 `--member caffei`，旧服务端也可沿用该参数。浏览器确认使用现有账号和项目成员关系，不自动创建用户或加入项目。
 
-本人本地文件是发布来源，服务器旧正文不会下载到本人目录。首次本地缺失的历史文件保留在服务器，不推断为删除；确认曾在本地存在的文件，之后删除并完成稳定等待才传播。其他成员目录只接收，不反向发布，本地误改会保留并报告。
+常规新建目录接入及日常同步中，本人本地文件是发布来源，服务器旧正文不会下载覆盖；上述已有 checkout 的确认替换流程是例外。首次本地缺失的历史文件保留在服务器，不推断为删除；确认曾在本地存在的文件，之后删除并完成稳定等待才传播。其他成员目录只接收，不反向发布，本地误改会保留并报告。
 
 默认约一分钟检查一次，文件变化连续一分钟稳定后准备完整目录版本；内容可分批传输，完整版本发布后才对外可见并触发任务整理。首次下载立即开始，大批量接收自动续批。周期由全站网页设置热更新。项目会话通过 hook 及后台补扫自动登记、提取并上传；只采集属于当前项目目录的会话，不自动扩展到 monorepo 上层其他会话。已有接入可通过 `sync on` 安装本项目 hook。
 
@@ -43,7 +43,7 @@ macOS 使用用户 LaunchAgent，Linux 使用 systemd 用户服务；不安装
 本次文件发布协议依赖服务端 `atomic-file-publications` 能力，两端需配套更新。以下维护命令从 0.1.0 提供，先安装新版，再执行修复：
 
 ```sh
-npm install -g @teammy/cli@0.1.1
+npm install -g @teammy/cli@0.1.2
 teammy repair
 ```
 

package/dist/main.js

@@ -286,7 +286,7 @@ var SessionSearchSchema = z5.object({
 });
 
 // packages/transport/hub-client.ts
-import { z as z8 } from "zod";
+import { z as z9 } from "zod";
 import { createHash } from "node:crypto";
 
 // packages/protocol/index.ts
@@ -331,6 +331,28 @@ function sharedPathAllowed(path, paths) {
   );
 }
 
+// packages/protocol/client-access.ts
+import { z as z8 } from "zod";
+var ConnectSecretSchema = z8.string().regex(/^[a-f0-9]{64}$/);
+var BrowserConnectRequestSchema = z8.object({
+  id: z8.uuid(),
+  projectId: NameSchema,
+  deviceId: DeviceIdSchema,
+  secret: ConnectSecretSchema,
+  label: z8.string().min(1).max(255)
+}).strict();
+var BrowserConnectStartSchema = z8.object({ id: z8.uuid(), expiresAt: z8.number() });
+var BrowserConnectPollSchema = z8.discriminatedUnion("state", [
+  z8.object({ state: z8.literal("pending") }),
+  z8.object({ state: z8.literal("approved"), memberId: NameSchema })
+]);
+var BrowserConnectInfoSchema = z8.object({
+  projectName: z8.string(),
+  label: z8.string(),
+  approvedBy: NameSchema.nullable(),
+  expiresAt: z8.number()
+});
+
 // packages/transport/hub-client.ts
 var HubRequestError = class extends Error {
   constructor(message2, status, code, requestId) {
@@ -371,6 +393,17 @@ var HubClient = class {
   get url() {
     return this.baseUrl.toString();
   }
+  startBrowserConnect(input) {
+    return this.request("POST", "api/v1/devices/connect", BrowserConnectStartSchema, input);
+  }
+  pollBrowserConnect(id, secret) {
+    return this.request(
+      "POST",
+      `api/v1/devices/connect/${encodeURIComponent(id)}/poll`,
+      BrowserConnectPollSchema,
+      { secret }
+    );
+  }
   bind(deviceId, projectId) {
     return this.request("POST", "api/v1/bind", BindingSchema, {
       deviceId,
@@ -401,7 +434,7 @@ var HubClient = class {
       void 0,
       BLOB_TRANSFER_TIMEOUT_MS
     );
-    if (!response.ok) return this.decode(response, signal, z8.never());
+    if (!response.ok) return this.decode(response, signal, z9.never());
     const reader = response.body?.getReader();
     if (!reader) throw new Error("Server returned no content body.");
     const parts = [];
@@ -446,7 +479,7 @@ var HubClient = class {
     return this.request(
       "PUT",
       "api/v1/devices/self/status",
-      z8.object({ ok: z8.literal(true) }),
+      z9.object({ ok: z9.literal(true) }),
       status
     );
   }
@@ -571,11 +604,11 @@ import { dirname as dirname9, join as join17, resolve as resolve8 } from "node:p
 import { parseArgs as parseArgs2 } from "node:util";
 
 // packages/protocol/file-publication.ts
-import { z as z9 } from "zod";
+import { z as z10 } from "zod";
 var FilePublicationSchema = FileCommitSchema.safeExtend({
   configRevision: RevisionSchema.optional()
 }).strict();
-var PublishFilesSchema = z9.object({ manifest: BlobRefSchema }).strict();
+var PublishFilesSchema = z10.object({ manifest: BlobRefSchema }).strict();
 
 // packages/state/sqlite.ts
 import { chmodSync, mkdirSync } from "node:fs";
@@ -952,7 +985,7 @@ var RuntimeState = class {
 // apps/client/state.ts
 import { randomUUID as randomUUID4 } from "node:crypto";
 import { join as join7, relative as relative2, isAbsolute, sep as sep2 } from "node:path";
-import { z as z12 } from "zod";
+import { z as z13 } from "zod";
 import { DatabaseSync as DatabaseSync3 } from "node:sqlite";
 
 // apps/client/runtime/state-access.ts
@@ -1066,7 +1099,7 @@ import { setImmediate } from "node:timers/promises";
 import { constants } from "node:fs";
 import { open, writeFile } from "node:fs/promises";
 import { join as join3 } from "node:path";
-import { z as z10 } from "zod";
+import { z as z11 } from "zod";
 import ignore from "ignore";
 function ignored(path) {
   return path.split("/").some(
@@ -1077,8 +1110,8 @@ function missing(error) {
   return error instanceof Error && "code" in error && ["ENOENT", "ENOTDIR"].includes(String(error.code));
 }
 var LOCAL_CONFIG_NAME = ".teammy-local.json";
-var LocalConfigSchema = z10.object({
-  files: z10.object({ ignore: z10.array(z10.string().max(1024)).max(256).default([]) }).strict().default({ ignore: [] })
+var LocalConfigSchema = z11.object({
+  files: z11.object({ ignore: z11.array(z11.string().max(1024)).max(256).default([]) }).strict().default({ ignore: [] })
 }).strict();
 async function ensureLocalConfig(root) {
   try {
@@ -1321,9 +1354,8 @@ async function verifyWorkspace(state, root) {
       "Workspace directory was replaced. Restore the original directory before syncing."
     );
 }
-async function ignorePlan(root) {
+async function workspaceGitInfo(root) {
   const parent = dirname4(root), name2 = basename(root);
-  if (/[\r\n]/.test(name2)) throw new Error("Workspace name cannot contain a newline.");
   let repo = false;
   for (let p = parent; ; p = dirname4(p)) {
     try {
@@ -1335,19 +1367,30 @@ async function ignorePlan(root) {
     }
     if (p === dirname4(p)) break;
   }
-  if (repo) {
-    let tracked;
-    try {
-      tracked = (await exec("git", ["-C", parent, "--literal-pathspecs", "ls-files", "-z", "--", name2], {
-        maxBuffer: 1024 * 1024
-      })).stdout;
-    } catch {
-      throw new Error("Cannot inspect the Git index. Check Git access before connecting.");
-    }
-    if (tracked)
-      throw new Error(
-        "Git already tracks this workspace path. Remove it from the Git index yourself before connecting."
-      );
+  if (!repo) return { repo: false, tracked: false, date: null };
+  try {
+    const tracked = (await exec("git", ["-C", parent, "--literal-pathspecs", "ls-files", "-z", "--", name2], {
+      maxBuffer: 16 * 1024 * 1024
+    })).stdout;
+    const date = tracked ? await exec("git", [
+      "-C",
+      parent,
+      "--literal-pathspecs",
+      "log",
+      "-1",
+      "--format=%cI",
+      "--",
+      name2
+    ]).then((result2) => result2.stdout.trim() || null).catch(() => null) : null;
+    return { repo: true, tracked: Boolean(tracked), date };
+  } catch {
+    throw new Error("Cannot inspect the Git index. Check Git access before connecting.");
+  }
+}
+async function ignorePlan(root) {
+  const parent = dirname4(root), name2 = basename(root);
+  if (/[\r\n]/.test(name2)) throw new Error("Workspace name cannot contain a newline.");
+  if ((await workspaceGitInfo(root)).repo) {
     try {
       await exec("git", ["-C", parent, "check-ignore", "--no-index", "-q", "--", name2 + "/"]);
       return;
@@ -1391,12 +1434,16 @@ async function prepareWorkspace(state, root, input, reconnect = false) {
       if (ignore3) await replaceFile(ignore3.parent, ".gitignore", ignore3.bytes, ignore3.signature);
       return;
     }
-    throw new Error(
-      'Workspace path already exists. Choose another directory; for a connected workspace use "teammy sync on".'
-    );
+    if (prior || state.binding(root))
+      throw new Error(
+        'Workspace is already prepared. Use the original connect command or "teammy sync on".'
+      );
+    await directoryIdentity(root);
+    return true;
   }
   if (state.binding(root) || prior)
     throw new Error("Connected workspace is missing. Restore its directory before syncing.");
+  if ((await workspaceGitInfo(root)).tracked) return true;
   const ignore2 = await ignorePlan(root);
   await mkdir2(root);
   try {
@@ -1491,43 +1538,43 @@ var ClientLog = class {
 import { setTimeout as setTimeout2 } from "node:timers/promises";
 
 // packages/protocol/devices.ts
-import { z as z11 } from "zod";
-var CredentialSchema = z11.string().regex(/^tmy_[a-f0-9]{64}$/);
-var EnrollmentSchema = z11.object({
-  operationId: z11.uuid(),
+import { z as z12 } from "zod";
+var CredentialSchema = z12.string().regex(/^tmy_[a-f0-9]{64}$/);
+var EnrollmentSchema = z12.object({
+  operationId: z12.uuid(),
   projectId: NameSchema,
   memberId: NameSchema,
   deviceId: DeviceIdSchema,
   credential: CredentialSchema
 }).strict();
-var EffectivePolicySchema = z11.object({
-  checkIntervalSeconds: z11.number().min(1).max(86400),
-  fileSettleSeconds: z11.number().min(0).max(86400)
+var EffectivePolicySchema = z12.object({
+  checkIntervalSeconds: z12.number().min(1).max(86400),
+  fileSettleSeconds: z12.number().min(0).max(86400)
 }).strict();
-var SyncSummarySchema = z11.object({
-  checkedAt: z11.string(),
-  published: z11.boolean(),
-  appliedFiles: z11.number().int().nonnegative(),
-  pendingFiles: z11.number().int().nonnegative(),
-  sessionSources: z11.number().int().nonnegative(),
-  errors: z11.array(z11.string().max(1e3)).max(20)
+var SyncSummarySchema = z12.object({
+  checkedAt: z12.string(),
+  published: z12.boolean(),
+  appliedFiles: z12.number().int().nonnegative(),
+  pendingFiles: z12.number().int().nonnegative(),
+  sessionSources: z12.number().int().nonnegative(),
+  errors: z12.array(z12.string().max(1e3)).max(20)
 }).strict();
-var DeviceStatusSchema = z11.object({
-  clientVersion: z11.string().max(64),
+var DeviceStatusSchema = z12.object({
+  clientVersion: z12.string().max(64),
   receivedRevision: RevisionSchema.nullable(),
   appliedRevision: RevisionSchema.nullable(),
   effectivePolicy: EffectivePolicySchema,
-  overrides: z11.array(z11.enum(["checkIntervalSeconds", "fileSettleSeconds"])).max(2),
-  configError: z11.string().max(2e3).nullable(),
-  reportError: z11.string().max(2e3).nullable(),
+  overrides: z12.array(z12.enum(["checkIntervalSeconds", "fileSettleSeconds"])).max(2),
+  configError: z12.string().max(2e3).nullable(),
+  reportError: z12.string().max(2e3).nullable(),
   lastSync: SyncSummarySchema.nullable()
 }).strict();
-var WebDevicesSchema = z11.object({
-  devices: z11.array(
-    z11.object({
+var WebDevicesSchema = z12.object({
+  devices: z12.array(
+    z12.object({
       memberId: NameSchema,
-      bound: z11.boolean(),
-      lastSeenAt: z11.string().nullable(),
+      bound: z12.boolean(),
+      lastSeenAt: z12.string().nullable(),
       status: DeviceStatusSchema.nullable()
     })
   )
@@ -1928,9 +1975,9 @@ var SessionState = class {
 
 // apps/client/state.ts
 var LocalBindingSchema = BindingSchema.extend({
-  root: z12.string(),
-  serverUrl: z12.string(),
-  token: z12.string()
+  root: z13.string(),
+  serverUrl: z13.string(),
+  token: z13.string()
 });
 var clientMigrations = [
   String.raw`
@@ -1949,7 +1996,11 @@ var clientMigrations = [
   projectFilesClientMigration,
   sessionSourcesMigration,
   atomicFilesClientMigration,
-  sessionParserMigration
+  sessionParserMigration,
+  `CREATE TABLE client_workspace_replacements (
+    root TEXT PRIMARY KEY REFERENCES connections(root), directory TEXT NOT NULL,
+    original_identity TEXT, incoming_identity TEXT, committed INTEGER NOT NULL DEFAULT 0
+  );`
 ];
 var clientSchemaVersion = clientMigrations.length;
 var ClientState = class extends FilePublicationState {
@@ -2770,12 +2821,12 @@ import { join as join13 } from "node:path";
 import { createHash as createHash7, randomUUID as randomUUID5 } from "node:crypto";
 import { mkdir as mkdir6, open as open3, opendir, rename as rename2, unlink as unlink2 } from "node:fs/promises";
 import { isAbsolute as isAbsolute3, join as join12 } from "node:path";
-import { z as z13 } from "zod";
-var HintSchema = z13.object({
+import { z as z14 } from "zod";
+var HintSchema = z14.object({
   agent: AgentSchema,
-  path: z13.string().min(1).max(4096).refine(isAbsolute3).optional(),
-  nativeId: z13.string().min(1).max(512).optional(),
-  projectDir: z13.string().min(1).max(4096).refine(isAbsolute3)
+  path: z14.string().min(1).max(4096).refine(isAbsolute3).optional(),
+  nativeId: z14.string().min(1).max(512).optional(),
+  projectDir: z14.string().min(1).max(4096).refine(isAbsolute3)
 });
 function inbox(directory, root) {
   return join12(directory, "session-hints", createHash7("sha256").update(root).digest("hex"));
@@ -2924,10 +2975,10 @@ import { setTimeout as delay } from "node:timers/promises";
 import { createConnection } from "node:net";
 import { mkdir as mkdir7, lstat as lstat3, chmod } from "node:fs/promises";
 import { join as join14 } from "node:path";
-import { z as z14 } from "zod";
-var RequestSchema = z14.object({
-  method: z14.enum(["ping", "wake", "status", "once"]),
-  root: z14.string().max(4096).optional()
+import { z as z15 } from "zod";
+var RequestSchema = z15.object({
+  method: z15.enum(["ping", "wake", "status", "once"]),
+  root: z15.string().max(4096).optional()
 }).strict();
 function socketPath(directory) {
   return join14(
@@ -3370,8 +3421,8 @@ async function prepareClient(directory, version, options = {}, control = service
       else await rm2(maintenancePath(directory), { force: true });
       restart = !options.daemonStartup && !pauseReason && enabled > 0;
       if (backup) {
-        const { readdir: readdir3 } = await import("node:fs/promises");
-        for (const file of await readdir3(join16(directory, "backups"))) {
+        const { readdir: readdir4 } = await import("node:fs/promises");
+        for (const file of await readdir4(join16(directory, "backups"))) {
           if (/^before-schema-\d+\.sqlite3$/.test(file) && join16(directory, "backups", file) !== backup)
             await rm2(join16(directory, "backups", file));
         }
@@ -3550,21 +3601,193 @@ async function runSessionCommand(args, version) {
 
 // apps/client/sync-command.ts
 import { parseArgs as parseArgs4 } from "node:util";
-import { setTimeout as setTimeout4 } from "node:timers/promises";
+import { setTimeout as setTimeout5 } from "node:timers/promises";
 
 // apps/client/client-command.ts
 import { parseArgs as parseArgs3 } from "node:util";
-import { join as join18, resolve as resolve10 } from "node:path";
+import { join as join19, resolve as resolve10 } from "node:path";
 import { homedir as homedir5 } from "node:os";
 import { createInterface as createInterface2 } from "node:readline/promises";
 
 // apps/client/connection.ts
-import { readFile as readFile5, mkdir as mkdir10 } from "node:fs/promises";
+import { readFile as readFile5, mkdir as mkdir11 } from "node:fs/promises";
 import { createInterface } from "node:readline/promises";
+
+// apps/client/workspace-replacement.ts
+import { lstat as lstat4, mkdir as mkdir10, mkdtemp, readdir as readdir2, rename as rename5, rm as rm3 } from "node:fs/promises";
+import { dirname as dirname10, join as join18 } from "node:path";
+var ConnectionCancelled = class extends Error {
+  constructor() {
+    super("\u5DF2\u53D6\u6D88\u63A5\u5165\uFF0C\u539F\u5DE5\u4F5C\u533A\u672A\u6539\u52A8\u3002");
+  }
+};
+async function localSnapshot(root) {
+  const entries = [];
+  let date = 0;
+  try {
+    const identity = await directoryIdentity(root);
+    const pending = [""];
+    while (pending.length) {
+      const path = pending.pop();
+      const stat2 = await lstat4(join18(root, path), { bigint: true });
+      entries.push([path, signature(stat2)]);
+      if (stat2.isFile()) date = Math.max(date, Number(stat2.mtimeMs));
+      if (stat2.isDirectory() && !stat2.isSymbolicLink())
+        for (const name2 of await readdir2(join18(root, path))) pending.push(join18(path, name2));
+    }
+    entries.sort(([a], [b]) => a < b ? -1 : a > b ? 1 : 0);
+    return {
+      identity,
+      fingerprint: JSON.stringify(entries),
+      date: date ? new Date(date).toISOString() : null
+    };
+  } catch (error) {
+    if (entries.length === 0 && missing2(error))
+      return { identity: null, fingerprint: "", date: null };
+    throw error;
+  }
+}
+async function identityIfPresent(path) {
+  try {
+    return await directoryIdentity(path);
+  } catch (error) {
+    if (missing2(error)) return null;
+    throw error;
+  }
+}
+async function recoverWorkspaceReplacement(state, root) {
+  const row = state.db.prepare("SELECT * FROM client_workspace_replacements WHERE root=?").get(root);
+  if (!row) return;
+  const directory = String(row.directory);
+  const previous = join18(directory, "previous");
+  const currentIdentity = await identityIfPresent(root);
+  if (row.committed) {
+    if (currentIdentity !== row.incoming_identity)
+      throw new Error(
+        "Connected workspace was replaced. Preserve the recovery directory before retrying."
+      );
+  } else {
+    const previousIdentity = await identityIfPresent(previous);
+    if (previousIdentity) {
+      if (previousIdentity !== row.original_identity || currentIdentity && currentIdentity !== row.incoming_identity)
+        throw new Error(
+          "Workspace changed during recovery. Preserve both directories before retrying."
+        );
+      if (currentIdentity) await rm3(root, { recursive: true });
+      await rename5(previous, root);
+    } else if (currentIdentity !== row.original_identity) {
+      if (row.original_identity === null && currentIdentity === row.incoming_identity)
+        await rm3(root, { recursive: true });
+      else
+        throw new Error(
+          "Original workspace is unavailable. Preserve the recovery directory before retrying."
+        );
+    }
+  }
+  await rm3(directory, { recursive: true, force: true });
+  state.db.prepare("DELETE FROM client_workspace_replacements WHERE root=?").run(root);
+}
+async function replaceExistingWorkspace(state, root, input, client, binding, confirm) {
+  const original = await localSnapshot(root);
+  const git = await workspaceGitInfo(root);
+  const shared = await client.sharedFilesConfig();
+  const members = (await client.members()).members;
+  const snapshots = [];
+  let remoteDate = null;
+  for (const owner of [.../* @__PURE__ */ new Set([...members, binding.memberId, PROJECT_FILE_OWNER])]) {
+    let revision;
+    let after = "";
+    const files = [];
+    for (; ; ) {
+      const page = await client.fileManifest(owner, revision, after);
+      if (revision !== void 0 && page.revision !== revision)
+        throw new Error("Manifest changed version during pagination.");
+      revision = page.revision;
+      files.push(...page.files);
+      if (page.nextCursor === null) {
+        snapshots.push({ owner, revision, complete: page.complete, files });
+        break;
+      }
+      if (page.nextCursor <= after) throw new Error("Manifest pagination did not advance.");
+      after = page.nextCursor;
+    }
+    if (revision > 0) {
+      const latest = (await client.fileChanges(owner, revision - 1)).revisions[0];
+      if (latest?.revision === revision && (!remoteDate || latest.createdAt > remoteDate))
+        remoteDate = latest.createdAt;
+    }
+  }
+  if (!await confirm({
+    localDate: git.date ?? original.date,
+    localDateSource: git.date ? "git" : "files",
+    remoteDate,
+    fileCount: snapshots.reduce((count, item) => count + item.files.length, 0),
+    tracked: git.tracked
+  }))
+    throw new ConnectionCancelled();
+  const ignore2 = await ignorePlan(root);
+  const directory = await mkdtemp(join18(dirname10(root), ".teammy-connect-"));
+  const incoming = join18(directory, "incoming");
+  try {
+    state.db.prepare(
+      "INSERT INTO client_workspace_replacements(root,directory,original_identity) VALUES (?,?,?)"
+    ).run(root, directory, original.identity);
+  } catch (error) {
+    await rm3(directory, { recursive: true, force: true });
+    throw error;
+  }
+  try {
+    await mkdir10(incoming);
+    for (const snapshot of snapshots) {
+      const target = snapshot.owner === PROJECT_FILE_OWNER ? incoming : join18(incoming, snapshot.owner);
+      if (target !== incoming) await mkdir10(target);
+      for (const file of snapshot.files) {
+        const bytes = await client.downloadBlob(file.sha256);
+        if (bytes.byteLength !== file.size) throw new Error(`Content size mismatch: ${file.path}`);
+        await replaceFile(target, file.path, bytes, null);
+      }
+    }
+    const identity = await directoryIdentity(incoming);
+    state.db.prepare("UPDATE client_workspace_replacements SET incoming_identity=? WHERE root=?").run(identity, root);
+    const current = await localSnapshot(root);
+    if (current.identity !== original.identity || current.fingerprint !== original.fingerprint)
+      throw new Error("\u4E0B\u8F7D\u671F\u95F4\u672C\u5730 workspaces \u5DF2\u53D8\u5316\uFF0C\u672A\u6267\u884C\u66FF\u6362\uFF1B\u8BF7\u786E\u8BA4\u6587\u4EF6\u540E\u91CD\u65B0 connect\u3002");
+    if (original.identity) await rename5(root, join18(directory, "previous"));
+    await rename5(incoming, root);
+    transaction(state.db, () => {
+      for (const snapshot of snapshots) {
+        const prefix = snapshot.owner === PROJECT_FILE_OWNER ? "project_" : "";
+        if (snapshot.owner === binding.memberId || prefix) {
+          state.db.prepare(
+            `INSERT OR REPLACE INTO ${prefix}publications(root,revision,initialized,complete) VALUES (?,?,1,?)`
+          ).run(root, snapshot.revision, Number(snapshot.complete));
+          state.db.prepare(`DELETE FROM ${prefix}owner_files WHERE root=?`).run(root);
+          for (const file of snapshot.files)
+            state.db.prepare(`INSERT INTO ${prefix}owner_files VALUES (?,?,?,?)`).run(root, file.path, file.sha256, file.size);
+        }
+        state.db.prepare(`INSERT OR REPLACE INTO ${prefix}received_progress VALUES (?,?,?)`).run(root, snapshot.owner, snapshot.revision);
+        state.db.prepare(`DELETE FROM ${prefix}received_files WHERE root=? AND owner=?`).run(root, snapshot.owner);
+        for (const file of snapshot.files)
+          state.db.prepare(`INSERT INTO ${prefix}received_files VALUES (?,?,?,?,?)`).run(root, snapshot.owner, file.path, file.sha256, file.size);
+      }
+      state.db.prepare("INSERT OR REPLACE INTO project_file_settings VALUES (?,?)").run(root, JSON.stringify(shared));
+      state.db.prepare("INSERT INTO client_preparations(root,identity,input_json) VALUES (?,?,?)").run(root, identity, JSON.stringify(input));
+      state.db.prepare("UPDATE client_workspace_replacements SET committed=1 WHERE root=?").run(root);
+    });
+  } catch (error) {
+    await recoverWorkspaceReplacement(state, root);
+    throw error;
+  }
+  await recoverWorkspaceReplacement(state, root);
+  if (ignore2) await replaceFile(ignore2.parent, ".gitignore", ignore2.bytes, ignore2.signature);
+}
+
+// apps/client/connection.ts
 async function connectProject(state, root, directory, options) {
   const lock = acquireRootLock(root, directory);
   try {
     state.assertRootAvailable(root);
+    if (options.prepare) await recoverWorkspaceReplacement(state, root);
     const transport = new HubClient(options.url);
     const existing = state.binding(root);
     const project = new ClientProjectState(state, root);
@@ -3582,19 +3805,23 @@ async function connectProject(state, root, directory, options) {
         "This client requires a multi-project server. Update the server before connecting."
       );
     let member = options.member;
+    const input = { url: transport.url, project: options.project ?? "", member: member ?? "" };
+    const replace = options.prepare ? await prepareWorkspace(state, root, input, Boolean(options.reconnect)) : false;
+    let binding = existing;
+    let token = existing?.token;
+    let enrolled = false;
     if (existing && !options.reconnect && !options.tokenFile) {
       if (member && member !== existing.memberId)
         throw new Error("This root belongs to a different member.");
       const client2 = new HubClient(existing.serverUrl, 1e4, existing);
       await client2.members();
     } else if (options.tokenFile) {
-      const token = CredentialSchema.parse((await readFile5(options.tokenFile, "utf8")).trim());
+      token = CredentialSchema.parse((await readFile5(options.tokenFile, "utf8")).trim());
       const deviceId = state.deviceFor(root);
       const client2 = new HubClient(options.url, 1e4, { token, deviceId });
-      const binding2 = await client2.bind(deviceId, options.project ?? existing?.workspaceId);
-      if (options.project && binding2.workspaceId !== options.project)
+      binding = await client2.bind(deviceId, options.project ?? existing?.workspaceId);
+      if (options.project && binding.workspaceId !== options.project)
         throw new Error("Token belongs to a different project.");
-      state.saveBinding(root, client2.url, token, binding2);
     } else {
       member ??= existing?.memberId;
       if (!member && process.stdin.isTTY) {
@@ -3621,12 +3848,26 @@ async function connectProject(state, root, directory, options) {
         projectId,
         Boolean(options.reconnect)
       );
-      const binding2 = await transport.enroll(request);
-      state.saveBinding(root, transport.url, request.credential, binding2);
-      project.completeEnrollment();
+      binding = await transport.enroll(request);
+      token = request.credential;
+      enrolled = true;
     }
-    const binding = state.binding(root);
-    const client = new HubClient(binding.serverUrl, 1e4, binding);
+    if (!binding || !token) throw new Error("Connection credentials are unavailable.");
+    const client = new HubClient(transport.url, 1e4, { ...binding, token });
+    if (replace) {
+      if (!options.confirmReplacement)
+        throw new Error("Existing workspaces requires confirmation before connecting.");
+      await replaceExistingWorkspace(
+        state,
+        root,
+        input,
+        client,
+        binding,
+        options.confirmReplacement
+      );
+    }
+    const localBinding = state.saveBinding(root, transport.url, token, binding);
+    if (enrolled) project.completeEnrollment();
     if (info.capabilities.includes("project-config")) {
       try {
         await applyProjectFile(project, await client.projectConfig());
@@ -3637,9 +3878,9 @@ async function connectProject(state, root, directory, options) {
     }
     const own = await metadata(root, binding.memberId);
     if (own && !own.directory) throw new Error("Member path is not a directory.");
-    if (!own) await mkdir10(await safePath(root, binding.memberId));
+    if (!own) await mkdir11(await safePath(root, binding.memberId));
     await ensureLocalConfig(root);
-    const { token: _, ...visible } = binding;
+    const { token: _, ...visible } = localBinding;
     return { ...visible, configRevision: project.cached()?.config.configRevision ?? null };
   } finally {
     lock.close();
@@ -3662,6 +3903,16 @@ function result(title, detail) {
 function json(value) {
   process.stdout.write(JSON.stringify(value, null, 2) + "\n");
 }
+function browserPrompt(url) {
+  const ansi = process.stderr.isTTY && process.env.NO_COLOR === void 0 && process.env.TERM !== "dumb";
+  const title = "\u5728\u7F51\u9875\u786E\u8BA4\u8EAB\u4EFD";
+  const link2 = redact(url);
+  return ansi ? `\x1B[1m${title}\x1B[22m
+  \x1B[1;4m${link2}\x1B[0m
+` : `${title}
+  ${link2}
+`;
+}
 
 // apps/client/runtime/diagnostics.ts
 import { resolve as resolve9 } from "node:path";
@@ -3742,10 +3993,53 @@ async function runDiagnostics(command, options, version) {
   return issue ? 1 : 0;
 }
 
+// apps/client/browser-connect.ts
+import { randomBytes as randomBytes2, randomUUID as randomUUID6 } from "node:crypto";
+import { hostname } from "node:os";
+import { basename as basename3, dirname as dirname11 } from "node:path";
+import { spawn } from "node:child_process";
+import { setTimeout as setTimeout4 } from "node:timers/promises";
+function openBrowser(url) {
+  if (process.env.SSH_CONNECTION || process.env.SSH_TTY) return;
+  const command = process.platform === "darwin" ? "open" : process.platform === "linux" ? "xdg-open" : void 0;
+  if (!command) return;
+  const child = spawn(command, [url], { detached: true, stdio: "ignore" });
+  child.on("error", () => {
+  });
+  child.unref();
+}
+async function browserConnectMember(state, root, client, projectId, options = {}) {
+  const info = await client.serverInfo();
+  if (!info.capabilities.includes("browser-connect"))
+    throw new Error("\u670D\u52A1\u7AEF\u5C1A\u672A\u652F\u6301\u7F51\u9875\u786E\u8BA4\u8EAB\u4EFD\u3002\u8BF7\u5148\u4F7F\u7528 --member \u7528\u6237ID\uFF0C\u6216\u5347\u7EA7\u670D\u52A1\u7AEF\u3002");
+  const secret = randomBytes2(32).toString("hex");
+  const started = await client.startBrowserConnect({
+    id: randomUUID6(),
+    projectId,
+    deviceId: state.deviceFor(root),
+    secret,
+    label: `${hostname()} \xB7 ${basename3(dirname11(root))}`.slice(0, 255)
+  });
+  const url = new URL(`connect?request=${encodeURIComponent(started.id)}`, client.url).href;
+  (options.write ?? ((text) => process.stderr.write(text)))(browserPrompt(url));
+  (options.open ?? openBrowser)(url);
+  while (Date.now() < started.expiresAt) {
+    options.signal?.throwIfAborted();
+    try {
+      const status = await client.pollBrowserConnect(started.id, secret);
+      if (status.state === "approved") return status.memberId;
+    } catch (error) {
+      if (error instanceof HubRequestError && error.status < 500) throw error;
+    }
+    await setTimeout4(options.intervalMs ?? 2e3, void 0, { signal: options.signal });
+  }
+  throw new Error("\u7F51\u9875\u786E\u8BA4\u5DF2\u8D85\u65F6\uFF0C\u8BF7\u91CD\u65B0\u8FD0\u884C teammy connect\u3002");
+}
+
 // apps/client/client-command.ts
 var locationOptions = {
   root: { type: "string", default: resolve10("workspaces") },
-  "state-dir": { type: "string", default: join18(homedir5(), ".teammy", "client") },
+  "state-dir": { type: "string", default: join19(homedir5(), ".teammy", "client") },
   json: { type: "boolean" },
   help: { type: "boolean", short: "h" }
 };
@@ -3760,12 +4054,13 @@ async function runClientCommand(command, args, version) {
       "token-file": { type: "string" },
       reconnect: { type: "boolean" },
       "no-start": { type: "boolean" },
+      yes: { type: "boolean", short: "y" },
       all: { type: "boolean" }
     }
   });
   if (values.help) {
     process.stdout.write(
-      command === "connect" ? "Usage: teammy connect --url URL --project ID --member ID [--root DIR]\n\nCreates ./workspaces, adds Git ignore rules and starts login-session background sync.\nAdvanced: --no-start, --reconnect (stop sync first), --token-file FILE, --state-dir DIR, --json\n" : `Usage: teammy ${command} [--root DIR] [--state-dir DIR] [--json]${command === "logs" ? " [--all]" : ""}
+      command === "connect" ? "Usage: teammy connect --url URL --project ID [--root DIR]\n\nOpens a browser to confirm your user ID; --member ID remains available for scripts.\nCreates ./workspaces or confirms replacing an existing checkout with the server version.\nAdds Git ignore rules without changing tracked files in the index, then starts background sync.\nAdvanced: --yes (confirm replacement), --no-start, --reconnect (stop sync first), --token-file FILE, --state-dir DIR, --json\n" : `Usage: teammy ${command} [--root DIR] [--state-dir DIR] [--json]${command === "logs" ? " [--all]" : ""}
 `
     );
     return 0;
@@ -3786,29 +4081,42 @@ async function runClientCommand(command, args, version) {
     const transport = new HubClient(url);
     const selectedProject = values.project ?? (values.reconnect ? existing?.workspaceId : void 0);
     const project = selectedProject === void 0 && values["token-file"] ? void 0 : NameSchema.parse(selectedProject);
-    let member = values.member ?? (values.reconnect ? existing?.memberId : void 0);
-    if (!member && !values["token-file"] && process.stdin.isTTY) {
-      const rl = createInterface2({ input: process.stdin, output: process.stderr });
-      try {
-        member = (await rl.question("Member ID: ")).trim();
-      } finally {
-        rl.close();
-      }
-    }
-    if (!values["token-file"]) member = NameSchema.parse(member);
-    await prepareWorkspace(
-      state,
-      root,
-      { url: transport.url, project: project ?? "", member: member ?? "" },
-      Boolean(values.reconnect)
-    );
+    let member = values.member ?? existing?.memberId;
     if (!values["no-start"]) await checkServiceSupport();
+    if (!member && !values["token-file"])
+      member = await browserConnectMember(state, root, transport, project);
+    if (!values["token-file"]) member = NameSchema.parse(member);
     const connected = await connectProject(state, root, directory, {
       url: transport.url,
       project,
       member,
       tokenFile: values["token-file"],
-      reconnect: values.reconnect
+      reconnect: values.reconnect,
+      prepare: true,
+      confirmReplacement: async (preview) => {
+        const date = (value) => value ? new Date(value).toLocaleString("zh-CN", { hour12: false }) : "\u6682\u65E0\u8BB0\u5F55";
+        const prompt = [
+          "\u5C06\u4F7F\u7528\u670D\u52A1\u5668\u7684\u5DE5\u4F5C\u533A workspaces/ \u66FF\u6362\u672C\u5730\u5185\u5BB9\uFF0C\u662F\u5426\u7EE7\u7EED\uFF1F",
+          `  \u670D\u52A1\u5668 workspaces/ \u6700\u540E\u66F4\u65B0\u65F6\u95F4\uFF1A${date(preview.remoteDate)}`,
+          `  \u672C\u5730 workspaces/ \u6700\u540E\u66F4\u65B0\u65F6\u95F4\uFF1A${date(preview.localDate)}`,
+          "[Y/n] "
+        ].join("\n");
+        if (!values.yes) {
+          if (!process.stdin.isTTY || values.json)
+            throw new Error(
+              "\u5DF2\u6709 workspaces \u9700\u8981\u786E\u8BA4\u66FF\u6362\u3002\u8BF7\u5728\u4EA4\u4E92\u7EC8\u7AEF\u91CD\u65B0\u8FD0\u884C\uFF0C\u6216\u660E\u786E\u4F20\u5165 --yes\u3002"
+            );
+          const rl = createInterface2({ input: process.stdin, output: process.stderr });
+          try {
+            const answer = (await rl.question(prompt)).trim().toLowerCase();
+            if (!["", "y", "yes", "\u662F"].includes(answer)) return false;
+          } finally {
+            rl.close();
+          }
+        }
+        if (!values.json) result("\u6B63\u5728\u4E0B\u8F7D\u5DE5\u4F5C\u533A\u2026");
+        return true;
+      }
     });
     const collection = await setupSessions(state, root, directory, { enable: true });
     for (const issue of collection.issues) log.write("sessions.setup.failed", root, issue);
@@ -3822,6 +4130,11 @@ async function runClientCommand(command, args, version) {
       result("\u90E8\u5206\u5BF9\u8BDD\u91C7\u96C6 Hook \u672A\u914D\u7F6E", "\u540E\u53F0\u53D1\u73B0\u4ECD\u53EF\u7528\uFF0C\u8BE6\u60C5\u89C1 teammy logs");
     return 0;
   } catch (e) {
+    if (e instanceof ConnectionCancelled) {
+      if (values.json) json({ cancelled: true });
+      else result(e.message);
+      return 0;
+    }
     log.write(`${command}.failed`, root, diagnostic(e));
     throw e;
   } finally {
@@ -3830,16 +4143,16 @@ async function runClientCommand(command, args, version) {
 }
 
 // apps/client/files/synchronizer.ts
-import { randomUUID as randomUUID7 } from "node:crypto";
+import { randomUUID as randomUUID8 } from "node:crypto";
 import { watch } from "node:fs";
-import { lstat as lstat4, mkdir as mkdir12 } from "node:fs/promises";
-import { join as join20, sep as sep5 } from "node:path";
+import { lstat as lstat5, mkdir as mkdir13 } from "node:fs/promises";
+import { join as join21, sep as sep5 } from "node:path";
 import { performance } from "node:perf_hooks";
 
 // packages/storage/local-blob-store.ts
-import { createHash as createHash9, randomUUID as randomUUID6 } from "node:crypto";
-import { link, mkdir as mkdir11, open as open4, readFile as readFile6, unlink as unlink3 } from "node:fs/promises";
-import { dirname as dirname10, join as join19, resolve as resolve11 } from "node:path";
+import { createHash as createHash9, randomUUID as randomUUID7 } from "node:crypto";
+import { link, mkdir as mkdir12, open as open4, readFile as readFile6, unlink as unlink3 } from "node:fs/promises";
+import { dirname as dirname12, join as join20, resolve as resolve11 } from "node:path";
 function hash(content) {
   return createHash9("sha256").update(content).digest("hex");
 }
@@ -3863,8 +4176,8 @@ var LocalBlobStore = class {
     const bytes = Buffer.from(content);
     const sha256 = hash(bytes);
     const target = this.pathFor(sha256);
-    await mkdir11(dirname10(target), { recursive: true, mode: 448 });
-    const temporary = `${target}.${randomUUID6()}.tmp`;
+    await mkdir12(dirname12(target), { recursive: true, mode: 448 });
+    const temporary = `${target}.${randomUUID7()}.tmp`;
     const file = await open4(temporary, "wx", 384);
     try {
       try {
@@ -3880,7 +4193,7 @@ var LocalBlobStore = class {
         await this.get(sha256);
       }
       if (process.platform !== "win32") {
-        let directory = dirname10(target);
+        let directory = dirname12(target);
         for (; ; ) {
           const handle = await open4(directory, "r");
           try {
@@ -3888,8 +4201,8 @@ var LocalBlobStore = class {
           } finally {
             await handle.close();
           }
-          if (directory === dirname10(this.root)) break;
-          directory = dirname10(directory);
+          if (directory === dirname12(this.root)) break;
+          directory = dirname12(directory);
         }
       }
     } finally {
@@ -3911,7 +4224,7 @@ var LocalBlobStore = class {
   }
   pathFor(sha256) {
     if (!/^[a-f0-9]{64}$/.test(sha256)) throw new Error("Invalid SHA-256 content identifier.");
-    return join19(this.root, "sha256", sha256.slice(0, 2), sha256);
+    return join20(this.root, "sha256", sha256.slice(0, 2), sha256);
   }
 };
 
@@ -3977,7 +4290,7 @@ var FileSynchronizer = class _FileSynchronizer {
     if (!binding) throw new Error("Connect this root before synchronizing.");
     this.binding = binding;
     this.client = new HubClient(binding.serverUrl, 3e4, binding, this.abort.signal);
-    this.blobs = new LocalBlobStore(join20(stateDirectory, "blobs"));
+    this.blobs = new LocalBlobStore(join21(stateDirectory, "blobs"));
     this.projectScope = options.scope === "project";
     this.owner = this.projectScope ? PROJECT_FILE_OWNER : binding.memberId;
     this.publication = new FilePublicationState(state.db, options.scope);
@@ -3987,7 +4300,7 @@ var FileSynchronizer = class _FileSynchronizer {
       commitFiles: (batch) => this.projectScope ? this.client.commitSharedFiles(batch, batch.configRevision) : this.client.commitFiles(batch)
     });
     this.index = new SyncState(state, root, options.scope);
-    this.ownRoot = this.projectScope ? root : join20(root, binding.memberId);
+    this.ownRoot = this.projectScope ? root : join21(root, binding.memberId);
     this.common = this.projectScope ? void 0 : new _FileSynchronizer(state, root, stateDirectory, { ...options, scope: "project" });
     const started = performance.now();
     const epoch = Date.now();
@@ -4104,7 +4417,7 @@ var FileSynchronizer = class _FileSynchronizer {
         if (pending?.batch.changes.some((change) => this.excludes(change.path)))
           await this.resetPublication();
         await this.initializeAuthor();
-        const ownStat = await lstat4(this.ownRoot);
+        const ownStat = await lstat5(this.ownRoot);
         if (!ownStat.isDirectory() || ownStat.isSymbolicLink())
           throw new Error("Author directory is unavailable or is a symlink.");
         this.listen();
@@ -4188,7 +4501,7 @@ var FileSynchronizer = class _FileSynchronizer {
       }
     }
     const ownerPath = this.projectScope ? this.root : await safePath(this.root, this.owner);
-    await mkdir12(ownerPath).catch((error) => {
+    await mkdir13(ownerPath).catch((error) => {
       if (error.code !== "EEXIST") throw error;
     });
     this.publication.initializePublication(this.root, manifest.revision, manifest.files, {
@@ -4336,7 +4649,7 @@ var FileSynchronizer = class _FileSynchronizer {
       return;
     if (changes.length || !publication.complete) {
       this.publication.enqueue(this.root, {
-        operationId: randomUUID7(),
+        operationId: randomUUID8(),
         parentRevision: publication.revision,
         changes,
         ...this.projectScope ? { configRevision: this.sharedConfig.revision } : {}
@@ -4384,10 +4697,10 @@ var FileSynchronizer = class _FileSynchronizer {
     }
     const job = this.index.job(owner);
     const ownerRoot = this.projectScope ? this.root : await safePath(this.root, owner);
-    await mkdir12(ownerRoot).catch((error) => {
+    await mkdir13(ownerRoot).catch((error) => {
       if (error.code !== "EEXIST") throw error;
     });
-    const ownerStat = await lstat4(ownerRoot);
+    const ownerStat = await lstat5(ownerRoot);
     if (!ownerStat.isDirectory() || ownerStat.isSymbolicLink())
       throw new Error("Mirror root is not an ordinary directory.");
     let count = 0;
@@ -4439,8 +4752,8 @@ function message(error) {
 }
 
 // apps/client/sessions/synchronizer.ts
-import { randomUUID as randomUUID8 } from "node:crypto";
-import { join as join23 } from "node:path";
+import { randomUUID as randomUUID9 } from "node:crypto";
+import { join as join24 } from "node:path";
 import { performance as performance3 } from "node:perf_hooks";
 
 // packages/protocol/session-key.ts
@@ -4451,14 +4764,14 @@ function sessionKey(agent, nativeId) {
 
 // apps/client/sessions/source.ts
 import { createReadStream, realpathSync } from "node:fs";
-import { stat, realpath as realpath8, readdir as readdir2 } from "node:fs/promises";
-import { basename as basename4, dirname as dirname12, relative as relative5, isAbsolute as isAbsolute5, sep as sep6, join as join21 } from "node:path";
+import { stat, realpath as realpath8, readdir as readdir3 } from "node:fs/promises";
+import { basename as basename5, dirname as dirname14, relative as relative5, isAbsolute as isAbsolute5, sep as sep6, join as join22 } from "node:path";
 import { createInterface as createInterface3 } from "node:readline";
 import * as zlib from "node:zlib";
 
 // apps/client/sessions/cursor.ts
 import { createHash as createHash11 } from "node:crypto";
-import { basename as basename3, dirname as dirname11, resolve as resolve12 } from "node:path";
+import { basename as basename4, dirname as dirname13, resolve as resolve12 } from "node:path";
 import { DatabaseSync as DatabaseSync6 } from "node:sqlite";
 import { fileURLToPath } from "node:url";
 function fields(bytes) {
@@ -4507,7 +4820,7 @@ function readCursor(path, projectDir, checkCwd) {
     if (typeof hex !== "string" || !/^(?:[a-fA-F0-9]{2})+$/.test(hex))
       throw new Error("Invalid Cursor metadata.");
     const meta = object(JSON.parse(Buffer.from(hex, "hex").toString("utf8")));
-    if (typeof meta.agentId !== "string" || meta.agentId !== basename3(dirname11(path)) || meta.subagentInfo != null)
+    if (typeof meta.agentId !== "string" || meta.agentId !== basename4(dirname13(path)) || meta.subagentInfo != null)
       throw new Error("Invalid or delegated Cursor session identity.");
     const blob = (id) => {
       if (!/^[a-f0-9]{64}$/.test(id)) throw new Error("Invalid Cursor blob reference.");
@@ -4519,7 +4832,7 @@ function readCursor(path, projectDir, checkCwd) {
       return bytes;
     };
     const root = fields(blob(String(meta.latestRootBlobId)));
-    const bucket = basename3(dirname11(dirname11(path)));
+    const bucket = basename4(dirname13(dirname13(path)));
     const md5 = (cwd2) => createHash11("md5").update(resolve12(cwd2)).digest("hex");
     let cwd = md5(projectDir) === bucket ? projectDir : void 0;
     for (const uri of root.get(9) ?? []) {
@@ -4584,7 +4897,7 @@ function within(project, cwd) {
   return rel !== ".." && !rel.startsWith(`..${sep6}`) && !isAbsolute5(rel);
 }
 var cursorEncoded = (cwd) => cwd.replace(/^[/\\]+/, "").replace(/[/\\]/g, "-");
-var cursorDatabase = (path) => basename4(path) === "store.db";
+var cursorDatabase = (path) => basename5(path) === "store.db";
 async function sourceSignature(path, agent) {
   const paths = agent === "cursor" && cursorDatabase(path) ? [path, `${path}-wal`] : [path];
   const signatures = [];
@@ -4608,12 +4921,12 @@ async function sourceSignature(path, agent) {
   return JSON.stringify(signatures);
 }
 async function cursorScope(path, project) {
-  let container = dirname12(path);
-  while (basename4(container) !== "agent-transcripts" && dirname12(container) !== container)
-    container = dirname12(container);
-  if (basename4(container) !== "agent-transcripts")
+  let container = dirname14(path);
+  while (basename5(container) !== "agent-transcripts" && dirname14(container) !== container)
+    container = dirname14(container);
+  if (basename5(container) !== "agent-transcripts")
     throw new Error("Cursor transcript workspace cannot be verified.");
-  const encoded = basename4(dirname12(container));
+  const encoded = basename5(dirname14(container));
   const matches = [];
   const visit = async (directory) => {
     const prefix = cursorEncoded(directory);
@@ -4622,8 +4935,8 @@ async function cursorScope(path, project) {
       return;
     }
     if (!encoded.startsWith(prefix + "-")) return;
-    for (const entry of await readdir2(directory, { withFileTypes: true })) {
-      if (entry.isDirectory() && !entry.isSymbolicLink()) await visit(join21(directory, entry.name));
+    for (const entry of await readdir3(directory, { withFileTypes: true })) {
+      if (entry.isDirectory() && !entry.isSymbolicLink()) await visit(join22(directory, entry.name));
     }
   };
   await visit(project);
@@ -4641,7 +4954,7 @@ async function readSource(agent, path, projectDir) {
     });
     return { snapshot: snapshot2, incomplete: false, skipped: 0, signature: signature2 };
   }
-  const cursor = agent === "cursor" ? { nativeId: basename4(path, ".jsonl"), cwd: await cursorScope(path, projectDir) } : void 0;
+  const cursor = agent === "cursor" ? { nativeId: basename5(path, ".jsonl"), cwd: await cursorScope(path, projectDir) } : void 0;
   const normalizer = new JsonlNormalizer(agent, cursor);
   const stream = createReadStream(path, {
     end: Math.max(0, Number(JSON.parse(signature2)[0][2]) - 1)
@@ -4701,7 +5014,7 @@ async function readSource(agent, path, projectDir) {
 // apps/client/sessions/discovery.ts
 import { opendir as opendir2 } from "node:fs/promises";
 import { performance as performance2 } from "node:perf_hooks";
-import { join as join22 } from "node:path";
+import { join as join23 } from "node:path";
 
 // apps/client/sessions/work-queue.ts
 var SessionWorkQueue = class {
@@ -4740,7 +5053,7 @@ async function* candidates(directory, agent) {
     const current = queue.shift();
     const dir = await opendir2(current);
     for await (const entry of dir) {
-      const path = join22(current, entry.name);
+      const path = join23(current, entry.name);
       if (entry.isDirectory()) queue.push(path);
       if (entry.isFile() && (agent === "cursor" ? entry.name === "store.db" || entry.name.endsWith(".jsonl") : entry.name.endsWith(".jsonl") || agent === "dsh" && entry.name.endsWith(".jsonl.zstd")))
         yield path;
@@ -4838,7 +5151,7 @@ var SessionSynchronizer = class {
     const binding = state.binding(root);
     if (!binding) throw new Error("Connect this root before collecting sessions.");
     this.client = new HubClient(binding.serverUrl, 1e4, binding, signal);
-    this.blobs = new LocalBlobStore(join23(directory, "blobs"));
+    this.blobs = new LocalBlobStore(join24(directory, "blobs"));
     this.index = new SessionState(state, root);
     this.discovery = new SessionDiscovery(this.index);
   }
@@ -4989,7 +5302,7 @@ var SessionSynchronizer = class {
         }
         this.index.stage(
           source.path,
-          { operationId: randomUUID8(), sessionKey: key, parentRevision: revision, blob },
+          { operationId: randomUUID9(), sessionKey: key, parentRevision: revision, blob },
           observed.signature
         );
         await this.flush(this.index.get(source.path));
@@ -5372,7 +5685,7 @@ async function runSyncCommand(args, version) {
           prior = report.errors[0] ?? "";
         }
         if (values.once) return report.errors.length ? 1 : 0;
-        await setTimeout4(Math.max(100, job.nextAt - Date.now()), void 0, {
+        await setTimeout5(Math.max(100, job.nextAt - Date.now()), void 0, {
           signal: abort.signal
         }).catch((e) => {
           if (!abort.signal.aborted) throw e;
@@ -5395,13 +5708,13 @@ async function runSyncCommand(args, version) {
 // apps/client/maintenance-command.ts
 import { parseArgs as parseArgs5 } from "node:util";
 import { homedir as homedir6 } from "node:os";
-import { join as join24, resolve as resolve13 } from "node:path";
-import { mkdir as mkdir13, realpath as realpath9 } from "node:fs/promises";
+import { join as join25, resolve as resolve13 } from "node:path";
+import { mkdir as mkdir14, realpath as realpath9 } from "node:fs/promises";
 async function runMaintenanceCommand(command, args, version) {
   const { values } = parseArgs5({
     args,
     options: {
-      "state-dir": { type: "string", default: join24(homedir6(), ".teammy", "client") },
+      "state-dir": { type: "string", default: join25(homedir6(), ".teammy", "client") },
       stop: { type: "boolean" },
       json: { type: "boolean" },
       help: { type: "boolean", short: "h" }
@@ -5417,7 +5730,7 @@ ${command === "repair" ? "Repair this local client and preserve project on/off s
     return 0;
   }
   if (command === "uninstall" && values.stop) throw new Error("--stop is a repair option.");
-  await mkdir13(resolve13(values["state-dir"]), { recursive: true, mode: 448 });
+  await mkdir14(resolve13(values["state-dir"]), { recursive: true, mode: 448 });
   const directory = await realpath9(values["state-dir"]);
   const report = await prepareClient(directory, version, {
     force: true,
@@ -5442,7 +5755,7 @@ ${command === "repair" ? "Repair this local client and preserve project on/off s
 // apps/client/runtime/daemon.ts
 import { createServer } from "node:net";
 import { chmod as chmod2, unlink as unlink4 } from "node:fs/promises";
-import { join as join25 } from "node:path";
+import { join as join26 } from "node:path";
 import { resolve as resolve14 } from "node:path";
 async function runDaemon(directory, version) {
   await prepareClient(directory, version, { daemonStartup: true });
@@ -5576,7 +5889,7 @@ async function runDaemon(directory, version) {
       });
     });
     await chmod2(socketPath(directory), 384);
-    writePrivateJson(join25(directory, "runtime", "daemon.json"), { pid: process.pid, directory });
+    writePrivateJson(join26(directory, "runtime", "daemon.json"), { pid: process.pid, directory });
     process.once("SIGINT", stop);
     process.once("SIGTERM", stop);
     log.write("daemon.started", void 0, `version=${version}`);
@@ -5599,7 +5912,7 @@ async function runDaemon(directory, version) {
     await new Promise((resolve16) => server.close(() => resolve16()));
     await unlink4(socketPath(directory)).catch(() => {
     });
-    await unlink4(join25(directory, "runtime", "daemon.json")).catch(() => {
+    await unlink4(join26(directory, "runtime", "daemon.json")).catch(() => {
     });
     log.write("daemon.stopped");
     state.close();
@@ -5616,7 +5929,7 @@ Usage:
   teammy --version                  Show the installed client version
   teammy server-info --url URL      Check server connection and protocol capabilities
   teammy server-info --help         Show connection options
-  teammy connect --url URL --project ID [--member ID | --token-file FILE] [--reconnect] [--root DIR] [--state-dir DIR]
+  teammy connect --url URL --project ID [--member ID | --token-file FILE] [--yes] [--reconnect] [--root DIR] [--state-dir DIR]
   teammy repair [--stop]            Repair or pause this local background client
   teammy uninstall                  Remove local service and hooks; keep user data
   teammy status [--root DIR] [--state-dir DIR]
@@ -5626,6 +5939,7 @@ Usage:
 
 Root defaults to ./workspaces; local state defaults to ~/.teammy/client.
 connect starts background sync; enabled projects resume after login.
+Without --member, connect opens a browser to confirm your user ID.
 Use --json for scripts; manage sync timing in the server dashboard.
 The hub server is installed separately as @teammy/server (command: teammy-server).
 `;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@teammy/cli",
-  "version": "0.1.1",
+  "version": "0.1.3",
   "description": "The Teammy client for team collaboration and synchronization.",
   "type": "module",
   "bin": {