driggsby 0.1.41 → 0.2.0

package/dist/mcp-setup/commands.js

@@ -0,0 +1,53 @@
+import {} from "./known-client.js";
+export const DRIGGSBY_MCP_URL = "https://app.driggsby.com/mcp";
+export function buildInstallerCommand(client, scope) {
+    switch (client) {
+        case "claude-code":
+            return {
+                program: "claude",
+                args: [
+                    "mcp",
+                    "add",
+                    "--transport",
+                    "http",
+                    "-s",
+                    scope ?? "user",
+                    "driggsby",
+                    DRIGGSBY_MCP_URL,
+                ],
+            };
+        case "codex":
+            return {
+                program: "codex",
+                args: ["mcp", "add", "driggsby", "--url", DRIGGSBY_MCP_URL],
+            };
+    }
+}
+export function buildInspectorCommand(client) {
+    switch (client) {
+        case "claude-code":
+            return { program: "claude", args: ["mcp", "get", "driggsby"] };
+        case "codex":
+            return { program: "codex", args: ["mcp", "get", "driggsby", "--json"] };
+    }
+}
+export function buildScopedRemoverCommand(client, scope) {
+    switch (client) {
+        case "claude-code":
+            return {
+                program: "claude",
+                args: ["mcp", "remove", "driggsby", "-s", scope ?? "user"],
+            };
+        case "codex":
+            return { program: "codex", args: ["mcp", "remove", "driggsby"] };
+    }
+}
+export function renderShellCommand(command) {
+    return [command.program, ...command.args].map(shellQuote).join(" ");
+}
+function shellQuote(value) {
+    if (/^[A-Za-z0-9\-_./=]*$/.test(value)) {
+        return value;
+    }
+    return `'${value.replaceAll("'", "'\\''")}'`;
+}

package/dist/mcp-setup/known-client.js

@@ -0,0 +1,38 @@
+import { CliError } from "../cli-error.js";
+import { sanitizeForTerminal, trimLikeRust } from "../terminal-text.js";
+const SUPPORTED_CLIENTS_NOTE = "Supported clients:\n  claude-code\n  codex\n  other";
+export function displayName(client) {
+    switch (client) {
+        case "claude-code":
+            return "Claude Code";
+        case "codex":
+            return "Codex";
+        case "other":
+            return "Other MCP client";
+    }
+}
+// Rust-set trimming plus ASCII-only lowercasing, matching the Rust CLI's
+// str::trim + to_ascii_lowercase: a non-ASCII uppercase letter stays as-is
+// and fails the lookup below.
+export function canonicalizeClientId(input) {
+    return trimLikeRust(input).replace(/[A-Z]/g, (letter) => letter.toLowerCase());
+}
+export function parseClient(value) {
+    const canonical = canonicalizeClientId(value);
+    if (canonical === "") {
+        throw new CliError(`Client is required.\n\n${SUPPORTED_CLIENTS_NOTE}`, 1);
+    }
+    if (canonical === "claude-code" || canonical === "codex" || canonical === "other") {
+        return canonical;
+    }
+    throw new CliError(`Unsupported client: ${sanitizeForTerminal(canonical)}\n\n${SUPPORTED_CLIENTS_NOTE}`, 1);
+}
+export function validateMcpScope(client, scope) {
+    if (scope === undefined || client === "claude-code") {
+        return;
+    }
+    throw new CliError("-s is supported only for Claude Code.", 1);
+}
+export function cliMcpClient(client) {
+    return client === "other" ? null : client;
+}

package/dist/mcp-setup/setup.js

@@ -0,0 +1,137 @@
+import { createInterface } from "node:readline/promises";
+import { CliError } from "../cli-error.js";
+import { trimLikeRust } from "../terminal-text.js";
+import { runClientCommand } from "./client-command.js";
+import { classifyExistingMcpConfig } from "./classify.js";
+import { buildInspectorCommand, buildInstallerCommand, buildScopedRemoverCommand, } from "./commands.js";
+import { cliMcpClient, displayName, parseClient, validateMcpScope, } from "./known-client.js";
+import { alreadySetupBlock, autoSetupFailureBlock, existingConfigDiffersBlock, manualCommandBlock, otherClientInstructionsBlock, successBlock, } from "./text.js";
+export async function runMcpSetup(options) {
+    const client = await resolveClient(options.client);
+    validateMcpScope(client, options.scope);
+    const installClient = cliMcpClient(client);
+    if (installClient === null) {
+        write(otherClientInstructionsBlock());
+        return;
+    }
+    const installer = buildInstallerCommand(installClient, options.scope);
+    if (options.print) {
+        write(manualCommandBlock(client, installer));
+        return;
+    }
+    write(`Checking for Driggsby in ${displayName(client)} MCP config...\n`);
+    if (await handleExistingConfig(client, installClient, options.scope, installer)) {
+        return;
+    }
+    write(`Adding Driggsby to ${displayName(client)} MCP config...\n`);
+    const result = await runClientCommand(installer, streamConfigOutput(client));
+    switch (result.kind) {
+        case "output":
+            if (result.output.succeeded) {
+                write(successBlock(client, codexCompletedLogin(result.output)));
+            }
+            else if (commandReportsExistingConfig(result.output)) {
+                const remover = buildScopedRemoverCommand(installClient, options.scope);
+                write(existingConfigDiffersBlock(client, remover, installer));
+            }
+            else {
+                write(autoSetupFailureBlock(client, "The client command returned an error.", installer));
+            }
+            return;
+        case "not-found":
+            write(autoSetupFailureBlock(client, `${displayName(client)} is not installed or not on PATH.`, installer));
+            return;
+        case "spawn-error":
+            write(autoSetupFailureBlock(client, "Could not start the client command.", installer));
+            return;
+        case "timed-out":
+            write(autoSetupFailureBlock(client, "The client command timed out.", installer));
+            return;
+    }
+}
+async function resolveClient(requested) {
+    if (requested !== undefined) {
+        return parseClient(requested);
+    }
+    return promptForClient();
+}
+function defaultPromptStreams() {
+    return {
+        input: process.stdin,
+        output: process.stdout,
+        isInteractive: process.stdin.isTTY,
+    };
+}
+export async function promptForClient(streams = defaultPromptStreams()) {
+    if (!streams.isInteractive) {
+        throw new CliError("Pass a client name.\n\nExamples:\n  npx driggsby@latest mcp setup claude-code\n  npx driggsby@latest mcp setup codex\n  npx driggsby@latest mcp setup other", 1);
+    }
+    streams.output.write("Which client are you setting up?\n\n  1. Claude Code\n  2. Codex\n  3. Other\n\n");
+    // terminal: false keeps the prompt a plain write (no cursor-control
+    // escapes); the TTY's own canonical mode handles echo, as in the original.
+    const readline = createInterface({
+        input: streams.input,
+        output: streams.output,
+        terminal: false,
+    });
+    // EOF (Ctrl+D) never settles readline's question(); it only closes the
+    // interface. Race the two so EOF becomes "no valid choice", exactly what
+    // the original did with a zero-byte read.
+    const closedAsEmptyChoice = new Promise((resolve) => {
+        readline.once("close", () => {
+            resolve("");
+        });
+    });
+    let choice;
+    try {
+        choice = trimLikeRust(await Promise.race([readline.question("Choose 1-3: "), closedAsEmptyChoice]));
+    }
+    finally {
+        readline.close();
+    }
+    switch (choice) {
+        case "1":
+            return "claude-code";
+        case "2":
+            return "codex";
+        case "3":
+            return "other";
+        default:
+            throw new CliError("Choose 1, 2, or 3.", 1);
+    }
+}
+// Returns true when an existing config entry fully handled the run (already
+// set up, or differs with remediation printed). Probe failures fall through
+// to a normal install attempt.
+async function handleExistingConfig(client, installClient, scope, installer) {
+    const result = await runClientCommand(buildInspectorCommand(installClient), false);
+    if (result.kind !== "output") {
+        return false;
+    }
+    switch (classifyExistingMcpConfig(installClient, scope, result.output)) {
+        case "matches":
+            write(alreadySetupBlock(client));
+            return true;
+        case "differs":
+            write(existingConfigDiffersBlock(client, buildScopedRemoverCommand(installClient, scope), installer));
+            return true;
+        case "missing":
+        case "unknown":
+            return false;
+    }
+}
+// Only Codex streams: its MCP add performs an interactive OAuth login
+// in-band, and swallowing that output makes setup look hung.
+function streamConfigOutput(client) {
+    return client === "codex";
+}
+function commandReportsExistingConfig(output) {
+    return output.stdout.includes("already exists") || output.stderr.includes("already exists");
+}
+function codexCompletedLogin(output) {
+    return (output.stdout.includes("Successfully logged in.") ||
+        output.stderr.includes("Successfully logged in."));
+}
+function write(text) {
+    process.stdout.write(text);
+}

package/dist/mcp-setup/spawn-plan.js

@@ -0,0 +1,91 @@
+// Turns an McpConfigCommand into something Node's spawn can run on every
+// platform WITHOUT a shell. On POSIX the command runs as-is. On Windows,
+// client CLIs are usually npm-installed .cmd shims, which Node (rightly)
+// refuses to spawn directly — so we resolve the program ourselves against
+// PATH + PATHEXT (never the current directory, which Windows shells would
+// search first) and run shims through an explicit, absolute cmd.exe
+// invocation with our own quoting. Real commands only ever carry fixed
+// constant arguments (see commands.ts); nothing user-controlled may ever
+// flow into a spawn plan.
+import { existsSync } from "node:fs";
+import { isAbsolute, join } from "node:path";
+import {} from "./commands.js";
+// null means the program does not exist on PATH (Windows only — POSIX lets
+// spawn report ENOENT itself). platform and lookup are injectable so the
+// Windows branch — including the absolute cmd.exe composition — stays
+// unit-testable on every CI runner.
+export function planSpawn(command, platform = process.platform, lookup) {
+    if (platform !== "win32") {
+        return { program: command.program, args: command.args, windowsVerbatimArguments: false };
+    }
+    const resolved = resolveWindowsProgram(command.program, lookup ?? defaultLookup());
+    if (resolved === null) {
+        return null;
+    }
+    if (resolved.kind === "direct") {
+        return { program: resolved.path, args: command.args, windowsVerbatimArguments: false };
+    }
+    const commandLine = [resolved.path, ...command.args].map(quoteForCmd).join(" ");
+    return {
+        // Absolute path: a bare "cmd.exe" would let Windows' legacy CreateProcess
+        // lookup find a planted cmd.exe in the current directory first.
+        program: join(process.env.SystemRoot ?? "C:\\Windows", "System32", "cmd.exe"),
+        args: ["/d", "/s", "/c", `"${commandLine}"`],
+        windowsVerbatimArguments: true,
+    };
+}
+function defaultLookup() {
+    return {
+        path: process.env.PATH ?? "",
+        pathext: process.env.PATHEXT ?? ".COM;.EXE;.BAT;.CMD",
+        exists: existsSync,
+    };
+}
+function kindForPath(candidate) {
+    return /\.(cmd|bat)$/i.test(candidate) ? "shim" : "direct";
+}
+export function resolveWindowsProgram(program, lookup = defaultLookup()) {
+    // An explicit path (absolute, or containing a separator) is used as given.
+    if (isAbsolute(program) || program.includes("\\") || program.includes("/")) {
+        return lookup.exists(program) ? { kind: kindForPath(program), path: program } : null;
+    }
+    // Windows PATH semantics regardless of the host running the tests: split
+    // on ";" (a POSIX-style ":" would cut drive letters like C: in half).
+    const pathDirectories = lookup.path
+        .split(";")
+        // Real Windows PATHs sometimes carry quoted segments; strip the quotes so
+        // the directory still resolves.
+        .map((directory) => directory.replaceAll('"', ""))
+        .filter((directory) => directory !== "");
+    const extensions = lookup.pathext.split(";").filter((extension) => extension !== "");
+    const hasExtension = /\.[^\\/.]+$/.test(program);
+    for (const directory of pathDirectories) {
+        if (hasExtension) {
+            const exact = join(directory, program);
+            if (lookup.exists(exact)) {
+                return { kind: kindForPath(exact), path: exact };
+            }
+        }
+        for (const extension of extensions) {
+            const candidate = join(directory, program + extension);
+            if (lookup.exists(candidate)) {
+                return { kind: kindForPath(candidate), path: candidate };
+            }
+        }
+    }
+    return null;
+}
+// Quoting for the cmd.exe /s /c command line: plain tokens pass through,
+// anything else is wrapped in double quotes with embedded quotes doubled
+// (the cmd convention) and trailing backslashes doubled (so a path ending
+// in \ cannot escape the closing quote for the child's own parser). The
+// safe set covers every constant argument the CLI actually runs, including
+// the MCP URL; only fixed constants and PATH-resolved program paths may
+// reach this function.
+export function quoteForCmd(value) {
+    if (/^[A-Za-z0-9_\-.:\\/=]+$/.test(value)) {
+        return value;
+    }
+    const escaped = value.replaceAll('"', '""').replace(/(\\+)$/, "$1$1");
+    return `"${escaped}"`;
+}

package/dist/mcp-setup/text.js

@@ -0,0 +1,83 @@
+// Every user-facing mcp-setup text block, byte-compatible with the original
+// Rust CLI output (pinned by the fixture parity tests). Terminal command
+// suggestions are raw and copy-pasteable — never wrapped in backticks.
+import { DRIGGSBY_MCP_URL, renderShellCommand } from "./commands.js";
+import { displayName } from "./known-client.js";
+export function nextStepLines(client, completedLogin) {
+    switch (client) {
+        case "claude-code":
+            return ["  Open Claude Code, run /mcp, and authenticate Driggsby to get started."];
+        case "codex":
+            if (completedLogin) {
+                return ["  Open Codex and ask it to use Driggsby."];
+            }
+            return [
+                "  Complete the Driggsby sign-in in the browser window opened by Codex.",
+                "  If no browser window opened, run:",
+                "    codex mcp login driggsby",
+            ];
+        case "other":
+            return otherClientInstructionLines();
+    }
+}
+function alreadySetupNextStepLines(client) {
+    switch (client) {
+        case "claude-code":
+            return ["  Open Claude Code, run /mcp, and authenticate Driggsby if prompted."];
+        case "codex":
+            return [
+                "  Open Codex and ask it to use Driggsby.",
+                "  If Codex asks you to sign in, run:",
+                "    codex mcp login driggsby",
+            ];
+        case "other":
+            return [];
+    }
+}
+function otherClientInstructionLines() {
+    return [
+        "  Add a remote MCP server named driggsby.",
+        "  Set its URL to https://app.driggsby.com/mcp.",
+        "  Choose OAuth authentication if the client asks.",
+        "  Complete the Driggsby browser sign-in when prompted.",
+        "",
+        "Requirement:",
+        "  The MCP client must support OAuth-based MCP authentication.",
+    ];
+}
+export function successBlock(client, completedLogin) {
+    return (`${displayName(client)} is set up.\n\nDriggsby MCP URL:\n  ${DRIGGSBY_MCP_URL}\n\nNext:\n` +
+        joinLines(nextStepLines(client, completedLogin)));
+}
+export function alreadySetupBlock(client) {
+    return (`Driggsby is already set up in ${displayName(client)} MCP config.\n\n` +
+        `Driggsby MCP URL:\n  ${DRIGGSBY_MCP_URL}\n\nNext:\n` +
+        joinLines(alreadySetupNextStepLines(client)));
+}
+export function existingConfigDiffersBlock(client, remover, installer) {
+    return (`Driggsby already exists in ${displayName(client)} MCP config, ` +
+        `but it does not match the expected Driggsby setup.\n\n` +
+        `Expected Driggsby MCP URL:\n  ${DRIGGSBY_MCP_URL}\n\n` +
+        `To replace the existing entry, run:\n` +
+        `  ${renderShellCommand(remover)}\n` +
+        `  ${renderShellCommand(installer)}\n`);
+}
+export function manualCommandBlock(client, installer) {
+    return (`Run this command to add Driggsby to ${displayName(client)}:\n\n` +
+        `  ${renderShellCommand(installer)}\n\n` +
+        `After adding it:\n` +
+        joinLines(nextStepLines(client, false)));
+}
+export function autoSetupFailureBlock(client, reason, installer) {
+    return (`Could not add Driggsby to ${displayName(client)}: ${reason}\n\n` +
+        manualCommandBlock(client, installer));
+}
+export function otherClientInstructionsBlock() {
+    return (`Driggsby currently supports OAuth-based remote MCP only.\n\n` +
+        `Driggsby OAuth MCP URL:\n  ${DRIGGSBY_MCP_URL}\n\n` +
+        `For another MCP client or agent:\n` +
+        joinLines(otherClientInstructionLines()));
+}
+function joinLines(lines) {
+    return lines.map((line) => `${line}\n`).join("");
+}

package/dist/terminal-text.js

@@ -0,0 +1,19 @@
+// Terminal-output text helpers. The sanitizer and prose wrapper live in
+// @driggsby/deploy (the zero-dependency package this CLI already depends
+// on) and are re-exported here so every caller keeps one import path. See
+// the sanitizer's comment there for what it strips and for the deliberate
+// boundary of that defense: it stops terminal corruption and hidden text,
+// and callers print untrusted values quoted and length-capped so they read
+// as names, not as the CLI's own voice.
+export { capForTerminal, quotedForTerminal, sanitizeForTerminal, wrapProse } from "@driggsby/deploy";
+// Rust's str::trim() trims the Unicode White_Space set, which differs from
+// JavaScript's String.prototype.trim at exactly two code points: Rust trims
+// U+0085 (NEL) and does NOT trim U+FEFF (ZWNBSP/BOM); JS does the opposite.
+// Client-id parsing must match the retired Rust binary byte-for-byte, so
+// trim against Rust's set explicitly.
+const RUST_WHITESPACE_CLASS = "[\\t\\n\\v\\f\\r \\u0085\\u00A0\\u1680\\u2000-\\u200A\\u2028\\u2029\\u202F\\u205F\\u3000]";
+const LEADING_RUST_WHITESPACE = new RegExp(`^${RUST_WHITESPACE_CLASS}+`);
+const TRAILING_RUST_WHITESPACE = new RegExp(`${RUST_WHITESPACE_CLASS}+$`);
+export function trimLikeRust(value) {
+    return value.replace(LEADING_RUST_WHITESPACE, "").replace(TRAILING_RUST_WHITESPACE, "");
+}

package/dist/version.js

@@ -0,0 +1,6 @@
+import { readFileSync } from "node:fs";
+// Read the version from this package's own manifest so it can never drift
+// from what npm published. Resolved relative to this module, which sits one
+// directory below the package root both in src/ (tests) and dist/ (shipped).
+const manifest = JSON.parse(readFileSync(new URL("../package.json", import.meta.url), "utf8"));
+export const VERSION = manifest.version;

package/package.json

@@ -1,53 +1,34 @@
 {
   "name": "driggsby",
-  "version": "0.1.41",
-  "description": "CLI helper for configuring Driggsby MCP clients",
+  "version": "0.2.0",
+  "description": "Set up and build on Driggsby, the MCP server for personal finance.",
   "license": "Apache-2.0",
-  "repository": "https://github.com/driggsby/driggsby",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/driggsby/driggsby.git"
+  },
+  "homepage": "https://driggsby.com",
   "type": "module",
   "bin": {
-    "driggsby": "bin/driggsby"
-  },
-  "scripts": {
-    "postinstall": "node ./install.js"
-  },
-  "engines": {
-    "node": ">=18",
-    "npm": ">=9"
+    "driggsby": "bin/driggsby.js"
   },
   "files": [
     "bin",
+    "dist",
     "LICENSE",
-    "README.md",
-    "install.js",
-    "lib",
-    "package.json"
+    "README.md"
   ],
-  "driggsbyArtifacts": {
-    "baseUrl": "https://github.com/driggsby/driggsby/releases/download/driggsby-v0.1.41",
-    "checksums": {
-      "driggsby-aarch64-apple-darwin.tar.xz": "cbe9cb4fc851f2137499cf7cce04c200e1c2b45df34aa0a5020454aa5563727c",
-      "driggsby-x86_64-apple-darwin.tar.xz": "bfbca81c351a2bb9b7fd9e998d432ff5ff13542e602b7ed9b983f1a90f637bb4",
-      "driggsby-aarch64-unknown-linux-gnu.tar.xz": "988f046c0918f85297ea41dbc217a36e9c9626ea48d9a1020295b944a9c349a1",
-      "driggsby-x86_64-unknown-linux-gnu.tar.xz": "3f8fa93dc16ac0a7d8e8795b06dd8a3e9ef22713bdbba59699b948194b4822e9"
-    },
-    "supportedPlatforms": {
-      "aarch64-apple-darwin": {
-        "artifactName": "driggsby-aarch64-apple-darwin.tar.xz",
-        "binaryPath": "driggsby"
-      },
-      "x86_64-apple-darwin": {
-        "artifactName": "driggsby-x86_64-apple-darwin.tar.xz",
-        "binaryPath": "driggsby"
-      },
-      "aarch64-unknown-linux-gnu": {
-        "artifactName": "driggsby-aarch64-unknown-linux-gnu.tar.xz",
-        "binaryPath": "driggsby"
-      },
-      "x86_64-unknown-linux-gnu": {
-        "artifactName": "driggsby-x86_64-unknown-linux-gnu.tar.xz",
-        "binaryPath": "driggsby"
-      }
-    }
+  "scripts": {
+    "build": "npm run build --prefix ../sdk && tsc -p ../deploy/tsconfig.build.json && tsc -p tsconfig.build.json",
+    "typecheck": "tsc -p tsconfig.json --noEmit",
+    "pretest": "npm run build",
+    "test": "node --test \"src/**/*.test.ts\""
+  },
+  "engines": {
+    "node": ">=18"
+  },
+  "dependencies": {
+    "@driggsby/deploy": "0.2.0",
+    "@driggsby/sdk": "0.2.0"
   }
 }

package/bin/driggsby

@@ -1,10 +0,0 @@
-#!/usr/bin/env node
-import { readPackageJson, resolvePlatform, unsupportedPlatformMessage, } from "../lib/artifacts.js";
-const packageJson = readPackageJson();
-const resolution = resolvePlatform(packageJson);
-if (!resolution.platform) {
-    console.error(unsupportedPlatformMessage(resolution));
-    process.exit(1);
-}
-console.error("Driggsby native binary is not active. Reinstall with npm scripts enabled, or rerun with npm_config_foreground_scripts=true to see installer output.");
-process.exit(1);