agentel 0.2.0

package/src/web-accounts.js

@@ -0,0 +1,122 @@
+"use strict";
+
+const crypto = require("crypto");
+const { paths, readJson, writeJson } = require("./paths");
+
+function loadWebAccounts(env = process.env) {
+  const state = readJson(paths(env).webAccounts, { version: 1, accounts: {} });
+  return {
+    version: state.version || 1,
+    accounts: state.accounts && typeof state.accounts === "object" ? state.accounts : {}
+  };
+}
+
+function saveWebAccounts(state, env = process.env) {
+  writeJson(paths(env).webAccounts, {
+    version: state.version || 1,
+    accounts: state.accounts || {}
+  });
+}
+
+function canonicalWebProvider(provider) {
+  const value = String(provider || "").trim().toLowerCase().replace(/[-\s]+/g, "_");
+  if (value === "claude" || value === "claude_ai" || value === "claude_web") return "claude_web";
+  if (value === "chatgpt" || value === "openai") return "chatgpt";
+  return value;
+}
+
+function webAccountKey(provider, accountId) {
+  return `${canonicalWebProvider(provider)}:${String(accountId || "").trim()}`;
+}
+
+function derivedAccountId(provider, username) {
+  const hash = crypto
+    .createHash("sha256")
+    .update(canonicalWebProvider(provider))
+    .update("\0")
+    .update(String(username || "").trim().toLowerCase())
+    .digest("hex")
+    .slice(0, 16);
+  return `u-${hash}`;
+}
+
+function getWebAccount(provider, accountId, env = process.env) {
+  const id = String(accountId || "").trim();
+  if (!id) return null;
+  return loadWebAccounts(env).accounts[webAccountKey(provider, id)] || null;
+}
+
+function findWebAccount(provider, value, env = process.env) {
+  const normalizedProvider = canonicalWebProvider(provider);
+  const wanted = String(value || "").trim().toLowerCase();
+  if (!wanted) return null;
+  for (const account of Object.values(loadWebAccounts(env).accounts)) {
+    if (canonicalWebProvider(account.provider) !== normalizedProvider) continue;
+    const candidates = [account.accountId, account.username, account.displayName, account.sourceAccountId]
+      .filter(Boolean)
+      .map((item) => String(item).toLowerCase());
+    if (candidates.includes(wanted)) return account;
+  }
+  return null;
+}
+
+function upsertWebAccount(provider, input = {}, env = process.env) {
+  const state = loadWebAccounts(env);
+  const normalizedProvider = canonicalWebProvider(provider);
+  const username = String(input.username || "").trim();
+  const sourceAccountId = String(input.sourceAccountId || "").trim();
+  const accountId = String(input.accountId || sourceAccountId || derivedAccountId(normalizedProvider, username)).trim();
+  if (!accountId) throw new Error("web account id is required");
+  if (!username && !state.accounts[webAccountKey(normalizedProvider, accountId)]) {
+    throw new Error("username is required for a new web chat account");
+  }
+  const key = webAccountKey(normalizedProvider, accountId);
+  const now = new Date().toISOString();
+  const previous = state.accounts[key] || {};
+  const account = {
+    provider: normalizedProvider,
+    accountId,
+    username: username || previous.username || accountId,
+    displayName: String(input.displayName || "").trim() || previous.displayName || username || previous.username || accountId,
+    sourceAccountId: sourceAccountId || previous.sourceAccountId || "",
+    createdAt: previous.createdAt || now,
+    updatedAt: now
+  };
+  state.accounts[key] = account;
+  saveWebAccounts(state, env);
+  return account;
+}
+
+function listWebAccounts(env = process.env) {
+  return Object.values(loadWebAccounts(env).accounts).sort((a, b) =>
+    String(a.provider).localeCompare(String(b.provider)) ||
+    String(a.displayName || a.username).localeCompare(String(b.displayName || b.username))
+  );
+}
+
+function renameWebAccount(provider, accountIdOrUsername, displayName, env = process.env) {
+  const account = findWebAccount(provider, accountIdOrUsername, env);
+  if (!account) throw new Error(`no ${canonicalWebProvider(provider)} account found for ${accountIdOrUsername}`);
+  const state = loadWebAccounts(env);
+  const key = webAccountKey(account.provider, account.accountId);
+  state.accounts[key] = {
+    ...account,
+    displayName: String(displayName || "").trim(),
+    updatedAt: new Date().toISOString()
+  };
+  if (!state.accounts[key].displayName) throw new Error("--display-name is required");
+  saveWebAccounts(state, env);
+  return state.accounts[key];
+}
+
+module.exports = {
+  canonicalWebProvider,
+  derivedAccountId,
+  findWebAccount,
+  getWebAccount,
+  listWebAccounts,
+  loadWebAccounts,
+  renameWebAccount,
+  upsertWebAccount,
+  webAccountKey
+};