@homie-rocks/studio 0.37.2 → 0.39.0

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.37.2';
+export const STUDIO_VERSION_TAG = '0.39.0';