@homie-rocks/studio 0.38.0 → 0.40.0

package/worker/mcp-tools.mjs

@@ -0,0 +1,105 @@
+import { withToolIdentity } from './tool-identity.mjs';
+import { officeRoutes } from './office.mjs';
+import { appRecordsRoute } from './app-records.mjs';
+import { players } from './players.mjs';
+import { readStats, rangeOf } from './stats.mjs';
+import { publicCatalogue, settingsOf, launchOf } from './office.mjs';
+export const object = (properties = {}, required = []) => ({type:'object',properties,required,additionalProperties:false});
+const str = {type:'string',maxLength:128};
+export async function allowed(audience, caller, env) {
+  if (audience === 'public') return true;
+  if (!caller.id) return false;
+  if (audience === 'signed-in') return true;
+  if (audience === 'owner') return caller.owner === true;
+  if (audience && typeof audience === 'object' && audience.app && audience.role) {
+    return caller.owner || Boolean(await env.DB.prepare('SELECT player FROM app_roles WHERE app=?1 AND role=?2 AND player=?3').bind(audience.app,audience.role,caller.id).first());
+  }
+  return false;
+}
+export async function currentCaller(env, props) {
+  if (!props?.connection) return {id:null,owner:false,client:null};
+  const row = await env.DB.prepare('SELECT * FROM mcp_connections WHERE id=?1 AND revoked=0').bind(props.connection).first();
+  if (!row) throw new Error('connection revoked');
+  if (row.person.startsWith('office-')) {
+    const key = await env.DB.prepare("SELECT kind FROM stats_keys WHERE hash=?1 AND kind='session' AND expires_at>?2").bind(row.person.slice(7),Date.now()).first();
+    if (!key) throw new Error('owner session expired');
+    return {id:row.person,owner:true,client:row.client,connection:row.id};
+  }
+  const p = await env.DB.prepare('SELECT id,name,owner,guest FROM players WHERE id=?1').bind(row.person).first();
+  if (!p || p.guest) throw new Error('account unavailable');
+  const grants=(await env.DB.prepare('SELECT app,role FROM app_roles WHERE player=?1').bind(p.id).all()).results;
+  const roles=Object.create(null);for(const grant of grants??[])(roles[grant.app]??=[]).push(grant.role);
+  return {id:p.id,name:p.name,owner:p.owner===1,roles,client:row.client,connection:row.id};
+}
+export function services(env, cat, origin, caller, namespace, definition = {}) {
+  const records = async ({app,role,collection,id,operation='read',data,version}) => {
+    const meta = cat.games.find(g=>g.id===app && g.kind==='app');
+    if (!meta || !/^[a-z][a-z0-9-]{0,39}$/.test(collection) || (id!==undefined && !/^[A-Za-z0-9_-]{1,64}$/.test(id))) throw new Error('unknown app, collection or record');
+    if (!caller.owner && launchOf(meta,await settingsOf(env,{fresh:true}),env)!=='public') throw new Error('app is private');
+    const url = new URL(`/${app}/api/app/records/${collection}${id ? '/'+id : ''}`,origin);if(role)url.searchParams.set('role',role);
+    const method = {read:'GET',create:'POST',update:'PUT'}[operation];if (!method) throw new Error('unsupported operation');
+    const request = withToolIdentity(new Request(url,{method,headers:{origin,'content-type':'application/json'},...(method==='GET'?{}:{body:JSON.stringify({data,version})})}),caller);
+    const response = await appRecordsRoute(request,env,meta,url,url.pathname.slice(app.length+2));
+    const result = await response.json(); if(!response.ok) throw new Error(result.error);return result;
+  };
+  const office = async (path, body, query={}) => {
+    if (!caller.owner || !/^\/_studio\/api\//.test(path) || path.includes('..') || path.includes('?')) throw new Error('owner only');
+    const url = new URL(path,origin);
+    for(const [key,value] of Object.entries(query))url.searchParams.set(key,String(value));
+    const request = withToolIdentity(new Request(url,{method:body?'POST':'GET',headers:{origin,'content-type':'application/json'},...(body?{body:JSON.stringify(body)}:{})}),caller);
+    const response = await officeRoutes(request,env,url,{catalogueOf:async()=>cat});
+    const result = response.headers.get('content-type')?.includes('application/json')?await response.json():{text:await response.text()}; if(!response.ok && response.status!==202) throw new Error(result.error);return result;
+  };
+  const key = v=>{if(typeof v!=='string'||v.length>128||!v.length)throw new Error('invalid key');return v;};
+  return Object.freeze({
+    caller:Object.freeze({...caller,roles:Object.freeze(Object.fromEntries(Object.entries(caller.roles??{}).map(([app,roles])=>[app,Object.freeze([...roles])])) )}), records, office,
+    rooms:Object.freeze({send:args=>import('./tool-events.mjs').then(m=>m.sendToolEvent(env,caller,definition,args))}),
+    shop:()=>office('/_studio/api/shop'),
+    database:Object.freeze({
+      async get(k){const r=await env.DB.prepare('SELECT value FROM tool_data WHERE namespace=?1 AND key=?2').bind(namespace,key(k)).first();return r?JSON.parse(r.value):null;},
+      async put(k,value){const text=JSON.stringify(value);if(text.length>16384)throw new Error('value too large');await env.DB.prepare('INSERT INTO tool_data(namespace,key,value) VALUES(?1,?2,?3) ON CONFLICT(namespace,key) DO UPDATE SET value=excluded.value').bind(namespace,key(k),text).run();},
+    }),
+    fetch:globalThis.fetch.bind(globalThis),
+    // A named secret may authenticate an HTTPS request; its value is never returned.
+    async fetchWithSecret(name,url,init={}) {
+      const rule=cat.studio?.mcp?.secrets?.[name]; const target=new URL(url);
+      if(!rule || target.protocol!=='https:' || target.origin!==rule.origin || (!caller.owner&&!rule.tools?.includes(definition.name))) throw new Error('secret capability refused');
+      const secret=env[name];if(typeof secret!=='string')throw new Error('secret unavailable');
+      const headers=new Headers(init.headers);headers.set(rule.header??'authorization',`${rule.prefix??'Bearer '}${secret}`);
+      const res=await fetch(target,{...init,headers,redirect:'error'});
+      // Do not return a remote echo of credentials.
+      const text=await res.text();if(text.includes(secret))throw new Error('response contained a credential');
+      return new Response([204,205,304].includes(res.status)?null:text,{status:res.status,headers:{'content-type':res.headers.get('content-type')??'text/plain'}});
+    },
+    async ai(model,input){if((!caller.owner&&!cat.studio?.mcp?.aiTools?.includes(definition.name))||!env.AI)throw new Error('Workers AI unavailable');return env.AI.run(model,input);},
+  });
+}
+export function builtins(env,cat,origin) {
+  const tool=(name,description,audience,inputSchema,handler)=>({name,description,audience,inputSchema,handler});
+  const tools=[
+    tool('studio_info','The public studio, apps, games and posts.','public',object(),async()=>{const pub=publicCatalogue(cat,await settingsOf(env),env);return {studio:pub.studio?.name,games:pub.games.map(g=>({id:g.id,name:g.name,kind:g.kind??'game'})),posts:pub.posts};}),
+    tool('studio_office','Live rooms and the players as shown in the office.','owner',object(),(_,ctx)=>ctx.office('/_studio/api/office')),
+    tool('studio_shop','Orders, refunds and the shop state.','owner',object(),(_,ctx)=>ctx.shop()),
+    tool('studio_players','The studio accounts as shown in the office.','owner',object({query:str}),({query})=>players.list(env,{q:query})),
+    tool('studio_stats','Studio visits and plays.','owner',object(),()=>readStats(env,cat,{range:rangeOf(new URLSearchParams())})),
+    tool('studio_posts','Published posts.','public',object(),()=>({posts:cat.posts??[]})),
+    tool('studio_parts','Parts this studio has chosen to share.','public',object(),async()=>{const r=await env.ASSETS.fetch(new Request(origin+'/parts/index.json'));return r.ok?r.json():{parts:[]};}),
+    tool('app_schema','Discover an app’s record fields, valid values and the roles available to this caller before reading or changing records.','public',object({app:str},['app']),async({app},ctx)=>{
+      const meta=cat.games.find(g=>g.id===app&&g.kind==='app');
+      if(!meta||(!ctx.caller.owner&&launchOf(meta,await settingsOf(env,{fresh:true}),env)!=='public'))throw new Error('app unavailable');
+      const roles={};for(const [role,definition] of Object.entries(meta.roles??{}))if(!definition.signIn||await allowed({app,role},ctx.caller,env))roles[role]={can:definition.can,signIn:Boolean(definition.signIn)};
+      const collections=new Set(Object.values(roles).flatMap(r=>r.can.map(cap=>cap.split(':')[1])));
+      return {app,roles,collections:Object.fromEntries(Object.entries(meta.records?.collections??{}).filter(([name])=>collections.has(name)))};
+    }),
+    tool('app_records','List, read, create or update app records with the app role and record version.','public',object({app:str,role:str,collection:str,id:str,operation:{enum:['read','create','update']},data:{type:'object'},version:{type:'integer',minimum:1}},['app','collection']), (args,ctx)=>ctx.records(args)),
+  ];
+  for(const [name,path,description] of [
+    ['room_announce','announce','Announce to a room.'],['room_kick','kick','Ask the owner to remove a player.'],['room_mute','mute','Ask the owner to mute a player.'],['room_close','close','Ask the owner to close a room.'],['studio_game','game','Ask the owner to change game access or room size.'],['shop_refund','shop/refund','Ask the owner to refund an order.'],
+  ]) tools.push(tool(name,description,'owner',object({action:{type:'object'}},['action']),({action},ctx)=>ctx.office('/_studio/api/'+path,action)));
+  const reads={rooms:'office',servers:'servers',members:'servers/members',chat:'chat',lounge:'lounge',shop:'shop',orders:'shop/orders.csv',lines:'shop/lines',received:'shop/received',statements:'shop/statements',invites:'invites'};
+  tools.push(tool('studio_office_read','Read an office view; use query for its existing filters and pagination.','owner',object({view:{enum:Object.keys(reads)},query:{type:'object',additionalProperties:{type:'string'}}},['view']),({view,query},ctx)=>ctx.office('/_studio/api/'+reads[view],undefined,query)));
+  const actions=['announce','kick','mute','close','game','servers','servers/set','servers/close','servers/member','room-level','agents/brain','chat/rules','chat/remove','chat/report','chat/budget','lounge/rules','lounge/night','lounge/mod','lounge/remove','lounge/hold','shop/release','shop/refund','shop/settle','invites','invites/revoke'];
+  tools.push(tool('studio_office_action','Use an existing office control. Destructive changes return a browser confirmation for the owner.','owner',object({operation:{enum:actions},action:{type:'object'}},['operation','action']),({operation,action},ctx)=>ctx.office('/_studio/api/'+operation,action)));
+  for (const op of ['sit','look','act','speak','stand']) tools.push(tool('agent_'+op, 'A marked AI guide: '+op+'. Room policy and declared vocabulary apply.', 'signed-in', object({game:str,role:str,server:str,room:str,goal:str,line:str,args:{type:'object'}},['game']), async (args,ctx)=>(await import('./mcp-room.mjs')).remoteSeat(env,cat,ctx.caller,op,args)));
+  return tools;
+}

package/worker/mcp.mjs

@@ -0,0 +1,159 @@
+import OAuthProvider from '@cloudflare/workers-oauth-provider';
+import { createMcpHandler } from 'agents/mcp/server';
+import { McpServer, fromJsonSchema } from '@modelcontextprotocol/server';
+import { CfWorkerJsonSchemaValidator } from '@modelcontextprotocol/server/validators/cf-worker';
+import { players } from './players.mjs';
+import { isOwner, sameOrigin } from './office.mjs';
+import { cookieValue } from './stats.mjs';
+import { esc } from './site.mjs';
+import { oauthStorage, rateLimit, audit, callsPerMinute } from './mcp-store.mjs';
+import { allowed, currentCaller, services, builtins } from './mcp-tools.mjs';
+const validator = new CfWorkerJsonSchemaValidator();
+const json = (data,status=200)=>Response.json(data,{status,headers:{'cache-control':'no-store'}});
+const html = (body,headers={})=>new Response(`<!doctype html><html lang="en"><meta charset="utf-8"><meta name="viewport" content="width=device-width"><title>Connect your AI</title><style>body{font:18px system-ui;max-width:640px;margin:64px auto;padding:24px;background:#faf9f6;color:#252520}button,a{padding:12px}button{font:inherit}li{margin:16px 0}</style><main>${body}</main></html>`,{headers:{'content-type':'text/html; charset=utf-8','cache-control':'no-store','content-security-policy':"default-src 'none'; style-src 'unsafe-inline'; form-action 'self'; frame-ancestors 'none'; base-uri 'none'",...Object.fromEntries(new Headers(headers))}});
+async function browserPerson(request,env) {
+  const person=await players.of(request,env);
+  if(person&&!person.guest)return person.id;
+  if(await isOwner(request,env)) {
+    const token=cookieValue(request,'studio_owner');
+    if(token){const hash=await crypto.subtle.digest('SHA-256',new TextEncoder().encode(token));return 'office-'+[...new Uint8Array(hash)].map(b=>b.toString(16).padStart(2,'0')).join('');}
+  }
+  return null;
+}
+export async function remoteMcp(request,env,ctx,{catalogueOf,definitions=[]}) {
+  const url=new URL(request.url), origin=url.origin, path=url.pathname;
+  if(!env.DB)return json({error:'studio database required'},503);
+  if(request.headers.has('origin') && request.headers.get('origin')!==origin)return json({error:'origin refused'},403);
+  // Cap all protocol bodies before handing them to a library or a handler.
+  if(request.body){
+    const reader=request.body.getReader(),chunks=[];let size=0;
+    for(;;){const {done,value}=await reader.read();if(done)break;size+=value.length;if(size>65536){await reader.cancel();return json({error:'request too large'},413);}chunks.push(value);}
+    const bytes=new Uint8Array(size);let at=0;for(const chunk of chunks){bytes.set(chunk,at);at+=chunk.length;}request=new Request(request,{body:bytes});
+  }
+  if(path.startsWith('/hooks/tools/')) return (await import('./tool-webhook.mjs')).toolWebhook(request,env,{cat:await catalogueOf(),definitions});
+  const scoped={...env,OAUTH_KV:oauthStorage(env.DB)};
+  const api=async(request,env,ctx)=>{
+    let caller;
+    try{caller=await currentCaller(env,ctx.props);}catch{return new Response(JSON.stringify({error:'connection revoked'}),{status:401,headers:{'content-type':'application/json','cache-control':'no-store','www-authenticate':`Bearer resource_metadata="${origin}/.well-known/oauth-protected-resource/mcp", error="invalid_token"`}});}
+    const cat=await catalogueOf();const tools=[...builtins(env,cat,origin),...definitions];
+    if(request.method==='POST') {
+      const body=await request.clone().json().catch(()=>null);
+      if(body?.method==='tools/call') {
+        const tool=tools.find(t=>t.name===body.params?.name);
+        if(tool&&!validator.getValidator(tool.inputSchema)(body.params?.arguments??{}).valid)await audit(env,caller,tool.name,'invalid');
+        if(!tool)await audit(env,caller,'unknown-tool','denied');
+      }
+    }
+    const rate=async fresh=>{
+      const limit=callsPerMinute(cat);
+      if(!await rateLimit(env,fresh.id??`public:${request.headers.get('cf-connecting-ip')??'local'}`,limit))throw new Error('Rate limit reached');
+    };
+    const read=async(name,handler)=>{
+      let outcome='error';
+      try{const fresh=await currentCaller(env,ctx.props);await rate(fresh);const result=await handler(fresh);if(JSON.stringify(result).length>65536)throw new Error('Result too large');outcome='ok';return result;}
+      finally{await audit(env,caller,name,outcome);}
+    };
+    const server=async()=>{
+      const s=new McpServer({name:cat.studio?.name??'Homie studio',version:'1.0.0'},{jsonSchemaValidator:validator});
+      for (const meta of cat.games.filter(g=>g.kind==='app' && g.records?.persist)) {
+        for (const [role,declared] of Object.entries(meta.roles??{})) {
+          if (declared.signIn && !await allowed({app:meta.id,role},caller,env)) continue;
+          for (const collection of Object.keys(meta.records.collections??{})) {
+            if (!declared.can.includes('read:'+collection)) continue;
+            const uri=`studio://records/${meta.id}/${role}/${collection}`;
+            s.registerResource(`${meta.id}_${role}_${collection}`,uri,{description:'Untrusted app record data',mimeType:'application/json'},async()=>read('resource:'+meta.id+':'+collection,async fresh=>{
+              const data=await services(env,cat,origin,fresh,'records').records({app:meta.id,role,collection});
+              return {contents:[{uri,mimeType:'application/json',text:JSON.stringify({kind:'untrusted-record-data',data})}]};
+            }));
+          }
+        }
+      }
+      for(const tool of tools){
+        if (tool.kind==='prompt') {
+          if (!await allowed(tool.audience,caller,env)) continue;
+          s.registerPrompt(tool.name,{description:tool.description,argsSchema:fromJsonSchema(tool.inputSchema,validator)},async(args)=>read('prompt:'+tool.name,async fresh=>{
+            if(!await allowed(tool.audience,fresh,env))throw new Error('Permission denied');
+            const text=await tool.handler(args,services(env,cat,origin,fresh,tool.namespace??tool.name,tool));
+            return {messages:[{role:'user',content:{type:'text',text:JSON.stringify({kind:'studio-prompt-data',prompt:tool.name,data:text})}}]};
+          }));continue;
+        }
+        s.registerTool(tool.name,{description:tool.description,inputSchema:fromJsonSchema(tool.inputSchema,validator)},async(args)=>{
+          let outcome='error';
+          try{
+            // Recheck inside dispatch, even when a connection listed tools earlier.
+            const fresh=await currentCaller(env,ctx.props);
+            if(!await allowed(tool.audience,fresh,env)){outcome='denied';throw new Error('Permission denied');}
+            try{await rate(fresh);}catch(error){outcome='limited';throw error;}
+            const value=await tool.handler(args,services(env,cat,origin,fresh,tool.namespace??tool.name,tool));
+            const text=JSON.stringify({kind:'untrusted-tool-data',tool:tool.name,data:value});
+            if(text.length>65536)throw new Error('Result too large; narrow your request');
+            outcome='ok';return {content:[{type:'text',text}]};
+          }catch(error){return {isError:true,content:[{type:'text',text:outcome==='denied'||outcome==='limited'?error.message:'Tool failed. Check the office audit and the tool definition.'}]};}
+          finally{await audit(env,caller,tool.name,outcome);}
+        });
+      }
+      return s;
+    };
+    return createMcpHandler(server)(request,env,ctx);
+  };
+  const provider=new OAuthProvider({
+    apiRoute:'/mcp',apiHandler:{fetch:api},
+    authorizeEndpoint:'/oauth/authorize',tokenEndpoint:'/oauth/token',clientRegistrationEndpoint:'/oauth/register',
+    resourceMetadata:{resource:origin+'/mcp',authorization_servers:[origin]},
+    scopesSupported:['studio','offline_access'],requiredScopes:['studio'],
+    accessTokenTTL:3600,
+    defaultHandler:{async fetch(req,env,ctx){
+      const u=new URL(req.url),person=await browserPerson(req,env),oauth=env.OAUTH_PROVIDER;
+      if(u.pathname==='/oauth/authorize'){
+        if(!person)return html(`<h1>Sign in to your studio</h1><p>Use your existing studio account, then approve your AI.</p><a href="/account?next=${esc(encodeURIComponent(u.pathname+u.search))}">Sign in</a>`,{'x-frame-options':'DENY'});
+        try{
+          if(req.method==='GET'){
+            const auth=await oauth.parseAuthRequest(req),description=await oauth.describeConsent(auth),transaction=await oauth.beginConsent(auth);
+            await env.OAUTH_KV.put('consent-person:'+transaction.handle,person,{expirationTtl:600});
+            return html(`<h1>Connect your AI</h1><p><strong>${esc(description.clientName)}</strong> asks to use this studio with your current permissions.</p><p>The app supplies this name. Approve only if you started this connection and recognize the return address.</p><p>Return address: ${esc(description.redirectHost)}. ${description.redirectIsLoopback?'This is a local app; any local process could be listening.':''}</p><p>Your AI can use your app roles. If you own the studio, it can use the office. Destructive office actions still need your confirmation. Revoke this connection in the office at any time.</p><form method="post"><input type="hidden" name="handle" value="${esc(transaction.handle)}"><button name="decision" value="allow">Allow connection</button> <button name="decision" value="deny">Cancel</button></form>`,transaction.headers);
+          }
+          if(req.method!=='POST'||!sameOrigin(req,u))return json({error:'same-origin POST required'},403);
+          const form=await req.formData(),handle=String(form.get('handle')??'');
+          if(form.get('decision')!=='allow'){const denied=await oauth.denyConsent(req,handle);return new Response(null,{status:302,headers:denied.headers});}
+          if(await env.OAUTH_KV.get('consent-person:'+handle)!==person)return json({error:'Sign-in changed; restart the connection'},403);
+          const approved=await oauth.approveConsent(req,handle,{scope:['studio','offline_access']});
+          await env.OAUTH_KV.delete('consent-person:'+handle);
+          const connection=crypto.randomUUID();
+          await env.DB.prepare('INSERT INTO mcp_connections(id,person,client,created) VALUES(?1,?2,?3,?4)').bind(connection,person,approved.request.clientId,Date.now()).run();
+          const result=await oauth.completeAuthorization({request:approved.request,userId:person,scope:['studio','offline_access'],metadata:{connection},props:{connection}});
+          approved.headers.set('location',result.redirectTo);return new Response(null,{status:302,headers:approved.headers});
+        }catch{return json({error:'Invalid or expired authorization request'},400);}
+      }
+      if(u.pathname==='/_studio/office/connections'){
+        if(!person)return html('<h1>Sign in to manage AI connections</h1><a href="/account?next=/_studio/office/connections">Sign in</a>');
+        const owner=await isOwner(req,env);
+        if(req.method==='POST'){
+          if(!sameOrigin(req,u))return json({error:'origin refused'},403);
+          const f=await req.formData();const id=String(f.get('connection')??'');
+          const connection=await env.DB.prepare('SELECT * FROM mcp_connections WHERE id=?1').bind(id).first();
+          if(connection&&(owner||connection.person===person)){
+            // Local denial takes effect first, even if upstream token cleanup must be retried.
+            await env.DB.prepare('UPDATE mcp_connections SET revoked=1 WHERE id=?1').bind(id).run();
+            let cursor;
+            do{const grants=await oauth.listUserGrants(connection.person,{limit:100,cursor});
+              for(const grant of grants.items)if(grant.metadata?.connection===id)await oauth.revokeGrant(grant.id,connection.person);
+              cursor=grants.cursor;
+            }while(cursor);
+          }
+          return Response.redirect(origin+u.pathname,303);
+        }
+        const page=Math.max(0,Math.min(100,Number.parseInt(u.searchParams.get('page')??'0',10)||0)),offset=page*100;
+        const rows=(await env.DB.prepare(owner?'SELECT c.*,p.name FROM mcp_connections c LEFT JOIN players p ON p.id=c.person ORDER BY c.created DESC LIMIT 100 OFFSET ?1':'SELECT c.*,p.name FROM mcp_connections c LEFT JOIN players p ON p.id=c.person WHERE c.person=?1 ORDER BY c.created DESC LIMIT 100 OFFSET ?2').bind(...(owner?[offset]:[person,offset])).all()).results;
+        const events=owner?(await env.DB.prepare('SELECT a.*,p.name FROM mcp_audit a LEFT JOIN players p ON p.id=a.person ORDER BY a.id DESC LIMIT 100 OFFSET ?1').bind(offset).all()).results:[];
+        const names=new Map(await Promise.all([...new Set([...rows,...events].map(r=>r.client).filter(Boolean))].map(async id=>[id,(await oauth.lookupClient(id).catch(()=>null))?.clientName??id])));
+        return html(`<h1>Your studio's AI connections</h1><p>MCP address: <code>${esc(origin)}/mcp</code></p><ul>${rows.map(r=>`<li>${esc(r.name??(r.person.startsWith('office-')?'Owner browser':r.person))} · ${esc(names.get(r.client))} · ${r.revoked?'Revoked':`<form method="post"><input type="hidden" name="connection" value="${esc(r.id)}"><button>Revoke</button></form>`}</li>`).join('')}</ul><h2>Recent tool calls</h2><ul>${events.map(r=>`<li>${esc(new Date(r.at).toISOString())} · ${esc(r.name??(r.person?.startsWith('office-')?'Owner browser':r.person)??'Public')} · ${esc(names.get(r.client)??'Anonymous')} · ${esc(r.tool)} · ${esc(r.outcome)}</li>`).join('')}</ul><nav>${page?`<a href="?page=${page-1}">Newer</a>`:''}${rows.length===100||events.length===100?`<a href="?page=${page+1}">Older</a>`:''}</nav>`);
+      }
+      return json({error:'not found'},404);
+    }},
+  });
+  if(path==='/mcp'&&!request.headers.has('authorization')){
+    // Public tools remain available without an account. Clients can discover OAuth metadata directly.
+    return api(request,scoped,ctx);
+  }
+  return provider.fetch(request,scoped,ctx);
+}

package/worker/office-page.mjs

@@ -937,7 +937,7 @@ export async function officePage(cat, headers = {}) {
   const name = cat.studio?.name ?? 'Studio';
   const options = (cat.games ?? []).map((g) => `<option value="${esc(g.id)}">every room of ${esc(g.name)}</option>`).join('');
   const body = `<header class="top"><h1>${esc(name)} <small>Office</small></h1>
-<div class="links"><span class="live"><i class="dot" id="livedot"></i><span id="live">…</span></span><a href="/_studio/stats">Stats</a>${cat.shop ? '<a href="/_studio/office/shop">Shop</a>' : ''}
+<div class="links"><span class="live"><i class="dot" id="livedot"></i><span id="live">…</span></span><a href="/_studio/stats">Stats</a><a href="/_studio/office/connections">AI connections</a>${cat.shop ? '<a href="/_studio/office/shop">Shop</a>' : ''}
 <form method="post" action="/_studio/signout" style="display:inline"><button class="ghost small" type="submit">Sign out</button></form></div></header>
 <form class="bar" id="announce-all"><label for="announce-text">Announce</label><input type="text" id="announce-text" maxlength="280" placeholder="A line every player sees, in the game" autocomplete="off">
 <select id="announce-scope" aria-label="Who sees it"><option value="">every room of every game</option>${options}</select><button type="submit">Send</button>

package/worker/office.mjs

@@ -1,5 +1,6 @@
 import { selling } from './extensions.mjs';
 import { purchaseOrderIfPresent } from './shop.mjs';
+import { toolIdentity } from './tool-identity.mjs';
 /**
  * THE STUDIO'S BACK OFFICE (@homie-rocks/studio 0.13.0): the studio's owner, and the owner's AI, see and run the
  * studio's live games. Everything lives in the studio's own Worker and D1; homie.rocks stores none of it.
@@ -1196,7 +1197,7 @@ async function invitesApi(request, env, url, cat, body, who) {
 async function api(request, env, url, cat) {
   const path = url.pathname;
   // An office key, the owner's signed-in browser, or the owner's own player account (a passkey).
-  let who = await ownerAllowed(request, env, { kinds: ['office', 'session'] });
+  let who = toolIdentity(request)?.owner ? 'office' : await ownerAllowed(request, env, { kinds: ['office', 'session'] });
   if (!who && (await isOwner(request, env))) who = 'session';
   if (!who) {
     return json({ ok: false, error: 'owner-only', message: 'The back office is the studio owner\'s. In the studio folder, `npx --no-install homie-studio office key` gives the owner\'s AI a key; `npx --no-install homie-studio office link` signs the owner\'s browser in.' }, 401, { 'www-authenticate': 'Bearer' });

package/worker/purchase-mcp.mjs

@@ -1,9 +1,9 @@
 import { purchaseResponse } from './purchase-response.mjs';
 import { machineCapabilities } from './payment-capabilities.mjs';
 /** The SDK owns protocol negotiation, JSON-RPC errors and stateless HTTP transport. */
-import { Server } from '@modelcontextprotocol/sdk/server/index.js';
-import { WebStandardStreamableHTTPServerTransport } from '@modelcontextprotocol/sdk/server/webStandardStreamableHttp.js';
-import { CallToolRequestSchema, ListToolsRequestSchema } from '@modelcontextprotocol/sdk/types.js';
+import { Server } from 'mcp-purchase-sdk/server/index.js';
+import { WebStandardStreamableHTTPServerTransport } from 'mcp-purchase-sdk/server/webStandardStreamableHttp.js';
+import { CallToolRequestSchema, ListToolsRequestSchema } from 'mcp-purchase-sdk/types.js';
 import { machineResource } from './purchase-machine.mjs';
 export const purchaseSchema = {
   type: 'object', required: ['kind', 'resource', 'version', 'buyer', 'claim', 'offerVersion'],

package/worker/tool-events.mjs

@@ -0,0 +1,14 @@
+import {CfWorkerJsonSchemaValidator} from '@modelcontextprotocol/server/validators/cf-worker';
+import {signControl} from './office.mjs';
+import {allowed} from './mcp-tools.mjs';
+/** A tool must declare each external event and its schema; it cannot impersonate player input. */
+export async function sendToolEvent(env,caller,definition,{game,room,event,data}) {
+  const declaration=definition.events?.[event];
+  if(!declaration||declaration.game!==game||!/^external:[a-z][a-z0-9_-]{0,40}$/.test(event)||!/^[A-Za-z0-9_-]{1,32}$/.test(room))throw new Error('event not declared');
+  if(!await allowed(declaration.audience??'owner',caller,env))throw new Error('event permission denied');
+  if(!new CfWorkerJsonSchemaValidator().getValidator(declaration.schema)(data).valid)throw new Error('event input invalid');
+  if(JSON.stringify(data).length>8192)throw new Error('event too large');
+  const ctl=await signControl(env,{op:'mcp-event',game,room,args:{event,data,person:caller.id}});
+  const response=await env.TABLE.get(env.TABLE.idFromName(`${game}/${room}`)).fetch(`https://table/__mcp-event?game=${game}&room=${room}`,{method:'POST',body:JSON.stringify(ctl)});
+  const result=await response.json();if(!response.ok)throw new Error('room refused event');return result;
+}

package/worker/tool-identity.mjs

@@ -0,0 +1,4 @@
+/** Internal request authority. HTTP headers cannot manufacture this identity. */
+const identities = new WeakMap();
+export function withToolIdentity(request, identity) { identities.set(request, identity); return request; }
+export function toolIdentity(request) { return identities.get(request) ?? null; }

package/worker/tool-webhook.mjs

@@ -0,0 +1,28 @@
+import {allowed,services} from './mcp-tools.mjs';
+import {rateLimit,audit,callsPerMinute} from './mcp-store.mjs';
+import {CfWorkerJsonSchemaValidator} from '@modelcontextprotocol/server/validators/cf-worker';
+/** HMAC-SHA256(timestamp + '.' + delivery id + '.' + exact request body). */
+export async function toolWebhook(request,env,{cat,definitions}) {
+  const name=new URL(request.url).pathname.split('/').pop(),tool=definitions.find(t=>t.name===name&&t.webhook);
+  const fail=(status)=>Response.json({ok:false},{status});
+  if(!tool||request.method!=='POST')return fail(404);
+  const timestamp=request.headers.get('x-studio-timestamp')??'',delivery=request.headers.get('x-studio-delivery')??'',signature=request.headers.get('x-studio-signature')??'';
+  if(!/^\d{10}$/.test(timestamp)||Math.abs(Date.now()/1000-Number(timestamp))>300||!/^[a-zA-Z0-9_-]{8,100}$/.test(delivery)||!/^[a-f0-9]{64}$/.test(signature))return fail(401);
+  const secret=env[tool.webhook.secret];if(typeof secret!=='string'||secret.length<32)return fail(503);
+  const body=await request.text();if(body.length>65536)return fail(413);
+  const key=await crypto.subtle.importKey('raw',new TextEncoder().encode(secret),{name:'HMAC',hash:'SHA-256'},false,['verify']);
+  const bytes=Uint8Array.from(signature.match(/../g),b=>parseInt(b,16));
+  if(!await crypto.subtle.verify('HMAC',key,bytes,new TextEncoder().encode(`${timestamp}.${delivery}.${body}`)))return fail(401);
+  const person=await env.DB.prepare('SELECT id,name,owner,guest FROM players WHERE id=?1').bind(tool.webhook.person).first();
+  const caller={id:person?.id,owner:person?.owner===1,client:'webhook:'+name};let outcome='denied';
+  try{
+    if(!person||person.guest||!await allowed(tool.audience,caller,env))return fail(403);
+    const limit=callsPerMinute(cat);
+    if(!await rateLimit(env,caller.client,limit)){outcome='limited';return fail(429);}
+    const value=JSON.parse(body),validate=new CfWorkerJsonSchemaValidator().getValidator(tool.inputSchema);
+    if(!validate(value).valid){outcome='invalid';return fail(400);}
+    const result=await env.DB.prepare('INSERT OR IGNORE INTO mcp_kv(key,value,expires) VALUES(?1,?2,?3)').bind(`delivery:${name}:${delivery}`,'true',Math.floor(Date.now()/1000)+600).run();
+    if(!result.meta.changes){outcome='replay';return fail(409);}
+    await tool.handler(value,services(env,cat,new URL(request.url).origin,caller,tool.namespace??tool.name,tool));outcome='ok';return Response.json({ok:true});
+  }catch{outcome='error';return fail(400);}finally{await audit(env,caller,name,outcome);}
+}

package/worker/version.mjs

@@ -1,2 +1,2 @@
 /** The @homie-rocks/studio version this Worker code is (package.json's; a test keeps them equal). Cache-busts /_homie/site.js. */
-export const STUDIO_VERSION_TAG = '0.38.0';
+export const STUDIO_VERSION_TAG = '0.40.0';