@bolloon/bolloon-agent 0.4.28 → 0.4.30

package/dist/agents/contacts/cli.js

@@ -0,0 +1,158 @@
+/**
+ * contacts/cli.ts — `/contacts` 统一入口 (2026-09-19, Phase 10)
+ *
+ * 刻意只有三个用户入口 (leo 要求不要再堆页面):
+ *   /contacts                    看联系方式 + 授权状态 + 等待中的回复
+ *   /contacts authorize [选项]   一次性授予 长期/完全 授权 (默认"长期使用")
+ *   /contacts revoke [目标]      暂停/撤销授权
+ *
+ * 输出是纯行数组, 由调用方 (CLI/Web/手机) 决定怎么上色 —— 三端读同一份 Grant 事实。
+ */
+import { FORBIDDEN_CATEGORIES, presetForChoice } from './grants.js';
+const CHOICE_ALIAS = {
+    once: 'task_once', task: 'task_once', 'task_once': 'task_once', '本次': 'task_once', '仅本次任务': 'task_once',
+    long: 'persistent', persistent: 'persistent', '长期': 'persistent', '长期使用': 'persistent',
+    full: 'full_contact_access', all: 'full_contact_access', 'full_contact_access': 'full_contact_access', '完全': 'full_contact_access', '完全授权': 'full_contact_access',
+};
+/** 统一授权卡 (Phase 3): 用户不需要理解 phone.contact / email.contact 是两个 Skill */
+export function authorizationCard() {
+    const p = presetForChoice('persistent');
+    const f = presetForChoice('full_contact_access');
+    return [
+        '让 Bolloon 代表你联系外部的人',
+        '',
+        '将获得权限:',
+        '  ✓ 使用已验证的手机号发送消息',
+        '  ✓ 使用已验证的邮箱发送邮件',
+        '  ✓ 自动等待回复, 回复到达后继续执行任务',
+        '  ✓ 在未来任务中自动使用 (不再逐次打断你)',
+        '',
+        '不会获得权限:',
+        '  × 读取全部邮箱 / 读取通讯录 / 短信历史',
+        '  × 群发消息 (批量永远禁止)',
+        '  × 自动支付或转账',
+        '  × 代表你签署合同或做承诺',
+        '  × 拿到手机号/邮箱明文 (只看得到脱敏值)',
+        '',
+        `选项: 仅本次任务 (task_once) · 长期使用 (persistent, 推荐) · 完全授权联系方式能力 (full_contact_access)`,
+        `默认长期使用: channels=${p.channels} · contactScope=${p.contactScope} · taskScope=${p.taskScope} · contentScope=${p.contentScope}`,
+        `完全授权额外带来: contactScope=${f.contactScope} (仍只覆盖**已验证**联系人) · contentScope=${f.contentScope} (身份信息/项目数据可直接发)`,
+        `无论哪一档都不放行: ${FORBIDDEN_CATEGORIES.join(', ')} (凭证/资金指令/合同承诺属另一类高风险能力)`,
+        `无论哪一档都保留: 单收件人 · 频率限制 · 任务关联 · requestId 幂等 · provider 检查 · 发送证据 · 随时撤销`,
+    ];
+}
+function label(g) {
+    return g.level === 'full_contact_access' ? '完全授权' : g.level === 'persistent' ? '长期自动使用' : g.level === 'task_once' ? '仅本次任务' : '不允许';
+}
+export async function contactsCli(chain, rest) {
+    const argv = rest.split(/\s+/).filter(Boolean);
+    const sub = (argv[0] || '').toLowerCase();
+    // ── /contacts authorize [...] ─────────────────────────────────────────────
+    if (sub === 'authorize' || sub === 'grant') {
+        const choice = CHOICE_ALIAS[(argv[1] || '').toLowerCase()] || 'persistent';
+        const out = authorizationCard();
+        const r = await chain.authorize({ choice, grantedBy: 'leo', grantedVia: 'cli' });
+        out.push('');
+        out.push(`已授权: ${r.userLabel} — grantId=${r.grant.grantId} v${r.grant.grantVersion}`);
+        out.push(`范围: channels=${r.grant.channels} · contactScope=${r.grant.contactScope} · taskScope=${r.grant.taskScope} · contentScope=${r.grant.contentScope}`);
+        out.push('之后 Agent 联系已验证的人不再逐次打断你; 仍然受频率/任务/幂等/证据/撤销约束');
+        out.push('随时可用: /contacts revoke all  (撤销) · /contacts pause  (暂停, 保留配置)');
+        return { ok: true, lines: out };
+    }
+    // ── /contacts revoke [...] ────────────────────────────────────────────────
+    if (sub === 'revoke') {
+        const target = (argv[1] || 'all').toLowerCase();
+        if (target === 'all' || target === 'grant') {
+            const r = await chain.revokeAllGrants({ by: 'leo', reason: 'CLI /contacts revoke all' });
+            return {
+                ok: true,
+                lines: [
+                    `已撤销授权: ${r.revoked.length ? r.revoked.join(', ') : '(没有生效中的授权)'}`,
+                    r.affectedGoals.length ? `受影响任务 (转人工, 不再自动唤醒): ${r.affectedGoals.join(', ')}` : '没有正在等待回复的任务受影响',
+                    '历史 Run/Goal 证据保留; 旧授权不能重新启用 —— 需要就要重新 /contacts authorize',
+                ],
+            };
+        }
+        const g = await chain.grants.get(target);
+        if (g) {
+            const r = await chain.revokeGrant(target, { by: 'leo', reason: 'CLI' });
+            return { ok: r.ok, lines: [`已撤销授权 ${target}`, r.affectedGoals.length ? `受影响任务: ${r.affectedGoals.join(', ')}` : '(无等待中的任务)'] };
+        }
+        const rc = await chain.revoke({ contactId: target, by: 'leo', reason: 'CLI /contacts revoke' });
+        if (!rc.ok)
+            return { ok: false, lines: [`没找到授权或联系方式: ${target}`, '用法: /contacts revoke all | <grantId> | <contactId>'] };
+        return { ok: true, lines: [`已撤销联系方式 ${target} 的授权 (历史证据保留, 后续调用一律拒绝)`, rc.affectedGoals?.length ? `受影响任务: ${rc.affectedGoals.join(', ')}` : '(无等待中的任务)'] };
+    }
+    // ── /contacts pause | resume ──────────────────────────────────────────────
+    if (sub === 'pause' || sub === 'resume') {
+        const g = argv[1] ? await chain.grants.get(argv[1]) : await chain.grants.activeFor(chain.ownerDid);
+        if (!g)
+            return { ok: false, lines: ['没有找到可操作的授权 (用 /contacts 看当前状态)'] };
+        const r = sub === 'pause' ? await chain.pauseGrant(g.grantId, { by: 'leo' }) : await chain.resumeGrant(g.grantId, { by: 'leo' });
+        return { ok: r.ok, lines: [r.ok ? `${sub === 'pause' ? '已暂停' : '已恢复'}授权 ${g.grantId} (v${r.grant?.grantVersion})` : `失败: ${r.error}`] };
+    }
+    // ── /contacts bind phone|email <值> [别名] ────────────────────────────────
+    if (sub === 'bind') {
+        const kind = (argv[1] || '').toLowerCase();
+        if (kind !== 'phone' && kind !== 'email')
+            return { ok: false, lines: ['用法: /contacts bind phone|email <号码/邮箱> [别名]'] };
+        const b = await chain.bind({ kind, value: argv[2] || '', aliases: argv[3] ? [argv[3]] : undefined });
+        if (!b.ok)
+            return { ok: false, lines: [`绑定失败: ${b.error}`] };
+        const lines = [
+            `已登记 ${kind} ${b.contact.displayValue} (待验证, 通道 ${b.channelLabel || b.contact.provider})`,
+            '完整' + (kind === 'phone' ? '号码' : '邮箱') + '不会进入 prompt / Run / Git; 别人只看得到脱敏值',
+        ];
+        if (b.otpForLocalSink)
+            lines.push(`本地落盘通道验证码 (未真实外发): ${b.otpForLocalSink} — 用 /contacts verify ${b.contact.contactId} <码>`);
+        else
+            lines.push(`验证码已通过通道外发, 收到后用 /contacts verify ${b.contact.contactId} <码> 完成验证`);
+        return { ok: true, lines };
+    }
+    if (sub === 'verify') {
+        const r = await chain.verify({ contactId: argv[1] || '', challengeId: argv[3] || '', code: argv[2] || '' });
+        if (!r.ok)
+            return { ok: false, lines: [`验证失败: ${r.error}`] };
+        return { ok: true, lines: [`验证通过: ${r.contact.displayValue} (能力 ${r.contact.capabilities.join(', ')})`, '下一步: /contacts authorize  (给长期授权) —— 验证 ≠ 自动获得长期发送权限'] };
+    }
+    // ── /contacts (状态) ──────────────────────────────────────────────────────
+    const summary = await chain.grantsSummary();
+    const contacts = await chain.listAuthorized();
+    const pending = await chain.consents.list('pending');
+    const sends = await chain.store.listSends();
+    const lines = [];
+    lines.push('联系方式与授权');
+    lines.push(`  授权状态: ${summary.effective}`);
+    if (summary.grants.length) {
+        for (const g of summary.grants) {
+            lines.push(`  · ${g.grantId} ${label({ level: g.level })} [${g.status}] channels=${g.channels} contactScope=${g.contactScope} taskScope=${g.taskScope} contentScope=${g.contentScope} v${g.grantVersion}${g.signed ? ` · 手机签名(${g.deviceId})` : ''}${g.lastUsedAt ? ` · 最近使用 ${g.lastUsedAt.slice(0, 16)}` : ''}`);
+        }
+    }
+    else {
+        lines.push('  (没有长期授权 —— 每次联系都会打断你一次; 用 /contacts authorize 授权一次即可长期使用)');
+    }
+    lines.push('  联系方式:');
+    if (!contacts.length)
+        lines.push('    (还没有绑定 —— /contacts bind email 你的邮箱 / /contacts bind phone +8613… )');
+    for (const c of contacts) {
+        lines.push(`    · ${c.displayValue} [${c.kind}] ${c.status} · 能力 ${c.capabilities.length ? c.capabilities.join(', ') : '无'} · 策略 ${c.policy} · ${c.capabilities.includes('send') ? '可联系' : '不可联系'}`);
+    }
+    if (pending.length) {
+        lines.push(`  待你批准 (${pending.length}):`);
+        for (const p of pending)
+            lines.push(`    · ${p.consentId} ${p.contactName} [${p.channel}] ${p.reason} · requestId=${p.requestId}`);
+    }
+    else {
+        lines.push('  待你批准: 无');
+    }
+    const waiting = sends.filter((s) => s.status === 'sent' && s.goalId);
+    lines.push(`  正在等回复: ${waiting.length ? waiting.map((s) => `${s.goalId}(${s.contactId})`).join(', ') : '无'}`);
+    const last = (await chain.store.readLedger({ limit: 5 })).slice(-5);
+    if (last.length) {
+        lines.push('  最近通信:');
+        for (const l of last)
+            lines.push(`    · ${l.ts.slice(0, 16)} ${l.activity} ${l.detail.slice(0, 80)}`);
+    }
+    lines.push('  用法: /contacts authorize [once|long|full] · /contacts revoke all|<grantId> · /contacts pause|resume · /contacts bind|verify');
+    return { ok: true, lines };
+}

package/dist/agents/contacts/consent.js

@@ -0,0 +1,124 @@
+/**
+ * contacts/consent.ts — 人工批准 (授权) 流程 (2026-09-19, Phase 6/7)
+ *
+ * 与 payment-approval.ts 同构: 首次联系/敏感内容/每次确认/策略要求时,
+ * 先落一条 pending 授权请求 → 人批准后才真正发送 (executor 由 chain 注入)。
+ *
+ * 落盘: ~/.bolloon/contacts/consents.json
+ * 关键纪律: 批准后**不绕过** policy —— executor 里会再判一次 (批准 ≠ 免检)。
+ */
+import * as fsp from 'fs/promises';
+import * as path from 'path';
+let _executor = null;
+export function setConsentExecutor(fn) { _executor = fn; }
+const DEFAULT_TTL_MS = 24 * 60 * 60_000;
+export class ContactConsentStore {
+    ttlMs;
+    file;
+    items = [];
+    loaded = false;
+    constructor(dir, ttlMs = DEFAULT_TTL_MS) {
+        this.ttlMs = ttlMs;
+        this.file = path.join(dir, 'consents.json');
+    }
+    async ensure() {
+        if (this.loaded)
+            return;
+        try {
+            const raw = JSON.parse(await fsp.readFile(this.file, 'utf8'));
+            this.items = Array.isArray(raw) ? raw : [];
+        }
+        catch (err) {
+            if (err?.code !== 'ENOENT')
+                throw new Error(`授权存储损坏 (${this.file}): ${err?.message || err}`);
+            this.items = [];
+        }
+        this.loaded = true;
+    }
+    async persist() {
+        const tmp = `${this.file}.tmp-${process.pid}`;
+        await fsp.mkdir(path.dirname(this.file), { recursive: true });
+        await fsp.writeFile(tmp, JSON.stringify(this.items.slice(-300), null, 2), 'utf8');
+        await fsp.rename(tmp, this.file);
+    }
+    async request(input) {
+        await this.ensure();
+        const now = input.now ?? Date.now();
+        const c = {
+            ...input,
+            consentId: `cc-${now.toString(36)}-${Math.random().toString(36).slice(2, 6)}`,
+            status: 'pending',
+            createdAt: now,
+            expiresAt: now + this.ttlMs,
+        };
+        this.items.push(c);
+        await this.persist();
+        return c;
+    }
+    async get(consentId) {
+        await this.ensure();
+        return this.items.find((x) => x.consentId === consentId) || null;
+    }
+    async list(status) {
+        await this.ensure();
+        return status ? this.items.filter((x) => x.status === status) : [...this.items];
+    }
+    /** 批准 → 立刻执行 (executor 里再判 policy) */
+    async approve(consentId, opts = {}) {
+        await this.ensure();
+        const c = await this.get(consentId);
+        if (!c)
+            return { ok: false, error: 'consent_not_found' };
+        if (c.status !== 'pending')
+            return { ok: false, error: `授权 ${consentId} 状态 ${c.status}, 不可批准` };
+        const now = opts.now ?? Date.now();
+        if (c.expiresAt < now) {
+            c.status = 'expired';
+            await this.persist();
+            return { ok: false, error: 'consent_expired' };
+        }
+        c.status = 'approved';
+        c.decidedAt = now;
+        c.decidedBy = opts.by || 'user';
+        c.decidedVia = opts.via || 'cli';
+        await this.persist();
+        if (!_executor)
+            return { ok: true, consent: c, error: 'no_executor: 已批准但没有执行器 (调用方未注入)' };
+        const r = await _executor(c);
+        const fresh = await this.get(consentId);
+        if (fresh) {
+            fresh.status = r.ok ? 'executed' : 'failed';
+            fresh.result = r.ok ? r.result : r.error;
+            await this.persist();
+        }
+        return { ok: r.ok, error: r.ok ? undefined : r.error, consent: fresh || c };
+    }
+    async reject(consentId, opts = {}) {
+        await this.ensure();
+        const c = await this.get(consentId);
+        if (!c)
+            return { ok: false, error: 'consent_not_found' };
+        if (c.status !== 'pending')
+            return { ok: false, error: `授权 ${consentId} 状态 ${c.status}, 不可拒绝` };
+        c.status = 'rejected';
+        c.decidedAt = opts.now ?? Date.now();
+        c.decidedBy = opts.by || 'user';
+        c.result = opts.reason;
+        await this.persist();
+        return { ok: true, consent: c };
+    }
+    /** 过期的 pending 授权 → expired (不静默留在 pending) */
+    async expireStale(now = Date.now()) {
+        await this.ensure();
+        const out = [];
+        for (const c of this.items) {
+            if (c.status === 'pending' && c.expiresAt < now) {
+                c.status = 'expired';
+                out.push(c);
+            }
+        }
+        if (out.length)
+            await this.persist();
+        return out;
+    }
+}

package/dist/agents/contacts/grant-payload.js

@@ -0,0 +1,45 @@
+/**
+ * contacts/grant-payload.ts — Grant 载荷的**单一规范** (2026-09-19)
+ *
+ * 为什么单独一个文件: 手机端 (WebCrypto) 与桌面端 (Node crypto) 必须对"同一条授权"算出**同一个字节串**,
+ * 否则签名永远验不过。这里只放纯函数 (无 node: 导入), 所以 browser bundle 与 Node 都能用。
+ *
+ * 铁律: 字段顺序固定 · 不含 signature 自身 · 不含 lastUsedAt (每次用都会变, 不该让签名失效)。
+ */
+/** 参与签名的字段 (顺序即规范顺序, 改动等于换协议版本) */
+export const GRANT_SIGNED_FIELDS = [
+    'grantId', 'identityId', 'ownerDid', 'level', 'channels', 'contactScope', 'taskScope', 'contentScope',
+    'replyWakeAllowed', 'autoSend', 'sensitiveContentAllowed', 'newRecipientAllowed',
+    'grantedAt', 'grantedBy', 'grantedVia', 'deviceIds', 'status', 'revokedAt', 'grantVersion',
+];
+export function canonicalGrantPayload(g) {
+    return JSON.stringify({
+        grantId: g.grantId, identityId: g.identityId, ownerDid: g.ownerDid, level: g.level,
+        channels: g.channels, contactScope: g.contactScope, taskScope: g.taskScope, contentScope: g.contentScope,
+        replyWakeAllowed: g.replyWakeAllowed, autoSend: g.autoSend, sensitiveContentAllowed: g.sensitiveContentAllowed,
+        newRecipientAllowed: g.newRecipientAllowed, grantedAt: g.grantedAt, grantedBy: g.grantedBy,
+        grantedVia: g.grantedVia, deviceIds: [...g.deviceIds].sort(), status: g.status,
+        revokedAt: g.revokedAt || '', grantVersion: g.grantVersion,
+    });
+}
+export function canonicalRevocationPayload(r) {
+    return JSON.stringify({ grantId: r.grantId, grantVersion: r.grantVersion, revokedAt: r.revokedAt, by: r.by });
+}
+/** 用户可见的三个选项 → 内部等级 + 默认范围 (手机端与 CLI 共用同一份, 避免两端范围不一致) */
+export function presetForChoice(choice) {
+    const base = { channels: 'both', replyWakeAllowed: true, autoSend: true, newRecipientAllowed: false };
+    switch (choice) {
+        case 'task_once':
+            return { ...base, level: 'task_once', contactScope: 'verified_contacts', taskScope: 'current_goal', contentScope: 'normal', autoSend: false, sensitiveContentAllowed: false };
+        case 'persistent':
+            return { ...base, level: 'persistent', contactScope: 'verified_contacts', taskScope: 'all_future_goals', contentScope: 'normal', sensitiveContentAllowed: false };
+        case 'full_contact_access':
+            return { ...base, level: 'full_contact_access', contactScope: 'all_contacts', taskScope: 'all_future_goals', contentScope: 'sensitive', sensitiveContentAllowed: true };
+    }
+}
+export const GRANT_LEVEL_LABEL = {
+    none: '不允许使用',
+    task_once: '本次任务',
+    persistent: '长期自动使用',
+    full_contact_access: '完全授权联系方式能力',
+};