@manudota/artist-mcp 0.1.0

package/dist/client.js

@@ -0,0 +1,46 @@
+/**
+ * The only network surface this package has.
+ *
+ * Everything goes through one POST to the edge function, which holds the
+ * Microsoft credentials. No Graph call is ever made from this machine, and the
+ * connection key is the only secret that lives here.
+ */
+const DEFAULT_ENDPOINT = "https://zxiemadwrkcoovvpscfb.supabase.co/functions/v1/graph";
+/** Overridable for testing; the baked-in default is what shipped copies use. */
+export function endpoint() {
+    return process.env.ARTIST_MCP_ENDPOINT ?? DEFAULT_ENDPOINT;
+}
+export class GraphError extends Error {
+    reconnectNeeded;
+    constructor(message, reconnectNeeded) {
+        super(message);
+        this.reconnectNeeded = reconnectNeeded;
+        this.name = "GraphError";
+    }
+}
+export async function call(op, key, params = {}) {
+    let res;
+    try {
+        res = await fetch(endpoint(), {
+            method: "POST",
+            headers: {
+                "content-type": "application/json",
+                authorization: `Bearer ${key}`,
+            },
+            body: JSON.stringify({ op, ...params }),
+        });
+    }
+    catch (cause) {
+        throw new GraphError(`Could not reach the notes service: ${cause}`, false);
+    }
+    if (res.status === 401 || res.status === 403) {
+        throw new GraphError("Reconnect needed — this connection key is no longer valid. " +
+            "Sign in to the web app and generate a new one.", true);
+    }
+    const body = (await res.json().catch(() => ({})));
+    if (!res.ok) {
+        const detail = typeof body.error === "string" ? body.error : `HTTP ${res.status}`;
+        throw new GraphError(detail, body.reconnect_needed === true);
+    }
+    return body;
+}

package/dist/config.js

@@ -0,0 +1,45 @@
+/** Locating and editing the Claude Desktop config, without trampling it. */
+import { homedir, platform } from "node:os";
+import { join } from "node:path";
+import { mkdir, readFile, writeFile } from "node:fs/promises";
+import { dirname } from "node:path";
+export const ENTRY_NAME = "artist-notes";
+export function configPath() {
+    const home = homedir();
+    switch (platform()) {
+        case "darwin":
+            return join(home, "Library", "Application Support", "Claude", "claude_desktop_config.json");
+        case "win32":
+            return join(process.env.APPDATA ?? join(home, "AppData", "Roaming"), "Claude", "claude_desktop_config.json");
+        default:
+            // Claude Desktop ships on macOS and Windows only; this keeps the error
+            // legible rather than writing a config nothing will ever read.
+            throw new Error(`Claude Desktop has no config location on ${platform()}. ` +
+                "Install on macOS or Windows.");
+    }
+}
+/** Missing file is not an error — it's the first-install case. */
+export async function readConfig(path) {
+    let raw;
+    try {
+        raw = await readFile(path, "utf8");
+    }
+    catch (err) {
+        if (err.code === "ENOENT")
+            return {};
+        throw err;
+    }
+    if (raw.trim() === "")
+        return {};
+    try {
+        return JSON.parse(raw);
+    }
+    catch {
+        throw new Error(`${path} is not valid JSON. Fix or move it, then run init again — ` +
+            "refusing to overwrite a file that may hold your other MCP servers.");
+    }
+}
+export async function writeConfig(path, config) {
+    await mkdir(dirname(path), { recursive: true });
+    await writeFile(path, `${JSON.stringify(config, null, 2)}\n`, "utf8");
+}

package/dist/index.js

@@ -0,0 +1,27 @@
+#!/usr/bin/env node
+import { runInit, runUninstall } from "./init.js";
+import { runServer } from "./server.js";
+const mode = process.argv[2];
+try {
+    switch (mode) {
+        case undefined:
+            await runServer();
+            break;
+        case "init":
+            await runInit();
+            break;
+        case "uninstall":
+            await runUninstall();
+            break;
+        default:
+            console.error(`Unknown command "${mode}".\n\n` +
+                "  artist-mcp            run the MCP server over stdio\n" +
+                "  artist-mcp init       connect this machine to your notes\n" +
+                "  artist-mcp uninstall  remove the Claude Desktop entry\n");
+            process.exit(1);
+    }
+}
+catch (err) {
+    console.error(err instanceof Error ? err.message : String(err));
+    process.exit(1);
+}

package/dist/init.js

@@ -0,0 +1,55 @@
+import { createInterface } from "node:readline/promises";
+import { stdin, stdout } from "node:process";
+import { call, GraphError } from "./client.js";
+import { configPath, ENTRY_NAME, readConfig, writeConfig } from "./config.js";
+const PACKAGE = "@manudota/artist-mcp";
+export async function runInit() {
+    const rl = createInterface({ input: stdin, output: stdout });
+    let key;
+    try {
+        key = (await rl.question("Paste your connection key: ")).trim();
+    }
+    finally {
+        rl.close();
+    }
+    if (key === "") {
+        console.error("No key entered. Nothing was written.");
+        process.exit(1);
+    }
+    // Verify before touching the config — a bad key should leave the machine
+    // exactly as it was.
+    try {
+        await call("verify", key);
+    }
+    catch (err) {
+        const message = err instanceof GraphError ? err.message : `Could not verify key: ${err}`;
+        console.error(`${message}\nNothing was written.`);
+        process.exit(1);
+    }
+    const path = configPath();
+    const config = await readConfig(path);
+    const servers = (config.mcpServers ?? {});
+    servers[ENTRY_NAME] = {
+        command: "npx",
+        args: ["-y", PACKAGE],
+        env: { ARTIST_MCP_KEY: key },
+    };
+    config.mcpServers = servers;
+    await writeConfig(path, config);
+    console.log(`\nConnected. Wrote "${ENTRY_NAME}" to ${path}`);
+    console.log("Restart Claude Desktop — it doesn't reload its config on its own.");
+}
+export async function runUninstall() {
+    const path = configPath();
+    const config = await readConfig(path);
+    const servers = (config.mcpServers ?? {});
+    if (!(ENTRY_NAME in servers)) {
+        console.log(`No "${ENTRY_NAME}" entry in ${path}. Nothing to do.`);
+        return;
+    }
+    delete servers[ENTRY_NAME];
+    config.mcpServers = servers;
+    await writeConfig(path, config);
+    console.log(`Removed "${ENTRY_NAME}" from ${path}`);
+    console.log("Restart Claude Desktop to apply.");
+}

package/dist/server.js

@@ -0,0 +1,40 @@
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { z } from "zod";
+import { call, GraphError } from "./client.js";
+export async function runServer() {
+    const key = process.env.ARTIST_MCP_KEY;
+    if (!key) {
+        // stderr, not stdout — stdout is the protocol channel.
+        console.error("ARTIST_MCP_KEY is not set. Run `npx @manudota/artist-mcp init` to configure.");
+        process.exit(1);
+    }
+    const server = new McpServer({ name: "artist-notes", version: "0.1.0" });
+    server.tool("list_notes", "List the user's OneNote pages, with title, section and last modified date.", {}, async () => {
+        try {
+            const { notes } = await call("list_notes", key);
+            if (notes.length === 0) {
+                return { content: [{ type: "text", text: "No notes found." }] };
+            }
+            const lines = notes.map((n) => `- ${n.title}${n.section ? ` (${n.section})` : ""} — modified ${n.last_modified ?? "unknown"}\n  id: ${n.id}`);
+            return { content: [{ type: "text", text: lines.join("\n") }] };
+        }
+        catch (err) {
+            return errorResult(err);
+        }
+    });
+    server.tool("read_note", "Read the text content of one OneNote page. Takes the id from list_notes.", { note_id: z.string().describe("The id of the note, as returned by list_notes") }, async ({ note_id }) => {
+        try {
+            const { title, text } = await call("read_note", key, { note_id });
+            return { content: [{ type: "text", text: `# ${title}\n\n${text}` }] };
+        }
+        catch (err) {
+            return errorResult(err);
+        }
+    });
+    await server.connect(new StdioServerTransport());
+}
+function errorResult(err) {
+    const message = err instanceof GraphError ? err.message : `Unexpected error: ${err}`;
+    return { content: [{ type: "text", text: message }], isError: true };
+}

package/package.json

@@ -0,0 +1,30 @@
+{
+  "name": "@manudota/artist-mcp",
+  "version": "0.1.0",
+  "description": "MCP server that reads your OneNote notes, via a hosted connection.",
+  "type": "module",
+  "bin": {
+    "artist-mcp": "dist/index.js"
+  },
+  "files": [
+    "dist"
+  ],
+  "engines": {
+    "node": ">=20"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "build": "tsc -p tsconfig.json && chmod +x dist/index.js",
+    "prepublishOnly": "pnpm run build"
+  },
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.12.0",
+    "zod": "^3.23.8"
+  },
+  "devDependencies": {
+    "@types/node": "^22.10.2",
+    "typescript": "^5.7.2"
+  }
+}