@xiaobuyu/nodesign 0.0.1

package/server/api/instruction.js

@@ -0,0 +1,75 @@
+/**
+ * server/api/instruction.js — 项目 Instruction 文件读写
+ *
+ * Instruction = workspace/.claude/CLAUDE.md。SDK 启用 settingSources:
+ * ['project'] 后 agent 进每次 session 自动读到 system prompt。S1 已经
+ * 在 ensureProjectWorkspace 写入模板 starter，本阶段加 GET/PUT 让前端
+ * "项目背景" tab 直接编辑该文件。
+ *
+ * GET /api/projects/:pid/instruction
+ *   → { content: string, exists: boolean }
+ *
+ * PUT /api/projects/:pid/instruction
+ *   body: { content: string }
+ *   → { ok: true }
+ *
+ * 长度限制 64KB（agent system prompt 不该太长 → token 浪费）。
+ * 文件不存在时返回 exists=false，content 用模板内容（fallback 不报错）。
+ */
+
+import express from 'express';
+import path from 'path';
+import { promises as fs } from 'fs';
+import { validateProjectId, getProject } from '../projects/store.js';
+import { guardProject } from './_guard.js';
+import { getSharedDir, ensureProjectWorkspace } from '../projects/workspace.js';
+
+const router = express.Router();
+
+const INSTRUCTION_FILE = 'CLAUDE.md';
+const INSTRUCTION_MAX_BYTES = 64 * 1024;
+
+router.get('/:pid/instruction', async (req, res, next) => {
+  try {
+    const project = guardProject(req, res);
+    if (!project) return;
+
+    // ensureProjectWorkspace 幂等补齐（老 project 第一次进 instruction tab 也能读到）
+    await ensureProjectWorkspace(req.params.pid);
+
+    const filePath = path.join(getSharedDir(req.params.pid), '.claude', INSTRUCTION_FILE);
+    try {
+      const content = await fs.readFile(filePath, 'utf8');
+      res.json({ content, exists: true });
+    } catch (err) {
+      if (err.code === 'ENOENT') {
+        // ensureProjectWorkspace 应该已经写了，这里 fallback 防万一
+        res.json({ content: '', exists: false });
+      } else {
+        throw err;
+      }
+    }
+  } catch (err) { next(err); }
+});
+
+router.put('/:pid/instruction', async (req, res, next) => {
+  try {
+    const project = guardProject(req, res);
+    if (!project) return;
+
+    const { content } = req.body || {};
+    if (typeof content !== 'string') {
+      return res.status(400).json({ error: 'content must be string' });
+    }
+    if (Buffer.byteLength(content, 'utf8') > INSTRUCTION_MAX_BYTES) {
+      return res.status(400).json({ error: `instruction too long (max ${INSTRUCTION_MAX_BYTES} bytes)` });
+    }
+
+    await ensureProjectWorkspace(req.params.pid);
+    const filePath = path.join(getSharedDir(req.params.pid), '.claude', INSTRUCTION_FILE);
+    await fs.writeFile(filePath, content, 'utf8');
+    res.json({ ok: true });
+  } catch (err) { next(err); }
+});
+
+export default router;

package/server/api/local.js

@@ -0,0 +1,115 @@
+/**
+ * server/api/local.js — 本地分发版专用接口（只在 NODESIGN_PROFILE=local 下挂载，见 index.js）。
+ *
+ *   GET  /api/local/status    profile / 数据目录 / 配置文件路径 / 插槽配置错误 / 版本
+ *   GET  /api/local/config    原始配置 + 校验结果 + 表单要的枚举（配置页用）
+ *   PUT  /api/local/config    保存（先校验；有错也存——用户可能在存半成品——但把 errors 回给页面标红）。
+ *                             模型表是加载时冻结的，改动要 POST /restart 才生效，响应里 needsRestart 说这件事
+ *   POST /api/local/restart   优雅退出并以 RESTART_EXIT_CODE 退，bin/nodesign.js 的 supervisor 拉起新进程
+ *
+ * 请求者恒为 LOCAL_OWNER（admin）；这里不再做权限判断——hosted 下整组路由不存在。
+ */
+
+import express from 'express';
+import { readFileSync } from 'node:fs';
+import { fileURLToPath } from 'node:url';
+import path from 'node:path';
+import { platform } from '../runtime/platform.js';
+import { loadLocalConfig, saveLocalConfig, CONFIG_ENUMS } from '../runtime/local-config.js';
+import { MODEL_CONFIG_ERRORS, EXTERNAL_SDK_ALIAS, externalModelIds } from '../engine/agent/model-context.js';
+import { UPSTREAMS_BUILTIN } from '../engine/agent/model-table.js';
+import { capabilitySnapshot } from '../runtime/capabilities.js';
+import { TOOL_CAPABILITIES } from '../engine/mcp/capability-gate.js';
+import { probeCapabilities } from '../runtime/capabilities.js';
+import { envView, setEnvValues, envPath } from '../runtime/local-env.js';
+import { probeModel } from '../lib/ingress/slot-probe.js';
+import { selectableModelsFor } from '../engine/agent/model-context.js';
+
+export const RESTART_EXIT_CODE = 75;
+
+const pkg = JSON.parse(readFileSync(path.join(path.dirname(fileURLToPath(import.meta.url)), '../../package.json'), 'utf8'));
+
+const router = express.Router();
+
+router.get('/status', (_req, res) => {
+  res.json({
+    profile: platform.profile,
+    version: pkg.version,
+    pid: process.pid,
+    dataRoot: platform.dataRoot,
+    configPath: loadLocalConfig().path,
+    // 进程里**正在生效**的那份表报的错（文件现在可能已经改好但没重启）
+    modelConfigErrors: MODEL_CONFIG_ERRORS,
+    // 本机能力位 + 每个能力位管着哪些工具（配置页那张表）
+    capabilities: capabilitySnapshot().map((c) => ({ ...c, tools: Object.entries(TOOL_CAPABILITIES).filter(([, v]) => v.cap === c.id).map(([t]) => t) })),
+    externalSdkAlias: EXTERNAL_SDK_ALIAS,
+    // 内置 Claude 行现在能不能选：'api_key' | 'login' | null（设置页「模型」那块的状态行）
+    claudeAuth: platform.claudeAuthPresent(),
+    // 内置上游（只报名字和是否配了钥匙，不报钥匙）：配置页提示「这些名字被占了」
+    builtinUpstreams: Object.fromEntries(Object.entries(UPSTREAMS_BUILTIN).map(([id, u]) => [id, { label: u.label, keyPresent: u.authStyle === 'none' || !!(u.keyEnv && process.env[u.keyEnv]) }])),
+  });
+});
+
+router.get('/config', (_req, res) => {
+  const cfg = loadLocalConfig();
+  res.json({ path: cfg.path, exists: cfg.exists, raw: cfg.raw || { upstreams: {}, models: [] }, errors: cfg.errors, enums: CONFIG_ENUMS,
+    // 这份文件里的行此刻有没有在跑：不在这份名单里说明还没重启（或校验没过）
+    activeExternalModels: externalModelIds() });
+});
+
+router.put('/config', (req, res) => {
+  const raw = req.body;
+  if (raw === null || typeof raw !== 'object' || Array.isArray(raw)) {
+    return res.status(400).json({ error: '配置必须是一个对象 { upstreams, models }' });
+  }
+  try {
+    const v = saveLocalConfig(raw);
+    res.json({ ok: true, path: v.path, errors: v.errors, needsRestart: true });
+  } catch (err) {
+    res.status(500).json({ error: `写配置失败：${err.message}` });
+  }
+});
+
+// ── 钥匙与开关（<dataRoot>/.env 白名单）──
+router.get('/env', (_req, res) => {
+  res.json({ path: envPath, keys: envView() });
+});
+
+router.put('/env', async (req, res) => {
+  const values = req.body?.values;
+  if (!values || typeof values !== 'object' || Array.isArray(values)) return res.status(400).json({ error: 'body 要是 { values: { KEY: "v" | null } }' });
+  try {
+    const r = setEnvValues(values);
+    // 钥匙变了能力表要重探（钥匙类即时生效；二进制类不变），新会话的工具闸就按新结果
+    await probeCapabilities({ force: true });
+    res.json({ ok: true, changed: r.changed, keys: envView(), capabilities: capabilitySnapshot() });
+  } catch (err) {
+    res.status(400).json({ error: err.message });
+  }
+});
+
+// ── 插槽体检（穿进程内入口打五发最小请求，见 lib/ingress/slot-probe.js）──
+const probing = new Set();
+router.post('/models/:id/probe', async (req, res) => {
+  const id = req.params.id;
+  if (!selectableModelsFor(req.user).some((m) => m.id === id)) return res.status(404).json({ error: `模型 ${id} 不在可选清单里（没配钥匙的行不体检）` });
+  if (probing.has(id)) return res.status(409).json({ error: '这一行正在体检，等它完' });
+  probing.add(id);
+  try {
+    const vision = req.query.vision !== '0';
+    const timeoutMs = Math.min(120_000, Math.max(5_000, Number(req.query.timeoutMs) || 45_000));
+    res.json(await probeModel(id, { vision, timeoutMs }));
+  } catch (err) {
+    res.status(500).json({ error: `体检出错：${err.message}` });
+  } finally {
+    probing.delete(id);
+  }
+});
+
+router.post('/restart', (_req, res) => {
+  res.json({ ok: true, note: '正在重启，几秒后刷新页面' });
+  // 先把响应发出去再退
+  setTimeout(() => process.emit('nodesign:restart'), 150);
+});
+
+export default router;

package/server/api/me.js

@@ -0,0 +1,116 @@
+/**
+ * server/api/me.js — 当前用户自视图（2026-07-30 内测）
+ *
+ *   GET    /api/me/usage              → { usedToday, limit, username, role }
+ *   GET    /api/me/models             → { options } 这个账号能选的模型（没有会话时问这条）
+ *   GET    /api/me/showcase           → 个人作品橱窗（作品 + 它沉淀出来的 skill）
+ *   GET    /api/me/showcase/:id/cover → 该作品封面 webp（复用首页那套截图缓存）
+ *   DELETE /api/me/showcase/:id       → 移出橱窗（只删卡片，不动作品本体）
+ *
+ * 橱窗条目目前由 agent 的 crystallize_skill 工具产生；跨用户的"市场"还没开
+ * （别人的 SKILL.md 会整段进你的 agent 上下文，得先有审核范围）。
+ */
+
+import express from 'express';
+import { checkQuota, usedTodayByFamily, usedTokensToday, familyLabel } from '../lib/quota.js';
+import { getActiveNotice } from '../lib/notice-store.js';
+import { listEntries, getEntry, removeEntry } from '../lib/showcase-store.js';
+import { getArtifactCover } from '../lib/cover.js';
+import { getSharedDir } from '../projects/workspace.js';
+import { getProject } from '../projects/store.js';
+import { selectableModelsFor, defaultModelFor } from '../engine/agent/model-context.js';
+import { tierOf } from '../auth/tier.js';
+
+const router = express.Router();
+
+/**
+ * 这个账号能选的模型清单 —— **没有会话时**（首页快速开始 / 项目 Hub）走这条。
+ *
+ * 有会话的那条在 `GET /:pid/sessions/:sid/model`，它顺带回当前生效值；这里没有
+ * 可读的会话配置，所以只回清单，选中值仍由前端的本地偏好决定。
+ *
+ * 为什么要有这条：前端原来在没有会话时直接吃 `web/src/lib/models.js` 的
+ * `FALLBACK_MODELS` 硬编码常量，于是**带闸门的模型（本地 Qwen）在首页永远不出现** ——
+ * 会话里能选、首页选不了，同一颗按钮两种清单。兜底清单从此只在这条接口也挂了时用。
+ */
+router.get('/models', (req, res) => {
+  res.json({ options: selectableModelsFor(req.user), default: defaultModelFor(req.user) });
+});
+
+/**
+ * 今日用量。**单位是美元**（口径见 lib/quota.js 文件头）。
+ *
+ * 金额对所有人可见（07-31 定案）。先前藏过一版，顾虑是"$1.36 / $15.00"会被读成
+ * 账单；但换模型的冷启动提醒必须带一个数才有意义，而同一个东西在一个地方说
+ * 美元、另一个地方说百分比，用户没法把两句话对上。统一成钱，顺带让人知道
+ * 这些对话背后有真实成本 —— 这本身就是内测该传达的信息。
+ */
+router.get('/usage', (req, res) => {
+  const { usedToday, limit, kind, used } = checkQuota(req.user);
+  const byFamily = usedTodayByFamily(req.user.id);
+  // 分模型只报明细不报限额 —— 07-31 起限额是一个总数，模型之间不再分账
+  const models = Object.entries(byFamily)
+    .filter(([, v]) => v.costUsd > 0 || v.tokens > 0)
+    .sort((a, b) => b[1].costUsd - a[1].costUsd)
+    .map(([family, v]) => ({
+      family,
+      label: familyLabel(family),
+      costUsd: v.costUsd,
+      tokens: v.tokens,
+    }));
+  res.json({
+    unit: 'usd',
+    kind,                                    // 'unlimited' | 'daily' | 'lifetime'（试用号）
+    used,                                    // 与 limit 同口径：daily=今天，lifetime=全史
+    usedToday,
+    limit,                                   // admin 是 null（不限额）
+    pct: limit ? Math.min(100, (used / limit) * 100) : 0,
+    capped: limit !== null,
+    tokensToday: usedTokensToday(req.user.id),
+    models,
+    // 站内公告搭这趟车（2026-07-31）：横幅组件本来就在 60s 轮询这个端点，
+    // 单开一个 /notice 就是第二个轮询循环，为一条一天用不到一次的消息不值得。
+    notice: getActiveNotice(),
+    username: req.user.username,
+    role: req.user.role,
+    tier: tierOf(req.user),                  // admin | pro | basic（auth/tier.js）：顶栏朱砂点 / pro 标签 / basic 解锁提示用
+  });
+});
+
+router.get('/showcase', (req, res) => {
+  const entries = listEntries(req.user.id).map((e) => ({
+    ...e,
+    // 项目可能已经被删：卡片还在，但别给一个点进去 404 的链接
+    projectAlive: e.projectId ? !!getProject(e.projectId) : false,
+  }));
+  res.json({ entries });
+});
+
+router.get('/showcase/:id/cover', async (req, res, next) => {
+  try {
+    const entry = getEntry(req.params.id);
+    if (!entry || entry.userId !== req.user.id) return res.status(404).end();
+    if (!entry.projectId || !entry.artifactRel) return res.status(204).end();
+    if (!getProject(entry.projectId)) return res.status(204).end();
+    let result;
+    try {
+      result = await getArtifactCover(entry.projectId, getSharedDir(entry.projectId), entry.artifactRel);
+    } catch (err) {
+      console.warn('[showcase cover] render failed:', err.message);
+      return res.status(204).end();
+    }
+    if (!result) return res.status(204).end();
+    if (req.headers['if-none-match'] === `"${result.etag}"`) return res.status(304).end();
+    res.set('ETag', `"${result.etag}"`);
+    res.set('Cache-Control', 'private, max-age=60');
+    res.type('image/webp').send(result.buffer);
+  } catch (err) { next(err); }
+});
+
+router.delete('/showcase/:id', (req, res) => {
+  const removed = removeEntry(req.params.id, req.user.id);
+  if (!removed) return res.status(404).json({ error: 'not found' });
+  res.status(204).end();
+});
+
+export default router;

package/server/api/memory.js

@@ -0,0 +1,185 @@
+/**
+ * server/api/memory.js — 项目级 agent memory 读写（H4b）
+ *
+ * 数据落在 shared/.claude/agent-memory/<agentType>/<file>，agent 用 SDK
+ * memory 机制（session-loop.js 启用 settingSources: ['project'] 后软链让 agent
+ * 看到 shared 路径）按需写。本文件给前端 MemoryCard 展示 + 用户偶尔覆盖。
+ *
+ * 路径：
+ *   shared/.claude/agent-memory/                   ← 顶级（无 agentType）
+ *     ├── memory.md                                ← 默认（main agent）
+ *     ├── <agentType>/                             ← 子 agent（vision-checker / 等）
+ *     │   └── memory.md
+ *
+ * 简化决策：
+ *   - 一个 agentType 一个 memory 概要（concat 子文件作内容）
+ *   - GET 返回所有 agentType 概要列表 + 每个的预览
+ *   - GET /:agentType 返回该 agent 的全文（concat 多文件）
+ *   - PUT /:agentType 覆盖 memory.md（默认文件名）
+ *   - DELETE /:agentType 删整个 agent 子目录
+ *
+ * 长度上限 64KB（agent system prompt 不该太长）
+ */
+
+import express from 'express';
+import path from 'path';
+import { promises as fs } from 'fs';
+import { validateProjectId, getProject } from '../projects/store.js';
+import { guardProject } from './_guard.js';
+import { getSharedDir, ensureProjectWorkspace } from '../projects/workspace.js';
+
+const router = express.Router();
+
+const MEMORY_FILE = 'memory.md';
+const MEMORY_MAX_BYTES = 64 * 1024;
+const AGENT_TYPE_RE = /^[A-Za-z0-9._-]+$/;
+
+function memoryRoot(pid) {
+  return path.join(getSharedDir(pid), '.claude', 'agent-memory');
+}
+
+async function fileExists(p) {
+  try { await fs.access(p); return true; } catch { return false; }
+}
+
+async function readDirectoryConcat(dir) {
+  let out = '';
+  try {
+    const entries = await fs.readdir(dir, { withFileTypes: true });
+    for (const e of entries.sort((a, b) => a.name.localeCompare(b.name))) {
+      if (!e.isFile()) continue;
+      try {
+        const content = await fs.readFile(path.join(dir, e.name), 'utf8');
+        if (out) out += '\n\n';
+        out += content;
+      } catch { /* skip unreadable */ }
+    }
+  } catch (err) {
+    if (err.code !== 'ENOENT') throw err;
+  }
+  return out;
+}
+
+// ── GET：列项目所有 agent 的 memory 概要 ──
+router.get('/:pid/memory', async (req, res, next) => {
+  try {
+    if (!guardProject(req, res)) return;
+
+    await ensureProjectWorkspace(req.params.pid);
+    const root = memoryRoot(req.params.pid);
+
+    // 默认（顶层 memory.md，main agent 用）
+    const out = [];
+    const topMemoryFile = path.join(root, MEMORY_FILE);
+    if (await fileExists(topMemoryFile)) {
+      const content = await fs.readFile(topMemoryFile, 'utf8');
+      out.push({
+        agentType: null,  // 顶层 = main agent / shared
+        size: Buffer.byteLength(content, 'utf8'),
+        preview: content.slice(0, 200),
+      });
+    }
+
+    // 子目录 = 各 agentType
+    let entries;
+    try {
+      entries = await fs.readdir(root, { withFileTypes: true });
+    } catch (err) {
+      if (err.code !== 'ENOENT') throw err;
+      entries = [];
+    }
+    for (const e of entries) {
+      if (!e.isDirectory()) continue;
+      if (!AGENT_TYPE_RE.test(e.name)) continue;
+      const subDir = path.join(root, e.name);
+      const content = await readDirectoryConcat(subDir);
+      if (!content) continue;
+      out.push({
+        agentType: e.name,
+        size: Buffer.byteLength(content, 'utf8'),
+        preview: content.slice(0, 200),
+      });
+    }
+
+    res.json({ memory: out });
+  } catch (err) { next(err); }
+});
+
+// ── GET /:agentType：读单个 agent 全文 ──
+router.get('/:pid/memory/:agentType', async (req, res, next) => {
+  try {
+    if (!guardProject(req, res)) return;
+
+    const agentType = req.params.agentType;
+    if (agentType !== '_root' && !AGENT_TYPE_RE.test(agentType)) {
+      return res.status(400).json({ error: 'invalid agentType' });
+    }
+
+    await ensureProjectWorkspace(req.params.pid);
+    const root = memoryRoot(req.params.pid);
+    const target = agentType === '_root'
+      ? root
+      : path.join(root, agentType);
+
+    let content = '';
+    if (agentType === '_root') {
+      const top = path.join(root, MEMORY_FILE);
+      if (await fileExists(top)) content = await fs.readFile(top, 'utf8');
+    } else {
+      content = await readDirectoryConcat(target);
+    }
+
+    res.json({ content, exists: !!content });
+  } catch (err) { next(err); }
+});
+
+// ── PUT /:agentType：覆盖 memory.md ──
+router.put('/:pid/memory/:agentType', async (req, res, next) => {
+  try {
+    if (!guardProject(req, res)) return;
+
+    const agentType = req.params.agentType;
+    if (agentType !== '_root' && !AGENT_TYPE_RE.test(agentType)) {
+      return res.status(400).json({ error: 'invalid agentType' });
+    }
+
+    const { content } = req.body || {};
+    if (typeof content !== 'string') {
+      return res.status(400).json({ error: 'content must be string' });
+    }
+    if (Buffer.byteLength(content, 'utf8') > MEMORY_MAX_BYTES) {
+      return res.status(400).json({ error: `memory too long (max ${MEMORY_MAX_BYTES} bytes)` });
+    }
+
+    await ensureProjectWorkspace(req.params.pid);
+    const root = memoryRoot(req.params.pid);
+    const targetDir = agentType === '_root' ? root : path.join(root, agentType);
+    await fs.mkdir(targetDir, { recursive: true });
+    await fs.writeFile(path.join(targetDir, MEMORY_FILE), content, 'utf8');
+    res.json({ ok: true });
+  } catch (err) { next(err); }
+});
+
+// ── DELETE /:agentType：删整个 agent 子目录 / 顶层文件 ──
+router.delete('/:pid/memory/:agentType', async (req, res, next) => {
+  try {
+    if (!guardProject(req, res)) return;
+
+    const agentType = req.params.agentType;
+    if (agentType !== '_root' && !AGENT_TYPE_RE.test(agentType)) {
+      return res.status(400).json({ error: 'invalid agentType' });
+    }
+
+    const root = memoryRoot(req.params.pid);
+    if (agentType === '_root') {
+      const top = path.join(root, MEMORY_FILE);
+      try { await fs.unlink(top); } catch { /* OK if not exist */ }
+    } else {
+      const sub = path.join(root, agentType);
+      try { await fs.rm(sub, { recursive: true, force: true }); } catch { /* ignore */ }
+    }
+    res.status(204).end();
+  } catch (err) { next(err); }
+});
+
+export default router;