@web-auto/webauto 0.1.8 → 0.1.11

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

@@ -1,16 +1,17 @@
 import fs from 'node:fs';
-import os from 'node:os';
 import path from 'node:path';
 import {
   ensureProfile,
   resolveFingerprintsRoot,
   resolveNextProfileId,
   resolveProfilesRoot,
+  resolveWebautoRoot,
 } from './profilepool.mjs';
 
 const INDEX_FILE = 'index.json';
 const META_FILE = 'meta.json';
 const DEFAULT_PLATFORM = 'xiaohongshu';
+const DEFAULT_PROFILE_PREFIX = 'profile';
 const STATUS_ACTIVE = 'active';
 const STATUS_VALID = 'valid';
 const STATUS_INVALID = 'invalid';
@@ -118,18 +119,6 @@ function ensureSafeName(name, field) {
   return value;
 }
 
-function resolvePortableRoot() {
-  const root = String(process.env.WEBAUTO_PORTABLE_ROOT || process.env.WEBAUTO_ROOT || '').trim();
-  return root ? path.join(root, '.webauto') : '';
-}
-
-export function resolveWebautoRoot() {
-  const portableRoot = resolvePortableRoot();
-  if (portableRoot) return portableRoot;
-  const home = process.env.HOME || process.env.USERPROFILE || os.homedir();
-  return path.join(home, '.webauto');
-}
-
 export function resolveAccountsRoot() {
   const envRoot = String(process.env.WEBAUTO_PATHS_ACCOUNTS || '').trim();
   if (envRoot) return envRoot;
@@ -213,21 +202,31 @@ function saveIndex(index) {
   return payload;
 }
 
-function resolveProfilePrefix(platform) {
+function resolveLegacyProfilePrefix(platform) {
   if (platform === 'xiaohongshu') return 'xiaohongshu-batch';
   const slug = toSlug(platform) || 'account';
   return `${slug}-account`;
 }
 
+function resolveProfilePrefix() {
+  return DEFAULT_PROFILE_PREFIX;
+}
+
 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;
+  const prefixes = [
+    resolveProfilePrefix(),
+    resolveLegacyProfilePrefix(platform),
+  ].filter(Boolean);
+  for (const prefix of prefixes) {
+    const match = value.match(new RegExp(`^${prefix.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')}-([0-9]+)$`));
+    if (!match) continue;
+    const seq = Number(match[1]);
+    if (!Number.isFinite(seq) || seq < 0) return null;
+    return seq;
+  }
+  return null;
 }
 
 function resolveUsedAutoSeq(index, platform) {
@@ -280,23 +279,34 @@ function resolveAccountOrThrow(index, key) {
   throw new Error(`account not found: ${idOrAlias}`);
 }
 
-function resolveAccountByProfile(index, profileId) {
+function resolveBindingKey(profileId, platform) {
+  const pid = String(profileId || '').trim();
+  const pf = normalizePlatform(platform);
+  if (!pid) return '';
+  return `${pid}::${pf}`;
+}
+
+function resolveAccountByProfile(index, profileId, platform = null) {
   const value = String(profileId || '').trim();
   if (!value) return null;
+  const wantedPlatform = platform ? normalizePlatform(platform) : null;
   let matched = null;
   for (const item of index.accounts) {
     if (String(item?.profileId || '').trim() !== value) continue;
+    if (wantedPlatform && normalizePlatform(item?.platform) !== wantedPlatform) continue;
     matched = pickNewerRecord(matched, item);
   }
   return matched;
 }
 
-function resolveAccountByAccountId(index, accountId) {
+function resolveAccountByAccountId(index, accountId, platform = null) {
   const value = normalizeText(accountId);
   if (!value) return null;
+  const wantedPlatform = platform ? normalizePlatform(platform) : null;
   let matched = null;
   for (const item of index.accounts) {
     if (normalizeText(item?.accountId) !== value) continue;
+    if (wantedPlatform && normalizePlatform(item?.platform) !== wantedPlatform) continue;
     matched = pickNewerRecord(matched, item);
   }
   return matched;
@@ -342,39 +352,76 @@ function buildProfileAccountView(profileId, record = null) {
   };
 }
 
-export function listAccountProfiles() {
+export function listAccountProfiles(options = {}) {
   const index = loadIndex();
+  const platformFilter = normalizeText(options?.platform) ? normalizePlatform(options.platform) : null;
   const byAccountId = new Map();
   for (const record of index.accounts) {
+    const recordPlatform = normalizePlatform(record?.platform);
+    if (platformFilter && recordPlatform !== platformFilter) continue;
     const accountId = normalizeText(record?.accountId);
     if (!accountId) continue;
-    byAccountId.set(accountId, pickNewerRecord(byAccountId.get(accountId), record));
+    const key = `${recordPlatform}::${accountId}`;
+    byAccountId.set(key, pickNewerRecord(byAccountId.get(key), record));
   }
   const deduped = [];
   for (const record of index.accounts) {
+    const recordPlatform = normalizePlatform(record?.platform);
+    if (platformFilter && recordPlatform !== platformFilter) continue;
     const accountId = normalizeText(record?.accountId);
     if (accountId) {
-      if (byAccountId.get(accountId) !== record) continue;
+      const key = `${recordPlatform}::${accountId}`;
+      if (byAccountId.get(key) !== record) continue;
     }
     deduped.push(record);
   }
-  const byProfile = new Map();
+  const byBinding = new Map();
   for (const record of deduped) {
     const profileId = normalizeText(record?.profileId);
     if (!profileId) continue;
-    byProfile.set(profileId, pickNewerRecord(byProfile.get(profileId), record));
+    const key = resolveBindingKey(profileId, record?.platform);
+    if (!key) continue;
+    byBinding.set(key, pickNewerRecord(byBinding.get(key), record));
+  }
+  const rows = Array.from(byBinding.values())
+    .sort((a, b) => {
+      const seqCmp = Number(a?.seq || 0) - Number(b?.seq || 0);
+      if (seqCmp !== 0) return seqCmp;
+      const pCmp = String(a?.profileId || '').localeCompare(String(b?.profileId || ''));
+      if (pCmp !== 0) return pCmp;
+      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) {
+    const platform = normalizePlatform(row.platform);
+    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 rows = Array.from(byProfile.entries())
-    .sort((a, b) => (Number(a[1]?.seq || 0) - Number(b[1]?.seq || 0)))
-    .map(([profileId, record]) => buildProfileAccountView(profileId, record));
-  const validProfiles = rows.filter((item) => item.valid).map((item) => item.profileId);
-  const invalidProfiles = rows.filter((item) => !item.valid).map((item) => item.profileId);
+  const validProfiles = Array.from(validProfilesSet);
+  const invalidProfiles = Array.from(invalidProfilesSet).filter((profileId) => !validProfilesSet.has(profileId));
   return {
     root: resolveAccountsRoot(),
     count: rows.length,
     profiles: rows,
     validProfiles,
     invalidProfiles,
+    validProfilesByPlatform,
+    invalidProfilesByPlatform,
   };
 }
 
@@ -426,6 +473,39 @@ export async function addAccount(input = {}) {
     status === STATUS_VALID
       ? null
       : (status === STATUS_PENDING ? 'waiting_login' : 'missing_account_id');
+
+  if (accountId) {
+    const existing = resolveAccountByAccountId(index, accountId, platform);
+    if (existing) {
+      const next = {
+        ...existing,
+        platform,
+        status,
+        valid: status === STATUS_VALID,
+        reason,
+        accountId,
+        name: accountId,
+        alias: alias || existing.alias || null,
+        username: normalizeText(input.username) || existing.username || null,
+        profileId,
+        fingerprintId,
+        updatedAt: createdAt,
+        aliasSource: alias ? (normalizeAlias(input.alias) ? 'manual' : 'username') : existing.aliasSource || null,
+      };
+      if (alias) ensureAliasUnique(index.accounts, alias, existing.id);
+      const rowIndex = index.accounts.findIndex((item) => item?.id === existing.id);
+      if (rowIndex < 0) throw new Error(`account not found: ${existing.id}`);
+      index.accounts[rowIndex] = next;
+      saveIndex(index);
+      persistAccountMeta(next);
+      return {
+        root: resolveAccountsRoot(),
+        account: next,
+        deduped: true,
+      };
+    }
+  }
+
   const account = {
     id,
     seq,
@@ -553,8 +633,8 @@ export function upsertProfileAccountState(input = {}) {
   const status = accountId ? STATUS_VALID : (pendingMode ? STATUS_PENDING : STATUS_INVALID);
 
   const index = loadIndex();
-  const existingByProfile = resolveAccountByProfile(index, profileId);
-  const existingByAccountId = accountId ? resolveAccountByAccountId(index, accountId) : null;
+  const existingByProfile = resolveAccountByProfile(index, profileId, platform);
+  const existingByAccountId = accountId ? resolveAccountByAccountId(index, accountId, platform) : null;
   let target = existingByAccountId || existingByProfile || null;
   const purgeIds = new Set();
 
@@ -611,7 +691,11 @@ export function upsertProfileAccountState(input = {}) {
     }
 
     const staleIds = index.accounts
-      .filter((item) => String(item?.profileId || '').trim() === profileId && !hasPersistentAccountId(item))
+      .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) {
@@ -677,6 +761,7 @@ export function upsertProfileAccountState(input = {}) {
   if (accountId) {
     for (const row of index.accounts) {
       if (!row || row.id === target.id) continue;
+      if (normalizePlatform(row?.platform) !== platform) continue;
       if (normalizeText(row.accountId) === accountId) {
         purgeIds.add(row.id);
       }
@@ -727,6 +812,7 @@ export function markProfileInvalid(profileId, reason = 'login_guard') {
   const id = ensureSafeName(normalizeText(profileId), 'profileId');
   return upsertProfileAccountState({
     profileId: id,
+    platform: DEFAULT_PLATFORM,
     accountId: null,
     reason,
   });
@@ -736,6 +822,7 @@ export function markProfilePending(profileId, reason = 'waiting_login') {
   const id = ensureSafeName(normalizeText(profileId), 'profileId');
   return upsertProfileAccountState({
     profileId: id,
+    platform: DEFAULT_PLATFORM,
     accountId: null,
     status: STATUS_PENDING,
     reason,

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

@@ -2,32 +2,64 @@ import os from 'node:os';
 import path from 'node:path';
 import fs from 'node:fs';
 
-function resolvePortableRoot() {
-  const root = String(process.env.WEBAUTO_PORTABLE_ROOT || process.env.WEBAUTO_ROOT || '').trim();
-  return root ? path.join(root, '.webauto') : '';
+function hasDrive(letter) {
+  if (process.platform !== 'win32') return false;
+  try {
+    return fs.existsSync(`${String(letter || '').replace(/[^A-Za-z]/g, '').toUpperCase()}:\\`);
+  } catch {
+    return false;
+  }
 }
 
-function resolveHomeDir() {
-  if (process.platform === 'win32') {
-    return process.env.USERPROFILE || os.homedir();
-  }
+function normalizePathForPlatform(input, platform = process.platform) {
+  const raw = String(input || '').trim();
+  const isWinPath = platform === 'win32' || /^[A-Za-z]:[\\/]/.test(raw);
+  const pathApi = isWinPath ? path.win32 : path;
+  return isWinPath ? pathApi.normalize(raw) : path.resolve(raw);
+}
+
+function normalizeLegacyWebautoRoot(input, platform = process.platform) {
+  const pathApi = platform === 'win32' ? path.win32 : path;
+  const resolved = normalizePathForPlatform(input, platform);
+  const base = pathApi.basename(resolved).toLowerCase();
+  if (base === '.webauto' || base === 'webauto') return resolved;
+  return pathApi.join(resolved, '.webauto');
+}
+
+function resolveHomeDir(platform = process.platform) {
+  if (platform === 'win32') return process.env.USERPROFILE || os.homedir();
   return process.env.HOME || os.homedir();
 }
 
+export function resolveWebautoRoot(options = {}) {
+  const env = options.env || process.env;
+  const platform = String(options.platform || process.platform);
+  const homeDir = String(options.homeDir || resolveHomeDir(platform));
+  const pathApi = platform === 'win32' ? path.win32 : path;
+
+  const explicitHome = String(env.WEBAUTO_HOME || '').trim();
+  if (explicitHome) return normalizePathForPlatform(explicitHome, platform);
+
+  const legacyRoot = String(env.WEBAUTO_ROOT || env.WEBAUTO_PORTABLE_ROOT || '').trim();
+  if (legacyRoot) return normalizeLegacyWebautoRoot(legacyRoot, platform);
+
+  if (platform === 'win32') {
+    const dDriveExists = typeof options.hasDDrive === 'boolean' ? options.hasDDrive : hasDrive('D');
+    return dDriveExists ? 'D:\\webauto' : pathApi.join(homeDir, '.webauto');
+  }
+  return pathApi.join(homeDir, '.webauto');
+}
+
 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(resolveHomeDir(), '.webauto', 'profiles');
+  return path.join(resolveWebautoRoot(), 'profiles');
 }
 
 export function resolveFingerprintsRoot() {
   const envFps = String(process.env.WEBAUTO_PATHS_FINGERPRINTS || '').trim();
   if (envFps) return envFps;
-  const portableRoot = resolvePortableRoot();
-  if (portableRoot) return path.join(portableRoot, 'fingerprints');
-  return path.join(resolveHomeDir(), '.webauto', 'fingerprints');
+  return path.join(resolveWebautoRoot(), 'fingerprints');
 }
 
 export function listProfiles() {

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

@@ -1,6 +1,6 @@
 import fs from 'node:fs';
-import os from 'node:os';
 import path from 'node:path';
+import { resolveWebautoRoot } from './profilepool.mjs';
 
 const INDEX_FILE = 'index.json';
 const DEFAULT_COMMAND_TYPE = 'xhs-unified';
@@ -78,18 +78,6 @@ function normalizeMaxRuns(value, fallback = null) {
   return Math.max(1, Math.floor(n));
 }
 
-function resolvePortableRoot() {
-  const root = String(process.env.WEBAUTO_PORTABLE_ROOT || process.env.WEBAUTO_ROOT || '').trim();
-  return root ? path.join(root, '.webauto') : '';
-}
-
-function resolveWebautoRoot() {
-  const portableRoot = resolvePortableRoot();
-  if (portableRoot) return portableRoot;
-  const home = process.env.HOME || process.env.USERPROFILE || os.homedir();
-  return path.join(home, '.webauto');
-}
-
 export function resolveSchedulesRoot() {
   const explicit = String(process.env.WEBAUTO_PATHS_SCHEDULES || '').trim();
   if (explicit) return explicit;
@@ -464,20 +452,11 @@ function validateCommand(task) {
 
 function validateXhsCommand(argv) {
   const keyword = normalizeText(argv.keyword || argv.k);
-  const profile = normalizeText(argv.profile);
-  const profiles = normalizeText(argv.profiles);
-  const profilepool = normalizeText(argv.profilepool);
   if (!keyword) throw new Error('task command argv missing keyword');
-  if (!profile && !profiles && !profilepool) {
-    throw new Error('task command argv missing profile/profiles/profilepool');
-  }
 }
 
 function validateGenericCommand(argv, platform, commandType = '') {
   const keyword = normalizeText(argv.keyword || argv.k);
-  const profile = normalizeText(argv.profile);
-  const profiles = normalizeText(argv.profiles);
-  const profilepool = normalizeText(argv.profilepool);
   let weiboTaskType = '';
   if (platform === 'weibo') {
     weiboTaskType = String(argv['task-type'] || argv.taskType || '').trim();
@@ -495,9 +474,6 @@ function validateGenericCommand(argv, platform, commandType = '') {
   if (!keyword && (platform !== 'weibo' || weiboTaskType === 'search')) {
     throw new Error('task command argv missing keyword');
   }
-  if (!profile && !profiles && !profilepool) {
-    throw new Error('task command argv missing profile/profiles/profilepool');
-  }
 }
 
 function normalizeScheduleFields(input = {}, fallback = {}) {

package/apps/webauto/entry/profilepool.mjs

@@ -173,6 +173,46 @@ async function cmdMigrateFingerprints(jsonMode) {
   output({ ok: true, checked: profiles.length, ensured: created.length }, jsonMode);
 }
 
+async function cmdGotoProfile(profileId, argv, jsonMode) {
+  const id = String(profileId || '').trim();
+  if (!id) throw new Error('profileId is required');
+  const url = String(argv.url || argv._?.[2] || '').trim();
+  if (!url) throw new Error('url is required');
+  await ensureProfile(id);
+
+  const gotoRet = runCamo(['goto', id, url], { rootDir: ROOT, timeoutMs: 30000 });
+  if (gotoRet.ok) {
+    output({
+      ok: true,
+      profileId: id,
+      url,
+      mode: 'goto',
+      result: gotoRet.json || null,
+    }, jsonMode);
+    return;
+  }
+
+  const idleTimeout = String(argv['idle-timeout'] || process.env.WEBAUTO_LOGIN_IDLE_TIMEOUT || '30m').trim() || '30m';
+  const startRet = runCamo(['start', id, '--url', url, '--idle-timeout', idleTimeout], { rootDir: ROOT });
+  if (!startRet.ok) {
+    output({
+      ok: false,
+      profileId: id,
+      url,
+      mode: 'start',
+      error: startRet.stderr || startRet.stdout || gotoRet.stderr || gotoRet.stdout || 'goto/start failed',
+    }, jsonMode);
+    process.exit(1);
+  }
+  output({
+    ok: true,
+    profileId: id,
+    url,
+    mode: 'start',
+    session: startRet.json || null,
+  }, jsonMode);
+}
+
 async function main() {
   const argv = minimist(process.argv.slice(2));
   const cmd = String(argv._[0] || '').trim();
@@ -180,14 +220,16 @@ async function main() {
   const jsonMode = argv.json === true;
 
   if (!cmd || cmd === 'help' || cmd === '--help' || cmd === '-h') {
-    console.log('Usage: node apps/webauto/entry/profilepool.mjs <list|add|login|login-profile|migrate-fingerprints> ... [--json]');
+    console.log('Usage: node apps/webauto/entry/profilepool.mjs <list|add|login|login-profile|goto-profile|migrate-fingerprints> ... [--json]');
+    console.log('Default profile prefix: profile (e.g. profile-0, profile-1)');
     return;
   }
 
   if (cmd === 'list') return cmdList(arg1, jsonMode);
-  if (cmd === 'add') return cmdAdd(arg1 || 'xiaohongshu-batch', jsonMode);
+  if (cmd === 'add') return cmdAdd(arg1 || 'profile', jsonMode);
   if (cmd === 'login-profile') return cmdLoginProfile(arg1, argv, jsonMode);
-  if (cmd === 'login') return cmdLogin(arg1 || 'xiaohongshu-batch', argv, jsonMode);
+  if (cmd === 'goto-profile') return cmdGotoProfile(arg1, argv, jsonMode);
+  if (cmd === 'login') return cmdLogin(arg1 || 'profile', argv, jsonMode);
   if (cmd === 'migrate-fingerprints') return cmdMigrateFingerprints(jsonMode);
 
   throw new Error(`unknown command: ${cmd}`);

package/apps/webauto/entry/schedule.mjs

@@ -22,6 +22,7 @@ import {
   resolveSchedulesRoot,
   updateScheduleTask,
 } from './lib/schedule-store.mjs';
+import { listAccountProfiles } from './lib/account-store.mjs';
 
 let xhsRunnerPromise = null;
 let weiboRunnerPromise = null;
@@ -70,6 +71,46 @@ function parseJson(text, fallback = {}) {
   return JSON.parse(raw.replace(/^\uFEFF/, ''));
 }
 
+function normalizePlatformByCommandType(commandType) {
+  const value = String(commandType || '').trim().toLowerCase();
+  if (value.startsWith('weibo')) return 'weibo';
+  if (value.startsWith('1688')) return '1688';
+  return 'xiaohongshu';
+}
+
+function hasProfileArg(argv = {}) {
+  return Boolean(
+    String(argv?.profile || '').trim()
+    || String(argv?.profiles || '').trim()
+    || String(argv?.profilepool || '').trim(),
+  );
+}
+
+function pickAutoProfile(platform) {
+  const rows = listAccountProfiles({ platform }).profiles || [];
+  const validRows = rows
+    .filter((row) => row?.valid === true && String(row?.accountId || '').trim())
+    .sort((a, b) => {
+      const ta = Date.parse(String(a?.updatedAt || '')) || 0;
+      const tb = Date.parse(String(b?.updatedAt || '')) || 0;
+      if (tb !== ta) return tb - ta;
+      return String(a?.profileId || '').localeCompare(String(b?.profileId || ''));
+    });
+  return String(validRows[0]?.profileId || '').trim();
+}
+
+function ensureProfileArgForTask(commandType, commandArgv = {}) {
+  const argv = commandArgv && typeof commandArgv === 'object' ? { ...commandArgv } : {};
+  if (hasProfileArg(argv)) return argv;
+  const platform = normalizePlatformByCommandType(commandType);
+  const profile = pickAutoProfile(platform);
+  if (!profile) {
+    throw new Error(`missing profile/profiles/profilepool and no valid account for platform=${platform}`);
+  }
+  argv.profile = profile;
+  return argv;
+}
+
 function safeReadJsonFile(filePath) {
   const raw = fs.readFileSync(filePath, 'utf8');
   return parseJson(raw, {});
@@ -265,14 +306,15 @@ async function executeTask(task, options = {}) {
   const quietExecutors = options.quietExecutors === true;
   try {
     const commandType = String(task?.commandType || 'xhs-unified').trim();
+    const commandArgv = ensureProfileArgForTask(commandType, task?.commandArgv || {});
     const result = await withConsoleSilenced(quietExecutors, async () => {
       if (commandType === 'xhs-unified') {
         const runUnified = await getXhsRunner();
-        return runUnified(task.commandArgv || {});
+        return runUnified(commandArgv);
       }
       if (commandType.startsWith('weibo-')) {
         const runWeiboUnified = await getWeiboRunner();
-        return runWeiboUnified(task.commandArgv || {});
+        return runWeiboUnified(commandArgv);
       }
       if (commandType === '1688-search') {
         throw new Error(`executor_not_implemented: ${commandType}`);

package/apps/webauto/entry/weibo-unified.mjs

@@ -4,7 +4,7 @@ import { runWorkflowById } from '../../../dist/modules/workflow/src/runner.js';
 import { pathToFileURL } from 'node:url';
 
 const WEIBO_HOME_URL = 'https://www.weibo.com';
-const DEFAULT_PROFILE = 'xiaohongshu-batch-1'; // Use shared profile for now
+const DEFAULT_PROFILE = 'profile-0';
 
 async function runCommand(argv) {
   const profile = String(argv.profile || DEFAULT_PROFILE).trim();
@@ -106,7 +106,7 @@ if (isDirectExec) {
 export async function runWeiboUnified(argv) {
   const workflowId = String(argv.workflow || 'weibo-search-v1').trim();
   const keyword = String(argv.keyword || argv.k || '').trim();
-  const profile = String(argv.profile || 'xiaohongshu-batch-1').trim();
+  const profile = String(argv.profile || DEFAULT_PROFILE).trim();
   const targetCount = Number(argv['max-notes'] || argv.target || argv['max-notes'] || 50);
   const maxComments = Number(argv['max-comments'] || 0);
   const env = String(argv.env || 'debug').trim();