gamekit777 0.1.2 → 0.1.5

package/studio/src/engine.ts

@@ -2,7 +2,9 @@
  *
  * 状态只有两处：长任务（Jobs）和总线（Bus）。游戏本身的状态在 Game 里按指纹缓存，
  * 预览的状态在浏览器里，node 侧只留一份最近上报的快照给 AI 读。 */
-import { join } from 'node:path';
+import { existsSync, readFileSync, readdirSync, statSync, writeFileSync } from 'node:fs';
+import { join, relative } from 'node:path';
+import { Sha256 } from 'gamekit777/sdk/hash';
 import type { Segment } from 'gamekit777/weights';
 import { Bus } from './bus.ts';
 import { buildMode, groupsSummary, listArtifacts, readArtifactBytes, sampleMode, type Artifact, type BuildModeOptions } from './build.ts';
@@ -10,8 +12,14 @@ import { CaseStore, captureCase, runCases, type CaseRecord, type RunCasesOptions
 import { Game, type Config } from './game.ts';
 import { Jobs, type Job } from './jobs.ts';
 import { probe, type ProbeOptions, type ProbeResult } from './probe.ts';
+import { AssetStore, type AssetSyncResult } from './assets.ts';
+import { hasSession, saveSession, sessionFile } from './session.ts';
 import { runSolve, type Targets } from './solver.ts';
 import { runTask, type TaskName, type TaskResult } from './tasks.ts';
+import { createClient, type GameKitClient } from 'gamekit777/client';
+import { fileCookieStore } from 'gamekit777/client/node';
+import { ASSET_INDEX_PATH, GameKitError } from 'gamekit777/protocol';
+import { uploadTables, type UploadTable } from 'gamekit777/publish/upload-core';
 
 export interface PreviewState {
   connected: boolean;
@@ -26,24 +34,55 @@ export interface PreviewState {
   updatedAt: number;
 }
 
+/** 一次发布的记录。页面的「发布」面板按它显示历史与进度 */
 export interface PublishRequest {
   id: string;
+  jobId: string;
   modes: string[] | null;
   note: string | null;
   from: 'mcp' | 'page';
   createdAt: number;
-  status: 'awaiting-approval' | 'running' | 'published' | 'rejected' | 'failed';
+  status: 'running' | 'published' | 'failed';
   progress: string[];
-  result: unknown;
+  result: PublishResult | null;
   error: string | null;
 }
 
+export interface PublishResult {
+  gameId: string;
+  slug: string;
+  verifiedRtpPpm: number | null;
+  /** 这次新发布的 mode。已生效的被跳过，不在这里 */
+  modes: string[];
+  bundle: string | null;
+  playUrl: string;
+}
+
+export interface PublishPreflight {
+  ok: boolean;
+  issues: string[];
+  warnings: string[];
+  artifacts: { mode: string; computedRtpPpm: number; rows: number }[];
+  session: boolean;
+  remote: {
+    user: string | null;
+    gameId: string | null;
+    game: { id: string; slug: string; status: string; liveModes: string[] } | null;
+    /** 这次会真正发布的 mode（去掉已生效的） */
+    willPublish: string[];
+  } | null;
+}
+
 export class Engine {
   readonly game: Game;
   readonly bus = new Bus();
   readonly jobs: Jobs;
   readonly cases: CaseStore;
   readonly urls: { studio: string; preview: string; backend: string; site: string };
+  /** node 侧记住的站点身份（反代从页面的 /v1/me 抄来的 cookie），MCP 发布用 */
+  readonly sessionPath: string;
+  /** 平台资源库（动画 + 套路）在本机的副本：后台拉、给页面预览、给 AI 查看、复制进游戏 */
+  readonly assets: AssetStore;
   preview: PreviewState = {
     connected: false, config: null, mode: null, bet: null, balance: null,
     status: null, lastError: null, recent: [], consoleErrors: [], updatedAt: 0,
@@ -54,6 +93,11 @@ export class Engine {
   constructor(gameDir: string, urls: Engine['urls']) {
     this.game = new Game(gameDir);
     this.urls = urls;
+    this.sessionPath = sessionFile(urls.backend);
+    this.assets = new AssetStore(urls.backend, gameDir, (r: AssetSyncResult) => {
+      this.bus.emit({ t: 'assets', added: r.added, removed: r.removed, total: r.total });
+      this.bus.log('info', `资源库同步：${r.total} 条${r.added.length ? `，新增/更新 ${r.added.join('、')}` : ''}${r.removed.length ? `，移除 ${r.removed.join('、')}` : ''}`);
+    });
     this.#lastFingerprint = this.game.fingerprint;
     this.jobs = new Jobs((job, msg) => this.bus.emit({ t: 'job', id: job.id, kind: job.kind, status: job.status, msg }));
     this.cases = new CaseStore(gameDir, () => this.bus.emit({ t: 'cases', changed: true }));
@@ -72,7 +116,8 @@ export class Engine {
     gameDir: string; fingerprint: string; packageName: string;
     snapshot: Awaited<ReturnType<Game['snapshot']>>;
     urls: Engine['urls']; previewConnected: boolean; artifacts: Artifact[]; cases: number;
-    caseFile: string;
+    caseFile: string; gameId: string | null; session: boolean;
+    assets: { count: number; syncedAt: number; dir: string };
   }> {
     this.touch();
     return {
@@ -81,9 +126,18 @@ export class Engine {
       previewConnected: this.bus.previewConnected,
       artifacts: listArtifacts(this.game), cases: this.cases.list().length,
       caseFile: this.cases.path,
+      gameId: this.meta().gameId, session: this.sessionPresent(),
+      assets: { count: this.assets.list().length, syncedAt: this.assets.syncedAt, dir: this.assets.dir },
     };
   }
 
+  /** 启动后在后台拉一次资源库，不阻塞任何东西；失败只记日志 */
+  syncAssetsInBackground(): void {
+    void this.assets.sync().then((r) => {
+      if (r === null) this.bus.log('warn', `资源库拉不到（${this.urls.backend}${ASSET_INDEX_PATH}）。离线或平台还没发过库；本地已有的照常可用`);
+    }).catch((e: unknown) => this.bus.log('error', `资源库同步失败：${e instanceof Error ? e.message : String(e)}`));
+  }
+
   /* ── 探测 / 采样 / 求解 / 建表 ── */
 
   probe(o: ProbeOptions = {}): Job<ProbeResult> {
@@ -175,6 +229,30 @@ export class Engine {
     return runCases(this.game, this.cases, o);
   }
 
+  /* ── 游戏包：vite build 的产物。页面拿它连表一起传 ── */
+
+  bundleFiles(): { path: string; bytes: number; sha256: string }[] {
+    const dist = join(this.game.dir, 'dist');
+    if (!existsSync(join(dist, 'index.js'))) return [];
+    const out: { path: string; bytes: number; sha256: string }[] = [];
+    const walk = (d: string): void => {
+      for (const n of readdirSync(d).sort()) {
+        const p = join(d, n);
+        if (statSync(p).isDirectory()) walk(p);
+        else { const b = readFileSync(p); out.push({ path: relative(dist, p).split('\\').join('/'), bytes: b.length, sha256: new Sha256().update(new Uint8Array(b)).hex() }); }
+      }
+    };
+    walk(dist);
+    return out;
+  }
+
+  bundleFile(path: string): Uint8Array | null {
+    const dist = join(this.game.dir, 'dist');
+    const full = join(dist, path);
+    if (!full.startsWith(dist) || !existsSync(full) || statSync(full).isDirectory()) return null;
+    return new Uint8Array(readFileSync(full));
+  }
+
   /* ── 预览 ── */
 
   reportPreview(state: Partial<PreviewState>): void {
@@ -187,24 +265,165 @@ export class Engine {
     return this.bus.command<T>(cmd, timeoutMs);
   }
 
-  /* ── 发布：node 侧只管排队和记录，上传由页面用浏览器身份做 ── */
+  /* ── 发布：node 侧一键跑完，不等人点。身份是反代从页面抄下来的那份站点 cookie ── */
+
+  rememberSession(cookieHeader: string): void { saveSession(this.sessionPath, cookieHeader); }
+  sessionPresent(): boolean { return hasSession(this.sessionPath); }
+
+  /** game.meta.json：游戏在平台上的身份是里面的 gameId（第一次发布后由这里写回），不是名字 */
+  meta(): { path: string; data: Record<string, unknown> | null; gameId: string | null } {
+    const path = join(this.game.dir, 'game.meta.json');
+    try {
+      const data = JSON.parse(readFileSync(path, 'utf8')) as Record<string, unknown>;
+      return { path, data, gameId: typeof data.gameId === 'string' && data.gameId ? data.gameId : null };
+    } catch { return { path, data: null, gameId: null }; }
+  }
+
+  #client(): GameKitClient {
+    return createClient({
+      baseUrl: this.urls.backend, cookies: 'manual', cookieStore: fileCookieStore(this.sessionPath),
+      headers: { origin: new URL(this.urls.backend).origin },
+    });
+  }
+
+  #noSession(): Error {
+    return new Error(`node 侧还没有站点身份。在浏览器打开 ${this.urls.studio}，连接一次身份（没身份会自动跳到站点授权），之后 MCP 就能直接发布`);
+  }
 
-  requestPublish(modes: string[] | null, note: string | null, from: PublishRequest['from']): PublishRequest {
-    const req: PublishRequest = {
-      id: `p${Date.now().toString(36)}`, modes, note, from, createdAt: Date.now(),
-      status: 'awaiting-approval', progress: [], result: null, error: null,
+  async publishPreflight(modes: string[] | null): Promise<PublishPreflight> {
+    this.touch();
+    const snap = await this.game.snapshot();
+    const all = listArtifacts(this.game);
+    const arts = modes ? all.filter((t) => modes.includes(t.mode)) : all;
+    const declared = Math.round(snap.spec.rtp * 1e6);
+    const issues: string[] = [];
+    const warnings: string[] = [];
+    if (arts.length === 0) issues.push('当前指纹下没有任何已建的表——先 build_table');
+    const missing = snap.spec.modes.filter((m) => !arts.some((t) => t.mode === m.name)).map((m) => m.name);
+    if (missing.length && !modes) issues.push(`这些 mode 还没建表：${missing.join('、')}`);
+    if (modes) for (const m of modes) if (!all.some((t) => t.mode === m)) issues.push(`mode ${m} 没有已建的表`);
+    const lowest = arts.reduce<number | null>((m, t) => (m === null || t.computedRtpPpm < m ? t.computedRtpPpm : m), null);
+    if (lowest !== null && lowest + 100 < declared) issues.push(`游戏声明 RTP ${declared} ppm，但最低的表只有 ${lowest} ppm——大厅里的声明不能高于任何一个 mode 实际能给的，发布会被拒`);
+
+    const meta = this.meta();
+    let remote: PublishPreflight['remote'] = null;
+    const session = this.sessionPresent();
+    if (!session) {
+      issues.push(this.#noSession().message);
+    } else {
+      const api = this.#client();
+      try {
+        const me = await api.session.me();
+        let game: NonNullable<PublishPreflight['remote']>['game'] = null;
+        let willPublish = arts.map((t) => t.mode);
+        if (meta.gameId) {
+          const g = await api.games.get(meta.gameId).catch((e: unknown) => {
+            issues.push(e instanceof GameKitError && e.code === 'NOT_FOUND'
+              ? `game.meta.json 的 gameId ${meta.gameId} 在平台上不存在——删掉这个字段会新建`
+              : `取游戏 ${meta.gameId} 失败：${e instanceof Error ? e.message : String(e)}`);
+            return null;
+          });
+          if (g) {
+            if (g.ownerId !== me.user.id) issues.push(`游戏 ${g.id}（${g.slug}）归另一个账号`);
+            if (g.status === 'published' && g.slug !== snap.spec.slug) issues.push(`已发布为 "${g.slug}"，slug 不能改成 "${snap.spec.slug}"`);
+            const live = g.modes.map((m) => m.mode);
+            willPublish = willPublish.filter((m) => !live.includes(m));
+            if (willPublish.length === 0) warnings.push('所有选中的 mode 都已生效：这次只会更新客户端包');
+            game = { id: g.id, slug: g.slug, status: g.status, liveModes: live };
+          }
+        } else {
+          const mine = await api.games.list({ status: 'all', owner: 'me', limit: 50 });
+          const dup = mine.items.find((g) => g.slug === snap.spec.slug);
+          if (dup) issues.push(`你已经有一个 slug 为 "${snap.spec.slug}" 的游戏（${dup.id}）。同一个项目就把它写进 game.meta.json 的 gameId；另一个项目就改 id`);
+        }
+        const taken = (await api.games.list({ status: 'published', limit: 50 })).items.find((g) => g.slug === snap.spec.slug && g.id !== meta.gameId);
+        if (taken) issues.push(`slug "${snap.spec.slug}" 已有别的已发布游戏在用（${taken.id}），发布会被拒。改 game.meta.json 的 id`);
+        remote = { user: me.user.id, gameId: meta.gameId, game, willPublish };
+      } catch (e) {
+        issues.push(`记住的身份已失效（${e instanceof Error ? e.message : String(e)}）。在 studio 页面重新连接一次`);
+      }
+    }
+    return {
+      ok: issues.length === 0, issues, warnings, session, remote,
+      artifacts: arts.map((t) => ({ mode: t.mode, computedRtpPpm: t.computedRtpPpm, rows: t.rowCount })),
     };
-    this.#publish.set(req.id, req);
-    this.bus.emit({ t: 'publish', request: req });
-    return req;
   }
 
-  updatePublish(id: string, patch: Partial<PublishRequest>): PublishRequest | null {
-    const req = this.#publish.get(id);
-    if (!req) return null;
-    Object.assign(req, patch);
-    this.bus.emit({ t: 'publish', request: req });
-    return req;
+  publish(modes: string[] | null, o: { note?: string | null; from: PublishRequest['from'] }): Job<PublishResult> {
+    this.touch();
+    const rec: PublishRequest = {
+      id: `p${Date.now().toString(36)}`, jobId: '', modes, note: o.note ?? null, from: o.from, createdAt: Date.now(),
+      status: 'running', progress: [], result: null, error: null,
+    };
+    this.#publish.set(rec.id, rec);
+    const emit = (): void => this.bus.emit({ t: 'publish', request: rec });
+    const job = this.jobs.start('publish', async (say0) => {
+      const say = (m: string): void => { say0(m); rec.progress.push(m); emit(); };
+      try {
+        const r = await this.#runPublish(modes, say);
+        rec.status = 'published'; rec.result = r; emit();
+        return r;
+      } catch (e) {
+        rec.status = 'failed'; rec.error = e instanceof Error ? e.message : String(e); emit();
+        throw e;
+      }
+    });
+    rec.jobId = job.id;
+    emit();
+    return job;
+  }
+
+  async #runPublish(modes: string[] | null, say: (m: string) => void): Promise<PublishResult> {
+    if (!this.sessionPresent()) throw this.#noSession();
+    const api = this.#client();
+    const me = await api.session.me().catch(() => {
+      throw new Error('记住的身份已失效（会话过期或在站点上退出了）。在 studio 页面重新连接一次');
+    });
+    say(`身份 ${me.user.isAnonymous ? '游客' : me.user.name ?? '玩家'} ${me.user.id.slice(0, 8)}…`);
+
+    const snap = await this.game.snapshot();
+    const all = listArtifacts(this.game);
+    const arts = modes ? all.filter((t) => modes.includes(t.mode)) : all;
+    if (arts.length === 0) throw new Error('当前指纹下没有已建的表——先 build_table');
+    const missing = (modes ?? []).filter((m) => !arts.some((t) => t.mode === m));
+    if (missing.length) throw new Error(`这些 mode 没有已建的表：${missing.join('、')}`);
+
+    /* 包：vite build 的产物。表是数学，包是演出，站点两样都要 */
+    say('构建游戏包（bun run build）…');
+    const built = await runTask(this.game.dir, 'build');
+    if (!built.ok) throw new Error(`vite build 失败：${built.issues.join('；') || built.output.split('\n').slice(-15).join('\n')}`);
+    const files = this.bundleFiles();
+    if (!files.length) throw new Error('dist/ 里没有 index.js——构建没产出游戏包');
+    const bundle = files.map((f) => ({ path: f.path, bytes: this.bundleFile(f.path)! }));
+    say(`游戏包 ${bundle.length} 个文件，${(bundle.reduce((n, f) => n + f.bytes.length, 0) / 1024).toFixed(0)} KB`);
+
+    /* 表：主进程没有游戏代码，赔率行从 worker 拿好带进去 */
+    const tables: UploadTable[] = [];
+    for (const a of arts) {
+      const mode = snap.spec.modes.find((m) => m.name === a.mode);
+      if (!mode) throw new Error(`产物里有 mode ${a.mode}，但当前清单里没有——重新 build_table`);
+      const { table, books } = readArtifactBytes(a);
+      tables.push({
+        mode: a.mode, bytes: table, contentHash: a.contentHash, rowCount: a.rowCount, betCostCenti: a.betCostCenti,
+        books, verdict: { computedRtpPpm: a.computedRtpPpm }, paytable: await this.game.paytable(mode.config),
+      });
+    }
+
+    const meta = this.meta();
+    const r = await uploadTables(snap.spec, tables, {
+      client: api, gameId: meta.gameId, bundle, publishModes: modes ?? undefined, onProgress: say,
+    });
+    if (meta.gameId !== r.game.id) {
+      writeFileSync(meta.path, `${JSON.stringify({ ...(meta.data ?? {}), gameId: r.game.id }, null, 2)}\n`);
+      say(`gameId ${r.game.id} 已写进 game.meta.json——之后发布都认它，改名只改 id/title`);
+    }
+    const out: PublishResult = {
+      gameId: r.game.id, slug: r.game.slug, verifiedRtpPpm: r.game.verifiedRtpPpm,
+      modes: r.tables.map((t) => t.mode), bundle: r.game.bundle?.hash ?? null,
+      playUrl: `${this.urls.site}/#/play/${r.game.slug}`,
+    };
+    say(`✅ 已发布 ${out.slug}：${out.playUrl}`);
+    return out;
   }
 
   publishRequests(): PublishRequest[] { return [...this.#publish.values()].sort((a, b) => b.createdAt - a.createdAt); }

package/studio/src/game-vite.ts

@@ -17,6 +17,8 @@ export interface GameServerOptions {
   /** 平台后端，/v1 反代到它。页面同源登录之后，发布用的就是浏览器里的这份身份 */
   backendUrl: string;
   engine: Engine;
+  /** 页面的身份连上时（GET /v1/me 200）收到它带的 cookie 头。node 侧记下来，MCP 发布用 */
+  onSession?: (cookieHeader: string) => void;
   /** stdio 模式下 stdout 是 MCP 协议，vite 的一切输出都得走 stderr */
   quiet?: boolean;
 }
@@ -46,6 +48,8 @@ function allowList(o: GameServerOptions): string[] {
     o.studioRoot, searchForWorkspaceRoot(o.studioRoot),
   ]);
   try { list.add(realpathSync(join(o.studioRoot, 'node_modules', 'gamekit777'))); } catch { /* 没装就算了 */ }
+  // 资源库的本机副本：页面用 /@fs 让 vite 现场编译预览
+  list.add(o.engine.assets.dir);
   return [...list];
 }
 
@@ -62,7 +66,7 @@ function stderrLogger(): Logger {
  *             创作者机器上的 127.0.0.1:随机端口不可能预先写进 TRUSTED_ORIGINS
  * 这么做不削弱 CSRF 防护：能打到这个反代的只有同源的 studio 页面本身。
  */
-function proxyRule(backendUrl: string): ProxyOptions {
+function proxyRule(backendUrl: string, onSession?: (cookieHeader: string) => void): ProxyOptions {
   const origin = new URL(backendUrl).origin;
   return {
     target: backendUrl,
@@ -72,6 +76,11 @@ function proxyRule(backendUrl: string): ProxyOptions {
         if (req.getHeader('origin')) req.setHeader('origin', origin);
         req.removeHeader('referer');
       });
+      /* 页面的身份连上了（GET /v1/me 200），把它带的 cookie 抄给 node 侧——MCP 发布用的就是这份 */
+      proxy.on('proxyRes', (res, req) => {
+        const cookie = req.headers.cookie;
+        if (onSession && cookie && res.statusCode === 200 && (req.url ?? '').split('?')[0] === '/v1/me') onSession(cookie);
+      });
     },
   };
 }
@@ -118,7 +127,7 @@ export async function startGameServer(o: GameServerOptions): Promise<ViteDevServ
       fs: { allow: allowList(o) },
       /* 同源代理到平台后端：cookie 才带得上。发布时用的就是这份身份 */
       proxy: {
-        '/v1': proxyRule(o.backendUrl),
+        '/v1': proxyRule(o.backendUrl, o.onSession),
         '/api': proxyRule(o.backendUrl),
       },
     },

package/studio/src/mcp.ts

@@ -99,7 +99,10 @@ const INSTRUCTIONS = [
   '没有这个文件就先调 game_info，再读 game.ts 和 src/rules/。',
   '',
   '工作流：改 src/rules/ 或 game.ts → run_task check/verify/test → probe_table（能不能打表、modes 写哪些键、book 怎么选）',
-  '→ preview_play 在预览里演几局 → case_add 存值得盯的局面 → build_table 建表 → publish_dry_run → publish（作者在页面确认）。',
+  '→ preview_play 在预览里演几局 → case_add 存值得盯的局面 → build_table 建表 → publish_dry_run → publish（一键跑完：vite build + 传包 + 传表 + 发布，不用人确认）。',
+  '演出先查资源库：asset_list → asset_show <name>（源码 + NOTES：为什么这么做、坑、退化）→ asset_use <name> 复制进游戏再改。库是参考实现，复制进来就是游戏自己的代码。',
+  '资源库两种条目：animation 是一个自足组件（复制到 src/animations/，{#key 局号} 重挂重播）；pattern 是一套机制 + 接线清单（复制到 src/patterns/<name>/，NOTES 里的接线表要你照着穿进游戏的时间轴，台词/文案要按这个游戏的角色重写，不要照抄范例）。',
+  '游戏在平台上的身份是 game.meta.json 的 gameId（第一次发布后自动写回），不是名字；改名只改 id/title。发布用的身份是作者在 studio 页面连过一次的站点身份，没有就先让作者打开页面。',
   '',
   '铁律：round() 是同步纯函数、只用注入的 rng；payout 是整数分且是注额的精确线性函数；restore 返回的 payout 必须等于 (bet/100)×payoutCenti，对不上就抛。',
   '不写 normalize/validate/modeOf，不加 meta 或版本号；已发布 mode 的解码逻辑不能改，要改就换 slug。',
@@ -206,39 +209,76 @@ export function createMcpServer(engine: Engine): McpServer {
     ].join('\n')));
 
   s.registerTool('publish_dry_run', {
-    description: '发布前体检（本地部分）：当前指纹下有哪些表、最低实算 RTP 是否低于声明。登录态和 slug 占用要在 studio 页面上看。',
+    description: '发布前体检：本地有哪些表、RTP 是否虚标；连平台查身份、gameId 绑定、slug 占用、哪些 mode 已生效会被跳过。不上传任何东西。',
     inputSchema: { modes: modesArg },
   }, async (a) => {
-    const i = await engine.info();
-    const arts = i.artifacts.filter((t) => !a.modes || a.modes.includes(t.mode));
-    const spec = i.snapshot.spec;
-    const declared = Math.round(spec.rtp * 1e6);
-    const issues: string[] = [];
-    if (arts.length === 0) issues.push('当前指纹下没有任何已建的表——先 build_table');
-    const missing = spec.modes.filter((m) => !arts.some((t) => t.mode === m.name)).map((m) => m.name);
-    if (missing.length && !a.modes) issues.push(`这些 mode 还没建表：${missing.join('、')}`);
-    const lowest = arts.reduce<number | null>((m, t) => (m === null || t.computedRtpPpm < m ? t.computedRtpPpm : m), null);
-    if (lowest !== null && lowest + 100 < declared) issues.push(`游戏声明 ${pct(declared)}，但最低的表只有 ${pct(lowest)}——大厅里的声明不能高于任何一个 mode 实际能给的，发布会被拒`);
-    const ok = issues.length === 0;
-    return out([`## ${ok ? '✅ 本地体检通过' : '❌ 本地体检有问题'}`, '', ...(ok ? [`${arts.length} 张表就绪：${arts.map((t) => t.mode).join('、')}`] : issues.map((x) => `- ${x}`)),
-      '', '登录态、slug 是否被占、哪些 mode 已经锁死——这些要连平台才知道，在 studio 页面的「发布」面板里看。'].join('\n'),
-      { ok, issues, artifacts: arts.map((t) => ({ mode: t.mode, computedRtpPpm: t.computedRtpPpm, rows: t.rowCount })) });
+    const r = await engine.publishPreflight(a.modes ?? null);
+    const lines = [`## ${r.ok ? '✅ 体检通过' : '❌ 体检有问题'}`, ''];
+    if (r.artifacts.length) lines.push(`本地 ${r.artifacts.length} 张表：${r.artifacts.map((t) => `${t.mode}（${pct(t.computedRtpPpm)}，${t.rows.toLocaleString()} 行）`).join('、')}`);
+    if (r.remote) {
+      lines.push(`身份 ${r.remote.user!.slice(0, 8)}…`);
+      lines.push(r.remote.game
+        ? `游戏 ${r.remote.game.id}（${r.remote.game.slug}，${r.remote.game.status}），已生效 mode：${r.remote.game.liveModes.join('、') || '无'}`
+        : 'game.meta.json 里没有 gameId：这次会新建游戏并写回');
+      lines.push(`这次会发布：${r.remote.willPublish.join('、') || '（无新表）'}`);
+    }
+    if (r.issues.length) lines.push('', ...r.issues.map((x) => `- ❌ ${x}`));
+    if (r.warnings.length) lines.push('', ...r.warnings.map((x) => `- ⚠️ ${x}`));
+    return out(lines.join('\n'), r);
   });
 
   s.registerTool('publish', {
-    description: '请求发布。上传要用作者在 studio 页面上登录的身份，所以这里只是把请求排进页面的待审批队列，作者点确认后才真正上传。发布不可逆。',
-    inputSchema: { modes: modesArg, note: z.string().optional().describe('给作者看的说明') },
+    description: '一键发布：vite build → 传游戏包 → 传表 → 发布，不需要作者确认。身份是作者在 studio 页面连过的站点身份（node 侧记住了）。游戏按 game.meta.json 的 gameId 绑定，第一次发布会新建并写回。发布不可逆：已生效的 mode 会被跳过，要改就换 slug。',
+    inputSchema: { modes: modesArg, note: z.string().optional().describe('记在发布记录里的说明') },
+  }, async (a) => awaitJob(engine, engine.publish(a.modes ?? null, { note: a.note ?? null, from: 'mcp' }), (r) =>
+    [`## ✅ 已发布 ${r.slug}`, '', `- gameId ${r.gameId}`, `- 新发布的 mode：${r.modes.join('、') || '（无新表，只换了包）'}`,
+      `- 实测 RTP ${r.verifiedRtpPpm === null ? '-' : pct(r.verifiedRtpPpm)}`, `- 游戏包 ${r.bundle ? `${r.bundle.slice(0, 12)}…` : '-'}`, `- 试玩：${r.playUrl}`].join('\n')));
+
+  s.registerTool('asset_list', {
+    description: '平台资源库：历史演出经验的归档。animation = 自足的小组件（赢面弹窗、分档大奖、揭示翻动、上飘文字…）；pattern = 一套机制 + 接线清单（荷官说话…），复杂度高，要照 NOTES 穿进游戏的时间轴。做演出前先看这里。',
+    inputSchema: {
+      kind: z.enum(['animation', 'pattern']).optional().describe('只列这一种'),
+      tag: z.string().optional().describe('按 tag 过滤'),
+      sync: z.boolean().optional().describe('先同平台同步一次再列（默认后台已同步过就不等）'),
+    },
   }, async (a) => {
-    const req = engine.requestPublish(a.modes ?? null, a.note ?? null, 'mcp');
-    const t0 = Date.now();
-    while (Date.now() - t0 < 120_000) {
-      const cur = engine.publishRequests().find((r) => r.id === req.id)!;
-      if (cur.status !== 'awaiting-approval' && cur.status !== 'running') {
-        return out(`## 发布请求 ${cur.id}：${cur.status}\n\n${cur.progress.map((p) => `- ${p}`).join('\n')}${cur.error ? `\n\n错误：${cur.error}` : ''}`, cur);
-      }
-      await new Promise((r) => setTimeout(r, 1000));
-    }
-    return out(`## 发布请求 ${req.id} 等待作者确认\n\n请作者打开 ${engine.urls.studio} 的「发布」面板点确认。之后用 job_status 不行，用 publish_dry_run 或 game_info 看状态。`, req);
+    if (a.sync || engine.assets.list().length === 0) await engine.assets.sync().catch(() => null);
+    const all = engine.assets.list(a.kind).filter((e) => !a.tag || e.tags.includes(a.tag));
+    if (!all.length) return out(`资源库为空${a.kind ? `（${a.kind}）` : ''}${a.tag ? `（tag ${a.tag} 下没有）` : `。平台 ${engine.urls.backend}/a/index.json 拉不到或还没发过库`}`, { entries: [] });
+    const row = (e: typeof all[number]): string => `| ${e.kind === 'pattern' ? '⚙ pattern' : '✦ animation'} | \`${e.name}\` | ${e.title} | ${e.summary} | ${e.tags.join(' ')} |`;
+    return out([`## 资源库 ${all.length} 条`, '', '| 类型 | name | 标题 | 一句话 | tags |', '|---|---|---|---|---|', ...all.map(row),
+      '', `预览：${engine.urls.studio}#assets  ·  详情 asset_show <name>  ·  复制进游戏 asset_use <name>`].join('\n'),
+      { entries: all.map((e) => ({ kind: e.kind, name: e.name, title: e.title, summary: e.summary, tags: e.tags, props: e.props, hash: e.hash })) });
+  });
+
+  s.registerTool('asset_show', {
+    description: '看一条：NOTES.md（为什么这么做、踩过的坑、turbo/reducedMotion 下怎么退化；套路还有接线清单）+ 全部文件源码 + 旋钮说明。',
+    inputSchema: { name: z.string() },
+  }, async (a) => {
+    let r;
+    try { r = engine.assets.show(a.name); } catch (e) { return fail(e instanceof Error ? e.message : String(e)); }
+    const e = r.entry;
+    const props = Object.entries(e.props).map(([k, p]) => `- \`${k}\`：${p.kind}${p.options ? `（${p.options.join(' / ')}）` : ''}，默认 ${JSON.stringify(p.default)}${p.label ? ` — ${p.label}` : ''}`);
+    const lang = (p: string): string => (p.endsWith('.svelte') ? 'svelte' : p.endsWith('.ts') ? 'ts' : p.endsWith('.json') ? 'json' : '');
+    const files = r.files.flatMap((f) => [`### ${f.path}${f.copied ? '' : e.kind === 'pattern' && f.path === e.demo ? '（Demo，只在预览里跑，不复制）' : '（范例，不复制）'}`, `\`\`\`${lang(f.path)}`, f.text, '```', '']);
+    return out([`## ${e.title}（\`${e.name}\`，${e.kind}）`, '', e.summary, '', `复制进游戏后落在 \`${r.target}\``, '', '### 旋钮', ...props, '', '### NOTES', r.notes, '', ...files,
+      `预览：${engine.urls.studio}#assets:${e.name}  ·  复制进游戏：asset_use ${e.name}`].join('\n'),
+      { entry: e, notes: r.notes, files: r.files, target: r.target });
+  });
+
+  s.registerTool('asset_use', {
+    description: '复制进游戏（文件头注来源哈希）：动画 → src/animations/<Component>.svelte；套路 → src/patterns/<name>/ 的机制文件（Demo、范例不进）。是复制不是依赖：之后随意改，库更新不会动它。目标已有且内容不同时拒绝，force 才覆盖。',
+    inputSchema: { name: z.string(), force: z.boolean().optional() },
+  }, async (a) => {
+    try {
+      const r = engine.assets.use(a.name, { force: a.force });
+      const e = engine.assets.get(a.name)!;
+      if (!r.written) return out(`未写入：${r.reason}（${r.path}）`, r);
+      const next = e.kind === 'animation'
+        ? `在组件里 \`import X from './animations/${e.component}'\`，用 {#key 局号} 重挂来重播。`
+        : `接下来按 asset_show ${e.name} 里 NOTES 的接线清单，把调用穿进游戏的时间轴；台词/文案按这个游戏的角色重写。复制了：${r.files.join('、')}`;
+      return out(`## ✅ 已复制到 ${r.path}\n\n${next}改它就像改自己的代码。`, r);
+    } catch (e) { return fail(e instanceof Error ? e.message : String(e)); }
   });
 
   s.registerTool('preview_state', {

package/studio/src/session.ts

@@ -0,0 +1,37 @@
+/* node 侧记住的站点身份，让 MCP 的 publish 不用等人在页面上点。
+ *
+ * 身份本来只在浏览器里：页面经 /v1 反代请求平台，cookie 由浏览器带。反代看得见每个请求的 cookie 头，
+ * 于是在 GET /v1/me 返回 200 时把那份 cookie 抄一份落盘——页面一开、身份一连，node 侧就有了同一个人。
+ * 文件按平台 host 分，放用户目录而不是游戏目录：身份是这个人的，不是这个项目的，也不该进版本控制。
+ * 格式和 client/node 的 fileCookieStore 一样（名 → 值），发布时直接当 cookieStore 用。 */
+import { chmodSync, existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { join } from 'node:path';
+
+export function sessionFile(backendUrl: string): string {
+  const host = new URL(backendUrl).host.replace(/[^a-z0-9.-]/gi, '_');
+  return process.env.GAMEKIT_STUDIO_SESSION_FILE ?? join(homedir(), '.gamekit', `session-${host}.json`);
+}
+
+export function parseCookieHeader(header: string): Record<string, string> {
+  const out: Record<string, string> = {};
+  for (const part of header.split(';')) {
+    const i = part.indexOf('=');
+    if (i <= 0) continue;
+    out[part.slice(0, i).trim()] = part.slice(i + 1).trim();
+  }
+  return out;
+}
+
+export function saveSession(path: string, cookieHeader: string): void {
+  const cookies = parseCookieHeader(cookieHeader);
+  if (Object.keys(cookies).length === 0) return;
+  mkdirSync(join(path, '..'), { recursive: true });
+  writeFileSync(path, `${JSON.stringify(cookies, null, 2)}\n`);
+  try { chmodSync(path, 0o600); } catch { /* Windows 没有权限位 */ }
+}
+
+export function hasSession(path: string): boolean {
+  try { return existsSync(path) && Object.keys(JSON.parse(readFileSync(path, 'utf8')) as object).length > 0; }
+  catch { return false; }
+}

package/studio/src/studio-plugin.ts

@@ -5,7 +5,9 @@
  *
  * 不往游戏目录写任何文件：两个 html 从内存吐，入口用 /@fs 指回 studio 包。
  * 不依赖游戏目录里有 index.html：脚手架出来的项目没有它，`bun run dev` 就是起 studio。 */
+import { readFileSync } from 'node:fs';
 import type { Plugin } from 'vite';
+import { compile } from 'svelte/compiler';
 import { API_PREFIX, createApi } from './api.ts';
 import type { Engine } from './engine.ts';
 
@@ -53,6 +55,20 @@ export function studioPlugin(o: StudioPluginOptions): Plugin {
       return null;
     },
 
+    /* 资源库组件的 <style> 兜底。vite-plugin-svelte 把组件 CSS 存在模块信息里，样式虚拟模块
+       （…svelte?svelte&type=style&lang.css）从那里取；组件还没编译过就先来要样式（重连、刷新、缓存未命中）时
+       它拿不到，退回读文件——整份 .svelte 源码被当 CSS 交给下游，namespace-css 直接炸页。
+       库组件在游戏根之外、内容自足，这里自己编一遍只取 CSS：scoped class 的哈希只由样式文本决定，和组件那次编译一致 */
+    load(id) {
+      const m = /^([^?]+\.svelte)\?(?:.*&)?svelte(?:&.*)?&type=style(?:&|$)/.exec(id) ?? /^([^?]+\.svelte)\?(?:.*&)?type=style(?:&|$)/.exec(id);
+      const file = m?.[1];
+      if (!file || !file.startsWith(o.engine.assets.dir)) return null;
+      try {
+        const src = readFileSync(file, 'utf8');
+        return { code: compile(src, { filename: file, generate: 'client', css: 'external' }).css?.code ?? '' };
+      } catch { return null; }
+    },
+
     configureServer(server) {
       server.middlewares.use(api);
       server.middlewares.use((req, res, next) => {

package/studio/src/tasks.ts

@@ -31,7 +31,10 @@ export function runTask(gameDir: string, task: TaskName, o: RunTaskOptions = {})
   const t0 = Date.now();
 
   return new Promise((resolve) => {
-    const child = spawn('bun', ['run', task], { cwd: gameDir, stdio: ['ignore', 'pipe', 'pipe'], env: { ...process.env, FORCE_COLOR: '0', NO_COLOR: '1' } });
+    /* 不把 NODE_ENV 传下去：studio 自己跑着 vite dev server，它会把 NODE_ENV 设成 development，
+       子进程的 vite build 继承后就产出开发版包（不压缩、带开发期检查），发到平台上的就是那份 */
+    const { NODE_ENV: _dev, ...env } = process.env;
+    const child = spawn('bun', ['run', task], { cwd: gameDir, stdio: ['ignore', 'pipe', 'pipe'], env: { ...env, FORCE_COLOR: '0', NO_COLOR: '1' } });
     let out = '';
     const push = (b: Buffer): void => { if (out.length < maxOutput * 2) out += b.toString(); };
     child.stdout.on('data', push);