Skip to Content

Work together

People and access

Invite people, give them roles in each workspace, and choose who's in each project.

Your instance is private: nobody signs in without an invitation. Each person then holds roles in each workspace they’re in, several or none, and together their roles decide what they can do there. Projects are opt-in: a person sees a project only once it lists one of their roles, or them by name, so a client sees their project and nothing else.

Invite someone

  1. Open the role on Access → Roles and people and press Invite to followed by its name, which starts the link with that role ticked. An instance administrator can also press Invite on Settings → Team.
  2. Under Link expires in, choose 1 day or 7 days.
  3. Under Workspace access, choose a workspace, then tick the roles the link gives there under Roles in that workspace. Each role shows its description under its name. Nothing is ticked at first, and each workspace needs at least one role: Create link stays off until it has one. Add workspace adds another.
  4. Press Create link. The new link shows above the role’s people (on Team, the Invitations tab opens with it on top); press Copy link. It’s shown once.
  5. Send the link yourself, by email, chat, or however you like. Nexul sends nothing.

A link works once and gives nothing but its roles. The Owner role is never offered, and a role holding more than you hold sits under Can’t give with what it holds that you don’t; ownership doesn’t move through an invitation. A role lists its links not used yet under Invited, below its people. Team’s Invitations tab lists the links not used yet under Active invitation links; Revoke invitation kills one.

Below them, Accepted in the last 30 days lists who each link let in, newest first: their name, the roles it gave, who made the link, when they accepted, and how far their setup got, the same line Team shows under them. Click one to open the person. Expired or deleted in the last 30 days lists the links that stopped working before anyone used them, whether they ran out, were revoked, or lost their role or their maker’s right to give it: what each gave, who made it and when, and when it ended.

What the person sees

Before they sign in, the page is titled with the workspace the link opens (“Join Northwind”, or “Join 2 workspaces”) and lists each workspace with the roles the link gives there and what each role means, then a Continue with button for each sign-in provider the instance has turned on. It names no project, so a link that reaches the wrong person shows only what the roles are. At the bottom it says the link works once and when it expires.

Once they sign in, each workspace shows how many projects its roles open right now (“Opens 2 projects”, or “Opens no projects yet”), and its card names them, such as “2 projects: Website relaunch, Mobile app”. Past eight names the rest fold into and N more. The page names the account they signed in with. Accept invitation puts them in each workspace with its roles and opens the instance. Decline leaves the link unused and goes to sign-in, which says the invitation was declined.

Signed in with the wrong account? Not you? beside the name goes back to the sign-in buttons for the same link, before anything is written.

A link is for someone without an account here. If a person who already has one opens it, signed in or by signing in with a provider account that belongs to them, the page says “You already have an account here” and lets them go to the instance. Not you? beside their name signs them out if they were signed in, and shows the sign-in buttons for the same link. Nothing is written: the link stays unused, so it still works for the person it was meant for. To give someone who’s already here a workspace, add them to a role (Give someone a role). A link that has run out or been revoked says only “This invitation has been deleted or has expired”: it doesn’t say which, names nobody, and tells no one.

Manage people

Settings → Team has two tabs. People lists everyone on the instance: a dot on each picture for who is online, when the others were last seen, the GitHub, Google or Discord marks of the accounts they sign in with, each beside its GitHub or Discord username, their roles as chips (three, then a count whose tooltip names the rest, or No roles) or how many workspaces they are in, and Disabled or Removed for an account that can’t sign in. Open a person to see one tab per workspace they’re in, each with their roles there as chips and View as. Roles aren’t changed here: Change on Access opens that workspace’s Roles and people (Give someone a role).

Setup progress

While someone hasn’t finished their Welcome wizard, a line under their name says how far they got: “2 of 3 set up”, then the first thing left (“computer not added”, “GitHub not connected +2” when more is left, or “hasn’t opened the wizard yet”), and the steps they skipped in muted text. Its dot is amber while a step is left and grey once only skips remain. The line is gone once every step is done, and never shows for a disabled or removed account. It names “not in a project yet” whenever the person is in no project, even when none of their roles gives that step, because adding them to one is yours to do. It updates on its own as they set things up.

Open the person for the detail. Under their name it says when they joined and who invited them. Welcome wizard lists each step left or skipped with why it isn’t done (“No paired computer with its setup confirmed”) or when they skipped it, and folds the done steps into one line.

Account actions apply at once, each after its own confirmation: Disable stops someone signing in and keeps their access, Reactivate lets them sign in again (its confirm says their computers stay disconnected), and Remove account removes them. Restore brings a removed account back with no workspace access. Disable and Remove account also disconnect the person’s computers: each one’s runner uninstalls itself, and you are told only that their computers were disconnected, never which ones. Reactivating or restoring the account brings none back; the person adds each computer again from their own settings.

A person with no role in a workspace stays a member. Opening it, they see No roles in that workspace, a line saying what that means, and its Owners, each a button that opens a direct message with them, which takes no role. Their sidebar shows no project; channels and direct messages show once they have some. They can read the public channels but not post in them, and their direct messages work as usual, so they can always message an Owner; posting in a channel takes a role that allows it.

Everyone sees their own roles in Settings → Profile → Your roles, one line per workspace, and the account row at the bottom of the sidebar lists them for the workspace in view.

Team takes accounts:read, and shows everyone on the instance.

Give someone a role

Roles are given from the role. Open Access → Roles and people and pick a role from the list on the left, where each shows its description and how many people hold it. The role’s page lists its People, each with when they were last seen and the other roles they hold, then what the role allows.

  • Add people lists everyone you can see who doesn’t hold the role, the workspace’s members first, then people Not in the workspace yet, whom picking also adds to it. Search narrows the list, and it stays open so you can add several in a row.
  • Invite to the role makes a link for someone without an account (Invite someone).
  • A person’s … menu takes the role from them, views Nexul as them (Check what someone can see), or removes them from the workspace, which asks first and takes every role they hold there; their account stays.

Each change saves at once and says so. If one is refused, the message names the person and the role. You can’t give a role holding more than you hold, or take one you couldn’t give: its page says why, with a lock, instead of offering Add people. The Owner role is never given or taken here.

No roles, under the roles, lists the members holding none, who see no projects or plays until a role is given from its own page. Giving and taking roles takes members:write in the workspace.

Check what someone can see

To see whether a person’s roles give them too much or too little, view Nexul as them. Choose View as followed by their first name from their … menu on a role’s page, or open the person on Settings → Team, pick the workspace’s tab, and press it there. Every page then shows what they see in that workspace: their projects, their channels, the buttons their roles allow. A bar across the top says who you’re viewing as, and stays until you stop.

Viewing as someone needs the View Nexul as another member permission in that workspace. You can’t view as yourself or as an Owner, who sees everything, and you can’t view as someone who holds a permission you don’t: Nexul says which one, since you couldn’t tell what it gives them.

A view is read only. A button the person can press is still there, but pressing it tells you changes are off, so nothing is done in their name. Live updates are off too: reload a page to see new changes. Their inbox, their devices and computers, and any direct message or private channel you aren’t in yourself are never shown, and neither are their other workspaces; a page that depends on them comes up empty.

Press Stop viewing in the bar to leave. You land back on the page you started from. Nexul also ends the view by itself, and tells you why, if the person’s roles change in a way that would no longer let you view them. Signing out ends it too.

Roles

Every workspace has an Owner role. It can’t be renamed, deleted, or limited: the Owner holds every permission, is in every project, and no rule can deny them. Every other role is yours to define in Access → Roles and people.

New role and a role’s Edit open the role editor, a dialog with the name at the top and Save at the bottom. A new role can Start from a copy of another role’s permissions and Welcome steps; the copy is yours to change and the other role stays as it is. Nothing is saved until Create role or Save, and closing with changes asks before it throws them away.

Under the name, Description holds one line on what someone with the role does, such as “Answers support tickets for the projects you’re added to.” It is shown on invitations and wherever someone picks roles. It holds up to 140 characters, and the count beside it turns amber with 20 left. A role without one shows its name alone; roles made before descriptions existed start without one, so write theirs when you next edit them.

A role sets one level per area: None, Read, Write, or Delete, each level including the ones before it. Plays’ first level is See. Some areas carry extra checkboxes under their name, such as docs’ Threads, Clone, and Lock, which need Read first (plays’ Run needs See). A few permissions are a plain yes or no, set with a switch at the top of their tab. The editor has three permission tabs, each with the number of areas and switches it allows, a dot while it holds unsaved changes (the footer counts them, such as 2 changes), and a top row that sets every area in it at once, leaving the switches as they are:

  • Instance: areas that apply across every workspace on this install, such as adding machines, DNS and gateways, connectors, accounts, the audit log, and the instance’s logs.
  • Workspace: across the workspace, whatever project someone is in. It leads with Show locked actions, a switch for the role and not a permission, then Create projects (projects:create) and Edit the workspace Interview template (memories:template), then areas such as chat, channels, plays, members, and roles.
  • In projects: a project’s areas, such as tickets, docs, memories and interview, and stacks, which a holder has only inside the projects they’re in. It leads with Manage this project’s access (projects:access): choosing who’s in a project and what they can do there.

Show locked actions decides what a holder sees where they can’t take an action. With it off, the action isn’t there. With it on, the action shows dimmed with the reason, such as “Your role can’t deploy”, so they can see what exists and which role would let them. Someone holding several roles sees locked actions when any one of them has it on. A new role starts with it off, a duplicate or clone keeps the original’s setting, and the Owner role never needs it. Something a person can’t read stays not found either way. It gives no permission, so anyone who can edit a role can change it.

A locked action keeps its place and its shape. A button loses its colour and gains a small lock, a menu row stays in order with the reason as a second line, and an editable value shows the reason when you point at it or tab to it. Clicking or pressing Enter does nothing. Something you can’t move simply doesn’t drag. The reason is one of two sentences. “Your role can’t deploy” says your roles don’t hold the permission. When a rule on that one thing decided it, the reason is that rule’s sentence instead, such as “Denied on stack api for bob”, so you can see who to ask. A stack, doc, play or project page reads these once for the item on screen, and they redraw when someone changes its rules or your roles.

Lists answer by role only. An action there that a rule on one row refuses is still shown, and pressing it shows a toast with the rule’s sentence rather than a bare “forbidden”. A person whose roles all have the switch off sees none of this: what they can’t do isn’t on the page. Machine rules work the same way on the Runners page.

A fourth tab, Welcome, switches on the Welcome wizard steps the role gives its holders. Switching one on asks everyone holding the role again, including anyone who skipped it.

Compare roles, under the roles on Access → Roles and people, shows every role side by side: one column per role, the Owner first, with how many people hold it under its name, and one row per area in the editor’s three sections, each cell the role’s level there (a +1 after it counts the extra checkboxes it holds) or Yes and No for a switch. A column’s … menu edits, duplicates (the copy is named Admin (copy)), clones to another workspace, or deletes it. Deleting a role someone holds asks first, saying how many people lose it, then takes it from them, along with the rules that name it and the pending invites that give it; someone left with no role stays a member and sees no project.

Nobody can hand out a permission they don’t hold: not in a role, a rule’s Allow, or an invitation, and can’t lift a Deny on one. Every permission is written <area>:<action>, such as docs:write, and the same names gate a person, a personal access token, an automation, and an agent.

Template roles

Five roles ship with Nexul as templates. Every new workspace, a fresh install’s first one included, starts with a copy of each beside its Owner, with the description, permissions and Welcome wizard steps the template holds when the workspace is created. From then on the copy belongs to the workspace: editing or deleting a template changes only workspaces created afterwards, and a workspace that existed before gets none. Projects are opt-in, so a copied role sees no project until a project lists it.

Template roleWhat it can doWelcome steps
ClientRead and write tickets, docs (with their threads) and attachments; read memoriesYour projects
Junior DeveloperThe same, plus read pull requests, code reviews, repositories, stacks and deploys with their logs, and see and run playsYour computer, Your projects
Senior DeveloperDelete in most project areas, write repositories, stacks and deploys, create projects, edit plays and auto plays, edit the Interview template, and read the topologyConnect GitHub, Your computer
DevOpsWrite tickets, docs, repositories, stacks and deploys, delete stacks, and deploy to, manage and delete machines, and edit the topologyAdd a deploy server
AdministratorEvery project and workspace permission plus deploying to, managing and deleting machines and editing the topology, except making or removing a workspace and the instance’s own administration, which stay with the OwnerConnect GitHub

All five can chat and use channels, voice, mentions, and notifications, and each ships with a one-line description, such as Client’s “Reads and writes the tickets and docs of the projects you’re added to.” Show locked actions is on for every template role except Client, so a new workspace’s developers see what they can’t do and its clients see only what they can.

Settings → Templates lists them on its Roles card, each with its levels, its Welcome steps, and whether it is the default or edited. A row’s … menu opens the same role editor as a workspace role, with its Instance, Workspace, In projects, and Welcome tabs. The five that ship have Reset to default and can’t be deleted. New template role adds one of your own, and its Delete removes it; workspaces that already have a copy keep theirs. Changing template roles takes templates:write.

Instance permissions

Some permissions cover the whole instance, not one workspace: instance settings and upgrades, accounts, adding machines, DNS, connectors, integrations, templates, and creating workspaces. Holding one in any workspace you’re in is enough. There’s no separate administrator: the instance Owner, the Owner of the default workspace, holds all of them. The Owner of another workspace is a full Owner inside it, and can still create workspaces, but holds the instance areas below only through a role or an area’s rule, like anyone else. Upgrading took these permissions off every role that had them, except topology, which on a role acts on that workspace’s own canvas; after an upgrade only the instance Owner holds them until a rule hands one out. Automations are not among them: automations:read, automations:write and automations:delete are workspace permissions and reach only the automations of the workspace the role is in.

To hand out one part of the instance without a custom role, such as letting bob manage DNS but not connectors, the instance Owner (the Owner of the default workspace) sets a rule on that instance area for a role or a person, the same Allow, Fallback and Deny as on a project. A role rule names a role of any workspace and reaches its holders. The areas and what each rule may set:

AreaKeyPermissions
The instance itself: its URL, upgrades, failed events, public addressinstanceinstance:read, instance:write, events:read
Sign-in providerssign_in_providersinstance:read, instance:write
Each connectorconnector:github, connector:cloudflare, connector:livekitconnectors:read, connectors:write
DNS and gatewaysdnsdns:read, dns:write, dns:delete
Instance templatestemplatestemplates:read, templates:write
Accountsaccountsaccounts:read, accounts:write, accounts:delete
Adding machinesmachinesmachines:create
The topology registrytopologytopology:read, topology:write, topology:delete
Integrationsintegrationsintegrations:read, integrations:write, integrations:delete
The audit logauditaudit:read
The instance’s logslogslogs:read

A person holds an area’s permission when one of their roles in any workspace grants it, unless a rule there says otherwise: between the rules for their roles Allow wins, and a rule naming them beats those. The instance Owner is never denied, so nobody can lock the instance away from them; the Owner of another workspace has no such protection here, and an area’s rules apply to them as to anyone. A rule on one area says nothing about another, so allowing connectors:read on GitHub leaves Cloudflare as their roles have it.

Only the instance Owner sees or changes these rules. In Settings, each instance entry ends with an Access card listing its areas: Instance, Team (accounts), Sign-in providers, DNS and Templates each show their own, Connectors has one row per connector on its Access tab, and the areas without an entry of their own (adding machines, the topology registry, integrations, the audit log, the instance’s logs) sit under Instance. Each row says whose rules it carries, and opens the permissions panel on that area: the roles of every workspace, each named with its workspace (“Member in Northwind”), and every account, with Check access showing a person’s answer for each permission and the rule or role it came from. A Deny on a read that a person or role holds today asks first, since a rule beats every role they hold and it may be their last way in.

To let sam manage DNS but not connectors: open Settings → DNS, then DNS and gateways in its Access card, add sam, set Read and Create and update to Allow, and save. Sam now sees DNS under Settings and nothing under Connectors, and Check access on sam reads “Allowed on DNS and gateways for sam” for both, and “Not allowed: role Member doesn’t grant it” for Delete. With the API:

PUT /api/permissions
{"resource_type": "instance_area", "resource_ids": ["dns"], "user_ids": ["<id>"], "actions": ["dns:read", "dns:write"], "state": "allow"}
GET /api/permissions?resource_type=instance_area&resource_id=dns

Machines

A machine carries rules of its own, like a project: a role of any workspace or a person, with See, Deploy to, Manage and Delete each at Allow, Fallback or Deny. See is held only through those rules, so a machine nobody has a rule on is seen by the instance Owner alone. The instance Owner and anyone holding Manage on a machine write its rules, from the people on its band on the Runners page. Add machines stays an instance permission, handed out on the machines area above. A machine’s automations hosts follow its rules too: you see a host when you see its machine, add or remove one with Manage, and place an automation on one with Deploy to, on top of automations:write in the automation’s workspace. See Where automations run.

Who’s in each project

Access in the sidebar’s Workspace section, between Automations and Configuration, is where you choose who’s in each project and what each role can do. It shows to anyone who can manage a project’s access (projects:access), edit roles (roles:write), or give them (members:write); the Owner sees every project, anyone else only the projects they’re in and manage. Its tabs are Projects, Roles and people and Public channels, each shown to the people who hold what it needs. Someone who manages no project sees Roles and people alone.

The Projects tab is a grid: one row per project, one column per role, with how many people hold each role under its name. Tick a role on a project and everyone holding it sees the project and everything in it; a ticked box is a check on a shaded cell, and a project with no ticks and no people is seen by Owners only. The Every project row ticks a role on every project at once, or clears it from all of them when every project already has it, and says how many projects have it, such as 9/15; past ten projects a filter narrows the rows, and the top row then acts on the rows shown. People, pinned to the right, names someone on a project whatever roles they hold: hover a row for the add button, which opens a list of the workspace’s people. The project names and the role names stay in view while the grid scrolls.

The grid is the whole workspace at a glance. For one project, its settings’ People in this project lists everyone in it, through which role or by name, and anyone kept out of it by name.

The Roles and people tab, between the two grids, is where you define what each role can do and give it to people: the same roles the grid uses as columns, so who holds a role, what it reaches and what it allows sit on one page. Defining roles takes roles:write, giving them members:write.

The Public channels tab is the Owner’s. Every member sees a public channel, so its cells start empty; click a role’s cell to hide that channel from everyone holding it, which shows a crossed-out eye there, and the Every channel row counts how many channels each role can’t see. Private channels keep their own members. A box here is the same rule as See this channel in the channel’s own permissions, where whoever holds channels:write also sets who posts in it.

A changed cell is outlined until you save, and the footer counts the changes, such as 3 changes. The grid tabs save from their own footers (the role editor saves on its own), and the change reaches everyone at once: a project someone was just listed in shows up in their sidebar without a reload. Leaving the page with unsaved ticks asks first.

After upgrading

The release that made projects opt-in wiped every per-person permission, so right after upgrading no project lists anyone and only Owners see projects. An Owner’s first visit to the workspace then opens Who’s in each project: the Projects grid and the Public channels grid on one page, and one Finish setup that saves both, with a Roles tab beside it to review or change what the roles allow first. Until an Owner finishes, the sidebar offers Owners Set up access to get back to it, and members see Projects being set up; any page that would show a project tells them their projects are on their way, and chat works as usual. Finish setup works with projects left empty: they stay Owners only until you list someone. Afterwards the page is the workspace’s Access page, which shows who finished the setup and when.

People in this project

A project they aren’t in, with everything in it, is not found for someone: lists, links, search and agents alike. Inside a project they’re in, their roles decide what they can do, and the project’s rules can change that for a role or a person.

A project’s Settings → Access holds People in this project, for whoever has Manage this project’s access there; nobody else sees the Access section:

  • Roles lists the roles it lets in, each with how many people hold it.
  • People lists the people with a rule of their own here.
  • Kept out lists the people a rule keeps out, whatever their roles.

Add a role or person lists one, which lets them in. Open a row to set what that role or person can do in the project. Remove in its ⋯ menu takes it off the project, along with every rule it holds there, after asking; on someone kept out, Let back in lets them back in. To keep someone out, open them and set See this project to Deny. A change reaches open browsers at once: a project opens in the sidebar of everyone a new role lets in, and drops out of the sidebar of someone kept out.

The project wizard’s Who’s in it step sets the same roles when you create a project. Deleting a project says how many people lose it before you confirm.

Permissions on a project, a folder, a doc or a play

Right-click a project in the sidebar’s switcher, a folder or a doc in the Docs list, or a play in Plays and pick Permissions…; a doc’s settings menu has it too, and each row of a project’s People in this project opens it. It shows only to someone who can change that project’s, folder’s, doc’s or play’s rules. The list on the left holds the roles, then the people, with a rule here; Add role or person lists another. A folder or a doc refuses a role or person who isn’t in its project, and says to add them to the project first.

Pick a role or a person to set its rule, one row per permission, each with three buttons:

  • Allow (check): they have it here, whatever their roles say.
  • Fallback (slash): this rule says nothing, so the answer comes from further out. The line under the row says what they get then, and from where; a project or role it names is a link to that project’s panel or that role’s rule.
  • Deny (cross): they don’t have it here, whatever their roles say.

A project carries See this project (being in it) and every project area; a folder and a doc carry the docs permissions and Manage this folder’s access or Manage this doc’s access; a play carries See this play, Run, Edit and Delete, and a play someone can’t see is gone from their lists, run menus and auto plays. Between the rules for a person’s roles, Allow wins, and a rule naming the person beats them.

A stack carries the stacks and deploys permissions; its rules reach its deploys and branch deployments, and a Deny of Read hides it, deploys included (see Who can see and deploy a stack).

A folder’s rules reach every doc in it. They sit between the project and the doc: a folder’s rule beats the project’s, and a doc’s own rule beats its folder’s, whichever role or person each names. Deny Read on a folder for a role and its docs drop out of that role’s lists, search and links, unless a doc’s own rule lets them back in. Moving a doc to another folder changes which folder’s rules reach it at once, and deleting a folder deletes its rules as its docs move to Main. The bin beside a role or person in the list takes them off, setting every row back to Fallback; press it, then press the check it turns into. Nothing changes until you press Save, and anyone else with the panel open sees the change without a refresh.

You can’t allow a permission you don’t hold on that project, folder, doc or play, or lift a Deny on one: its button shows a lock and says why. Adding a Deny is never limited. Check access shows what one person can do here, each answer with the rule or role that decided it.

Changing a project’s rules takes Manage this project’s access there, which its creator has; a folder’s takes Manage this folder’s access (permissions:write) on it; a doc’s takes Manage this doc’s access on it, which its creator has; a play’s takes plays:write.

Why someone can or can’t

Every answer has a source: the Owner role, the person’s roles, a rule on a project, a folder, a doc, a stack or a play for one of their roles or for them, or not being in the project. When Nexul refuses something you can see, the message names it, such as docs:write required (Denied on doc Pricing for bob) or tickets:write required (Not allowed: role Client doesn't grant it). Something you can’t see is not found and says nothing more, so it never confirms it exists.

To see every answer on one doc, folder, stack, play, project, or instance area at once, each with its source and the answer it would have without that entity’s own rule:

GET /api/permissions/explain?resource_type=doc&resource_id=<id>&user_id=<id>

Leave out user_id for your own answers, which take only being able to open it. role_id in its place answers for a role, as someone holding only that role would get them; the panel’s lines under a role’s Fallback come from it. Someone else’s, or a role’s, take managing it: permissions:write on a doc or folder, stacks:write on a stack, plays:write on a play, projects:access on a project, or being the instance Owner for an instance area (resource_type=instance_area&resource_id=dns). Agents ask the same with permission_overwrite_list and a user_id.

Names and pictures

Every member of a workspace sees its people’s login, display name, and picture, and of their roles only who is an Owner. Set your own name and picture in Settings → Profile; a change reaches everyone’s open screens without a refresh.

Sign-in accounts and GitHub

Settings → Profile lists the accounts you sign in with under Sign-in accounts. Link adds another provider to the same profile, and Unlink removes one, never your last.

Under Passkeys, Add a passkey saves one on this device, named after the browser and system it was made on; sign in with it from the sign-in page with Sign in with a passkey, which uses your fingerprint, face, PIN or security key instead of a provider. Passkeys work alongside your linked accounts, never instead of them, so you always keep at least one linked account. When the instance uses single sign-on as its only sign-in, an instance Owner’s passkey is the one that still works. They need Nexul on an https address, and each one signs in only on the domain it was made for: after the instance moves to a new domain its old passkeys are marked Made for another domain, and you remove them and add new ones. Rename and Remove manage each passkey; there is no MCP tool for them, since making or using one needs your device.

Under GitHub, the same page shows whether your own GitHub account lists your repositories: Connected with your GitHub login, Reconnect needed after GitHub refused to refresh it, or Not connected. Signing in with GitHub connects it. If you sign in with Google or Discord, Connect GitHub runs GitHub’s sign-in and links it to this profile; a GitHub account already linked to someone else is refused. Disconnect forgets the token, and unlinking your GitHub sign-in does too. Nexul lists repositories only with your own GitHub, never with someone else’s or the instance’s; see GitHub App.

Over MCP

Agents manage people with account_list (each person’s roles per workspace), account_update, invitation_create, invitation_list, invitation_delete, role_update, role_delete, and the permission_overwrite_* tools. role_update takes description and show_locked_actions beside the name, permissions and welcome_steps, and workspace_list returns both on each role. account_update gives and takes away roles per workspace with add_roles and remove_roles, and invitation_create takes roles per workspace, at least one; neither sets anything per person. account_list also returns each person’s welcome progress and joined, the invitation that let them in, and invitation_list with state accepted or ended lists the links accepted, or expired or revoked, in the last 30 days. permission_overwrite_update sets a state of allow, fallback, or deny for people (user_ids) or roles (role_ids) on a doc, folder, stack, play, project, channel, or instance area (a folder’s ids are project_get’s doc_folders, a stack’s stack_list’s): allowing projects:open on a project lists a role or a person in it, denying it keeps a person out, denying channels:read on a channel hides it and denying channels:post keeps someone from posting there, with channels:write on the channel, and allowing dns:write on the dns instance area hands out DNS alone, which only the instance Owner may do. Template roles are template_get and template_update with kind role at scope instance: the shipped keys are client, junior_developer, senior_developer, devops, and administrator, a body is JSON with name, description, permissions, welcome_steps, and show_locked_actions, a body with no key adds one, reset returns a shipped one to its default, and delete removes one you added. workspace_update with finish_access_setup ends the one-time setup after an upgrade, and workspace_list says whether it’s done. On a computer, its owner shares it with people, and nobody else, an Owner included, can see or change its rules. See MCP server.

Edit this page