driggsby 0.5.2 → 0.6.0

package/README.md

@@ -22,6 +22,12 @@ npx driggsby@latest mcp setup other
 After setup, authenticate Driggsby through your client — run `/mcp` in
 Claude Code, or sign in through the browser window Codex opens.
 
+So your Driggsby MCP page can tell your connections apart, `login` sends
+Driggsby this computer's name and operating system version (for example
+`mbp-studio` and `macOS 15.6`) with its sign-in, and
+`mcp setup claude-code` saves them as headers on the Driggsby entry it
+adds to Claude Code, which sends them with each request.
+
 For another MCP client, choose Other. Driggsby currently supports only
 OAuth-based remote MCP at:
 

package/dist/device.js

@@ -0,0 +1,127 @@
+import { readFileSync, statSync } from "node:fs";
+import { isIP } from "node:net";
+import { hostname, platform, release, version } from "node:os";
+// Load-bearing: these allowlists are what make the values safe as command
+// arguments (spawn-plan.ts quotes them for cmd.exe) and as "Name: value"
+// headers. They must never admit % ! ^ & | < > " \ : or a control
+// character; device.test.ts checks each.
+const NAME_PATTERN = /^[A-Za-z0-9][A-Za-z0-9_-]{0,62}$/;
+const SYSTEM_PATTERN = /^[A-Za-z0-9][A-Za-z0-9 ._/-]{0,63}$/;
+const MAC_VERSION_FILE = "/System/Library/CoreServices/SystemVersion.plist";
+// os-release(5): /etc first, then the vendor copy.
+const LINUX_RELEASE_FILES = ["/etc/os-release", "/usr/lib/os-release"];
+// Both files are a few hundred bytes; anything larger isn't one.
+const MAX_FILE_BYTES = 64 * 1024;
+// A PRETTY_NAME is a short line; a longer one is not parsed at all.
+const MAX_PRETTY_NAME_CHARS = 256;
+// Hostname labels that spell out an address ("ip-172-31-22-33",
+// "c-73-162-12-34", "192-168-1-20") or are only digits name no computer.
+const ADDRESS_LABEL = /^((ip|c)-)?\d{1,3}(-\d{1,3}){3}$|^\d+$/i;
+// Windows 11 reports itself as NT 10.0; its builds start at 22000.
+const WINDOWS_11_FIRST_BUILD = 22000;
+export function describeDevice(facts) {
+    try {
+        const known = facts ?? realOsFacts();
+        return { name: deviceName(known.hostname), system: deviceSystem(known) };
+    }
+    catch {
+        // os.hostname() and os.release() can throw in unusual runtimes.
+        return { name: null, system: null };
+    }
+}
+// The known values alone, as the sign-in request carries them; null when
+// nothing is known.
+export function knownDevice(device) {
+    const known = {
+        ...(device.name === null ? {} : { name: device.name }),
+        ...(device.system === null ? {} : { system: device.system }),
+    };
+    return Object.keys(known).length === 0 ? null : known;
+}
+// The Driggsby headers `mcp setup` gives Claude Code, one per known value.
+export function deviceHeaders(device) {
+    const headers = [];
+    if (device.name !== null) {
+        headers.push(`X-Driggsby-Device-Name: ${device.name}`);
+    }
+    if (device.system !== null) {
+        headers.push(`X-Driggsby-Device-System: ${device.system}`);
+    }
+    return headers;
+}
+// "mbp-studio.local" and "devbox-02.corp.example.test" are mbp-studio and
+// devbox-02: the first label is the name people give their computer. An
+// address or localhost names no computer.
+function deviceName(raw) {
+    const trimmed = raw.trim();
+    if (isIP(trimmed) !== 0) {
+        return null;
+    }
+    const first = trimmed.split(".")[0] ?? "";
+    if (first.toLowerCase() === "localhost" || ADDRESS_LABEL.test(first)) {
+        return null;
+    }
+    return NAME_PATTERN.test(first) ? first : null;
+}
+function deviceSystem(facts) {
+    switch (facts.platform) {
+        case "darwin":
+            return allowed(macVersion(facts)) ?? "macOS";
+        case "linux":
+            return allowed(linuxPrettyName(facts)) ?? "Linux";
+        case "win32":
+            return facts.version.includes("Server") ? "Windows Server" : windowsName(facts.release);
+        default:
+            return null;
+    }
+}
+function macVersion(facts) {
+    const plist = facts.readFile(MAC_VERSION_FILE);
+    const version = plist?.match(/<key>ProductVersion<\/key>\s*<string>([0-9.]+)<\/string>/)?.[1];
+    return version === undefined ? null : `macOS ${version}`;
+}
+// PRETTY_NAME="Debian GNU/Linux 12 (bookworm)" is Debian GNU/Linux 12.
+function linuxPrettyName(facts) {
+    for (const path of LINUX_RELEASE_FILES) {
+        const osRelease = facts.readFile(path);
+        if (osRelease === null) {
+            continue;
+        }
+        const line = osRelease.split(/\r?\n/).find((each) => each.startsWith("PRETTY_NAME="));
+        if (line === undefined || line.length > MAX_PRETTY_NAME_CHARS) {
+            return null;
+        }
+        const value = line.slice("PRETTY_NAME=".length).trim().replace(/^["']|["']$/g, "");
+        return value.replace(/\s*\([^)]*\)\s*$/, "").trim();
+    }
+    return null;
+}
+// Windows 10 and 11 both report NT 10.0; anything else is just Windows.
+function windowsName(nodeRelease) {
+    const [major, , buildText] = nodeRelease.split(".");
+    const build = Number(buildText);
+    if (major !== "10" || !Number.isInteger(build)) {
+        return "Windows";
+    }
+    return build >= WINDOWS_11_FIRST_BUILD ? "Windows 11" : "Windows 10";
+}
+function allowed(value) {
+    return value !== null && SYSTEM_PATTERN.test(value) ? value : null;
+}
+function realOsFacts() {
+    return { hostname: hostname(), platform: platform(), release: release(), version: version(), readFile: readTextFile };
+}
+// A regular file of a sane size only: never a FIFO or device node that
+// would block, never something huge.
+function readTextFile(path) {
+    try {
+        const stat = statSync(path);
+        if (!stat.isFile() || stat.size > MAX_FILE_BYTES) {
+            return null;
+        }
+        return readFileSync(path, "utf8");
+    }
+    catch {
+        return null;
+    }
+}

package/dist/login/claim-client.js

@@ -4,6 +4,7 @@
 // token is returned by exactly one poll; callers must never poll again after
 // an approval.
 import { CliError } from "../cli-error.js";
+import { knownDevice } from "../device.js";
 import { sanitizeForTerminal } from "../terminal-text.js";
 // The CLI's own sign-in: read, deploy, and the transaction-rule tools.
 const CLAIM_SCOPE = "driggsby.cli";
@@ -23,11 +24,13 @@ export const SIGN_IN_START_FAILURE = "We weren't able to start a Driggsby sign-i
 // Poll failures happen after the user may already have approved, so "start a
 // sign-in" would be the wrong stage to describe.
 const SIGN_IN_FINISH_FAILURE = "We weren't able to finish your Driggsby sign-in just now. Please try again\nin a minute.";
-export async function createClaimRequest(baseUrl) {
+// device: this computer's name and system (device.ts), so the sign-in shows
+// up on Driggsby's MCP page as the computer it is; only known values go.
+export async function createClaimRequest(baseUrl, device = { name: null, system: null }) {
     const response = await fetch(`${baseUrl}/app-tokens/claim-requests`, {
         method: "POST",
         headers: { "Content-Type": "application/json" },
-        body: JSON.stringify({ app_name: CLAIM_APP_NAME, scope: CLAIM_SCOPE }),
+        body: JSON.stringify({ app_name: CLAIM_APP_NAME, scope: CLAIM_SCOPE, ...deviceField(device) }),
         signal: AbortSignal.timeout(REQUEST_TIMEOUT_MS),
         // Never follow a redirect: a 307/308 would replay this claim flow —
         // and, on the poll below, the poll secret — to whatever origin a
@@ -141,6 +144,11 @@ function stringField(record, field) {
     const value = record?.[field];
     return typeof value === "string" && value !== "" ? value : null;
 }
+// The claim body's device field: only the values this computer knows.
+function deviceField(device) {
+    const known = knownDevice(device);
+    return known === null ? {} : { device: known };
+}
 // The server's user-facing error text, stripped of terminal control bytes
 // like every other string this CLI did not author, and length-bounded.
 function errorDescription(body) {

package/dist/login/login.js

@@ -2,9 +2,10 @@
 // page, poll until they approve, and store the token. The token is shown to
 // no one — it goes straight from the poll response into the credential
 // store.
-import { apiBaseUrl, apiHost } from "../api/base-url.js";
+import { apiBaseUrl, apiHost, baseUrlMayReceiveSavedSignIn } from "../api/base-url.js";
 import { blockedNetworkError } from "../api/network-error.js";
 import { CliError } from "../cli-error.js";
+import { describeDevice } from "../device.js";
 import { defaultCredentialEnvironment, describeStorageLocation, environmentToken, saveToken, } from "../credentials/store.js";
 import { sanitizeForTerminal, wrapProse } from "../terminal-text.js";
 import { createClaimRequest, pollClaimRequest, SIGN_IN_START_FAILURE, } from "./claim-client.js";
@@ -69,7 +70,10 @@ async function storeApprovedToken(appToken, environment, warn) {
 }
 async function createClaim(baseUrl) {
     try {
-        return await createClaimRequest(baseUrl);
+        // This computer's name goes only to Driggsby (or a local run), never
+        // to another host a base-URL override names.
+        const device = baseUrlMayReceiveSavedSignIn(baseUrl) ? describeDevice() : { name: null, system: null };
+        return await createClaimRequest(baseUrl, device);
     }
     catch (error) {
         const blocked = blockedNetworkError(error, {

package/dist/mcp-setup/commands.js

@@ -1,6 +1,11 @@
 import {} from "./known-client.js";
 export const DRIGGSBY_MCP_URL = "https://app.driggsby.com/mcp";
-export function buildInstallerCommand(client, scope) {
+// headers: this computer's name and system for Driggsby's MCP page
+// (device.ts builds them from allowlisted values only). Claude Code takes
+// them after the URL (--header is variadic, so before the name it would
+// swallow it); Codex has no header option, so it never gets any. The
+// commands printed for a person to run carry none.
+export function buildInstallerCommand(client, scope, headers = []) {
     switch (client) {
         case "claude-code":
             return {
@@ -14,6 +19,7 @@ export function buildInstallerCommand(client, scope) {
                     scope ?? "user",
                     "driggsby",
                     DRIGGSBY_MCP_URL,
+                    ...headers.flatMap((header) => ["--header", header]),
                 ],
             };
         case "codex":

package/dist/mcp-setup/setup.js

@@ -1,5 +1,6 @@
 import { createInterface } from "node:readline/promises";
 import { CliError } from "../cli-error.js";
+import { describeDevice, deviceHeaders } from "../device.js";
 import { trimLikeRust } from "../terminal-text.js";
 import { runClientCommand } from "./client-command.js";
 import { classifyExistingMcpConfig } from "./classify.js";
@@ -24,7 +25,11 @@ export async function runMcpSetup(options) {
         return;
     }
     write(`Adding Driggsby to ${displayName(client)} MCP config...\n`);
-    const result = await runClientCommand(installer, streamConfigOutput(client));
+    // The command it runs also names this computer (Claude Code only); the
+    // commands it prints for a person stay the plain, portable ones.
+    const headers = installClient === "claude-code" ? deviceHeaders(describeDevice()) : [];
+    const runInstaller = buildInstallerCommand(installClient, options.scope, headers);
+    const result = await runClientCommand(runInstaller, streamConfigOutput(client));
     switch (result.kind) {
         case "output":
             if (result.output.succeeded) {

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

@@ -5,8 +5,9 @@
 // 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.
+// constant arguments (see commands.ts) or this computer's name and system,
+// allowlisted by device.ts to characters cmd.exe treats as plain; 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";
@@ -80,8 +81,9 @@ export function resolveWindowsProgram(program, lookup = defaultLookup()) {
 // (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.
+// the MCP URL; only fixed constants, PATH-resolved program paths, and the
+// device values device.ts allowlists (no % ! ^ & | < > " \ or control
+// characters) may reach this function.
 export function quoteForCmd(value) {
     if (/^[A-Za-z0-9_\-.:\\/=]+$/.test(value)) {
         return value;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "driggsby",
-  "version": "0.5.2",
+  "version": "0.6.0",
   "description": "Set up and build on Driggsby, the MCP server for personal finance.",
   "license": "Apache-2.0",
   "repository": {
@@ -28,7 +28,7 @@
     "node": ">=18"
   },
   "dependencies": {
-    "@driggsby/deploy": "0.5.2",
-    "@driggsby/sdk": "0.5.2"
+    "@driggsby/deploy": "0.6.0",
+    "@driggsby/sdk": "0.6.0"
   }
 }