weflow-cli 1.8.2 → 1.10.0

package/scripts/backfill_articles.py

@@ -4,6 +4,7 @@
 用法:
   python scripts/backfill_articles.py --since 2026-03-01 --until 2026-08-31 --dry-run --json
   python scripts/backfill_articles.py --since 2026-03-01 --until 2026-08-31 --workers 12 --yes
+  python scripts/backfill_articles.py --since 2025-09-05 --until 2026-03-02 --topic AI --yes
 
 ## 为什么不是直接跑 `pipeline run --date`
 
@@ -26,6 +27,17 @@
 **图片型文章抓不到正文。** 实测 3/4、7/4 两天：27/40、44/60 有正文，其余是图文消息
 （内容全在图片里），清洗掉图片与链接后不足 100 字，与 `biz_daily` 一样被跳过。这不是
 抓取失败，是那类文章本来就没有文字。所以"2 万篇"这个量级是有正文的部分，不是总量。
+
+## `--topic`：只回填一部分主题（先筛后抓）
+
+`--topic AI` 用的就是本脚本自己判主题的那套 `_guess_topic`（只看标题与号名、**不看正文**），
+所以它筛出来的 AI 集合，与全量跑完之后落在 `AI/` 目录里的那批**逐个相同** —— 不是另立一套
+口径，只是省掉了其余主题的抓取（实测 2025-09-05~2026-03-02 那段：全量 10,880 篇里 AI 占
+1,759 篇，抓取量约 1/6）。
+
+**代价必须写出来：那一天就不再是完整的一天。** 所以 `.articles.json` 里会多一个 `topicFilter`
+（README 里也写明），`day_done` 据此在之后跑**全量**时**不会**跳过这一天。少了这一步，那天
+其余五个主题的文章会被永久漏掉、而且不报错 —— 文件在、json 在、"已回填"看起来处处成立。
 """
 import argparse
 import hashlib
@@ -121,6 +133,32 @@ def apply_topics(articles):
     return articles
 
 
+def parse_topics(values):
+    """把 `--topic` 的取值展开成一个列表：**可重复，也可逗号分隔**。
+
+    两种都收的理由是仓库里另一条命令（`article_notes.py`）的 `--topic` 就是 `action='append'`
+    且写明"可重复或逗号分隔"。只认一种的话，照另一边习惯写就会**静默只做一个主题**。
+
+    `values` 传字符串也当单个处理：`for chunk in 'AI'` 会**逐字符**迭代，而每个字符都不在分类法里
+    —— 于是"整批被拒"看起来跟"参数拼错"一模一样，很难查。这里把它挡住。
+    """
+    if isinstance(values, str) or values is None:
+        values = [values or '']
+    return [t.strip() for chunk in values for t in str(chunk).split(',') if t.strip()]
+
+
+def select_topics(articles, topics):
+    """只留下选中主题的文章；`topics` 为空/None 表示全要（原样返回）。
+
+    必须在 `apply_topics` **之后**调：主题是那个函数的输出。顺序对"选中哪些"没有影响
+    （`_guess_topic` 逐篇独立、只看标题与号名），所以筛出来的集合与全量跑完落在对应主题
+    目录里的那批逐个相同。
+    """
+    if not topics:
+        return articles
+    return [a for a in articles if a.get('topic') in topics]
+
+
 def fetch_bodies(articles, workers: int, log=None):
     """并发把这批文章的正文抓回来，写进 `fetched_md`。
 
@@ -151,13 +189,66 @@ def fetch_bodies(articles, workers: int, log=None):
     return {'attempted': len(todo), 'ok': ok}
 
 
-def write_day(articles, day, out_root):
+def _read_index(day_dir) -> dict:
+    """读这一天已有的 `.articles.json`（没有就空表）。
+
+    **读不了的时候不是安静地返回空表**：那等于把已有条目从索引里抹掉，而这件事不会报错
+    —— 正是这一整段要防的事。所以把原文件改名留成 `.json.bad` 再继续，至少还能人工救。
+    """
+    path = Path(day_dir) / '.articles.json'
+    if not path.exists():
+        return {}
+    try:
+        payload = json.loads(path.read_text(encoding='utf-8'))
+        return payload if isinstance(payload, dict) else {}
+    except Exception as exc:
+        try:
+            path.rename(path.with_name('.articles.json.bad'))
+        except OSError:
+            pass
+        print('    警告：%s 读不了（%s），已留成 .articles.json.bad，旧索引未参与合并'
+              % (path.name, exc))
+        return {}
+
+
+def _merge_articles(kept, fresh):
+    """合并两组 `.articles.json` 条目，按「来源-标题」去重（那是它在盘上的文件名）。
+
+    顺序按 `time` 再 `title` 排，是为了让同一天的索引**稳定**：分两次回填的那天，
+    第二次不该把先前的条目挤到别处去，否则每次跑都产生一份看着像"改了"的索引。
+    没有 `time` 的老条目（理论上不会有）排在前面，不参与排序。
+    """
+    merged = {}
+    for entry in list(kept) + list(fresh):
+        if not isinstance(entry, dict):
+            continue
+        merged[(str(entry.get('source', '')), str(entry.get('title', '')))] = entry
+    return sorted(merged.values(), key=lambda e: (str(e.get('time', '')), str(e.get('title', ''))))
+
+
+def write_day(articles, day, out_root, topic_filter=None, truncated=False):
     """落盘：`<日期>/<主题>/<来源>-<标题>.md` + `.articles.json` + README。
 
     格式与 `biz_daily` 一致——`create_reading_notes` 与 `compile_wiki` 都按那个形状读。
     正文那段写 `## AI 摘要`（内容用文章自带的 digest）：**本脚本不调模型**，所以这里
     放的只能是原文已有的东西，不能假装是生成的摘要。
+
+    传了 `topic_filter`（`--topic`）时，这里会**再筛一次**并在元数据里留下 `topicFilter`：
+
+    - 筛在**这里**做，是为了让标记不可能撒谎。如果筛只发生在调用方（`main`），那么有人
+      漏调那一步时，`write_day` 会把六个主题全写出去、同时盖上"只回填了 AI"的章 ——
+      一个自称只回填了一半、实际写满了的目录，比不写标记更坏。
+    - README 里也写明这一天是哪几个主题。**这两处不是装饰**：一天只回填了一半却看起来像
+      完整的一天，是这份产出唯一会"静默变少"的方式（见 `day_done`）。
+    - 传了 `truncated`（`--limit-per-day` 截过）时同理，多一个 `truncated` 标记。
+    - **索引是与这一天已有的内容合并的，不是覆盖**：先 `--topic AI` 再来 `--topic 学术`，
+      先前那个主题的条目必须留着。覆盖会让**索引比盘上少几条**而 md 还在 —— 不报错，
+      而"索引与盘不一致"正是这一支反复吃的那个形状（见 `_merge_articles`、`_read_index`）。
+      `topicFilter` 取并集；只要这次是全量、或这天本来就是完整的，标记就**消失**。
+
+    `truncated` 只影响元数据（它记录的是"调用方截过"，不宜在这里重算——截在调用方发生）。
     """
+    articles = select_topics(articles, topic_filter)
     groups, fallbacks = _group_by_topic(articles)
     out_dir = Path(out_root) / day
     written, skipped = [], []
@@ -201,13 +292,50 @@ def write_day(articles, day, out_root):
             written.append(article)
     out_dir.mkdir(parents=True, exist_ok=True)
     serializable = [_serializable_article(a, day) for a in written]
+    # **索引描述的是这一天盘上全部的文章，不是这一轮写的那批。** 分两次、用不同主题回填同一天
+    # 时（`--topic AI` 之后再来 `--topic 学术`），只写本轮的话，先前那个主题的条目会从索引里
+    # 消失而 md 还留在盘上——索引少一条、盘上多一篇，不报错。所以先把不属于本轮的旧条目接过来。
+    prior = _read_index(out_dir)
+    kept = [e for e in prior.get('articles', [])
+            if e.get('topic') not in set(topic_filter or ())]
+    stored_filter = prior.get('topicFilter')
+    # 「**没有**旧索引」与「旧索引是**完整**的一天」是两件事，第一版把它们混成了一个 `None`：
+    # 于是第一次做过滤回填时标记根本没写，那天看起来像完整的一天 —— 正是要防的那件事。
+    # 区分它们的是"旧索引里有没有东西"，不是"有没有那个键"。
+    if topic_filter is None:
+        scope_filter = None                       # 全量跑过 → 这天完整
+    elif not prior.get('articles'):
+        scope_filter = sorted(topic_filter)       # 第一次写这天，且只写了一部分
+    elif stored_filter is None:
+        scope_filter = None                       # 本来就完整，这次只是重做其中一部分
+    else:
+        scope_filter = sorted(set(stored_filter) | set(topic_filter))
+    if scope_filter and set(scope_filter) >= set(TOPICS):
+        # 六个主题都做过一遍了 —— 这一天"能做的都做了"，与全量跑过没有区别。
+        # 不撤标记的话它**永远**被当成没做完：以后随便跑一次全量都会把整个窗口重抓一遍。
+        scope_filter = None
+    payload = {'date': day, 'generated_at': datetime.now(TZ).strftime('%Y-%m-%d %H:%M:%S'),
+               'backfilled': True, 'articles': _merge_articles(kept, serializable)}
+    # 只在**确实是一部分**的时候才加这两个键：全量回填写出来的文件与以前逐字节相同，
+    # 而 `day_done` 把"没有 topicFilter"读作"完整的一天"。缺了它就等于把半天的产出
+    # 冒充成整天——这正是这条路径唯一能静默丢东西的地方。
+    if scope_filter:
+        payload['topicFilter'] = scope_filter
+    if truncated or prior.get('truncated'):
+        # `truncated` 一旦记上就不撤销：这一次没截，不代表上一次截掉的那些补回来了。
+        payload['truncated'] = True
     (out_dir / '.articles.json').write_text(
-        json.dumps({'date': day, 'generated_at': datetime.now(TZ).strftime('%Y-%m-%d %H:%M:%S'),
-                    'backfilled': True, 'articles': serializable},
-                   ensure_ascii=False, indent=2), encoding='utf-8')
+        json.dumps(payload, ensure_ascii=False, indent=2), encoding='utf-8')
+    if scope_filter:
+        scope = ('**只回填了 %s 主题** —— 这一天并非全部文章，其余主题还没拉。\n'
+                 % '、'.join(scope_filter))
+    else:
+        scope = ''
+    # README 说的是**这一天**有几篇（合并后的），不是这一轮写了几篇 —— 分两次回填的那天，
+    # 前者才是读它的人想要的数。
     (out_dir / 'README.md').write_text(
         '# 公众号文章 — %s（历史回填）\n\n共 %d 篇。正文由 `backfill_articles.py` 抓取，'
-        '**未下载图片、未调用模型**。\n' % (day, len(written)), encoding='utf-8')
+        '**未下载图片、未调用模型**。\n%s' % (day, len(payload['articles']), scope), encoding='utf-8')
     return {'written': len(written), 'skipped': len(skipped),
             'fallbackTopics': fallbacks, 'skipSample': skipped[:3]}
 
@@ -277,15 +405,40 @@ def days_with_articles(out_root) -> list:
     return days
 
 
-def day_done(out_root, day) -> bool:
-    """这一天已经回填过了吗（增量：免得重跑把同样的文章再抓一遍）。"""
+def day_done(out_root, day, topics=None) -> bool:
+    """这一天**我们要的那些主题**已经回填过了吗（增量：免得重跑把同样的文章再抓一遍）。
+
+    `topics=None` 表示"全量"。**判据不只是"写过"**，还要看写的是不是完整的一天：
+
+    - 只回填过 AI 的一天，`.articles.json` 里带着 `topicFilter`。此后跑**全量**时必须
+      **不能**被跳过 —— 否则那天其余五个主题的文章会被永久漏掉，而且不报错：文件在、
+      `.articles.json` 在、"已回填"看起来成立。这就是 `days_with_articles` 那条注释里
+      记的同一类事故（拿一个不完整的判据当"做完了"）。
+    - 反向：`--topic AI` 之后又跑 `--topic AI,学术`，存过的是子集，也要重做；
+      而存过的**覆盖**了这次要的（或那天本来就完整），才算做完。
+    - 被 `--limit-per-day` 截过的一天**从来不算做完**：截掉的那些既没抓、也看不出来。
+    """
     path = Path(out_root) / day / '.articles.json'
     if not path.exists():
         return False
     try:
-        return bool(json.loads(path.read_text(encoding='utf-8')).get('articles'))
+        payload = json.loads(path.read_text(encoding='utf-8'))
     except Exception:
         return False
+    if not payload.get('articles'):
+        return False
+    if payload.get('truncated'):
+        return False
+    stored = payload.get('topicFilter')
+    if stored is None:
+        return True            # 完整的一天，所有主题都在
+    if set(stored) >= set(TOPICS):
+        # 六个主题在标记里都在 = 这天完整（`write_day` 现在会直接把标记撤掉，但**旧代码写的**
+        # 天数带着这个形态留在盘上 —— 读的判据也认它，免得那几天永远"没做完"）。
+        return True
+    if topics is None:
+        return False           # 只要过一部分，全量的活还没干
+    return set(stored) >= set(topics)
 
 
 def main():
@@ -300,7 +453,13 @@ def main():
     parser.add_argument('--vault-sync', action='store_true',
                         help='只做这件事：把已回填的天补拷进 Vault 的 Sources（本地，不抓取、不调模型）')
     parser.add_argument('--workers', type=int, default=8, help='抓正文的并发数（默认 8）')
-    parser.add_argument('--limit-per-day', type=int, default=0, help='每天最多抓几篇（0=不限）')
+    parser.add_argument('--limit-per-day', type=int, default=0,
+                        help='每天最多抓几篇（0=不限）。设了就不是完整的一天：'
+                             '截掉的那些既没抓也看不出来，所以增量判断会重做这天')
+    parser.add_argument('--topic', action='append', default=[], metavar='T',
+                        help='只回填这些主题（可重复或逗号分隔，合法值 %s），不写=全部。'
+                             '只回填过一部分主题的一天，之后跑全量时不会被跳过。'
+                             % '/'.join(TOPICS))
     parser.add_argument('--refresh', action='store_true', help='已回填过的天也重做（默认跳过）')
     parser.add_argument('--max-days', type=int, default=0, help='最多处理几天（0=不限，用于试跑）')
     parser.add_argument('--dry-run', action='store_true', help='只报到要抓多少，不抓不写')
@@ -319,6 +478,17 @@ def main():
         print('--until 不能早于 --since'); return 1
     if args.workers < 1:
         print('--workers 要 ≥ 1'); return 1
+    picked = parse_topics(args.topic)
+    unknown = [t for t in picked if t not in TOPICS]
+    if unknown:
+        # 拼错一个词（比如 `--topic ai` 小写）会静默筛出 0 篇、然后报一句"没有要处理的"——
+        # 看着像"这天本来就没文章"。所以这里当场报错并列出合法值，放在碰库之前。
+        message = ('--topic 里有不在分类法里的主题：%s\n合法值：%s'
+                   % ('、'.join(unknown), '、'.join(TOPICS)))
+        print(json.dumps({'success': False, 'error': message}, ensure_ascii=False)
+              if args.json else message)
+        return 1
+    topics = sorted(set(picked)) or None
 
     if args.vault_sync:
         # **补拷模式**：不抓取、不调模型，只把已经躺在 biz-daily 的那几天补进 Vault。
@@ -328,6 +498,8 @@ def main():
         # 重复跑是**安全**的：`copy_to_vault` 逐 md 覆盖、不删别的东西，而它现在还会洗残留，
         # 所以"再补一次"同时也是"把库里那一层重新洗一遍"（2026-09-28 就是这么把 1,755 篇
         # 漏网的补上的 —— 那天被 `backfilled` 标记挡在门外的 12 天）。
+        if topics:
+            print('提示：--vault-sync 只把**已回填的** md 补拷进 Vault，--topic 对这一步不起作用。')
         days = days_with_articles(args.out)
         if args.max_days:
             days = days[:args.max_days]
@@ -374,28 +546,35 @@ def main():
 
     todo = []
     for day in days:
-        if not args.refresh and day_done(args.out, day):
+        if not args.refresh and day_done(args.out, day, topics):
             continue
         articles = collect_articles(cursor, users, name_map, day)
+        # 筛选在 `collect_articles` **之后**：主题是它内部 `apply_topics` 的输出，
+        # 先筛就无从筛起（理由与等价性写在 `select_topics` 上）。
+        articles = select_topics(articles, topics)
+        # 截断要在**筛完之后**判断：`--limit-per-day 5 --topic AI` 该解作"每天 5 篇 AI"。
+        truncated = bool(args.limit_per_day) and len(articles) > args.limit_per_day
         if args.limit_per_day:
             articles = articles[:args.limit_per_day]
         if articles:
-            todo.append((day, articles))
+            todo.append((day, articles, truncated))
 
     if args.dry_run:
-        total = sum(len(items) for _, items in todo)
-        need = sum(1 for _, items in todo for a in items
+        total = sum(len(items) for _, items, _ in todo)
+        need = sum(1 for _, items, _ in todo for a in items
                    if len(body_without_media(a.get('local_text'))) < MIN_BODY_CHARS and a.get('url'))
         payload = {
             'success': True, 'dryRun': True, 'action': 'backfill-articles',
+            'topics': topics or '全部',
             'days': len(todo), 'articles': total, 'needFetch': need,
             'workers': args.workers, 'invokesAI': False, 'downloadsImages': False,
             'readsLocalData': True,
             'note': '只抓正文，不下图片、不调用模型；抓完还要跑 vault notes 与 article-notes',
         }
         print(json.dumps(payload, ensure_ascii=False, indent=2) if args.json
-              else '%d 天、%d 篇（其中 %d 篇要联网抓正文），并发 %d'
-                   % (len(todo), total, need, args.workers))
+              else '%d 天、%d 篇（其中 %d 篇要联网抓正文），并发 %d，主题 %s'
+                   % (len(todo), total, need, args.workers,
+                      '全部' if not topics else '、'.join(topics)))
         conn.close()
         return 0
 
@@ -404,23 +583,25 @@ def main():
         conn.close()
         return 0
     if not args.yes:
-        print('会抓 %d 天、%d 篇的正文（不调模型）。加 --yes 确认。'
-              % (len(todo), sum(len(i) for _, i in todo)))
+        print('会抓 %d 天、%d 篇的正文（不调模型，主题 %s）。加 --yes 确认。'
+              % (len(todo), sum(len(i) for _, i, _ in todo),
+                 '全部' if not topics else '、'.join(topics)))
         conn.close()
         return 1
 
     report = []
-    for index, (day, articles) in enumerate(todo, 1):
-        print('\n[%d/%d] %s — 库里 %d 篇' % (index, len(todo), day, len(articles)))
+    for index, (day, articles, truncated) in enumerate(todo, 1):
+        print('\n[%d/%d] %s — 选中 %d 篇' % (index, len(todo), day, len(articles)))
         fetch = fetch_bodies(articles, args.workers, log=print)
-        result = write_day(articles, day, args.out)
+        result = write_day(articles, day, args.out, topic_filter=topics, truncated=truncated)
         print('    写入 %d 篇，跳过 %d 篇（正文太短），主题兜底 %d 篇'
               % (result['written'], result['skipped'], result['fallbackTopics']))
         if args.vault_copy:
             sync = copy_to_vault(day, args.out, args.vault_root)
             print('    入 Vault 的 Sources: %d 个 md' % sync['copied'])
         report.append({'date': day, 'inDb': len(articles), 'fetched': fetch['ok'],
-                       'written': result['written'], 'skippedThin': result['skipped']})
+                       'written': result['written'], 'skippedThin': result['skipped'],
+                       'truncated': truncated})
     conn.close()
 
     total_written = sum(r['written'] for r in report)

package/scripts/biz_daily.py

@@ -212,19 +212,29 @@ def _group_by_topic(articles):
     return groups, fallbacks
 
 
-def _classify_with_jev(client, title, body, topics):
+def _classify_with_jev(client, title, body, topics, noise=None):
     """让 Jev 判断这一篇；**问不出来就返回 None**，由调用方逐篇退回老路。
 
     这里刻意吞掉异常（包括 `JevError` 之外的意外），因为"分类这一篇失败"
     不该让整天的日报挂掉。但异常类型会打出来——一个真的写错了的行号不该
     在日志里长得跟"网络抖了一下"一样。
+
+    `noise` 可选（见 `_classify_articles_parallel`）：把**同一条**失败折叠成一次输出。
+    一天上百篇全因同一个原因失败时（实测：判断层按地区不可用，HTTP 451），打上百行
+    等于没说；而**没见过的异常类型或没见过的消息仍然每次照打**——折叠的是重复，不是未知。
     """
     if client is None:
         return None
     try:
         return client.decide_article(title, body, topics)
     except Exception as error:
-        print(f'    [WARN] Jev 分类失败（{type(error).__name__}），本篇退回 LLM 解析：{error}')
+        signature = (type(error).__name__, str(error)[:200])
+        if noise is not None and signature in noise['seen']:
+            noise['repeat'] += 1
+        else:
+            if noise is not None:
+                noise['seen'].add(signature)
+            print(f'    [WARN] Jev 分类失败（{type(error).__name__}），本篇退回 LLM 解析：{error}')
         return None
 
 
@@ -284,9 +294,12 @@ def _classify_articles_parallel(articles, client, topics, workers=JEV_WORKERS):
 
     started = time.time()
     decisions = {}
+    # 同一条失败折叠成一次输出（见 `_classify_with_jev`）：一天上百篇同一个原因失败时，
+    # 逐篇刷同一行等于没说；但没见过的异常/消息仍然照打。
+    noise = {'seen': set(), 'repeat': 0}
     with ThreadPoolExecutor(max_workers=max(1, workers)) as pool:
         futures = {
-            pool.submit(_classify_with_jev, client, title, body, topics): index
+            pool.submit(_classify_with_jev, client, title, body, topics, noise): index
             for index, title, body in todo
         }
         for future in as_completed(futures):
@@ -296,6 +309,8 @@ def _classify_articles_parallel(articles, client, topics, workers=JEV_WORKERS):
     # 先报个数：并发之后逐篇日志没有意义了，但这三件事必须看得见。
     print(f'  分类完成 {ok}/{len(todo)} 篇，耗时 {time.time() - started:.1f}s'
           f'（{workers} 并发；串行约需 {len(todo) * 0.97:.0f}s）')
+    if noise['repeat']:
+        print(f'  [WARN] 另有 {noise["repeat"]} 篇因**同一条**失败被折叠（原因已在上面打过一次）')
     return decisions
 
 
@@ -473,37 +488,14 @@ def get_db_keys(config):
     contact_salt = config.get('contactSalt', '')
     contact_key = decrypt_lock(contact_key_enc) if contact_key_enc else ''
 
-    # biz_message_0.db (每库独立密钥)
-    biz_db = os.path.join(msg_dir, 'biz_message_0.db')
-    biz_key_enc = config.get('bizKey', '')
-    biz_salt = config.get('bizSalt', '')
-    pass_enc = config.get('favPassphrase', '')
-    passphrase = decrypt_lock(pass_enc) if pass_enc else ''
-    if passphrase and os.path.exists(biz_db):
-        with open(biz_db, 'rb') as fh:
-            biz_salt = fh.read(16).hex()
-        biz_key_enc = ''
-    if biz_key_enc and biz_salt:
-        biz_key = decrypt_lock(biz_key_enc)
-    else:
-        # 从全库共用 passphrase 派生 (微信 4.x: PBKDF2-HMAC-SHA512, 256000 轮, 32 字节)
-        pass_enc = config.get('favPassphrase', '')
-        passphrase = decrypt_lock(pass_enc) if pass_enc else ''
-        biz_key = ''
-        if passphrase and os.path.exists(biz_db):
-            with open(biz_db, 'rb') as fh:
-                biz_salt = fh.read(16).hex()
-            biz_key = hashlib.pbkdf2_hmac(
-                'sha512', bytes.fromhex(passphrase),
-                bytes.fromhex(biz_salt), 256000, dklen=32
-            ).hex()
-        if not biz_key:
-            # 只指向 passphrase 一条路: 早先还建议 `config set bizKey`, 但该键不在
-            # CLI 的可写白名单里, 照做必然报 INVALID_CONFIG_KEY。
-            raise SystemExit(
-                '缺少公众号数据库密钥: 请运行 weflow-cli fav set-key --passphrase <64位hex> '
-                '配置全库 passphrase (自动派生各库密钥)'
-            )
+    # biz_message_0.db（订阅号库）：钥匙派生统一在 `_utils.biz_message_db()`。
+    # 这块原来自己算了两遍（先按 bizKey/bizSalt，又被下面按 passphrase 派生的一遍覆盖），
+    # 两遍并存就是分叉留下的痕迹 —— 见那个函数的注释。
+    from _utils import biz_message_db
+    try:
+        biz_db, biz_key, biz_salt = biz_message_db(config)
+    except RuntimeError as exc:
+        raise SystemExit(str(exc))
 
     return {
         'biz_db': biz_db, 'biz_key': biz_key, 'biz_salt': biz_salt,