codexuse-cli 3.5.6 → 3.6.1

package/dist/index.js

@@ -2102,6 +2102,7 @@ var APP_STORAGE_DB_NAME = "state.sqlite";
 var SQLITE_BUSY_TIMEOUT_MS = 5e3;
 var SQLITE_BUSY_MAX_ATTEMPTS = 3;
 var SQLITE_BUSY_RETRY_DELAY_MS = 100;
+var writeQueueByDbPath = /* @__PURE__ */ new Map();
 var initializedDbPaths = /* @__PURE__ */ new Set();
 function isRecord(value) {
   return Boolean(value) && typeof value === "object" && !Array.isArray(value);
@@ -2142,6 +2143,23 @@ function rollback(db) {
   } catch {
   }
 }
+async function withWriteQueue(dbPath, task) {
+  const previous = writeQueueByDbPath.get(dbPath) ?? Promise.resolve();
+  let release;
+  const current = new Promise((resolve) => {
+    release = resolve;
+  });
+  writeQueueByDbPath.set(dbPath, current);
+  await previous;
+  try {
+    return await task();
+  } finally {
+    release?.();
+    if (writeQueueByDbPath.get(dbPath) === current) {
+      writeQueueByDbPath.delete(dbPath);
+    }
+  }
+}
 function applyConnectionPragmas(db) {
   db.exec(`PRAGMA busy_timeout = ${SQLITE_BUSY_TIMEOUT_MS};`);
   db.exec("PRAGMA journal_mode = WAL;");
@@ -2213,56 +2231,62 @@ async function readDocument(dbPath, namespace, normalize) {
   });
 }
 async function writeDocument(dbPath, namespace, value) {
-  return withDatabase(dbPath, (db) => {
-    const normalizedValue = clone(value);
-    beginImmediate(db);
-    try {
-      db.prepare(
-        `
-          INSERT INTO ${APP_STORAGE_TABLE} (namespace, value_json, updated_at)
-          VALUES (?, ?, ?)
-          ON CONFLICT(namespace)
-          DO UPDATE SET
-            value_json = excluded.value_json,
-            updated_at = excluded.updated_at
-        `
-      ).run(namespace, JSON.stringify(normalizedValue), (/* @__PURE__ */ new Date()).toISOString());
-      commit(db);
-      return normalizedValue;
-    } catch (error) {
-      rollback(db);
-      throw error;
-    }
-  });
+  return withWriteQueue(
+    dbPath,
+    async () => withDatabase(dbPath, (db) => {
+      const normalizedValue = clone(value);
+      beginImmediate(db);
+      try {
+        db.prepare(
+          `
+              INSERT INTO ${APP_STORAGE_TABLE} (namespace, value_json, updated_at)
+              VALUES (?, ?, ?)
+              ON CONFLICT(namespace)
+              DO UPDATE SET
+                value_json = excluded.value_json,
+                updated_at = excluded.updated_at
+            `
+        ).run(namespace, JSON.stringify(normalizedValue), (/* @__PURE__ */ new Date()).toISOString());
+        commit(db);
+        return normalizedValue;
+      } catch (error) {
+        rollback(db);
+        throw error;
+      }
+    })
+  );
 }
 async function updateDocument(input) {
-  return withDatabase(input.dbPath, (db) => {
-    beginImmediate(db);
-    try {
-      const row = db.prepare(
-        `SELECT value_json AS valueJson FROM ${APP_STORAGE_TABLE} WHERE namespace = ?`
-      ).get(input.namespace);
-      const current = isRecord(row) ? input.normalize(
-        safeParseJson(row.valueJson) ?? input.fallback()
-      ) : input.fallback();
-      const next = input.normalize(input.transform(clone(current)));
-      db.prepare(
-        `
-          INSERT INTO ${APP_STORAGE_TABLE} (namespace, value_json, updated_at)
-          VALUES (?, ?, ?)
-          ON CONFLICT(namespace)
-          DO UPDATE SET
-            value_json = excluded.value_json,
-            updated_at = excluded.updated_at
-        `
-      ).run(input.namespace, JSON.stringify(next), (/* @__PURE__ */ new Date()).toISOString());
-      commit(db);
-      return clone(next);
-    } catch (error) {
-      rollback(db);
-      throw error;
-    }
-  });
+  return withWriteQueue(
+    input.dbPath,
+    async () => withDatabase(input.dbPath, (db) => {
+      beginImmediate(db);
+      try {
+        const row = db.prepare(
+          `SELECT value_json AS valueJson FROM ${APP_STORAGE_TABLE} WHERE namespace = ?`
+        ).get(input.namespace);
+        const current = isRecord(row) ? input.normalize(
+          safeParseJson(row.valueJson) ?? input.fallback()
+        ) : input.fallback();
+        const next = input.normalize(input.transform(clone(current)));
+        db.prepare(
+          `
+              INSERT INTO ${APP_STORAGE_TABLE} (namespace, value_json, updated_at)
+              VALUES (?, ?, ?)
+              ON CONFLICT(namespace)
+              DO UPDATE SET
+                value_json = excluded.value_json,
+                updated_at = excluded.updated_at
+            `
+        ).run(input.namespace, JSON.stringify(next), (/* @__PURE__ */ new Date()).toISOString());
+        commit(db);
+        return clone(next);
+      } catch (error) {
+        rollback(db);
+        throw error;
+      }
+    })
+  );
 }
 
 // ../../packages/runtime-app-state/src/app/state.ts
@@ -3511,6 +3535,63 @@ var import_path = __toESM(require("path"), 1);
 var import_path2 = require("path");
 var import_toml = __toESM(require_toml(), 1);
 
+// ../../packages/contracts/src/profiles/identity.ts
+function normalizeValue(value) {
+  if (typeof value !== "string") {
+    return null;
+  }
+  const trimmed = value.trim();
+  return trimmed.length > 0 ? trimmed : null;
+}
+function normalizeEmail(value) {
+  const normalized = normalizeValue(value);
+  return normalized ? normalized.toLowerCase() : null;
+}
+function encodeIdentityPart(value) {
+  return encodeURIComponent(value);
+}
+function resolveLegacyProfileAccountKey(profile) {
+  const accountId = normalizeValue(profile.accountId);
+  if (accountId) {
+    return accountId;
+  }
+  const email = normalizeValue(profile.email ?? profile.metadata?.email);
+  if (email) {
+    return email;
+  }
+  const profileName = normalizeValue(profile.name);
+  return profileName ? `profile:${profileName}` : null;
+}
+function resolveProfileIdentityKey(profile) {
+  const workspaceId = normalizeValue(profile.workspaceId);
+  const accountUserId = normalizeValue(profile.metadata?.chatgptAccountUserId);
+  if (accountUserId) {
+    return `seat:${encodeIdentityPart(accountUserId)}`;
+  }
+  const userId = normalizeValue(profile.metadata?.userId) ?? normalizeValue(profile.metadata?.chatgptUserId);
+  if (workspaceId && userId) {
+    return `workspace-user:${encodeIdentityPart(workspaceId)}|${encodeIdentityPart(userId)}`;
+  }
+  const accountId = normalizeValue(profile.accountId);
+  if (accountId) {
+    return accountId;
+  }
+  const email = normalizeEmail(profile.email ?? profile.metadata?.email);
+  if (workspaceId && email) {
+    return `workspace-email:${encodeIdentityPart(workspaceId)}|${encodeIdentityPart(email)}`;
+  }
+  if (userId) {
+    return `user:${encodeIdentityPart(userId)}`;
+  }
+  if (email) {
+    return `email:${encodeIdentityPart(email)}`;
+  }
+  return resolveLegacyProfileAccountKey(profile);
+}
+function resolveProfileIdentityKeyFromProfile(profile) {
+  return resolveProfileIdentityKey(profile) ?? `profile:${profile.name}`;
+}
+
 // ../../packages/runtime-codex/src/codex/rpc.ts
 var import_node_child_process2 = require("child_process");
 var import_node_readline = __toESM(require("readline"), 1);
@@ -4516,6 +4597,7 @@ var ProfileManager = class {
       groups,
       userId,
       chatgptUserId,
+      chatgptAccountUserId,
       emailVerified,
       tokenExpiresAt: this.toIsoStringFromSeconds(exp),
       tokenIssuedAt: this.toIsoStringFromSeconds(iat),
@@ -4523,7 +4605,7 @@ var ProfileManager = class {
     };
     const hasMeaningfulData = Boolean(metadata.planType) || Boolean(
       metadata.subscription && (metadata.subscription.activeStart || metadata.subscription.activeUntil || metadata.subscription.lastChecked)
-    ) || Boolean(metadata.organizations && metadata.organizations.length > 0) || Boolean(metadata.groups && metadata.groups.length > 0) || Boolean(metadata.userId) || Boolean(metadata.chatgptUserId) || Boolean(metadata.email) || typeof metadata.emailVerified === "boolean" || Boolean(metadata.tokenExpiresAt) || Boolean(metadata.tokenIssuedAt) || Boolean(metadata.tokenAuthTime);
+    ) || Boolean(metadata.organizations && metadata.organizations.length > 0) || Boolean(metadata.groups && metadata.groups.length > 0) || Boolean(metadata.userId) || Boolean(metadata.chatgptUserId) || Boolean(metadata.chatgptAccountUserId) || Boolean(metadata.email) || typeof metadata.emailVerified === "boolean" || Boolean(metadata.tokenExpiresAt) || Boolean(metadata.tokenIssuedAt) || Boolean(metadata.tokenAuthTime);
     return hasMeaningfulData ? metadata : void 0;
   }
   /**
@@ -4639,13 +4721,35 @@ var ProfileManager = class {
         return accountId.trim();
       }
     }
-    const projectId = "project_id" in data && typeof data.project_id === "string" ? data.project_id?.trim() : void 0;
-    if (projectId) {
-      return projectId;
-    }
     const email = "email" in data && typeof data.email === "string" ? data.email?.trim() : void 0;
     return email || void 0;
   }
+  resolveProfileIdentityKey(args) {
+    return resolveProfileIdentityKey(args);
+  }
+  resolveLegacyAccountKey(args) {
+    return resolveLegacyProfileAccountKey(args);
+  }
+  resolveProfileIdentityFromData(name, data, metadata) {
+    const resolvedMetadata = metadata ?? this.extractProfileMetadata(data);
+    const workspace = this.resolveWorkspaceIdentity(data, resolvedMetadata);
+    const email = this.resolveProfileEmail(data, resolvedMetadata) ?? null;
+    return this.resolveProfileIdentityKey({
+      name,
+      accountId: this.getAccountIdFromData(data) ?? null,
+      workspaceId: workspace.id ?? null,
+      email,
+      metadata: resolvedMetadata
+    });
+  }
+  resolveProfileIdentityFromRecord(record) {
+    return this.resolveProfileIdentityFromData(record.name, record.data, record.metadata) ?? this.resolveLegacyAccountKey({
+      name: record.name,
+      accountId: record.accountId,
+      email: record.email,
+      metadata: record.metadata
+    }) ?? resolveFallbackAccountKey(record.name);
+  }
   resolveWorkspaceIdentity(data, metadata) {
     const directId = "workspace_id" in data && typeof data.workspace_id === "string" ? data.workspace_id.trim() : void 0;
     const directName = "workspace_name" in data && typeof data.workspace_name === "string" ? data.workspace_name.trim() : void 0;
@@ -4666,12 +4770,9 @@ var ProfileManager = class {
     const record = await this.readProfileRecord(normalized);
     return record ?? void 0;
   }
-  async getProfileRowByAccountId(accountId, options) {
+  async getProfileRowByIdentityKey(identityKey, options) {
     const records = await this.listProfileRecords();
-    const matches = records.filter((record) => {
-      const storedAccountId = record.accountId ?? this.getAccountIdFromData(record.data);
-      return storedAccountId === accountId;
-    });
+    const matches = records.filter((record) => this.resolveProfileIdentityFromRecord(record) === identityKey);
     if (matches.length === 0) {
       return void 0;
     }
@@ -4685,12 +4786,11 @@ var ProfileManager = class {
     }
     return matches[0];
   }
-  async getProfileRowByAccountAndWorkspace(accountId, workspaceId, options) {
+  async getProfileRowByIdentityAndWorkspace(identityKey, workspaceId, options) {
     const workspaceKey = workspaceId && workspaceId.trim().length > 0 ? workspaceId.trim() : DEFAULT_WORKSPACE_ID;
     const records = await this.listProfileRecords();
     const matches = records.filter((record) => {
-      const storedAccountId = record.accountId ?? this.getAccountIdFromData(record.data);
-      if (storedAccountId !== accountId) {
+      if (this.resolveProfileIdentityFromRecord(record) !== identityKey) {
         return false;
       }
       const storedWorkspace = record.workspaceId ?? record.data.workspace_id ?? DEFAULT_WORKSPACE_ID;
@@ -4968,11 +5068,17 @@ var ProfileManager = class {
     if (latestRow) {
       existing = latestRow.data;
     }
-    const existingAccountId = this.getAccountIdFromData(existing);
-    const newAccountId = this.getAccountIdFromData(normalized);
-    if (existingAccountId && newAccountId && existingAccountId !== newAccountId) {
+    const existingMetadata = this.extractProfileMetadata(existing);
+    const existingWorkspace = this.resolveWorkspaceIdentity(existing, existingMetadata);
+    existing.workspace_id = existing.workspace_id ?? existingWorkspace.id ?? DEFAULT_WORKSPACE_ID;
+    if (existingWorkspace.name) {
+      existing.workspace_name = existing.workspace_name ?? existingWorkspace.name;
+    }
+    const existingIdentity = this.resolveProfileIdentityFromData(profileName, existing, existingMetadata);
+    const nextIdentity = this.resolveProfileIdentityFromData(profileName, normalized, metadata);
+    if (existingIdentity && nextIdentity && existingIdentity !== nextIdentity) {
       logWarn(
-        `Skipped syncing tokens for profile '${profileName}' because Codex auth switched to account '${newAccountId}'.`
+        `Skipped syncing tokens for profile '${profileName}' because Codex auth switched to a different OpenAI identity.`
       );
       return;
     }
@@ -5208,15 +5314,6 @@ var ProfileManager = class {
     if (workspace.name) {
       normalizedProfile.workspace_name = normalizedProfile.workspace_name ?? workspace.name;
     }
-    const accountId = this.getAccountIdFromData(normalizedProfile);
-    if (accountId) {
-      const requestedWorkspace = normalizedProfile.workspace_id ?? DEFAULT_WORKSPACE_ID;
-      const duplicate = await this.getProfileRowByAccountAndWorkspace(accountId, requestedWorkspace, { authMethod: "codex-cli" });
-      if (duplicate) {
-        normalizedProfile.workspace_id = `${requestedWorkspace}:${profileName}`;
-        normalizedProfile.workspace_name = normalizedProfile.workspace_name ?? profileName;
-      }
-    }
     const resolvedEmail = this.resolveProfileEmail(normalizedProfile, metadata);
     if (resolvedEmail) {
       normalizedProfile.email = resolvedEmail;
@@ -5271,25 +5368,30 @@ var ProfileManager = class {
       throw new Error("Failed to read Codex auth file. Complete the login and try again.");
     }
     const normalized = this.normalizeProfileData(activeAuth);
-    const existingAccountId = this.getAccountIdFromData(existing);
-    const newAccountId = this.getAccountIdFromData(normalized);
+    const existingMetadata = record.metadata ?? this.extractProfileMetadata(existing);
+    const currentWorkspace = this.resolveWorkspaceIdentity(existing, existingMetadata);
+    existing.workspace_id = existing.workspace_id ?? currentWorkspace.id ?? DEFAULT_WORKSPACE_ID;
+    if (currentWorkspace.name) {
+      existing.workspace_name = existing.workspace_name ?? currentWorkspace.name;
+    }
     const normalizedMetadata = this.extractProfileMetadata(normalized);
     const normalizedWorkspace = this.resolveWorkspaceIdentity(normalized, normalizedMetadata);
     normalized.workspace_id = normalized.workspace_id ?? normalizedWorkspace.id ?? DEFAULT_WORKSPACE_ID;
     if (normalizedWorkspace.name) {
       normalized.workspace_name = normalized.workspace_name ?? normalizedWorkspace.name;
     }
-    if (existingAccountId && newAccountId && existingAccountId !== newAccountId) {
+    const existingIdentity = this.resolveProfileIdentityFromData(profileName, existing, existingMetadata);
+    const newIdentity = this.resolveProfileIdentityFromData(profileName, normalized, normalizedMetadata);
+    if (existingIdentity && newIdentity && existingIdentity !== newIdentity) {
       throw new Error(
-        `Active Codex login is for account '${newAccountId}', but profile '${profileName}' is tied to '${existingAccountId}'. Create a new profile for the new account instead.`
+        `Active Codex login is for a different OpenAI identity than profile '${profileName}'. Create a new profile for that login instead.`
       );
     }
-    if (existingAccountId && normalized.workspace_id) {
-      const currentWorkspace = this.resolveWorkspaceIdentity(existing, this.extractProfileMetadata(existing));
+    if (existingIdentity && normalized.workspace_id) {
       const targetWorkspaceId = normalized.workspace_id;
       const currentWorkspaceId = currentWorkspace.id ?? DEFAULT_WORKSPACE_ID;
       if (targetWorkspaceId !== currentWorkspaceId) {
-        const duplicate = await this.getProfileRowByAccountAndWorkspace(existingAccountId, targetWorkspaceId, {
+        const duplicate = await this.getProfileRowByIdentityAndWorkspace(existingIdentity, targetWorkspaceId, {
           authMethod: this.resolveAuthMethod(existing)
         });
         if (duplicate && duplicate.name !== profileName) {
@@ -5506,9 +5608,9 @@ var ProfileManager = class {
       const normalizedAuth = this.normalizeProfileData(activeAuth);
       const authMetadata = this.extractProfileMetadata(normalizedAuth);
       const workspace = this.resolveWorkspaceIdentity(normalizedAuth, authMetadata);
-      const activeAccountId = this.getAccountIdFromData(normalizedAuth);
-      if (activeAccountId) {
-        const scoped = await this.getProfileRowByAccountAndWorkspace(activeAccountId, workspace.id ?? DEFAULT_WORKSPACE_ID, {
+      const activeIdentityKey = this.resolveProfileIdentityFromData(null, normalizedAuth, authMetadata);
+      if (activeIdentityKey) {
+        const scoped = await this.getProfileRowByIdentityAndWorkspace(activeIdentityKey, workspace.id ?? DEFAULT_WORKSPACE_ID, {
           preferAuthMethod: "codex-cli"
         });
         if (scoped) {
@@ -5516,7 +5618,7 @@ var ProfileManager = class {
           await this.persistPreferredProfileName(normalized);
           return { name: normalized, trusted: true };
         }
-        const matching = await this.getProfileRowByAccountId(activeAccountId, { preferAuthMethod: "codex-cli" });
+        const matching = await this.getProfileRowByIdentityKey(activeIdentityKey, { preferAuthMethod: "codex-cli" });
         if (matching) {
           const normalized = this.normalizeProfileName(matching.name);
           await this.persistPreferredProfileName(normalized);
@@ -7218,7 +7320,7 @@ function formatProfileLabel(name, displayName) {
   return name;
 }
 function profileRateLimitKey(profile) {
-  return profile.accountId ?? `profile:${profile.name}`;
+  return resolveProfileIdentityKeyFromProfile(profile);
 }
 function toTitleCase(value) {
   return value.replace(/\w\S*/g, (word) => word.charAt(0).toUpperCase() + word.slice(1).toLowerCase());
@@ -10124,7 +10226,7 @@ async function ensureCliStorageReady() {
 }
 
 // src/app/main.ts
-var VERSION = true ? "3.5.6" : "0.0.0";
+var VERSION = true ? "3.6.1" : "0.0.0";
 async function runCli() {
   const args = process.argv.slice(2);
   if (args.length === 0) {