@web-auto/webauto 0.1.18 → 0.1.19

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

@@ -1,9 +1,8 @@
 import fs from 'node:fs';
 import path from 'node:path';
 import {
-  ensureProfile,
+  listProfiles,
   resolveFingerprintsRoot,
-  resolveNextProfileId,
   resolveProfilesRoot,
   resolveWebautoRoot,
 } from './profilepool.mjs';
@@ -16,6 +15,8 @@ const STATUS_ACTIVE = 'active';
 const STATUS_VALID = 'valid';
 const STATUS_INVALID = 'invalid';
 const STATUS_PENDING = 'pending';
+export const REQUIRED_ACCOUNT_PLATFORMS = Object.freeze(['xiaohongshu', 'weibo']);
+const MIN_REQUIRED_ACCOUNT_BINDINGS = 1;
 
 function nowIso() {
   return new Date().toISOString();
@@ -143,8 +144,16 @@ function removeAccountDirById(id) {
 }
 
 function hasPersistentAccountId(record) {
-  if (normalizeText(record?.accountId)) return true;
-  return normalizeStatus(record?.status) === STATUS_PENDING;
+  return Boolean(normalizeText(record?.accountId));
+}
+
+function assertExistingProfile(profileId) {
+  const id = ensureSafeName(profileId, 'profileId');
+  const { profiles } = listProfiles();
+  if (!profiles.includes(id)) {
+    throw new Error(`profile not found: ${id}. create/login account profile first`);
+  }
+  return id;
 }
 
 function isWithinDir(rootDir, targetPath) {
@@ -267,16 +276,57 @@ function ensureAliasUnique(accounts, alias, exceptId = '') {
   }
 }
 
-function resolveAccountOrThrow(index, key) {
-  const idOrAlias = String(key || '').trim();
-  if (!idOrAlias) throw new Error('account id or alias is required');
-  const byId = index.accounts.find((item) => item?.id === idOrAlias);
-  if (byId) return byId;
-  const target = idOrAlias.toLowerCase();
-  const byAlias = index.accounts.filter((item) => String(item?.alias || '').trim().toLowerCase() === target);
-  if (byAlias.length === 1) return byAlias[0];
-  if (byAlias.length > 1) throw new Error(`alias is not unique: ${idOrAlias}`);
-  throw new Error(`account not found: ${idOrAlias}`);
+function filterByPlatform(records, platform = null) {
+  const wanted = normalizeText(platform) ? normalizePlatform(platform) : null;
+  if (!wanted) return records;
+  return records.filter((item) => normalizePlatform(item?.platform) === wanted);
+}
+
+function resolveSingleOrThrow(records, field, key, platform = null) {
+  if (!Array.isArray(records) || records.length === 0) return null;
+  if (records.length === 1) return records[0];
+  const platformText = normalizeText(platform) ? ` under platform=${normalizePlatform(platform)}` : '';
+  const detail = records.map((item) => `${String(item?.id || '?')}(${normalizePlatform(item?.platform)})`).join(', ');
+  throw new Error(`${field} is not unique${platformText}: ${key} -> [${detail}]`);
+}
+
+function resolveAccountOrThrow(index, key, options = {}) {
+  const lookup = String(key || '').trim();
+  if (!lookup) throw new Error('account id, alias, profileId, or accountId is required');
+  const platform = normalizeText(options?.platform) ? normalizePlatform(options.platform) : null;
+  const rows = Array.isArray(index?.accounts) ? index.accounts : [];
+
+  const byId = filterByPlatform(rows.filter((item) => String(item?.id || '').trim() === lookup), platform);
+  const idMatch = resolveSingleOrThrow(byId, 'account id', lookup, platform);
+  if (idMatch) return idMatch;
+
+  const aliasTarget = lookup.toLowerCase();
+  const byAlias = filterByPlatform(
+    rows.filter((item) => String(item?.alias || '').trim().toLowerCase() === aliasTarget),
+    platform,
+  );
+  const aliasMatch = resolveSingleOrThrow(byAlias, 'alias', lookup, platform);
+  if (aliasMatch) return aliasMatch;
+
+  const byProfile = filterByPlatform(
+    rows.filter((item) => String(item?.profileId || '').trim() === lookup),
+    platform,
+  );
+  const profileMatch = resolveSingleOrThrow(byProfile, 'profileId', lookup, platform);
+  if (profileMatch) return profileMatch;
+
+  const accountIdTarget = normalizeText(lookup);
+  if (accountIdTarget) {
+    const byAccountId = filterByPlatform(
+      rows.filter((item) => normalizeText(item?.accountId) === accountIdTarget),
+      platform,
+    );
+    const accountIdMatch = resolveSingleOrThrow(byAccountId, 'accountId', lookup, platform);
+    if (accountIdMatch) return accountIdMatch;
+  }
+
+  const platformHint = platform ? ` under platform=${platform}` : '';
+  throw new Error(`account not found${platformHint}: ${lookup}`);
 }
 
 function resolveBindingKey(profileId, platform) {
@@ -352,6 +402,28 @@ function buildProfileAccountView(profileId, record = null) {
   };
 }
 
+function resolveProfileCoverage(rows) {
+  const byProfile = new Map();
+  for (const row of rows) {
+    const profileId = normalizeText(row?.profileId);
+    if (!profileId) continue;
+    if (!byProfile.has(profileId)) {
+      byProfile.set(profileId, {
+        profileId,
+        platforms: new Set(),
+      });
+    }
+    if (row?.valid === true && normalizeText(row?.accountId)) {
+      byProfile.get(profileId).platforms.add(normalizePlatform(row.platform));
+    }
+  }
+  return byProfile;
+}
+
+function isProfileFullyBound(platforms) {
+  return (platforms instanceof Set ? platforms.size : 0) >= MIN_REQUIRED_ACCOUNT_BINDINGS;
+}
+
 export function listAccountProfiles(options = {}) {
   const index = loadIndex();
   const platformFilter = normalizeText(options?.platform) ? normalizePlatform(options.platform) : null;
@@ -392,8 +464,6 @@ export function listAccountProfiles(options = {}) {
       return normalizePlatform(a?.platform).localeCompare(normalizePlatform(b?.platform));
     })
     .map((record) => buildProfileAccountView(record?.profileId, record));
-  const validProfilesSet = new Set();
-  const invalidProfilesSet = new Set();
   const validProfilesByPlatform = {};
   const invalidProfilesByPlatform = {};
   for (const row of rows) {
@@ -401,33 +471,52 @@ export function listAccountProfiles(options = {}) {
     if (!validProfilesByPlatform[platform]) validProfilesByPlatform[platform] = [];
     if (!invalidProfilesByPlatform[platform]) invalidProfilesByPlatform[platform] = [];
     if (row.valid) {
-      validProfilesSet.add(row.profileId);
       if (!validProfilesByPlatform[platform].includes(row.profileId)) {
         validProfilesByPlatform[platform].push(row.profileId);
       }
     } else {
-      invalidProfilesSet.add(row.profileId);
       if (!invalidProfilesByPlatform[platform].includes(row.profileId)) {
         invalidProfilesByPlatform[platform].push(row.profileId);
       }
     }
   }
-  const validProfiles = Array.from(validProfilesSet);
-  const invalidProfiles = Array.from(invalidProfilesSet).filter((profileId) => !validProfilesSet.has(profileId));
+  const coverage = resolveProfileCoverage(rows);
+  const savedProfiles = [];
+  const unsavedProfiles = [];
+  for (const [profileId, entry] of coverage.entries()) {
+    if (isProfileFullyBound(entry.platforms)) savedProfiles.push(profileId);
+    else unsavedProfiles.push(profileId);
+  }
+  savedProfiles.sort((a, b) => a.localeCompare(b));
+  unsavedProfiles.sort((a, b) => a.localeCompare(b));
+  const validProfiles = savedProfiles;
+  const invalidProfiles = unsavedProfiles;
   return {
     root: resolveAccountsRoot(),
     count: rows.length,
     profiles: rows,
     validProfiles,
     invalidProfiles,
+    savedProfiles,
+    unsavedProfiles,
     validProfilesByPlatform,
     invalidProfilesByPlatform,
   };
 }
 
-export function getAccount(idOrAlias) {
+export function listSavedProfiles() {
+  return listAccountProfiles().savedProfiles || [];
+}
+
+export function isProfileSaved(profileId) {
+  const id = normalizeText(profileId);
+  if (!id) return false;
+  return listSavedProfiles().includes(id);
+}
+
+export function getAccount(idOrAlias, options = {}) {
   const index = loadIndex();
-  return resolveAccountOrThrow(index, idOrAlias);
+  return resolveAccountOrThrow(index, idOrAlias, options);
 }
 
 export async function addAccount(input = {}) {
@@ -435,21 +524,12 @@ export async function addAccount(input = {}) {
   const platform = normalizePlatform(input.platform);
   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);
+  if (!explicitProfileId) {
+    throw new Error('profileId is required; automatic profile creation is disabled');
   }
-
-  await ensureProfile(profileId);
+  const profileId = assertExistingProfile(explicitProfileId);
+  const profileSeq = resolveProfileSeq(profileId, platform);
+  const seq = resolveNextAutoSeq(index, platform, hasCustomId ? null : profileSeq);
 
   const id = ensureSafeName(
     hasCustomId ? normalizeId(input.id, platform, seq) : buildAutoAccountId(platform, seq),
@@ -560,9 +640,8 @@ export async function updateAccount(idOrAlias, patch = {}) {
     next.reason = normalizeText(patch.reason);
   }
   if (Object.prototype.hasOwnProperty.call(patch, 'profileId')) {
-    const profileId = ensureSafeName(normalizeText(patch.profileId), 'profileId');
+    const profileId = assertExistingProfile(normalizeText(patch.profileId));
     if (profileId !== next.profileId) {
-      await ensureProfile(profileId);
       next.profileId = profileId;
       if (!Object.prototype.hasOwnProperty.call(patch, 'fingerprintId')) {
         next.fingerprintId = profileId;
@@ -623,6 +702,7 @@ export async function updateAccount(idOrAlias, patch = {}) {
 
 export function upsertProfileAccountState(input = {}) {
   const profileId = ensureSafeName(normalizeText(input.profileId), 'profileId');
+  assertExistingProfile(profileId);
   const platform = normalizePlatform(input.platform);
   const accountId = normalizeText(input.accountId || input.platformAccountId || null);
   const alias = normalizeAlias(input.alias);
@@ -639,76 +719,26 @@ export function upsertProfileAccountState(input = {}) {
   const purgeIds = new Set();
 
   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
-        && normalizePlatform(item?.platform) === platform
-        && !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);
+    if (!pendingMode) {
+      const staleIds = index.accounts
+        .filter((item) => (
+          String(item?.profileId || '').trim() === profileId
+          && normalizePlatform(item?.platform) === platform
+        ))
+        .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,
+      platform,
       accountId: null,
       alias: null,
       status,
@@ -808,27 +838,89 @@ export function upsertProfileAccountState(input = {}) {
   return buildProfileAccountView(profileId, next);
 }
 
-export function markProfileInvalid(profileId, reason = 'login_guard') {
+export function markProfileInvalid(profileId, reason = 'login_guard', platform = DEFAULT_PLATFORM) {
   const id = ensureSafeName(normalizeText(profileId), 'profileId');
   return upsertProfileAccountState({
     profileId: id,
-    platform: DEFAULT_PLATFORM,
+    platform: normalizePlatform(platform),
     accountId: null,
     reason,
   });
 }
 
-export function markProfilePending(profileId, reason = 'waiting_login') {
+export function markProfilePending(profileId, reason = 'waiting_login', platform = DEFAULT_PLATFORM) {
   const id = ensureSafeName(normalizeText(profileId), 'profileId');
   return upsertProfileAccountState({
     profileId: id,
-    platform: DEFAULT_PLATFORM,
+    platform: normalizePlatform(platform),
     accountId: null,
     status: STATUS_PENDING,
     reason,
   });
 }
 
+export function cleanupIncompleteProfiles(options = {}) {
+  const deleteProfileDirs = options?.deleteProfileDirs !== false;
+  const index = loadIndex();
+  const byProfile = new Map();
+  for (const row of index.accounts) {
+    const profileId = normalizeText(row?.profileId);
+    if (!profileId) continue;
+    if (!byProfile.has(profileId)) {
+      byProfile.set(profileId, {
+        profileId,
+        accountRecordIds: [],
+        platforms: new Set(),
+      });
+    }
+    const entry = byProfile.get(profileId);
+    if (row?.id) entry.accountRecordIds.push(row.id);
+    if (normalizeText(row?.accountId) && normalizeStatus(row?.status) === STATUS_VALID) {
+      entry.platforms.add(normalizePlatform(row?.platform));
+    }
+  }
+
+  const removedProfiles = [];
+  const removedRecordIds = [];
+  const purgeRecordIds = new Set();
+  const profileIds = new Set([...byProfile.keys(), ...listProfiles().profiles]);
+  for (const profileId of profileIds) {
+    const entry = byProfile.get(profileId) || {
+      profileId,
+      accountRecordIds: [],
+      platforms: new Set(),
+    };
+    if (isProfileFullyBound(entry.platforms)) continue;
+    removedProfiles.push(entry.profileId);
+    for (const id of entry.accountRecordIds) purgeRecordIds.add(id);
+  }
+  if (purgeRecordIds.size > 0) {
+    index.accounts = index.accounts.filter((row) => {
+      const id = String(row?.id || '').trim();
+      if (!id || !purgeRecordIds.has(id)) return true;
+      removedRecordIds.push(id);
+      return false;
+    });
+    saveIndex(index);
+    for (const id of removedRecordIds) {
+      deleteAccountMeta(id);
+    }
+  }
+
+  if (deleteProfileDirs) {
+    const profilesRoot = resolveProfilesRoot();
+    for (const profileId of removedProfiles) {
+      const profilePath = path.join(profilesRoot, profileId);
+      if (!isWithinDir(profilesRoot, profilePath)) continue;
+      fs.rmSync(profilePath, { recursive: true, force: true });
+    }
+  }
+  return {
+    removedProfiles,
+    removedRecords: removedRecordIds,
+  };
+}
+
 export function removeAccount(idOrAlias, options = {}) {
   const index = loadIndex();
   const account = resolveAccountOrThrow(index, idOrAlias);

package/apps/webauto/entry/lib/iflow-reply.mjs

@@ -0,0 +1,194 @@
+/**
+ * iflow-reply.mjs
+ * 
+ * 使用 iflow -p 生成智能回复
+ */
+
+import { spawn } from 'child_process';
+
+/**
+ * @typedef {Object} SmartReplyOptions
+ * @property {string} noteContent - 帖子正文
+ * @property {string} commentText - 命中的评论全文
+ * @property {string} replyIntent - 回复的中心意思（用户提供）
+ * @property {string} [style] - 回复风格
+ * @property {number} [maxLength] - 最大字数
+ * @property {string} [model] - 指定模型
+ */
+
+/**
+ * @typedef {Object} SmartReplyResult
+ * @property {boolean} ok
+ * @property {string} [reply]
+ * @property {string} [error]
+ * @property {number} [executionTimeMs]
+ * @property {{input: number, output: number, total: number}} [tokenUsage]
+ */
+
+/**
+ * Build prompt for iflow
+ * @param {SmartReplyOptions} opts
+ * @returns {string}
+ */
+function buildPrompt(opts) {
+  const { noteContent, commentText, replyIntent, style, maxLength } = opts;
+  const styleDesc = style || '友好、自然、口语化';
+  const maxLen = maxLength || 100;
+
+  return `你是一个小红书评论回复助手。请根据以下信息生成一条回复。
+
+## 帖子正文
+${noteContent}
+
+## 命中的评论
+${commentText}
+
+## 回复要求
+- 回复的中心意思：${replyIntent}
+- 回复风格：${styleDesc}
+- 字数限制：${maxLen}字以内
+- 不要使用表情符号开头
+- 不要过于正式，保持自然对话感
+- 可以适当使用 1-2 个表情符号
+
+请直接输出回复内容，不要有任何解释或说明。`;
+}
+
+/**
+ * Generate smart reply using iflow -p
+ * @param {SmartReplyOptions} opts
+ * @returns {Promise<SmartReplyResult>}
+ */
+export async function generateSmartReply(opts) {
+  const prompt = buildPrompt(opts);
+  const startTime = Date.now();
+
+  return new Promise((resolve) => {
+    const args = ['-p', prompt];
+    if (opts.model) {
+      args.unshift('-m', opts.model);
+    }
+
+    const child = spawn('iflow', args, {
+      stdio: ['ignore', 'pipe', 'pipe'],
+    });
+
+    let stdout = '';
+    let stderr = '';
+
+    child.stdout.on('data', (chunk) => {
+      stdout += String(chunk);
+    });
+
+    child.stderr.on('data', (chunk) => {
+      stderr += String(chunk);
+    });
+
+    const timeout = setTimeout(() => {
+      try {
+        child.kill('SIGTERM');
+      } catch {}
+      resolve({
+        ok: false,
+        error: 'timeout (30s)',
+        executionTimeMs: Date.now() - startTime,
+      });
+    }, 30000);
+
+    child.on('error', (err) => {
+      clearTimeout(timeout);
+      resolve({
+        ok: false,
+        error: err.message,
+        executionTimeMs: Date.now() - startTime,
+      });
+    });
+
+    child.on('close', (code) => {
+      clearTimeout(timeout);
+      const executionTimeMs = Date.now() - startTime;
+
+      if (code !== 0) {
+        resolve({
+          ok: false,
+          error: stderr || `exit code ${code}`,
+          executionTimeMs,
+        });
+        return;
+      }
+
+      const lines = stdout.trim().split('\n');
+      let replyText = '';
+      let tokenUsage = { input: 0, output: 0, total: 0 };
+
+      for (let i = lines.length - 1; i >= 0; i--) {
+        const line = lines[i].trim();
+        if (line.startsWith('{') && line.endsWith('}')) {
+          try {
+            const info = JSON.parse(line);
+            if (info.tokenUsage) {
+              tokenUsage = info.tokenUsage;
+              replyText = lines.slice(0, i).join('\n').trim();
+              break;
+            }
+          } catch {}
+        }
+      }
+
+      if (!replyText) {
+        replyText = stdout.trim();
+        const execInfoMatch = replyText.match(/<Execution Info>[\s\S]*$/);
+        if (execInfoMatch) {
+          replyText = replyText.slice(0, execInfoMatch.index).trim();
+        }
+      }
+
+      replyText = replyText
+        .replace(/^["']|["']$/g, '')
+        .replace(/\n+/g, ' ')
+        .trim();
+
+      if (!replyText) {
+        resolve({
+          ok: false,
+          error: 'empty reply from iflow',
+          executionTimeMs,
+        });
+        return;
+      }
+
+      resolve({
+        ok: true,
+        reply: replyText,
+        executionTimeMs,
+        tokenUsage,
+      });
+    });
+  });
+}
+
+/**
+ * Batch generate replies
+ * @param {Array<{noteContent: string, commentText: string, replyIntent: string}>} items
+ * @param {{style?: string, maxLength?: number, model?: string, concurrency?: number}} [opts]
+ * @returns {Promise<Array<SmartReplyResult & {index: number}>>}
+ */
+export async function generateBatchReplies(items, opts = {}) {
+  const concurrency = opts.concurrency || 3;
+  const results = [];
+
+  for (let i = 0; i < items.length; i += concurrency) {
+    const batch = items.slice(i, i + concurrency);
+    const batchResults = await Promise.all(
+      batch.map((item, batchIndex) =>
+        generateSmartReply({ ...item, ...opts }).then((r) => ({
+          ...r,
+          index: i + batchIndex,
+        })),
+      ),
+    );
+    results.push(...batchResults);
+  }
+
+  return results;
+}

package/apps/webauto/entry/lib/profile-policy.mjs

@@ -0,0 +1,48 @@
+import { listProfiles } from './profilepool.mjs';
+import { isProfileSaved } from './account-store.mjs';
+
+const TEMP_PROFILE_PATTERNS = [
+  /^test(?:$|[-_])/i,
+  /^tmp(?:$|[-_])/i,
+  /^temp(?:$|[-_])/i,
+  /^profile-\d+$/i,
+  /^debug(?:$|[-_])/i,
+];
+
+function normalizeProfileId(input) {
+  return String(input || '').trim();
+}
+
+export function isTemporaryProfileId(profileId) {
+  const id = normalizeProfileId(profileId);
+  if (!id) return false;
+  return TEMP_PROFILE_PATTERNS.some((pattern) => pattern.test(id));
+}
+
+export function assertProfileUsable(profileId) {
+  const id = normalizeProfileId(profileId);
+  if (!id) {
+    throw new Error('profileId is required');
+  }
+  if (isTemporaryProfileId(id)) {
+    throw new Error(`forbidden temporary profileId: ${id}`);
+  }
+  const profiles = listProfiles().profiles || [];
+  if (!profiles.includes(id)) {
+    throw new Error(`profile not found: ${id}. create/login account profile first`);
+  }
+  if (!isProfileSaved(id)) {
+    throw new Error(`profile not saved: ${id}. require at least one valid social account binding`);
+  }
+  return id;
+}
+
+export function assertProfilesUsable(profileIds) {
+  const list = Array.from(new Set((Array.isArray(profileIds) ? profileIds : [])
+    .map((item) => normalizeProfileId(item))
+    .filter(Boolean)));
+  if (list.length === 0) {
+    throw new Error('missing --profile/--profiles/--profilepool');
+  }
+  return list.map((profileId) => assertProfileUsable(profileId));
+}

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

@@ -114,6 +114,18 @@ export async function ensureProfile(profileId) {
   return { root, profileDir, profileId: id };
 }
 
+export function assertProfileExists(profileId) {
+  const id = String(profileId || '').trim();
+  if (!id) throw new Error('profileId is required');
+  if (id.includes('/') || id.includes('\\')) throw new Error('invalid profileId');
+  const root = resolveProfilesRoot();
+  const profileDir = path.join(root, id);
+  if (!fs.existsSync(profileDir) || !fs.statSync(profileDir).isDirectory()) {
+    throw new Error(`profile not found: ${id}. create/login account profile first`);
+  }
+  return { root, profileDir, profileId: id };
+}
+
 async function ensureFingerprint(profileId) {
   try {
     const modulePath = path.resolve(process.cwd(), 'dist', 'modules', 'camo-backend', 'src', 'internal', 'fingerprint.js');