@lanes-sh/link 0.6.10 → 0.7.0

package/.gcloudignore

@@ -12,9 +12,19 @@
 # method is a directory under `~/.bun` with no `.git` in it — so the safe
 # behaviour was being inherited from a coincidence.
 #
-# Keep the first block in step with `.dockerignore`. `data/` holds the encrypted
-# credential store *and* the key that opens it.
-data/
+# **Anchor every directory pattern with a leading slash.** This file is gitignore
+# syntax and `.dockerignore` is not: there, a pattern is relative to the context
+# root, so `docs/` means the one at the top. Here `docs/` means *any* directory
+# called `docs`, at any depth — which is `src/providers/google/docs/`, and
+# stripping it produced an image that built cleanly and died on its first import
+# with `Cannot find module './google/docs/index.ts'`. The two files must say the
+# same thing, not carry the same characters.
+#
+# The credential patterns below are deliberately *not* anchored: a stray `*.key`
+# is worth excluding wherever it turns up. `data/` is, because the credential
+# store is one known directory and a source directory called `data` would be a
+# legitimate part of the package.
+/data/
 *.key
 *.pem
 *.enc
@@ -23,28 +33,28 @@ data/
 .env.*
 
 # Not needed to build, and `.git` in particular carries every branch.
-.git/
+/.git/
 .gitignore
-.worktrees/
+/.worktrees/
 node_modules/
 **/node_modules/
-coverage/
-dist/
-build/
+/coverage/
+/dist/
+/build/
 *.tsbuildinfo
 
 # Tests, docs and tooling: the image runs the endpoint and nothing else.
 **/*.test.ts
 **/*.test.json
-docs/
-instructions/
+/docs/
+/instructions/
 **/README.md
-.lanes/
-.claude/
-.vscode/
-.idea/
+/.lanes/
+/.claude/
+/.vscode/
+/.idea/
 .DS_Store
-.playwright-mcp/
+/.playwright-mcp/
 
 # The compiled binary from `bun build --compile`, if one was made locally.
 /lanes

package/README.md

@@ -4,12 +4,13 @@
 [![license Apache-2.0](https://img.shields.io/github/license/lanes-sh/link?style=flat-square&color=black)](LICENSE)
 [![ci](https://img.shields.io/github/actions/workflow/status/lanes-sh/link/ci.yml?branch=main&style=flat-square&label=ci)](https://github.com/lanes-sh/link/actions/workflows/ci.yml)
 
-**One secure endpoint between your AI agents and all your connections, memory, tasks, files, and secrets.**
+**One endpoint you own, holding everything your agents need to know you: connections, memory, tasks, files, contacts, and secrets.**
 
-Connect your mail, calendar, files, and notes once, and add the memory, tasks, and procedures that
-only you have. Every agent you use — Claude, ChatGPT, and anything else that speaks MCP — reaches them
-through a single MCP endpoint that you own and run. Open source, self-hostable, no vendor sitting in
-the middle of your data.
+You own it and you run it. Connect your mail, calendar, files, and notes once, and add the memory,
+tasks, and procedures that only you have. Every agent you use — Claude, ChatGPT, and anything else
+that speaks MCP — reaches all of it through that one endpoint. Change your AI and you keep your
+context, because none of it ever lived in the agent. Open source, self-hostable, no vendor in the
+middle of your data.
 
 <picture>
   <source media="(prefers-color-scheme: dark)" srcset="docs/images/lanes-link-dark.svg">
@@ -23,6 +24,9 @@ the middle of your data.
   them — it does not ask the model to behave.
 - **Work and personal never mix.** Separate profiles, separate credentials, separate stores.
 - **Every call is recorded.** An append-only log of what was reached, and what was refused.
+- **It is yours to move.** What you store is plain files on your own disk — readable in an editor,
+  backed up like anything else, and portable to a private Git repository or to another machine
+  whenever you want. There is no export to ask for.
 
 ## What people use it for
 
@@ -67,7 +71,7 @@ ok    registered lanes-link with Codex
 
 Your agents can now use it. Memory, tasks, files, skills, and the vault hold your own material
 rather than an account, so they are already there — nothing to connect, no credentials, no browser.
-Mail and calendar are the next step. **[Full quickstart →](docs/quickstart.md)**
+Mail and calendar are the next step. **[Full quickstart →](https://lanes.sh/docs/link/quickstart)**
 
 ## In the Lanes desktop app
 
@@ -88,7 +92,10 @@ $ lanes link desktop     # opens the app on that page, installing it if it is no
 
 **[How to use it →](https://lanes.sh/docs/desktop/lanes-link)**
 
-## What your agent gets
+## What you keep in it
+
+Not "what your agent gets" — the distinction is the whole point. These are yours. An agent is a
+visitor to them, and you decide per profile how far in it comes.
 
 | | | Manage it with |
 |---|---|---|
@@ -97,12 +104,18 @@ $ lanes link desktop     # opens the app on that page, installing it if it is no
 | **Tasks** | what you have to do, each with a status | `lanes link tasks` |
 | **Assets** | files you want kept, by name | `lanes link assets` |
 | **Skills** | your own procedures, handed to an agent as instructions | `lanes link skills` |
+| **Identity** | who you are, and the people and companies that recur in your work | `lanes link identity` |
 | **Vault** | passwords and API keys, released only where you allow it | `lanes link vault` |
 
-The first five arrive switched on: they hold your own material rather than an account, so there was
-never anything to authorise. Memory, tasks, and skills are plain Markdown files and an asset is
-stored under its own filename, so a text editor and an agent reach the same bytes. Every one of them
-belongs to a single profile: what you add under `work` is invisible under `personal`.
+Every one of these except connections arrives switched on: they hold your own material rather than
+an account, so there was never anything to authorise. Memory, tasks, and skills are plain Markdown
+files and an asset is stored under its own filename, so a text editor and an agent reach the same
+bytes. Every one of them belongs to a single profile: what you add under `work` is invisible under
+`personal`.
+
+Identity is the one that is read-only by construction. An agent able to rewrite whose name it signs
+with would be rewriting the one fact that stops it signing as the wrong person, so you declare it in
+a terminal and the endpoint only reads it back.
 
 Which store a thing goes in is the one thing worth knowing. **Memory is what is true, tasks is what
 is to be done, assets is a file.** "Remember to chase the invoice" is a task — filed as memory it
@@ -121,34 +134,35 @@ are, and there is no setting that would put them in a repository.
 
 ## Connect an account
 
-One command per account. Run it again to add a second mailbox, a second calendar, a second anything.
+**Over a hundred accounts and services, one command each.** Run it again to add a second mailbox, a
+second calendar, a second anything.
 
-| | Connect with |
+| | |
 |---|---|
-| Gmail | `lanes link connect gmail` |
-| Google Drive | `lanes link connect drive` |
-| Google Sheets | `lanes link connect sheets` |
-| Google Docs | `lanes link connect docs` |
-| Google Calendar | `lanes link connect calendar` |
-| Google Tasks | `lanes link connect google_tasks` |
-| Google Contacts | `lanes link connect contacts` |
-| iCloud Mail | `lanes link connect icloud_mail` |
-| iCloud Calendar | `lanes link connect icloud_calendar` |
-| iCloud Contacts | `lanes link connect icloud_contacts` |
-| iCloud Drive | `lanes link connect icloud_drive` |
-| Notion | `lanes link connect notion` |
-| Linear | `lanes link connect linear` |
-| GitHub | `lanes link connect github` |
-| Slack | `lanes link connect slack` |
-| Reddit | `lanes link connect reddit` |
-| Discord | `lanes link connect discord` |
-| Gmail (IMAP, app password) | `lanes link connect gmail_imap` |
-| Gmail (Google MCP) | `lanes link connect gmail_mcp` |
-| Drive (Google MCP) | `lanes link connect drive_mcp` |
-| bunq | `lanes link connect bunq` |
+| **Mail, calendar, contacts, files** | Gmail · Google Calendar · Google Drive · Google Docs · Google Sheets · Google Tasks · Google Contacts · iCloud Mail, Calendar, Contacts and Drive · Outlook Mail, Calendar and Contacts · OneDrive · Microsoft To Do · Fastmail · Zoho Mail · Yahoo Mail · Nextcloud · any IMAP mailbox |
+| **Work** | Notion · Linear · Slack · GitHub · Asana · Atlassian (Jira, Confluence) · Todoist · ClickUp · monday.com · Shortcut · Miro · Whimsical · Figma · Canva · Calendly · Fireflies · HubSpot |
+| **Money** | Stripe · PayPal · Square · Mercury · Ramp · bunq · Paddle · Recurly · Expensify |
+| **Build and run** | Sentry · Vercel · Netlify · Cloudflare · Supabase · Neon · Prisma · Heroku · CircleCI · Buildkite · Datadog · Grafana · Better Stack · Rootly · Flagsmith |
+| **Content and data** | Contentful · Storyblok · Hygraph · Sanity · Webflow · Wix · Algolia · PostHog · Mixpanel · Amplitude · RudderStack |
+| **Everything else** | Reddit · Discord · Dropbox · Box · Airtable · Zapier · Attio · Klaviyo · Salesloft · Vimeo · Mux · Replicate · Apify · Tavily · Bright Data |
+
+**[The full list, with the command for each →](https://lanes.sh/docs/link/connect)**
+
+Most of them need nothing set up. Seventy of them run their own MCP server and offer dynamic client
+registration, so `connect` registers us on the spot: browser, approve, done. The rest are one of
+three shapes — an app password you issue yourself (iCloud, Fastmail, Gmail over IMAP), a token you
+paste (GitHub, Discord), or an OAuth client of your own (Reddit, Microsoft). A few also ask *where*
+they are, because the address belongs to the account rather than the vendor — a Nextcloud you run,
+or any IMAP server.
+
+**Most of them are also untested**, and the tables say which. A provider marked † validates, generates
+tools inside the budget, and answers a probe — but nobody has connected it to a real account yet, and
+that is the part only a real account proves. See
+[`src/providers/README.md`](src/providers/README.md) for what that means and how the list is kept.
 
 Three things worth knowing up front. `lanes link connect icloud` sets up Mail, Calendar, and
-Contacts together, because one app-specific password covers all three. Reddit is the one that does
+Contacts together, because one app-specific password covers all three — and `lanes link connect
+fastmail` does the same for Fastmail's three. Reddit is the one that does
 need an app of your own — it rate-limits per client id, so a shared client would mean strangers
 spending your budget. Google and Slack need no
 OAuth client of your own: both authorise against the one Lanes operates, so there is no console to
@@ -158,10 +172,12 @@ token you paste rather than a browser sign-in, because it will not register a cl
 bunq — which wants a key from inside its app rather than a console at all — is the one that can move
 money, and it says so: its payment tool executes immediately and is not reversible. Set a spending
 limit on the API key while you are in there, and read
-[docs/detailed/setup/bunq.md](docs/detailed/setup/bunq.md) before connecting it.
+[Connecting bunq](https://lanes.sh/docs/link/bunq) before connecting it.
 
 Full guide — what each one gives your agent, what it needs, and adding your own:
-**[docs/connect.md](docs/connect.md)**.
+**[Connect your accounts](https://lanes.sh/docs/link/connect)**. How the provider layer works, and
+the whole inventory by connector and credential type:
+**[src/providers/README.md](src/providers/README.md)**.
 
 ## Run it anywhere
 
@@ -184,19 +200,20 @@ than being rebuilt.
 
 ## Docs
 
-- **[Quickstart](docs/quickstart.md)** — from nothing to a working endpoint
+- **[Quickstart](https://lanes.sh/docs/link/quickstart)** — from nothing to a working endpoint
 - **[In the Lanes desktop app](https://lanes.sh/docs/desktop/lanes-link)** — the page that drives it
-- **[Connect your accounts](docs/connect.md)** — every provider, and what each one needs
-- **[Add it to your agent](docs/clients.md)** — Claude Code, Codex, Claude Desktop, claude.ai, ChatGPT
-- **[Deploy to your own cloud](docs/deploy.md)** — five commands to a URL
-- **[Every command](docs/detailed/commands.md)** — arguments and flags, one entry each
-- **[Full reference](docs/detailed/)** — architecture, configuration, the CLI, the security model,
-  writing a provider, and the decision records
+- **[Connect your accounts](https://lanes.sh/docs/link/connect)** — every provider, and what each one needs
+- **[Add it to your agent](https://lanes.sh/docs/link/clients)** — Claude Code, Codex, Claude Desktop, claude.ai, ChatGPT
+- **[Deploy to your own cloud](https://lanes.sh/docs/link/deploy)** — five commands to a URL
+- **[Every command](https://lanes.sh/docs/link/commands)** — arguments and flags, one entry each
+- **[Full reference](https://lanes.sh/docs/link)** — architecture, configuration, the CLI, the
+  security model, and writing a provider
+- **[Decision records](docs/detailed/adr/)** — why each choice was made, kept here with the source
 
 ## Security
 
 Lanes Link holds live credentials to your email and documents. The
-[security model](docs/detailed/security.md) states its limits plainly rather than implying
+[security model](https://lanes.sh/docs/link/security) states its limits plainly rather than implying
 guarantees the code does not deliver — read it before you trust it with an account. To report a
 vulnerability, see [`SECURITY.md`](SECURITY.md); please do not open a public issue.
 

package/instructions/skills/lanes-link/SKILL.md

@@ -174,6 +174,31 @@ inventing something; they add one with `lanes link identity add <kind> <value> -
 --target <target>` — both flags, because neither has a fallback.
 Nothing you can call writes here, deliberately.
 
+## Who you are writing *to* is declared as well
+
+`entities_find` holds the people, companies and projects this owner deals with,
+with the addresses and handles to reach each of them. Call it before using
+anyone's address — do not recall one from earlier in the conversation, and do
+not lift one off a message you happen to have read.
+
+**It answers with every match and never chooses between them.** One match is an
+answer. More than one is a question: the reply shows what separates the
+candidates, so settle it from what you already know if that is genuinely
+unambiguous, and otherwise **ask**. Do not take the first — the order is not a
+ranking, and nothing about the reply is an error you need to work around.
+
+None matching is not a failure either. It means the owner has not written that
+person down, so ask rather than using an address from somewhere else.
+
+Where an entity holds two of a kind — a work address and a personal one — the
+first is the default and the notes say when to prefer the other, exactly as
+identity works.
+
+Writing is a separate grant. Where you have it, `entities_write` declares one
+and `entities_link` relates two; a field you do not send is left as it is.
+`entities_forget` does not clean up edges pointing at what it removed, and says
+which ones will dangle.
+
 ## Attachments are named, not carried
 
 Where a tool takes `attachments`, each entry names **one** source and the endpoint

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lanes-sh/link",
-  "version": "0.6.10",
+  "version": "0.7.0",
   "description": "A self-hostable MCP gateway for all your connections, memory, tasks, files, and secrets",
   "license": "Apache-2.0",
   "homepage": "https://lanes.sh/link",
@@ -54,7 +54,8 @@
     "audit": "bun audit",
     "vendor:bunq": "bun run ./src/providers/bunq/specs/vendor.ts",
     "vendor:discord": "bun run ./src/providers/discord/specs/vendor.ts",
-    "vendor:google": "bun run ./src/providers/google/specs/vendor.ts"
+    "vendor:google": "bun run ./src/providers/google/specs/vendor.ts",
+    "vendor:microsoft": "bun run ./src/providers/microsoft/specs/vendor.ts"
   },
   "imports": {
     "#audit": "./src/audit/index.ts",

package/src/audit/conformance.ts

@@ -358,7 +358,7 @@ export function describeAuditSinkContract(
       await use(async (fixture) => {
         // The append-only guarantee is the absence of these methods, so assert
         // the absence directly rather than trusting the interface to stay
-        // honest. `docs/detailed/security.md` lists `audit.append-only` as ENFORCED on
+        // honest. `https://lanes.sh/docs/link/security` lists `audit.append-only` as ENFORCED on
         // the grounds that the store interface has no update or delete — this
         // is the check behind that claim, and it holds for every adapter.
         const sink = fixture.open();

package/src/cli/argv.ts

@@ -107,7 +107,7 @@ export function globalFlags(flags: Flags): GlobalFlags {
  * The kebab-case spellings live here and nowhere else, so the one place that
  * knows `--display-name` is the one place that parses argv.
  */
-export function ownerFlags(flags: Flags): OwnerFlags {
+export function ownerFlags(flags: Flags, argv: readonly string[] = []): OwnerFlags {
   return {
     ...globalFlags(flags),
     show: flags['show'] === true,
@@ -124,10 +124,23 @@ export function ownerFlags(flags: Flags): OwnerFlags {
     due: text(flags, 'due'),
     name: text(flags, 'name'),
     contentType: text(flags, 'content-type'),
+    type: text(flags, 'type'),
+    // Repeatable, so read from argv rather than from the parsed map: `parseArgv`
+    // keeps only the last value of a repeated flag, and two email addresses on
+    // one entity is the case entities exists for. `customFlags` does the same.
+    alias: list(argv, 'alias'),
+    attr: list(argv, 'attr'),
+    related: list(argv, 'related'),
     yes: flags['yes'] === true,
   };
 }
 
+/** A repeatable flag's values, or undefined when it was not passed at all. */
+function list(argv: readonly string[], name: string): string[] | undefined {
+  const values = all(argv, name);
+  return values.length > 0 ? values : undefined;
+}
+
 /**
  * `lanes link knowledge`'s flags.
  *

package/src/cli/commands/connect/acquire.ts

@@ -0,0 +1,100 @@
+import type { ConfigDocument } from '../../config-edit.ts';
+import type { ProviderManifest } from '#connectivity';
+import type { SecretStore } from '#secrets';
+import type { Prompter } from '../../prompt.ts';
+import { authorise } from './authorise.ts';
+import { authoriseWithKey } from './assertion.ts';
+import { authorisePastedToken } from './pasted-token.ts';
+import { ensureStaticCredential } from './setup.ts';
+import type { ChosenMethod } from './method.ts';
+
+/**
+ * Getting the credential, whichever way this provider offers.
+ *
+ * Four routes and exactly one of them runs: a signed assertion from a key the
+ * operator holds, a token they paste, a browser round trip, or a static
+ * credential asked for and stored. `none` is the fifth case and does nothing —
+ * an `fs` provider has no account to prove.
+ *
+ * Its own file because it is the one part of `runConnect` that is a decision
+ * rather than a sequence, and because that file was at the size budget. Each arm
+ * already lives in a module of its own; this is only the choosing.
+ */
+export async function acquireCredential(input: {
+  readonly method: ChosenMethod;
+  readonly manifest: ProviderManifest;
+  readonly provisionalId: string;
+  readonly credentials: SecretStore;
+  readonly document: ConfigDocument;
+  readonly changes: string[];
+  readonly providerId: string;
+  readonly connections: readonly { readonly provider: string }[];
+  /** How the operator spelled the target, so a refusal names a command they typed. */
+  readonly target: string | undefined;
+  readonly profile: string;
+  readonly prompter: Prompter;
+  /** True when a name was given, which reads as "that one again". */
+  readonly named: boolean;
+  /** The connection id is still the placeholder, so nothing has been settled. */
+  readonly provisional: boolean;
+  readonly replace: boolean;
+  readonly nonInteractive: boolean;
+  readonly acceptBroadScopes: boolean;
+  readonly fetch?: typeof globalThis.fetch | undefined;
+}): Promise<void> {
+  const { manifest, method, provisionalId, prompter, changes, document } = input;
+  const { credentials, providerId, target, profile } = input;
+
+  /**
+   * "That one again", which is what asks for a value the store already has.
+   *
+   * Naming a connection says it, and so does `--replace`. Never
+   * non-interactively: there, again has already happened — the new value was
+   * written with `secrets set` before this ran, so asking would be asking for
+   * something the store is holding.
+   */
+  const askAgain = !input.nonInteractive && (input.replace || input.named);
+
+  if (method.kind === 'assertion') {
+    await authoriseWithKey({
+      manifest,
+      assertion: method.assertion,
+      connectionId: provisionalId,
+      credentials,
+      changes,
+      replace: askAgain,
+      prompter,
+    });
+  } else if (method.kind === 'pasted') {
+    await authorisePastedToken({
+      manifest,
+      connectionId: provisionalId,
+      credentials,
+      prompter,
+    });
+  } else if (manifest.auth.kind === 'oauth') {
+    await authorise({
+      manifest,
+      connectionId: provisionalId,
+      credentials,
+      document,
+      changes,
+      firstForProvider: !input.connections.some((c) => c.provider === providerId),
+      ...(target === undefined ? {} : { target }),
+      profile,
+      client: method.client,
+      prompter,
+      acceptBroadScopes: input.acceptBroadScopes,
+      ...(input.fetch ? { fetch: input.fetch } : {}),
+    });
+  } else if (manifest.auth.kind !== 'none') {
+    await ensureStaticCredential({
+      manifest,
+      connectionId: provisionalId,
+      credentials,
+      replace: askAgain,
+      provisional: input.provisional,
+      prompter,
+    });
+  }
+}

package/src/cli/commands/connect/custom/index.ts

@@ -35,7 +35,7 @@ import {
  * So this composes the two closed unions: a connectivity type and a credential
  * type. Anything not covered by a pair of them is not something to bolt on here
  * — it is a member missing from one of those lists, which is a folder and a
- * schema entry away. `docs/detailed/connectivity-coverage.md` is the standing
+ * schema entry away. `https://lanes.sh/docs/link/connectivity-coverage` is the standing
  * account of which pairs work, which are closed on purpose, and which are not
  * built yet.
  *

package/src/cli/commands/connect/declare.ts

@@ -24,8 +24,17 @@ export function declareConnection(input: {
   readonly label: string;
   /** Which route in, where the provider offered a choice. */
   readonly method: string | undefined;
+  /**
+   * Where this connection's service is, for a provider that asked.
+   *
+   * Empty for every provider whose address is fixed, which is almost all of
+   * them. Written on a reconnect as well as on an add: the operator may be
+   * reconnecting *because* the server moved.
+   */
+  readonly config: Readonly<Record<string, string>>;
 }): readonly string[] {
   const { document, connections, providerId, connectionId, account, label, method } = input;
+  const config = input.config;
 
   const key = `${providerId}.${connectionId}`;
   const index = connections.findIndex((c) => `${c.provider}.${c.id}` === key);
@@ -44,6 +53,7 @@ export function declareConnection(input: {
       provider: providerId,
       account,
       ...(label === account ? {} : { label }),
+      ...(Object.keys(config).length > 0 ? { config } : {}),
     });
     changes.push(`connections += ${key} (${account})`);
     return changes;
@@ -67,6 +77,15 @@ export function declareConnection(input: {
     changes.push(`connections.${key}.label = ${label}`);
   }
 
+  // The address, when the provider has one to keep. Written whenever it differs,
+  // because a reconnect is exactly when a self-hosted service has moved — and a
+  // row whose config is silently stale points the credential at the old host.
+  for (const [key_, value] of Object.entries(config)) {
+    if ((declared?.config as Record<string, unknown> | undefined)?.[key_] === value) continue;
+    document.setIn(['connections', index, 'config', key_], value);
+    changes.push(`connections.${key}.config.${key_} = ${value}`);
+  }
+
   // Named where the provider offered a choice, because this is the line an
   // operator reads to see that a re-connect swapped the route rather than
   // refreshed it — and `--auth` reaches here having asked nothing. Unnamed for a