driggsby 0.0.1 → 0.1.2

package/dist/cli/format.js

@@ -0,0 +1,23 @@
+export function formatStatusText(status) {
+    const lines = [
+        "Local Driggsby broker",
+        `installed: ${status.installed ? "yes" : "no"}`,
+        `running: ${status.brokerRunning ? "yes" : "no"}`,
+        `connected: ${status.remoteSession ? "yes" : "no"}`,
+        `remote mcp ready: ${status.remoteMcpReady ? "yes" : "no"}`,
+        `socket: ${status.socketPath}`,
+    ];
+    if (status.brokerId) {
+        lines.push(`broker id: ${status.brokerId}`);
+    }
+    if (status.dpopThumbprint) {
+        lines.push(`dpop thumbprint: ${status.dpopThumbprint}`);
+    }
+    if (status.remoteSession) {
+        lines.push(`server: ${status.remoteSession.issuer}`);
+        lines.push(`resource: ${status.remoteSession.resource}`);
+        lines.push(`scope: ${status.remoteSession.scope}`);
+        lines.push(`access token expires: ${status.remoteSession.accessTokenExpiresAt}`);
+    }
+    return `${lines.join("\n")}\n`;
+}

package/dist/index.js

@@ -0,0 +1,39 @@
+#!/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

@@ -0,0 +1,36 @@
+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/runtime-paths.js

@@ -0,0 +1,62 @@
+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/shim/server.js

@@ -0,0 +1,103 @@
+/* eslint-disable @typescript-eslint/no-deprecated */
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { Server } from "@modelcontextprotocol/sdk/server/index.js";
+import { CallToolRequestSchema, ListToolsRequestSchema, } from "@modelcontextprotocol/sdk/types.js";
+import { ensureBrokerRunning } from "../broker/launch.js";
+import { callBrokerTool, getBrokerStatus, listBrokerTools, } from "../broker/client.js";
+import { buildBrokerStatus } from "../broker/installation.js";
+import { KeyringSecretStore } from "../broker/secret-store.js";
+import { formatStatusText } from "../cli/format.js";
+const LOCAL_STATUS_TOOL = {
+    description: "Report readiness and connectivity for the shared local Driggsby broker.",
+    inputSchema: {
+        additionalProperties: false,
+        properties: {},
+        type: "object",
+    },
+    name: "get_local_broker_status",
+};
+export async function runMcpServerCommand(runtimePaths, entrypointPath) {
+    const secretStore = new KeyringSecretStore();
+    await ensureBrokerRunning({
+        entrypointPath,
+        runtimePaths,
+        secretStore,
+    });
+    const server = createLocalShimServer(runtimePaths, secretStore);
+    await server.connect(new StdioServerTransport());
+}
+export function createLocalShimServer(runtimePaths, secretStore) {
+    const server = new Server({
+        name: "driggsby-local-broker",
+        version: "0.1.0",
+    }, {
+        capabilities: {
+            tools: {},
+        },
+    });
+    server.setRequestHandler(ListToolsRequestSchema, async () => {
+        const remoteTools = await loadRemoteTools(runtimePaths, secretStore);
+        return {
+            tools: [LOCAL_STATUS_TOOL, ...remoteTools],
+        };
+    });
+    server.setRequestHandler(CallToolRequestSchema, async (request) => {
+        if (request.params.name === LOCAL_STATUS_TOOL.name) {
+            return await buildLocalStatusToolResult(runtimePaths, secretStore);
+        }
+        const remoteTools = await listBrokerTools({
+            runtimePaths,
+            secretStore,
+        });
+        if (remoteTools === null) {
+            throw new Error("The local Driggsby broker could not load the remote Driggsby tools right now. Use `get_local_broker_status` for details, then try again.");
+        }
+        if (!remoteTools.some((tool) => tool.name === request.params.name)) {
+            throw new Error("That Driggsby tool is not available in this session anymore. Ask the client to refresh its tool list and try again.");
+        }
+        const toolResult = await callBrokerTool({
+            runtimePaths,
+            secretStore,
+        }, request.params.name, asToolArguments(request.params.arguments));
+        if (toolResult === null) {
+            throw new Error("The local Driggsby broker could not reach Driggsby right now. Use `get_local_broker_status` for details, then try again.");
+        }
+        return toolResult;
+    });
+    return server;
+}
+async function buildLocalStatusToolResult(runtimePaths, secretStore) {
+    const status = (await getBrokerStatus({ runtimePaths, secretStore })) ??
+        (await buildBrokerStatus(runtimePaths, secretStore, false));
+    return {
+        content: [
+            {
+                text: formatStatusText(status).trimEnd(),
+                type: "text",
+            },
+        ],
+    };
+}
+function asToolArguments(argumentsValue) {
+    if (argumentsValue === undefined) {
+        return undefined;
+    }
+    if (typeof argumentsValue !== "object" ||
+        argumentsValue === null ||
+        Array.isArray(argumentsValue)) {
+        throw new Error("Driggsby received invalid tool arguments.");
+    }
+    return argumentsValue;
+}
+async function loadRemoteTools(runtimePaths, secretStore) {
+    try {
+        const remoteTools = await listBrokerTools({
+            runtimePaths,
+            secretStore,
+        });
+        return remoteTools ?? [];
+    }
+    catch {
+        return [];
+    }
+}

package/package.json

@@ -1,6 +1,60 @@
 {
   "name": "driggsby",
-  "version": "0.0.1",
-  "description": "FinAgent",
-  "license": "MIT"
+  "version": "0.1.2",
+  "description": "Local Driggsby MCP broker and CLI",
+  "license": "UNLICENSED",
+  "type": "module",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/thegoodsoftwareco/driggsby.git",
+    "directory": "packages/driggsby"
+  },
+  "homepage": "https://github.com/thegoodsoftwareco/driggsby/tree/main/packages/driggsby#readme",
+  "bugs": {
+    "url": "https://github.com/thegoodsoftwareco/driggsby/issues"
+  },
+  "keywords": [
+    "driggsby",
+    "mcp",
+    "broker",
+    "cli",
+    "finance"
+  ],
+  "bin": {
+    "driggsby": "./dist/index.js"
+  },
+  "files": [
+    "dist",
+    "README.md",
+    "LICENSE"
+  ],
+  "engines": {
+    "node": ">=20"
+  },
+  "scripts": {
+    "build": "node --eval \"require('node:fs').rmSync('dist', { recursive: true, force: true });\" && tsc -p tsconfig.build.json",
+    "lint": "eslint src --max-warnings 0",
+    "pack:release": "npm pack --json --ignore-scripts",
+    "secrets:check": "node ./scripts/check-publish-surface.mjs",
+    "typecheck": "tsc -p tsconfig.json --noEmit",
+    "test": "tsx --test src/**/*.test.ts",
+    "start": "tsx src/index.ts",
+    "verify:release": "npm run lint && npm run typecheck && npm test && npm run build"
+  },
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.29.0",
+    "@napi-rs/keyring": "^1.2.0",
+    "jose": "^6.2.2",
+    "zod": "^4.3.6"
+  },
+  "devDependencies": {
+    "@secretlint/secretlint-rule-preset-recommend": "^11.4.1",
+    "@eslint/js": "^9.39.4",
+    "@types/node": "^24.6.1",
+    "eslint": "^9.39.4",
+    "secretlint": "^11.4.1",
+    "tsx": "^4.21.0",
+    "typescript": "^6.0.2",
+    "typescript-eslint": "^8.58.0"
+  }
 }

package/pyproject.toml

@@ -1,11 +0,0 @@
-[project]
-name = "driggsby"
-version = "0.0.1"
-description = "FinAgent"
-requires-python = ">=3.11"
-license = "MIT"
-authors = [{ name = "Driggsby" }]
-
-[build-system]
-requires = ["hatchling"]
-build-backend = "hatchling.build"

package/src/driggsby/__init__.py

@@ -1,3 +0,0 @@
-"""Driggsby - Your personal financial agent."""
-
-__version__ = "0.0.1"