driggsby 0.1.14 → 0.1.16

package/LICENSE

@@ -1,8 +1,117 @@
-UNLICENSED
+Apache License
+Version 2.0, January 2004
+http://www.apache.org/licenses/
 
-Copyright (c) The Good Software Company.
-All rights reserved.
+TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
 
-This package and its source are proprietary. No license rights are granted to
-use, copy, modify, or distribute this software except as otherwise agreed in
-writing by The Good Software Company.
+1. Definitions.
+
+"License" shall mean the terms and conditions for use, reproduction, and
+distribution as defined by Sections 1 through 9 of this document.
+
+"Licensor" shall mean the copyright owner or entity authorized by the copyright
+owner that is granting the License.
+
+"Legal Entity" shall mean the union of the acting entity and all other entities
+that control, are controlled by, or are under common control with that entity.
+For the purposes of this definition, "control" means (i) the power, direct or
+indirect, to cause the direction or management of such entity, whether by
+contract or otherwise, or (ii) ownership of fifty percent (50%) or more of the
+outstanding shares, or (iii) beneficial ownership of such entity.
+
+"You" (or "Your") shall mean an individual or Legal Entity exercising
+permissions granted by this License.
+
+"Source" form shall mean the preferred form for making modifications, including
+but not limited to software source code, documentation source, and configuration
+files.
+
+"Object" form shall mean any form resulting from mechanical transformation or
+translation of a Source form, including but not limited to compiled object code,
+generated documentation, and conversions to other media types.
+
+"Work" shall mean the work of authorship, whether in Source or Object form,
+made available under the License, as indicated by a copyright notice that is
+included in or attached to the work.
+
+"Derivative Works" shall mean any work, whether in Source or Object form, that
+is based on (or derived from) the Work and for which the editorial revisions,
+annotations, elaborations, or other modifications represent, as a whole, an
+original work of authorship. For the purposes of this License, Derivative Works
+shall not include works that remain separable from, or merely link (or bind by
+name) to the interfaces of, the Work and Derivative Works thereof.
+
+"Contribution" shall mean any work of authorship, including the original version
+of the Work and any modifications or additions to that Work or Derivative Works
+thereof, that is intentionally submitted to Licensor for inclusion in the Work
+by the copyright owner or by an individual or Legal Entity authorized to submit
+on behalf of the copyright owner. For the purposes of this definition,
+"submitted" means any form of electronic, verbal, or written communication sent
+to the Licensor or its representatives, including but not limited to
+communication on electronic mailing lists, source code control systems, and
+issue tracking systems that are managed by, or on behalf of, the Licensor for
+the purpose of discussing and improving the Work, but excluding communication
+that is conspicuously marked or otherwise designated in writing by the copyright
+owner as "Not a Contribution."
+
+"Contributor" shall mean Licensor and any individual or Legal Entity on behalf
+of whom a Contribution has been received by Licensor and subsequently
+incorporated within the Work.
+
+2. Grant of Copyright License. Subject to the terms and conditions of this
+License, each Contributor hereby grants to You a perpetual, worldwide,
+non-exclusive, no-charge, royalty-free, irrevocable copyright license to
+reproduce, prepare Derivative Works of, publicly display, publicly perform,
+sublicense, and distribute the Work and such Derivative Works in Source or
+Object form.
+
+3. Grant of Patent License. Subject to the terms and conditions of this License,
+each Contributor hereby grants to You a perpetual, worldwide, non-exclusive,
+no-charge, royalty-free, irrevocable patent license to make, have made, use,
+offer to sell, sell, import, and otherwise transfer the Work.
+
+4. Redistribution. You may reproduce and distribute copies of the Work or
+Derivative Works thereof in any medium, with or without modifications, and in
+Source or Object form, provided that You meet the following conditions:
+
+(a) You must give any other recipients of the Work or Derivative Works a copy of
+this License; and
+
+(b) You must cause any modified files to carry prominent notices stating that
+You changed the files; and
+
+(c) You must retain, in the Source form of any Derivative Works that You
+distribute, all copyright, patent, trademark, and attribution notices from the
+Source form of the Work, excluding those notices that do not pertain to any part
+of the Derivative Works; and
+
+(d) If the Work includes a "NOTICE" text file as part of its distribution, then
+any Derivative Works that You distribute must include a readable copy of the
+attribution notices contained within such NOTICE file.
+
+5. Submission of Contributions. Unless You explicitly state otherwise, any
+Contribution intentionally submitted for inclusion in the Work by You to the
+Licensor shall be under the terms and conditions of this License.
+
+6. Trademarks. This License does not grant permission to use the trade names,
+trademarks, service marks, or product names of the Licensor, except as required
+for reasonable and customary use in describing the origin of the Work.
+
+7. Disclaimer of Warranty. Unless required by applicable law or agreed to in
+writing, Licensor provides the Work on an "AS IS" BASIS, WITHOUT WARRANTIES OR
+CONDITIONS OF ANY KIND, either express or implied, including, without limitation,
+any warranties or conditions of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or
+FITNESS FOR A PARTICULAR PURPOSE.
+
+8. Limitation of Liability. In no event and under no legal theory, whether in
+tort (including negligence), contract, or otherwise, unless required by
+applicable law or agreed to in writing, shall any Contributor be liable to You
+for damages, including any direct, indirect, special, incidental, or
+consequential damages arising as a result of this License or out of the use or
+inability to use the Work.
+
+9. Accepting Warranty or Additional Liability. While redistributing the Work or
+Derivative Works thereof, You may choose to offer, and charge a fee for,
+acceptance of support, warranty, indemnity, or other liability obligations.
+However, in accepting such obligations, You may act only on Your own behalf and
+on Your sole responsibility.

package/README.md

@@ -2,64 +2,20 @@
 
 `driggsby` is the local CLI for connecting AI clients to Driggsby over MCP.
 
-## What You Get
-
-- browser-based sign-in to Driggsby
-- a local MCP server for tools like Codex and Claude Code
-- access to supported Driggsby tools from your AI client
-
-## Run
-
-```bash
-npx driggsby@latest login
-```
-
-## Install
-
-```bash
-npm install -g driggsby
-```
-
-If you prefer not to install globally, use `npx driggsby@latest` for
-human-invoked commands like `login`, `status`, and `logout`, and use
-`npx -y driggsby@latest mcp-server` for non-interactive MCP launcher flows.
-
-On machines without working platform keyring support, such as some headless
-Linux servers, Driggsby falls back to an owner-only local file-backed secret
-store so the CLI can still complete login and run the broker.
-
 ## Quick Start
 
-1. Sign in:
-
 ```bash
 npx driggsby@latest login
-```
-
-2. Add Driggsby as an MCP server in your client:
-
-```bash
-codex mcp add driggsby -- npx -y driggsby@latest mcp-server
-```
-
-3. Check broker status any time:
-
-```bash
 npx driggsby@latest status
+npx -y driggsby@latest mcp-server
 ```
 
-## Commands
+For non-interactive MCP launcher flows, use:
 
 ```bash
-npx driggsby@latest login
-npx driggsby@latest status
 npx -y driggsby@latest mcp-server
-npx driggsby@latest logout
 ```
 
 ## License
 
-This package is currently published as `UNLICENSED`.
-
-No license rights are granted beyond what The Good Software Company agrees to in
-writing.
+Apache-2.0

package/install.js

@@ -1,4 +1,168 @@
 #!/usr/bin/env node
-
-const { install } = require("./binary");
-install(false);
+import { createHash } from "node:crypto";
+import { chmodSync, createWriteStream, existsSync, lstatSync, mkdtempSync, mkdirSync, readFileSync, rmSync, } from "node:fs";
+import { tmpdir } from "node:os";
+import { basename, dirname, join } from "node:path";
+import { Transform } from "node:stream";
+import { pipeline } from "node:stream/promises";
+import { fileURLToPath } from "node:url";
+import { readCommandOutput, writeCommandOutputToFile } from "./lib/process.js";
+const packageDirectory = dirname(fileURLToPath(import.meta.url));
+const installDirectory = join(packageDirectory, "node_modules", ".bin_real");
+const maxArtifactBytes = 64 * 1024 * 1024;
+const packageJson = JSON.parse(readFileSync(join(packageDirectory, "package.json"), "utf8"));
+try {
+    await install();
+}
+catch (error) {
+    if (error instanceof Error) {
+        console.error(error.message);
+    }
+    else {
+        console.error(error);
+    }
+    process.exit(1);
+}
+async function install() {
+    const platform = resolvePlatform();
+    const binaryPath = join(installDirectory, platform.binaryPath);
+    if (existsSync(binaryPath)) {
+        return;
+    }
+    rmSync(installDirectory, { force: true, recursive: true });
+    mkdirSync(installDirectory, { recursive: true });
+    const artifactUrl = `${packageJson.driggsbyArtifacts.baseUrl}/${platform.artifactName}`;
+    const tempDirectory = mkdtempSync(join(tmpdir(), "driggsby-install-"));
+    chmodSync(tempDirectory, 0o700);
+    const tempArtifact = join(tempDirectory, platform.artifactName);
+    try {
+        const expectedChecksum = packageJson.driggsbyArtifacts.checksums[platform.artifactName];
+        if (!expectedChecksum) {
+            throw new Error(`Driggsby package is missing a checksum for ${platform.artifactName}.`);
+        }
+        await downloadAndVerifyFile(artifactUrl, tempArtifact, expectedChecksum);
+        await extractTarball(tempArtifact, installDirectory, platform.binaryPath);
+        chmodSync(binaryPath, 0o755);
+    }
+    catch (error) {
+        rmSync(installDirectory, { force: true, recursive: true });
+        throw error;
+    }
+    finally {
+        rmSync(tempDirectory, { force: true, recursive: true });
+    }
+}
+function resolvePlatform() {
+    const triple = targetTriple();
+    const platform = packageJson.driggsbyArtifacts.supportedPlatforms[triple];
+    if (!platform) {
+        const supported = Object.keys(packageJson.driggsbyArtifacts.supportedPlatforms)
+            .sort()
+            .join(", ");
+        throw new Error(`Driggsby does not currently publish a native binary for ${process.platform}/${process.arch}. Supported targets: ${supported}.`);
+    }
+    return platform;
+}
+function targetTriple() {
+    const architecture = mapArchitecture(process.arch);
+    const operatingSystem = mapOperatingSystem(process.platform);
+    return `${architecture}-${operatingSystem}`;
+}
+function mapArchitecture(architecture) {
+    if (architecture === "arm64") {
+        return "aarch64";
+    }
+    if (architecture === "x64") {
+        return "x86_64";
+    }
+    return architecture;
+}
+function mapOperatingSystem(platform) {
+    if (platform === "darwin") {
+        return "apple-darwin";
+    }
+    if (platform === "linux") {
+        return "unknown-linux-gnu";
+    }
+    if (platform === "win32") {
+        return "pc-windows-msvc";
+    }
+    return platform;
+}
+async function downloadAndVerifyFile(url, destination, expectedChecksum) {
+    const response = await fetch(url);
+    if (!response.ok || response.body === null) {
+        throw new Error(`Could not download Driggsby binary ${url}: HTTP ${response.status}.`);
+    }
+    const contentLength = response.headers.get("content-length");
+    if (contentLength && Number(contentLength) > maxArtifactBytes) {
+        throw new Error(`Driggsby binary download is unexpectedly large: ${contentLength} bytes.`);
+    }
+    const hash = createHash("sha256");
+    let bytesRead = 0;
+    const verifier = new Transform({
+        transform(chunk, _encoding, callback) {
+            bytesRead += chunk.byteLength;
+            if (bytesRead > maxArtifactBytes) {
+                callback(new Error(`Driggsby binary download exceeded ${maxArtifactBytes} bytes.`));
+                return;
+            }
+            hash.update(chunk);
+            callback(null, chunk);
+        },
+    });
+    await pipeline(response.body, verifier, createWriteStream(destination, { flags: "wx", mode: 0o600 }));
+    const actualChecksum = hash.digest("hex");
+    if (actualChecksum !== expectedChecksum) {
+        throw new Error(`Driggsby binary checksum mismatch for ${basename(destination)}. Expected ${expectedChecksum}, got ${actualChecksum}.`);
+    }
+}
+function extractTarball(artifactPath, destination, binaryPath) {
+    const tarPath = trustedTarPath();
+    const entry = findBinaryTarEntry(tarPath, artifactPath, binaryPath);
+    const installedBinary = join(destination, binaryPath);
+    writeCommandOutputToFile(tarPath, ["-xOf", artifactPath, "--", entry], installedBinary, maxArtifactBytes);
+    if (!existsSync(installedBinary)) {
+        throw new Error(`Driggsby archive did not contain expected binary ${binaryPath}.`);
+    }
+    const installedBinaryStats = lstatSync(installedBinary);
+    if (!installedBinaryStats.isFile() || installedBinaryStats.isSymbolicLink()) {
+        throw new Error(`Driggsby archive entry ${binaryPath} was not a regular file.`);
+    }
+}
+function trustedTarPath() {
+    for (const candidate of ["/usr/bin/tar", "/bin/tar"]) {
+        if (existsSync(candidate)) {
+            return candidate;
+        }
+    }
+    throw new Error("Could not find the system tar executable required to unpack Driggsby.");
+}
+function findBinaryTarEntry(tarPath, artifactPath, binaryPath) {
+    const entries = readCommandOutput(tarPath, ["-tf", artifactPath])
+        .split("\n")
+        .map((entry) => entry.trim())
+        .filter((entry) => entry.length > 0);
+    const binaryEntries = [];
+    for (const entry of entries) {
+        const normalizedEntry = entry.replace(/\\/g, "/");
+        const segments = normalizedEntry.split("/").filter((segment) => segment.length > 0);
+        if (normalizedEntry.startsWith("/") ||
+            /^[A-Za-z]:/.test(normalizedEntry) ||
+            segments.includes("..") ||
+            segments.some((segment) => segment.startsWith("-"))) {
+            throw new Error(`Driggsby archive contains unsafe path ${entry}.`);
+        }
+        if (segments.length === 2 && segments[1] === binaryPath) {
+            binaryEntries.push(entry);
+        }
+    }
+    if (binaryEntries.length !== 1) {
+        throw new Error(`Driggsby archive did not contain exactly one ${binaryPath} binary.`);
+    }
+    const [binaryEntry] = binaryEntries;
+    if (!binaryEntry) {
+        throw new Error(`Driggsby archive did not contain expected binary ${binaryPath}.`);
+    }
+    return binaryEntry;
+}

package/lib/process.js

@@ -0,0 +1,65 @@
+import { spawnSync } from "node:child_process";
+import { writeFileSync } from "node:fs";
+export function runFile(command, args) {
+    const result = spawnSync(command, args, {
+        cwd: process.cwd(),
+        stdio: "inherit",
+    });
+    if (result.error) {
+        throw result.error;
+    }
+    return { status: result.status ?? 1 };
+}
+export function spawnFile(command, args) {
+    const result = runFile(command, args);
+    if (result.status !== 0) {
+        throw new Error(`${command} exited with status ${result.status}.`);
+    }
+}
+export function readCommandOutput(command, args) {
+    const result = spawnSync(command, args, {
+        cwd: process.cwd(),
+        encoding: "utf8",
+        maxBuffer: 1024 * 1024,
+    });
+    if (result.error) {
+        throw result.error;
+    }
+    if (result.status !== 0) {
+        const stderr = result.stderr.trim();
+        const detail = stderr.length > 0 ? `: ${stderr}` : "";
+        throw new Error(`${command} exited with status ${result.status ?? 1}${detail}.`);
+    }
+    return result.stdout;
+}
+export function writeCommandOutputToFile(command, args, destination, maxBytes) {
+    const result = spawnSync(command, args, {
+        cwd: process.cwd(),
+        encoding: "buffer",
+        maxBuffer: maxBytes,
+    });
+    if (result.error) {
+        throw result.error;
+    }
+    if (result.status !== 0) {
+        const stderr = result.stderr.toString("utf8").trim();
+        const detail = stderr.length > 0 ? `: ${stderr}` : "";
+        throw new Error(`${command} exited with status ${result.status ?? 1}${detail}.`);
+    }
+    writeFileSync(destination, result.stdout, { flag: "wx", mode: 0o700 });
+}
+export function spawnFileAndExit(command, args) {
+    try {
+        const result = runFile(command, args);
+        process.exit(result.status);
+    }
+    catch (error) {
+        if (error instanceof Error) {
+            console.error(error.message);
+        }
+        else {
+            console.error(error);
+        }
+        process.exit(1);
+    }
+}

package/package.json

@@ -1,63 +1,48 @@
 {
-  "artifactDownloadUrls": [
-    "https://github.com/thegoodsoftwareco/driggsby/releases/download/driggsby-v0.1.14"
-  ],
+  "name": "driggsby",
+  "version": "0.1.16",
+  "description": "Local MCP broker and CLI for connecting AI clients to Driggsby",
+  "license": "Apache-2.0",
+  "repository": "https://github.com/thegoodsoftwareco/driggsby-cli",
+  "type": "module",
   "bin": {
     "driggsby": "run-driggsby.js"
   },
-  "dependencies": {
-    "axios": "^1.13.5",
-    "axios-proxy-builder": "^0.1.2",
-    "console.table": "^0.10.0",
-    "detect-libc": "^2.1.2",
-    "rimraf": "^6.1.3"
-  },
-  "description": "Local MCP broker and CLI for connecting AI clients to Driggsby",
-  "devDependencies": {
-    "prettier": "^3.8.1"
-  },
-  "engines": {
-    "node": ">=14",
-    "npm": ">=6"
-  },
-  "glibcMinimum": {
-    "major": 2,
-    "series": 35
-  },
-  "name": "driggsby",
-  "preferUnplugged": true,
-  "repository": "https://github.com/thegoodsoftwareco/driggsby",
   "scripts": {
-    "fmt": "prettier --write **/*.js",
-    "fmt:check": "prettier --check **/*.js",
     "postinstall": "node ./install.js"
   },
-  "supportedPlatforms": {
-    "aarch64-apple-darwin": {
-      "artifactName": "driggsby-aarch64-apple-darwin.tar.xz",
-      "bins": {
-        "driggsby": "driggsby"
-      },
-      "zipExt": ".tar.xz"
+  "engines": {
+    "node": ">=18",
+    "npm": ">=9"
+  },
+  "files": [
+    "LICENSE",
+    "README.md",
+    "install.js",
+    "lib",
+    "package.json",
+    "run-driggsby.js"
+  ],
+  "driggsbyArtifacts": {
+    "baseUrl": "https://github.com/thegoodsoftwareco/driggsby-cli/releases/download/driggsby-v0.1.16",
+    "checksums": {
+      "driggsby-aarch64-apple-darwin.tar.xz": "627b0b53f288270d3a4f29c12811c92e34fd7eba8107a92e0854d98d9a6d845d",
+      "driggsby-x86_64-apple-darwin.tar.xz": "3ab8735d30f98b15f878fe397fd5f2496a75192e155a5626987869394748acb1",
+      "driggsby-x86_64-unknown-linux-gnu.tar.xz": "515cacd5a00b42e742a84e81fcb08f32a3d76d9ce24b300b7ccaf3850550bd21"
     },
-    "x86_64-apple-darwin": {
-      "artifactName": "driggsby-x86_64-apple-darwin.tar.xz",
-      "bins": {
-        "driggsby": "driggsby"
+    "supportedPlatforms": {
+      "aarch64-apple-darwin": {
+        "artifactName": "driggsby-aarch64-apple-darwin.tar.xz",
+        "binaryPath": "driggsby"
       },
-      "zipExt": ".tar.xz"
-    },
-    "x86_64-unknown-linux-gnu": {
-      "artifactName": "driggsby-x86_64-unknown-linux-gnu.tar.xz",
-      "bins": {
-        "driggsby": "driggsby"
+      "x86_64-apple-darwin": {
+        "artifactName": "driggsby-x86_64-apple-darwin.tar.xz",
+        "binaryPath": "driggsby"
       },
-      "zipExt": ".tar.xz"
+      "x86_64-unknown-linux-gnu": {
+        "artifactName": "driggsby-x86_64-unknown-linux-gnu.tar.xz",
+        "binaryPath": "driggsby"
+      }
     }
-  },
-  "version": "0.1.14",
-  "volta": {
-    "node": "18.14.1",
-    "npm": "9.5.0"
   }
-}
+}

package/run-driggsby.js

@@ -1,4 +1,12 @@
 #!/usr/bin/env node
-
-const { run } = require("./binary");
-run("driggsby");
+import { existsSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+import { spawnFileAndExit } from "./lib/process.js";
+const packageDirectory = dirname(fileURLToPath(import.meta.url));
+const binaryPath = join(packageDirectory, "node_modules", ".bin_real", "driggsby");
+if (!existsSync(binaryPath)) {
+    console.error("Driggsby is not installed. Reinstall the npm package and try again.");
+    process.exit(1);
+}
+spawnFileAndExit(binaryPath, process.argv.slice(2));

package/.gitignore

@@ -1,2 +0,0 @@
-/node_modules
-