@lark-codem/codem-cli 0.1.234-dev-browser-use-review.100102657797.0.g7a31979 → 0.1.234

package/profile/device-identity.js

@@ -0,0 +1,95 @@
+// 设备身份（device_id / device_secret）的唯一读取与归一实现（叶子模块，无内部依赖）。
+//
+// 为什么要有这个模块：在此之前 device_id 的读取被手写了四份（index.js 绑定路径、
+// login-state.js 的 isLoggedInConfig、config-store.js 的 logout 墓碑、
+// daemon-post-client.ts 的自动重绑），各自认的形状还不一样——绑定路径认四个位置，
+// 墓碑只认两个。这种漂移是必然的：读侧每遇到一次「读不到」就加宽一次容忍度，
+// 写侧却从没收敛，于是容忍度成了口头约定而不是一个函数。
+//
+// 事实核对（git 考古）：config.json 里 device_id 的**唯一**真实写入形状是嵌套
+// camelCase `device.deviceId`，自 initial commit 起从未变过。snake_case 只存在于
+// 服务端 JSON 响应，在 API 边界就被归一成字符串了，从未整体落盘；顶层
+// `config.deviceId` / `config.device_id` 更是从来没有任何写入代码产生过——它们是
+// 防御性代码的化石。所以这里只保留嵌套两种：camelCase 是真实形状，snake_case 是
+// 对「服务端响应被整体 spread 进配置」这一真实可能性的收口。顶层形状已删除。
+//
+// 新增形状请改这里，不要在调用点就地手写回退链。
+
+function firstString(...values) {
+  for (const value of values) {
+    if (typeof value === "string" && value.trim()) {
+      return value;
+    }
+  }
+  return null;
+}
+
+function deviceOf(config) {
+  return config?.device && typeof config.device === "object" && !Array.isArray(config.device)
+    ? config.device
+    : null;
+}
+
+/** 从 config 读设备 ID；读不到返回 null（"本机确实没有设备"，不表示"读失败"）。 */
+export function readDeviceId(config = null) {
+  const device = deviceOf(config);
+  return device ? firstString(device.deviceId, device.device_id) : null;
+}
+
+/** 从 config 读设备密钥。logout 墓碑只留 deviceId，故此处会返回 null。 */
+export function readDeviceSecret(config = null) {
+  const device = deviceOf(config);
+  return device ? firstString(device.deviceSecret, device.device_secret) : null;
+}
+
+/**
+ * 判定本次设备绑定的意图，供 bind_reason 上报与用户提示使用。
+ *
+ *   rekey          读到了本地锚点，期望服务端复用同一条设备记录
+ *   first_bind     本机从未绑定过设备，新建是预期行为
+ *   anchor_missing ⚠️ 有登录过的痕迹、却读不到 device_id：不该发生
+ *
+ * 判据是「**曾登录过的痕迹**」而不是「配置文件是否存在」。后者会把合法首次登录误
+ * 判成异常：`codem channel test` 等命令在登录前就会写出一份合法配置（device 为
+ * null），此时报「历史工作目录仍挂在原设备下」纯属虚惊。
+ *
+ * 用 lastLoginUser / auth.oauth 而不是新加一个持久标记，是因为它们对存量用户天然
+ * 成立、无需迁移，且都由 buildBaseConfig 透传保留 —— 包括 logout（clearLoginIdentity
+ * 只清 user 和 auth.oauth，lastLoginUser 保留）。所以「device 被误抹成 null」这个
+ * 事故形态仍会被正确判成 anchor_missing，不会被这次修正掩盖掉。
+ */
+export function resolveBindReason(config = null) {
+  if (readDeviceId(config)) {
+    return "rekey";
+  }
+  const everLoggedIn = Boolean(
+    config?.lastLoginUser || config?.auth?.oauth
+  );
+  return everLoggedIn ? "anchor_missing" : "first_bind";
+}
+
+/**
+ * 把 device 子树归一到唯一的存储形状（camelCase），供 buildBaseConfig 在每次写盘
+ * 时收敛。device 曾是 buildBaseConfig 里唯一被跳过归一化的字段（纯透传），这正是
+ * 读侧兜底永远删不掉的原因——没有 normalize 就无法证明删掉兜底是安全的。
+ */
+export function normalizeDeviceConfig(device = null) {
+  if (!device || typeof device !== "object" || Array.isArray(device)) {
+    return null;
+  }
+  const { device_id, device_secret, ...rest } = device;
+  const deviceId = firstString(device.deviceId, device_id);
+  const deviceSecret = firstString(device.deviceSecret, device_secret);
+  const normalized = { ...rest };
+  if (deviceId) {
+    normalized.deviceId = deviceId;
+  } else {
+    delete normalized.deviceId;
+  }
+  if (deviceSecret) {
+    normalized.deviceSecret = deviceSecret;
+  } else {
+    delete normalized.deviceSecret;
+  }
+  return normalized;
+}

package/profile/diagnostic-id.js

@@ -0,0 +1,47 @@
+import { randomBytes } from "node:crypto";
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+
+const VALID = /^cm-[a-f0-9]{16}$/u;
+let cached;
+
+// A local support identifier, never an authentication/device-binding identity.
+// Exclusive creation avoids overwriting another process's ID. A failed or
+// interrupted write only loses persistence; diagnostics never gate startup.
+export function resolveDiagnosticId({ env = process.env, io = fs, home = os.homedir, random = randomBytes } = {}) {
+  try {
+    const inherited = env.CODEM_DIAGNOSTIC_ID;
+    if (VALID.test(inherited ?? "")) return inherited;
+  } catch { /* Unavailable environment must not gate startup. */ }
+  let generated;
+  try { generated = `cm-${random(8).toString("hex")}`; }
+  catch {
+    // Correlation only: entropy failure must not become a startup failure.
+    generated = `cm-${Array.from({ length: 16 }, () => Math.floor(Math.random() * 16).toString(16)).join("")}`;
+  }
+  try {
+    const root = env.CODEM_HOME || env.LINCO_HOME || path.join(home(), ".codem");
+    const file = path.join(root, "diagnostic-id");
+    const read = () => {
+      if (io.statSync(file).size > 64) return undefined;
+      const value = io.readFileSync(file, "utf8").trim();
+      return VALID.test(value) ? value : undefined;
+    };
+    try { const existing = read(); if (existing) return existing; } catch { /* first run */ }
+    io.mkdirSync(root, { recursive: true });
+    try { io.writeFileSync(file, `${generated}\n`, { flag: "wx", mode: 0o600 }); }
+    catch { return read() ?? generated; }
+  } catch { /* Read-only or unavailable local storage: process-local fallback. */ }
+  return generated;
+}
+
+export function diagnosticId() {
+  if (!cached) {
+    cached = resolveDiagnosticId();
+    // Children, including a restarted CLI and Core, inherit the same fallback
+    // even when local storage is unavailable.
+    try { process.env.CODEM_DIAGNOSTIC_ID = cached; } catch { /* Child spawn also receives the cached ID explicitly. */ }
+  }
+  return cached;
+}

package/profile/index.d.ts

@@ -0,0 +1,61 @@
+export interface ProfileAccount {
+  readonly userId: string
+  readonly tenantId: string
+  readonly displayName: string | null
+  readonly avatarUrl: string | null
+}
+export interface ProfileSnapshot {
+  readonly schemaVersion: 1
+  readonly user: { readonly userId: string | null; readonly tenantId: string | null; readonly displayName: string | null; readonly avatarUrl: string | null }
+  readonly serverUrl: string | null
+  readonly account: ProfileAccount | null
+  readonly device: { readonly id: string; readonly name: string | null; readonly binding: 'ready' | 'missing' } | null
+  readonly identityRevision: string | null
+}
+export interface ProfileWriterBlocker {
+  readonly kind: 'app-process' | 'cli-process' | 'codem-process' | 'session-handle'
+  readonly processId: number | null
+  readonly processName: string | null
+}
+export type ProfileSetupChoice = { readonly kind: 'migrate'; readonly home: string } | { readonly kind: 'new' | 'defer' | 'resume' }
+export interface ProfileSetupSnapshot {
+  readonly stage: 'choice' | 'welcome' | 'working' | 'blocked'
+  readonly situation: 'accounts' | 'devices' | 'recovery' | 'desktop-data'
+  readonly targetHome: string
+  readonly environment: string
+  readonly backupHome: string
+  readonly profiles: {
+    readonly home: string
+    readonly accountKey: string | null
+    readonly accountLabel: string
+    readonly deviceId: string | null
+    readonly status: 'available' | 'signed-out' | 'recovery' | 'other-environment'
+    readonly issue: string | null
+  }[]
+  readonly recommendedHome: string
+  readonly busy: boolean
+  readonly blockers: ProfileWriterBlocker[]
+  readonly notice: string | null
+  readonly diagnosticId: string | null
+}
+export interface ProfileMigrationOptions {
+  readonly mode: 'automatic' | 'maintenance'
+  readonly targetHome: string
+  readonly legacyHomes: readonly string[]
+  readonly backupHome: string
+  readonly serverOrigin: string
+  readonly migrateSessions: (sessionRoots: readonly string[]) => Promise<void>
+  readonly choose: (snapshot: ProfileSetupSnapshot) => Promise<ProfileSetupChoice>
+}
+export type ProfileMigrationResult = { readonly kind: 'ready'; readonly backupHome: string | null; readonly legacyCleanupPending: boolean } | { readonly kind: 'defer' }
+export class CodeMProfileMigrationError extends Error {}
+export class CodeMProfileMigrationBlockedError extends CodeMProfileMigrationError {
+  readonly code: 'CODEM_PROFILE_MIGRATION_BLOCKED'
+  readonly reason: 'daemon-active' | 'session-writer-active' | 'writer-inspection-failed'
+  readonly blockers: readonly ProfileWriterBlocker[]
+  constructor(detail: string, reason: CodeMProfileMigrationBlockedError['reason'], blockers: readonly ProfileWriterBlocker[], options?: ErrorOptions)
+}
+export function readProfileSnapshot(home: string): Promise<ProfileSnapshot>
+export function canonicalCodeMProfileHome(home: string): Promise<string>
+export function migrateCodeMProfile(options: ProfileMigrationOptions): Promise<ProfileMigrationResult>
+export function withProfileSessionMaintenance<T>(home: string, operation: () => Promise<T>): Promise<T>

package/profile/index.js

@@ -0,0 +1,17 @@
+export { readProfileSnapshot } from "./profile-snapshot.js";
+export {
+  canonicalCodeMProfileHome,
+  migrateCodeMProfile,
+  CodeMProfileMigrationError,
+  CodeMProfileMigrationBlockedError
+} from "./profile-migration.js";
+import { join } from "node:path";
+import { withCodeMConfigLock } from "./profile-io.js";
+import { requireIdleProfileSessions } from "./profile-writers.js";
+
+export async function withProfileSessionMaintenance(home, operation) {
+  return withCodeMConfigLock(join(home, "config.json"), async () => {
+    await requireIdleProfileSessions(home);
+    return operation();
+  });
+}

package/profile/profile-io.js

@@ -0,0 +1,70 @@
+import { execFile } from "node:child_process";
+import { randomUUID } from "node:crypto";
+import { mkdir, open, rename, rm } from "node:fs/promises";
+import { basename, dirname, join, posix, win32 } from "node:path";
+import { acquireConfigLock } from "./config-lock.js";
+
+export async function withCodeMConfigLock(path, operation) {
+  const release = await acquireConfigLock(path);
+  try { return await operation(); } finally { await release(); }
+}
+
+export function probeProcessLiveness(pid) {
+  try { process.kill(pid, 0); return { kind: "alive" }; }
+  catch (cause) { return cause.code === "ESRCH" ? { kind: "missing" } : { kind: "unavailable", cause }; }
+}
+
+export function samePathForPlatform(left, right, platform) {
+  const api = platform === "win32" ? win32 : posix;
+  const normalize = value => platform === "win32" ? api.resolve(value).toLowerCase() : api.resolve(value);
+  return normalize(left) === normalize(right);
+}
+
+export async function writeFileAtomically(path, contents, label) {
+  await mkdir(dirname(path), { recursive: true, mode: 0o700 });
+  const temporary = join(dirname(path), `.${basename(path)}.${randomUUID()}.tmp`);
+  try {
+    const file = await open(temporary, "wx", 0o600);
+    try { await file.writeFile(contents); await file.sync(); }
+    finally { await file.close(); }
+    await rename(temporary, path);
+  } catch (cause) {
+    await rm(temporary, { force: true }).catch(() => undefined);
+    throw new Error(`Cannot persist ${label}`, { cause });
+  }
+}
+
+export function writeJsonFileAtomically(path, value, label) {
+  return writeFileAtomically(path, `${JSON.stringify(value, null, 2)}\n`, label);
+}
+
+export function runProcessResult(options) {
+  return new Promise(resolve => {
+    execFile(options.executable, options.arguments, {
+      timeout: options.timeoutMilliseconds,
+      maxBuffer: options.maximumOutputBytes,
+      windowsHide: true,
+      encoding: "utf8"
+    }, (error, stdout, stderr) => resolve({
+      stdout, stderr,
+      termination: error
+        ? typeof error.code === "number"
+          ? { kind: "exit", exitCode: error.code }
+          : { kind: "failure" }
+        : { kind: "exit", exitCode: 0 }
+    }));
+  });
+}
+
+export function isProcessExit(outcome, code) {
+  return outcome.termination.kind === "exit" && outcome.termination.exitCode === code;
+}
+
+export function requireProcessSuccess(outcome) {
+  if (!isProcessExit(outcome, 0)) throw new Error("Profile writer inspection failed");
+  return outcome;
+}
+
+export async function runProcess(options) {
+  return requireProcessSuccess(await runProcessResult(options));
+}