@vitex/nook 0.0.0-stage → 0.1.0

package/package.json

@@ -1,6 +1,39 @@
 {
   "name": "@vitex/nook",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "0.1.0",
+  "publishConfig": {
+    "access": "public"
+  },
+  "description": "Nook — a quiet web interface for the Pi coding agent",
+  "type": "module",
+  "bin": {
+    "nook": "bin/nook.js"
+  },
+  "files": [
+    "bin",
+    "src/backend",
+    "dist/frontend",
+    "README.md"
+  ],
+  "workspaces": [
+    "src/backend",
+    "src/frontend"
+  ],
+  "scripts": {
+    "dev:backend": "npm --workspace @nook/backend run dev",
+    "dev:frontend": "npm --workspace @nook/frontend run dev",
+    "build:frontend": "npm --workspace @nook/frontend run build",
+    "build": "npm run build:frontend && node scripts/build.js",
+    "start": "node bin/nook.js start",
+    "service": "node bin/nook.js service",
+    "prepublishOnly": "npm run build"
+  },
+  "dependencies": {
+    "@earendil-works/pi-coding-agent": "0.86.1",
+    "typebox": "1.3.27"
+  },
+  "engines": {
+    "node": ">=22.19.0"
+  },
+  "license": "ISC"
+}

package/src/backend/agent/pool.js

@@ -0,0 +1,229 @@
+/**
+ * 会话池：一个 Pi 会话文件对应一个常驻 AgentSession。
+ *
+ * 同一会话同时只允许一个 prompt。事件直接交给 `emit`（服务端负责 SSE 广播），
+ * 这样 Pi 的 message_update / tool_execution_* 能原样流到前端。
+ */
+import crypto from 'node:crypto';
+import { createAgentSession } from '@earendil-works/pi-coding-agent';
+import { findSessionFile, openSessionManager } from '../sessions.js';
+import { getModelRuntime } from './runtime.js';
+import { loadCustomTools } from './tools.js';
+import { log, logErr, shortId } from '../logging.js';
+
+const IDLE_MS = 30 * 60 * 1000;
+const MAX_IDLE = 12;
+
+export class SessionPool {
+  constructor({ emit }) {
+    this.emit = emit;
+    this.entries = new Map();
+    this.ready = null;
+    this.gcTimer = setInterval(() => this.gc(), 10 * 60 * 1000);
+    if (this.gcTimer.unref) this.gcTimer.unref();
+  }
+
+  async init() {
+    if (!this.ready) {
+      this.ready = (async () => {
+        const [runtime, customTools] = await Promise.all([
+          getModelRuntime(),
+          loadCustomTools(),
+        ]);
+        this.runtime = runtime;
+        this.customTools = customTools;
+        return this;
+      })();
+    }
+    return this.ready;
+  }
+
+  key(project, sessionId) {
+    return `${project.id}:${sessionId}`;
+  }
+
+  async get(project, sessionId) {
+    await this.init();
+    const key = this.key(project, sessionId);
+    const cached = this.entries.get(key);
+    if (cached) {
+      cached.lastUsed = Date.now();
+      return cached;
+    }
+
+    const file = findSessionFile(project, sessionId);
+    const sessionManager = openSessionManager(project, sessionId, file);
+    const { session } = await createAgentSession({
+      cwd: project.path,
+      modelRuntime: this.runtime,
+      sessionManager,
+      customTools: this.customTools,
+    });
+
+    const entry = {
+      key,
+      project,
+      projectId: project.id,
+      sessionId,
+      sessionManager,
+      session,
+      running: false,
+      run: null,
+      lastUsed: Date.now(),
+      unsubscribe: null,
+    };
+    entry.unsubscribe = session.subscribe((event) => {
+      try {
+        this.emit(project, sessionId, event);
+      } catch (e) {
+        logErr('转发会话事件失败：', e?.message || e);
+      }
+    });
+    this.entries.set(key, entry);
+    this.evict();
+    log(`打开会话 ${shortId(sessionId)}（${file ? 'pi' : 'new'}）`);
+    return entry;
+  }
+
+  /**
+   * 发送消息。
+   * mode: 'prompt' 普通发送；'steer' 运行中插话；'followUp' 运行中排队跟进。
+   * 运行中传普通 prompt 会抛 RUNNING；steer/followUp 只入队，不新建 run。
+   */
+  async send(project, sessionId, text, mode = 'prompt') {
+    const entry = await this.get(project, sessionId);
+    if (entry.running) {
+      if (mode === 'steer') {
+        await entry.session.steer(text);
+        return { queued: true, mode };
+      }
+      if (mode === 'followUp') {
+        await entry.session.followUp(text);
+        return { queued: true, mode };
+      }
+      const err = new Error('这个会话正在运行');
+      err.code = 'RUNNING';
+      throw err;
+    }
+
+    const run = {
+      id: crypto.randomUUID(),
+      startedAt: Date.now(),
+      userText: text,
+      startSeq: 0,
+    };
+    entry.running = true;
+    entry.run = run;
+    run.startSeq = this.emit(project, sessionId, {
+      type: 'nook_run_start',
+      runId: run.id,
+      startedAt: run.startedAt,
+      userText: text,
+    });
+
+    (async () => {
+      try {
+        await entry.session.prompt(text);
+      } catch (e) {
+        logErr('prompt 失败：', e?.message || e);
+        this.emit(project, sessionId, { type: 'nook_error', message: e?.message || String(e) });
+      } finally {
+        if (entry.run?.id === run.id) {
+          entry.running = false;
+          entry.run = null;
+          entry.lastUsed = Date.now();
+          this.emit(project, sessionId, { type: 'nook_run_end', runId: run.id });
+        }
+      }
+    })();
+
+    return { runId: run.id, startSeq: run.startSeq, queued: false };
+  }
+
+  async abort(project, sessionId) {
+    const entry = this.entries.get(this.key(project, sessionId));
+    if (!entry) return { aborted: false, cleared: { steering: [], followUp: [] } };
+    const cleared = entry.session.clearQueue();
+    if (!entry.running) return { aborted: false, cleared };
+    try {
+      await entry.session.abort();
+    } catch (e) {
+      logErr('abort 失败：', e?.message || e);
+    }
+    return { aborted: true, cleared };
+  }
+
+  clearQueue(project, sessionId) {
+    const entry = this.entries.get(this.key(project, sessionId));
+    if (!entry) return { steering: [], followUp: [] };
+    return entry.session.clearQueue();
+  }
+
+  getRun(project, sessionId) {
+    const entry = this.entries.get(this.key(project, sessionId));
+    if (!entry?.run) return null;
+    return {
+      runId: entry.run.id,
+      startedAt: entry.run.startedAt,
+      userText: entry.run.userText,
+      startSeq: entry.run.startSeq,
+      queue: {
+        steering: [...entry.session.getSteeringMessages()],
+        followUp: [...entry.session.getFollowUpMessages()],
+      },
+    };
+  }
+
+  isRunning(projectId, sessionId) {
+    const entry = this.entries.get(`${projectId}:${sessionId}`);
+    return Boolean(entry?.running);
+  }
+
+  runningSessions(projectId) {
+    const out = new Set();
+    for (const entry of this.entries.values()) {
+      if (entry.projectId === projectId && entry.running) out.add(entry.sessionId);
+    }
+    return out;
+  }
+
+  disposeEntry(entry) {
+    if (!entry || entry.running) return false;
+    try { entry.unsubscribe?.(); } catch { }
+    try { entry.session.dispose(); } catch { }
+    this.entries.delete(entry.key);
+    return true;
+  }
+
+  dispose(projectId, sessionId) {
+    return this.disposeEntry(this.entries.get(`${projectId}:${sessionId}`));
+  }
+
+  disposeProject(projectId) {
+    for (const entry of [...this.entries.values()]) {
+      if (entry.projectId === projectId) this.disposeEntry(entry);
+    }
+  }
+
+  disposeAll() {
+    for (const entry of [...this.entries.values()]) this.disposeEntry(entry);
+    clearInterval(this.gcTimer);
+  }
+
+  evict() {
+    if (this.entries.size <= MAX_IDLE) return;
+    const idle = [...this.entries.values()]
+      .filter((e) => !e.running)
+      .sort((a, b) => a.lastUsed - b.lastUsed);
+    while (this.entries.size > MAX_IDLE && idle.length) {
+      this.disposeEntry(idle.shift());
+    }
+  }
+
+  gc() {
+    const now = Date.now();
+    for (const entry of [...this.entries.values()]) {
+      if (!entry.running && now - entry.lastUsed > IDLE_MS) this.disposeEntry(entry);
+    }
+  }
+}

package/src/backend/agent/runtime.js

@@ -0,0 +1,17 @@
+/**
+ * 共享的 Pi 模型运行时。
+ * 模型选择完全交给 Pi 的设置，Nook 不指定默认值。
+ */
+import { ModelRuntime } from '@earendil-works/pi-coding-agent';
+
+let runtimePromise;
+
+export function getModelRuntime() {
+  if (!runtimePromise) {
+    runtimePromise = ModelRuntime.create({
+      allowModelNetwork: true,
+      modelRefreshTimeoutMs: 15_000,
+    });
+  }
+  return runtimePromise;
+}

package/src/backend/agent/serialize.js

@@ -0,0 +1,180 @@
+/**
+ * 把 SDK 事件压成适合通过 SSE 传输的形状：
+ * - 去掉 message_update 里不断增长的 partial 快照
+ * - 工具结果/参数截断，避免手机端一次收几 MB
+ * - 保留前端工具卡片需要的 toolcall 参数快照
+ */
+import { stripAnsi } from '../text.js';
+
+const VALUE_LIMIT = 4000;
+const RESULT_LIMIT = 8000;
+
+function truncateString(s, limit) {
+  const str = String(s ?? '');
+  if (str.length <= limit) return str;
+  return str.slice(0, limit) + `\n…（已截断 ${str.length - limit} 字符）`;
+}
+
+export function truncateValue(value, limit = VALUE_LIMIT, depth = 0) {
+  if (value == null) return value;
+  if (typeof value === 'string') return truncateString(value, limit);
+  if (typeof value !== 'object') return value;
+  if (depth > 6) return '[…]';
+  if (Array.isArray(value)) return value.map((v) => truncateValue(v, limit, depth + 1));
+  const out = {};
+  for (const [k, v] of Object.entries(value)) out[k] = truncateValue(v, limit, depth + 1);
+  return out;
+}
+
+function serializeContent(content) {
+  if (typeof content === 'string') return content;
+  if (!Array.isArray(content)) return [];
+  return content.map((block) => {
+    if (!block || typeof block !== 'object') return block;
+    if (block.type === 'text') return { type: 'text', text: block.text };
+    if (block.type === 'thinking') {
+      return { type: 'thinking', thinking: block.thinking, redacted: Boolean(block.redacted) };
+    }
+    if (block.type === 'toolCall') {
+      return {
+        type: 'toolCall',
+        id: block.id,
+        name: block.name,
+        arguments: truncateValue(block.arguments),
+      };
+    }
+    if (block.type === 'image') return { type: 'text', text: '[图片]' };
+    return block;
+  });
+}
+
+function serializeToolResult(content) {
+  const text = Array.isArray(content)
+    ? content.filter((b) => b?.type === 'text').map((b) => b.text || '').join('\n')
+    : typeof content === 'string' ? content : '';
+  const cut = truncateString(stripAnsi(text), RESULT_LIMIT);
+  return { content: [{ type: 'text', text: cut }], truncated: cut.length !== text.length, length: text.length };
+}
+
+export function serializeMessage(message) {
+  if (!message || typeof message !== 'object') return message;
+  if (message.role === 'toolResult') {
+    return {
+      role: 'toolResult',
+      toolCallId: message.toolCallId,
+      toolName: message.toolName,
+      content: serializeToolResult(message.content).content,
+      isError: Boolean(message.isError),
+      timestamp: message.timestamp,
+    };
+  }
+  return {
+    role: message.role,
+    content: serializeContent(message.content),
+    stopReason: message.stopReason,
+    errorMessage: message.errorMessage,
+    timestamp: message.timestamp,
+  };
+}
+
+function toolCallFromPartial(partial, contentIndex, limit = 1200) {
+  const block = partial?.content?.[contentIndex];
+  if (!block || block.type !== 'toolCall') return null;
+  return {
+    id: block.id,
+    name: block.name,
+    arguments: truncateValue(block.arguments ?? block.partialArgs ?? block.partialJson, limit),
+  };
+}
+
+export function serializeEvent(event) {
+  if (!event || typeof event !== 'object') return event;
+  switch (event.type) {
+    case 'message_update': {
+      const a = event.assistantMessageEvent;
+      if (!a) return { type: 'message_update' };
+      const out = { type: a.type, contentIndex: a.contentIndex };
+      if (typeof a.delta === 'string') out.delta = a.delta;
+      if (a.type === 'toolcall_start' || a.type === 'toolcall_delta' || a.type === 'toolcall_end') {
+        const tc = a.type === 'toolcall_end' ? a.toolCall : toolCallFromPartial(a.partial, a.contentIndex);
+        if (tc) out.toolCall = {
+          id: tc.id,
+          name: tc.name,
+          arguments: truncateValue(tc.arguments, a.type === 'toolcall_end' ? 4000 : 1200),
+        };
+      }
+      return { type: 'message_update', assistantMessageEvent: out };
+    }
+    case 'message_start':
+    case 'message_end':
+      return { type: event.type, message: serializeMessage(event.message) };
+    case 'tool_execution_start':
+      return {
+        type: event.type,
+        toolCallId: event.toolCallId,
+        toolName: event.toolName,
+        args: truncateValue(event.args),
+      };
+    case 'tool_execution_update':
+      // 前端不需要流式工具输出；只保留事件骨架，避免把大段输出塞进 SSE / 内存环形缓冲
+      return {
+        type: event.type,
+        toolCallId: event.toolCallId,
+        toolName: event.toolName,
+      };
+    case 'tool_execution_end':
+      return {
+        type: event.type,
+        toolCallId: event.toolCallId,
+        toolName: event.toolName,
+        result: serializeToolResult(event.result?.content).content,
+        isError: Boolean(event.isError),
+      };
+    case 'turn_start':
+      return { type: event.type, turnIndex: event.turnIndex, timestamp: event.timestamp };
+    case 'turn_end':
+      return { type: event.type, turnIndex: event.turnIndex, timestamp: event.timestamp };
+    case 'agent_end':
+      return { type: 'agent_end', willRetry: Boolean(event.willRetry) };
+    case 'agent_settled':
+      return { type: 'agent_settled' };
+    case 'compaction_start':
+      return { type: event.type, reason: event.reason };
+    case 'compaction_end':
+      return {
+        type: event.type,
+        reason: event.reason,
+        aborted: Boolean(event.aborted),
+        willRetry: Boolean(event.willRetry),
+        errorMessage: event.errorMessage,
+      };
+    case 'auto_retry_start':
+      return {
+        type: event.type,
+        attempt: event.attempt,
+        maxAttempts: event.maxAttempts,
+        delayMs: event.delayMs,
+        errorMessage: event.errorMessage,
+      };
+    case 'auto_retry_end':
+      return { type: event.type, success: Boolean(event.success), attempt: event.attempt, finalError: event.finalError };
+    case 'session_info_changed':
+      return { type: event.type, name: event.name };
+    case 'thinking_level_changed':
+      return { type: event.type, level: event.level };
+    case 'model_select':
+      return { type: event.type, model: event.model ? { provider: event.model.provider, id: event.model.id } : null };
+    case 'queue_update':
+      return { type: event.type, steering: event.steering, followUp: event.followUp };
+    case 'bash_execution_update':
+      return { type: event.type, id: event.id, delta: truncateString(event.delta, 2000) };
+    case 'entry_appended':
+      return { type: 'entry_appended' };
+    case 'nook_run_start':
+    case 'nook_run_end':
+    case 'nook_error':
+      return event;
+    default:
+      return { type: event.type || 'unknown' };
+  }
+}

package/src/backend/agent/tools.js

@@ -0,0 +1,34 @@
+/**
+ * Nook 的附加工具。Pi 自带的 read/bash/edit/write 仍然保留。
+ * 这里先只加 server_time。
+ */
+import { defineTool } from '@earendil-works/pi-coding-agent';
+import { Type } from 'typebox';
+
+const serverTime = defineTool({
+  name: 'server_time',
+  label: '服务器时间',
+  description: '返回运行 agent 的服务器当前时间（本地时区），用于需要时间信息的任务。',
+  parameters: Type.Object({
+    format: Type.Optional(
+      Type.Union([Type.Literal('iso'), Type.Literal('human')], {
+        default: 'human',
+        description: '输出格式：iso 为 ISO 字符串，human 为可读时间',
+      }),
+    ),
+  }),
+  async execute(_toolCallId, params) {
+    const now = new Date();
+    if (params.format === 'iso') {
+      return { content: [{ type: 'text', text: now.toISOString() }], details: null };
+    }
+    return {
+      content: [{ type: 'text', text: now.toLocaleString('zh-CN', { timeZoneName: 'short' }) }],
+      details: null,
+    };
+  },
+});
+
+export async function loadCustomTools() {
+  return [serverTime];
+}