Skip to content

armgit / cindy

Public Imported from GitHub
0

Consider it done. The open-source AI agent that works out of the box · 想到,就能做到。开源、开箱即用的 AI Agent。

14.7 KB
Raw Blame
/**
 * pendingFirstMessage —— 跨路由把「还不能在草稿页发出的首条」递交给真实 SessionView。
 *
 * 本机新建的普通文本不走这里:草稿路由 createSession 后直接 sendMessage,再 navigate。
 * 切走只换画面,发送在 makerChatStore 里继续,不依赖 SessionView hydrate。
 * SessionView 会当成斜杠命令的本机首条(列首 /cmd,以及 Pi 空白前缀)仍走 setPending:
 * desktop / Pi 分派必须等 SessionView 挂上(SSH 跳过控制端 skill、远端 /review 拒绝、
 * Pi runtime 重试),不能在草稿路由复制一套。
 *
 * device-link 远程草稿的普通首条同样不走这里:对端建会话之后,草稿路由直接交给
 * makerChatStore 的远程发件队列,切走也会送达。仍走这套交接的远程首条只有开了协同
 * (首轮要排在被控端起 Worker 之后,不能挡在 navigate 前面)与斜杠命令两类:
 *
 *   NewMakerDraftRoute.handleSend(远程,协同 / 斜杠命令)
 *     → 对端 create-session 拿到 remoteSessionId
 *     → setPending(remoteSessionId, { text, files, remoteCollab? })
 *     → navigate('/cc-agent/' + remoteSessionId)
 *   CCAgentSessionView mount
 *     → consumePending(id) → (可选开协同) → sendMessage(text, files)
 *
 * 仅内存(模块级 Map):app 重启意味着发送链路被打断,丢弃不持久化。
 * 一次性消费(consume 即删):防止重复发送。
 *
 * 例外见文件末尾「远程协同交接的可恢复副本」:device-link 开协同那条路径在 consume
 * 之后还要等被控端起 Worker,等待期间正文另存一份到 localStorage,重启后回填输入框。
 */

import type { AttachedFile, MentionedResource } from '@/lib/fileTypes';
import type { PastedTextRange, SlashCommandRange } from '@/lib/imageRef';
import type { AgentInputReference } from '@cindy/maker-shared/agent-input-projection';
import type { DeferredUiAssignment } from '@/features/cc-agent/deferredUiAssignment';
import type { BuiltInSkillDraftIntent } from '@/lib/composerDraftStore';

/**
 * device-link 草稿开了协同时,把「开协同」这件事一起交接给 SessionView(issue #1170)。
 *
 * 为什么不在 draft route 就 await 掉:被控端起 Worker 是一次隧道往返,可能一路走到
 * invoke 默认 30s 超时。把它挡在 navigate 前面,既让新建页凭空卡住半分钟,又把
 * 「对端会话已建好、用户输入还只在内存里」的窗口拉到同样长度(greptile P1)。
 * 而首轮必须排在协同之后又是硬要求 —— 两者只能靠「导航后再协调」同时满足:
 * draft route 登记完就立刻 navigate,SessionView 消费时先 await 开协同、再发首轮。
 */
export interface PendingRemoteCollab {
  /** 被控设备 deviceId —— Worker 在这台机器上 spawn。 */
  deviceId: string;
  /** enableOrca 入参,已按被控端的模型 / 供应商目录收窄。 */
  options: Record<string, unknown>;
  /** 老被控端不支持延迟派单时,保留新建 Lead 的待发送输入作为兼容上下文。 */
  pendingLeadInput?: string;
}

export interface PendingPayload {
  text: string;
  builtInSkillIntent?: BuiltInSkillDraftIntent;
  files?: AttachedFile[];
  mentions?: MentionedResource[];
  vendorOptions?: Record<string, unknown>;
  quotesEncoded?: boolean;
  agentReferences?: AgentInputReference[];
  pastedTextRanges?: PastedTextRange[];
  slashCommandRanges?: SlashCommandRange[];
  /** 非空 = 发首轮之前先在被控端开协同(见 PendingRemoteCollab)。 */
  remoteCollab?: PendingRemoteCollab;
  /** 本机 Worker 已创建但尚未派单;首条消息 accepted 后再派。 */
  deferredUiAssignment?: DeferredUiAssignment;
  /** 调试用——createPending 时刻,过期清理时可参考(目前未做 GC,实际场景 navigate 立即消费)。 */
  createdAt: number;
}

const map = new Map<string, PendingPayload>();

/** 超过此时间未被 consumePending 消费的 payload 自动清理,防止导航失败时大体积附件泄漏。 */
const PENDING_TTL_MS = 60_000;

export function setPending(sessionId: string, payload: Omit<PendingPayload, 'createdAt'>): void {
  map.set(sessionId, { ...payload, createdAt: Date.now() });
  setTimeout(() => {
    if (map.has(sessionId)) {
      map.delete(sessionId);
    }
  }, PENDING_TTL_MS);
}

export function consumePending(sessionId: string): PendingPayload | null {
  const v = map.get(sessionId);
  if (!v) return null;
  map.delete(sessionId);
  return v;
}

export function hasPending(sessionId: string): boolean {
  return map.has(sessionId);
}

// ─── pendingGoal —— 跨路由把「远程草稿的新建目标」递交给真实 SessionView ────────
// device-link 远程草稿的 New Goal 流程不能在 /cc-agent/new 就发 maker:goal:set:
// 重 topic `session:<id>` 订阅要等 CCAgentSessionView mount 才建立,goal 首轮的
// maker:event/status 推送会掉在订阅建立前的窗口里(Codex review #548)。
// 与首条消息同款交接:先建会话 → setPendingGoal → navigate → SessionView 消费
// (此时订阅已随 mount 建立)→ goalApiFor(sessionId).setGoal。
// 本机草稿不走这里(本机推送不经订阅,原地 setGoal 即可)。

export interface PendingGoalPayload {
  objective: string;
  limits: { maxTurns: number | null; budgetTokens: number | null; noProgressLimit: number | null };
  /** 与首条消息同款:非空 = 起目标首轮之前先在被控端开协同。 */
  remoteCollab?: PendingRemoteCollab;
  createdAt: number;
}

const goalMap = new Map<string, PendingGoalPayload>();

export function setPendingGoal(
  sessionId: string,
  payload: Omit<PendingGoalPayload, 'createdAt'>,
): void {
  goalMap.set(sessionId, { ...payload, createdAt: Date.now() });
  setTimeout(() => {
    goalMap.delete(sessionId);
  }, PENDING_TTL_MS);
}

export function consumePendingGoal(sessionId: string): PendingGoalPayload | null {
  const v = goalMap.get(sessionId);
  if (!v) return null;
  goalMap.delete(sessionId);
  return v;
}

// ─── 远程协同交接的可恢复副本 ──────────────────────────────────────────────────
//
// 为什么只有 remoteCollab 这条路径要落盘(greptile P1):
// 本机普通文本已在草稿路由直接 sendMessage。仍走 setPending 的是 device-link
// 远程草稿,以及本机必须交给 SessionView 分派的斜杠命令首条(含 Pi 空白前缀)。
// **device-link 远程交接**和本机不同 ——
// consume 之后还要 await 隧道往返:开协同要等被控端起 Worker(正常一两秒,慢设备会一路走到
// 30s 隧道超时再加 6×3s 回查),起目标之前还要先 await 一次 `deviceLink.subscribe`
// (同样是 invoke,同样可能走到 30s)。这段时间用户输入只存在于渲染进程内存里,
// app 被关掉就永久消失,被控端还留着一个没有首轮的空会话。
//
// 所以判据是「**这是不是一次远程交接**」,不是「开没开协同」:只挡在开协同那一段前面,
// 非协同的 device-link 起目标照样会在 subscribe 那次 await 里丢掉目标正文。
//
// 取舍:
//  · 只存**正文及可选的内置 Skill 调用意图**,不存附件 —— 与本仓既有取舍一致(newMakerDraft 头部:「附件 → 丢失
//    (产品决策)」),也避免把附件字节写进 localStorage。
//  · 恢复时**只回填输入框,绝不自动补发**。用户上次按下发送时的意图未必还成立,
//    重启后凭空冒出一条已发消息比丢失更难解释;回填后由用户自己决定。
//  · 与 PENDING_TTL_MS(60s,针对内存 payload)不同,这份副本要跨重启活着,
//    用天级 TTL 兜底,防止导航失败的残留无限堆积。

const RECOVERY_STORAGE_KEY = 'xdt:pendingHandoffRecovery:v1';
/** 跨重启保留,但不无限堆积:超过此年龄的残留在下次读写时清掉。 */
const RECOVERY_TTL_MS = 7 * 24 * 60 * 60 * 1000;

export type RecoverableHandoffKind = 'message' | 'goal';

interface RecoverableHandoff {
  kind: RecoverableHandoffKind;
  text: string;
  builtInSkillIntent?: BuiltInSkillDraftIntent;
  createdAt: number;
}

let activeDataOwnerId: string | null = null;

function recoveryStorageKey(): string {
  return activeDataOwnerId
    ? `${RECOVERY_STORAGE_KEY}:${encodeURIComponent(activeDataOwnerId)}`
    : RECOVERY_STORAGE_KEY;
}

/** 与 composerDraftStore / newMakerDraft 同款:按数据归属人分命名空间,换账号不串台。 */
export function setPendingHandoffOwner(ownerId: string | null): void {
  activeDataOwnerId = ownerId;
}

/**
 * 读全表并剔除过期 / 损坏项。localStorage 不可用或 schema 损坏时静默回退空表。
 *
 * **剔除必须落盘**:只从返回值里过滤掉,原始条目会一直留在磁盘上 —— 之后如果这个账号
 * 再没写过新的交接项,就永远没人重写那份 JSON,用户的正文实际上被无限期保存,
 * 与声明的 TTL 和「持久数据要有明确生命周期」不符(codex P2 第三轮)。
 * 所以这里回传是否发生过剔除,由 `loadRecoveryTable` 立刻写回清理后的表。
 */
function parseRecoveryTable(raw: string): {
  table: Record<string, RecoverableHandoff>;
  pruned: boolean;
} {
  let parsed: unknown;
  try {
    parsed = JSON.parse(raw);
  } catch {
    // 整份 JSON 都读不懂:当空表处理,并按"有剔除"落盘覆盖掉这份垃圾。
    return { table: {}, pruned: true };
  }
  if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed)) {
    return { table: {}, pruned: true };
  }
  const now = Date.now();
  const table: Record<string, RecoverableHandoff> = {};
  let pruned = false;
  for (const [sessionId, value] of Object.entries(parsed as Record<string, unknown>)) {
    const entry = (value ?? {}) as Partial<RecoverableHandoff>;
    const usable =
      !!value &&
      typeof value === 'object' &&
      typeof entry.text === 'string' &&
      entry.text !== '' &&
      (entry.kind === 'message' || entry.kind === 'goal') &&
      typeof entry.createdAt === 'number' &&
      now - entry.createdAt <= RECOVERY_TTL_MS;
    if (!usable) {
      pruned = true;
      continue;
    }
    table[sessionId] = {
      kind: entry.kind as RecoverableHandoffKind,
      text: entry.text as string,
      createdAt: entry.createdAt as number,
      ...(entry.builtInSkillIntent &&
      typeof entry.builtInSkillIntent.name === 'string' &&
      typeof entry.builtInSkillIntent.commandName === 'string'
        ? {
            builtInSkillIntent: {
              name: entry.builtInSkillIntent.name,
              commandName: entry.builtInSkillIntent.commandName,
            },
          }
        : {}),
    };
  }
  return { table, pruned };
}

/** 读全表;发生过剔除就立刻把清理后的表写回,不让过期正文赖在磁盘上。 */
function readRecoveryTable(): Record<string, RecoverableHandoff> {
  let raw: string | null;
  try {
    raw = window.localStorage.getItem(recoveryStorageKey());
  } catch {
    return {};
  }
  if (!raw) return {};
  const { table, pruned } = parseRecoveryTable(raw);
  if (pruned) writeRecoveryTable(table);
  return table;
}

function writeRecoveryTable(table: Record<string, RecoverableHandoff>): void {
  try {
    if (Object.keys(table).length === 0) {
      window.localStorage.removeItem(recoveryStorageKey());
      return;
    }
    window.localStorage.setItem(recoveryStorageKey(), JSON.stringify(table));
  } catch {
    // localStorage 满 / 私密窗口禁写 —— 忽略。副本是尽力而为的兜底,
    // 写不进去也不该把首轮发送本身弄失败。
  }
}

/** 进入远程协同等待**之前**调用:留下一份正文,等待期间 app 被关掉也能捞回来。 */
export function rememberRecoverableHandoff(
  sessionId: string,
  kind: RecoverableHandoffKind,
  text: string,
  builtInSkillIntent?: BuiltInSkillDraftIntent,
): void {
  if (!sessionId || text === '') return;
  const table = readRecoveryTable();
  table[sessionId] = {
    kind, text, createdAt: Date.now(),
    ...(builtInSkillIntent ? { builtInSkillIntent } : {}),
  };
  writeRecoveryTable(table);
}

/**
 * 丢掉副本。**模块私有** —— 唯一的公开入口是 `deliverRecoverableHandoff`。
 *
 * 不导出是刻意的:副本的删除条件("正文已经有了新的归宿")在本 PR 的 review 里被反复
 * 判错,每次都是某个调用点自己就地判断"这算交付了吧"。只要还能裸调它,下一处就还会
 * 再判错一次。收进 deliver 之后,"什么时候可以删"只剩一处可改。
 */
function forgetRecoverableHandoff(sessionId: string): void {
  if (!sessionId) return;
  const table = readRecoveryTable();
  if (!(sessionId in table)) return;
  delete table[sessionId];
  writeRecoveryTable(table);
}

/**
 * 把正文交出去,**只有确认交付成功才丢副本**。
 *
 * 这是删除副本的唯一途径。三处交接(命令派发 / 首轮 sendMessage / 起目标 setGoal)
 * 全部走这里,于是"交付成功"只有一个判据:
 *
 *  · `deliver()` resolve `true`  → 确实交出去了 → 丢副本;
 *  · `deliver()` resolve `false` → **没交出去**,副本必须留着;
 *  · `deliver()` 抛错             → 同样没交出去 → 保留副本,错误照常向上冒泡。
 *
 * 第二条是本轮 codex P1 的要害:`sendMessage` 在设备离线 / 访问被撤销 / 远端
 * `maker:input:enqueue` 拒绝时**不抛错**,而是 resolve `false`,并且对远程会话还会
 * 把那条乐观气泡从 transcript 里撤掉 —— 不 await 就删副本,等于正文从界面和磁盘上
 * 同时消失,而内存 pending 早已消费、新建页草稿也已清空。
 */
export async function deliverRecoverableHandoff(
  sessionId: string,
  deliver: () => boolean | Promise<boolean>,
): Promise<boolean> {
  const delivered = await deliver();
  if (delivered) forgetRecoverableHandoff(sessionId);
  return delivered;
}

/**
 * 取出并清除某会话的可恢复正文;kind 不匹配时不动它(首条消息与目标各自恢复各自的)。
 * 返回 null = 没有待恢复内容(绝大多数情况)。
 */
export function takeRecoverableHandoff(
  sessionId: string,
  kind: RecoverableHandoffKind,
): string | null {
  return takeRecoverableHandoffPayload(sessionId, kind)?.text ?? null;
}

/** Includes the built-in intent so restoring text cannot silently select a user skill. */
export function takeRecoverableHandoffPayload(
  sessionId: string,
  kind: RecoverableHandoffKind,
): RecoverableHandoff | null {
  if (!sessionId) return null;
  const table = readRecoveryTable();
  const entry = table[sessionId];
  if (!entry || entry.kind !== kind) return null;
  delete table[sessionId];
  writeRecoveryTable(table);
  return entry;
}

/** 测试用。 */
export function __clearAllForTest(): void {
  map.clear();
  goalMap.clear();
  activeDataOwnerId = null;
  try {
    window.localStorage.removeItem(RECOVERY_STORAGE_KEY);
  } catch {
    // ignore
  }
}