actas 0.0.0-stage → 0.4.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 BRAIN TRUST PRIVATE LIMITED
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -1,3 +1,78 @@
-# Temporary Holding Version
+# ActAs MCP
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+Give an AI agent its own identity, email, saved accounts and scoped credentials.
+ActAs Pro costs US$12/month or US$120/year; there is no free tier. The MCP server
+is available remotely over Streamable HTTP or locally over stdio.
+
+## Remote: no install
+
+Add `https://actas.dev/mcp` in an MCP client that supports bearer headers. Use
+the token from your scoped ActAs connection in the Authorization bearer header,
+saved through your client's protected credential settings. Do not put the token
+in the endpoint URL, a prompt, or source control. OAuth is not offered.
+
+The remote endpoint shares the 19 stdio tool schemas and applies the same API
+permissions and revocation checks on every call. Browser flows still need a
+local browser adapter. Private verification handles and registered executable
+consumers return `needs_local_runtime` remotely; use the local client below.
+
+Stored passwords and TOTP codes are withheld by default. To return them remotely,
+explicitly configure `ActAs-MCP-Secret-Output: allow` as an additional header.
+Existing reveal scopes and vault grants still apply. A hosted client may retain
+secret tool results in chat history; prefer the local runtime to avoid that.
+Inbox sign-in codes also enter the client's results. Workspace management tokens
+require `ActAs-MCP-Management: allow`; prefer scoped identity connections.
+
+## Install
+
+Requires Node.js 22 or newer and an ActAs subscription at https://actas.dev.
+Download https://actas.dev/actas-mcp.tgz and run:
+
+```sh
+npm install -g ./actas-mcp.tgz
+actas-accounts-mcp --help
+```
+
+Create an identity in your workspace, give it an inbox and grant only the
+resources and actions it needs. Download its private connection from the Access
+tab. Store it outside your source repository with owner-only file permissions.
+
+Add this configuration to a stdio MCP client (replace the example file path):
+
+```json
+{
+  "mcpServers": {
+    "actas": {
+      "command": "actas-accounts-mcp",
+      "env": {
+        "ACTAS_CONNECTION_FILE": "/absolute/path/to/actas-identity.json"
+      }
+    }
+  }
+}
+```
+
+The connection file contains a bearer token. Never put its contents in prompts,
+URLs, logs or git. Revoke the connection in ActAs to stop its future requests.
+
+## Tools and permissions
+
+The server lists saved accounts, runs scoped account actions, retrieves granted
+login credentials and current TOTP codes, and waits for verification mail. Some
+tools return sensitive credentials or codes to the authorized agent: grant only
+what that agent should see. Management tools for identity creation and domain
+setup require a separate management connection; ordinary identity connections
+cannot gain management access by choosing a tool.
+
+The optional browser adapter needs a locally installed Playwright Chromium
+browser (`npx playwright install chromium`). Website signup and login depend on
+the website and its policies. Phone, ID checks and CAPTCHAs require a human
+handoff; saving an account record is not proof of external registration.
+
+Documentation: https://actas.dev/docs
+
+Plain-text quickstart: https://actas.dev/mcp.md
+
+API reference: https://actas.dev/openapi.json
+
+Support: support@actas.dev

package/client/accounts-inbox.mjs

@@ -0,0 +1,42 @@
+import {randomBytes} from 'node:crypto';
+
+// Values never leave this trusted runtime through MCP. Handles expire and consume once.
+export class PrivateValues {
+ #values=new Map();
+ constructor(now=Date.now){this.now=now;}
+ put(value){for(const [key,item] of this.#values)if(item.expiresAt<=this.now())this.#values.delete(key);if(this.#values.size>=1000)throw Error('Private value capacity reached.');const handle=randomBytes(32).toString('base64url'),expiresAt=this.now()+60000;this.#values.set(handle,{value,expiresAt});return {valueHandle:handle,expiresAt};}
+ consume(handle){const item=this.#values.get(handle);this.#values.delete(handle);if(!item||item.expiresAt<=this.now())throw Error('Private value is unavailable.');return item.value;}
+}
+function senderAddress(value){if(typeof value!=='string')return '';const match=/^(?:[^<>]*<)?([^<>\s]+@[^<>\s]+)>?$/.exec(value.trim());return match?.[1].toLowerCase()??'';}
+export function validateInboxArgs(args){
+ const keys=['emailId','sender','subject','after','linkOrigin','linkPath','codePattern','timeoutMs'];if(!args||Object.keys(args).some(k=>!keys.includes(k)))throw Error('Invalid inbox request.');
+ if(typeof args.emailId!=='string'||!args.emailId||args.emailId.length>160||typeof args.sender!=='string'||!/^\S+@\S+\.\S+$/.test(args.sender)||args.sender.length>254||typeof args.subject!=='string'||!args.subject||args.subject.length>200||typeof args.after!=='string'||!Number.isFinite(Date.parse(args.after))||Date.parse(args.after)>Date.now())throw Error('Invalid inbox request.');
+ if(args.codePattern){if(args.linkOrigin||args.linkPath||! /^(?:\\d|\[A-Z0-9\])\{(?:[4-9]|1[0-2])\}$/.test(args.codePattern))throw Error('Use a bounded digit or uppercase code pattern.');}
+ else{const url=new URL(args.linkOrigin);if(url.protocol!=='https:'||url.origin!==args.linkOrigin||typeof args.linkPath!=='string'||!args.linkPath.startsWith('/')||/[?#\\]/.test(args.linkPath))throw Error('Use an exact HTTPS link origin and path.');}
+ if(args.timeoutMs!==undefined&&(!Number.isInteger(args.timeoutMs)||args.timeoutMs<0||args.timeoutMs>30000))throw Error('Invalid timeout.');return args;
+}
+export function verificationValue(message,args,now=Date.now()){
+ const timestamp=Date.parse(message.timestamp),after=Date.parse(args.after);
+ if(!message.labels?.includes('received')||!Number.isFinite(timestamp)||timestamp<after||timestamp>now||senderAddress(message.from)!==args.sender.toLowerCase()||typeof message.subject!=='string'||!message.subject.includes(args.subject)||typeof message.text!=='string')return;
+ // ActAs wraps received mail as untrusted; match only the body, and only
+ // when ActAs authenticated the sender's domain.
+ if(message.sender_check?.domain_verified!==true)return;
+ const wrapped=message.untrusted?/^<(untrusted-email-[a-f0-9]+)>\n[\s\S]*?\n\n([\s\S]*)\n<\/\1>$/.exec(message.text):null;
+ if(message.untrusted&&!wrapped)return;
+ const body=(wrapped?wrapped[2]:message.text).slice(0,200*1024);
+ if(args.codePattern){const re=new RegExp(`(?:^|[^A-Za-z0-9])(${args.codePattern})(?=$|[^A-Za-z0-9])`),match=re.exec(body);return match?.[1];}
+ for(const candidate of body.match(/https:\/\/[^\s<>"']+/g)??[]){try{const url=new URL(candidate);if(url.origin===args.linkOrigin&&url.pathname===args.linkPath&&!url.username&&!url.password&&!url.hash)return url.href;}catch{}}
+}
+export async function waitForInbox(args,request,values,{now=Date.now,sleep=ms=>new Promise(r=>setTimeout(r,ms))}={}){
+ validateInboxArgs(args);const deadline=now()+(args.timeoutMs??0);
+ do{
+  const listing=await request('/emails/'+encodeURIComponent(args.emailId)+'/messages?limit=20','GET');
+  for(const item of listing.messages??listing){
+   if(!item.labels?.includes('received'))continue;const id=item.message_id??item.id;if(typeof id!=='string')continue;
+   const detail=await request('/emails/'+encodeURIComponent(args.emailId)+'/messages/'+encodeURIComponent(id),'GET');
+   const value=verificationValue(detail,args,now());if(value!==undefined)return {status:'matched',...values.put(value)};
+  }
+  if(now()>=deadline)return {status:'pending'};await sleep(Math.min(1000,deadline-now()));
+ }while(now()<=deadline);
+ return {status:'pending'};
+}

package/client/accounts-mcp-core.mjs

@@ -0,0 +1,116 @@
+import {PrivateValues,waitForInbox} from './accounts-inbox.mjs';
+
+// Routing metadata stays outside the strict browser report/vault boundary.
+// The step ID survives token rotation so callers can persist one Turnless request.
+function humanResult(result,name,args,account,action){
+ if(result.status!=='needs_human')return result;
+ account=result.account??account;
+ const platform={x:'X',instagram:'Instagram',github:'GitHub',bluesky:'Bluesky',reddit:'Reddit',discord:'Discord'}[account?.platform]??account?.platform??'the provider';
+ const ref=account?.accountRef??args.accountRef;
+ const reason=result.handoff??result.reason??(account?.method==='browser'?'human_credential_entry':'api_credentials');
+ const actions={captcha:'Complete the CAPTCHA',mfa:'Complete the authentication challenge',phone:'Complete the phone verification',provider_policy:'Review the provider approval',human_credential_entry:`Sign in as ${account?.handle??ref}`,api_credentials:`Create and save official ${platform} API credentials for ${ref} in its ActAs vault`};
+ const where=reason==='api_credentials'?`${platform} account ${account?.handle??ref}: developer settings, then a private Terminal running actas secret set`: `ActAs ${platform} ${action==='signup'?'signup':'sign-in'} window for ${ref} at ${result.origin??result.humanRequest?.openedUrl}`;
+ const question=reason==='api_credentials'?`${actions[reason]}.`:`${actions[reason]??actions.provider_policy} in the ActAs ${action==='signup'?'signup':'sign-in'} window.`;
+ const resumeHandle=result.resumeToken?{tool:name,arguments:{accountRef:ref,resumeToken:result.resumeToken}}:name==='actas_account_connect'?{tool:account?.method==='browser'?'actas_account_signup':name,arguments:account?.method==='browser'?{accountRef:ref}:{...args}}:undefined;
+ return {...result,kind:'action',question,where,
+  why:`${action==='signup'?'Signup':action==='login'?'Sign-in':'Account connection'} for ${platform} account ${ref}${account?.product?` (product ${account.product})`:''} is paused until a person completes this step.`,
+  brianOnly:true,humanStepId:JSON.stringify([account?.workspace,account?.product,ref,result.flowId??'connect',reason,result.flowId?result.humanRequest?.createdAt:null]),
+  ...(resumeHandle?{resumeHandle}:{})};
+}
+
+// The caller cannot supply argv. Only owner-registered exact arguments execute.
+export async function runAccountCommand(consumer,env,spawnChild){
+ const {childEnvironment}=await import('./vault.mjs');
+ spawnChild??=(await import('node:child_process')).spawn;
+ if(!consumer||typeof consumer.executable!=='string'||!consumer.executable.startsWith('/')||!/^[a-f0-9]{64}$/.test(consumer.contentHash)||!Array.isArray(consumer.args)||consumer.args.some(x=>typeof x!=='string'||x.includes('\0')))throw Error('Invalid registered consumer.');
+ if(!env||typeof env!=='object'||Object.values(env).some(x=>typeof x!=='string'||x.includes('\0'))||'ACTAS_BROWSER_STATE' in env)throw Error('Invalid private session.');
+ const {open,mkdtemp,writeFile,rm}=await import('node:fs/promises'),{createHash}=await import('node:crypto'),{tmpdir}=await import('node:os'),{join}=await import('node:path');
+ const binary=await open(consumer.executable,'r');let directory;
+ try{
+  const stat=await binary.stat();if(!stat.isFile()||stat.size>100*1024*1024||stat.mode&0o022)throw Error('Consumer binary must not be writable by its group or others.');
+  const bytes=await binary.readFile();if(createHash('sha256').update(bytes).digest('hex')!==consumer.contentHash)throw Error('Registered consumer changed.');
+  // Execute a private verified snapshot: replacing the registered path cannot
+  // substitute code between validation and exec (portable to macOS).
+  directory=await mkdtemp(join(tmpdir(),'actas-consumer-'));
+  const executable=join(directory,'consumer');await writeFile(executable,bytes,{mode:0o500,flag:'wx'});
+  return await new Promise((resolve,reject)=>{
+   let child;try{child=spawnChild(executable,consumer.args,{env:{...childEnvironment(),...env},shell:false,stdio:'ignore'});}catch{reject(Error('Account consumer could not start.'));return;}
+   const timer=setTimeout(()=>child.kill('SIGKILL'),30000);
+   child.once('error',()=>{clearTimeout(timer);reject(Error('Account consumer could not start.'));});
+   child.once('exit',code=>{clearTimeout(timer);resolve({status:code===0?'succeeded':'failed'});});
+  });
+ }finally{await binary.close();if(directory)await rm(directory,{recursive:true,force:true});}
+}
+// Same contract as the SDK's vault.login: username/email, password and a current TOTP code, never the seed.
+export async function vaultLogin(request,scope,path){
+ const read=body=>request('/vault/read','POST',{...scope,path,...body});
+ const entry=await read({action:'read'});if(entry.kind!=='login')throw Error('Not a login item.');
+ const field=async name=>(await read({action:'reveal',field:name})).value||null;
+ const [username,email,password]=await Promise.all([field('username'),field('email'),entry.login?.hasPassword?field('password'):null]);
+ const totp=entry.login?.hasTotp?await read({action:'totp:code'}):null;
+ return {path,username,email,password,totp:totp?{code:totp.code,secondsRemaining:totp.secondsRemaining}:null};
+}
+export function createAccountsRuntime({request,codesRequest=request,scope,identityId,browserAdapter,spawnChild,runConsumer,values=new PrivateValues()}){
+ const call=(route,body={})=>request('/account-tools'+route,'POST',{...body,...scope});
+ const inbox=args=>waitForInbox(args,request,values);
+ const flows=new Map();
+ async function saveReport(report){
+  const state=flows.get(report.flowId);if(!state||state.accountRef!==report.accountRef||state.uncertain)throw Error('Flow must be reconciled before reporting.');
+  const key=JSON.stringify(report);if(state.lastReport===key)return state.latest;
+  if(state.saving)throw Error('Flow report already in flight.');state.saving=true;
+  try{
+   state.latest=await call('/flow/report',{accountRef:state.accountRef,flowId:report.flowId,report,...(state.resumeToken?{resumeToken:state.resumeToken}:{})});
+   state.resumeToken=state.latest.resumeToken;state.lastReport=key;return state.latest;
+  }catch(error){state.uncertain=true;throw error;}finally{state.saving=false;}
+ }
+ const adapterOptions={request:(route,method,body)=>request(route,method,body===undefined?undefined:{...body,...scope}),scope,saveReport,waitForInbox:inbox,consumePrivateValue:handle=>values.consume(handle)};
+ async function flow(action,args){
+  // Without an installed browser adapter do not create a dispatched operation.
+  const account=await call('/status',{accountRef:args.accountRef});
+  if(account.status==='active'&&action==='signup')return {status:'complete',account,source:'saved_account'};
+  if(account.status==='active'&&account.method!=='browser')return call('/flow/start',{accountRef:args.accountRef,action});
+  if(!browserAdapter)return {status:'step',step:'inspect_form',reason:'browser_adapter_required',account};
+  const started=args.resumeToken?await call('/flow/resume',args):await call('/flow/start',{accountRef:args.accountRef,action});
+  if(!started.dispatch)return humanResult(flows.get(started.flowId)?.latest??started,`actas_account_${action}`,args,account,action);
+  const state={accountRef:args.accountRef};flows.set(started.flowId,state);
+  await browserAdapter.run({version:1,action:started.action??action,flowId:started.flowId,account:started.account,origin:started.origin,...(started.report?{report:started.report}:{})});
+  if(!state.latest)throw Error('Browser adapter did not persist its report.');
+  return humanResult(state.latest,`actas_account_${action}`,args,account,action);
+ }
+ return {adapterOptions,setBrowserAdapter(adapter){browserAdapter=adapter;},async invoke(name,args){
+  switch(name){
+   case 'actas_domains_list':return request('/domains?ownerId='+encodeURIComponent(scope.ownerId));
+   case 'actas_domains_add':return request('/domains','POST',{ownerId:scope.ownerId,domain:args.domain});
+   case 'actas_domains_verify':return request('/domains/'+encodeURIComponent(args.domain)+'/verify','POST',{});
+   case 'actas_domains_remove':return request('/domains/'+encodeURIComponent(args.domain),'DELETE');
+   case 'actas_identity_create':{
+    const {inbox,...fields}=args,identity=await request('/identities','POST',{...fields,...scope});if(!inbox)return identity;
+    const mailbox=await request('/identities/'+encodeURIComponent(identity.id)+'/email','POST',{});
+    return {...identity,inbox:{id:mailbox.id,address:mailbox.metadata?.address,status:mailbox.status}};
+   }
+   case 'actas_inbox_wait_for_code':{
+    const result=await codesRequest('/emails/'+encodeURIComponent(args.inboxId)+'/code','POST',{sender:args.sender,subject:args.subject,after:args.after,codePattern:args.pattern??'\\d{6}',timeoutMs:args.timeoutMs??30000});
+    return result.status==='matched'?{status:'matched',code:result.code,receivedAt:result.receivedAt}:{status:'pending'};
+   }
+   case 'actas_vault_login':return vaultLogin(request,scope,args.path);
+   case 'actas_totp_code':return request('/vault/read','POST',{...scope,path:args.path,action:'totp:code'});
+   case 'actas_identity_accounts':{const id=args.identityId??identityId;if(!id)throw Error('Choose an identity for this registry.');return request('/identities/'+encodeURIComponent(id)+'/accounts','GET');}
+   case 'actas_identity_account_close':{const result=await request('/identities/'+encodeURIComponent(args.identityId)+'/accounts/'+encodeURIComponent(args.registryId)+'/close','POST',args.revokeProvider===undefined?{}:{revokeProvider:args.revokeProvider});return {...result,accountStatus:result.status,...result.closure};}
+   case 'actas_account_list':return call('/list');
+   case 'actas_account_status':return call('/status',args);
+   case 'actas_account_connect':return humanResult(await call('/connect',args),name,args,undefined,'connect');
+   case 'actas_account_revoke':{const account=await call('/status',args),result=await call('/revoke',args);await browserAdapter?.revoke?.(account);return result;}
+   case 'actas_account_post':return call('/post',args);
+   case 'actas_account_signup':return flow('signup',args);
+   case 'actas_account_login':return flow('login',args);
+   case 'actas_account_use':{
+    if(Object.keys(args).some(k=>!['accountRef','consumerId'].includes(k))||!args.consumerId||!runConsumer)throw Error('An owner-registered consumer and isolated runtime are required.');
+    const handle=await call('/use',args);
+    const result=await runConsumer({...scope,accountRef:args.accountRef,sessionHandle:handle.sessionHandle});
+    return {status:result?.status==='succeeded'?'succeeded':'failed'};
+   }
+   case 'actas_inbox_wait_for':return inbox(args);
+   default:throw Error('Unknown account tool.');
+  }
+ }};
+}

package/client/accounts-mcp.mjs

@@ -0,0 +1,48 @@
+#!/usr/bin/env node
+import {StdioServerTransport} from '@modelcontextprotocol/sdk/server/stdio.js';
+import {z} from 'zod';
+import {pathToFileURL} from 'node:url';
+import {readIdentityConnection,identityRequest} from './identity.mjs';
+import {createAccountsRuntime} from './accounts-mcp-core.mjs';
+import {PrivateValues,validateInboxArgs} from './accounts-inbox.mjs';
+import {createBrowserAdapter} from './browser-adapter.mjs';
+import {request as socketRequest} from 'node:http';
+import {readFile} from 'node:fs/promises';
+
+export {createAccountsMcp} from './accounts-server.mjs';
+import {createAccountsMcp} from './accounts-server.mjs';
+const ref=z.string().regex(/^[A-Za-z0-9_-]{1,80}$/);
+export async function main(){
+ if(process.argv.includes('--help')||process.argv.includes('-h')){
+  process.stdout.write('ActAs MCP — identity, email and scoped accounts for AI agents.\nRequires Node.js 22+ and ActAs Pro (US$12/month or US$120/year).\nSet ACTAS_CONNECTION_FILE to your private identity connection JSON file.\nStart actas-accounts-mcp from a stdio MCP client.\nDocumentation: https://actas.dev/docs\n');return;
+ }
+ const connection=await readIdentityConnection(),request=(route,method='GET',body)=>identityRequest(connection,route,method,body);
+ const identity=connection.kind==='management'?null:await request('/identities/'+connection.identityId);
+ const scope={ownerId:identity?.ownerId??connection.ownerId,productId:identity?identity.productId:process.env.ACTAS_PRODUCT_ID??null};
+ // Trusted operator configuration contains selectors/inbox filters, never credentials or executable code.
+ let browserOptions={};
+ if(process.env.ACTAS_BROWSER_CONFIG_FILE){
+  const raw=await readFile(process.env.ACTAS_BROWSER_CONFIG_FILE,'utf8');if(raw.length>65536)throw Error('Browser configuration too large.');
+  browserOptions=JSON.parse(raw);
+  if(!browserOptions||Array.isArray(browserOptions)||Object.keys(browserOptions).some(k=>!['stateDir','emailRules'].includes(k))||browserOptions.stateDir!==undefined&&(typeof browserOptions.stateDir!=='string'||!browserOptions.stateDir))throw Error('Invalid browser configuration.');
+  const rules=browserOptions.emailRules??{};
+  if(!rules||typeof rules!=='object'||Array.isArray(rules))throw Error('Invalid email rules.');
+  for(const [accountRef,rule] of Object.entries(rules)){
+   ref.parse(accountRef);
+   if(!rule||typeof rule!=='object'||Array.isArray(rule)||Object.keys(rule).some(k=>!['selector','submitSelector','match'].includes(k))||typeof rule.selector!=='string'||!rule.selector||rule.selector.length>1024||typeof rule.submitSelector!=='string'||!rule.submitSelector||rule.submitSelector.length>1024)throw Error('Invalid email rule.');
+   validateInboxArgs(rule.match);
+  }
+ }
+ // Codes connections hold only emails:codes, so they ride alongside the main connection.
+ const codes=process.env.ACTAS_CODES_CONNECTION_FILE?await readIdentityConnection(process.env.ACTAS_CODES_CONNECTION_FILE):null;
+ const codesRequest=codes?(route,method='GET',body)=>identityRequest(codes,route,method,body):request;
+ const values=new PrivateValues(),runtime=createAccountsRuntime({request,codesRequest,scope,identityId:connection.identityId,values,runConsumer:process.env.ACTAS_RUNTIME_SOCKET?body=>new Promise((resolve,reject)=>{const req=socketRequest({socketPath:process.env.ACTAS_RUNTIME_SOCKET,path:'/use',method:'POST',timeout:35000},res=>{let raw='';res.on('data',b=>{raw+=b;if(raw.length>1024)req.destroy();});res.on('end',()=>{try{resolve(JSON.parse(raw));}catch{reject(Error('Runtime unavailable'));}});});req.on('error',()=>reject(Error('Runtime unavailable')));req.on('timeout',()=>req.destroy());req.end(JSON.stringify(body));}):undefined});
+ const adapter=createBrowserAdapter({...browserOptions,...runtime.adapterOptions});runtime.setBrowserAdapter(adapter);
+ const server=createAccountsMcp(runtime);
+ let closing;
+ const close=()=>closing??=Promise.resolve().then(async()=>{await adapter.close();await server.close();}).catch(()=>{});
+ server.server.onclose=()=>{void close();};
+ for(const signal of ['SIGINT','SIGTERM'])process.once(signal,()=>{void close();});
+ await server.connect(new StdioServerTransport());
+}
+if(process.argv[1]&&import.meta.url===pathToFileURL(process.argv[1]).href)main().catch(()=>{process.stderr.write('ActAs accounts MCP could not start. Verify the private connection file and account permissions.\n');process.exitCode=1;});

package/client/accounts-registry.mjs

@@ -0,0 +1,25 @@
+import {readIdentityConnection,identityRequest} from './identity.mjs';
+export const registryHelp=`ActAs — identity accounts registry
+  actas accounts list [identity-id]
+  actas accounts close <registry-id> [identity-id] [--revoke-provider]
+  actas accounts retire <identity-id> --confirm-retire
+Owners and management may close. Agents list only granted records.
+Close erases ActAs credentials; follow the returned external-deletion checklist.
+`;
+export async function runRegistryCommand(args){
+ if(args[0]!=='accounts')return false;
+ try{
+  const [,action,...raw]=args;
+  const revokeProvider=raw.includes('--revoke-provider');
+  if(revokeProvider&&(action!=='close'||raw.filter(v=>v==='--revoke-provider').length!==1))throw Error(registryHelp);
+  const rest=raw.filter(v=>v!=='--revoke-provider');
+  if(!['list','close','retire'].includes(action)||action==='list'&&rest.length>1||action==='close'&&(rest.length<1||rest.length>2)||action==='retire'&&(rest.length!==2||rest[1]!=='--confirm-retire'))throw Error(registryHelp);
+  const connection=await readIdentityConnection();
+  const identity=action==='list'?rest[0]??connection.identityId:action==='close'?rest[1]??connection.identityId:rest[0];
+  if(!identity)throw Error('Management connections must select an identity ID.');
+  const base='/identities/'+encodeURIComponent(identity)+'/accounts';
+  const result=await identityRequest(connection,action==='list'?base:action==='close'?base+'/'+encodeURIComponent(rest[0])+'/close':base+'/retire',action==='list'?'GET':'POST',action==='list'?undefined:action==='close'?(revokeProvider?{revokeProvider:true}:{}):{confirm:'RETIRE ACCOUNTS'});
+  process.stdout.write(JSON.stringify(action==='close'?{...result,accountStatus:result.status,...result.closure}:result,null,2)+'\n');
+ }catch{process.stderr.write('Accounts registry request failed. Check identity, permissions and command arguments; refresh the list before retrying an uncertain close.\n');process.exitCode=1;}
+ return true;
+}

package/client/accounts-runtime.mjs

@@ -0,0 +1,36 @@
+/** Owner-operated service. Run under a dedicated OS account; its config and
+ * credentials must be inaccessible to the agent user. Socket grants operation only. */
+import {createServer} from 'node:http';
+import {readFile,lstat,chmod,unlink} from 'node:fs/promises';
+import {runAccountCommand} from './accounts-mcp-core.mjs';
+export function createConsumerService({connection,runtimeCredential,scope,consumers=[],fetcher=fetch,execute=runAccountCommand}){
+ let busy=false;
+ return createServer(async(req,res)=>{
+  const reply=status=>{res.writeHead(200,{'Content-Type':'application/json'});res.end(JSON.stringify({status}));};
+  if(req.method!=='POST'||req.url!=='/use'||busy){reply('failed');return;}
+  busy=true;
+  try{
+   let raw='';for await(const chunk of req){raw+=chunk;if(raw.length>2048)throw Error();}
+   const body=JSON.parse(raw);
+   if(Object.keys(body).some(k=>!['ownerId','productId','accountRef','sessionHandle'].includes(k))||body.ownerId!==scope.ownerId||body.productId!==scope.productId||typeof body.accountRef!=='string'||typeof body.sessionHandle!=='string')throw Error();
+   const response=await fetcher(connection.apiUrl+'/api/v1/account-tools/session/consume',{method:'POST',redirect:'error',headers:{Authorization:'Bearer '+connection.token,'X-ActAs-Runtime':runtimeCredential,'Content-Type':'application/json'},body:JSON.stringify(body),signal:AbortSignal.timeout(15000)});
+   if(!response.ok)throw Error();const {data}=await response.json();
+   const consumer=consumers.find(pin=>pin.id===data.consumer?.id&&pin.accountRef===body.accountRef);
+   if(!consumer||consumer.executable!==data.consumer.executable||consumer.contentHash!==data.consumer.contentHash||JSON.stringify(consumer.args)!==JSON.stringify(data.consumer.args))throw Error();
+   const allowed=new Set(['GH_TOKEN','BLUESKY_ACCESS_JWT','BLUESKY_HANDLE','BLUESKY_DID','BLUESKY_SERVICE','REDDIT_ACCESS_TOKEN','REDDIT_USERNAME']);
+   if(!data.env||typeof data.env!=='object'||Array.isArray(data.env)||Object.keys(data.env).some(k=>!allowed.has(k)))throw Error();
+   const result=await execute(consumer,data.env);reply(result.status==='succeeded'?'succeeded':'failed');
+  }catch{reply('failed');}finally{busy=false;}
+ });
+}
+if(process.argv[1]&&import.meta.url===new URL('file://'+process.argv[1]).href){
+ const configPath=process.argv[2];
+ try{
+  const info=await lstat(configPath);if(!info.isFile()||info.isSymbolicLink()||info.uid!==process.getuid()||info.mode&0o077)throw Error();
+  const config=JSON.parse(await readFile(configPath,'utf8'));
+  if(!config.socket||!config.runtimeCredential||!config.scope||!config.connection||!Array.isArray(config.consumers)||!config.consumers.length)throw Error();
+  try{const socket=await lstat(config.socket);if(!socket.isSocket()||socket.uid!==process.getuid())throw Error();await unlink(config.socket);}catch(error){if(error.code!=='ENOENT')throw error;}
+  const server=createConsumerService(config);server.listen(config.socket,async()=>{await chmod(config.socket,0o660);});
+  for(const signal of ['SIGINT','SIGTERM'])process.once(signal,()=>server.close(async()=>{await unlink(config.socket);process.exit(0);}));
+ }catch{process.stderr.write('Private ActAs runtime configuration unavailable.\n');process.exitCode=1;}
+}

package/client/accounts-server.mjs

@@ -0,0 +1,34 @@
+import {McpServer} from '@modelcontextprotocol/sdk/server/mcp.js';
+import {z} from 'zod';
+
+const ref=z.string().regex(/^[A-Za-z0-9_-]{1,80}$/),path=z.string().regex(/^\/(?:[A-Za-z0-9_-]+\/)*[A-Za-z0-9_-]+$/).max(512);
+const select={accountRef:ref};
+export function createAccountsMcp(runtime){
+ const server=new McpServer({name:'actas-accounts',version:'0.1.0'},{maxToolInputElements:300});
+ const definitions=[
+  ['actas_identity_create','Create an identity with a permanently reserved chosen email name (management). inbox:true also allocates its inbox.',{name:z.string().min(1).max(80),localPart:z.string().min(3).max(40).optional(),domain:z.string().min(3).max(253).optional(),inbox:z.boolean().optional()}],
+  ['actas_inbox_wait_for_code','Wait up to 60s for one sign-in code from an authenticated sender (emails:codes). Returns only the code.',{inboxId:z.string().min(1).max(160),sender:z.string().email().max(254),subject:z.string().min(1).max(200),after:z.string().datetime(),pattern:z.string().regex(/^(?:\\d|\[A-Z0-9\])\{(?:[4-9]|1[0-2])\}$/).optional(),timeoutMs:z.number().int().min(0).max(60000).optional()}],
+  ['actas_vault_login','Return a granted login item: username/email, password and a current TOTP code. Never the TOTP seed (secrets:reveal plus read, reveal and totp:code grants).',{path}],
+  ['actas_domains_list','List workspace domains and exact DNS records (domain management).',{}],
+  ['actas_domains_add','Claim a workspace mail domain (domain management); reconcile by checking the same domain.',{domain:z.string().min(3).max(253)}],
+  ['actas_domains_verify','Check ownership, DKIM and MX and reconcile SES setup (domain management).',{domain:z.string().min(3).max(253)}],
+  ['actas_domains_remove','Permanently retire a domain and stop delivery (domain management).',{domain:z.string().min(3).max(253)}],
+  ['actas_totp_code','Return only a granted current six-digit TOTP code and seconds remaining.',{path}],
+  ['actas_account_list','List accounts granted to this product agent.',{}],
+  ['actas_identity_accounts','List this identity’s registry. Agents see only granted accounts.',{identityId:z.string().min(1).max(160).optional()}],
+  ['actas_identity_account_close','Remove all ActAs grants and saved login; return external-deletion checklist (owner/management).',{identityId:z.string().min(1).max(160),registryId:z.string().min(1).max(512),revokeProvider:z.boolean().optional()}],
+  ['actas_account_status','Read account status without exposing credentials.',select],
+  ['actas_account_connect','Connect and verify official API credentials saved in the product vault (owner/management).',{...select,platform:z.enum(['bluesky','github','reddit','x','instagram','discord']),handle:z.string().regex(/^[A-Za-z0-9_.-]+$/).max(120),email:z.string().email().max(254),identityId:z.string().min(1).max(160).optional(),secretRefs:z.record(z.enum(['token','appPassword','clientId','clientSecret','password','appId','installationId','privateKey']),path).optional()}],
+  ['actas_account_signup','Start or resume a saved account signup; pause for platform human checks.',{...select,resumeToken:z.string().max(160).optional()}],
+  ['actas_account_login','Start or resume login for a saved account.',{...select,resumeToken:z.string().max(160).optional()}],
+  ['actas_account_use','Run an owner-registered fixed consumer in the isolated ActAs runtime.',{...select,consumerId:z.string().uuid()}],
+  ['actas_account_post','Post through a fixed official API action without exposing credentials.',{...select,action:z.enum(['post','issue','submit','comment']),target:z.string().max(180).optional(),title:z.string().max(300).optional(),text:z.string().min(1).max(10000)}],
+  ['actas_account_revoke','Revoke future ActAs account use and pending handles (owner/management).',select],
+  ['actas_inbox_wait_for','Wait for a received verification message. Returns a private value handle; never the code/link.',{emailId:z.string().min(1).max(160),sender:z.string().email().max(254),subject:z.string().min(1).max(200),after:z.string().datetime(),linkOrigin:z.string().url().optional(),linkPath:z.string().max(1024).optional(),codePattern:z.string().max(30).optional(),timeoutMs:z.number().int().min(0).max(30000).optional()}]
+ ];
+ for(const [name,description,shape] of definitions)server.registerTool(name,{description,inputSchema:z.object(shape).strict()},async args=>{
+  try{const result=await runtime.invoke(name,args);return {content:[{type:'text',text:JSON.stringify(result)}]};}
+  catch{return {isError:true,content:[{type:'text',text:'ActAs account operation failed. Check account status and permissions before retrying; no automatic retry was made.'}]};}
+ });
+ return server;
+}

package/client/accounts.mjs

@@ -0,0 +1,130 @@
+import {createHash, randomUUID} from 'node:crypto';
+import {mkdir, open, readFile, rename, unlink} from 'node:fs/promises';
+import {homedir} from 'node:os';
+import {isAbsolute, join} from 'node:path';
+import {spawn} from 'node:child_process';
+
+const reasons = {
+  custodian_action_required: 'Chief must validate the broker request, perform the authorised fresh login in the operations browser, and return a nonsecret observation.',
+  broker_scope_denied: 'This broker only permits the assigned Infisical operations account login.',
+  authorization_required: 'The site can be inspected, but the account owner must assign this exact origin and account before credential entry or signup submission.',
+  verification_pending: 'Signup is saved. Resume after email verification; no duplicate account was requested.',
+  account_lookup_failed: 'The mapped existing account could not be retrieved. No signup or login was performed.',
+  registry_unavailable: 'The saved account registry could not be updated. Check the registry and connection before continuing; no browser credentials were delivered.',
+  vault_unavailable: 'The assigned development vault key could not be read. No browser credentials were delivered.',
+  helper_failed: 'The local credential-delivery helper could not start.',
+  browser_action_required: 'Continue the returned browser step, preserving required human handoffs and the operation ID.',
+  account_exists: 'This development profile maps an existing account. Use login; creating a new account is not enabled for this profile.',
+  integration_not_configured: 'No browser account driver is configured. Signup/login has not been performed.',
+  human_credential_entry: 'The browser requires a person to enter and submit credentials. Resume after that step.',
+  mfa: 'The service requires a human authentication step.',
+  captcha: 'The service requires a human verification step.',
+  provider_policy: 'The service requires a human approval or onboarding step.',
+  unsupported_site: 'The configured driver does not support this website.',
+  unverified: 'The driver did not verify a successful signup/login at the requested origin.',
+  driver_failed: 'The account driver failed. Its raw output was withheld because it may contain credentials.',
+  driver_timeout: 'The account driver timed out. Progress is retained; completion is unknown.',
+};
+
+export function targetUrl(input) {
+  let url;
+  try {url = new URL(input);} catch {throw new Error('Provide a full website URL, such as https://example.com.');}
+  if (url.protocol !== 'https:' && !(url.protocol === 'http:' && ['localhost','127.0.0.1','[::1]'].includes(url.hostname))) {
+    throw new Error('Use HTTPS, or loopback HTTP for a local test service.');
+  }
+  if (url.username || url.password || url.search || url.hash) {
+    throw new Error('Use a public website URL without credentials, query parameters or fragments.');
+  }
+  return url;
+}
+
+async function save(path, state) {
+  const temp = `${path}.${randomUUID()}.tmp`;
+  const file = await open(temp, 'wx', 0o600);
+  try {await file.writeFile(JSON.stringify(state, null, 2)+'\n');} finally {await file.close();}
+  await rename(temp, path);
+}
+
+function runDriver(executable, request, timeoutMs) {
+  return new Promise(resolve => {
+    // A trusted, explicitly configured driver. No shell or inherited provider keys.
+    const env = Object.fromEntries(['PATH','HOME','TMPDIR','TEMP','SYSTEMROOT'].filter(k=>process.env[k]).map(k=>[k,process.env[k]]));
+    const child = spawn(executable, [], {shell:false, env, stdio:['pipe','pipe','pipe']});
+    let stdout = ''; let oversized = false; let timedOut = false;
+    const timer = setTimeout(()=>{timedOut=true;child.kill('SIGKILL');}, timeoutMs);
+    child.stdout.on('data', chunk => {stdout += chunk.toString();if(Buffer.byteLength(stdout)>65536){oversized=true;child.kill('SIGKILL');}});
+    child.stderr.resume(); // Never forward driver output: it can contain secrets.
+    child.stdin.on('error',()=>{});
+    child.on('error',()=>{clearTimeout(timer);resolve({status:'failed',reason:'driver_failed'});});
+    child.on('close',code=>{
+      clearTimeout(timer);
+      if(timedOut)return resolve({status:'blocked',reason:'driver_timeout'});
+      if(code!==0||oversized)return resolve({status:'failed',reason:'driver_failed'});
+      try {resolve(JSON.parse(stdout));} catch {resolve({status:'failed',reason:'driver_failed'});}
+    });
+    child.stdin.end(JSON.stringify(request)+'\n');
+  });
+}
+
+export async function accountFlow(action, input, options={}) {
+  if(!['signup','login'].includes(action))throw new Error('Choose signup or login.');
+  const url = targetUrl(input);
+  const stateDir = options.stateDir || process.env.ACTAS_STATE_DIR || join(homedir(),'.local','state','actas','accounts');
+  const driver = options.driver ?? process.env.ACTAS_ACCOUNT_DRIVER;
+  if(driver && !isAbsolute(driver))throw new Error('ACTAS_ACCOUNT_DRIVER must be an absolute path to a trusted executable.');
+  await mkdir(stateDir,{recursive:true,mode:0o700});
+  // Paths share an operation only within the selected origin/account pair.
+  const accountRef=options.accountRef;
+  if(accountRef!==undefined&&(typeof accountRef!=='string'||!accountRef))throw new Error('A nonempty account reference is required.');
+  const key = createHash('sha256').update(accountRef===undefined?url.origin:JSON.stringify([url.origin,accountRef])).digest('hex');
+  const path = join(stateDir,`${action}-${key}.json`);
+  const lockPath = join(stateDir,`${key}.lock`);
+  let lock;
+  try {lock = await open(lockPath,'wx',0o600);} catch(error) {
+    if(error.code==='EEXIST')return {status:'blocked',action,origin:url.origin,reason:'operation_in_progress',message:'An account operation is already running for this website. No second operation was started.',exitCode:2};
+    throw error;
+  }
+  try {
+    await lock.writeFile(JSON.stringify({pid:process.pid,startedAt:new Date().toISOString()}));
+    let previous;
+    try {previous=JSON.parse(await readFile(path,'utf8'));} catch(error) {if(error.code!=='ENOENT')throw new Error('Saved operation state could not be read. It was not replaced.');}
+    if(previous && (previous.version!==1 || previous.action!==action || previous.origin!==url.origin || previous.accountRef!==accountRef || typeof previous.flowId!=='string'))throw new Error('Saved operation state does not match this request. It was not replaced.');
+    if(action==='signup' && previous?.status==='succeeded'&&!options.revalidateSignup)return {...receipt(previous),reused:true,exitCode:0};
+    const state = previous && (previous.status!=='succeeded'||action==='signup'&&options.revalidateSignup) ? previous : {version:1,flowId:randomUUID(),action,origin:url.origin,...(accountRef?{accountRef}:{}),url:url.href,createdAt:new Date().toISOString()};
+    state.updatedAt=new Date().toISOString();
+    state.status='pending';
+    delete state.verification;
+    delete state.reason;
+    await save(path,state); // Preserve the request before any external work.
+    let result;
+    if(options.execute)result=await options.execute(state);
+    else if(!driver)result={status:'blocked',reason:'integration_not_configured'};
+    else result=await runDriver(driver,{version:1,flowId:state.flowId,action,url:state.url,origin:state.origin,...(accountRef?{accountRef}:{}),requirements:{respectBrowserHumanTakeover:true,credentialsOutsideOutput:true,verifyAtRequestedOrigin:true}},options.timeoutMs||60000);
+    if(result?.status==='succeeded' && result.verification?.origin===url.origin && result.verification?.authenticated===true && ['authenticated_page','provider_api'].includes(result.verification?.method)) {
+      state.status='succeeded';
+      state.verification={origin:url.origin,authenticated:true,method:result.verification.method,...(result.verification.source==='authorised_caller_observation'?{source:result.verification.source}:{}),...(options.execute&&result.verification.custody==='chief-caller'?{custody:'chief-caller'}:{})};
+    } else {
+      state.status=result?.status==='needs_custodian'?'needs_custodian':result?.status==='needs_browser'?'needs_browser':result?.status==='needs_human'?'needs_human':result?.status==='blocked'?'blocked':'failed';
+      state.reason=Object.hasOwn(reasons,result?.reason)?result.reason:result?.status==='succeeded'?'unverified':'driver_failed';
+    }
+    if(result?.status==='needs_browser'&&options.execute)state.browser=result.browser;else delete state.browser;
+    if(options.execute && result?.brokerRequest)state.brokerRequest=result.brokerRequest;else delete state.brokerRequest;
+    if(options.execute && result?.progress)state.progress=result.progress;else delete state.progress;
+    state.updatedAt=new Date().toISOString();
+    await save(path,state);
+    return {...receipt(state),exitCode:state.status==='succeeded'?0:state.status==='failed'?1:2};
+  } finally {
+    await lock.close();
+    await unlink(lockPath);
+  }
+}
+
+function receipt(state) {
+  return {action:state.action,origin:state.origin,...(state.accountRef?{accountRef:state.accountRef}:{}),flowId:state.flowId,status:state.status,
+    ...(state.reason?{reason:state.reason,message:reasons[state.reason]}:{}),
+    ...(state.verification?{verification:state.verification}:{}),
+    ...(state.browser?{browser:state.browser}:{}),
+    ...(state.progress?{progress:state.progress}:{}),
+    ...(state.brokerRequest?{brokerRequest:state.brokerRequest}:{}),
+  };
+}

package/client/browser/providers.mjs

@@ -0,0 +1,51 @@
+// First-party browser fallback. Challenge fields and policy buttons are observed
+// only. Trusted credential references may be filled on the exact assigned origin.
+const visible = async (page, selector) => page.locator(selector).first().isVisible().catch(() => false);
+export async function detectHumanStep(page) {
+  for (const frame of page.frames()) {
+    if (/recaptcha|hcaptcha|challenges\.cloudflare|arkoselabs|funcaptcha/.test(frame.url())) {
+      const element = await frame.frameElement().catch(() => undefined);
+      if (element && await element.isVisible()) return 'captcha';
+    }
+  }
+  if (await visible(page, 'input[autocomplete="one-time-code"], input[name="verificationCode"], input[name="challenge_response"]')) return 'mfa';
+  if (await visible(page, 'input[type="tel"], input[name="phone_number"]')) return 'phone';
+  return undefined;
+}
+export function createBrowserProviders({credentials, emailRules = {}} = {}) {
+  function provider(origins, entry, profileSelector, username, password, next, submit) {
+    const verify = async (page, account) => {
+      const handle = account.handle?.replace(/^@/, '');
+      if (!origins.includes(new URL(page.url()).origin) || !/^[A-Za-z0-9_.]{1,80}$/.test(handle)) return false;
+      return visible(page, profileSelector(handle));
+    };
+    return {origins, entry, verify,
+      async observe(page, account, action) {
+        if (!origins.includes(new URL(page.url()).origin)) return {kind:'human',reason:'provider_policy',id:'unexpected_origin'};
+        const reason = await detectHumanStep(page);
+        if (reason === 'captcha' || reason === 'phone') return {kind:'human',reason};
+        if (reason) return {kind:'human',reason};
+        if (await verify(page, account)) return {kind:'authenticated'};
+        const hasUsername=await visible(page,username), hasPassword=await visible(page,password);
+        // Signup has provider-specific policy/age/name requirements; do not
+        // silently consent or invent a person's details.
+        if (hasUsername || hasPassword) return {kind:'human',reason:'human_credential_entry'};
+        // Let client-rendered form/navigation arrive before asking a person to
+        // review an unknown page. Waiting is observation, never a login retry.
+        try { await page.locator(`${username}, ${password}, ${profileSelector(account.handle?.replace(/^@/,'') || '')}`).first().waitFor({state:'visible',timeout:3000}); return {kind:'waiting'}; }
+        catch { return {kind:'human',reason:'provider_policy'}; }
+      },
+      async verifyEmail() { throw Error('Browser verification requires a human; automated entry is blocked.'); },
+      async advance() { throw Error('Browser credential entry requires a human; automated entry is blocked.'); },
+    };
+  }
+  return {
+    x: provider(['https://x.com'], {login:'https://x.com/i/flow/login',signup:'https://x.com/i/flow/signup'},
+      handle=>`a[data-testid="AppTabBar_Profile_Link"][href="/${handle}"]`,
+      'input[autocomplete="username"]','input[name="password"]','button:has-text("Next"), div[role="button"]:has-text("Next")','[data-testid="LoginForm_Login_Button"]'),
+    instagram: provider(['https://www.instagram.com'], {login:'https://www.instagram.com/accounts/login/',signup:'https://www.instagram.com/accounts/emailsignup/'},
+      handle=>`nav a[href="/${handle}/"] img[alt*="profile picture"], [role="navigation"] a[href="/${handle}/"] img[alt*="profile picture"]`,
+      'input[name="username"]','input[name="password"]','button[type="submit"]','button[type="submit"]'),
+  };
+}
+export const browserProviders = createBrowserProviders();