Plugins

Each page here is read from the plugin itself, so it says what the code does. plugins.json has the same, as data.

In copilotz#

• api: Developer keys: what code calls the app with, as someone, over the runtime's REST API (/api/) or its socket (see runtime/api.ts and runtime/client.ts): Authorization: Bearer <key>.
• api-web: The developer API's web front end, for the browser.
• chat: Chat: threads where people and agents talk.
• chat-terminal: Chat's terminal front end, for the process that draws the terminal: how a conversation, a message, its author and a reply being written look there, and chat's commands.
• chat-web: Chat's web front end, for the browser: home (a new chat), how a chat looks with what agents are writing right now, a message and its files, where you type, and at the top of the sidebar, starting one.
• contacts: Contacts: people outside the org who talk to its agents, such as a WhatsApp customer writing to a business's number.
• contacts-web: Contacts on the web: their names, wherever a page shows who wrote (spaces' names resource, for the browser): "Ana", not "someone".
• dev-sign-in: Dev sign-in: people sign in by the name they type, from this machine only, for trying an app out (with the identity plugin).
• email: Email: sending it, and signing in with it.
• email-sign-in: Email: sending it, and signing in with it.
• google-sign-in: Google sign-in: google.sign-in turns a Google ID token into a person and a session (with the identity plugin).
• history: Summarizes each thread's older messages as they leave its tail, and sends agents the outline and the recent messages whole (it replaces chat's history View).
• identity: Identity: who people are and what proves it.
• maintenance: Maintenance: HTTP endpoints for an app's operators, for when they can't reach its database themselves (a client's network that keeps their database user out).
• mcp: MCP: models outside the app (ChatGPT, Claude, any MCP client) call the app's tools.
• memory: Memory: what agents know across conversations.
• memory-extraction: Memories that arrive on their own: the extractor model reads every few messages.
• memory-terminal: Memory's terminal front end: how a memory looks there, and /memories.
• memory-web: Memory's web front end, for the browser: what agents remember (the memories View, as the terminal's /memories lists it: ★ for core memories, always in mind).
• models: Models: talking to models, one way for every kind.
• openapi: OpenAPI: an HTTP API's operations as Actions and as tools for agents, made from its OpenAPI 3 spec.
• routines: Routines: a message sent to an agent on a schedule, in a space ("every weekday at 9:00, ask @researcher for the news on X").
• routines-web: Routines' web front end, for the browser.
• skills: Skills: know-how an agent reads only when it needs it.
• skills-web: Skills' web front end, for the browser.
• spaces: Spaces: who reaches what, for every collection that shares its documents.
• spaces-terminal: Access's terminal front end: how spaces look there, and /spaces, /space, /work, /invite, /invitations, /accept, /decline, and requests to join.
• spaces-web: Spaces' web front end.
• terminal: The terminal plugin: a command line's data, built from the same primitives as everything else, which every process has.
• terminal-shell: The terminal's front end, for the process that draws: the shell View (what's open, the scrollback, where you type), where you type's prompt, and the View any kind without its own falls back to.
• usage: Usage: what was used, what it cost, and what to charge for it, as a ledger.
• usage-terminal: Usage's terminal front end: how totals look there, and /usage.
• usage-web: Usage's web front end: where the app serves many orgs, the org page's Usage section (the web shell's orgSettings).
• voice: Voice: people call the app's phone number and talk to its agents, through Twilio's ConversationRelay (Twilio hears them and speaks for the agent; the app gets and sends text).
• web-lines: Web sites (resources.web.<name>, declared in the app's settings, with the app's secret, links).
• web-page: The page: the app's code, its files, its manifest and worker, and the page itself.
• web-shell: The web shell: the web's root View, which the web host observes for the address it's at (hosts/web).
• webTools: Web tools: agents that search the web and read a page, without a computer.
• whatsapp: WhatsApp: people talk to their agents from WhatsApp, through Meta's Cloud API.
• whatsapp-web: WhatsApp's web front end, for the browser.

In packages of their own#

• boards: Boards: kanban boards in a space, for people and agents, the team's operational source of truth: one real outcome per card, with its owner, what done looks like, an honest column, and any blocker. In @copilotz/work.
• boards-web: Boards' web front end, for the browser. In @copilotz/work.
• credits: Credits: what an org has to spend, and the check that stops it at its limit. In @copilotz/billing.
• credits-web: Credits' web front end: the org page's Billing section (the web shell's orgSettings). In @copilotz/billing.
• directory: The directory plugin, and what each org's runtime gets of it: directory.member(dir, org) (see shared/member.ts), with the org as org.info says it. In @copilotz/directory.
• directory-member: member(dir, org): the plugin each org's runtime gets from the directory (dir, its runtime) that serves it, beside the app's own plugins. In @copilotz/directory.
• directory-web: The directory's web front end, for apps that serve many orgs behind one address: it fills the web shell's orgs slot, and draws the org's pages. In @copilotz/directory.
• documents: Documents: shared Markdown in a space, for people and agents — the canonical artifact of the thing being made, and its working memory. In @copilotz/work.
• documents-web: Documents' web front end, for the browser. In @copilotz/work.
• stripe: Stripe: one way an org pays, for credits, which never asks it anything. In @copilotz/billing.
• stripe-webhook: Stripe's webhook, POST /__stripe/<seller>, where the app's accounts send their events (see routes/webhook.ts). In @copilotz/billing.
• team: Team: agents people make, beside those the app declares in code. In @copilotz/team.
• team-web: Team's web front end, for the browser: making and changing agents. In @copilotz/team.
• tiers: Tiers: which models the app's agents think with, chosen by what the work needs rather than model by model. In @copilotz/team.
• tiers-web: Tiers' web front end, for the browser. In @copilotz/team.