@web-auto/webauto 0.1.4 → 0.1.6

package/apps/webauto/entry/lib/account-store.mjs

@@ -14,6 +14,7 @@ const DEFAULT_PLATFORM = 'xiaohongshu';
 const STATUS_ACTIVE = 'active';
 const STATUS_VALID = 'valid';
 const STATUS_INVALID = 'invalid';
+const STATUS_PENDING = 'pending';
 
 function nowIso() {
   return new Date().toISOString();
@@ -21,7 +22,8 @@ function nowIso() {
 
 function readJson(filePath, fallback) {
   try {
-    return JSON.parse(fs.readFileSync(filePath, 'utf8'));
+    const raw = fs.readFileSync(filePath, 'utf8');
+    return JSON.parse(String(raw).replace(/^\uFEFF/, ''));
   } catch {
     return fallback;
   }
@@ -91,12 +93,21 @@ function formatSeq(seq) {
   return String(seq).padStart(4, '0');
 }
 
+function resolveAutoTag(platform) {
+  const normalized = normalizePlatform(platform);
+  return normalized === 'xiaohongshu'
+    ? 'xhs'
+    : (toSlug(normalized).split('-')[0] || 'acct');
+}
+
+function buildAutoAccountId(platform, seq) {
+  return `${resolveAutoTag(platform)}-${formatSeq(seq)}`;
+}
+
 function normalizeId(id, fallbackPlatform, seq) {
   const cleaned = toSlug(id || '');
   if (cleaned) return cleaned;
-  const platform = normalizePlatform(fallbackPlatform);
-  const tag = platform === 'xiaohongshu' ? 'xhs' : (toSlug(platform).split('-')[0] || 'acct');
-  return `${tag}-${formatSeq(seq)}`;
+  return buildAutoAccountId(fallbackPlatform, seq);
 }
 
 function ensureSafeName(name, field) {
@@ -133,6 +144,20 @@ function resolveAccountDir(id) {
   return path.join(resolveAccountsRoot(), id);
 }
 
+function removeAccountDirById(id) {
+  const safeId = String(id || '').trim();
+  if (!safeId) return;
+  const dir = resolveAccountDir(safeId);
+  if (fs.existsSync(dir)) {
+    fs.rmSync(dir, { recursive: true, force: true });
+  }
+}
+
+function hasPersistentAccountId(record) {
+  if (normalizeText(record?.accountId)) return true;
+  return normalizeStatus(record?.status) === STATUS_PENDING;
+}
+
 function isWithinDir(rootDir, targetPath) {
   const root = path.resolve(rootDir);
   const target = path.resolve(targetPath);
@@ -142,7 +167,12 @@ function isWithinDir(rootDir, targetPath) {
 function loadIndex() {
   const fallback = { version: 1, nextSeq: 1, updatedAt: null, accounts: [] };
   const raw = readJson(resolveIndexPath(), fallback);
-  const accounts = Array.isArray(raw?.accounts) ? raw.accounts : [];
+  const accountsRaw = Array.isArray(raw?.accounts) ? raw.accounts : [];
+  const staleIds = accountsRaw
+    .filter((account) => !hasPersistentAccountId(account))
+    .map((account) => String(account?.id || '').trim())
+    .filter(Boolean);
+  const accounts = accountsRaw.filter((account) => hasPersistentAccountId(account));
   const maxSeq = accounts.reduce((max, account) => {
     const seq = Number(account?.seq);
     return Number.isFinite(seq) ? Math.max(max, seq) : max;
@@ -150,12 +180,26 @@ function loadIndex() {
   const nextSeq = Number.isFinite(Number(raw?.nextSeq)) && Number(raw?.nextSeq) > maxSeq
     ? Number(raw.nextSeq)
     : maxSeq + 1;
-  return {
+  const normalized = {
     version: 1,
     nextSeq,
     updatedAt: raw?.updatedAt || null,
     accounts,
   };
+
+  if (staleIds.length > 0 || accounts.length !== accountsRaw.length) {
+    writeJson(resolveIndexPath(), {
+      version: 1,
+      nextSeq,
+      updatedAt: nowIso(),
+      accounts,
+    });
+    for (const id of staleIds) {
+      removeAccountDirById(id);
+    }
+  }
+
+  return normalized;
 }
 
 function saveIndex(index) {
@@ -175,6 +219,43 @@ function resolveProfilePrefix(platform) {
   return `${slug}-account`;
 }
 
+function resolveProfileSeq(profileId, platform) {
+  const value = String(profileId || '').trim();
+  if (!value) return null;
+  const prefix = resolveProfilePrefix(platform);
+  const match = value.match(new RegExp(`^${prefix.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')}-([0-9]+)$`));
+  if (!match) return null;
+  const seq = Number(match[1]);
+  if (!Number.isFinite(seq) || seq < 0) return null;
+  return seq;
+}
+
+function resolveUsedAutoSeq(index, platform) {
+  const tag = resolveAutoTag(platform);
+  const pattern = new RegExp(`^${tag}-([0-9]+)$`);
+  const used = new Set();
+  for (const row of (index?.accounts || [])) {
+    const id = String(row?.id || '').trim();
+    const match = id.match(pattern);
+    if (!match) continue;
+    const seq = Number(match[1]);
+    if (!Number.isFinite(seq) || seq < 0) continue;
+    used.add(seq);
+  }
+  return used;
+}
+
+function resolveNextAutoSeq(index, platform, preferredSeq = null) {
+  const used = resolveUsedAutoSeq(index, platform);
+  const preferred = Number(preferredSeq);
+  if (Number.isFinite(preferred) && preferred >= 0 && !used.has(preferred)) {
+    return preferred;
+  }
+  let seq = 0;
+  while (used.has(seq)) seq += 1;
+  return seq;
+}
+
 function ensureAliasUnique(accounts, alias, exceptId = '') {
   if (!alias) return;
   const target = alias.toLowerCase();
@@ -227,10 +308,7 @@ function persistAccountMeta(account) {
 }
 
 function deleteAccountMeta(id) {
-  const dir = resolveAccountDir(id);
-  if (fs.existsSync(dir)) {
-    fs.rmSync(dir, { recursive: true, force: true });
-  }
+  removeAccountDirById(id);
 }
 
 function resolveAccountName(inputName, platform, seq) {
@@ -249,9 +327,11 @@ function buildProfileAccountView(profileId, record = null) {
   const accountId = normalizeText(record?.accountId);
   const status = normalizeStatus(record?.status || (accountId ? STATUS_VALID : STATUS_INVALID));
   const valid = status === STATUS_VALID && Boolean(accountId);
+  const platform = normalizePlatform(record?.platform);
   return {
     profileId,
     accountRecordId: record?.id || null,
+    platform,
     accountId,
     alias: normalizeText(record?.alias),
     name: normalizeText(record?.name),
@@ -305,9 +385,29 @@ export function getAccount(idOrAlias) {
 
 export async function addAccount(input = {}) {
   const index = loadIndex();
-  const seq = Number(index.nextSeq) || 1;
   const platform = normalizePlatform(input.platform);
-  const id = ensureSafeName(normalizeId(input.id, platform, seq), 'id');
+  const hasCustomId = Boolean(normalizeText(input.id));
+  const explicitProfileId = normalizeText(input.profileId);
+  const autoPrefix = resolveProfilePrefix(platform);
+  let seq = null;
+  let profileId = explicitProfileId;
+
+  if (!hasCustomId && !explicitProfileId) {
+    // Default path: account/profile share the same minimal available slot.
+    seq = resolveNextAutoSeq(index, platform, null);
+    profileId = `${autoPrefix}-${seq}`;
+  } else {
+    profileId = explicitProfileId || resolveNextProfileId(autoPrefix);
+    const profileSeq = resolveProfileSeq(profileId, platform);
+    seq = resolveNextAutoSeq(index, platform, hasCustomId ? null : profileSeq);
+  }
+
+  await ensureProfile(profileId);
+
+  const id = ensureSafeName(
+    hasCustomId ? normalizeId(input.id, platform, seq) : buildAutoAccountId(platform, seq),
+    'id',
+  );
   if (index.accounts.some((item) => item?.id === id)) {
     throw new Error(`account id already exists: ${id}`);
   }
@@ -315,21 +415,24 @@ export async function addAccount(input = {}) {
   const alias = normalizeAlias(input.alias) || normalizeAlias(input.username);
   ensureAliasUnique(index.accounts, alias);
 
-  const profileId = normalizeText(input.profileId)
-    || resolveNextProfileId(resolveProfilePrefix(platform));
-  await ensureProfile(profileId);
-
   const fingerprintId = normalizeText(input.fingerprintId) || profileId;
   const createdAt = nowIso();
   const accountId = normalizeText(input.accountId || input.platformAccountId || null);
-  const status = accountId ? STATUS_VALID : STATUS_INVALID;
+  const requestedStatus = normalizeStatus(input.status);
+  const status = accountId
+    ? STATUS_VALID
+    : (requestedStatus === STATUS_PENDING ? STATUS_PENDING : STATUS_INVALID);
+  const reason =
+    status === STATUS_VALID
+      ? null
+      : (status === STATUS_PENDING ? 'waiting_login' : 'missing_account_id');
   const account = {
     id,
     seq,
     platform,
     status,
-    valid: status === STATUS_VALID,
-    reason: status === STATUS_VALID ? null : 'missing_account_id',
+    valid: false,
+    reason,
     accountId,
     name: accountId || resolveAccountName(input.name, platform, seq),
     alias,
@@ -342,7 +445,7 @@ export async function addAccount(input = {}) {
   };
 
   index.accounts.push(account);
-  index.nextSeq = seq + 1;
+  index.nextSeq = Math.max(Number(index.nextSeq) || 1, seq + 1);
   saveIndex(index);
   persistAccountMeta(account);
 
@@ -406,9 +509,14 @@ export async function updateAccount(idOrAlias, patch = {}) {
     next.name = String(next.accountId);
   }
   if (!next.accountId) {
-    next.status = STATUS_INVALID;
-    next.valid = false;
-    if (!next.reason) next.reason = 'missing_account_id';
+    if (next.status === STATUS_PENDING) {
+      next.valid = false;
+      if (!next.reason) next.reason = 'waiting_login';
+    } else {
+      next.status = STATUS_INVALID;
+      next.valid = false;
+      if (!next.reason) next.reason = 'missing_account_id';
+    }
   } else if (next.status !== 'disabled' && next.status !== 'archived') {
     next.status = next.valid === false ? STATUS_INVALID : STATUS_VALID;
   }
@@ -418,6 +526,9 @@ export async function updateAccount(idOrAlias, patch = {}) {
   } else if (next.status === STATUS_INVALID) {
     next.valid = false;
     next.reason = next.reason || 'invalid';
+  } else if (next.status === STATUS_PENDING) {
+    next.valid = false;
+    next.reason = next.reason || 'waiting_login';
   }
 
   next.updatedAt = nowIso();
@@ -437,7 +548,9 @@ export function upsertProfileAccountState(input = {}) {
   const alias = normalizeAlias(input.alias);
   const reason = normalizeText(input.reason);
   const detectedAt = normalizeText(input.detectedAt) || nowIso();
-  const status = accountId ? STATUS_VALID : STATUS_INVALID;
+  const statusHint = normalizeStatus(input.status);
+  const pendingMode = !accountId && statusHint === STATUS_PENDING;
+  const status = accountId ? STATUS_VALID : (pendingMode ? STATUS_PENDING : STATUS_INVALID);
 
   const index = loadIndex();
   const existingByProfile = resolveAccountByProfile(index, profileId);
@@ -445,20 +558,86 @@ export function upsertProfileAccountState(input = {}) {
   let target = existingByAccountId || existingByProfile || null;
   const purgeIds = new Set();
 
-  if (!target && !accountId) {
+  if (!accountId) {
+    if (target && hasPersistentAccountId(target)) {
+      const nextStatus = pendingMode ? STATUS_PENDING : STATUS_INVALID;
+      const next = {
+        ...target,
+        platform,
+        profileId,
+        fingerprintId: profileId,
+        status: nextStatus,
+        valid: false,
+        reason: reason || (nextStatus === STATUS_PENDING ? 'waiting_login' : 'invalid'),
+        detectedAt,
+        updatedAt: nowIso(),
+      };
+      const rowIndex = index.accounts.findIndex((item) => item?.id === target.id);
+      if (rowIndex < 0) throw new Error(`account not found: ${target.id}`);
+      index.accounts[rowIndex] = next;
+      saveIndex(index);
+      persistAccountMeta(next);
+      return buildProfileAccountView(profileId, next);
+    }
+
+    if (pendingMode) {
+      const profileSeq = resolveProfileSeq(profileId, platform);
+      const seq = resolveNextAutoSeq(index, platform, profileSeq);
+      const id = ensureSafeName(buildAutoAccountId(platform, seq), 'id');
+      const createdAt = nowIso();
+      const record = {
+        id,
+        seq,
+        platform,
+        status: STATUS_PENDING,
+        valid: false,
+        reason: reason || 'waiting_login',
+        accountId: null,
+        name: `${platform}-${profileId}`,
+        alias: alias || null,
+        username: null,
+        profileId,
+        fingerprintId: profileId,
+        createdAt,
+        updatedAt: createdAt,
+        detectedAt,
+        aliasSource: alias ? 'auto' : null,
+      };
+      index.accounts.push(record);
+      index.nextSeq = Math.max(Number(index.nextSeq) || 1, seq + 1);
+      saveIndex(index);
+      persistAccountMeta(record);
+      return buildProfileAccountView(profileId, record);
+    }
+
+    const staleIds = index.accounts
+      .filter((item) => String(item?.profileId || '').trim() === profileId && !hasPersistentAccountId(item))
+      .map((item) => String(item?.id || '').trim())
+      .filter(Boolean);
+    if (staleIds.length > 0) {
+      index.accounts = index.accounts.filter((item) => {
+        const id = String(item?.id || '').trim();
+        return !staleIds.includes(id);
+      });
+      saveIndex(index);
+      for (const id of staleIds) deleteAccountMeta(id);
+    }
+
     return buildProfileAccountView(profileId, {
       profileId,
       accountId: null,
-      status: STATUS_INVALID,
+      alias: null,
+      status,
       valid: false,
-      reason: reason || 'missing_account_id',
+      reason: reason || (pendingMode ? 'waiting_login' : 'missing_account_id'),
       updatedAt: detectedAt,
     });
   }
 
   if (!target) {
-    const seq = Number(index.nextSeq) || 1;
-    const id = ensureSafeName(normalizeId(`${platform}-${profileId}`, platform, seq), 'id');
+    const profileSeq = resolveProfileSeq(profileId, platform);
+    const seq = resolveNextAutoSeq(index, platform, profileSeq);
+    const id = ensureSafeName(buildAutoAccountId(platform, seq), 'id');
     const createdAt = nowIso();
     const record = {
       id,
@@ -479,7 +658,7 @@ export function upsertProfileAccountState(input = {}) {
       aliasSource: alias ? 'auto' : null,
     };
     index.accounts.push(record);
-    index.nextSeq = seq + 1;
+    index.nextSeq = Math.max(Number(index.nextSeq) || 1, seq + 1);
     saveIndex(index);
     persistAccountMeta(record);
     return buildProfileAccountView(profileId, record);
@@ -553,6 +732,16 @@ export function markProfileInvalid(profileId, reason = 'login_guard') {
   });
 }
 
+export function markProfilePending(profileId, reason = 'waiting_login') {
+  const id = ensureSafeName(normalizeText(profileId), 'profileId');
+  return upsertProfileAccountState({
+    profileId: id,
+    accountId: null,
+    status: STATUS_PENDING,
+    reason,
+  });
+}
+
 export function removeAccount(idOrAlias, options = {}) {
   const index = loadIndex();
   const account = resolveAccountOrThrow(index, idOrAlias);

package/apps/webauto/entry/lib/bus-publish.mjs

@@ -0,0 +1,63 @@
+import WebSocket from 'ws';
+
+function resolveBusUrl() {
+  const explicit = String(process.env.WEBAUTO_UNIFIED_BUS_URL || '').trim();
+  if (explicit) return explicit;
+  const host = String(process.env.WEBAUTO_UNIFIED_HOST || '127.0.0.1').trim() || '127.0.0.1';
+  const port = Number(
+    process.env.WEBAUTO_FLOATING_BUS_PORT
+    || process.env.WEBAUTO_UNIFIED_PORT
+    || 7701,
+  );
+  return `ws://${host}:${Number.isFinite(port) ? port : 7701}/bus`;
+}
+
+export async function publishBusEvent(payload, options = {}) {
+  const message = typeof payload === 'string' ? payload : JSON.stringify(payload ?? {});
+  const timeoutMs = Math.max(300, Number(options.timeoutMs || 1500));
+  const url = resolveBusUrl();
+
+  return await new Promise((resolve) => {
+    let settled = false;
+    let sent = false;
+    let ws;
+
+    const done = (ok) => {
+      if (settled) return;
+      settled = true;
+      resolve(ok);
+    };
+
+    try {
+      ws = new WebSocket(url);
+    } catch {
+      done(false);
+      return;
+    }
+
+    const timer = setTimeout(() => {
+      try { ws?.terminate(); } catch {}
+      done(false);
+    }, timeoutMs);
+
+    ws.on('open', () => {
+      try {
+        ws.send(message);
+        sent = true;
+      } catch {
+        // ignore send failure
+      }
+      setTimeout(() => {
+        try { ws.close(); } catch {}
+      }, 30);
+    });
+    ws.on('close', () => {
+      clearTimeout(timer);
+      done(sent);
+    });
+    ws.on('error', () => {
+      clearTimeout(timer);
+      done(false);
+    });
+  });
+}

package/apps/webauto/entry/lib/camo-cli.mjs

@@ -0,0 +1,93 @@
+import path from 'node:path';
+import { existsSync } from 'node:fs';
+import { spawnSync } from 'node:child_process';
+
+function resolveOnPath(candidates) {
+  const pathEnv = process.env.PATH || process.env.Path || '';
+  const dirs = pathEnv.split(path.delimiter).filter(Boolean);
+  for (const dir of dirs) {
+    for (const name of candidates) {
+      const full = path.join(dir, name);
+      if (existsSync(full)) return full;
+    }
+  }
+  return null;
+}
+
+function resolveInDir(dir, candidates) {
+  for (const name of candidates) {
+    const full = path.join(dir, name);
+    if (existsSync(full)) return full;
+  }
+  return null;
+}
+
+export function wrapWindowsRunner(cmdPath, prefix = []) {
+  if (process.platform !== 'win32') return { cmd: cmdPath, prefix };
+  const lower = String(cmdPath || '').toLowerCase();
+  if (lower.endsWith('.ps1')) {
+    return {
+      cmd: 'powershell.exe',
+      prefix: ['-NoProfile', '-ExecutionPolicy', 'Bypass', '-File', cmdPath, ...prefix],
+    };
+  }
+  if (lower.endsWith('.cmd') || lower.endsWith('.bat')) {
+    return {
+      cmd: 'cmd.exe',
+      prefix: ['/d', '/s', '/c', cmdPath, ...prefix],
+    };
+  }
+  return { cmd: cmdPath, prefix };
+}
+
+export function getCamoRunner(rootDir = process.cwd()) {
+  const isWin = process.platform === 'win32';
+  const localBin = path.join(rootDir, 'node_modules', '.bin');
+  const camoNames = isWin ? ['camo.cmd', 'camo.exe', 'camo.bat', 'camo.ps1'] : ['camo'];
+  const npxNames = isWin ? ['npx.cmd', 'npx.exe', 'npx.bat', 'npx.ps1'] : ['npx'];
+
+  const local = resolveInDir(localBin, camoNames);
+  if (local) return wrapWindowsRunner(local);
+
+  const global = resolveOnPath(camoNames);
+  if (global) return wrapWindowsRunner(global);
+
+  const npx = resolveOnPath(npxNames) || (isWin ? 'npx.cmd' : 'npx');
+  return wrapWindowsRunner(npx, ['--yes', '--package=@web-auto/camo', 'camo']);
+}
+
+function parseLastJson(stdout) {
+  const text = String(stdout || '').trim();
+  if (!text) return null;
+  const lines = text.split('\n').map((line) => line.trim()).filter(Boolean).reverse();
+  for (const line of lines) {
+    try {
+      return JSON.parse(line);
+    } catch {
+      continue;
+    }
+  }
+  return null;
+}
+
+export function runCamo(args, options = {}) {
+  const rootDir = String(options.rootDir || process.cwd());
+  const timeoutMs = Number(options.timeoutMs) > 0 ? Number(options.timeoutMs) : 60000;
+  const runner = getCamoRunner(rootDir);
+  const ret = spawnSync(runner.cmd, [...runner.prefix, ...args], {
+    cwd: rootDir,
+    env: { ...process.env, ...(options.env || {}) },
+    encoding: 'utf8',
+    timeout: timeoutMs,
+    windowsHide: true,
+  });
+  const stdout = String(ret.stdout || '').trim();
+  const stderr = String(ret.stderr || '').trim();
+  return {
+    ok: ret.status === 0,
+    code: ret.status,
+    stdout,
+    stderr,
+    json: parseLastJson(stdout),
+  };
+}

package/apps/webauto/entry/lib/profilepool.mjs

@@ -7,12 +7,19 @@ function resolvePortableRoot() {
   return root ? path.join(root, '.webauto') : '';
 }
 
+function resolveHomeDir() {
+  if (process.platform === 'win32') {
+    return process.env.USERPROFILE || os.homedir();
+  }
+  return process.env.HOME || os.homedir();
+}
+
 export function resolveProfilesRoot() {
   const envProfiles = String(process.env.WEBAUTO_PATHS_PROFILES || '').trim();
   if (envProfiles) return envProfiles;
   const portableRoot = resolvePortableRoot();
   if (portableRoot) return path.join(portableRoot, 'profiles');
-  return path.join(process.env.HOME || os.homedir(), '.webauto', 'profiles');
+  return path.join(resolveHomeDir(), '.webauto', 'profiles');
 }
 
 export function resolveFingerprintsRoot() {
@@ -20,7 +27,7 @@ export function resolveFingerprintsRoot() {
   if (envFps) return envFps;
   const portableRoot = resolvePortableRoot();
   if (portableRoot) return path.join(portableRoot, 'fingerprints');
-  return path.join(process.env.HOME || os.homedir(), '.webauto', 'fingerprints');
+  return path.join(resolveHomeDir(), '.webauto', 'fingerprints');
 }
 
 export function listProfiles() {
@@ -52,14 +59,16 @@ export function resolveNextProfileId(prefix) {
   const normalized = String(prefix || '').trim();
   if (!normalized) throw new Error('prefix is required');
   const { profiles } = listProfilesForPool(normalized);
-  let maxIndex = 0;
+  const used = new Set();
   for (const profileId of profiles) {
     const match = profileId.match(/-(\d+)$/);
     if (!match) continue;
     const index = Number(match[1]);
-    if (Number.isFinite(index)) maxIndex = Math.max(maxIndex, index);
+    if (Number.isFinite(index) && index >= 0) used.add(index);
   }
-  return `${normalized}-${maxIndex + 1}`;
+  let next = 0;
+  while (used.has(next)) next += 1;
+  return `${normalized}-${next}`;
 }
 
 export async function ensureProfile(profileId) {

package/apps/webauto/entry/lib/quota-status.mjs

@@ -0,0 +1,23 @@
+#!/usr/bin/env node
+/**
+ * quota-status.mjs - CLI tool to get rate limiter status
+ */
+
+import { RateLimiter } from '../../../../dist/modules/rate-limiter/index.js';
+
+async function main() {
+  const limiter = RateLimiter.getInstance();
+  await limiter.init();
+  
+  const status = limiter.getStatus();
+  
+  console.log(JSON.stringify({
+    ok: true,
+    quotas: status
+  }));
+}
+
+main().catch(err => {
+  console.error(JSON.stringify({ ok: false, error: err.message }));
+  process.exit(1);
+});