driggsby 0.1.12 → 0.1.13

package/dist/broker/test-support.js

@@ -1,258 +0,0 @@
-/* eslint-disable @typescript-eslint/no-deprecated */
-import assert from "node:assert/strict";
-import { mkdtemp } from "node:fs/promises";
-import http from "node:http";
-import os from "node:os";
-import path from "node:path";
-import { decodeProtectedHeader, importJWK, jwtVerify, } from "jose";
-import { Server } from "@modelcontextprotocol/sdk/server/index.js";
-import { StreamableHTTPServerTransport } from "@modelcontextprotocol/sdk/server/streamableHttp.js";
-import { CallToolRequestSchema, ListToolsRequestSchema, } from "@modelcontextprotocol/sdk/types.js";
-export async function makeBrokerRuntimePaths(prefix) {
-    const baseDir = await mkdtemp(path.join(os.tmpdir(), prefix));
-    return {
-        configDir: path.join(baseDir, "config"),
-        stateDir: path.join(baseDir, "state"),
-        metadataPath: path.join(baseDir, "config", "broker-metadata.json"),
-        lockPath: path.join(baseDir, "state", "broker.lock"),
-        socketPath: path.join(baseDir, "state", "broker.sock"),
-    };
-}
-export async function startFakeRemoteService() {
-    let currentAccessToken = "refreshed-access-token";
-    let tokenRequestCount = 0;
-    let listToolsCount = 0;
-    let callToolCount = 0;
-    let exposeSavingsTool = false;
-    const server = http.createServer((request, response) => {
-        void handleRequest(request, response);
-    });
-    async function handleRequest(request, response) {
-        const requestUrl = new URL(request.url ?? "/", "http://127.0.0.1");
-        if (request.method === "GET" &&
-            requestUrl.pathname === "/.well-known/oauth-authorization-server") {
-            response.setHeader("content-type", "application/json");
-            response.end(JSON.stringify({
-                issuer: originForServer(server),
-                authorization_endpoint: `${originForServer(server)}/authorize`,
-                token_endpoint: `${originForServer(server)}/token`,
-                registration_endpoint: `${originForServer(server)}/register`,
-                response_types_supported: ["code"],
-                grant_types_supported: ["authorization_code", "refresh_token"],
-                token_endpoint_auth_methods_supported: ["none"],
-                dpop_signing_alg_values_supported: ["ES256"],
-                code_challenge_methods_supported: ["S256"],
-                scopes_supported: ["driggsby.default"],
-            }));
-            return;
-        }
-        if (request.method === "POST" && requestUrl.pathname === "/token") {
-            tokenRequestCount += 1;
-            const body = await readRequestBody(request);
-            const params = new URLSearchParams(body);
-            assert.equal(params.get("client_id"), "client-123");
-            assert.equal(params.get("grant_type"), "refresh_token");
-            assert.equal(params.get("refresh_token"), "refresh-token-1");
-            assert.equal(params.get("resource"), `${originForServer(server)}/mcp`);
-            await assertDpopProof(request.headers["dpop"], {
-                authorizationHeader: undefined,
-                expectedMethod: "POST",
-                expectedUrl: `${originForServer(server)}/token`,
-            });
-            currentAccessToken = "refreshed-access-token";
-            response.setHeader("content-type", "application/json");
-            response.end(JSON.stringify({
-                access_token: currentAccessToken,
-                token_type: "DPoP",
-                expires_in: 3600,
-                refresh_token: "refresh-token-2",
-                scope: "driggsby.default",
-            }));
-            return;
-        }
-        if (requestUrl.pathname === "/mcp" && request.method === "GET") {
-            response.statusCode = 405;
-            response.setHeader("content-type", "application/json");
-            response.end(JSON.stringify({
-                error: {
-                    code: -32000,
-                    message: "Method not allowed.",
-                },
-                id: null,
-                jsonrpc: "2.0",
-            }));
-            return;
-        }
-        if (requestUrl.pathname === "/mcp" && request.method === "POST") {
-            if (request.headers.authorization !== `DPoP ${currentAccessToken}`) {
-                response.statusCode = 401;
-                response.end();
-                return;
-            }
-            await assertDpopProof(request.headers["dpop"], {
-                authorizationHeader: request.headers.authorization,
-                expectedMethod: "POST",
-                expectedUrl: `${originForServer(server)}/mcp`,
-            });
-            const mcpServer = new Server({
-                name: "fake-remote-mcp",
-                version: "0.1.0",
-            }, {
-                capabilities: {
-                    tools: {},
-                },
-            });
-            mcpServer.setRequestHandler(ListToolsRequestSchema, () => {
-                listToolsCount += 1;
-                return {
-                    tools: [
-                        {
-                            description: "Echo a balance amount back to the caller.",
-                            inputSchema: {
-                                additionalProperties: false,
-                                properties: {
-                                    amount: {
-                                        type: "string",
-                                    },
-                                },
-                                required: ["amount"],
-                                type: "object",
-                            },
-                            name: "echo_balance",
-                        },
-                        ...(exposeSavingsTool
-                            ? [
-                                {
-                                    description: "Project a savings target over time.",
-                                    inputSchema: {
-                                        additionalProperties: false,
-                                        properties: {},
-                                        type: "object",
-                                    },
-                                    name: "savings_projection",
-                                },
-                            ]
-                            : []),
-                    ],
-                };
-            });
-            mcpServer.setRequestHandler(CallToolRequestSchema, (mcpRequest) => {
-                callToolCount += 1;
-                const amount = readAmountArgument(mcpRequest.params.arguments);
-                return {
-                    content: [
-                        {
-                            text: `echoed ${amount}`,
-                            type: "text",
-                        },
-                    ],
-                };
-            });
-            const transport = new StreamableHTTPServerTransport({});
-            await mcpServer.connect(toTransport(transport));
-            await transport.handleRequest(request, response, await readJsonBody(request));
-            response.once("close", () => {
-                void transport.close();
-                void mcpServer.close();
-            });
-            return;
-        }
-        response.statusCode = 404;
-        response.end();
-    }
-    await new Promise((resolve, reject) => {
-        server.once("error", reject);
-        server.listen(0, "127.0.0.1", resolve);
-    });
-    return {
-        async close() {
-            await new Promise((resolve, reject) => {
-                server.close((error) => {
-                    if (error) {
-                        reject(error);
-                        return;
-                    }
-                    resolve();
-                });
-            });
-        },
-        get callToolCount() {
-            return callToolCount;
-        },
-        get listToolsCount() {
-            return listToolsCount;
-        },
-        get origin() {
-            return originForServer(server);
-        },
-        setExposeSavingsTool(value) {
-            exposeSavingsTool = value;
-        },
-        get tokenRequestCount() {
-            return tokenRequestCount;
-        },
-    };
-}
-function readAmountArgument(argumentsValue) {
-    if (typeof argumentsValue !== "object" ||
-        argumentsValue === null ||
-        Array.isArray(argumentsValue)) {
-        throw new Error("Expected object arguments.");
-    }
-    const amount = argumentsValue["amount"];
-    if (typeof amount !== "string") {
-        throw new Error("Expected a string amount argument.");
-    }
-    return amount;
-}
-async function readJsonBody(request) {
-    const body = await readRequestBody(request);
-    if (body.length === 0) {
-        return undefined;
-    }
-    return JSON.parse(body);
-}
-async function assertDpopProof(proof, options) {
-    if (typeof proof !== "string") {
-        throw new Error("Expected a DPoP proof header.");
-    }
-    const protectedHeader = decodeProtectedHeader(proof);
-    const verificationKey = await importJWK(protectedHeader.jwk, "ES256");
-    const { payload } = await jwtVerify(proof, verificationKey, {
-        algorithms: ["ES256"],
-        typ: "dpop+jwt",
-    });
-    assert.equal(payload["htm"], options.expectedMethod);
-    assert.equal(payload["htu"], options.expectedUrl);
-    if (options.authorizationHeader !== undefined) {
-        const [, accessToken] = options.authorizationHeader.split(" ");
-        if (accessToken === undefined) {
-            throw new Error("Expected an access token in the authorization header.");
-        }
-        assert.ok(typeof payload["ath"] === "string");
-        assert.equal(payload["ath"], await sha256Base64Url(accessToken));
-    }
-}
-async function sha256Base64Url(value) {
-    return (await import("node:crypto"))
-        .createHash("sha256")
-        .update(value)
-        .digest("base64url");
-}
-async function readRequestBody(request) {
-    let body = "";
-    for await (const chunk of request) {
-        body += String(chunk);
-    }
-    return body;
-}
-function originForServer(server) {
-    const address = server.address();
-    if (address === null || typeof address === "string") {
-        throw new Error("Expected an HTTP server address.");
-    }
-    return `http://127.0.0.1:${address.port}`;
-}
-function toTransport(transport) {
-    return transport;
-}

package/dist/broker/types.js

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

package/dist/cli/commands/broker-daemon.js

@@ -1,4 +0,0 @@
-import { runBrokerDaemon } from "../../broker/daemon.js";
-export async function runBrokerDaemonCommand(runtimePaths) {
-    await runBrokerDaemon(runtimePaths);
-}

package/dist/cli/commands/login.js

@@ -1,35 +0,0 @@
-import { loginBroker } from "../../auth/login.js";
-import { resolveSecretStore } from "../../broker/resolve-secret-store.js";
-import { ensureRuntimeDirectories } from "../../lib/runtime-paths.js";
-export async function runLoginCommand(runtimePaths) {
-    await ensureRuntimeDirectories(runtimePaths);
-    const resolvedSecretStore = await resolveSecretStore(runtimePaths);
-    const secretStore = resolvedSecretStore.store;
-    process.stdout.write("Opening Driggsby sign-in in your browser...\n");
-    if (resolvedSecretStore.notice !== null) {
-        process.stdout.write(`${resolvedSecretStore.notice}\n`);
-    }
-    const result = await loginBroker(runtimePaths, {
-        onBrowserPrompt: ({ browserOpened, signInUrl }) => {
-            if (!browserOpened) {
-                process.stdout.write([
-                    "Your browser did not open automatically.",
-                    "Open this URL to finish connecting Driggsby:",
-                    signInUrl,
-                    "",
-                ].join("\n"));
-            }
-        },
-        secretStore,
-    });
-    process.stdout.write([
-        "Local Driggsby broker is connected.",
-        `broker id: ${result.brokerId}`,
-        `dpop thumbprint: ${result.dpopThumbprint}`,
-        `server: ${result.session.issuer}`,
-        `resource: ${result.session.resource}`,
-        `scope: ${result.session.scope}`,
-        `access token expires: ${result.session.accessTokenExpiresAt}`,
-        "",
-    ].join("\n"));
-}

package/dist/cli/commands/logout.js

@@ -1,20 +0,0 @@
-import { getBrokerStatus, shutdownBroker } from "../../broker/client.js";
-import { clearBrokerInstallation } from "../../broker/installation.js";
-import { resolveSecretStoreForLogout } from "../../broker/resolve-secret-store.js";
-export async function runLogoutCommand(runtimePaths) {
-    const resolvedSecretStore = await resolveSecretStoreForLogout(runtimePaths);
-    const secretStore = resolvedSecretStore.store;
-    const clientOptions = {
-        runtimePaths,
-        secretStore,
-    };
-    const runningStatus = await getBrokerStatus(clientOptions);
-    if (runningStatus !== null && !(await shutdownBroker(clientOptions))) {
-        throw new Error("The local Driggsby broker did not shut down cleanly. Close active MCP sessions and try again.");
-    }
-    await clearBrokerInstallation(runtimePaths, secretStore);
-    if (resolvedSecretStore.notice !== null) {
-        process.stdout.write(`${resolvedSecretStore.notice}\n`);
-    }
-    process.stdout.write("Local Driggsby broker state cleared.\n");
-}

package/dist/cli/commands/status.js

@@ -1,13 +0,0 @@
-import { getBrokerStatus } from "../../broker/client.js";
-import { resolveBrokerStatusForDisplay } from "../../broker/installation.js";
-import { resolveSecretStore } from "../../broker/resolve-secret-store.js";
-import { formatStatusText } from "../format.js";
-export async function runStatusCommand(runtimePaths) {
-    const secretStore = (await resolveSecretStore(runtimePaths)).store;
-    const liveStatus = await getBrokerStatus({
-        runtimePaths,
-        secretStore,
-    });
-    const status = await resolveBrokerStatusForDisplay(runtimePaths, secretStore, liveStatus);
-    process.stdout.write(formatStatusText(status));
-}

package/dist/cli/format.js

@@ -1,84 +0,0 @@
-import { DRIGGSBY_LOGIN_COMMAND, DRIGGSBY_STATUS_COMMAND, } from "../lib/user-guidance.js";
-export function formatStatusText(status) {
-    const remoteAccessState = resolveRemoteAccessState(status);
-    const remoteAccessDetail = resolveRemoteAccessDetail(status, remoteAccessState);
-    const nextStepCommand = resolveNextStepCommand(status, remoteAccessState);
-    const lines = [
-        "Local Driggsby broker",
-        `remote MCP forwarding: ${status.remoteMcpReady ? "ready" : "not ready"}`,
-        `remote access state: ${formatRemoteAccessState(remoteAccessState)}`,
-        `what this means: ${remoteAccessDetail}`,
-    ];
-    if (!status.installed) {
-        lines.push("local broker setup: incomplete");
-    }
-    if (!status.brokerRunning) {
-        lines.push("local broker service: not running");
-    }
-    if (nextStepCommand) {
-        lines.push(`next step: run \`${nextStepCommand}\``);
-    }
-    if (status.remoteSession) {
-        lines.push(`saved access token expires at: ${status.remoteSession.accessTokenExpiresAt}`);
-    }
-    return `${lines.join("\n")}\n`;
-}
-function formatRemoteAccessState(remoteAccessState) {
-    switch (remoteAccessState) {
-        case "ready":
-            return "authenticated";
-        case "not_connected":
-            return "not connected";
-        case "reauth_required":
-            return "re-authentication required";
-        case "temporarily_unavailable":
-            return "temporarily unavailable";
-    }
-    return remoteAccessState;
-}
-function resolveRemoteAccessState(status) {
-    const runtimeStatus = status;
-    return runtimeStatus.remoteAccessState ?? inferLegacyRemoteAccessState(status);
-}
-function resolveRemoteAccessDetail(status, remoteAccessState) {
-    const runtimeStatus = status;
-    return runtimeStatus.remoteAccessDetail ??
-        inferLegacyRemoteAccessDetail(status, remoteAccessState);
-}
-function resolveNextStepCommand(status, remoteAccessState) {
-    const runtimeStatus = status;
-    return runtimeStatus.nextStepCommand ??
-        inferLegacyNextStepCommand(remoteAccessState);
-}
-function inferLegacyRemoteAccessState(status) {
-    if (status.remoteMcpReady) {
-        return "ready";
-    }
-    if (status.remoteSession) {
-        return "temporarily_unavailable";
-    }
-    return "not_connected";
-}
-function inferLegacyRemoteAccessDetail(status, remoteAccessState) {
-    if (remoteAccessState === "ready") {
-        return "Remote MCP forwarding is ready to use.";
-    }
-    if (remoteAccessState === "not_connected") {
-        return "Driggsby does not have a saved remote session yet.";
-    }
-    if (status.remoteSession) {
-        return "Remote MCP forwarding is not ready yet. Driggsby may still need to refresh the saved remote session before forwarding can run.";
-    }
-    return "Remote MCP forwarding is not ready to use yet.";
-}
-function inferLegacyNextStepCommand(remoteAccessState) {
-    switch (remoteAccessState) {
-        case "ready":
-            return undefined;
-        case "not_connected":
-        case "reauth_required":
-            return DRIGGSBY_LOGIN_COMMAND;
-        case "temporarily_unavailable":
-            return DRIGGSBY_STATUS_COMMAND;
-    }
-}

package/dist/index.js

@@ -1,39 +0,0 @@
-#!/usr/bin/env node
-import { fileURLToPath } from "node:url";
-import { runBrokerDaemonCommand } from "./cli/commands/broker-daemon.js";
-import { runLoginCommand } from "./cli/commands/login.js";
-import { runLogoutCommand } from "./cli/commands/logout.js";
-import { runStatusCommand } from "./cli/commands/status.js";
-import { runMcpServerCommand } from "./shim/server.js";
-import { resolveRuntimePaths } from "./lib/runtime-paths.js";
-const ENTRYPOINT_PATH = fileURLToPath(import.meta.url);
-async function main() {
-    const [, , ...args] = process.argv;
-    const command = args[0];
-    const runtimePaths = resolveRuntimePaths();
-    switch (command) {
-        case "login":
-            await runLoginCommand(runtimePaths);
-            return;
-        case "logout":
-            await runLogoutCommand(runtimePaths);
-            return;
-        case "status":
-            await runStatusCommand(runtimePaths);
-            return;
-        case "mcp-server":
-            await runMcpServerCommand(runtimePaths, ENTRYPOINT_PATH);
-            return;
-        case "broker-daemon":
-            await runBrokerDaemonCommand(runtimePaths);
-            return;
-        default:
-            process.stderr.write("Usage: driggsby <mcp-server|login|logout|status|broker-daemon>\n");
-            process.exitCode = 1;
-    }
-}
-void main().catch((error) => {
-    const message = error instanceof Error ? error.message : "Driggsby command failed.";
-    process.stderr.write(`${message}\n`);
-    process.exitCode = 1;
-});

package/dist/lib/json-file.js

@@ -1,36 +0,0 @@
-import { promises as fs } from "node:fs";
-import path from "node:path";
-export async function readJsonFile(filePath) {
-    try {
-        const contents = await fs.readFile(filePath, "utf8");
-        return JSON.parse(contents);
-    }
-    catch (error) {
-        if (isNotFoundError(error)) {
-            return null;
-        }
-        throw error;
-    }
-}
-export async function writeJsonFile(filePath, value) {
-    const tempPath = `${filePath}.${process.pid}.tmp`;
-    const contents = `${JSON.stringify(value, null, 2)}\n`;
-    await fs.mkdir(path.dirname(filePath), { recursive: true, mode: 0o700 });
-    await fs.writeFile(tempPath, contents, { encoding: "utf8", mode: 0o600 });
-    await fs.rename(tempPath, filePath);
-}
-export async function removeFileIfPresent(filePath) {
-    try {
-        await fs.rm(filePath);
-    }
-    catch (error) {
-        if (!isNotFoundError(error)) {
-            throw error;
-        }
-    }
-}
-function isNotFoundError(error) {
-    return (error instanceof Error &&
-        "code" in error &&
-        error.code === "ENOENT");
-}

package/dist/lib/retry.js

@@ -1,22 +0,0 @@
-import { setTimeout as sleep } from "node:timers/promises";
-export async function retryOperation(operation, options) {
-    let lastError;
-    const totalAttempts = options.delaysMs.length;
-    for (const [index, delayMs] of options.delaysMs.entries()) {
-        if (delayMs > 0) {
-            await sleep(delayMs);
-        }
-        try {
-            return await operation(index + 1, totalAttempts);
-        }
-        catch (error) {
-            lastError = error;
-            if (index === totalAttempts - 1 || !options.shouldRetry(error)) {
-                throw error;
-            }
-        }
-    }
-    throw lastError instanceof Error
-        ? lastError
-        : new Error("The retry operation did not complete successfully.");
-}

package/dist/lib/runtime-paths.js

@@ -1,62 +0,0 @@
-import { createHash } from "node:crypto";
-import { promises as fs } from "node:fs";
-import os from "node:os";
-import path from "node:path";
-export function resolveRuntimePaths(options = {}) {
-    const env = options.env ?? process.env;
-    const platform = options.platform ?? process.platform;
-    const homeDir = options.homeDir ?? os.homedir();
-    const username = options.username ?? os.userInfo().username;
-    const allowEnvOverrides = options.allowEnvOverrides ?? false;
-    const configDir = allowEnvOverrides && env["DRIGGSBY_CONFIG_DIR"]
-        ? env["DRIGGSBY_CONFIG_DIR"]
-        : defaultConfigDir(platform, homeDir, env);
-    const stateDir = allowEnvOverrides && env["DRIGGSBY_STATE_DIR"]
-        ? env["DRIGGSBY_STATE_DIR"]
-        : defaultStateDir(platform, homeDir, env);
-    const pathModule = platform === "win32" ? path.win32 : path;
-    return {
-        configDir,
-        stateDir,
-        metadataPath: pathModule.join(configDir, "broker-metadata.json"),
-        socketPath: defaultSocketPath(platform, stateDir, username),
-        lockPath: pathModule.join(stateDir, "broker.lock"),
-    };
-}
-export async function ensureRuntimeDirectories(runtimePaths) {
-    await fs.mkdir(runtimePaths.configDir, { recursive: true, mode: 0o700 });
-    await fs.mkdir(runtimePaths.stateDir, { recursive: true, mode: 0o700 });
-}
-function defaultConfigDir(platform, homeDir, env) {
-    const pathModule = platform === "win32" ? path.win32 : path;
-    switch (platform) {
-        case "darwin":
-            return pathModule.join(homeDir, "Library", "Application Support", "driggsby");
-        case "win32":
-            return pathModule.join(env["APPDATA"] ?? path.join(homeDir, "AppData", "Roaming"), "Driggsby");
-        default:
-            return pathModule.join(env["XDG_CONFIG_HOME"] ?? path.join(homeDir, ".config"), "driggsby");
-    }
-}
-function defaultStateDir(platform, homeDir, env) {
-    const pathModule = platform === "win32" ? path.win32 : path;
-    switch (platform) {
-        case "darwin":
-            return pathModule.join(homeDir, "Library", "Application Support", "driggsby");
-        case "win32":
-            return pathModule.join(env["LOCALAPPDATA"] ?? path.join(homeDir, "AppData", "Local"), "Driggsby");
-        default:
-            return pathModule.join(env["XDG_STATE_HOME"] ?? path.join(homeDir, ".local", "state"), "driggsby");
-    }
-}
-function defaultSocketPath(platform, stateDir, username) {
-    if (platform === "win32") {
-        const win32Path = path.win32;
-        const userHash = createHash("sha256")
-            .update(username)
-            .digest("hex")
-            .slice(0, 16);
-        return win32Path.join("\\\\.\\pipe", `driggsby-broker-${userHash}`);
-    }
-    return path.join(stateDir, "broker.sock");
-}

package/dist/lib/user-guidance.js

@@ -1,19 +0,0 @@
-export const DRIGGSBY_LOGIN_COMMAND = "npx driggsby@latest login";
-export const DRIGGSBY_STATUS_COMMAND = "npx driggsby@latest status";
-export function buildReauthenticationRequiredMessage(reason) {
-    return `${ensureTrailingPeriod(reason)} Please re-authenticate by running \`${DRIGGSBY_LOGIN_COMMAND}\`.`;
-}
-export function buildBrokerInvestigationMessage(reason) {
-    return `${ensureTrailingPeriod(reason)} Investigate broker readiness by running \`${DRIGGSBY_STATUS_COMMAND}\`. If authentication expired, re-authenticate with \`${DRIGGSBY_LOGIN_COMMAND}\`.`;
-}
-export function errorMessageIncludesReauthenticationCommand(error) {
-    return (error instanceof Error &&
-        error.message.includes(DRIGGSBY_LOGIN_COMMAND));
-}
-export function formatRetryWindow(delaysMs) {
-    const totalDelayMs = delaysMs.reduce((sum, delay) => sum + delay, 0);
-    return `${(totalDelayMs / 1_000).toFixed(1)} seconds`;
-}
-function ensureTrailingPeriod(value) {
-    return /[.!?]$/.test(value) ? value : `${value}.`;
-}