Skip to content

armgit / mso

Public Imported from GitHub
0

Browser-based graphical shell and control plane for a Linux server you own — real terminal, file manager, live metrics and BYOK AI in one mobile-first workspace. Next.js 16 · React 19 · node-pty · Tailwind v4 · shadcn/ui. Public alpha, self-hosted.

13.5 KB
Raw Blame
import { clearGoogleRuntime } from "./google-native-state";
import { isGoogleProvider, GOOGLE_APP_PROVIDER } from "./google-native-config";
import { variableKey, assertNoVariableReferences } from "./connection-variables";
import {connectionMethod} from "./connection-registry";
import { randomUUID } from "node:crypto";
import { mutateIntegrationState } from "./connection-storage";
import { createConnectionIn, summaryIn } from "./connection-service";
import { IntegrationError, identity, connectionLabel, canonicalFolder, selectConnection, metadataOnly, assertNotBusy, type ConnectionSource } from "./identity";
import { createDemoCredential, listDemoCredentials, getDemoCredential, updateDemoCredential, deleteDemoCredential } from "./demo-credentials";
// Demo logins are agent-created, workspace-scoped throwaways, not API keys: they are
// CRUD'd through this same manager so an agent needs no second surface.
export const DEMO_ACTIONS=["demo.create","demo.list","demo.get","demo.update","demo.delete"] as const;
const DEMO_FIELDS:Record<string,string[]>={"demo.create":["cwd","email","password","label","site","notes"],"demo.list":["cwd"],"demo.get":["cwd","id"],"demo.update":["cwd","id","email","password","label","site","notes"],"demo.delete":["cwd","id"]};
/** The password is a real secret, so these actions run BEFORE metadataOnly: every
 *  other action keeps rejecting secret-shaped keys. */
export async function runDemoAction(action:string,input:Record<string,unknown>){
  const allowed=DEMO_FIELDS[action];if(!allowed)throw new IntegrationError("invalid_management_fields");
  if(Object.keys(input).some(k=>!["action","confirm",...allowed].includes(k)))throw new IntegrationError("invalid_management_fields");
  if(action!=="demo.list"&&action!=="demo.get"&&input.confirm!==true)throw new IntegrationError("confirmation_required",403);
  if(action==="demo.create")return createDemoCredential(input);
  if(action==="demo.list")return listDemoCredentials(input);
  if(action==="demo.get")return getDemoCredential(input);
  if(action==="demo.update")return updateDemoCredential(input);
  return deleteDemoCredential(input);
}
export const INTEGRATION_ACTIONS=["variable.set","variable.delete","user.create","user.rename","user.duplicate","user.delete","user.default","folder.map","folder.unmap","connection.create","connection.rename","connection.default","connection.delete","connection.share","connection.duplicate","connection.unshare","credential.delete",...DEMO_ACTIONS] as const;
export async function integrationManage(input:Record<string,unknown>){
  const requested=String(input.action);
  if((DEMO_ACTIONS as readonly string[]).includes(requested))return runDemoAction(requested,input);
  metadataOnly(input);if(input.confirm!==true)throw new IntegrationError("confirmation_required",403);
  const shapes:Record<string,string[]>={
    "variable.set":["key","user","provider","connection"],"variable.delete":["key"],
    "user.create":["user","label"],"user.rename":["user","target","label"],"user.duplicate":["user","target","label","copyCredentials"],"user.delete":["user"],"user.default":["user"],
    "folder.map":["user","path","provider","connection"],"folder.unmap":["path"],"connection.create":["user","provider","connection","label","source","authMethod","makeDefault"],
    "connection.rename":["user","provider","connection","label"],"connection.default":["user","provider","connection"],"connection.delete":["user","provider","connection"],"connection.share":["user","provider","connection","target","label","makeDefault"],"connection.duplicate":["user","provider","connection","target","targetConnection","label","copyCredentials","makeDefault"],"connection.unshare":["user","provider","connection"],"credential.delete":["user","provider","connection","key"],
  };
  const action=String(input.action);if(!shapes[action]||Object.keys(input).some(k=>!["action","confirm",...shapes[action]].includes(k)))throw new IntegrationError("invalid_management_fields");
  return mutateIntegrationState(state=>{
    if(action==="variable.set"||action==="variable.delete"){const key=variableKey(input.key);state.variables??={};if(action==="variable.delete")delete state.variables[key];else{const provider=identity(input.provider),user=identity(input.user),connection=identity(input.connection);selectConnection(state,provider,{user,connection});state.variables[key]={provider,user,connection};}return{ok:true,action,variables:state.variables};}
    if(action==="folder.unmap"){const p=canonicalFolder(String(input.path));state.bindings=state.bindings.filter(b=>b.path!==p);return{ok:true,action};}
    const user=identity(input.user,"user");
    if(action==="user.create"){
      if(Object.hasOwn(state.users,user))throw new IntegrationError("user_exists",409);
      state.users[user]={id:user,uid:randomUUID(),label:connectionLabel(input.label??user),connections:{},defaults:{}};if(!state.defaultUser)state.defaultUser=user;return{ok:true,action,user};
    }
    const profile=state.users[user];if(!profile)throw new IntegrationError("user_not_found",404);
    if(action==="user.default"){state.defaultUser=user;return{ok:true,action,user};}
    if(action==="user.delete"){
      assertNoVariableReferences(state,user);
      if(Object.values(state.users).some(u=>Object.values(u.connections).some(rows=>Object.values(rows).some(c=>c.sharedFrom?.user===user))))throw new IntegrationError("user_has_shared_dependents",409);
      Object.values(profile.connections).flatMap(Object.values).forEach(assertNotBusy);
      delete state.users[user];state.bindings=state.bindings.filter(b=>b.user!==user);if(state.defaultUser===user)state.defaultUser=null;return{ok:true,action,user};
    }
    if(action==="user.rename"||action==="user.duplicate"){
      const target=identity(input.target,"target");if(Object.hasOwn(state.users,target))throw new IntegrationError("user_exists",409);
      Object.values(profile.connections).flatMap(Object.values).forEach(assertNotBusy);
      const copy=structuredClone(profile);copy.id=target;
      // A duplicate must not retain an invisible dependency on a sharing owner.
      if(action==="user.duplicate")for(const rows of Object.values(copy.connections))for(const c of Object.values(rows))if(c.sharedFrom){const ref=c.sharedFrom,owner=state.users[ref.user]?.connections[ref.provider]?.[ref.connection];if(!owner)throw new IntegrationError("shared_backing_not_found",409);c.values={...owner.values};delete c.sharedFrom;}if(action==="user.duplicate")copy.uid=randomUUID();copy.label=connectionLabel(input.label??target);
      for(const rows of Object.values(copy.connections))for(const c of Object.values(rows)){clearGoogleRuntime(c);c.uid=randomUUID();c.revision++;c.updatedAt=Date.now();delete c.lease;if(action==="user.duplicate"&&input.copyCredentials!==true){c.values={};delete c.verifiedAt;}if(action==="user.duplicate"&&c.source!=="direct"){c.external=undefined;delete c.verifiedAt;}}
      state.users[target]=copy;
      if(action==="user.rename"){for(const ref of Object.values(state.variables??{}))if(ref.user===user)ref.user=target;delete state.users[user];for(const u of Object.values(state.users))for(const rows of Object.values(u.connections))for(const c of Object.values(rows))if(c.sharedFrom?.user===user)c.sharedFrom.user=target;for(const b of state.bindings)if(b.user===user)b.user=target;if(state.defaultUser===user)state.defaultUser=target;}
      return{ok:true,action,user:target};
    }
    if(action==="folder.map"){
      const p=canonicalFolder(String(input.path)),old=state.bindings.find(b=>b.path===p),connections=old?.user===user?{...old.connections}:{};
      if(input.provider||input.connection){const provider=identity(input.provider,"provider"),connection=identity(input.connection,"connection");selectConnection(state,provider,{user,connection});connections[provider]=connection;}
      state.bindings=state.bindings.filter(b=>b.path!==p);state.bindings.push({path:p,user,connections});return{ok:true,action,user,path:p};
    }
    const provider=identity(input.provider,"provider"),connection=identity(input.connection,"connection");
    if(action==="connection.create"){const c=createConnectionIn(state,{user,provider,connection,label:input.label as string|undefined,source:input.source as ConnectionSource|undefined,authMethod:input.authMethod as string|undefined,makeDefault:input.makeDefault===true});return{ok:true,action,connection:summaryIn(state,user,c)};}
    const {connection:c}=selectConnection(state,provider,{user,connection});assertNotBusy(c);
    if(action==="connection.duplicate"){
      if(c.sharedFrom)throw new IntegrationError("shared_alias_copy_from_owner",409);
      const target=identity(input.target,"target"),targetUser=state.users[target];if(!targetUser)throw new IntegrationError("user_not_found",404);
      const targetConnection=identity(input.targetConnection??connection,"target_connection"),rows=targetUser.connections[provider]??{};if(Object.hasOwn(rows,targetConnection))throw new IntegrationError("connection_exists",409);
      const clone=structuredClone(c);clone.id=targetConnection;clone.uid=randomUUID();clone.label=connectionLabel(input.label??c.label);clone.values=c.source==="direct"&&input.copyCredentials===true?{...c.values}:{};delete clone.sharedFrom;delete clone.external;delete clone.verifiedAt;delete clone.lastCheck;delete clone.lease;clearGoogleRuntime(clone);clone.revision=1;clone.createdAt=clone.updatedAt=Date.now();
      targetUser.connections[provider]={...rows,[targetConnection]:clone};if(input.makeDefault===true||!targetUser.defaults[provider])targetUser.defaults[provider]=targetConnection;return{ok:true,action,connection:summaryIn(state,target,clone)};
    }
    if(action==="connection.share"){
      if(isGoogleProvider(provider)||provider===GOOGLE_APP_PROVIDER)throw new IntegrationError("google_shared_authorization_not_supported",409);
      if(c.source!=="direct")throw new IntegrationError("external_connections_cannot_share",409);if(c.sharedFrom)throw new IntegrationError("shared_alias_cannot_share",409);
      const target=identity(input.target,"target"), targetUser=state.users[target];if(!targetUser)throw new IntegrationError("user_not_found",404);if(target===user)throw new IntegrationError("shared_alias_same_user",409);
      const rows=targetUser.connections[provider]??{},rawBase=String(input.label??connection).toLowerCase().replace(/[^a-z0-9]+/g,"-").replace(/^-+|-+$/g,"")||"shared",base=rawBase.slice(0,56),id=Array.from({length:100},(_,i)=>i?`${base.slice(0,61-String(i+1).length)}-${i+1}`:base).find(x=>!Object.hasOwn(rows,x));if(!id)throw new IntegrationError("connection_alias_limit",409);identity(id,"connection");
      const alias=structuredClone(c);alias.id=id;alias.uid=randomUUID();alias.label=connectionLabel(input.label??c.label);alias.values={};alias.sharedFrom={user,connection,provider};alias.revision++;alias.createdAt=Date.now();alias.updatedAt=Date.now();delete alias.lease;
      targetUser.connections[provider]={...rows,[id]:alias};if(input.makeDefault===true||!targetUser.defaults[provider])targetUser.defaults[provider]=id;return{ok:true,action,connection:summaryIn(state,target,alias)};
    }
    if(action==="connection.delete"||action==="connection.unshare")assertNoVariableReferences(state,user,provider,connection);
    if(action==="connection.unshare"){
      if(state.bindings.some(b=>b.user===user&&b.connections[provider]===connection))throw new IntegrationError("connection_has_folder_binding",409);
      if(!c.sharedFrom)throw new IntegrationError("connection_not_shared",409);delete profile.connections[provider][connection];if(profile.defaults[provider]===connection)delete profile.defaults[provider];return{ok:true,action,user,provider,connection};
    }
    if(c.sharedFrom&&action==="connection.delete")throw new IntegrationError("shared_alias_use_unshare",409);
    if(c.sharedFrom&&action==="credential.delete")throw new IntegrationError("shared_alias_readonly",409);
    if(action==="connection.default")profile.defaults[provider]=connection;
    if(action==="connection.rename"){c.label=connectionLabel(input.label);c.updatedAt=Date.now();}
    if(action==="connection.delete"){
      if(provider===GOOGLE_APP_PROVIDER&&Object.values(profile.connections).some(rows=>Object.values(rows).some(x=>isGoogleProvider(x.provider)&&x.values.appConnection===connection)))throw new IntegrationError("google_app_has_connections",409);
      if(Object.values(state.users).some(u=>Object.values(u.connections).some(rows=>Object.values(rows).some(x=>x.sharedFrom?.user===user&&x.sharedFrom.connection===connection&&x.provider===provider))))throw new IntegrationError("connection_has_shared_dependents",409);
      if(state.bindings.some(b=>b.user===user&&b.connections[provider]===connection))throw new IntegrationError("connection_has_folder_binding",409);
      if(Object.values(profile.connections).some(rows=>Object.values(rows).some(x=>x.source==="composio"&&x.external?.brokerConnection===connection&&provider==="composio")))throw new IntegrationError("broker_has_linked_connections",409);
      delete profile.connections[provider][connection];if(profile.defaults[provider]===connection)delete profile.defaults[provider];return{ok:true,action,user,provider,connection};
    }
    if(action==="credential.delete"){
      if(c.source!=="direct")throw new IntegrationError("external_secrets_forbidden");
      if(input.key!==undefined){const key=identity(input.key,"key");if(!connectionMethod(provider,c.source,c.authMethod).fields.some(f=>f.key===key))throw new IntegrationError("unknown_credential_field");delete c.values[key];}else c.values={};clearGoogleRuntime(c);c.revision++;delete c.verifiedAt;delete c.lastCheck;c.updatedAt=Date.now();
    }
    return{ok:true,action,connection:summaryIn(state,user,c)};
  });
}