@homie-rocks/studio 0.55.0 → 0.57.0

package/worker/studios-client.mjs

@@ -0,0 +1,93 @@
+import {signAssertion} from './studios-keys.mjs';
+import {Client, StreamableHTTPClientTransport, PrivateKeyJwtProvider} from 'mcp-studio-client';
+export function studioOrigin(value,{allowPrivate=false}={}) {
+ const url=new URL(value);
+ if(url.protocol!=='https:'||url.username||url.password||url.pathname!=='/'||url.search||url.hash)throw new Error('Studio requires a bare HTTPS origin');
+ const host=url.hostname.toLowerCase().replace(/\.$/,'');
+ if(!allowPrivate&&(url.port||host.includes(':')||/^[0-9.]+$/.test(host)||!host.includes('.')||/(^|\.)(localhost|local|internal)$/.test(host)))throw new Error('Studio requires a public DNS origin on port 443');
+ return url.origin;
+}
+/** Bound bytes before SDK parsing; the SDK owns JSON-RPC, SSE and OAuth. */
+export function boundedStudioFetch(origin,signal,{maxBytes=1024*1024,fetchFn=globalThis.fetch.bind(globalThis)}={}) {
+ return async(input,init)=>{
+  const request=new Request(input,init),url=new URL(request.url);
+  if(url.origin!==origin||url.username||url.password)throw new Error('Studio request escaped its origin');
+  const response=await fetchFn(new Request(request,{redirect:'manual',signal:AbortSignal.any([signal,request.signal])}));
+  if(response.status>=300&&response.status<400){await response.body?.cancel();throw new Error('Studio redirects refused');}
+  if(Number(response.headers.get('content-length'))>maxBytes){await response.body?.cancel();throw new Error('Studio response size exceeded');}
+  if(!response.body)return response;
+  let bytes=0;
+  const body=response.body.pipeThrough(new TransformStream({transform(chunk,controller){bytes+=chunk.byteLength;if(bytes>maxBytes)throw new Error('Studio response size exceeded');controller.enqueue(chunk);}}));
+  return new Response(body,{status:response.status,statusText:response.statusText,headers:response.headers});
+ };
+}
+export function studioResult(result,source={origin:null,authenticated:false}) {
+ let data=result.structuredContent;
+ if(data===undefined&&result.content?.length===1&&result.content[0].type==='text'){
+  try{const parsed=JSON.parse(result.content[0].text);if(parsed?.kind==='untrusted-tool-data')data=parsed;}catch{/* Ordinary MCP text remains content. */}
+ }
+ if(data?.kind==='untrusted-tool-data'&&Object.hasOwn(data,'data'))data=data.data;
+ return {source,untrusted:true,isError:result.isError===true,...(data===undefined?{}:{data}),content:result.content??[]};
+}
+export function outboundRules(cat) {
+ const rules=new Map();
+ for(const [key,rule] of Object.entries(cat.studio?.mcp?.studios?.outbound??{})) {
+  const origin=studioOrigin(key,{allowPrivate:rule.allowPrivate===true});
+  if(rules.has(origin)||rule.origin!==undefined&&studioOrigin(rule.origin,{allowPrivate:rule.allowPrivate===true})!==origin)throw new Error('Studio configuration origin mismatch');
+  rules.set(origin,rule);
+ }
+ return rules;
+}
+export function studiosClient(env,cat,definition,{fetchFn=globalThis.fetch.bind(globalThis),origin:ownOrigin}={}) {
+ const providers=new Map(),discovery=new Map();
+ const rules=outboundRules(cat);
+ const run=async(origin,operation,options={})=>{
+  const candidate=new URL(origin).origin,rule=rules.get(candidate);
+  origin=studioOrigin(origin,{allowPrivate:rule?.allowPrivate===true});
+  if(!rule)throw new Error('Studio destination is not configured');
+  if(rule&&!rule.tools?.includes(definition.name))throw new Error('Studio connection not delegated to this tool');
+  const controller=new AbortController(),timer=setTimeout(()=>controller.abort(new Error('Studio request timed out')),10000);
+  const client=new Client({name:'homie-studio',version:'1'});
+  try{
+   const authenticated=rule.anonymous!==true;
+   let authProvider;
+   if(authenticated){
+    if(!ownOrigin||!env.STUDIO_SIGNING_KEY)throw new Error('Studio signing key unavailable');
+    authProvider=providers.get(origin);
+    if(!authProvider){
+     authProvider=new PrivateKeyJwtProvider({clientId:ownOrigin,privateKey:{},algorithm:'EdDSA',scope:'studio',expectedIssuer:origin});
+     authProvider.addClientAuthentication=async(_headers,params,url)=>{
+      if(String(url)!==origin+'/oauth/token')throw new Error('Unexpected studio token endpoint');
+      params.set('client_id',ownOrigin);
+      params.set('client_assertion_type','urn:ietf:params:oauth:client-assertion-type:jwt-bearer');
+      params.set('client_assertion',await signAssertion(env,ownOrigin,String(url)));
+     };
+     providers.set(origin,authProvider);
+    }
+   }
+   const cachedFetch=async(request)=>{
+    const url=new URL(request.url),cacheable=request.method==='GET'&&url.pathname.startsWith('/.well-known/');
+    if(cacheable&&discovery.has(request.url))return discovery.get(request.url).clone();
+    const response=await fetchFn(request);
+    if(cacheable&&response.ok){const bounded=await (await boundedStudioFetch(origin,controller.signal,{fetchFn:async()=>response,maxBytes:32768})(request)).arrayBuffer();if(bounded.byteLength>32768)throw new Error('Discovery size exceeded');const saved=new Response(bounded,{status:response.status,headers:response.headers});discovery.set(request.url,saved);return saved.clone();}
+    return response;
+   };
+   const headers={};
+   if(options.assertedHandle!==undefined){
+    if(!authenticated||typeof options.assertedHandle!=='string'||! /^[A-Za-z0-9._@-]{1,128}$/.test(options.assertedHandle))throw new Error('Acting-for needs an authenticated studio and a handle of 1–128 characters');
+    headers['x-studio-asserted-handle']=encodeURIComponent(options.assertedHandle);
+   }
+   const transport=new StreamableHTTPClientTransport(new URL(authenticated?'/mcp/auth':'/mcp',origin),{fetch:boundedStudioFetch(origin,controller.signal,{fetchFn:async request=>cachedFetch(request)}),authProvider,requestInit:{headers}});
+   await client.connect(transport,{signal:controller.signal,timeout:10000});
+   return await operation(client,controller.signal,{origin,authenticated});
+  }finally{controller.abort();clearTimeout(timer);await client.close();}
+ };
+ return Object.freeze({
+  send:(origin,name,event)=>import('./studios-events.mjs').then(m=>m.sendStudioEvent(env,cat,ownOrigin,definition,origin,name,event,{fetchFn})),
+  listTools:(origin,options)=>run(origin,async(client,signal,source)=>{const page=await client.listTools(options?.cursor?{cursor:options.cursor}:{},{signal,timeout:10000});return {...page,source,untrusted:true,tools:page.tools.map(tool=>({...tool,source,untrusted:true,description:'[Untrusted remote description] '+(tool.description??'')}))};},options),
+  call:(origin,tool,args={},options)=>{
+   if(new TextEncoder().encode(JSON.stringify(args)).length>65536)return Promise.reject(new Error('Studio arguments size exceeded'));
+   return run(origin,async(client,signal,source)=>studioResult(await client.callTool({name:tool,arguments:args},{signal,timeout:10000}),source),options);
+  },
+ });
+}

package/worker/studios-events.mjs

@@ -0,0 +1,52 @@
+import {boundedBody,studioPolicy} from './studios-auth.mjs';
+import {studioOrigin,outboundRules,boundedStudioFetch} from './studios-client.mjs';
+import {signBytes,originKey,verifyBytes} from './studios-keys.mjs';
+import {publishBusinessEvent,BUSINESS_EVENT_MAX_BYTES} from './business-events.mjs';
+import {syncFunctions} from './functions.mjs';
+export async function signStudioEvent(env,source,name,{id,data},{now=Date.now}={}){
+ if(typeof id!=='string'||!/^[A-Za-z0-9_-]{1,128}$/.test(id))throw new Error('Stable event id required');
+ const body=JSON.stringify({eventId:id,name,timestamp:new Date(now()).toISOString(),source,data});
+ if(new TextEncoder().encode(body).length>BUSINESS_EVENT_MAX_BYTES)throw new Error('Studio event exceeds 8192 bytes');
+ const timestamp=String(Math.floor(now()/1000)),{kid,signature}=await signBytes(env,`${id}.${timestamp}.${body}`);
+ return {body,headers:{'content-type':'application/json','webhook-id':id,'webhook-timestamp':timestamp,'webhook-signature':'v1a,'+signature,'webhook-key-id':kid,'webhook-origin':source}};
+}
+export async function sendStudioEvent(env,cat,source,definition,origin,name,event,options={}) {
+ const rule=outboundRules(cat).get(new URL(origin).origin);origin=studioOrigin(origin,{allowPrivate:rule?.allowPrivate===true});
+ if(!rule?.tools?.includes(definition.name)||!rule.events?.includes(name)||!/^\/hooks\/studios\/[a-zA-Z0-9_-]+$/.test(rule.eventPath??''))throw new Error('Studio event destination not delegated');
+ if(rule.anonymous||!source)throw new Error('Studio event requires origin authentication');
+ const signed=await signStudioEvent(env,source,name,event,options);
+ const response=await boundedStudioFetch(origin,AbortSignal.timeout(10000),options)(origin+rule.eventPath,{method:'POST',...signed});
+ await response.body?.cancel();if(!response.ok)throw new Error('Studio event rejected ('+response.status+')');
+ return {id:event.id};
+}
+/** Standard Webhooks v1a: Ed25519 over id.timestamp.exact-body, keys fetched only from configured origin. */
+export async function receiveStudioEvent(request,env,cat,options={}) {
+ if(request.method!=='POST')return new Response(null,{status:405});
+ const id=new URL(request.url).pathname.slice('/hooks/studios/'.length),entries=cat.studio?.mcp?.studios?.inbound??{};
+ const configured=Object.hasOwn(entries,id)?entries[id]:null;
+ let origin,rule;try{origin=studioOrigin(configured?.origin,{allowPrivate:configured?.allowPrivate===true});if(configured.enabled!==false&&await studioPolicy(env,cat,origin))rule=configured;}catch{}
+ if(!rule)return new Response(null,{status:403});
+ let body;try{body=await boundedBody(request,BUSINESS_EVENT_MAX_BYTES);}catch{return new Response('Studio event exceeds 8192 bytes',{status:413});}
+ let event;
+ try{
+  const timestamp=request.headers.get('webhook-timestamp'),eventId=request.headers.get('webhook-id');
+  if(!/^\d+$/.test(timestamp??'')||Math.abs(Date.now()/1000-Number(timestamp))>300||!/^[A-Za-z0-9_-]{1,128}$/.test(eventId??'')||request.headers.get('webhook-origin')!==origin)throw Error();
+  const key=await originKey(env,origin,request.headers.get('webhook-key-id'),{...options,allowPrivate:rule.allowPrivate===true});
+  let valid=false;for(const part of (request.headers.get('webhook-signature')??'').split(' ').slice(0,8)){
+   const [version,signature]=part.split(',');if(version==='v1a'&&await verifyBytes(key,signature,`${eventId}.${timestamp}.${body}`)){valid=true;break;}
+  }
+  if(!valid)throw Error();event=JSON.parse(body);
+ }catch{return new Response(null,{status:401});}
+ if(!event||typeof event!=='object'||Array.isArray(event)||event.source!==origin||event.eventId!==request.headers.get('webhook-id')||typeof event.name!=='string')return new Response(null,{status:400});
+ const feed=Object.hasOwn(rule.events??{},event.name)?rule.events[event.name]:null;
+ if(!feed)return new Response(null,{status:403});
+ await syncFunctions(env);
+ try{await publishBusinessEvent(env,{}, {publish:[feed]},'@studio:'+origin,{feed,id:event.eventId,data:{sender:{origin,verified:true},data:event.data}});}
+ catch(error){
+  if(/already published/.test(error.message))return new Response(null,{status:409});
+  if(/8192 bytes/.test(error.message))return new Response(error.message,{status:413});
+  if(/schema|characters/.test(error.message))return new Response(null,{status:400});
+  throw error;
+ }
+ return new Response(null,{status:204});
+}

package/worker/studios-keys.mjs

@@ -0,0 +1,54 @@
+import {oauthStorage} from './mcp-store.mjs';
+import {studioOrigin,boundedStudioFetch} from './studios-client.mjs';
+const bytes=text=>new TextEncoder().encode(text);
+export const base64=value=>btoa(String.fromCharCode(...new Uint8Array(value)));
+export const unbase64=value=>Uint8Array.from(atob(value),c=>c.charCodeAt(0));
+const encode=value=>base64(bytes(JSON.stringify(value))).replaceAll('+','-').replaceAll('/','_').replace(/=+$/,'');
+export const decode=value=>JSON.parse(new TextDecoder().decode(unbase64(value.replaceAll('-','+').replaceAll('_','/'))));
+export function publicKeys(env){
+ const current=JSON.parse(env.STUDIO_SIGNING_KEY??'null');
+ const keys=[current,...JSON.parse(env.STUDIO_PREVIOUS_PUBLIC_KEYS??'[]')].filter(Boolean);
+ return {keys:keys.map(({kty,crv,x,kid})=>({kty,crv,x,kid,alg:'EdDSA',use:'sig'}))};
+}
+export async function signBytes(env,text){
+ const jwk=JSON.parse(env.STUDIO_SIGNING_KEY??'null');
+ if(!jwk?.kid||jwk.crv!=='Ed25519'||!jwk.d)throw new Error('Studio signing key unavailable');
+ const key=await crypto.subtle.importKey('jwk',{...jwk,alg:'EdDSA'},'Ed25519',false,['sign']);
+ return {kid:jwk.kid,signature:base64(await crypto.subtle.sign('Ed25519',key,bytes(text)))};
+}
+export async function signAssertion(env,origin,audience){
+ const jwk=JSON.parse(env.STUDIO_SIGNING_KEY??'null'),now=Math.floor(Date.now()/1000);
+ const text=encode({alg:'EdDSA',typ:'JWT',kid:jwk?.kid})+'.'+encode({iss:origin,sub:origin,aud:audience,iat:now,exp:now+60,jti:crypto.randomUUID()});
+ return text+'.'+(await signBytes(env,text)).signature.replaceAll('+','-').replaceAll('/','_').replace(/=+$/,'');
+}
+/** D1 cache and atomic per-origin fetch claim bound failures and unknown kids across requests. */
+export async function originKey(env,origin,kid,{fetchFn=globalThis.fetch.bind(globalThis),allowPrivate=false}={}){
+ origin=studioOrigin(origin,{allowPrivate});
+ if(typeof kid!=='string'||! /^[A-Za-z0-9_-]{1,128}$/.test(kid))throw new Error('Invalid key id');
+ const store=oauthStorage(env.DB),cacheKey='studio-jwks:'+origin,now=Date.now();
+ let cached=await store.get(cacheKey,'json');
+ if(!cached||cached.until<=now||!cached.keys.some(k=>k.kid===kid)&&now-cached.at>=60000){
+  // Claim before network I/O: concurrent misses cannot each fetch. Milliseconds
+  // in value enforce a full 60 seconds; expires is the storage cleanup bound.
+  const claim=await env.DB.prepare("INSERT INTO mcp_kv(key,value,expires) VALUES(?1,?2,?3) ON CONFLICT(key) DO UPDATE SET value=excluded.value,expires=excluded.expires WHERE CAST(mcp_kv.value AS INTEGER)<=?4 RETURNING key")
+   .bind('studio-jwks-fetch:'+origin,String(now+60000),Math.ceil((now+60000)/1000),now).first();
+  if(claim){
+   try{
+    const fetch=boundedStudioFetch(origin,AbortSignal.timeout(5000),{fetchFn,maxBytes:32768});
+    const response=await fetch(origin+'/.well-known/jwks.json');if(!response.ok)throw new Error('Studio keys unavailable');
+    const jwks=await response.json();
+    if(!Array.isArray(jwks?.keys)||jwks.keys.length>8||jwks.keys.some(k=>!k||typeof k!=='object'||k.d))throw new Error('Invalid studio keys');
+    cached={keys:jwks.keys,at:now,until:now+300000};
+   }catch{
+    // Preserve still-valid known keys when an unknown-kid refresh fails.
+    cached={keys:cached?.until>now?cached.keys:[],at:now,until:Math.max(cached?.until??0,now+60000)};
+   }
+   await store.put(cacheKey,JSON.stringify(cached),{expiration:Math.ceil(cached.until/1000)});
+  }
+ }
+ if(!cached||cached.until<=now)throw new Error('Studio keys unavailable');
+ const matches=cached.keys.filter(k=>k.kid===kid&&k.kty==='OKP'&&k.crv==='Ed25519'&&(!k.alg||k.alg==='EdDSA')&&(!k.use||k.use==='sig'));
+ if(matches.length!==1)throw new Error('Unknown studio key');
+ return crypto.subtle.importKey('jwk',matches[0],'Ed25519',false,['verify']);
+}
+export async function verifyBytes(key,signature,text){return crypto.subtle.verify('Ed25519',key,unbase64(signature.replaceAll('-','+').replaceAll('_','/')),bytes(text));}