ai-growth 1.1.0

package/dist/device/renderCard.js

@@ -0,0 +1,48 @@
+import { buildCardState, buildDeck, buildCardMeta, encodeCardPayload, } from './deck.js';
+import { buildCardHtml } from './card.js';
+import { renderCardCached } from './render.js';
+/** 用给定的状态与卡规格渲染（构建期生成兜底卡走这条） */
+export async function renderSpec(state, spec, index, count, dataDir) {
+    const meta = buildCardMeta(state, spec, index, count);
+    const html = buildCardHtml(state, spec);
+    const rendered = await renderCardCached(html, meta.deckId, dataDir);
+    return {
+        payload: encodeCardPayload(meta, rendered.pixels),
+        meta,
+        pixels: rendered.pixels,
+        html,
+        cached: rendered.cached,
+    };
+}
+/**
+ * 读取 Core 当前状态，渲染第 index 张卡。
+ * 越界返回 null（由 HTTP 层翻成 404），不抛错。
+ */
+export async function renderCardAt(ctx, index, dataDir, opts = {}) {
+    const state = buildCardState(ctx, { battery: opts.battery ?? null, offlineSince: opts.offlineSince });
+    const cards = buildDeck(state);
+    if (!Number.isInteger(index) || index < 0 || index >= cards.length)
+        return null;
+    return renderSpec(state, cards[index], index, cards.length, dataDir);
+}
+/** 给模拟器/调试用的牌组摘要（不是设备必需的，设备只看每张卡的 meta） */
+export function deckSummary(ctx, opts = {}) {
+    const state = buildCardState(ctx, { battery: opts.battery ?? null });
+    const cards = buildDeck(state);
+    return {
+        deckId: buildCardMeta(state, cards[0], 0, cards.length).deckId,
+        count: cards.length,
+        cards: cards.map((c, i) => ({
+            index: i,
+            kind: c.kind,
+            title: c.title,
+            actionId: buildCardMeta(state, c, i, cards.length).actionId,
+        })),
+        today: state.dateKey,
+        dateLabel: state.dateLabel,
+        doneCount: state.doneCount,
+        total: state.total,
+        stage: state.stage,
+        items: state.items,
+    };
+}

package/dist/device/report.js

@@ -0,0 +1,146 @@
+import { writeAudit } from '../core/context.js';
+import { DomainError, ErrorCodes } from '../shared/result.js';
+import { getAction, completeAction, skipAction, delayAction } from '../core/actions.js';
+import { addEvidence, createGrowthEvent } from '../core/evidence.js';
+import { getSystemState, setSystemState, todayIn } from '../core/profile.js';
+import { nowIso } from '../shared/time.js';
+const TARGET = {
+    complete: 'COMPLETED',
+    skip: 'SKIPPED',
+    delay: 'DELAYED',
+};
+/** 已经走到头、不可能再变成目标状态的动作状态 */
+const TERMINAL = new Set(['COMPLETED', 'SKIPPED', 'CANCELLED', 'EXPIRED']);
+export function applyDeviceReport(ctx, input) {
+    if (!input?.actionId)
+        throw new DomainError(ErrorCodes.VALIDATION_ERROR, 'actionId is required');
+    if (!Object.prototype.hasOwnProperty.call(TARGET, input.op)) {
+        throw new DomainError(ErrorCodes.VALIDATION_ERROR, `unknown op: ${String(input.op)}`);
+    }
+    const today = todayIn(ctx);
+    const action = getAction(ctx, input.actionId);
+    if (!action)
+        throw new DomainError(ErrorCodes.NOT_FOUND, `unknown action: ${input.actionId}`);
+    const base = {
+        actionId: action.id,
+        actionTitle: action.title,
+        actionDateKey: action.dateKey,
+        today,
+    };
+    // 设备给的日期只做校验，绝不当时间戳用
+    const occurred = input.occurredDateKey;
+    if (occurred && (occurred > today || occurred < action.dateKey)) {
+        writeAudit(ctx, {
+            entityType: 'action',
+            entityId: action.id,
+            after: { occurredDateKey: occurred, today, actionDateKey: action.dateKey },
+            reason: 'device reported an out-of-range occurred date; rejected',
+        });
+        throw new DomainError(ErrorCodes.VALIDATION_ERROR, `occurredDateKey ${occurred} 不在 [${action.dateKey}, ${today}] 区间内`);
+    }
+    // 该动作所属的自然日已经过去 → 状态不可再改（铁律 3）
+    if (today > action.dateKey) {
+        if (input.op !== 'complete') {
+            return {
+                ...base,
+                outcome: 'CONFLICT',
+                status: action.status,
+                note: `${action.dateKey} 已经过去，${input.op} 无处可施`,
+            };
+        }
+        return lateRecord(ctx, action, today);
+    }
+    const target = TARGET[input.op];
+    if (action.status === target) {
+        return { ...base, outcome: 'ALREADY_IN_STATE', status: action.status, duplicate: true };
+    }
+    if (TERMINAL.has(action.status)) {
+        return {
+            ...base,
+            outcome: 'CONFLICT',
+            status: action.status,
+            note: `当前状态是 ${action.status}，设备视图已过期，刷新即可`,
+        };
+    }
+    try {
+        const updated = input.op === 'complete'
+            ? completeAction(ctx, action.id)
+            : input.op === 'skip'
+                ? skipAction(ctx, action.id, input.reason ?? '设备跳过')
+                : delayAction(ctx, action.id, input.reason ?? '设备顺延');
+        const outcome = input.op === 'complete' ? 'COMPLETED' : input.op === 'skip' ? 'SKIPPED' : 'DELAYED';
+        return { ...base, outcome, status: updated.status };
+    }
+    catch (e) {
+        if (e instanceof DomainError && e.code === ErrorCodes.INVALID_STATE) {
+            const after = getAction(ctx, action.id);
+            if (after && after.status === target) {
+                return { ...base, outcome: 'ALREADY_IN_STATE', status: after.status, duplicate: true };
+            }
+            return {
+                ...base,
+                outcome: 'CONFLICT',
+                status: after?.status ?? action.status,
+                note: e.message,
+            };
+        }
+        throw e;
+    }
+}
+/** 跨天提交：补一条带真实日期的进展，动作状态一动不动 */
+function lateRecord(ctx, action, today) {
+    const key = `late_record:${action.id}`;
+    const base = {
+        actionId: action.id,
+        actionTitle: action.title,
+        actionDateKey: action.dateKey,
+        status: action.status,
+        today,
+    };
+    const prev = getSystemState(ctx, key);
+    if (prev) {
+        const parsed = JSON.parse(prev);
+        return {
+            ...base,
+            outcome: 'LATE_RECORDED',
+            duplicate: true,
+            evidenceId: parsed.evidenceId,
+            growthEventId: parsed.growthEventId,
+            note: '此前已经补记过，未重复写入',
+        };
+    }
+    const ev = addEvidence(ctx, {
+        actionId: action.id,
+        type: 'TEXT',
+        strength: 'USER_CONFIRMED',
+        content: `[设备] ${action.dateKey} 完成「${action.title}」，${today} 同步`,
+        metadata: {
+            source: 'ai-passport-device',
+            actionId: action.id,
+            actionDateKey: action.dateKey,
+            syncedAt: nowIso(),
+        },
+    });
+    const ge = createGrowthEvent(ctx, {
+        title: action.title,
+        domain: action.domain,
+        evidenceIds: [ev.id],
+        dateKey: action.dateKey,
+        goalId: action.basisGoalId,
+        stageId: action.basisStageId,
+    });
+    setSystemState(ctx, key, JSON.stringify({ evidenceId: ev.id, growthEventId: ge.id, recordedAt: nowIso() }));
+    writeAudit(ctx, {
+        entityType: 'action',
+        entityId: action.id,
+        after: { evidenceId: ev.id, growthEventId: ge.id, dateKey: action.dateKey, status: action.status },
+        reason: 'device reported completion after the action day expired; recorded as a dated growth event instead of mutating state',
+    });
+    return {
+        ...base,
+        outcome: 'LATE_RECORDED',
+        evidenceId: ev.id,
+        growthEventId: ge.id,
+        note: '跨天提交，已降级为迟记：动作状态保持不变，只补一条带真实日期的进展',
+    };
+}

package/dist/device/serial.js

@@ -0,0 +1,201 @@
+/**
+ * 串口控制台会话（AI Passport 的 USB-Serial-JTAG）。
+ *
+ * 为什么不用 npm 的 serialport：它是**原生模块**，用户机器上装它就要编译工具链；
+ * 而这件事只需要「以 raw 打开一个字符设备、写一行、读一段」三件事，
+ * Node 自带的 fs / child_process 就够 —— 装完软件就能用，不要额外依赖。
+ *
+ * ⚠ 三个现实问题，全部在下面处理掉了（都是实测踩出来的）：
+ *
+ * 1. **Node 没有 termios**，不能自己把 tty 设成 raw，只能借系统的 `stty`。
+ *    不设 raw，主机的行规程会改写字节（\n → \r\n、回显、流控），设备端解析会乱。
+ *    macOS 用 `stty -f`，Linux 用 `stty -F`，两边都要试。
+ *
+ * 2. **打开端口会让设备复位**（USB-Serial-JTAG 的行为），于是会先涌出一整段启动日志，
+ *    这期间写进去的命令会被**直接丢掉**。所以判断"能不能发"的唯一可靠依据是
+ *    **响应本身**，而不是等某个提示符 —— 不复位时提示符根本不会重新打印，
+ *    等它必然误判成"没就绪"。
+ *
+ * 3. 读数必须用 StringDecoder：UTF-8 汉字可能被切在两个 chunk 之间，
+ *    直接按 chunk 解码会得到乱码（而设备的中文日志正是我们判断成败的依据）。
+ */
+import { execFileSync } from 'node:child_process';
+import { closeSync, createReadStream, existsSync, openSync, readdirSync, writeSync } from 'node:fs';
+import { StringDecoder } from 'node:string_decoder';
+import { setTimeout as delay } from 'node:timers/promises';
+/**
+ * 列出可能是 AI Passport 的串口。
+ *
+ * 只看这几类名字：设备走原生 USB-Serial-JTAG（macOS 是 /dev/cu.usbmodem*，
+ * Linux 是 /dev/ttyACM*）；也带上常见的 USB-UART 桥（ch34x/cp210x/ftdi），
+ * 免得个别批次用了外置桥就找不到设备。
+ * ⚠ 不返回 /dev/cu.Bluetooth-* 之类：那是蓝牙虚拟口，连上去只会浪费时间。
+ */
+/**
+ * 从设备名列表里挑出可能是 AI Passport 的串口（**纯函数，便于单测**）。
+ *
+ * 只看这几类名字：设备走原生 USB-Serial-JTAG（macOS 是 /dev/cu.usbmodem*，
+ * Linux 是 /dev/ttyACM*）；也带上常见的 USB-UART 桥（ch34x/cp210x/ftdi），
+ * 免得个别批次用了外置桥就找不到设备。
+ *
+ * ⚠ macOS 会给同一个物理设备**两个**节点：/dev/cu.*（拨出，callout）和
+ *   /dev/tty.*（拨入，dialin）。只收 cu.*，否则永远会"找到多个串口"而走不下去 ——
+ *   这个 bug 会让 device setup 在所有 macOS 上直接失败。Linux 那边只有 ttyACM
+ *   和 ttyUSB 系列，没有这种孪生节点。
+ * ⚠ 不返回 /dev/cu.Bluetooth-* 之类：那是蓝牙虚拟口，连上去只会浪费时间。
+ * ⚠ 注释里别出现"星号紧跟斜杠"的字符序列：它会把块注释提前闭合（我已经踩过两次）。
+ */
+export function pickSerialPorts(names, platform) {
+    const out = [];
+    const isDarwin = platform === 'darwin';
+    for (const name of names) {
+        if (/^cu\.usbmodem/.test(name))
+            out.push({ path: `/dev/${name}`, kind: 'usbmodem' });
+        else if (/^cu\.(usbserial|wchusbserial|SLAB_USBtoUART)/.test(name))
+            out.push({ path: `/dev/${name}`, kind: 'usbserial' });
+        else if (!isDarwin && /^ttyACM\d+$/.test(name))
+            out.push({ path: `/dev/${name}`, kind: 'acm' });
+        else if (!isDarwin && /^ttyUSB\d+$/.test(name))
+            out.push({ path: `/dev/${name}`, kind: 'usbserial' });
+    }
+    // 原生 USB-Serial-JTAG 优先；其余按路径排序保证稳定
+    const rank = { usbmodem: 0, acm: 1, usbserial: 2 };
+    return out.sort((a, b) => rank[a.kind] - rank[b.kind] || a.path.localeCompare(b.path));
+}
+/** 列出本机上可能是 AI Passport 的串口（pickSerialPorts 的 io 外壳）。 */
+export function findSerialPorts() {
+    if (!existsSync('/dev'))
+        return [];
+    try {
+        return pickSerialPorts(readdirSync('/dev'), process.platform);
+    }
+    catch {
+        return [];
+    }
+}
+/** 把 tty 设成 raw 且关回显。macOS/Linux 的参数名不同，都试一遍。 */
+function makeRaw(path) {
+    const attempts = process.platform === 'darwin'
+        ? [['-f', path, 'raw', '-echo'], ['-F', path, 'raw', '-echo']]
+        : [['-F', path, 'raw', '-echo'], ['-f', path, 'raw', '-echo']];
+    let lastErr = null;
+    for (const args of attempts) {
+        try {
+            execFileSync('stty', args, { stdio: 'ignore' });
+            return;
+        }
+        catch (e) {
+            lastErr = e;
+        }
+    }
+    throw new Error(`stty 无法把 ${path} 设为 raw 模式：${lastErr instanceof Error ? lastErr.message : String(lastErr)}`);
+}
+export class SerialSession {
+    path;
+    fd;
+    stream;
+    decoder = new StringDecoder('utf8');
+    buf = '';
+    waiter = null;
+    constructor(path) {
+        this.path = path;
+        makeRaw(path);
+        this.fd = openSync(path, 'r+');
+        this.stream = createReadStream(path, { fd: this.fd, autoClose: false });
+        this.stream.on('data', (chunk) => {
+            this.buf += typeof chunk === 'string' ? chunk : this.decoder.write(chunk);
+            this.checkWaiter();
+        });
+        // 串口读不到 EOF；出错时别抛到全局（例如设备被拔掉）
+        this.stream.on('error', () => { });
+    }
+    static open(path) {
+        return new SerialSession(path);
+    }
+    checkWaiter() {
+        const w = this.waiter;
+        if (!w)
+            return;
+        for (const p of w.patterns) {
+            if (this.buf.includes(p)) {
+                this.waiter = null;
+                clearTimeout(w.timer);
+                const text = this.buf;
+                this.buf = '';
+                w.resolve({ matched: p, text });
+                return;
+            }
+        }
+    }
+    /** 写一行（自动补 \n，UTF-8 编码）。命令本身是 ASCII，无需转义。 */
+    writeLine(line) {
+        writeSync(this.fd, Buffer.from(line + '\n', 'utf8'));
+    }
+    /** 等到出现任一 pattern 或超时。同一时刻只允许一个等待者。 */
+    waitFor(patterns, timeoutMs) {
+        const hit = patterns.find((p) => this.buf.includes(p));
+        if (hit) {
+            const text = this.buf;
+            this.buf = '';
+            return Promise.resolve({ matched: hit, text });
+        }
+        return new Promise((resolve) => {
+            const timer = setTimeout(() => {
+                if (this.waiter?.timer === timer)
+                    this.waiter = null;
+                const text = this.buf;
+                this.buf = '';
+                resolve({ matched: null, text });
+            }, timeoutMs);
+            this.waiter = { patterns, resolve, timer };
+        });
+    }
+    /** 丢弃当前累积的读取内容（例如启动日志），只保留"从现在起"的输出 */
+    clear() {
+        this.buf = '';
+    }
+    /**
+     * 发一条命令并等响应。返回是否命中，以及这次读到的文本。
+     * 为什么要重试：开端口会复位设备，头一两条命令可能正好落在启动过程中被丢掉。
+     */
+    async sendAndWait(line, patterns, timeoutMs, tries = 3) {
+        for (let i = 1; i <= tries; i++) {
+            this.clear();
+            this.writeLine(line);
+            const r = await this.waitFor(patterns, timeoutMs);
+            if (r.matched)
+                return { ...r, tries: i };
+        }
+        return { matched: null, text: this.buf, tries };
+    }
+    /**
+     * 只读地收集一段时间。用在**没有终止标记**的输出上（启动日志、取卡结论）——
+     * 这类只能按时间收，不能等某个关键词。
+     * ⚠ 不要与 waitFor 同时用：两者都会消费内部缓冲。
+     */
+    drain(ms) {
+        this.clear();
+        return new Promise((resolve) => {
+            setTimeout(() => {
+                const text = this.buf;
+                this.buf = '';
+                resolve(text);
+            }, ms);
+        });
+    }
+    async sleep(ms) { await delay(ms); }
+    close() {
+        if (this.waiter) {
+            clearTimeout(this.waiter.timer);
+            this.waiter = null;
+        }
+        try {
+            this.stream.destroy();
+        }
+        catch { /* ignore */ }
+        try {
+            closeSync(this.fd);
+        }
+        catch { /* ignore */ }
+    }
+}

package/dist/device/token.js

@@ -0,0 +1,78 @@
+/**
+ * 设备访问令牌 —— 唯一需要触碰铁律 10（不做账号体系、安全边界是 loopback）的地方。
+ *
+ * 设计原则：**默认关**。令牌只在显式开启局域网访问后才被强制校验，
+ * 且校验对**所有**来源一律生效（含 localhost）—— 否则局域网客户端只要伪造
+ * `Host: 127.0.0.1` 就能绕过校验，那就等于没锁。
+ *
+ * - 局域网关：socket 绑在 127.0.0.1，物理上只有本机能连 → 不校验令牌
+ * - 局域网开：socket 绑 0.0.0.0，任何来源（含本机）都必须带正确令牌
+ *
+ * 这不是"登录"，是一把写进设备 NVS 的共享密钥，只为挡住同一个 Wi-Fi 下的其他人。
+ */
+import { randomBytes, timingSafeEqual } from 'node:crypto';
+import { getSetting, setSetting } from '../core/profile.js';
+const TOKEN_KEY = 'device_token';
+const LAN_KEY = 'device_lan';
+/**
+ * 局域网访问开关（device_lan）。
+ *
+ * 取值顺序：**环境变量优先，其次数据库里持久化过的开关，最后默认关**。
+ *
+ * 为什么要落库：这个开关以前只认环境变量，于是「开一次」这个动作**根本存不下来** ——
+ * 本机 launchd 起不来（全局包是指向 ~/Desktop 的符号链接，TCC 拦着），
+ * 而项目里又没有别的可写配置文件。结果是用户每次启动都得手动带环境变量，
+ * 对一个要发布出去的应用来说不能接受。令牌本来就存在 settings 表里（见 TOKEN_KEY），
+ * 这里沿用同一套：环境变量仍然可以临时覆盖，但"开启"这个决定能被记住。
+ */
+export function isDeviceLanEnabled(cfg, ctx) {
+    const truthy = (v) => v === '1' || v === 'true' || v === 'yes' || v === 'on';
+    const env = (cfg.deviceLan ?? '').trim().toLowerCase();
+    if (env)
+        return truthy(env); // 显式设置的环境变量说了算
+    if (!ctx)
+        return false; // 没有数据库上下文时只能用环境变量
+    return truthy((getSetting(ctx, LAN_KEY) ?? '').trim().toLowerCase());
+}
+/** 把"开/关局域网访问"这个决定记下来（下次启动生效）。 */
+export function setDeviceLanEnabled(ctx, on) {
+    setSetting(ctx, LAN_KEY, on ? '1' : '0');
+}
+export function deviceToken(ctx) {
+    return getSetting(ctx, TOKEN_KEY);
+}
+export function getOrCreateDeviceToken(ctx) {
+    const cur = deviceToken(ctx);
+    if (cur)
+        return cur;
+    const t = randomBytes(16).toString('hex');
+    setSetting(ctx, TOKEN_KEY, t);
+    return t;
+}
+export function rotateDeviceToken(ctx) {
+    const t = randomBytes(16).toString('hex');
+    setSetting(ctx, TOKEN_KEY, t);
+    return t;
+}
+function safeEqual(a, b) {
+    const ba = Buffer.from(a);
+    const bb = Buffer.from(b);
+    if (ba.length !== bb.length)
+        return false;
+    return timingSafeEqual(ba, bb);
+}
+/** 从请求里取令牌：优先请求头（不落日志），其次查询串（方便浏览器直接开） */
+export function extractToken(headerValue, queryValue) {
+    if (headerValue && headerValue.trim())
+        return headerValue.trim();
+    return (queryValue ?? '').trim();
+}
+export function checkDeviceAccess(input) {
+    if (!input.lanEnabled)
+        return 'ALLOW';
+    if (!input.expected)
+        return 'NOT_CONFIGURED';
+    if (!input.provided)
+        return 'TOKEN_REQUIRED';
+    return safeEqual(input.expected, input.provided) ? 'ALLOW' : 'TOKEN_INVALID';
+}

package/dist/device/types.js

@@ -0,0 +1,2 @@
+/** 设备卡的数据契约。固件按这套字段解析（meta 段为 JSON）。 */
+export {};

package/dist/mcp/ctx.js

@@ -0,0 +1,48 @@
+/**
+ * 每次操作构造 ctx（timezone 实时解析：settings > profile > 默认）。
+ * 所有状态变更必须通过 Core Service（§23.9），MCP 层只做参数校验与转发。
+ */
+export function makeCtx(db, cfg, actor = 'agent') {
+    // resolve timezone: settings.timezone > profiles.timezone > cfg.timezone
+    let tz = cfg.timezone;
+    try {
+        const s = db.prepare("SELECT value FROM settings WHERE key='timezone'").get();
+        if (s?.value)
+            tz = s.value;
+        else {
+            const p = db.prepare('SELECT timezone FROM profiles WHERE deleted_at IS NULL LIMIT 1').get();
+            if (p?.timezone)
+                tz = p.timezone;
+        }
+    }
+    catch {
+        /* table may not exist during early init */
+    }
+    return { db, tz, actor };
+}
+import { ok, err } from '../shared/result.js';
+import { DomainError } from '../shared/result.js';
+export function toResult(fn) {
+    try {
+        return ok(fn());
+    }
+    catch (e) {
+        if (e instanceof DomainError) {
+            return err(e.code, e.message, e.retryable);
+        }
+        const message = e instanceof Error ? e.message : String(e);
+        return err('INTERNAL', message);
+    }
+}
+export async function toResultAsync(fn) {
+    try {
+        return ok(await fn());
+    }
+    catch (e) {
+        if (e instanceof DomainError) {
+            return err(e.code, e.message, e.retryable);
+        }
+        const message = e instanceof Error ? e.message : String(e);
+        return err('INTERNAL', message);
+    }
+}

package/dist/mcp/server.js

@@ -0,0 +1,15 @@
+#!/usr/bin/env node
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
+import { loadConfig } from '../shared/config.js';
+import { openDb } from '../db/client.js';
+import { registerTools } from './tools.js';
+const cfg = loadConfig();
+const db = openDb(cfg.dataDir);
+const server = new McpServer({ name: 'ai-growth', version: '1.1.0' }, {
+    instructions: 'AI Growth — agent-driven personal growth system. Call growth_status first; it tells you the suggested next operation (onboarding / replan / daily planning / continue).',
+});
+registerTools(server, db, cfg);
+const transport = new StdioServerTransport();
+await server.connect(transport);
+process.stderr.write(`[ai-growth] MCP server ready (data: ${cfg.dataDir})\n`);