@invitedlabs/cli 0.0.0-stage → 0.2.0

package/LICENSE

@@ -0,0 +1,55 @@
+Apache License
+
+Version 2.0, January 2004
+
+http://www.apache.org/licenses/ 
+
+TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+1. Definitions.
+
+"License" shall mean the terms and conditions for use, reproduction, and distribution as defined by Sections 1 through 9 of this document.
+
+"Licensor" shall mean the copyright owner or entity authorized by the copyright owner that is granting the License.
+
+"Legal Entity" shall mean the union of the acting entity and all other entities that control, are controlled by, or are under common control with that entity. For the purposes of this definition, "control" means (i) the power, direct or indirect, to cause the direction or management of such entity, whether by contract or otherwise, or (ii) ownership of fifty percent (50%) or more of the outstanding shares, or (iii) beneficial ownership of such entity.
+
+"You" (or "Your") shall mean an individual or Legal Entity exercising permissions granted by this License.
+
+"Source" form shall mean the preferred form for making modifications, including but not limited to software source code, documentation source, and configuration files.
+
+"Object" form shall mean any form resulting from mechanical transformation or translation of a Source form, including but not limited to compiled object code, generated documentation, and conversions to other media types.
+
+"Work" shall mean the work of authorship, whether in Source or Object form, made available under the License, as indicated by a copyright notice that is included in or attached to the work (an example is provided in the Appendix below).
+
+"Derivative Works" shall mean any work, whether in Source or Object form, that is based on (or derived from) the Work and for which the editorial revisions, annotations, elaborations, or other modifications represent, as a whole, an original work of authorship. For the purposes of this License, Derivative Works shall not include works that remain separable from, or merely link (or bind by name) to the interfaces of, the Work and Derivative Works thereof.
+
+"Contribution" shall mean any work of authorship, including the original version of the Work and any modifications or additions to that Work or Derivative Works thereof, that is intentionally submitted to Licensor for inclusion in the Work by the copyright owner or by an individual or Legal Entity authorized to submit on behalf of the copyright owner. For the purposes of this definition, "submitted" means any form of electronic, verbal, or written communication sent to the Licensor or its representatives, including but not limited to communication on electronic mailing lists, source code control systems, and issue tracking systems that are managed by, or on behalf of, the Licensor for the purpose of discussing and improving the Work, but excluding communication that is conspicuously marked or otherwise designated in writing by the copyright owner as "Not a Contribution."
+
+"Contributor" shall mean Licensor and any individual or Legal Entity on behalf of whom a Contribution has been received by Licensor and subsequently incorporated within the Work.
+
+2. Grant of Copyright License. Subject to the terms and conditions of this License, each Contributor hereby grants to You a perpetual, worldwide, non-exclusive, no-charge, royalty-free, irrevocable copyright license to reproduce, prepare Derivative Works of, publicly display, publicly perform, sublicense, and distribute the Work and such Derivative Works in Source or Object form.
+
+3. Grant of Patent License. Subject to the terms and conditions of this License, each Contributor hereby grants to You a perpetual, worldwide, non-exclusive, no-charge, royalty-free, irrevocable (except as stated in this section) patent license to make, have made, use, offer to sell, sell, import, and otherwise transfer the Work, where such license applies only to those patent claims licensable by such Contributor that are necessarily infringed by their Contribution(s) alone or by combination of their Contribution(s) with the Work to which such Contribution(s) was submitted. If You institute patent litigation against any entity (including a cross-claim or counterclaim in a lawsuit) alleging that the Work or a Contribution incorporated within the Work constitutes direct or contributory patent infringement, then any patent licenses granted to You under this License for that Work shall terminate as of the date such litigation is filed.
+
+4. Redistribution. You may reproduce and distribute copies of the Work or Derivative Works thereof in any medium, with or without modifications, and in Source or Object form, provided that You meet the following conditions:
+
+You must give any other recipients of the Work or Derivative Works a copy of this License; and
+
+You must cause any modified files to carry prominent notices stating that You changed the files; and
+
+You must retain, in the Source form of any Derivative Works that You distribute, all copyright, patent, trademark, and attribution notices from the Source form of the Work, excluding those notices that do not pertain to any part of the Derivative Works; and
+
+If the Work includes a "NOTICE" text file as part of its distribution, then any Derivative Works that You distribute must include a readable copy of the attribution notices contained within such NOTICE file, excluding those notices that do not pertain to any part of the Derivative Works, in at least one of the following places: within a NOTICE text file distributed as part of the Derivative Works; within the Source form or documentation, if provided along with the Derivative Works; or, within a display generated by the Derivative Works, if and wherever such third-party notices normally appear. The contents of the NOTICE file are for informational purposes only and do not modify the License. You may add Your own attribution notices within Derivative Works that You distribute, alongside or as an addendum to the NOTICE text from the Work, provided that such additional attribution notices cannot be construed as modifying the License. You may add Your own copyright statement to Your modifications and may provide additional or different license terms and conditions for use, reproduction, or distribution of Your modifications, or for any such Derivative Works as a whole, provided Your use, reproduction, and distribution of the Work otherwise complies with the conditions stated in this License.
+
+5. Submission of Contributions. Unless You explicitly state otherwise, any Contribution intentionally submitted for inclusion in the Work by You to the Licensor shall be under the terms and conditions of this License, without any additional terms or conditions. Notwithstanding the above, nothing herein shall supersede or modify the terms of any separate license agreement you may have executed with Licensor regarding such Contributions.
+
+6. Trademarks. This License does not grant permission to use the trade names, trademarks, service marks, or product names of the Licensor, except as required for reasonable and customary use in describing the origin of the Work and reproducing the content of the NOTICE file.
+
+7. Disclaimer of Warranty. Unless required by applicable law or agreed to in writing, Licensor provides the Work (and each Contributor provides its Contributions) on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied, including, without limitation, any warranties or conditions of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A PARTICULAR PURPOSE. You are solely responsible for determining the appropriateness of using or redistributing the Work and assume any risks associated with Your exercise of permissions under this License.
+
+8. Limitation of Liability. In no event and under no legal theory, whether in tort (including negligence), contract, or otherwise, unless required by applicable law (such as deliberate and grossly negligent acts) or agreed to in writing, shall any Contributor be liable to You for damages, including any direct, indirect, special, incidental, or consequential damages of any character arising as a result of this License or out of the use or inability to use the Work (including but not limited to damages for loss of goodwill, work stoppage, computer failure or malfunction, or any and all other commercial damages or losses), even if such Contributor has been advised of the possibility of such damages.
+
+9. Accepting Warranty or Additional Liability. While redistributing the Work or Derivative Works thereof, You may choose to offer, and charge a fee for, acceptance of support, warranty, indemnity, or other liability obligations and/or rights consistent with this License. However, in accepting such obligations, You may act only on Your own behalf and on Your sole responsibility, not on behalf of any other Contributor, and only if You agree to indemnify, defend, and hold each Contributor harmless for any liability incurred by, or claims asserted against, such Contributor by reason of your accepting any such warranty or additional liability.
+
+END OF TERMS AND CONDITIONS

package/README.md

@@ -1,3 +1,80 @@
-# Temporary Holding Version
+# invited
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+The `invited` command connects terminal agents and AI assistants to your Invited Identity. It is a client of Invited's MCP connector (`https://invited.you/mcp`), the same connector Claude and ChatGPT use: it sets up the connector in Claude Code, Cursor, Codex CLI and Gemini CLI, and it can log in itself to print, in a terminal, the fragments you share with it.
+
+It reads only the fragments you choose on Invited's consent screen, for as long as you chose, like every connected assistant. It never reads your Invited Page, which is for the people and programs that visit it. It holds an OAuth log-in like any other connected assistant, never a vault key, and decrypts nothing.
+
+## Install
+
+Node 22.13 or later. Nothing else is installed: the CLI has no dependencies and uses only Node's own modules (`fetch`, `node:crypto`, `node:http`, `node:fs`).
+
+```sh
+npx @invitedlabs/cli connect claude-code   # add Invited to Claude Code, which then logs in itself
+npx @invitedlabs/cli login                 # or log this CLI in: you approve in your browser
+npx @invitedlabs/cli whoami                # then print the fragments you share with it
+```
+
+or install it once with `npm install --global @invitedlabs/cli` and run `invited …`.
+
+From a checkout of the platform repository, `npm run build:cli` builds `cli/dist` (`npm run build` does it too); then run `node cli/dist/index.js --help`.
+
+## Commands
+
+Every command prints plain English, exits 0 when it did what was asked and 1 otherwise, and uses no colour (set `FORCE_COLOR=1` for bold headings; `NO_COLOR` always wins). `--origin <url>` (or `INVITED_ORIGIN`) points any command at another Invited, such as a local one on `http://127.0.0.1:4180`; the default is `https://invited.you`.
+
+| Command | What it does |
+| --- | --- |
+| `invited connect <host>` | Adds Invited's MCP server to `claude-code`, `cursor`, `codex` or `gemini` as `invited`, keeping every other server in the file as it is. The host then logs in to Invited itself. `--dry-run` prints what it would write and writes nothing; `--bridge` writes the `mcp-remote` bridge instead (`npx -y mcp-remote@0.14.3 https://invited.you/mcp`, pinned to the reviewed version) for a host version without remote log-in; `--config <file>` edits another file. |
+| `invited login` | Logs this CLI in to your Identity. Your browser opens Invited's consent screen ("Connect your Identity?", its box naming Invited CLI): you choose the fragments it may read and for how long (30 days, 7 days, 24 hours, or until you disconnect), approve it, and the browser returns to the CLI, which says how many fragments it can read. `--no-browser` prints the address to open instead (an SSH session, say). `--private`, which 0.1.0 needed to share fragments, is still taken: every log-in asks now. |
+| `invited whoami` | Prints the fragments you share with this CLI as Markdown, by section, and when that sharing ends (`invited://identity`). `--json` prints `invited://identity.json`: the same as JSON. |
+| `invited fragments --type <type>` | Prints the fragments you share with this CLI of one or more types (`get_fragments`); repeat `--type` for more. Types are keys such as `skill`, `language`, `experience`, `cuisines` or `dietaryPreferences`. `--json` prints the structured answer. |
+| `invited fragments --search <words>` | Prints the fragments you share with this CLI that match, best first (`search_fragments`). |
+| `invited private` | Prints the fragments you share with this CLI (`private_fragments`) and when that sharing ends. `--type <type>` (repeatable) prints only those types; `--json` prints the structured answer. |
+| `invited status` | Shows the log-in this CLI holds: your Identity, its scopes (`identity:private` while you share fragments with it), when it was last used and when it expires. `--json` prints the same as JSON, with `assistantsUrl`, the address of Activity's Assistants. It reads the credentials file only. |
+| `invited logout` | Revokes this CLI's own log-in at Invited and deletes its credentials. `invited revoke` does the same. |
+| `invited --help`, `invited help <command>`, `invited --version` | Help and the version. |
+
+When nothing is shared with the CLI (you shared none, or the time you chose has ended), `whoami`, `fragments` and `private` say so: run `invited login` to choose again.
+
+Where `connect` writes, and how each host logs in:
+
+| Host | File | Entry | Log in |
+| --- | --- | --- | --- |
+| Claude Code | `~/.claude.json` (user scope) | `"invited": { "type": "http", "url": "https://invited.you/mcp" }` | `claude mcp login invited`, or `/mcp` in Claude Code |
+| Cursor | `~/.cursor/mcp.json` | `"invited": { "url": "https://invited.you/mcp" }` | Customize > MCP in Cursor |
+| Codex CLI | `~/.codex/config.toml` (`$CODEX_HOME`) | `[mcp_servers.invited]` `url = "https://invited.you/mcp"` | `codex mcp login invited` |
+| Gemini CLI | `~/.gemini/settings.json` | `"invited": { "httpUrl": "https://invited.you/mcp" }` | when Gemini CLI first connects; `/mcp auth invited` again |
+
+A file the CLI cannot edit safely (JSON with comments, a TOML table written inline) is left as it is, and the CLI prints the entry to add by hand. Running `connect` again changes nothing.
+
+## Your log-in
+
+`invited login` is OAuth 2.1 with PKCE as the pre-registered public client `invited-cli`. While you approve, the CLI listens on `http://127.0.0.1:<port>/callback`, on a port the system picks, bound to this computer only. The listener accepts one answer, the one carrying this log-in's `state` and Invited's `iss`, and closes as soon as it arrives, or after 5 minutes.
+
+The log-in is kept in `~/.invited/credentials.json` (set `INVITED_CONFIG_DIR` to keep it elsewhere): the refresh token, your Identity's id, its scopes, and when it was made and last used (and, empty since 0.2.0, the Page address 0.1.0 kept). The file is written with mode 0600 in a 0700 folder (on Windows, your user profile's permissions protect it). Access tokens are never written: each command renews one in memory, and Invited issues a new refresh token every time, so the file changes after every command. Two commands at once wait for each other rather than renew the same token.
+
+A log-in lasts 30 days from its last use, and 90 days at most; then run `invited login` again.
+
+## Reads and the budget
+
+`whoami`, `fragments` and `private` are reads of what you share with the CLI, the same reads a connected assistant makes. Each one appears in your access log in Activity, Reads, as Invited CLI. Invited allows each connection 60 reads a minute; every Invited CLI logged in to your Identity shares one connection, so they share that budget. Past it, the CLI says how many seconds to wait.
+
+## What it reads
+
+Fragments reach the CLI only when you share them on the consent screen (`invited login`), and only for as long as you chose. While they are shared, Invited's server can read those fragments to pass them to the CLI; with your vault on, everything else stays sealed. Activity, Assistants shows what is shared and until when, and Disconnect ends it at once.
+
+## Removing it
+
+1. `invited logout` revokes the log-in and deletes `~/.invited/credentials.json` (the folder `~/.invited` can then go too).
+2. To remove the connection itself, use Activity, Assistants: https://invited.you/app/activity?tab=assistants. Its reads stay in your access log for 3 months. The CLI can end only its own log-in; other assistants are disconnected there.
+3. Remove the `invited` entry from each host you connected (`claude mcp remove invited`, or delete it from the file listed above).
+4. `npm uninstall --global @invitedlabs/cli` if you installed it.
+
+## Changes in 0.2.0
+
+- The CLI reads only the fragments you share with it, never your Page, as every connected assistant does since 8 November 2026. `invited login` always asks you to choose them (`--private` is still taken); `whoami` and `fragments` print them; `status` no longer shows a Page. 0.1.0 reads only after `invited login --private`, and its `invited fragments` answers "Invited answered in a form this CLI does not know.": update to 0.2.0.
+
+- Connected assistants and their reads are in Activity now, not Settings: `invited status`, the messages and this README send you to Activity, Assistants (https://invited.you/app/activity?tab=assistants).
+- `invited status --json` names that address `assistantsUrl`. In 0.1.0 it was `settingsUrl`, which is gone: a script that read it reads `assistantsUrl` instead.
+- Your access log keeps each read for 3 months.
+- "Log in" and "log out" in every message, as on invited.you. The commands are still `invited login` and `invited logout`.

package/dist/args.js

@@ -0,0 +1,95 @@
+import { CliError } from './errors.js';
+const VALUES = {
+    '--origin': 'origin',
+    '--config': 'config',
+    '--search': 'search',
+    '--type': 'type',
+};
+const SWITCHES = {
+    '--json': 'json',
+    '--dry-run': 'dryRun',
+    '--bridge': 'bridge',
+    '--no-browser': 'noBrowser',
+    '--private': 'private',
+    '--help': 'help',
+    '-h': 'help',
+    '--version': 'version',
+    '-v': 'version',
+};
+/** Which options each command takes (help and version go with any). */
+export const COMMAND_OPTIONS = {
+    connect: ['--origin', '--dry-run', '--bridge', '--config'],
+    login: ['--origin', '--no-browser', '--private'],
+    whoami: ['--origin', '--json'],
+    fragments: ['--origin', '--json', '--type', '--search'],
+    private: ['--origin', '--json', '--type'],
+    status: ['--origin', '--json'],
+    logout: ['--origin'],
+    revoke: ['--origin'],
+    help: [],
+};
+export function parseArgs(argv) {
+    const flags = {
+        types: [],
+        json: false,
+        dryRun: false,
+        bridge: false,
+        noBrowser: false,
+        private: false,
+        help: false,
+        version: false,
+    };
+    const positionals = [];
+    const given = new Set();
+    let command = null;
+    for (let i = 0; i < argv.length; i++) {
+        const arg = argv[i];
+        if (arg === '--') {
+            positionals.push(...argv.slice(i + 1));
+            break;
+        }
+        if (!arg.startsWith('-') || arg === '-') {
+            if (command === null)
+                command = arg;
+            else
+                positionals.push(arg);
+            continue;
+        }
+        const equals = arg.startsWith('--') ? arg.indexOf('=') : -1;
+        const name = equals > 0 ? arg.slice(0, equals) : arg;
+        const inline = equals > 0 ? arg.slice(equals + 1) : undefined;
+        if (name in VALUES) {
+            const value = inline ?? argv[++i];
+            if (value === undefined || value === '' || (inline === undefined && value.startsWith('--')))
+                throw new CliError(`${name} needs a value.`);
+            const key = VALUES[name];
+            if (key === 'type')
+                flags.types.push(...value
+                    .split(',')
+                    .map(type => type.trim())
+                    .filter(Boolean));
+            else if (flags[key] !== undefined)
+                throw new CliError(`Give ${name} once.`);
+            else
+                flags[key] = value;
+        }
+        else if (name in SWITCHES) {
+            if (inline !== undefined)
+                throw new CliError(`${name} takes no value.`);
+            flags[SWITCHES[name]] = true;
+        }
+        else
+            throw new CliError(`Unknown option ${name}. Run \`invited --help\` to see the options.`);
+        given.add(name.startsWith('--') ? name : name === '-h' ? '--help' : '--version');
+    }
+    return { command, positionals, flags, given };
+}
+/** Refuse an option the command does not take, so nothing is silently ignored. */
+export function checkOptions(command, given) {
+    const allowed = COMMAND_OPTIONS[command] ?? [];
+    for (const name of given)
+        if (name !== '--help' && name !== '--version' && !allowed.includes(name))
+            throw new CliError(allowed.length
+                ? `\`invited ${command}\` does not take ${name}. It takes: ${allowed.join(', ')}.`
+                : `\`invited ${command}\` takes no options.`);
+}

package/dist/browser.js

@@ -0,0 +1,29 @@
+import { spawn } from 'node:child_process';
+/**
+ * Opens an http(s) address in the person's browser without a shell: the
+ * address is one argument to the system's opener, never parsed by cmd or sh.
+ * Resolves false when the opener cannot start (no desktop, an SSH session);
+ * the address is printed either way.
+ */
+export function openBrowser(url, platform) {
+    if (!/^https?:\/\//.test(url))
+        return Promise.resolve(false);
+    const [command, args] = platform === 'win32'
+        ? ['rundll32', ['url.dll,FileProtocolHandler', url]]
+        : platform === 'darwin'
+            ? ['open', [url]]
+            : ['xdg-open', [url]];
+    return new Promise(resolve => {
+        try {
+            const child = spawn(command, args, { stdio: 'ignore', detached: true, windowsHide: true });
+            child.once('error', () => resolve(false));
+            child.once('spawn', () => {
+                child.unref();
+                resolve(true);
+            });
+        }
+        catch {
+            resolve(false);
+        }
+    });
+}

package/dist/commands.js

@@ -0,0 +1,344 @@
+import { CliError } from './errors.js';
+import { refreshExpiry } from './credentials.js';
+import { duration, formatTime, plural } from './format.js';
+import { listenForCallback } from './loopback.js';
+import { McpError, mcpRequest, ScopeRefused } from './mcp.js';
+import { authorizationUrl, CLIENT_ID, discover, exchangeCode, GrantRefused, newState, pkcePair, PRIVATE_SCOPE, PUBLIC_SCOPE, refreshTokens, revokeRefreshToken, } from './oauth.js';
+/** Activity's Assistants, where every connected assistant is listed and disconnected (owner, 3 November 2026: what
+ * sent members to Settings for assistants and the access log says Activity; Settings keeps one row linking there). */
+export const assistantsUrl = (origin) => `${origin}/app/activity?tab=assistants`;
+export const assistantsLine = (origin) => `Manage every connected assistant in Activity at ${assistantsUrl(origin)}.`;
+const iso = (time) => new Date(time).toISOString();
+const notConnected = (origin) => new CliError(`The Invited CLI is not connected to ${origin}. Run \`invited login\` to connect it.`);
+/** Access tokens for this command: one renewal (refresh token rotation)
+ * under the credentials lock, kept in memory only and renewed again when it
+ * nears its hour or the server refuses it. */
+export function accessTokens(ctx, primed) {
+    let current = primed ?? null;
+    return async (force) => {
+        if (current && !force && current.expiresAt - 60_000 > ctx.now())
+            return current.token;
+        current = await ctx.store.locked(async () => {
+            const file = await ctx.store.read();
+            const connection = file.connections[ctx.origin];
+            if (!connection)
+                throw notConnected(ctx.origin);
+            let tokens;
+            try {
+                tokens = await refreshTokens(ctx.fetch, connection, ctx.now());
+            }
+            catch (error) {
+                if (error instanceof GrantRefused)
+                    throw new CliError(`Invited did not renew this CLI's log-in: ${error.description} Run \`invited login\` to connect again.`);
+                throw error;
+            }
+            file.connections[ctx.origin] = {
+                ...connection,
+                refreshToken: tokens.refreshToken,
+                scopes: tokens.scopes,
+                identityId: tokens.identityId,
+                lastUsedAt: iso(ctx.now()),
+            };
+            await ctx.store.write(file);
+            return { token: tokens.accessToken, expiresAt: tokens.accessExpiresAt };
+        });
+        return current.token;
+    };
+}
+/** Nothing is shared with the CLI now (it was given none, or the sharing ended): the member chooses again. */
+export const NOTHING_SHARED = 'Nothing is shared with the CLI right now. Run `invited login` to choose the fragments it may read.';
+/** An answer read as every read writes it, or the CLI says it does not know the form. */
+function inScopeOf(value) {
+    const data = value;
+    if (typeof data !== 'object' ||
+        data === null ||
+        !(data.expiresAt === null || typeof data.expiresAt === 'string') ||
+        !Array.isArray(data.fragments))
+        throw new CliError('Invited answered in a form this CLI does not know.');
+    return data;
+}
+/** A read's refusal in the CLI's words: nothing shared now is the way to share again. */
+function refused(error) {
+    if (error instanceof ScopeRefused && error.scope === PRIVATE_SCOPE)
+        throw new CliError(NOTHING_SHARED);
+    if (error instanceof McpError)
+        throw new CliError(error.message);
+    throw error;
+}
+/** One tool call: its answer, from its structured content or the JSON its text carries. A tool error is the server's
+ * explanation (an unknown type). The Profile photo's image, after the JSON, is not printed: a terminal shows its
+ * answer as any other, the path the JSON holds on its first line and its caption, if any, under it. */
+async function callTool(ctx, name, args) {
+    let result;
+    try {
+        result = await mcpRequest(ctx.fetch, ctx.origin, accessTokens(ctx), 'tools/call', { name, arguments: args });
+    }
+    catch (error) {
+        refused(error);
+    }
+    const blocks = Array.isArray(result.content) ? result.content : [];
+    const texts = blocks.flatMap(item => (item && typeof item === 'object' && 'text' in item ? [String(item.text)] : []));
+    if (result.isError === true)
+        throw new CliError(texts.join('\n') || 'Invited could not read those fragments.');
+    if (result.structuredContent !== undefined)
+        return inScopeOf(result.structuredContent);
+    try {
+        return inScopeOf(JSON.parse(texts.findLast(text => text.trimStart().startsWith('{')) ?? ''));
+    }
+    catch (error) {
+        if (error instanceof CliError)
+            throw error;
+        throw new CliError('Invited answered in a form this CLI does not know.');
+    }
+}
+async function readResource(ctx, token, uri) {
+    const result = await mcpRequest(ctx.fetch, ctx.origin, token, 'resources/read', { uri });
+    const content = (Array.isArray(result.contents) ? result.contents[0] : null);
+    if (typeof content?.text !== 'string')
+        throw new CliError('Invited answered without the document.');
+    return content.text;
+}
+/** How long the sharing lasts, in words. An edit never ends it (owner, 8 November 2026: under Current and Specify an
+ * edit updates the shared copy, as under Automatic). */
+const lasting = (ctx, expiresAt) => expiresAt ? `until ${formatTime(expiresAt, ctx.timeZone)}` : 'until you disconnect it in Activity';
+/** A fragment as the CLI prints it: its name, then its answer, a line at a time. */
+const shownFragment = (ctx, fragment) => `${ctx.style.bold(fragment.label)}: ${fragment.answer.replace(/\r?\n/g, '\n  ')}`;
+// login ----------------------------------------------------------------------
+/** Every log-in asks for identity:private (owner, 8 November 2026): the connector serves only the fragments the
+ * member chooses on the consent screen, so a log-in with identity:public alone reads nothing. `--private`, 0.1.0's way
+ * to ask for it, is still taken. */
+export async function login(ctx, options) {
+    const { noBrowser } = options;
+    const endpoints = await discover(ctx.fetch, ctx.origin);
+    const { verifier, challenge } = pkcePair();
+    const state = newState();
+    const callback = await listenForCallback({
+        state,
+        issuer: endpoints.issuer,
+        requireIss: endpoints.issInResponse,
+        timeoutMs: ctx.loginTimeoutMs,
+    });
+    let tokens;
+    try {
+        const url = authorizationUrl(endpoints, callback.redirectUri, challenge, state, [PUBLIC_SCOPE, PRIVATE_SCOPE]);
+        ctx.out('To connect the Invited CLI to your Identity, approve it in your browser and choose the fragments it may read.\n');
+        const opened = !noBrowser && (await ctx.openBrowser(url));
+        ctx.out((opened
+            ? 'Your browser should open. If it does not, open this address:\n'
+            : 'Open this address in your browser:\n') +
+            `${url}\nWaiting for your approval (up to ${duration(ctx.loginTimeoutMs)})...\n`);
+        const outcome = await callback.outcome;
+        if (!outcome.ok)
+            throw new CliError(outcome.message);
+        try {
+            tokens = await exchangeCode(ctx.fetch, endpoints, { code: outcome.code, verifier, redirectUri: callback.redirectUri }, ctx.now());
+        }
+        catch (error) {
+            if (error instanceof GrantRefused)
+                throw new CliError(`Invited did not finish logging you in: ${error.description} Run \`invited login\` again.`);
+            throw error;
+        }
+    }
+    finally {
+        callback.close();
+    }
+    const now = iso(ctx.now());
+    const connection = {
+        origin: ctx.origin,
+        clientId: CLIENT_ID,
+        resource: endpoints.resource,
+        tokenEndpoint: endpoints.token,
+        revocationEndpoint: endpoints.revocation,
+        identityId: tokens.identityId,
+        scopes: tokens.scopes,
+        refreshToken: tokens.refreshToken,
+        connectedAt: now,
+        lastUsedAt: now,
+        // No read names a Page since 8 November 2026; kept, null, so an older CLI still reads the file.
+        pageUrl: null,
+        pageReadAt: null,
+    };
+    const previous = await ctx.store.locked(async () => {
+        const file = await ctx.store.read();
+        const before = file.connections[ctx.origin];
+        file.connections[ctx.origin] = connection;
+        await ctx.store.write(file);
+        return before;
+    });
+    // A log-in this one replaces ends now rather than in 30 days.
+    if (previous)
+        await revokeRefreshToken(ctx.fetch, previous).catch(() => undefined);
+    // One read says what it may read; the connection stands either way. Shared nothing, it reads nothing: since migration
+    // 190 that read is an empty list, before it a refusal, and the CLI says the same of both.
+    const none = 'Connected, but you shared no fragments with it, so it can read nothing. Run `invited login` again to choose some.';
+    let read = none, reads = false;
+    if (tokens.scopes.includes(PRIVATE_SCOPE))
+        try {
+            const shared = inScopeOf(JSON.parse(await readResource(ctx, accessTokens(ctx, { token: tokens.accessToken, expiresAt: tokens.accessExpiresAt }), 'invited://identity.json')));
+            reads = shared.fragments.length > 0;
+            read = reads
+                ? `Connected. The Invited CLI can read ${plural(shared.fragments.length, 'fragment')} you chose to share with it, ${lasting(ctx, shared.expiresAt)}.`
+                : none;
+        }
+        catch (error) {
+            if (error instanceof ScopeRefused)
+                read = none;
+            else if (error instanceof CliError)
+                read = `Connected, but your fragments could not be read just now: ${error.message}`;
+            else if (error instanceof SyntaxError)
+                read = 'Connected, but Invited answered in a form this CLI does not know.';
+            else
+                throw error;
+        }
+    ctx.out(`${read}\n` +
+        `Its log-in is saved in ${ctx.store.path} and lasts 30 days from its last use (90 days at most).\n` +
+        (reads ? 'Try: invited whoami\n' : ''));
+}
+// whoami ---------------------------------------------------------------------
+/** The fragments the member lets the CLI read, as Markdown (invited://identity), or as JSON (invited://identity.json). */
+export async function whoami(ctx, json) {
+    let text;
+    try {
+        text = await readResource(ctx, accessTokens(ctx), json ? 'invited://identity.json' : 'invited://identity');
+    }
+    catch (error) {
+        refused(error);
+    }
+    ctx.out(text.endsWith('\n') ? text : text + '\n');
+}
+// fragments ------------------------------------------------------------------
+/** The fragments the member lets the CLI read, of some types (get_fragments) or that match some words, best first
+ * (search_fragments). */
+export async function fragments(ctx, options) {
+    if (options.types.length && options.search !== undefined)
+        throw new CliError('Use --type or --search, not both.');
+    if (!options.types.length && options.search === undefined)
+        throw new CliError('Name a fragment type with --type <type> (repeat it for more), or search with --search <words>. For example: invited fragments --type skill');
+    const types = [...new Set(options.types)];
+    const data = types.length
+        ? await callTool(ctx, 'get_fragments', { types })
+        : await callTool(ctx, 'search_fragments', { query: options.search });
+    if (options.json) {
+        ctx.out(JSON.stringify(data, null, 2) + '\n');
+        return;
+    }
+    const list = data.fragments;
+    const what = types.length
+        ? `of type ${types.join(', ')}`
+        : `matching "${options.search}"${list.length > 1 ? ', best first' : ''}`;
+    if (!list.length) {
+        ctx.out(`No shared fragments ${what}.\n`);
+        return;
+    }
+    const lines = [`${plural(list.length, 'shared fragment')} ${what}`, ''];
+    for (const fragment of list)
+        lines.push(shownFragment(ctx, fragment));
+    ctx.out(lines.join('\n') + '\n');
+}
+// private --------------------------------------------------------------------
+/** private_fragments: the fragments the member shares with the CLI (step 4b), and when that sharing ends. Nothing
+ * shared (none was, it ended, or the log-in has only the public scope) is the message to choose again. */
+export async function privateFragments(ctx, options) {
+    const types = [...new Set(options.types)];
+    const data = await callTool(ctx, 'private_fragments', types.length ? { types } : {});
+    if (options.json) {
+        ctx.out(JSON.stringify(data, null, 2) + '\n');
+        return;
+    }
+    const list = data.fragments;
+    const until = lasting(ctx, data.expiresAt);
+    const what = types.length ? ` of type ${types.join(', ')}` : '';
+    if (!list.length) {
+        ctx.out(`No fragments${what} are shared with the Invited CLI. Its sharing lasts ${until}.\n`);
+        return;
+    }
+    const lines = [`${plural(list.length, 'fragment')}${what} shared with the Invited CLI ${until}.`, ''];
+    for (const fragment of list)
+        lines.push(shownFragment(ctx, fragment));
+    lines.push('', assistantsLine(ctx.origin));
+    ctx.out(lines.join('\n') + '\n');
+}
+// status ---------------------------------------------------------------------
+/** What this CLI holds, from its credentials file alone: no network. Listing
+ * other assistants needs the member's browser session (Activity). */
+export async function status(ctx, json) {
+    const file = await ctx.store.read();
+    const connection = file.connections[ctx.origin];
+    if (!connection) {
+        if (json)
+            ctx.out(JSON.stringify({ connected: false, origin: ctx.origin }, null, 2) + '\n');
+        else
+            ctx.out(`The Invited CLI is not connected to ${ctx.origin}. Run \`invited login\` to connect it.\n`);
+        return 1;
+    }
+    const { expiresAt, latest } = refreshExpiry(connection);
+    const expired = expiresAt <= ctx.now();
+    if (json) {
+        ctx.out(JSON.stringify({
+            connected: !expired,
+            origin: connection.origin,
+            clientId: connection.clientId,
+            identityId: connection.identityId,
+            // No read names a Page since 8 November 2026: null unless an older CLI's log-in named one.
+            pageUrl: connection.pageUrl,
+            pageReadAt: connection.pageReadAt,
+            scopes: connection.scopes,
+            connectedAt: connection.connectedAt,
+            lastUsedAt: connection.lastUsedAt,
+            expiresAt: iso(expiresAt),
+            expiresAtLatest: iso(latest),
+            credentialsFile: ctx.store.path,
+            assistantsUrl: assistantsUrl(ctx.origin),
+        }, null, 2) + '\n');
+        return expired ? 1 : 0;
+    }
+    const time = (value) => formatTime(value, ctx.timeZone);
+    const reads = connection.scopes.includes(PRIVATE_SCOPE);
+    // The public scope first, as every connection holds it.
+    const scopes = [...connection.scopes]
+        .sort((a, b) => Number(b === PUBLIC_SCOPE) - Number(a === PUBLIC_SCOPE))
+        .map(scope => (scope === PRIVATE_SCOPE ? 'identity:private (the fragments you chose to share with it)' : scope))
+        .join(', ');
+    const rows = [
+        ['Identity', connection.identityId],
+        ['Scopes', scopes],
+        ['Connected', time(connection.connectedAt)],
+        ['Last used', time(connection.lastUsedAt)],
+        [
+            expired ? 'Expired' : 'Expires',
+            expired
+                ? `${time(expiresAt)}: run \`invited login\``
+                : `${time(expiresAt)} unless used before then (${time(latest)} at the latest)`,
+        ],
+        ['Credentials', ctx.store.path],
+    ];
+    ctx.out([
+        ctx.style.bold(`The Invited CLI is logged in to ${connection.origin} (client ${connection.clientId}).`),
+        ...rows.map(([label, value]) => `  ${label.padEnd(13)}${value}`),
+        reads
+            ? 'Run `invited whoami` to see the fragments it reads and when that sharing ends.'
+            : 'It reads nothing: you shared no fragments with it. Run `invited login` to choose some.',
+        'The CLI can end only its own log-in (`invited logout`).',
+        assistantsLine(ctx.origin),
+    ].join('\n') + '\n');
+    return expired ? 1 : 0;
+}
+// logout ---------------------------------------------------------------------
+export async function logout(ctx, target) {
+    if (target !== undefined && !['invited-cli', 'invited', 'cli'].includes(target))
+        throw new CliError(`The Invited CLI can end only its own log-in, not ${target}'s. Disconnect ${target} in Activity at ${assistantsUrl(ctx.origin)}.`);
+    const ended = await ctx.store.locked(async () => {
+        const file = await ctx.store.read();
+        const connection = file.connections[ctx.origin];
+        if (!connection)
+            return false;
+        await revokeRefreshToken(ctx.fetch, connection);
+        delete file.connections[ctx.origin];
+        await ctx.store.write(file);
+        return true;
+    });
+    ctx.out((ended
+        ? `Revoked the Invited CLI's log-in to ${ctx.origin} and deleted its credentials from ${ctx.store.path}.\n`
+        : `The Invited CLI was not logged in to ${ctx.origin}; nothing to revoke.\n`) +
+        `Other assistants stay connected. ${assistantsLine(ctx.origin)}\n`);
+}