@glie/mcp-manager 0.0.0-stage → 0.1.0

package/LICENSE

@@ -0,0 +1,201 @@
+                                 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:
+
+      (a) You must give any other recipients of the Work or Derivative
+          Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) 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
+
+      (d) 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
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright 2026 glie
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

package/README.md

@@ -1,3 +1,45 @@
-# Temporary Holding Version
+# @glie/mcp-manager
 
-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.
+An [MCP](https://modelcontextprotocol.io) server that lets Claude Code, Codex or any MCP client
+work in [Manager](https://manager.glie.ai) — tasks, meetings, agendas, follow-ups, comments and
+notifications — as you.
+
+## Setup
+
+1. In Manager, open **Account → Agents** and create a token. Choose the workspace and whether it
+   may write. Copy it: it is shown once.
+2. Export it in the shell you start your agent from:
+
+   ```bash
+   export MANAGER_TOKEN='mgr_…'
+   ```
+
+3. Register the server, for example in a project's `.mcp.json`:
+
+   ```json
+   {
+     "mcpServers": {
+       "manager": {
+         "command": "npx",
+         "args": ["-y", "@glie/mcp-manager@latest"],
+         "env": { "MANAGER_URL": "https://manager.glie.ai", "MANAGER_TOKEN": "${MANAGER_TOKEN}" }
+       }
+     }
+   }
+   ```
+
+The token acts as you, in its workspace, with your role and visibility. Everything it does shows in
+the task activity as "you · via <token name>". Revoke it any time from the same page.
+
+## Tools
+
+`manager_me`, `manager_attention`, `manager_people_list`, `manager_contact_create`,
+`manager_tag_list`, `manager_team_list`, `manager_report_get`, `manager_task_list`,
+`manager_task_get`, `manager_task_create`, `manager_task_update`, `manager_task_complete`,
+`manager_task_cancel`, `manager_task_reopen`, `manager_task_reschedule`,
+`manager_task_reschedule_history`, `manager_task_handshake`, `manager_meeting_rsvp`,
+`manager_step_list|add|update|remove`, `manager_agenda_list|add|update|remove`,
+`manager_followup_list|create|update|remove`, `manager_comment_list`, `manager_comment_add`,
+`manager_activity_list`, `manager_notification_list`, `manager_notification_mark_read`.
+
+The API behind them is described in the Manager repository, `docs/API.md`.

package/dist/client.js

@@ -0,0 +1,66 @@
+/**
+ * Thin HTTP client for the Manager API (docs/API.md in the Manager repo).
+ * Every call carries the user's API token; the workspace is the one the token was made for.
+ */
+export class ManagerClient {
+    baseUrl;
+    token;
+    fetchImpl;
+    workspace = null;
+    constructor(baseUrl, token, fetchImpl = fetch) {
+        this.baseUrl = baseUrl;
+        this.token = token;
+        this.fetchImpl = fetchImpl;
+    }
+    async request(method, path, options = {}) {
+        const url = new URL(path, this.baseUrl);
+        for (const [key, value] of Object.entries(options.query ?? {})) {
+            if (value !== undefined)
+                url.searchParams.set(key, String(value));
+        }
+        const headers = {
+            Accept: "application/json",
+            Authorization: `Bearer ${this.token}`,
+        };
+        if (options.body !== undefined)
+            headers["Content-Type"] = "application/json";
+        if (options.idempotencyKey)
+            headers["Idempotency-Key"] = options.idempotencyKey;
+        const res = await this.fetchImpl(url, {
+            method,
+            headers,
+            body: options.body === undefined ? undefined : JSON.stringify(options.body),
+        });
+        const text = await res.text();
+        let body = text;
+        if (text) {
+            try {
+                body = JSON.parse(text);
+            }
+            catch {
+                // Not JSON (a proxy error page, say): hand the raw text back.
+            }
+        }
+        return { status: res.status, body };
+    }
+    /** `/api/workspaces/<id>` for the token's workspace, resolved once from `/api/me`. */
+    async workspacePath(rest = "") {
+        this.workspace ??= this.request("GET", "/api/me").then(({ status, body }) => {
+            const id = body?.data?.token
+                ?.workspace?.id;
+            if (status !== 200 || !id) {
+                this.workspace = null;
+                throw new Error(`Could not resolve the token's workspace (${status}): ${describe(body)}`);
+            }
+            return id;
+        });
+        return `/api/workspaces/${await this.workspace}${rest}`;
+    }
+}
+export function describe(body) {
+    if (body && typeof body === "object" && "error" in body) {
+        const { error, details } = body;
+        return details ? `${String(error)} ${JSON.stringify(details)}` : String(error);
+    }
+    return typeof body === "string" ? body.slice(0, 500) : JSON.stringify(body);
+}

package/dist/index.js

@@ -0,0 +1,39 @@
+#!/usr/bin/env node
+/**
+ * mcp-manager — stdio MCP server for Manager (newline-delimited JSON-RPC 2.0).
+ *
+ * Reads MANAGER_URL and MANAGER_TOKEN (an API token created under Account → Agents).
+ * The token decides who acts, in which workspace, and whether writes are allowed.
+ * Logs go to stderr; stdout carries only JSON-RPC.
+ */
+import { createInterface } from "node:readline";
+import { ManagerClient } from "./client.js";
+import { handle } from "./server.js";
+import { TOOLS } from "./tools.js";
+const log = (msg) => process.stderr.write(`mcp-manager: ${msg}\n`);
+const baseUrl = process.env.MANAGER_URL ?? "https://manager.glie.ai";
+const token = process.env.MANAGER_TOKEN ?? "";
+if (!token) {
+    log("MANAGER_TOKEN is not set. Create a token in Manager under Account → Agents.");
+    process.exit(1);
+}
+const client = new ManagerClient(baseUrl, token);
+const send = (msg) => process.stdout.write(`${JSON.stringify(msg)}\n`);
+log(`starting against ${baseUrl}`);
+const rl = createInterface({ input: process.stdin, crlfDelay: Number.POSITIVE_INFINITY });
+rl.on("line", async (line) => {
+    if (!line.trim())
+        return;
+    let req;
+    try {
+        req = JSON.parse(line);
+    }
+    catch {
+        send({ jsonrpc: "2.0", id: null, error: { code: -32700, message: "parse error" } });
+        return;
+    }
+    const res = await handle(req, TOOLS, client);
+    if (res)
+        send(res);
+});
+rl.on("close", () => log("stdin closed, exiting"));

package/dist/server.js

@@ -0,0 +1,67 @@
+import { describe } from "./client.js";
+import { INSTRUCTIONS } from "./tools.js";
+/** Keep in step with "version" in package.json on each release. */
+export const SERVER_VERSION = "0.1.0";
+const ok = (id, result) => ({
+    jsonrpc: "2.0",
+    id,
+    result,
+});
+const fail = (id, code, message) => ({
+    jsonrpc: "2.0",
+    id,
+    error: { code, message },
+});
+const text = (value) => [{ type: "text", text: JSON.stringify(value, null, 2) }];
+/**
+ * One MCP request in, at most one response out (notifications get none).
+ * A refused API call is a tool result with isError, carrying the API's own reason, so the
+ * model reads "This token is read-only" rather than a protocol failure.
+ */
+export async function handle(req, tools, client) {
+    const id = req.id ?? null;
+    switch (req.method) {
+        case "initialize":
+            return ok(id, {
+                protocolVersion: "2024-11-05",
+                capabilities: { tools: {} },
+                serverInfo: { name: "mcp-manager", version: SERVER_VERSION },
+                instructions: INSTRUCTIONS,
+            });
+        case "notifications/initialized":
+        case "initialized":
+            return null;
+        case "ping":
+            return ok(id, {});
+        case "tools/list":
+            return ok(id, {
+                tools: tools.map(({ name, description, inputSchema }) => ({
+                    name,
+                    description,
+                    inputSchema,
+                })),
+            });
+        case "tools/call": {
+            const name = req.params?.name;
+            const args = (req.params?.arguments ?? {});
+            const tool = tools.find((t) => t.name === name);
+            if (!tool)
+                return fail(id, -32602, `unknown tool: ${String(name)}`);
+            try {
+                const { status, body } = await tool.call(client, args);
+                if (status >= 400) {
+                    return ok(id, { content: text({ status, error: describe(body) }), isError: true });
+                }
+                const data = body && typeof body === "object" && "data" in body ? body.data : body;
+                return ok(id, { content: text(data) });
+            }
+            catch (err) {
+                return ok(id, { content: text({ error: err.message }), isError: true });
+            }
+        }
+        default:
+            if (req.id === undefined)
+                return null; // an unknown notification needs no answer
+            return fail(id, -32601, `method not found: ${req.method}`);
+    }
+}

package/dist/tools.js

@@ -0,0 +1,389 @@
+const str = (description) => ({ type: "string", description });
+const int = (description) => ({ type: "integer", description });
+const bool = (description) => ({ type: "boolean", description });
+const strList = (description) => ({
+    type: "array",
+    items: { type: "string" },
+    description,
+});
+const oneOf = (values, description) => ({
+    type: "string",
+    enum: values,
+    description,
+});
+const obj = (properties, required = []) => ({
+    type: "object",
+    properties,
+    ...(required.length ? { required } : {}),
+    additionalProperties: false,
+});
+/** The arguments in `keys` that the caller actually sent. */
+function pick(args, keys) {
+    const out = {};
+    for (const key of keys)
+        if (args[key] !== undefined)
+            out[key] = args[key];
+    return out;
+}
+const seg = (value) => encodeURIComponent(String(value));
+const taskPath = (args, rest = "") => `/tasks/${seg(args.taskId)}${rest}`;
+const taskId = str("Task or meeting id (uuid).");
+const idempotencyKey = str("Optional. A key unique to this creation (e.g. a uuid you generate once). Retrying with the same key returns the first result instead of creating a duplicate.");
+const TASK_FIELDS = {
+    name: str("Title, up to 200 characters."),
+    description: str("Rich-text HTML description."),
+    meeting: bool("true for a meeting, false (default) for a task."),
+    dateDeadline: str("Deadline day, YYYY-MM-DD. Required on create; for a meeting, its day."),
+    allDay: bool("Meetings default to false (timed). Tasks default to true."),
+    datetimeDeadlineStart: str("ISO 8601 start, e.g. 2026-11-09T10:00:00Z. Required for timed meetings."),
+    datetimeDeadlineEnd: str("ISO 8601 end; must be after the start."),
+    duration: { type: "number", description: "Duration in hours." },
+    location: str("Where it happens."),
+    videocallLocation: str("Video call URL."),
+    privacy: oneOf(["public", "private"], "private: only the responsible and participants see it."),
+    state: oneOf(["pending", "placeholder"], "pending (default) or placeholder (not yet firm)."),
+    managerId: str("Responsible person: a member's userId from manager_people_list, or 'current_user'. Assigning someone else starts a handshake they must accept."),
+    ownerId: str("Owner contact id (may be an external contact). Defaults to you."),
+    participantIds: strList("Contact ids of the participants (contacts from manager_people_list)."),
+    tagIds: strList("Tag ids from manager_tag_list."),
+    teamId: str("Team id from manager_team_list; you must belong to the team."),
+    reschedulesAllowed: int("How many times it may be rescheduled before needing approval."),
+};
+const TASK_FIELD_NAMES = Object.keys(TASK_FIELDS);
+export const INSTRUCTIONS = [
+    "Manager is where Glie runs its day-to-day operation: tasks, meetings and their follow-ups. You act as the person whose API token you hold, in one workspace, with their role and visibility — nothing more. Every manager_* tool wraps one REST call.",
+    "",
+    "START HERE:",
+    "• manager_me — who you act as, your role, and whether the token can write.",
+    "• The day: manager_task_list { from: <today>, to: <today> } (add meeting: true for meetings only), plus manager_task_list { overdue: true } for what slipped.",
+    "• manager_attention — counts of overdue items and unread notifications; manager_notification_list for the details.",
+    "",
+    "MODEL:",
+    "• A task and a meeting are the same object; meeting: true makes it a meeting (timed, with participants, agenda and follow-ups).",
+    "• States: placeholder (not firm) → pending → done | cancelled. Done and cancelled are read-only until manager_task_reopen.",
+    "• People: managerId is the responsible member (a userId). ownerId and participantIds are contacts — members have a contact too, and contacts may be external.",
+    "• Handshake: giving a task to someone else (as a plain member) leaves it pending their acceptance; they answer with manager_task_handshake. Nothing else moves while it is pending.",
+    "• Rescheduling is governed: each task allows a number of reschedules. Past it, manager_task_reschedule with requestOnly: true asks the responsible person instead.",
+    "• Completing is refused while steps, agenda items or follow-ups are still pending, and a meeting needs at least one participant. Finish or remove those first.",
+    "• Follow-ups are tasks linked to a meeting (manager_followup_create creates and links one).",
+    "",
+    "CONVENTIONS: dates are YYYY-MM-DD; times are ISO 8601 with offset. Pass idempotencyKey when creating, so a retry never duplicates. A 403 means the person may not do it (or the token is read-only); a 404 means it does not exist or is not visible to them.",
+].join("\n");
+export const TOOLS = [
+    {
+        name: "manager_me",
+        description: "Who you act as: the person, and the token's name, scope (read|write), workspace and role.",
+        inputSchema: obj({}),
+        call: (c) => c.request("GET", "/api/me"),
+    },
+    {
+        name: "manager_attention",
+        description: "Counts that need action now: your overdue tasks and unread notifications.",
+        inputSchema: obj({}),
+        call: async (c) => c.request("GET", await c.workspacePath("/badge-counts")),
+    },
+    {
+        name: "manager_people_list",
+        description: "Members (with userId for managerId, role, and their contact) and every contact (for ownerId and participantIds).",
+        inputSchema: obj({}),
+        call: async (c) => {
+            const [members, contacts] = await Promise.all([
+                c.request("GET", await c.workspacePath("/members")),
+                c.request("GET", await c.workspacePath("/contacts")),
+            ]);
+            const failed = [members, contacts].find((r) => r.status >= 400);
+            if (failed)
+                return failed;
+            const data = (r) => r.body.data;
+            return { status: 200, body: { data: { members: data(members), contacts: data(contacts) } } };
+        },
+    },
+    {
+        name: "manager_contact_create",
+        description: "Add a contact (e.g. an external participant). Workspace admins only.",
+        inputSchema: obj({ name: str("Full name."), email: str("Email address.") }, ["name", "email"]),
+        call: async (c, a) => c.request("POST", await c.workspacePath("/contacts"), { body: pick(a, ["name", "email"]) }),
+    },
+    {
+        name: "manager_tag_list",
+        description: "Tags of the workspace.",
+        inputSchema: obj({}),
+        call: async (c) => c.request("GET", await c.workspacePath("/tags")),
+    },
+    {
+        name: "manager_team_list",
+        description: "Teams you belong to.",
+        inputSchema: obj({}),
+        call: async (c) => c.request("GET", await c.workspacePath("/teams/my")),
+    },
+    {
+        name: "manager_report_get",
+        description: "Performance report for a period (completion, on-time and reschedule rates). Defaults to the last 7 days.",
+        inputSchema: obj({ from: str("First day, YYYY-MM-DD."), to: str("Last day, YYYY-MM-DD.") }),
+        call: async (c, a) => c.request("GET", await c.workspacePath("/reports"), { query: pick(a, ["from", "to"]) }),
+    },
+    {
+        name: "manager_task_list",
+        description: "List tasks and meetings visible to you, newest first. Combine filters to get a day, a week, or what is overdue.",
+        inputSchema: obj({
+            from: str("Deadline on or after this day, YYYY-MM-DD."),
+            to: str("Deadline on or before this day, YYYY-MM-DD."),
+            overdue: bool("Only pending items whose deadline has passed."),
+            meeting: bool("true: meetings only; false: tasks only."),
+            state: oneOf(["placeholder", "pending", "done", "cancelled"], "Only this state."),
+            q: str("Name contains this text."),
+            managed: bool("Only items you are responsible for or own."),
+            myTasks: bool("Only items where you are a participant."),
+            limit: int("Up to 500; default 100."),
+            offset: int("For paging."),
+        }),
+        call: async (c, a) => c.request("GET", await c.workspacePath("/tasks"), {
+            query: pick(a, [
+                "from",
+                "to",
+                "overdue",
+                "meeting",
+                "state",
+                "q",
+                "managed",
+                "myTasks",
+                "limit",
+                "offset",
+            ]),
+        }),
+    },
+    {
+        name: "manager_task_get",
+        description: "One task or meeting in full: people, participants and their RSVP, tags.",
+        inputSchema: obj({ taskId }, ["taskId"]),
+        call: async (c, a) => c.request("GET", await c.workspacePath(taskPath(a))),
+    },
+    {
+        name: "manager_task_create",
+        description: "Create a task or a meeting. Requires name and dateDeadline; meetings also need datetimeDeadlineStart unless allDay.",
+        inputSchema: obj({ ...TASK_FIELDS, idempotencyKey }, ["name", "dateDeadline"]),
+        call: async (c, a) => c.request("POST", await c.workspacePath("/tasks"), {
+            body: { managerId: "current_user", ...pick(a, TASK_FIELD_NAMES) },
+            idempotencyKey: a.idempotencyKey,
+        }),
+    },
+    {
+        name: "manager_task_update",
+        description: "Change fields of a pending task or meeting. Send only what changes. For a recurring series, recurringUpdate 'all' also applies safe fields to the coming occurrences. To move a date, prefer manager_task_reschedule.",
+        inputSchema: obj({
+            taskId,
+            ...TASK_FIELDS,
+            recurringUpdate: oneOf(["this", "all"], "Recurring series: this occurrence or all."),
+        }, ["taskId"]),
+        call: async (c, a) => c.request("PATCH", await c.workspacePath(taskPath(a)), {
+            body: pick(a, [...TASK_FIELD_NAMES, "recurringUpdate"]),
+        }),
+    },
+    {
+        name: "manager_task_complete",
+        description: "Mark done. On the last occurrence of a recurring series it first answers with a terminationWarning; repeat with bypassTerminationCheck: true to confirm.",
+        inputSchema: obj({ taskId, bypassTerminationCheck: bool("Confirm ending a series.") }, [
+            "taskId",
+        ]),
+        call: async (c, a) => c.request("POST", await c.workspacePath(taskPath(a, "/complete")), {
+            body: pick(a, ["bypassTerminationCheck"]),
+        }),
+    },
+    {
+        name: "manager_task_cancel",
+        description: "Cancel with a reason. If you may not cancel it yourself, this sends a cancellation request to the responsible person.",
+        inputSchema: obj({
+            taskId,
+            reason: str("Why, up to 200 characters."),
+            recurringAction: oneOf(["cancel_only", "cancel_create_next"], "Recurring: also create the next occurrence?"),
+        }, ["taskId", "reason"]),
+        call: async (c, a) => c.request("POST", await c.workspacePath(taskPath(a, "/cancel")), {
+            body: pick(a, ["reason", "recurringAction"]),
+        }),
+    },
+    {
+        name: "manager_task_reopen",
+        description: "Bring a done or cancelled item back to pending.",
+        inputSchema: obj({ taskId }, ["taskId"]),
+        call: async (c, a) => c.request("POST", await c.workspacePath(taskPath(a, "/reopen")), { body: {} }),
+    },
+    {
+        name: "manager_task_reschedule",
+        description: "Move to a new day (and time, for timed meetings). Counts against the reschedule limit of tasks; past the limit, use requestOnly: true to ask the responsible person.",
+        inputSchema: obj({
+            taskId,
+            newDate: str("New day, YYYY-MM-DD, not in the past."),
+            newDatetimeStart: str("Timed meetings: new ISO start, on newDate."),
+            newDatetimeEnd: str("Timed meetings: new ISO end, on newDate."),
+            reason: str("Why, up to 500 characters."),
+            requestOnly: bool("Ask the responsible person instead of moving it."),
+        }, ["taskId", "newDate"]),
+        call: async (c, a) => c.request("POST", await c.workspacePath(taskPath(a, "/reschedule")), {
+            body: pick(a, ["newDate", "newDatetimeStart", "newDatetimeEnd", "reason", "requestOnly"]),
+        }),
+    },
+    {
+        name: "manager_task_reschedule_history",
+        description: "Every reschedule of an item: from, to, when, by whom and why.",
+        inputSchema: obj({ taskId }, ["taskId"]),
+        call: async (c, a) => c.request("GET", await c.workspacePath(taskPath(a, "/reschedule"))),
+    },
+    {
+        name: "manager_task_handshake",
+        description: "Accept or reject a task someone assigned to you.",
+        inputSchema: obj({
+            taskId,
+            action: oneOf(["accept", "reject"], "Your answer."),
+            reason: str("Why, when rejecting."),
+        }, ["taskId", "action"]),
+        call: async (c, a) => c.request("POST", await c.workspacePath(taskPath(a, "/handshake")), {
+            body: pick(a, ["action", "reason"]),
+        }),
+    },
+    {
+        name: "manager_meeting_rsvp",
+        description: "Answer a meeting invitation you are a participant of.",
+        inputSchema: obj({ taskId, responseStatus: oneOf(["accepted", "declined", "tentative"], "Your answer.") }, ["taskId", "responseStatus"]),
+        call: async (c, a) => c.request("PATCH", await c.workspacePath(taskPath(a, "/rsvp")), {
+            body: pick(a, ["responseStatus"]),
+        }),
+    },
+    ...checklist("step", "steps", "stepId", "Checklist step of a task", {
+        completed: bool("Tick or untick the step."),
+    }),
+    ...checklist("agenda", "agenda", "agendaId", "Agenda item of a meeting", {
+        state: oneOf(["pending", "delayed", "done", "cancelled"], "Item state."),
+    }),
+    {
+        name: "manager_followup_list",
+        description: "Follow-ups of a meeting, each with its linked task.",
+        inputSchema: obj({ taskId }, ["taskId"]),
+        call: async (c, a) => c.request("GET", await c.workspacePath(taskPath(a, "/followups"))),
+    },
+    {
+        name: "manager_followup_create",
+        description: "Add a follow-up to a meeting: either link an existing task (followupTaskId) or create a new one (name, managerId, dateDeadline…).",
+        inputSchema: obj({
+            taskId: str("The meeting's id."),
+            followupTaskId: str("Link this existing task instead of creating one."),
+            name: str("New follow-up task's title."),
+            description: str("New task's description."),
+            managerId: str("Responsible member's userId, or 'current_user'."),
+            ownerId: str("Owner contact id."),
+            dateDeadline: str("YYYY-MM-DD."),
+            meeting: bool("Create the follow-up as a meeting."),
+            idempotencyKey,
+        }, ["taskId"]),
+        call: async (c, a) => {
+            const body = a.followupTaskId
+                ? pick(a, ["followupTaskId"])
+                : {
+                    managerId: "current_user",
+                    ...pick(a, ["name", "description", "managerId", "ownerId", "dateDeadline", "meeting"]),
+                };
+            return c.request("POST", await c.workspacePath(taskPath(a, "/followups")), {
+                body,
+                idempotencyKey: a.idempotencyKey,
+            });
+        },
+    },
+    {
+        name: "manager_followup_update",
+        description: "Set a follow-up's state.",
+        inputSchema: obj({
+            taskId: str("The meeting's id."),
+            followupId: str("Follow-up id from manager_followup_list."),
+            state: oneOf(["pending", "scheduled", "rescheduled", "delayed", "done", "cancelled"], "New state."),
+        }, ["taskId", "followupId", "state"]),
+        call: async (c, a) => c.request("PATCH", await c.workspacePath(taskPath(a, `/followups/${seg(a.followupId)}`)), {
+            body: pick(a, ["state"]),
+        }),
+    },
+    {
+        name: "manager_followup_remove",
+        description: "Unlink a follow-up from a meeting.",
+        inputSchema: obj({ taskId: str("The meeting's id."), followupId: str("Follow-up id.") }, [
+            "taskId",
+            "followupId",
+        ]),
+        call: async (c, a) => c.request("DELETE", await c.workspacePath(taskPath(a, `/followups/${seg(a.followupId)}`))),
+    },
+    {
+        name: "manager_comment_list",
+        description: "Comments on a task or meeting, newest first.",
+        inputSchema: obj({ taskId }, ["taskId"]),
+        call: async (c, a) => c.request("GET", await c.workspacePath(taskPath(a, "/comments"))),
+    },
+    {
+        name: "manager_comment_add",
+        description: "Comment on a task or meeting (up to 2000 characters).",
+        inputSchema: obj({ taskId, content: str("The comment."), idempotencyKey }, [
+            "taskId",
+            "content",
+        ]),
+        call: async (c, a) => c.request("POST", await c.workspacePath(taskPath(a, "/comments")), {
+            body: pick(a, ["content"]),
+            idempotencyKey: a.idempotencyKey,
+        }),
+    },
+    {
+        name: "manager_activity_list",
+        description: "What happened to an item, newest first: who did what, and through which token.",
+        inputSchema: obj({ taskId }, ["taskId"]),
+        call: async (c, a) => c.request("GET", await c.workspacePath(taskPath(a, "/activity"))),
+    },
+    {
+        name: "manager_notification_list",
+        description: "Your notifications, newest first, with the unread count.",
+        inputSchema: obj({ unread: bool("Only unread."), limit: int("Up to 50; default 20.") }),
+        call: async (c, a) => c.request("GET", await c.workspacePath("/notifications"), {
+            query: pick(a, ["unread", "limit"]),
+        }),
+    },
+    {
+        name: "manager_notification_mark_read",
+        description: "Mark notifications as read: some by id, or all of them.",
+        inputSchema: obj({
+            notificationIds: strList("Ids to mark read (up to 100)."),
+            markAllRead: bool("Mark every notification read."),
+        }),
+        call: async (c, a) => c.request("PATCH", await c.workspacePath("/notifications"), {
+            body: pick(a, ["notificationIds", "markAllRead"]),
+        }),
+    },
+];
+/** list/add/update/remove for the two checklists that live inside a task: steps and agenda. */
+function checklist(noun, route, idName, what, extra) {
+    const itemPath = (a) => taskPath(a, `/${route}/${seg(a[idName])}`);
+    const id = str(`${what} id, from manager_${noun}_list.`);
+    return [
+        {
+            name: `manager_${noun}_list`,
+            description: `${what}s, in order.`,
+            inputSchema: obj({ taskId }, ["taskId"]),
+            call: async (c, a) => c.request("GET", await c.workspacePath(taskPath(a, `/${route}`))),
+        },
+        {
+            name: `manager_${noun}_add`,
+            description: `Add a ${what.toLowerCase()}.`,
+            inputSchema: obj({ taskId, name: str("Text, up to 200 characters."), sequence: int("Position.") }, ["taskId", "name"]),
+            call: async (c, a) => c.request("POST", await c.workspacePath(taskPath(a, `/${route}`)), {
+                body: pick(a, ["name", "sequence"]),
+            }),
+        },
+        {
+            name: `manager_${noun}_update`,
+            description: `Rename, reorder or change the state of a ${what.toLowerCase()}.`,
+            inputSchema: obj({ taskId, [idName]: id, name: str("New text."), sequence: int("Position."), ...extra }, ["taskId", idName]),
+            call: async (c, a) => c.request("PATCH", await c.workspacePath(itemPath(a)), {
+                body: pick(a, ["name", "sequence", ...Object.keys(extra)]),
+            }),
+        },
+        {
+            name: `manager_${noun}_remove`,
+            description: `Delete a ${what.toLowerCase()}.`,
+            inputSchema: obj({ taskId, [idName]: id }, ["taskId", idName]),
+            call: async (c, a) => c.request("DELETE", await c.workspacePath(itemPath(a))),
+        },
+    ];
+}

package/package.json

@@ -1,6 +1,33 @@
 {
   "name": "@glie/mcp-manager",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "0.1.0",
+  "description": "Model Context Protocol (stdio) server exposing Manager, glie's tasks and meetings product, as native tools in Claude Code and any MCP client.",
+  "license": "Apache-2.0",
+  "author": "glie <carlos@glie.ai>",
+  "type": "module",
+  "bin": {
+    "mcp-manager": "dist/index.js"
+  },
+  "files": ["dist", "README.md", "LICENSE"],
+  "engines": {
+    "node": ">=18"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/glieai/manager.git",
+    "directory": "packages/mcp-manager"
+  },
+  "homepage": "https://manager.glie.ai",
+  "keywords": ["mcp", "model-context-protocol", "claude", "claude-code", "manager", "glie"],
+  "scripts": {
+    "bundle": "tsc -p tsconfig.build.json && chmod +x dist/index.js",
+    "prepublishOnly": "npm run bundle"
+  },
+  "devDependencies": {
+    "@types/node": "^22.10.5",
+    "typescript": "^5.7.2"
+  }
+}