umtri-mcp 1.7.0 → 1.7.1

package/README.md

@@ -56,7 +56,7 @@ appear and then error, re-check the token and its scope — `read` tokens cannot
 ## Tools
 
 **Read** — `get_graph`, `get_bug`, `get_impact`, `list_projects`, `list_bugs`, `list_seasons`,
-`list_events`
+`list_events`, `export_ground`
 
 **Write** — `create_project`, `create_node`, `update_node`, `delete_node` (a subtree only with
 `cascade: true`), `create_edge`, `delete_edge`, `create_api`, `update_api`, `delete_api`,

package/core/api-client.js

@@ -6,9 +6,17 @@
 export function createApiClient({ baseUrl, getToken }) {
   const base = String(baseUrl || '').replace(/\/$/, '');
 
+  // 토큰 없는 연결(HTTP 익명 discovery)에서 도구를 부르면 여기서 멈춘다. 연결은 되고 호출만
+  // 실패하는 모양이라, 이 문구가 사람에게 닿는 유일한 안내다 — 발급 위치와 넣는 자리를 한 번에.
   async function authHeader() {
     const token = await getToken();
-    if (!token) throw new Error('No API token available for request.');
+    if (!token) {
+      throw new Error(
+        'This connection has no API token, so tools cannot run. Sign in at app.umtri.io, generate a personal access token in Settings → API Tokens, ' +
+        'then send it as "Authorization: Bearer umtri_pat_…" (remote https://mcp.umtri.io) or set UMTRI_API_TOKEN (npx umtri-mcp). ' +
+        'Guide: https://docs.umtri.io/en/token',
+      );
+    }
     return `Bearer ${token}`;
   }
 

package/core/instructions.js

@@ -15,6 +15,8 @@ export const SERVER_INSTRUCTIONS = `Umtri maps a project's structure as a tree (
 
 Umtri never reads git. A commit reaches the ground only because something called create_node / update_node / record_commit — so the tree drifts behind the code unless the repo has a habit that says otherwise. If this repo's own rules file (CLAUDE.md, AGENTS.md, …) has no commit-sync policy, read umtri://rules/commit-sync and offer the human a short one to paste in.
 
+Umtri holds only what tool calls send — labels, descriptions, file paths, connections, bug and wiki text. It never reads files or git. Never put secrets, environment values, credentials or personal data into a node or page; metadata.implements is a path, not content. If the human asks what is sent or whether it is safe, read umtri://about/data and answer from it.
+
 Before creating or reclassifying nodes, read umtri://rules/vocabulary; before creating a trunk or a limb under one, also umtri://rules/trunk-kinds. Opening a season seals the current one, so create_season only acts after the user confirms (umtri://rules/seasons).
 
 If Umtri itself gets in your way — a call rejected for a reason that looks wrong, a capability that is missing, a tool description that misled you — tell the human what happened and offer to file it with send_feedback. Never file it on your own initiative.`;

package/core/resources/data.md

@@ -0,0 +1,60 @@
+# What Umtri receives — and what it never sees
+
+Umtri is a map of a project, not a copy of it. This page is for the agent that
+is about to draw a tree: it says exactly what leaves the machine, so you can
+answer the human plainly instead of hesitating, and so you send only what the
+map needs. The human-facing version is https://docs.umtri.io/en/data
+(Korean: https://docs.umtri.io/ko/data).
+
+## Only what a tool call sends
+
+Umtri holds nothing it was not handed through the app or an MCP tool call:
+
+- node labels, descriptions, types and metadata — including `implements`,
+  which is a list of **file paths**, never file contents
+- connections between nodes (edges, api flows) and their labels
+- bug titles, descriptions and solutions
+- wiki prose
+- season labels and the ground's name
+
+Umtri never reads the repository. There is no git integration, no file
+scanning, no agent on the machine. A commit reaches a ground only because
+something called `record_commit` with a SHA and a list of paths. If you do not
+put something into a call, it does not exist on Umtri.
+
+## What not to record
+
+The map describes *structure*. Keep out of every label, description, metadata
+value and wiki page:
+
+- secrets, API keys, tokens, passwords, environment values
+- customer or personal data (names, emails, ids from production tables)
+- verbatim source code — point at the file (`implements`), do not paste it
+- internal hostnames, IPs and URLs beyond what the structure needs to say
+
+`implements` is a path, not content. A description says what a thing is for,
+not how its code reads. If a `.env` or a credentials file would be the honest
+`implements` of a node, name the node and leave `implements` empty.
+
+## Where it goes and who sees it
+
+- Stored at `api.umtri.io` (AWS, Seoul) in PostgreSQL; every connection is TLS.
+- No ground is public. Only the members of the organisation that owns the
+  ground — and, in a team, only the people assigned to that ground — can read
+  it. The public demo (`app.umtri.io/demo`) is separate, fictional data.
+- API tokens are stored as SHA-256 hashes; the plain token is shown once. A
+  `read` token cannot write. Tokens can be revoked at any time.
+- Deleting a ground removes it immediately and cannot be undone. Deleting an
+  account removes it immediately.
+- Everything can be taken out at any time: `export_ground` (or
+  `GET /api/projects/<slug>/export`) returns the whole ground as one JSON.
+
+## When the human asks "is this safe?"
+
+Answer from this page: what will be sent (the list above, nothing else), where
+it goes, who can see it, how it is deleted and exported. Point them to the docs
+page and let them decide. Do not refuse on their behalf, and do not send more
+than the map needs. If the project's own rules forbid naming a part of the
+system, leave that part out and say so in the ground's wiki.
+
+Privacy policy: https://umtri.io/privacy/ (Korean: https://umtri.io/ko/privacy/).

package/core/resources/system-structure.md

@@ -81,6 +81,23 @@ served to users (its pages, its i18n, its shell) is a product surface and
 belongs in the tree. The line is not "markdown vs code" — it is *served to
 users* vs *read by us*.
 
+## What not to record — the map is structure, not contents
+
+Everything above is about *which* things become nodes. This is about what goes
+into a node once it exists. A label, a description, a metadata value or a wiki
+page never holds:
+
+- **secrets** — API keys, tokens, passwords, environment values
+- **customer or personal data** — names, emails, ids copied from production
+- **verbatim source code** — point at the file with `implements`; do not paste
+  the function
+- **internal hostnames, IPs, URLs** beyond what the structure needs to say
+
+`implements` is a list of paths, not contents. A description says what a thing
+is for, not how its code reads. If the honest `implements` of a node would be a
+`.env` or a credentials file, name the node and leave `implements` empty. The
+full statement of what Umtri receives and keeps is `umtri://about/data`.
+
 ## Trunk and limb rules
 
 - `trunk` = a big domain (e.g. `www`, `server`, `db`). Pick stable,

package/core/resources.js

@@ -78,6 +78,13 @@ const RESOURCES = [
     title: 'Nodes represent information structures',
     description: 'Modelling principle: nodes are user-visible units, not code files. Metadata key conventions.',
   },
+  {
+    name: 'data',
+    uri: 'umtri://about/data',
+    file: 'data.md',
+    title: 'What Umtri receives — and what it never sees',
+    description: 'Umtri holds only what tool calls send (labels, descriptions, file paths, connections, bug and wiki text) and never reads files or git. Lists what must not be recorded (secrets, env values, personal data, verbatim code), where data is stored, who can see it, and how it is exported or deleted. Read when the human asks whether it is safe to map their project, or before drawing a tree for a new ground.',
+  },
   {
     name: 'vision',
     uri: 'umtri://about/vision',

package/core/tools.js

@@ -534,6 +534,23 @@ export function registerTools(server, { api }) {
     },
   );
 
+  server.registerTool(
+    'export_ground',
+    {
+      title: 'Export a whole ground as JSON',
+      description: 'Returns everything in a ground as one JSON document — project, seasons, nodes (removed ones included, with removedAt), edges, apis, bugs and wiki pages with full bodies. For backups, moving off Umtri, or answering "can I take my data out?" (yes — see umtri://about/data). The result is large; save it to a file rather than summarising it, and do not call it for ordinary reads (use get_graph).',
+      inputSchema: z.object({
+        slug: z.string().min(1).describe('Ground slug.'),
+      }),
+    },
+    async ({ slug }) => {
+      try {
+        const data = await api.get(`/api/projects/${encodeURIComponent(slug)}/export`);
+        return jsonResult(data);
+      } catch (e) { return errorResult(e); }
+    },
+  );
+
   server.registerTool(
     'list_events',
     {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "umtri-mcp",
-  "version": "1.7.0",
+  "version": "1.7.1",
   "description": "MCP server for Umtri — give your AI coding agent a persistent map of your project's structure, dependencies, and bugs.",
   "mcpName": "io.umtri/umtri",
   "keywords": [