squally-mcp 0.1.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
@@ -0,0 +1,45 @@
1
+ export type JsonSchema = Record<string, unknown>;
2
+ export type OpenApiParameter = {
3
+ name: string;
4
+ in: "path" | "query";
5
+ required?: boolean;
6
+ description?: string;
7
+ schema: JsonSchema;
8
+ };
9
+ export type OpenApiOperation = {
10
+ operationId: string;
11
+ method: string;
12
+ path: string;
13
+ summary?: string;
14
+ description?: string;
15
+ parameters: OpenApiParameter[];
16
+ /** The 200 response's schema, with any $ref already resolved. */
17
+ responseSchema: JsonSchema;
18
+ };
19
+ export type ErrorCode = {
20
+ code: string;
21
+ status: number;
22
+ when: string;
23
+ action: string;
24
+ hasBody: boolean;
25
+ };
26
+ export type OpenApiDocument = {
27
+ version: string;
28
+ operations: Map<string, OpenApiOperation>;
29
+ errorCodes: Map<string, ErrorCode>;
30
+ };
31
+ export declare function parseDocument(text: string): OpenApiDocument;
32
+ export declare function loadDocument(): OpenApiDocument;
33
+ export declare function operationFor(operationId: string): OpenApiOperation;
34
+ /**
35
+ * The operation's parameters as one JSON Schema object.
36
+ *
37
+ * `additionalProperties: false` on purpose: a model that invents a parameter
38
+ * should be told, not silently ignored - an ignored `?branch=` reads to the
39
+ * agent as "there are no runs on that branch".
40
+ *
41
+ * Descriptions come from the document except for the two in
42
+ * PARAMETER_DESCRIPTIONS - see there for why those cannot.
43
+ */
44
+ export declare function inputSchemaFor(operation: OpenApiOperation): JsonSchema;
45
+ export declare function outputSchemaFor(operation: OpenApiOperation): JsonSchema;
@@ -0,0 +1,139 @@
1
+ // The vendored OpenAPI document, and the two schemas each tool is built from.
2
+ //
3
+ // DERIVED, NOT TRANSCRIBED. A tool's inputSchema is the operation's parameter
4
+ // list and its outputSchema is the operation's 200 response schema, both read
5
+ // out of the document at startup. Hand-writing either would create a second
6
+ // description of the same contract, and the two would drift the first time a
7
+ // parameter changed - the failure read-api-mcp-spec §4.6 guards against on the
8
+ // server side ("two endpoints cannot describe the same run differently").
9
+ //
10
+ // The document is a file beside the compiled code, never a fetch: see
11
+ // scripts/vendor-openapi.mjs for why, and test/drift.test.js for the check
12
+ // that keeps the copy honest.
13
+ import { readFileSync } from "node:fs";
14
+ const DOCUMENT_URL = new URL("./openapi/v1.json", import.meta.url);
15
+ /** Resolves a local `#/components/...` pointer; other forms are not produced by our generator. */
16
+ function resolveRef(raw, ref) {
17
+ if (!ref.startsWith("#/"))
18
+ throw new Error(`unsupported $ref: ${ref}`);
19
+ let node = raw;
20
+ for (const part of ref.slice(2).split("/")) {
21
+ node = node?.[part.replace(/~1/g, "/").replace(/~0/g, "~")];
22
+ if (node === undefined)
23
+ throw new Error(`$ref does not resolve: ${ref}`);
24
+ }
25
+ return node;
26
+ }
27
+ function deref(raw, schema) {
28
+ const ref = schema["$ref"];
29
+ return typeof ref === "string" ? deref(raw, resolveRef(raw, ref)) : schema;
30
+ }
31
+ export function parseDocument(text) {
32
+ const raw = JSON.parse(text);
33
+ const operations = new Map();
34
+ for (const [path, methods] of Object.entries(raw.paths ?? {})) {
35
+ for (const [method, operation] of Object.entries(methods)) {
36
+ if (method === "parameters" || !operation?.operationId)
37
+ continue;
38
+ const success = operation.responses?.["200"]?.content?.["application/json"]?.schema;
39
+ if (!success)
40
+ continue;
41
+ operations.set(operation.operationId, {
42
+ operationId: operation.operationId,
43
+ method: method.toUpperCase(),
44
+ path,
45
+ summary: operation.summary,
46
+ description: operation.description,
47
+ parameters: (operation.parameters ?? []).map((p) => ({
48
+ name: p.name,
49
+ in: p.in,
50
+ required: Boolean(p.required),
51
+ description: p.description,
52
+ schema: deref(raw, p.schema ?? {}),
53
+ })),
54
+ responseSchema: deref(raw, success),
55
+ });
56
+ }
57
+ }
58
+ const errorCodes = new Map();
59
+ for (const entry of (raw["x-error-codes"] ?? [])) {
60
+ errorCodes.set(entry.code, entry);
61
+ }
62
+ return { version: raw.info?.version ?? "unknown", operations, errorCodes };
63
+ }
64
+ let cached = null;
65
+ export function loadDocument() {
66
+ if (cached === null)
67
+ cached = parseDocument(readFileSync(DOCUMENT_URL, "utf8"));
68
+ return cached;
69
+ }
70
+ export function operationFor(operationId) {
71
+ const operation = loadDocument().operations.get(operationId);
72
+ if (!operation) {
73
+ // Unreachable through the shipped tool table, and loud rather than silent
74
+ // if the vendored document is ever replaced by one missing an operation:
75
+ // a tool that quietly disappears is worse than a server that will not
76
+ // start.
77
+ throw new Error(`the vendored OpenAPI document has no operation "${operationId}"`);
78
+ }
79
+ return operation;
80
+ }
81
+ /**
82
+ * Parameter descriptions that must NOT come from the OpenAPI document.
83
+ *
84
+ * The document describes an HTTP request, where the caller builds the URL and
85
+ * therefore has to percent-encode a test name itself. A tool argument is not a
86
+ * URL: src/api.ts encodes it on the way out, so a pre-encoded argument is
87
+ * encoded twice and stops matching anything.
88
+ *
89
+ * MEASURED, NOT ANTICIPATED (24.09., §10e session). Claude Code read the
90
+ * document's "URL-encode it, including \"/\" as %2F" and sent
91
+ * `checkout%20flow%20%3E%20...`. Against the live dev API the raw name
92
+ * resolves to a status and the pre-encoded one answers `test_not_found` - so
93
+ * the model would have reported a test that exists as missing.
94
+ *
95
+ * Deliberately NOT solved by detecting already-encoded input: a test name may
96
+ * legitimately contain a percent sign, so "looks encoded" is a guess, and a
97
+ * client that guesses wrong about its own arguments is worse than one that
98
+ * states the rule plainly.
99
+ */
100
+ const PARAMETER_DESCRIPTIONS = {
101
+ testName: "The full test name as Squally stores it (the Playwright title path), for example " +
102
+ '"checkout flow > completes payment". Pass the name exactly as shown in Squally; ' +
103
+ "do not URL-encode, the server does. A name used in several spec files also needs filePath.",
104
+ filePath: "The spec file of the test, as stored (e.g. tests/checkout.spec.ts); an empty value " +
105
+ "means a test with no file. Pass it exactly as shown in Squally; do not URL-encode, " +
106
+ "the server does. Needed only when the name exists in several files - the " +
107
+ "ambiguous_test error lists them.",
108
+ };
109
+ /**
110
+ * The operation's parameters as one JSON Schema object.
111
+ *
112
+ * `additionalProperties: false` on purpose: a model that invents a parameter
113
+ * should be told, not silently ignored - an ignored `?branch=` reads to the
114
+ * agent as "there are no runs on that branch".
115
+ *
116
+ * Descriptions come from the document except for the two in
117
+ * PARAMETER_DESCRIPTIONS - see there for why those cannot.
118
+ */
119
+ export function inputSchemaFor(operation) {
120
+ const properties = {};
121
+ const required = [];
122
+ for (const parameter of operation.parameters) {
123
+ const { description, ...rest } = parameter.schema;
124
+ const override = PARAMETER_DESCRIPTIONS[parameter.name];
125
+ const text = override ?? parameter.description ?? description;
126
+ properties[parameter.name] = text === undefined ? { ...rest } : { ...rest, description: text };
127
+ if (parameter.required)
128
+ required.push(parameter.name);
129
+ }
130
+ return {
131
+ type: "object",
132
+ properties,
133
+ ...(required.length > 0 ? { required } : {}),
134
+ additionalProperties: false,
135
+ };
136
+ }
137
+ export function outputSchemaFor(operation) {
138
+ return operation.responseSchema;
139
+ }
@@ -0,0 +1,18 @@
1
+ import type { CallToolResult } from "@modelcontextprotocol/sdk/types.js";
2
+ import type { ApiFailure, ApiResult, ApiUnreachable } from "./api.js";
3
+ import type { ErrorCode } from "./openapi.js";
4
+ /** The one message for a rate limit, which arrives without a body. */
5
+ export declare const RATE_LIMITED_TEXT = "Rate limited - wait 60 seconds, then retry.";
6
+ /**
7
+ * The line appended when the key is within 7 days of expiring.
8
+ *
9
+ * One line, on every successful call, for as long as the header is sent. It is
10
+ * the only warning the user gets: the key stops working on that date and there
11
+ * is no renewal (spec §2.2.2), so a quiet expiry would read to an agent as the
12
+ * API having broken.
13
+ */
14
+ export declare function expiryLine(isoDate: string): string;
15
+ export declare function successResult(data: unknown, keyExpiresAt: string | null): CallToolResult;
16
+ export declare function failureResult(failure: ApiFailure, errorCodes: Map<string, ErrorCode>): CallToolResult;
17
+ export declare function unreachableResult(failure: ApiUnreachable, apiBase: string): CallToolResult;
18
+ export declare function toolResult(result: ApiResult, errorCodes: Map<string, ErrorCode>, apiBase: string): CallToolResult;
package/dist/result.js ADDED
@@ -0,0 +1,70 @@
1
+ /** The one message for a rate limit, which arrives without a body. */
2
+ export const RATE_LIMITED_TEXT = "Rate limited - wait 60 seconds, then retry.";
3
+ function text(value) {
4
+ return { type: "text", text: value };
5
+ }
6
+ /**
7
+ * The line appended when the key is within 7 days of expiring.
8
+ *
9
+ * One line, on every successful call, for as long as the header is sent. It is
10
+ * the only warning the user gets: the key stops working on that date and there
11
+ * is no renewal (spec §2.2.2), so a quiet expiry would read to an agent as the
12
+ * API having broken.
13
+ */
14
+ export function expiryLine(isoDate) {
15
+ const parsed = new Date(isoDate);
16
+ const shown = Number.isNaN(parsed.getTime())
17
+ ? isoDate
18
+ : parsed.toISOString().slice(0, 10);
19
+ return `Note: this Squally read key expires on ${shown}. Create a new one in Settings -> API keys before then; expired keys are not renewed.`;
20
+ }
21
+ export function successResult(data, keyExpiresAt) {
22
+ const content = [text(JSON.stringify(data, null, 2))];
23
+ if (keyExpiresAt)
24
+ content.push(text(expiryLine(keyExpiresAt)));
25
+ return {
26
+ content,
27
+ // The API's JSON verbatim. The tool's outputSchema is that operation's own
28
+ // 200 schema, so the client can validate this without trusting us.
29
+ structuredContent: data,
30
+ };
31
+ }
32
+ export function failureResult(failure, errorCodes) {
33
+ if (failure.status === 429) {
34
+ return { content: [text(RATE_LIMITED_TEXT)], isError: true };
35
+ }
36
+ const known = failure.code ? errorCodes.get(failure.code) : undefined;
37
+ const lines = [];
38
+ lines.push(failure.message ?? `The Squally API answered HTTP ${failure.status}.`);
39
+ if (failure.code)
40
+ lines.push(`Error code: ${failure.code}`);
41
+ if (known) {
42
+ lines.push(`What to do: ${known.action}`);
43
+ }
44
+ else if (failure.status >= 500) {
45
+ // Not in the catalogue, but the document states one retry rule for 5xx and
46
+ // an agent that retries a 500 immediately, forever, is the failure mode.
47
+ lines.push("What to do: retry with exponential backoff from 1 second, capped at 30 seconds.");
48
+ }
49
+ return { content: [text(lines.join("\n"))], isError: true };
50
+ }
51
+ export function unreachableResult(failure, apiBase) {
52
+ return {
53
+ content: [
54
+ text(`Could not reach the Squally API at ${apiBase} (${failure.detail}). ` +
55
+ "Check that the host is correct and reachable; if SQUALLY_API_URL is set, it should be " +
56
+ "a base URL such as https://app.squally.dev."),
57
+ ],
58
+ isError: true,
59
+ };
60
+ }
61
+ export function toolResult(result, errorCodes, apiBase) {
62
+ switch (result.kind) {
63
+ case "success":
64
+ return successResult(result.data, result.keyExpiresAt);
65
+ case "failure":
66
+ return failureResult(result, errorCodes);
67
+ case "unreachable":
68
+ return unreachableResult(result, apiBase);
69
+ }
70
+ }
@@ -0,0 +1,8 @@
1
+ import { Server } from "@modelcontextprotocol/sdk/server/index.js";
2
+ import { type Tool } from "@modelcontextprotocol/sdk/types.js";
3
+ import type { Config } from "./config.js";
4
+ import { type Fetcher } from "./api.js";
5
+ export declare const SERVER_NAME = "squally";
6
+ /** The tool list as it goes on the wire - also what the schema tests assert. */
7
+ export declare function toolList(): Tool[];
8
+ export declare function createServer(config: Config, version: string, fetcher?: Fetcher): Server;
package/dist/server.js ADDED
@@ -0,0 +1,55 @@
1
+ // The MCP server: seven tools over stdio, each one HTTP GET.
2
+ //
3
+ // THE LOW-LEVEL Server RATHER THAN McpServer.registerTool, deliberately. The
4
+ // tool schemas here are not authored in TypeScript - they are lifted out of
5
+ // the OpenAPI document (src/openapi.ts) and must reach the client byte for
6
+ // byte, because read-api-mcp-spec §10e makes them a contract ("schemas are a
7
+ // contract with clients and must not drift silently") and test/schemas.test.js
8
+ // pins them. registerTool would take a Zod shape and generate its own JSON
9
+ // Schema, putting a translation layer between the document and the wire.
10
+ import { Server } from "@modelcontextprotocol/sdk/server/index.js";
11
+ import { CallToolRequestSchema, ListToolsRequestSchema, } from "@modelcontextprotocol/sdk/types.js";
12
+ import { callOperation } from "./api.js";
13
+ import { INSTRUCTIONS } from "./instructions.js";
14
+ import { inputSchemaFor, loadDocument, operationFor, outputSchemaFor } from "./openapi.js";
15
+ import { toolResult } from "./result.js";
16
+ import { ANNOTATIONS, TOOLS } from "./tools.js";
17
+ import { validateArgs } from "./validate.js";
18
+ export const SERVER_NAME = "squally";
19
+ /** The tool list as it goes on the wire - also what the schema tests assert. */
20
+ export function toolList() {
21
+ return TOOLS.map((tool) => {
22
+ const operation = operationFor(tool.operationId);
23
+ return {
24
+ name: tool.name,
25
+ title: tool.title,
26
+ description: tool.description,
27
+ inputSchema: inputSchemaFor(operation),
28
+ outputSchema: outputSchemaFor(operation),
29
+ annotations: ANNOTATIONS,
30
+ };
31
+ });
32
+ }
33
+ export function createServer(config, version, fetcher = fetch) {
34
+ const document = loadDocument();
35
+ const byName = new Map(TOOLS.map((tool) => [tool.name, tool]));
36
+ const server = new Server({ name: SERVER_NAME, version }, { capabilities: { tools: {} }, instructions: INSTRUCTIONS });
37
+ server.setRequestHandler(ListToolsRequestSchema, async () => ({ tools: toolList() }));
38
+ server.setRequestHandler(CallToolRequestSchema, async (request) => {
39
+ const tool = byName.get(request.params.name);
40
+ if (!tool) {
41
+ return {
42
+ content: [{ type: "text", text: `Unknown tool: ${request.params.name}` }],
43
+ isError: true,
44
+ };
45
+ }
46
+ const operation = operationFor(tool.operationId);
47
+ const validated = validateArgs(operation, request.params.arguments);
48
+ if (!validated.ok) {
49
+ return { content: [{ type: "text", text: validated.message }], isError: true };
50
+ }
51
+ const result = await callOperation(config, operation, validated.args, fetcher);
52
+ return toolResult(result, document.errorCodes, config.apiBase);
53
+ });
54
+ return server;
55
+ }
@@ -0,0 +1,14 @@
1
+ import type { ToolAnnotations } from "@modelcontextprotocol/sdk/types.js";
2
+ /**
3
+ * §5.4, on every tool. `readOnlyHint` is what lets a client run these without
4
+ * a confirmation prompt, and it is structurally true here: this server issues
5
+ * GETs and has no code path that writes.
6
+ */
7
+ export declare const ANNOTATIONS: ToolAnnotations;
8
+ export type ToolDefinition = {
9
+ name: string;
10
+ title: string;
11
+ operationId: string;
12
+ description: string;
13
+ };
14
+ export declare const TOOLS: ToolDefinition[];
package/dist/tools.js ADDED
@@ -0,0 +1,67 @@
1
+ /**
2
+ * §5.4, on every tool. `readOnlyHint` is what lets a client run these without
3
+ * a confirmation prompt, and it is structurally true here: this server issues
4
+ * GETs and has no code path that writes.
5
+ */
6
+ export const ANNOTATIONS = {
7
+ readOnlyHint: true,
8
+ destructiveHint: false,
9
+ idempotentHint: true,
10
+ openWorldHint: false,
11
+ };
12
+ export const TOOLS = [
13
+ {
14
+ name: "squally-list-projects",
15
+ title: "List projects",
16
+ operationId: "listProjects",
17
+ description: "Lists the projects in your Squally organization. Start here: every other tool needs a " +
18
+ "projectId, and this is the only tool that produces one.",
19
+ },
20
+ {
21
+ name: "squally-find-run",
22
+ title: "Find runs",
23
+ operationId: "listRuns",
24
+ description: "Finds CI runs of a project - the latest, or filtered by branch, commit SHA or status. " +
25
+ "One row per logical run: a sharded run is collapsed into a single entry. Returns summary " +
26
+ "counters only; use squally-get-run for the per-test rows.",
27
+ },
28
+ {
29
+ name: "squally-get-run",
30
+ title: "Get one run",
31
+ operationId: "getRun",
32
+ description: "One run with its per-test result rows, across every shard. Use this to find out which " +
33
+ "test is red in a run; the run list carries only the counters.",
34
+ },
35
+ {
36
+ name: "squally-debug-failure",
37
+ title: "Debug a failing test",
38
+ operationId: "getRunTestAttempts",
39
+ description: "Every attempt of one test in one run, oldest first, each with the error, the stack and " +
40
+ "the Copy-for-AI prompt (the same text the Squally UI puts on the clipboard). This is the " +
41
+ "tool for 'why did this test fail'. If the test name is ambiguous, pass filePath.",
42
+ },
43
+ {
44
+ name: "squally-get-test-status",
45
+ title: "Get a test's status",
46
+ operationId: "getTestStatus",
47
+ description: "The stored flakiness status and active signals for ONE test. Cheap - one findUnique. " +
48
+ "Use this when you are asking about a single test; do not reach for " +
49
+ "squally-list-flaky-tests, which is expensive.",
50
+ },
51
+ {
52
+ name: "squally-list-flaky-tests",
53
+ title: "List flaky tests",
54
+ operationId: "listFlakyTests",
55
+ description: "The project's flaky and broken tests, ranked, with the time each has cost (timeLostMs). " +
56
+ "Expensive - one engine pass over the project's recent runs. For a single test use " +
57
+ "squally-get-test-status instead.",
58
+ },
59
+ {
60
+ name: "squally-list-errors",
61
+ title: "List error signatures",
62
+ operationId: "listErrors",
63
+ description: "The project's error signatures in a period: failures grouped by fingerprint, with how " +
64
+ "often and how recently each occurred. Answers 'is this failure one instance of something " +
65
+ "that keeps happening' - a grouping no agent can compute from the repository alone.",
66
+ },
67
+ ];
@@ -0,0 +1,20 @@
1
+ import { z } from "zod";
2
+ import type { OpenApiOperation } from "./openapi.js";
3
+ /**
4
+ * A validator for one operation's arguments.
5
+ *
6
+ * `.strict()` mirrors the advertised `additionalProperties: false`: an unknown
7
+ * argument is reported rather than dropped, because a dropped `branch` reads
8
+ * to the agent as "no runs on that branch" rather than as "I made that
9
+ * parameter up".
10
+ */
11
+ export declare function validatorFor(operation: OpenApiOperation): z.ZodType;
12
+ export type ValidationResult = {
13
+ ok: true;
14
+ args: Record<string, unknown>;
15
+ } | {
16
+ ok: false;
17
+ message: string;
18
+ };
19
+ /** One sentence naming every problem, so a model can fix them all in one retry. */
20
+ export declare function validateArgs(operation: OpenApiOperation, raw: unknown): ValidationResult;
@@ -0,0 +1,88 @@
1
+ // Argument validation, built from the same parameter list the tool advertises.
2
+ //
3
+ // WHY VALIDATE AT ALL when the tool already ships an inputSchema: the schema
4
+ // is a hint to the client, not a guarantee to the server. Clients differ in
5
+ // how strictly they enforce it and some do not enforce it at all, so an
6
+ // argument reaching the handler has been checked by nobody. Without this, a
7
+ // model passing days=5 would produce a 400 from the API with a sentence about
8
+ // a query parameter the model never saw itself write.
9
+ //
10
+ // Built FROM the OpenAPI parameter schema rather than written beside it, for
11
+ // the reason src/openapi.ts gives: two descriptions of one contract drift.
12
+ import { z } from "zod";
13
+ function stringSchema(schema) {
14
+ const values = schema["enum"];
15
+ if (Array.isArray(values)) {
16
+ return z.enum(values.map(String));
17
+ }
18
+ let out = z.string();
19
+ const min = schema["minLength"];
20
+ const max = schema["maxLength"];
21
+ const pattern = schema["pattern"];
22
+ if (typeof min === "number")
23
+ out = out.min(min);
24
+ if (typeof max === "number")
25
+ out = out.max(max);
26
+ if (typeof pattern === "string")
27
+ out = out.regex(new RegExp(pattern));
28
+ return out;
29
+ }
30
+ function integerSchema(schema) {
31
+ const values = schema["enum"];
32
+ if (Array.isArray(values)) {
33
+ const allowed = values.map(Number);
34
+ return z
35
+ .number()
36
+ .int()
37
+ .refine((n) => allowed.includes(n), {
38
+ message: `must be one of: ${allowed.join(", ")}`,
39
+ });
40
+ }
41
+ let out = z.number().int();
42
+ const minimum = schema["minimum"];
43
+ if (typeof minimum === "number")
44
+ out = out.min(minimum);
45
+ return out;
46
+ }
47
+ function forParameter(schema) {
48
+ switch (schema["type"]) {
49
+ case "integer":
50
+ case "number":
51
+ return integerSchema(schema);
52
+ case "boolean":
53
+ return z.boolean();
54
+ case "string":
55
+ default:
56
+ return stringSchema(schema);
57
+ }
58
+ }
59
+ /**
60
+ * A validator for one operation's arguments.
61
+ *
62
+ * `.strict()` mirrors the advertised `additionalProperties: false`: an unknown
63
+ * argument is reported rather than dropped, because a dropped `branch` reads
64
+ * to the agent as "no runs on that branch" rather than as "I made that
65
+ * parameter up".
66
+ */
67
+ export function validatorFor(operation) {
68
+ const shape = {};
69
+ for (const parameter of operation.parameters) {
70
+ const base = forParameter(parameter.schema);
71
+ shape[parameter.name] = parameter.required ? base : base.optional();
72
+ }
73
+ return z.object(shape).strict();
74
+ }
75
+ /** One sentence naming every problem, so a model can fix them all in one retry. */
76
+ export function validateArgs(operation, raw) {
77
+ const parsed = validatorFor(operation).safeParse(raw ?? {});
78
+ if (parsed.success)
79
+ return { ok: true, args: parsed.data };
80
+ const problems = parsed.error.issues.map((issue) => {
81
+ const where = issue.path.length > 0 ? issue.path.join(".") : "(arguments)";
82
+ return `${where}: ${issue.message}`;
83
+ });
84
+ return {
85
+ ok: false,
86
+ message: `Invalid arguments for this tool - ${problems.join("; ")}.`,
87
+ };
88
+ }
package/package.json ADDED
@@ -0,0 +1,48 @@
1
+ {
2
+ "name": "squally-mcp",
3
+ "version": "0.1.0",
4
+ "description": "Local MCP server for Squally — read-only access to your Playwright test runs, flaky tests and failures.",
5
+ "license": "MIT",
6
+ "author": "Squally",
7
+ "homepage": "https://app.squally.dev",
8
+ "repository": {
9
+ "type": "git",
10
+ "url": "git+https://github.com/squallydev-admin/squally-mcp.git"
11
+ },
12
+ "bugs": {
13
+ "url": "https://github.com/squallydev-admin/squally-mcp/issues"
14
+ },
15
+ "keywords": [
16
+ "mcp",
17
+ "modelcontextprotocol",
18
+ "playwright",
19
+ "flaky-tests",
20
+ "squally"
21
+ ],
22
+ "type": "module",
23
+ "bin": {
24
+ "squally-mcp": "dist/index.js"
25
+ },
26
+ "main": "dist/index.js",
27
+ "types": "dist/index.d.ts",
28
+ "files": [
29
+ "dist"
30
+ ],
31
+ "engines": {
32
+ "node": ">=22"
33
+ },
34
+ "scripts": {
35
+ "build": "tsc && node scripts/copy-assets.mjs",
36
+ "vendor:openapi": "node scripts/vendor-openapi.mjs",
37
+ "test": "npm run build && node --test \"test/**/*.test.js\"",
38
+ "prepublishOnly": "npm run build"
39
+ },
40
+ "dependencies": {
41
+ "@modelcontextprotocol/sdk": "^1.30.1",
42
+ "zod": "^4.6.5"
43
+ },
44
+ "devDependencies": {
45
+ "@types/node": "^22.10.0",
46
+ "typescript": "^5.6.0"
47
+ }
48
+ }