@notjustyou/mcp 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Not Just You
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,66 @@
+# @notjustyou/mcp
+
+Read-only MCP server for Not Just You AI service status lookup.
+
+## Install
+
+```bash
+npm install -g @notjustyou/mcp
+```
+
+You can also run it from a workspace checkout:
+
+```bash
+pnpm --filter @notjustyou/mcp build
+NOTJUSTYOU_BASE_URL=http://localhost:3000 node packages/notjustyou-mcp/dist/index.js
+```
+
+## MCP Client Configuration
+
+```json
+{
+  "mcpServers": {
+    "notjustyou": {
+      "command": "notjustyou-mcp",
+      "env": {
+        "NOTJUSTYOU_BASE_URL": "https://notjustyou.dev"
+      }
+    }
+  }
+}
+```
+
+For local development, set `NOTJUSTYOU_BASE_URL` to your local app URL:
+
+```json
+{
+  "mcpServers": {
+    "notjustyou-local": {
+      "command": "node",
+      "args": ["packages/notjustyou-mcp/dist/index.js"],
+      "env": {
+        "NOTJUSTYOU_BASE_URL": "http://localhost:3000"
+      }
+    }
+  }
+}
+```
+
+## Tools
+
+- `list_surfaces`
+- `get_surface_status`
+- `get_recent_signals`
+- `explain_privacy`
+
+All tools are read-only. This package does not expose a signal submission tool and does not require collector credentials.
+
+## Privacy Boundary
+
+The MCP server reads public status summaries only:
+
+- `/api/summary`
+- `/api/signals/summary`
+- `/api/official`
+
+It does not collect prompt text, request or response bodies, headers, API keys, cookies, source files, diffs, clipboard content, exact IP addresses, account emails, or machine/user names.

package/dist/api.d.ts

@@ -0,0 +1,10 @@
+import type { InstalledSignalSummaryResponse, StatusData } from "./types.js";
+export declare function fetchStatusData(baseUrl: string, options?: {
+    serviceId?: string;
+    signalWindowMinutes?: number;
+}): Promise<StatusData>;
+export declare function fetchInstalledSignalSummary(baseUrl: string, options: {
+    serviceId: string;
+    windowMinutes?: number;
+}): Promise<InstalledSignalSummaryResponse>;
+export declare function normalizeBaseUrl(baseUrl: string): string;

package/dist/api.js

@@ -0,0 +1,46 @@
+export async function fetchStatusData(baseUrl, options = {}) {
+    const normalizedBaseUrl = normalizeBaseUrl(baseUrl);
+    const signalsUrl = new URL(`${normalizedBaseUrl}/api/signals/summary`);
+    if (options.serviceId) {
+        signalsUrl.searchParams.set("serviceId", options.serviceId);
+    }
+    if (options.signalWindowMinutes) {
+        signalsUrl.searchParams.set("windowMinutes", String(options.signalWindowMinutes));
+    }
+    const [communityResult, installedSignalsResult, officialResult] = await Promise.allSettled([
+        fetchJson(`${normalizedBaseUrl}/api/summary`),
+        fetchJson(signalsUrl.toString()),
+        fetchJson(`${normalizedBaseUrl}/api/official`),
+    ]);
+    if (communityResult.status === "rejected") {
+        throw communityResult.reason;
+    }
+    return {
+        community: communityResult.value,
+        installedSignals: installedSignalsResult.status === "fulfilled"
+            ? installedSignalsResult.value
+            : null,
+        official: officialResult.status === "fulfilled" ? officialResult.value : null,
+    };
+}
+export async function fetchInstalledSignalSummary(baseUrl, options) {
+    const normalizedBaseUrl = normalizeBaseUrl(baseUrl);
+    const signalsUrl = new URL(`${normalizedBaseUrl}/api/signals/summary`);
+    signalsUrl.searchParams.set("serviceId", options.serviceId);
+    if (options.windowMinutes) {
+        signalsUrl.searchParams.set("windowMinutes", String(options.windowMinutes));
+    }
+    return fetchJson(signalsUrl.toString());
+}
+export function normalizeBaseUrl(baseUrl) {
+    return baseUrl.replace(/\/+$/, "");
+}
+async function fetchJson(url) {
+    const response = await fetch(url, {
+        cache: "no-store",
+    });
+    if (!response.ok) {
+        throw new Error(`Request failed: ${url} (${response.status})`);
+    }
+    return (await response.json());
+}

package/dist/index.d.ts

@@ -0,0 +1,3 @@
+#!/usr/bin/env node
+export declare function main(): Promise<void>;
+export declare function isDirectRun(metaUrl: string, argvPath?: string): boolean;

package/dist/index.js

@@ -0,0 +1,50 @@
+#!/usr/bin/env node
+import { realpathSync } from "node:fs";
+import { createInterface } from "node:readline/promises";
+import { fileURLToPath } from "node:url";
+import { handleJsonRpcMessage, parseJsonRpcLine, serializeJsonRpcMessage, } from "./protocol.js";
+export async function main() {
+    const lines = createInterface({
+        input: process.stdin,
+        crlfDelay: Infinity,
+    });
+    for await (const line of lines) {
+        if (!line.trim())
+            continue;
+        const response = await handleLine(line);
+        if (response) {
+            process.stdout.write(serializeJsonRpcMessage(response));
+        }
+    }
+}
+async function handleLine(line) {
+    try {
+        return await handleJsonRpcMessage(parseJsonRpcLine(line));
+    }
+    catch (error) {
+        return {
+            jsonrpc: "2.0",
+            id: null,
+            error: {
+                code: -32700,
+                message: error instanceof Error ? error.message : String(error),
+            },
+        };
+    }
+}
+export function isDirectRun(metaUrl, argvPath = process.argv[1]) {
+    if (!argvPath)
+        return false;
+    try {
+        return realpathSync(argvPath) === realpathSync(fileURLToPath(metaUrl));
+    }
+    catch {
+        return false;
+    }
+}
+if (isDirectRun(import.meta.url)) {
+    main().catch((error) => {
+        process.stderr.write(`${error instanceof Error ? error.message : String(error)}\n`);
+        process.exitCode = 1;
+    });
+}

package/dist/protocol.d.ts

@@ -0,0 +1,16 @@
+type JsonRpcId = string | number | null;
+export declare function handleJsonRpcMessage(message: unknown): Promise<{
+    jsonrpc: string;
+    id: JsonRpcId;
+    error: {
+        code: number;
+        message: string;
+    };
+} | {
+    jsonrpc: string;
+    id: JsonRpcId;
+    result: unknown;
+} | null>;
+export declare function parseJsonRpcLine(line: string): unknown;
+export declare function serializeJsonRpcMessage(message: unknown): string;
+export {};

package/dist/protocol.js

@@ -0,0 +1,93 @@
+import { callTool, toolErrorResult, ToolExecutionError, TOOLS } from "./tools.js";
+const PROTOCOL_VERSION = "2025-06-18";
+export async function handleJsonRpcMessage(message) {
+    if (!isJsonRpcRequest(message) || !message.method) {
+        return errorResponse(null, -32600, "Invalid Request");
+    }
+    if (message.id === undefined) {
+        return null;
+    }
+    try {
+        if (message.method === "initialize") {
+            return successResponse(message.id, {
+                protocolVersion: PROTOCOL_VERSION,
+                capabilities: {
+                    tools: {
+                        listChanged: false,
+                    },
+                },
+                serverInfo: {
+                    name: "notjustyou-mcp",
+                    title: "Not Just You MCP",
+                    version: "0.1.0",
+                },
+                instructions: "Read-only Not Just You status lookup. This server does not submit signals.",
+            });
+        }
+        if (message.method === "ping") {
+            return successResponse(message.id, {});
+        }
+        if (message.method === "tools/list") {
+            return successResponse(message.id, {
+                tools: TOOLS,
+            });
+        }
+        if (message.method === "tools/call") {
+            const params = readParamsObject(message.params);
+            const name = readToolName(params.name);
+            const result = await callTool(name, params.arguments).catch((error) => {
+                if (error instanceof ToolExecutionError) {
+                    return toolErrorResult(error);
+                }
+                throw error;
+            });
+            return successResponse(message.id, result);
+        }
+        return errorResponse(message.id, -32601, `Method not found: ${message.method}`);
+    }
+    catch (error) {
+        return errorResponse(message.id, -32602, error instanceof Error ? error.message : String(error));
+    }
+}
+export function parseJsonRpcLine(line) {
+    return JSON.parse(line);
+}
+export function serializeJsonRpcMessage(message) {
+    return `${JSON.stringify(message)}\n`;
+}
+function successResponse(id, result) {
+    return {
+        jsonrpc: "2.0",
+        id,
+        result,
+    };
+}
+function errorResponse(id, code, message) {
+    return {
+        jsonrpc: "2.0",
+        id,
+        error: {
+            code,
+            message,
+        },
+    };
+}
+function isJsonRpcRequest(value) {
+    if (typeof value !== "object" || value === null || Array.isArray(value)) {
+        return false;
+    }
+    const candidate = value;
+    return candidate.jsonrpc === "2.0";
+}
+function readParamsObject(value) {
+    if (typeof value !== "object" || value === null || Array.isArray(value)) {
+        throw new Error("params must be an object.");
+    }
+    return value;
+}
+function readToolName(value) {
+    if (typeof value !== "string" || value.length === 0) {
+        throw new Error("Tool name must be a non-empty string.");
+    }
+    return value;
+}

package/dist/tools.d.ts

@@ -0,0 +1,102 @@
+export declare const DEFAULT_BASE_URL = "https://notjustyou.dev";
+export interface McpTool {
+    name: string;
+    title: string;
+    description: string;
+    inputSchema: JsonSchema;
+    annotations: {
+        readOnlyHint: true;
+    };
+}
+export interface ToolResult {
+    content: Array<{
+        type: "text";
+        text: string;
+    }>;
+    structuredContent?: Record<string, unknown>;
+    isError?: boolean;
+}
+export declare class ToolExecutionError extends Error {
+}
+type JsonSchema = {
+    type: "object";
+    properties: Record<string, unknown>;
+    required?: string[];
+    additionalProperties: false;
+};
+export declare const TOOLS: readonly [{
+    readonly name: "list_surfaces";
+    readonly title: "List Not Just You Surfaces";
+    readonly description: "List AI service surfaces with public community, installed-signal, and official status summaries.";
+    readonly inputSchema: {
+        readonly type: "object";
+        readonly properties: {
+            readonly provider: {
+                readonly type: "string";
+                readonly description: "Optional provider id such as openai, anthropic, google, or cursor.";
+            };
+        };
+        readonly additionalProperties: false;
+    };
+    readonly annotations: {
+        readonly readOnlyHint: true;
+    };
+}, {
+    readonly name: "get_surface_status";
+    readonly title: "Get Surface Status";
+    readonly description: "Get public Not Just You status for one service surface by serviceId.";
+    readonly inputSchema: {
+        readonly type: "object";
+        readonly properties: {
+            readonly serviceId: {
+                readonly type: "string";
+                readonly description: "Service id, for example openai-api.";
+            };
+        };
+        readonly required: ["serviceId"];
+        readonly additionalProperties: false;
+    };
+    readonly annotations: {
+        readonly readOnlyHint: true;
+    };
+}, {
+    readonly name: "get_recent_signals";
+    readonly title: "Get Recent Signals";
+    readonly description: "Get recent installed-client signal aggregates for one service surface.";
+    readonly inputSchema: {
+        readonly type: "object";
+        readonly properties: {
+            readonly serviceId: {
+                readonly type: "string";
+                readonly description: "Service id, for example openai-api.";
+            };
+            readonly windowMinutes: {
+                readonly type: "integer";
+                readonly minimum: 1;
+                readonly maximum: 60;
+                readonly description: "Signal summary window in minutes. Defaults to the server default.";
+            };
+        };
+        readonly required: ["serviceId"];
+        readonly additionalProperties: false;
+    };
+    readonly annotations: {
+        readonly readOnlyHint: true;
+    };
+}, {
+    readonly name: "explain_privacy";
+    readonly title: "Explain Privacy Boundary";
+    readonly description: "Explain the public privacy boundary for Not Just You local tools.";
+    readonly inputSchema: {
+        readonly type: "object";
+        readonly properties: {};
+        readonly additionalProperties: false;
+    };
+    readonly annotations: {
+        readonly readOnlyHint: true;
+    };
+}];
+export declare function getBaseUrl(): string;
+export declare function callTool(name: string, argumentsValue: unknown, baseUrl?: string): Promise<ToolResult>;
+export declare function toolErrorResult(error: unknown): ToolResult;
+export {};

package/dist/tools.js

@@ -0,0 +1,305 @@
+import { fetchInstalledSignalSummary, fetchStatusData } from "./api.js";
+export const DEFAULT_BASE_URL = "https://notjustyou.dev";
+export class ToolExecutionError extends Error {
+}
+export const TOOLS = [
+    {
+        name: "list_surfaces",
+        title: "List Not Just You Surfaces",
+        description: "List AI service surfaces with public community, installed-signal, and official status summaries.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                provider: {
+                    type: "string",
+                    description: "Optional provider id such as openai, anthropic, google, or cursor.",
+                },
+            },
+            additionalProperties: false,
+        },
+        annotations: {
+            readOnlyHint: true,
+        },
+    },
+    {
+        name: "get_surface_status",
+        title: "Get Surface Status",
+        description: "Get public Not Just You status for one service surface by serviceId.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                serviceId: {
+                    type: "string",
+                    description: "Service id, for example openai-api.",
+                },
+            },
+            required: ["serviceId"],
+            additionalProperties: false,
+        },
+        annotations: {
+            readOnlyHint: true,
+        },
+    },
+    {
+        name: "get_recent_signals",
+        title: "Get Recent Signals",
+        description: "Get recent installed-client signal aggregates for one service surface.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                serviceId: {
+                    type: "string",
+                    description: "Service id, for example openai-api.",
+                },
+                windowMinutes: {
+                    type: "integer",
+                    minimum: 1,
+                    maximum: 60,
+                    description: "Signal summary window in minutes. Defaults to the server default.",
+                },
+            },
+            required: ["serviceId"],
+            additionalProperties: false,
+        },
+        annotations: {
+            readOnlyHint: true,
+        },
+    },
+    {
+        name: "explain_privacy",
+        title: "Explain Privacy Boundary",
+        description: "Explain the public privacy boundary for Not Just You local tools.",
+        inputSchema: {
+            type: "object",
+            properties: {},
+            additionalProperties: false,
+        },
+        annotations: {
+            readOnlyHint: true,
+        },
+    },
+];
+export function getBaseUrl() {
+    return process.env.NOTJUSTYOU_BASE_URL ?? DEFAULT_BASE_URL;
+}
+export async function callTool(name, argumentsValue, baseUrl = getBaseUrl()) {
+    if (name === "list_surfaces") {
+        const args = readObject(argumentsValue);
+        rejectUnknownFields(args, ["provider"]);
+        const provider = readOptionalString(args.provider, "provider");
+        const data = await readStatusData(baseUrl);
+        const surfaces = listSurfaceSummaries(data, provider);
+        return jsonToolResult({
+            surfaces,
+            sources: sourceAvailability(data),
+        });
+    }
+    if (name === "get_surface_status") {
+        const args = readObject(argumentsValue);
+        rejectUnknownFields(args, ["serviceId"]);
+        const serviceId = readRequiredString(args.serviceId, "serviceId");
+        const data = await readStatusData(baseUrl);
+        const status = getSurfaceSummary(data, serviceId);
+        return jsonToolResult({
+            serviceId,
+            found: Boolean(status.community || status.installedSignals || status.official),
+            ...status,
+            sources: sourceAvailability(data),
+        });
+    }
+    if (name === "get_recent_signals") {
+        const args = readObject(argumentsValue);
+        rejectUnknownFields(args, ["serviceId", "windowMinutes"]);
+        const serviceId = readRequiredString(args.serviceId, "serviceId");
+        const windowMinutes = readOptionalWindowMinutes(args.windowMinutes);
+        const summary = await readInstalledSignalSummary(baseUrl, {
+            serviceId,
+            windowMinutes,
+        });
+        const installedSignals = summary.services.find((service) => service.serviceId === serviceId);
+        return jsonToolResult({
+            serviceId,
+            windowMinutes: summary.windowMinutes,
+            installedSignalsAvailable: true,
+            installedSignals: installedSignals ? formatInstalled(installedSignals) : null,
+        });
+    }
+    if (name === "explain_privacy") {
+        rejectUnknownFields(readObject(argumentsValue), []);
+        return jsonToolResult({
+            readOnly: true,
+            sendsSignals: false,
+            requiresCollectorToken: false,
+            readsPublicEndpoints: [
+                "/api/summary",
+                "/api/signals/summary",
+                "/api/official",
+            ],
+            doesNotCollect: [
+                "prompt text",
+                "request or response bodies",
+                "headers",
+                "API keys",
+                "cookies",
+                "source files",
+                "diffs",
+                "clipboard content",
+                "exact IP addresses",
+                "account emails",
+                "machine or user names",
+            ],
+        });
+    }
+    throw new Error(`Unknown tool: ${name}`);
+}
+export function toolErrorResult(error) {
+    return {
+        content: [
+            {
+                type: "text",
+                text: error instanceof Error ? error.message : String(error),
+            },
+        ],
+        isError: true,
+    };
+}
+async function readStatusData(baseUrl, options = {}) {
+    try {
+        return await fetchStatusData(baseUrl, options);
+    }
+    catch (error) {
+        throw new ToolExecutionError(`Failed to read Not Just You status: ${errorMessage(error)}`);
+    }
+}
+async function readInstalledSignalSummary(baseUrl, options) {
+    try {
+        return await fetchInstalledSignalSummary(baseUrl, options);
+    }
+    catch (error) {
+        throw new ToolExecutionError(`Failed to read installed signal summary: ${errorMessage(error)}`);
+    }
+}
+function listSurfaceSummaries(data, provider) {
+    return getServiceIds(data)
+        .filter((serviceId) => !provider || getProviderId(serviceId) === provider)
+        .map((serviceId) => ({
+        serviceId,
+        providerId: getProviderId(serviceId),
+        ...getSurfaceSummary(data, serviceId),
+    }));
+}
+function getSurfaceSummary(data, serviceId) {
+    const community = data.community.services.find((service) => service.serviceId === serviceId);
+    const installedSignals = data.installedSignals?.services.find((service) => service.serviceId === serviceId);
+    const official = data.official?.services.find((service) => service.serviceId === serviceId);
+    return {
+        community: community ? formatCommunity(community) : null,
+        installedSignals: installedSignals ? formatInstalled(installedSignals) : null,
+        official: official ? formatOfficial(official) : null,
+    };
+}
+function getServiceIds(data) {
+    return [
+        ...new Set([
+            ...data.community.services.map((service) => service.serviceId),
+            ...(data.installedSignals?.services.map((service) => service.serviceId) ?? []),
+            ...(data.official?.services.map((service) => service.serviceId) ?? []),
+        ]),
+    ];
+}
+function getProviderId(serviceId) {
+    return serviceId.split("-")[0] ?? "unknown";
+}
+function formatCommunity(service) {
+    return {
+        total: service.total,
+        counts: service.counts,
+        state: service.communityState,
+    };
+}
+function formatInstalled(service) {
+    return {
+        total: service.total,
+        uniqueInstallationsApprox: service.uniqueInstallationsApprox,
+        countsBySource: numericRecord(service.countsBySource),
+        countsBySymptom: numericRecord(service.countsBySymptom),
+        lastSignal: service.lastSignal
+            ? {
+                symptom: service.lastSignal.symptom,
+                source: service.lastSignal.source,
+                observedAt: service.lastSignal.observedAt,
+            }
+            : null,
+    };
+}
+function formatOfficial(service) {
+    return {
+        overall: service.overall,
+        source: service.source,
+        updatedAt: service.updatedAt,
+    };
+}
+function sourceAvailability(data) {
+    return {
+        community: true,
+        installedSignals: Boolean(data.installedSignals),
+        official: Boolean(data.official),
+    };
+}
+function jsonToolResult(value) {
+    return {
+        content: [
+            {
+                type: "text",
+                text: JSON.stringify(value, null, 2),
+            },
+        ],
+        structuredContent: value,
+        isError: false,
+    };
+}
+function readObject(value) {
+    if (value === undefined || value === null)
+        return {};
+    if (typeof value !== "object" || Array.isArray(value)) {
+        throw new Error("Tool arguments must be an object.");
+    }
+    return value;
+}
+function rejectUnknownFields(value, allowedFields) {
+    const unknownField = Object.keys(value).find((key) => !allowedFields.includes(key));
+    if (unknownField) {
+        throw new Error(`Unknown argument: ${unknownField}`);
+    }
+}
+function readRequiredString(value, name) {
+    if (typeof value !== "string" || value.length === 0) {
+        throw new Error(`${name} must be a non-empty string.`);
+    }
+    return value;
+}
+function readOptionalString(value, name) {
+    if (value === undefined)
+        return undefined;
+    if (typeof value !== "string" || value.length === 0) {
+        throw new Error(`${name} must be a non-empty string when provided.`);
+    }
+    return value;
+}
+function readOptionalWindowMinutes(value) {
+    if (value === undefined)
+        return undefined;
+    if (!Number.isInteger(value) || Number(value) < 1 || Number(value) > 60) {
+        throw new Error("windowMinutes must be an integer from 1 to 60 when provided.");
+    }
+    return Number(value);
+}
+function errorMessage(error) {
+    return error instanceof Error ? error.message : String(error);
+}
+function numericRecord(value) {
+    return Object.fromEntries(Object.entries(value).filter((entry) => {
+        const [, count] = entry;
+        return typeof count === "number";
+    }));
+}

package/dist/types.d.ts

@@ -0,0 +1,47 @@
+export interface CommunityServiceSummary {
+    serviceId: string;
+    total: number;
+    counts: {
+        slow: number;
+        error: number;
+        down: number;
+    };
+    communityState: string;
+}
+export interface CommunitySummaryResponse {
+    windowMinutes: number;
+    updatedAt: string;
+    services: CommunityServiceSummary[];
+}
+export interface InstalledSignalServiceSummary {
+    serviceId: string;
+    total: number;
+    uniqueInstallationsApprox: number;
+    countsBySource: Record<string, number>;
+    countsBySymptom: Record<string, number>;
+    lastSignal: {
+        symptom: string;
+        source: string;
+        observedAt: string;
+    } | null;
+}
+export interface InstalledSignalSummaryResponse {
+    windowMinutes: number;
+    updatedAt: string;
+    services: InstalledSignalServiceSummary[];
+}
+export interface OfficialServiceStatus {
+    serviceId: string;
+    overall: string;
+    source: "official" | "not_connected";
+    updatedAt: string;
+}
+export interface OfficialSummaryResponse {
+    updatedAt: string;
+    services: OfficialServiceStatus[];
+}
+export interface StatusData {
+    community: CommunitySummaryResponse;
+    installedSignals: InstalledSignalSummaryResponse | null;
+    official: OfficialSummaryResponse | null;
+}

package/dist/types.js

@@ -0,0 +1 @@
+export {};

package/package.json

@@ -0,0 +1,49 @@
+{
+  "name": "@notjustyou/mcp",
+  "version": "0.1.0",
+  "description": "Read-only MCP server for Not Just You AI service status lookup.",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/dobbylee/notjustyou.git",
+    "directory": "packages/notjustyou-mcp"
+  },
+  "homepage": "https://github.com/dobbylee/notjustyou#readme",
+  "bugs": {
+    "url": "https://github.com/dobbylee/notjustyou/issues"
+  },
+  "keywords": [
+    "ai-status",
+    "mcp",
+    "status",
+    "notjustyou"
+  ],
+  "type": "module",
+  "files": [
+    "dist",
+    "LICENSE",
+    "README.md"
+  ],
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    }
+  },
+  "bin": {
+    "notjustyou-mcp": "dist/index.js"
+  },
+  "scripts": {
+    "build": "tsc -p tsconfig.json",
+    "prepack": "pnpm run build",
+    "pack:dry-run": "pnpm pack --dry-run"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "engines": {
+    "node": ">=20.9.0"
+  }
+}