# Welcome to Dockito > Publish Markdown and HTML docs as links you can share, from the app, the terminal or your own AI. Every doc gets a short link that always shows its latest version. Publish from wherever you work, and share it with your team or the world. Dockito never calls an AI itself: you bring your own. - [Use the app](/help/quickstart): Drop a Markdown or HTML file and get a link to share. - [Connect your AI](/help/agents/connect): Let Claude, ChatGPT or Cursor publish and read docs for you. - [Use the terminal](/help/cli/install): Publish files and whole folders with one command. ## Connect your AI Pick your tool. It takes about a minute, and your AI can only do what you allow. ### Claude Code **Command** 1. Add Dockito: ```sh claude mcp add --transport http dockito https://dockito.ai/mcp ``` 2. In Claude Code, run `/mcp`, choose **dockito**, then **Authenticate**. 3. Your browser opens Dockito. Choose what it may do in each workspace (**View**, **Publish** or **Everything**) and **Approve**. **Token** 1. In Dockito, open **Account → Tokens** and make a token, with **Publish** where it should write. 2. Add Dockito with it: ```sh claude mcp add --transport http dockito https://dockito.ai/mcp \ --header "Authorization: Bearer dkt_…" ``` Add `--scope user` to have Dockito in every project. ### Claude 1. Open **Settings → Connectors** and choose **Add custom connector**. 2. Name it **Dockito**, paste the address and choose **Connect**: ```text https://dockito.ai/mcp ``` 3. Your browser opens Dockito. Choose what it may do in each workspace (**View**, **Publish** or **Everything**) and **Approve**. 4. In a chat, turn Dockito on from the tools menu. Custom connectors need a paid Claude plan. On Team and Enterprise, an owner may need to add it. ### ChatGPT 1. Open **Settings → Apps & Connectors → Advanced settings** and turn on **Developer mode**. 2. Back in **Apps & Connectors**, choose **Create**. Name it **Dockito**, paste the address and pick **OAuth**: ```text https://dockito.ai/mcp ``` 3. Your browser opens Dockito. Choose what it may do in each workspace (**View**, **Publish** or **Everything**) and **Approve**. 4. In a chat, add Dockito from the **+** menu under **Developer mode**. Developer mode is on paid ChatGPT plans. On Business and Enterprise, an admin may need to allow it. ### Cursor **One click** [Add to Cursor](cursor://anysphere.cursor-deeplink/mcp/install?name=dockito&config=eyJ1cmwiOiJodHRwczovL2RvY2tpdG8uYWkvbWNwIn0=) 1. Choose **Add to Cursor** and confirm in Cursor. 2. In **Cursor Settings → MCP**, choose **Needs login** next to dockito. 3. Your browser opens Dockito. Choose what it may do in each workspace (**View**, **Publish** or **Everything**) and **Approve**. **Config file** 1. Add Dockito to `~/.cursor/mcp.json`: ```json { "mcpServers": { "dockito": { "url": "https://dockito.ai/mcp" } } } ``` 2. In **Cursor Settings → MCP**, choose **Needs login** next to dockito. 3. Your browser opens Dockito. Choose what it may do in each workspace (**View**, **Publish** or **Everything**) and **Approve**. **Token** 1. In Dockito, open **Account → Tokens** and make a token, with **Publish** where it should write. 2. Add Dockito to `~/.cursor/mcp.json` with it: ```json { "mcpServers": { "dockito": { "url": "https://dockito.ai/mcp", "headers": { "Authorization": "Bearer dkt_…" } } } } ``` ### VS Code **One click** [Add to VS Code](vscode:mcp/install?%7B%22name%22%3A%22dockito%22%2C%22type%22%3A%22http%22%2C%22url%22%3A%22https%3A%2F%2Fdockito.ai%2Fmcp%22%7D) 1. Choose **Add to VS Code** and confirm **Install** in VS Code. 2. Allow it to sign in to Dockito when it asks. 3. Your browser opens Dockito. Choose what it may do in each workspace (**View**, **Publish** or **Everything**) and **Approve**. **Config file** 1. Add Dockito to `.vscode/mcp.json` in your project: ```json { "servers": { "dockito": { "type": "http", "url": "https://dockito.ai/mcp" } } } ``` 2. Choose **Start** above the server, and allow it to sign in. 3. Your browser opens Dockito. Choose what it may do in each workspace (**View**, **Publish** or **Everything**) and **Approve**. Use Dockito from Copilot Chat in **Agent** mode. ### Antigravity 1. In Dockito, open **Account → Tokens** and make a token, with **Publish** where it should write. 2. In the agent panel, open the **⋯** menu → **MCP Servers → Manage MCP Servers → View raw config**. 3. Add Dockito: ```json { "mcpServers": { "dockito": { "serverUrl": "https://dockito.ai/mcp", "headers": { "Authorization": "Bearer dkt_…" } } } } ``` 4. Save, then choose **Refresh**. ### Codex 1. Add Dockito to `~/.codex/config.toml`: ```toml [mcp_servers.dockito] url = "https://dockito.ai/mcp" ``` 2. Sign in: ```sh codex mcp login dockito ``` 3. Your browser opens Dockito. Choose what it may do in each workspace (**View**, **Publish** or **Everything**) and **Approve**. ### Gemini CLI 1. Add Dockito to `~/.gemini/settings.json`: ```json { "mcpServers": { "dockito": { "httpUrl": "https://dockito.ai/mcp" } } } ``` 2. In Gemini CLI, run `/mcp auth dockito`. 3. Your browser opens Dockito. Choose what it may do in each workspace (**View**, **Publish** or **Everything**) and **Approve**. ### Any MCP client **Sign in** 1. Add a remote (HTTP) MCP server with this address: ```text https://dockito.ai/mcp ``` 2. If your client signs in with OAuth, it opens Dockito for you. 3. Your browser opens Dockito. Choose what it may do in each workspace (**View**, **Publish** or **Everything**) and **Approve**. **Token** 1. In Dockito, open **Account → Tokens** and make a token, with **Publish** where it should write. 2. Add the address, and send the token as a header: ```text https://dockito.ai/mcp Authorization: Bearer dkt_… ``` ## Learn the basics - [Workspaces and roles](/help/concepts/workspaces): Your space, your team, and who can do what. - [Projects and folders](/help/concepts/projects-and-folders): Group docs, two folders deep. - [Markdown and HTML](/help/concepts/docs): What each kind of doc looks like, and its link. - [History](/help/concepts/history): Every change kept for a while; saved points kept for good. - [Sharing and access](/help/concepts/sharing): Who can open what, and public links. - [Tokens and access](/help/agents/tokens): What your AI and the CLI may do, per workspace. ## For AI agents Every page here is also plain Markdown: add `.md` to its address, or use **Copy page**. The whole set is at [`/llms.txt`](/llms.txt) and [`/llms-full.txt`](/llms-full.txt). --- # Quickstart > From nothing to a shared link in about two minutes. Sign in, publish one doc and send its link. It takes about two minutes, and there's nothing to install. 1. ## Sign in Your account, a username and your own workspace are made the first time you sign in. There's nothing to set up. [Sign in to Dockito](https://dockito.ai/signin) with GitHub or Google. 2. ## Publish a doc Pick the way you work. Each one makes the same doc, with its own link. **In the app** Drop a `.md` or `.html` file on **Home**, or choose **New doc**. The doc opens at its link straight away. **From the terminal** ```sh npx dockito@beta login npx dockito@beta publish plan.md ``` `login` approves this computer in your browser, and `publish` prints the doc's link. Publish the same file again later and the same link shows the new version. **From your AI** Connect your tool once, then just ask: *"Publish this plan to Dockito and give me the link."* - [Claude Code](/help/agents/connect#claude-code) - [Claude](/help/agents/connect#claude) - [ChatGPT](/help/agents/connect#chatgpt) - [Cursor](/help/agents/connect#cursor) - [VS Code](/help/agents/connect#vscode) - [Antigravity](/help/agents/connect#antigravity) - [Codex](/help/agents/connect#codex) - [Gemini CLI](/help/agents/connect#gemini) - [Any MCP client](/help/agents/connect#other) 3. ## Share the link New docs are private to your workspace. Open **Share** on the doc and choose who can open it: - **Everyone with access**: Everyone who can open where it sits. Members can edit. - **Only people you pick**: Each can edit, comment or view. - **Public**: Anyone with the link can view, no sign-in. ## What's next - [Connect your AI](/help/agents/connect): Let your AI publish and read docs for you. - [Organise with projects](/help/concepts/projects-and-folders): Group docs into projects and folders. - [Publish a folder](/help/cli/publishing): Keep a repo's docs in step with one command. - [Use History](/help/concepts/history): See earlier versions, save one, restore it. --- # Workspaces and roles > Personal and team workspaces, who is in them, and what each role can do. A workspace holds docs, projects and the people who work on them. Everything in Dockito belongs to exactly one workspace. ## Your personal workspace Your first sign-in makes a personal workspace named after you, with your username as its address. Your username can be changed once, in **Account → Profile**. Old links to it keep working. ## People and invites The workspace Owner and Admins invite people by email from **Workspace settings → People**. An invite opens only for someone signed in with that email, and they choose **Accept** or **Decline**. Invites last 30 days and can be renewed or revoked. Until it's answered, an invite holds a place in the workspace. Until Dockito sends email, **Invite** gives you a link to send yourself. People can be removed, or can leave. The docs they published stay in the workspace, which owns its content. ## Roles | Role | Can | |---|---| | **Owner** | Everything. Sees every project, folder and doc, including Custom ones. One per workspace. | | **Admin** | Manages people and settings. Sees everything except what the Owner keeps from Admins. | | **Member** | Works in the workspace: publishes, edits and organises wherever they have access. | Inside the workspace, each project, folder and doc can narrow who opens it. See [Sharing and access](/help/concepts/sharing). The Free plan allows the Owner plus two collaborators. See [Plans and limits](/help/account/limits). --- # Projects and folders > Group docs into projects, with folders up to two deep. **Projects** group docs inside a workspace. Each has a name, an optional short description, and an icon and colour. Its page is at `/{workspace}/project/{project}`. **Folders** go inside a project, at most **two deep**. A folder can hold docs and other folders. Docs that aren't in any project live in the workspace's **Docs**. ## Making them - In the app: **New project** in the sidebar, then **New folder** on a project or folder. The **Agile** template starts a project with Backlog, Sprints, Releases and Retrospectives. - From the terminal: `dockito mkdir handbook/specs` makes whatever is missing. `dockito sync` can make a project from a folder on your computer. - From your AI: the `mkdir` tool, when you ask for it. `tree` and `ls` tell it where it can only view, so it publishes where it can. ## Moving A doc can move anywhere in its workspace, and a folder anywhere in its project: **Move** in its ⋯ menu, `dockito move`, or the `move` tool. Its link stays the same. Who can open it follows where it sits. If a move would let more people open it, the app asks first and names them; your AI can't make that move, and asks you to. If a move shuts people out, you're told who. People outside the workspace a doc is shared with, and its public link, go with it. Moving needs the right to change its access (its creator, the workspace Owner or an Admin) and Edit where it goes. ## Deleting A project or folder can be deleted once it's empty. Its creator, the workspace Owner and Admins can delete it. Your AI can remove an empty folder (`dockito rmdir`, the `rmdir` tool), never a doc or a project. ## Access A project or folder can be open to everyone with access to where it sits, or only to people you pick. Everything inside follows it, and can only narrow further. See [Sharing and access](/help/concepts/sharing). --- # Markdown and HTML docs > What Dockito shows for each kind of file, and how docs are named and linked. Dockito takes **Markdown** (`.md`, `.markdown`) and **HTML** (`.html`, `.htm`) files, up to 10 MB each. ## Links Every doc gets a short link of its own, like `/f3n7uk6g4w9s`, the moment it's made. The link belongs to the doc. Renaming the doc never changes it, and a deleted doc's link is never given to another doc. Add the file's extension to the link (`/f3n7uk6g4w9s.md`) to get the file itself, which is handy for scripts and agents. ## Names A doc is named after the file it was first published as. Publishing a file with the **same name to the same place** updates that doc rather than making a new one. Rename a doc in the app to give it a different title; its link stays. ## Markdown Markdown docs show with headings, tables, task lists, footnotes, highlighted code with a copy button, images and links. An outline on the side follows you as you read. Raw HTML inside Markdown is never run. You can edit Markdown in the app: write on the page, use `/` for blocks, and paste from Google Docs or the web. **Changes** shows what you changed, and **Save** adds it to [History](/help/concepts/history). ## HTML HTML docs open full window, as the page itself. They run in a sealed frame: their scripts work, but they can't read Dockito, your sign-in or other docs. HTML docs aren't edited in the browser. Change the file (or ask your AI to) and publish it again. --- # History > How Dockito keeps a doc's earlier versions, saved points and restores. A doc is one living doc with one link. Every publish, edit or restore adds an entry to its **History**. ## What's kept - The **last 5 entries**, besides the current one. Older entries are deleted for good. - **Saved points**: any entry you choose to keep, with an optional note. They stay until you unsave them. Changes by the same person less than 10 minutes apart count as **one entry**. An AI revising a doc twenty times in a row leaves one entry, not twenty. ## Saved points - In the app: open **History** and choose **Save this point**. - From the terminal: `dockito publish plan.md -m "Sent to the client"`, or `dockito save -m "…"`. - From your AI: the `save` tool, or publish with a message. ## Restore Open an entry and choose **Restore**. It becomes the current version as a **new** entry, so what was current stays in History and a restore can be undone. ## Where a change came from Each entry says who made it, when, and how: uploaded, edited in the app, restored, from the CLI or from MCP. When the CLI publishes a file from a git repo, the entry also shows the commit. ## Two people at once If someone publishes while you were editing, Dockito stops your change instead of overwriting theirs. Open the latest and make your change again. --- # Sharing and access > Who can open a project, folder or doc, sharing with people outside the workspace, and public links. Docs are **private** by default: only people in the workspace can open them. From there you can narrow access to people you pick, or open a doc to anyone with its link. ## Who can open it Each project, folder and doc has one of these: - **Everyone with access to where it sits.** For a project or a doc in Docs, that's everyone in the workspace. For a folder or doc inside a project, it's everyone who can open that project or folder. Members can edit. - **Only the people you pick**, each with **Can edit**, **Can comment** or **Can view**. Comments are coming soon; until then Can comment works like Can view. Access only narrows as you go down. A folder inside a restricted project can only include people who can open the project, and nobody gets more than they have there. Someone who can't open an item doesn't see it at all: it's missing from the sidebar, lists, the CLI and MCP. ## Who always sees it - The workspace **Owner** sees everything. - **Admins** see everything a Member makes, even when it's restricted. Only the Owner can keep something from Admins. - A **Member** who restricts something hides it from other Members only. ## People outside the workspace Share a doc with anyone by email, with **Can view** or **Can comment**. They sign in with that email and the doc appears in their **Shared with me**. They see the doc as it is now: not its History, not where it sits in your workspace, and nothing else in it. They can never edit. Dockito never tells you whether an email has an account. Until someone signs in with it, the doc simply waits for them. ## Public links A doc can be made **public**: anyone with its link can view it, without signing in. A public page shows the doc as it is now. It never shows History, who wrote it, or the workspace's name. Projects and folders can't be public. Only docs can. ### Public docs and AI An AI can make a doc public only as it publishes a new one, and only when you ask for a public link. Everything else it publishes is private. An existing doc can be made public only from **Share** in the app. When you ask your AI to publish, say so if you want a public link. If you don't, it stays private. ## Who can change it A doc's, folder's or project's creator, the workspace Owner and Admins can change its access, share it outside the workspace, make it public or delete it. Anyone with **Can edit** can change its content. ## Workspace controls In **Workspace settings → Sharing**, the Owner can turn off public links, sharing outside the workspace, or both. Turning one off takes effect at once: every public doc becomes private, or everyone outside loses access. Settings says how many docs or people that affects before it happens. --- # Connect your AI > Add Dockito to Claude Code, Claude, ChatGPT, Cursor, VS Code and any MCP client. Connect once and your AI can publish docs, read them and keep their History, through the Dockito MCP server. It can never do more than you can, and only what you allow when you connect it. Pick your tool: ### Claude Code **Command** 1. Add Dockito: ```sh claude mcp add --transport http dockito https://dockito.ai/mcp ``` 2. In Claude Code, run `/mcp`, choose **dockito**, then **Authenticate**. 3. Your browser opens Dockito. Choose what it may do in each workspace (**View**, **Publish** or **Everything**) and **Approve**. **Token** 1. In Dockito, open **Account → Tokens** and make a token, with **Publish** where it should write. 2. Add Dockito with it: ```sh claude mcp add --transport http dockito https://dockito.ai/mcp \ --header "Authorization: Bearer dkt_…" ``` Add `--scope user` to have Dockito in every project. ### Claude 1. Open **Settings → Connectors** and choose **Add custom connector**. 2. Name it **Dockito**, paste the address and choose **Connect**: ```text https://dockito.ai/mcp ``` 3. Your browser opens Dockito. Choose what it may do in each workspace (**View**, **Publish** or **Everything**) and **Approve**. 4. In a chat, turn Dockito on from the tools menu. Custom connectors need a paid Claude plan. On Team and Enterprise, an owner may need to add it. ### ChatGPT 1. Open **Settings → Apps & Connectors → Advanced settings** and turn on **Developer mode**. 2. Back in **Apps & Connectors**, choose **Create**. Name it **Dockito**, paste the address and pick **OAuth**: ```text https://dockito.ai/mcp ``` 3. Your browser opens Dockito. Choose what it may do in each workspace (**View**, **Publish** or **Everything**) and **Approve**. 4. In a chat, add Dockito from the **+** menu under **Developer mode**. Developer mode is on paid ChatGPT plans. On Business and Enterprise, an admin may need to allow it. ### Cursor **One click** [Add to Cursor](cursor://anysphere.cursor-deeplink/mcp/install?name=dockito&config=eyJ1cmwiOiJodHRwczovL2RvY2tpdG8uYWkvbWNwIn0=) 1. Choose **Add to Cursor** and confirm in Cursor. 2. In **Cursor Settings → MCP**, choose **Needs login** next to dockito. 3. Your browser opens Dockito. Choose what it may do in each workspace (**View**, **Publish** or **Everything**) and **Approve**. **Config file** 1. Add Dockito to `~/.cursor/mcp.json`: ```json { "mcpServers": { "dockito": { "url": "https://dockito.ai/mcp" } } } ``` 2. In **Cursor Settings → MCP**, choose **Needs login** next to dockito. 3. Your browser opens Dockito. Choose what it may do in each workspace (**View**, **Publish** or **Everything**) and **Approve**. **Token** 1. In Dockito, open **Account → Tokens** and make a token, with **Publish** where it should write. 2. Add Dockito to `~/.cursor/mcp.json` with it: ```json { "mcpServers": { "dockito": { "url": "https://dockito.ai/mcp", "headers": { "Authorization": "Bearer dkt_…" } } } } ``` ### VS Code **One click** [Add to VS Code](vscode:mcp/install?%7B%22name%22%3A%22dockito%22%2C%22type%22%3A%22http%22%2C%22url%22%3A%22https%3A%2F%2Fdockito.ai%2Fmcp%22%7D) 1. Choose **Add to VS Code** and confirm **Install** in VS Code. 2. Allow it to sign in to Dockito when it asks. 3. Your browser opens Dockito. Choose what it may do in each workspace (**View**, **Publish** or **Everything**) and **Approve**. **Config file** 1. Add Dockito to `.vscode/mcp.json` in your project: ```json { "servers": { "dockito": { "type": "http", "url": "https://dockito.ai/mcp" } } } ``` 2. Choose **Start** above the server, and allow it to sign in. 3. Your browser opens Dockito. Choose what it may do in each workspace (**View**, **Publish** or **Everything**) and **Approve**. Use Dockito from Copilot Chat in **Agent** mode. ### Antigravity 1. In Dockito, open **Account → Tokens** and make a token, with **Publish** where it should write. 2. In the agent panel, open the **⋯** menu → **MCP Servers → Manage MCP Servers → View raw config**. 3. Add Dockito: ```json { "mcpServers": { "dockito": { "serverUrl": "https://dockito.ai/mcp", "headers": { "Authorization": "Bearer dkt_…" } } } } ``` 4. Save, then choose **Refresh**. ### Codex 1. Add Dockito to `~/.codex/config.toml`: ```toml [mcp_servers.dockito] url = "https://dockito.ai/mcp" ``` 2. Sign in: ```sh codex mcp login dockito ``` 3. Your browser opens Dockito. Choose what it may do in each workspace (**View**, **Publish** or **Everything**) and **Approve**. ### Gemini CLI 1. Add Dockito to `~/.gemini/settings.json`: ```json { "mcpServers": { "dockito": { "httpUrl": "https://dockito.ai/mcp" } } } ``` 2. In Gemini CLI, run `/mcp auth dockito`. 3. Your browser opens Dockito. Choose what it may do in each workspace (**View**, **Publish** or **Everything**) and **Approve**. ### Any MCP client **Sign in** 1. Add a remote (HTTP) MCP server with this address: ```text https://dockito.ai/mcp ``` 2. If your client signs in with OAuth, it opens Dockito for you. 3. Your browser opens Dockito. Choose what it may do in each workspace (**View**, **Publish** or **Everything**) and **Approve**. **Token** 1. In Dockito, open **Account → Tokens** and make a token, with **Publish** where it should write. 2. Add the address, and send the token as a header: ```text https://dockito.ai/mcp Authorization: Bearer dkt_… ``` ## What to ask Your AI reads Dockito's instructions when it connects, so plain words work: - “Publish this spec to Dockito and give me the link.” - “Put these notes in the Harbor project, in Meetings.” - “What changed in the Cedarline brief since Friday? Restore the version from before.” - “Save the current version of the proposal as *Sent to the client*.” It's told to **ask where a doc goes** rather than guess, and to **keep docs private** unless you ask for a public link. Deleting docs and sharing with people happen in the Dockito app, never through an AI. ## More - [Tokens and access](/help/agents/tokens): what a connection may do, and how to sign it out. - [MCP tools](/help/agents/mcp-tools): every tool and its parameters. --- # Tokens and access > How the CLI, MCP connectors and personal tokens are allowed in, and how to sign them out. Anything that isn't your browser uses a token: the CLI, an AI client connected over MCP, a script or a CI job. A token never does more than you can. ## Access per workspace When you approve a token, you choose its access in **each** workspace separately: | Access | Can | |---|---| | **View** | Read docs and their History | | **Publish** | Read, publish, rename and restore docs; make projects and folders; take a public link back | | **Everything** | Publish, plus comments when they arrive | | **No access** | Nothing in that workspace | No token can delete docs, share with people, or make an existing doc public. Those happen in the app. ## Two kinds **Sign-in tokens** are approved in your browser: `dockito login`, and AI clients that sign in by themselves. They renew on their own and end after **90 days without use**. They're listed in **Account → Sessions and devices**, where **Sign out** ends one. **Personal tokens** are made by hand in **Account → Tokens** for clients that can't sign in, scripts and CI. Each lasts 7, 30 or 90 days, or until a date up to a year away. There's no never-expiring token. You can have up to 20 at a time, and **Revoke** ends one. Token secrets start with `dkt_`. Dockito stores only a hash, so a token is shown once, when it's made. ## Changing access - The CLI: `dockito login --update` opens the browser to change its access. - An AI client: sign it out and connect again. - A personal token: make a new one with the access you want and revoke the old one. Removing someone from a workspace stops all their tokens there at once. --- # MCP tools > Every tool the Dockito MCP server offers, with its parameters. This page is built from the MCP server's own tool list, so it always matches what your AI client sees. A tool can never do more than the person who connected, and only what the connection's access allows in each workspace (View, Publish or Everything). History records changes made here as `mcp`. ## whoami **Who am I** · Reads only The user, how long this token lasts, and its access (View, Publish or Everything) in each workspace it can reach. No parameters. ## tree **Places** · Reads only Every workspace, project and folder this token can use, each written as the "to" that publish takes, with doc counts and your role there (edit, comment or view; publishing needs edit). No docs; ls lists those. No parameters. ## ls **List docs** · Reads only The docs (with their codes and links), projects and folders in one place: the workspace's Docs (no place), a project, or a folder. Each place has your role there (edit, comment or view; publishing needs edit). | Parameter | Type | | |---|---|---| | `to` | string | "project" or "project/folder", as publish takes it. Empty: the workspace's Docs and its projects. | | `workspace` | string | Workspace slug. Default: the only one, else the user's personal one. | ## get **Read a doc** · Reads only A doc's file: the current one, or a History entry. Returns its details, then the file's text. A file over 20,000 characters comes back as its outline (headings with line numbers) instead: read the part you need with "lines", or all of it with "full". A sheet comes back as its outline: each sheet's columns, what's in them, and the version to apply changes at; read gives its rows. | Parameter | Type | | |---|---|---| | `doc` (required) | string | The doc's link or 12-character code. | | `entry` | integer | A History entry number. Default: current. | | `outline` | boolean | Only the details and the outline: each heading with the line it starts on. | | `lines` | string | Only these lines of the file: "120-260", "120-" (to the end) or "120". | | `text` | boolean | HTML as readable text: no tags, scripts or styles, headings and list items kept as # and -. Often a few times shorter. Markdown is already text. | | `full` | boolean | The whole file, however long. | ## read **Read a sheet** · Reads only Rows of a sheet as a text table: row numbers, values as shown, and the version (v N) to apply changes at. A range, or a sheet's rows under its header row, filtered and sorted; with "group" or "totals", totals instead of rows. 200 rows unless "limit" says, at most 1,000; the answer says how to page on with "from". With "chart", a chart's points instead. | Parameter | Type | | |---|---|---| | `doc` (required) | string | The doc's link or 12-character code. | | `range` | string | "Tasks!A1:G40", "Tasks!B:B", "Tasks!3:5", a defined name, or "E17" when there's one sheet. | | `sheet` | string | A sheet or table by name: its rows under its header row. Default: the only sheet. | | `where` | string | A filter on headers: "Area = Kitchen and Status <> Done or Hours > 4". With = <> < > <= >= contains, "is empty" and "is not empty"; dates as yyyy-mm-dd. | | `select` | array | Columns to show, by header or letter, in this order. | | `orderBy` | string | "Due desc, ID". Empty cells go last. | | `group` | array | Group the rows by these columns. | | `totals` | array | Per group, or for all the rows: "count", "sum Hours", "avg Hours", "min Due", "max Due". | | `from` | integer | The first of the matching rows to give, from 1. | | `limit` | integer | How many rows. Default 200, at most 1,000. | | `formulas` | boolean | Formulas with their results: =F2*50 → 50. | | `styles` | boolean | Formatting in words: bold, fills, number formats, merges, sizes, frozen panes; a cell a conditional format colours shows it with the rule, as fill #f6d3d0 (format #3). | | `csv` | boolean | As CSV instead of a table. | | `chart` | integer | A chart's number (chart #2 in the outline): its points as a table, label column then each series, as drawn (a long range thinned, saying how many rows of how many). Alone, with doc. | ## apply **Change a sheet** · Changes docs Changes a sheet, read at "base": the version (v N) your last get, read or changes showed. Addresses, rows and headers mean what they meant at that version, wherever they moved since; so do chart and format numbers (#N, by order in the outline; a chart an earlier op here makes takes the next number) and sheet names (after a rename by an earlier op, either works). Every op applies, or none: a cell someone changed since is refused, naming who, so read again and apply on the new version. Answers each cell old → new, results that changed, and the new version. "dryRun" answers the same without saving; "undo" takes back a change of yours. | Parameter | Type | | |---|---|---| | `doc` (required) | string | The doc's link or 12-character code. | | `base` | integer | The version you read: v N in the answer. | | `ops` | array | Changes, applied in order; "sheet" can be left out when there's one. Each is one of: {"set": "Tasks!E17", "value": "Done"} · {"set": "Tasks!B2:C3", "values": [["Tile grout", "Kitchen"], ["Vent cover", "Bathrooms"]]} (past the last row or column, the sheet grows) {"update": {"sheet": "Tasks", "where": "ID = T-104", "set": {"Status": "Done", "Owner": "Dana"}}} · {"update": {"sheet": "Tasks", "where": "Area = Kitchen and Status = Open", "set": {"Status": "Done"}, "max": 50}} (rows matching at base, by header; max is 1 unless set, and more matches than max are refused, so set it when you mean several rows) {"append": {"sheet": "Tasks", "rows": [{"ID": "T-214", "Item": "Gutter downspout", "Status": "Open"}]}} (after the last filled row, by header; a table grows; a column's formula in the rows above carries into the new rows, as in Excel, unless you give a value) {"insertRows": {"sheet": "Tasks", "after": 40, "count": 2}} (after 0: the top) · {"deleteRows": {"sheet": "Tasks", "rows": "41:42"}} (or a list: "9, 16, 41:42") · {"moveRows": {"sheet": "Tasks", "rows": "5:6", "after": 10}} {"insertCols": {"sheet": "Tasks", "after": "C", "count": 1}} ("" for before A) · {"deleteCols": {"sheet": "Tasks", "cols": "D:E"}} · {"moveCols": {"sheet": "Tasks", "cols": "F", "after": "B"}} {"format": {"range": "Tasks!1:1", "bold": true, "fill": "#fff2cc"}} (cells, rows "1:1" or columns "F:F"; null clears a field. bold italic underline strike wrap: true or false · size: points, 1 to 409 · font: a name, as "Inter" · color fill: "#rrggbb" · hAlign: left, center, right or justify · vAlign: top, middle or bottom · indent: 0 to 250 · borderTop borderRight borderBottom borderLeft: "thin #d0d5dd" or {"line": "thin", "color": "#d0d5dd"}, lines thin, medium, thick, dashed, dotted or double · numFmt: Excel's, as "$#,##0.00") {"resize": {"range": "Tasks!B:C", "size": 120}} (points or "auto"; "hidden": true hides) · {"merge": "Tasks!A1:G1"} · {"unmerge": "Tasks!A1:G1"} {"addSheet": {"name": "Hours", "after": "Tasks"}} · {"renameSheet": {"sheet": "Hours", "name": "Time"}} · {"moveSheet": {"sheet": "Time", "first": true}} · {"deleteSheet": "Old"} · {"sheetProps": {"frozenRows": 1, "frozenCols": 0, "hidden": false, "tabColor": "#4472c4"}} {"setName": {"name": "Rate", "range": "Summary!B2"}} · {"deleteName": "Rate"} {"addTable": {"range": "Tasks!A1:G40", "name": "Tasks"}} (a header row and banded rows in one change; a cell's own fill shows over them) · {"setTable": {"table": "Tasks", "range": "Tasks!A1:G60", "totals": true}} · {"deleteTable": "Tasks"} (its cells stay) {"validate": {"range": "Tasks!E2:E", "list": ["Open", "In progress", "Done"], "reject": true, "help": "Pick a status"}} (E2:E: from row 2 down, rows added later too; reject: other values are refused, else taken and marked; the outline lists each rule) · one kind each: "list", "from": "Lists!A2:A20", "checkbox": true or ["Yes", "No"], "number": {"between": [0, 100]} (or "equal to", "not equal to", "greater than", "at least", "less than", "at most", "not between"), "date": {"after": "2026-01-01"} (or "before", "on or after", "on or before", "on", "not on", "between"; true: any date), "text": {"contains": "x"} (or "not contains", "exactly"), "email": true, "url": true, "length": {"at most": 50}, "formula": "=F2<G2" (for the first cell) · {"validate": {"range": "Tasks!E2:E", "remove": true}} {"conditional": {"range": "Tasks!E2:E", "text is": "Blocked", "format": {"fill": "#f6d3d0", "bold": true}}} (the outline lists rules in order as format #N; on a cell the first that matches wins; new ones go last) · one condition each: "empty": true, "not empty": true, "text contains", "text not contains", "text starts with", "text ends with", "text is": "x", "date is", "date before", "date after": "today", "tomorrow", "yesterday", "past week", "past month", "past year" or "2026-01-01", "number": {"greater than": 8} (validate's words), "formula": "=$F2<TODAY()" (for the first cell), "scale": {"min": "#ffffff", "mid": "#ffd666", "max": "#57bb8a"} (a point may be {"color": "#57bb8a", "number": 10}, "percent" or "percentile"; no format), "duplicate": true, "unique": true, "top": 10 or "10%", "bottom", "above average": true, "below average": true · format: bold italic underline strike, color fill · "before": 2 or "first": true places it · {"conditional": {"rule": 3, "first": true}} moves rule 3; with range, a condition or format it changes them · {"conditional": {"rule": 3, "remove": true}} or {"conditional": {"range": "Tasks!E:E", "remove": true}} (rules inside it) · read with styles marks coloured cells: fill #f6d3d0 (format #3) {"replace": {"find": "Lee", "with": "Priya", "in": "Owner"}} (find and replace, as one change: "in" is a column by header or letter, its rows under the header, or a range, "Tasks!C2:C"; left out, the whole sheet, "sheet" naming it when there's more than one; "with" may be "") · "case": true matches case · "whole": true the whole cell · "regex": true for a pattern (RE2), $1 in "with" its first group · "formulas": true changes formulas, searching their text (else a formula matches by its result and is left) · the answer says what was left and why: formulas, matched only as formatted, formulas that would break, values a rule refuses; over 100,000 cells changes nothing {"chart": {"range": "Tasks!A1:C40", "type": "column", "title": "Costs by area"}} (the outline lists each as chart #N; the first row names the series and the first column labels the points, or is a scatter's x, guessed when left out: "header", "labels") · "type": "column", "bar", "line", "area", "pie", "donut" or "scatter" (first column: x), or "stacked column", "stacked bar", "stacked area", "doughnut", "horizontal bar"; "stacked": true for column, bar, area · "at": "E2" puts its top-left corner there, or "below", "beside", "below chart #2", "beside chart #2"; left out, beside the range on its first row, past whatever fills those rows (under a wide range when that's clear), never over filled cells or another chart (the sheet grows to fit; "below" far down says so) · "width", "height" in pixels, 40 to 4,000 (left out: fitted, 480 × 300, wider past 24 points; a pie 420 × 300) · "title" (left out: the series by the label column, "Kitchen and Bath by Month"), "x title", "y title" · "legend": "right", "bottom", "top" or "none" · "colors": ["#4285f4", null] per series (null: the default) · the answer says what it draws (points, labels, each series' range, a pie's shares) and warns about a total row or column, or a column with no numbers; read with "chart" gives its points · {"chart": {"chart": 2, "type": "line"}} changes chart 2 · {"chart": {"chart": 2, "remove": true}} Values: a number, true or false, null (empty), a string ("=…" is a formula: "=SUM(F2:F40)", "=[@Hours]*85", "=Tasks[Hours]"), {"text": "=shown as typed"} or {"date": "2026-10-19"}. | | `expect` | object | Cells that must hold these values before the ops, as at base, or nothing applies: {"Tasks!E17": "Open"}. Not what the ops should make: the answer shows that. | | `note` | string | Why, in a few words. Shown with the change in the sheet and in changes. | | `dryRun` | boolean | Work it out and answer, saving nothing. | | `undo` | integer | Undo your own change that made this version, as one change. Goes alone: no base, ops or expect. | | `key` | string | A retry key, up to 64 characters. Default: one made from the request, so the same request on the same version applies once. | ## check **Check a sheet** · Reads only Problems in a sheet, by rules: formula errors, a formula that breaks its column's pattern, a value typed over a column's formulas or a cell left empty among them, numbers or dates typed as text, and totals that stop before their column does. | Parameter | Type | | |---|---|---| | `doc` (required) | string | The doc's link or 12-character code. | | `sheet` | string | One sheet by name. Default: every sheet. | ## changes **What changed in a sheet** · Reads only What changed after a version, or since a time, oldest first: who, when, through what, with each cell old → new, named where it is now. Ends at the current version, to apply changes at. 50 changes unless "max" says, at most 200. | Parameter | Type | | |---|---|---| | `doc` (required) | string | The doc's link or 12-character code. | | `since` (required) | integer,string | A version (412), or a time in UTC: "2026-10-13" or "2026-10-13 09:00". | | `max` | integer | At most this many changes. Default 50. | ## publish **Publish a doc** · Changes docs Publishes Markdown or HTML. A file with the same name in that place updates its doc (same link, a new History entry); otherwise it becomes a new doc. Unchanged content is skipped. A .csv becomes a new live sheet, typed as Excel opens it; after that it changes with apply, never by a file. Docs are private: only people in the workspace can open them. Set public: true only when the user clearly asked for a public link; if they didn't say, keep it private. Only a new doc can be public; an existing private doc is made public from Share in the Dockito app. | Parameter | Type | | |---|---|---| | `name` (required) | string | The file name, with .md, .html or .csv: "plan.md". It titles the doc and matches it next time. | | `content` (required) | string | The whole file. | | `title` | string | A new doc's title. Default: the file name without its extension. An existing doc keeps its title; rename changes it. | | `to` | string | "project" or "project/folder". Default: the workspace's Docs. Ask the user when a doc belongs in a project; never guess. | | `workspace` | string | Workspace slug. Default: the only one, else the user's personal one. | | `message` | string | Keep this entry as a saved point, with this note. | | `public` | boolean | Anyone with the link can open it, no sign-in. Only when the user asked. Only for a new doc. | | `doc` | string | Update this doc (link or code) instead of matching by name. | | `new` | boolean | A new doc even if one with this name is there. | ## mkdir **Make a project or folders** · Changes docs Makes whatever is missing of "project/folder/subfolder": the project, then up to 2 levels of folders. Only when the user wants them. | Parameter | Type | | |---|---|---| | `path` (required) | string | "project", "project/folder" or "project/folder/subfolder". | | `workspace` | string | Workspace slug. Default: the only one, else the user's personal one. | ## move **Move a doc or folder** · Changes docs Puts a doc (by "doc") anywhere in its workspace, or a folder (by "folder", "project/folder") elsewhere in its project. The link stays the same. Who can open it follows where it sits: a move that would let more people open it is refused, naming them, and the user does it in the Dockito app; a move that shuts people out says who. Only when the user asks. | Parameter | Type | | |---|---|---| | `doc` | string | The doc's link or 12-character code. | | `folder` | string | A folder, "project/folder" or "project/folder/subfolder", instead of a doc. | | `to` | string | Where it goes: "project" or "project/folder". Empty: the workspace's Docs (docs only). | | `workspace` | string | Workspace slug. Default: the only one, else the user's personal one. | ## rmdir **Remove an empty folder** · Changes docs Removes an empty folder ("project/folder"). A folder with docs or folders in it stays, and nothing is deleted with it. Only when the user asks. | Parameter | Type | | |---|---|---| | `folder` (required) | string | "project/folder" or "project/folder/subfolder". | | `workspace` | string | Workspace slug. Default: the only one, else the user's personal one. | ## history **History** · Reads only A doc's History, newest first: entry number, when, who, from where (upload, edit, cli, mcp), saved points with their notes, and the git commit. A sheet's entries are how each editing session left it (its version, and everyone who changed it then); the sheet now is newer than its first entry. | Parameter | Type | | |---|---|---| | `doc` (required) | string | The doc's link or 12-character code. | ## restore **Restore an entry** · Changes docs Makes an older History entry the current one, as a new entry. Nothing is lost. A sheet is made as it was then in one change, which apply with undo takes back. | Parameter | Type | | |---|---|---| | `doc` (required) | string | The doc's link or 12-character code. | | `entry` (required) | integer | The entry number from history. | ## save **Keep a saved point** · Changes docs Keeps a History entry (default: the current one; a sheet: as it is now) as a saved point, so History never drops it, with an optional note. A doc keeps up to 10. | Parameter | Type | | |---|---|---| | `doc` (required) | string | The doc's link or 12-character code. | | `entry` | integer | Default: the current entry. | | `message` | string | A note for the saved point. | ## share **Who can open a doc** · Changes docs Says whether a doc is private (only people in its workspace) or public (anyone with the link). "private": true takes a public link back at once. An existing doc is made public only from Share in the Dockito app; a new doc can be published public when the user asks. | Parameter | Type | | |---|---|---| | `doc` (required) | string | The doc's link or 12-character code. | | `private` | boolean | Make it private now. | ## rename **Rename a doc** · Changes docs Changes a doc's title. Its link stays the same. | Parameter | Type | | |---|---|---| | `doc` (required) | string | The doc's link or 12-character code. | | `title` (required) | string | The new title, 1 to 200 characters. | ## What the server tells your AI Every client receives these instructions when it connects: ```text Dockito hosts Markdown and HTML docs, and live sheets, at a short link, with History. workspace: a person's or a team's space. project: docs grouped in a workspace, with folders up to 2 deep. Docs: a workspace's docs outside any project. doc: one file; publishing a file with the same name to the same place updates that doc and keeps its link. History: every publish is an entry; a message keeps one as a saved point. A token has View, Publish or Everything per workspace. - Nothing is remembered between calls. Call tree to see where docs can go and ls for what's in a place. - Just a link to share: publish with no "to"; it goes to the workspace's Docs. When a doc belongs in a project, ask the user where, never guess, and pass "to" every time. - Docs are private: only people in the workspace can open them. Set public: true (anyone with the link, no sign-in) only when the user clearly asked for a public link. If they didn't say, keep it private. Only a new doc can be published public. - A doc is named by its link or its 12-character code. - move puts a doc or folder in another place; its link stays. Who can open it follows where it sits, so a move that would let more people in is refused: the user moves it in the Dockito app. rmdir removes an empty folder. - Deleting docs and sharing with people happen in the Dockito app, not here. Sheets: people and agents edit the same cells, live; publishing a .csv makes a new one. - get gives a sheet's outline (its sheets, columns and what's in them) and its version (v N). read gives rows; check finds broken formulas and typed-over cells; changes lists what changed since a version. - apply changes it, with "base" set to the version you last read. Addresses and rows mean what they meant then, wherever they moved since. If someone changed the same cells meanwhile, nothing applies and the answer says who: read again, then apply with the new version. - Change rows by what's in them, not by row number: update with a filter ("ID = T-104"), and "max" when you mean several rows. - Dates: write {"date": "yyyy-mm-dd"}; the outline says which order the sheet shows them in. Formulas start with =. ``` --- # Install the CLI > Run the Dockito CLI, sign in, and check what it can reach. The CLI publishes files and folders from your terminal, and gives agents like Claude Code and Codex a simple way to use Dockito. It's in beta: commands may still change. ## Run it It needs Node.js 18.17 or newer. Run it with `npx`: ```sh npx dockito@beta --help ``` Or install it once: ```sh npm install -g dockito@beta dockito --help ``` On a Mac or Linux with Homebrew, without Node.js: ```sh brew install dockito-ai/tap/dockito ``` `brew upgrade dockito` gets the newest version. ## Sign in ```sh dockito login ``` It prints a code and opens your browser. Check that the code matches, choose what this login may do in each workspace (**View**, **Publish** or **Everything**) and approve. On a machine without a browser, `dockito login --no-browser` prints the link to open elsewhere. The token is kept in your system's keychain, or in a file only you can read where there's no keychain. ```sh dockito whoami # who you are, and what this login can reach dockito tree # every workspace, project and folder you can publish to dockito logout # sign this machine out ``` ## In CI and scripts Make a personal token in **Account → Tokens** and set it as `DOCKITO_TOKEN`. The CLI uses it instead of a login. ```sh DOCKITO_TOKEN=dkt_… dockito publish CHANGELOG.md --to handbook ``` ## For agents The CLI keeps nothing but your login: no config files, nothing written into your repo. Where docs go is passed with `--to` every time. Every command takes `--json`, and `dockito agent` prints what an AI agent needs to know. See [CLI commands](/help/cli/commands) for everything it does. --- # Publishing from a repo > Publish single files or keep a whole folder of docs in step with a project. ## One file ```sh dockito publish plan.md # your personal Docs dockito publish plan.md --to handbook/specs # a project's folder dockito publish plan.md -m "Sent to the client" ``` A file with the same name in that place updates its doc: same link, a new [History](/help/concepts/history) entry. Unchanged files are skipped. `--doc ` updates a particular doc whatever the file is called, and `--new` makes a new doc even if the name is taken. New docs are private. Add `--public` only when you want anyone with the link to read it. ## A folder ```sh dockito sync docs --to handbook ``` `sync` mirrors a folder into a project: - Subfolders become folders, and each file updates the doc with the same name in the same folder, or becomes a new doc there. - Only changed files are sent. - Nothing is moved or deleted in Dockito. It always shows a plan first. If it would make a project or folders, it waits for `--yes`. `--dry-run` shows the plan and changes nothing. ```sh dockito sync docs --to handbook --create --dry-run # see what would happen dockito sync docs --to handbook --create --yes # do it ``` Projects go two folders deep. `--fold` puts deeper folders into the deepest allowed one. Where two files would clash, the folders left out go in front of the name. ## Git When a file you publish matches a commit in your repo, the History entry records the commit, so you can tell which version of the repo a doc came from. ## In CI ```yaml - run: npx dockito@beta sync docs --to handbook env: DOCKITO_TOKEN: ${{ secrets.DOCKITO_TOKEN }} ``` Use a personal token with **Publish** access to just that workspace. --- # CLI commands > Every dockito command and option, from the CLI's own help. This page is built from the CLI's own help, so it always matches the release. In a terminal, `dockito --help` shows the same text. Every command takes `--json` for machine-readable output and `-w, --workspace ` for a workspace other than your personal one. A `` is a doc's link or its 12-character code. ## sync Mirror a folder into a project. ```sh dockito sync --to ``` Mirrors a local folder into a project: subfolders become folders, and each file updates the doc with the same file name in the same folder, or becomes a new doc there. Only files whose content changed are sent. Nothing is moved or deleted in Dockito. The CLI remembers nothing: pass `--to` every time. Docs made by sync are private. | Option | | |---|---| | `--to ` | Where it goes (required; `dockito tree` lists places) | | `-w, --workspace ` | Another workspace | | `--create` | Make the project if it doesn't exist | | `--fold` | Put folders deeper than 2 into the deepest allowed; clashing names get the left-out folders in front | | `--dry-run` | Show the plan, change nothing | | `--yes` | Apply a plan that makes a project or folders | It always shows a plan. Making a project or folders waits for `--yes`: show the plan to the user first. Sending docs into folders that exist just runs. ```sh dockito sync docs --to handbook dockito sync docs --to handbook --create --fold --dry-run ``` ## publish Publish files; the same name in that place updates its doc. ```sh dockito publish ``` Publishes Markdown or HTML files. A file with the same name in that place updates its doc (same link, a new History entry); otherwise it's a new doc. Unchanged files are skipped. A .csv becomes a new live sheet, typed as Excel opens it; after that it changes with `dockito apply`, never by a file. Docs are private: only people in the workspace can open them. Add `--public` only when the user clearly asked for a public link (anyone with the link, no sign-in). If they didn't say, keep it private. `--public` works only for a new doc; an existing private doc can be made public only from Share in the app. | Option | | |---|---| | `--to ` | Where (default: the workspace's Docs) | | `-w, --workspace ` | Another workspace (default: your personal one) | | `-m, --message ` | Keep this entry as a saved point, with a note | | `--public` | Make the new doc public (only when the user asked) | | `--title