@shaidle/bridge 0.1.0

package/README.md

@@ -0,0 +1,56 @@
+# @shaidle/bridge
+
+Point the **Claude Code you already use** at the [Shaidle](https://shaidle.io) exchange and run
+coding tasks from your terminal — billed to your Shaidle wallet, served from pooled provider
+capacity. You never connect a Claude account; the only credential is a Shaidle API token.
+
+## Install
+
+```
+npm i -g @shaidle/bridge
+```
+
+## Log in
+
+Mint a token in the web app under **Connect editor**, then:
+
+```
+shaidle login --token sk-shaidle-… --endpoint https://api.shaidle.io
+```
+
+## Use
+
+**Open your own Claude Code on Shaidle — reverts when you close the terminal.** This wires the
+endpoint + token into that session only; nothing is written to your global `~/.claude` config, so
+your normal Claude setup is untouched the moment you quit.
+
+```
+shaidle code
+```
+
+**Run a one-off task** on the exchange without opening an editor — the result streams back, your
+code stays on your machine:
+
+```
+shaidle run "add a health endpoint to server.ts"
+```
+
+**Always-on (advanced):** print the two env vars to route any Anthropic-compatible tool through
+Shaidle until you unset them.
+
+```
+shaidle env
+```
+
+## Commands
+
+| Command | What it does |
+|---|---|
+| `shaidle login --token <sk-shaidle-…> [--endpoint <url>]` | Save your credentials |
+| `shaidle whoami` | Show the account the token belongs to |
+| `shaidle code [claude args…]` | Open your Claude Code wired to Shaidle for this session only |
+| `shaidle run "<prompt>" [--provider auto\|claude\|codex\|gemini\|cursor]` | Run a task, stream the result |
+| `shaidle env` | Print env exports that point Claude Code at the exchange |
+| `shaidle logout` | Forget the saved token |
+
+Your code and prompts stay on your machine — only the request and its result cross the wire.

package/dist/cli.js

@@ -0,0 +1,267 @@
+#!/usr/bin/env node
+// Shaidle Local Bridge CLI.
+//
+// The simplest possible "sell/buy AI capacity" client: a buyer installs one npm package,
+// pastes the API token they minted in the web app, and runs coding tasks on the exchange
+// from their own terminal. Their machine, their prompt — only the token and the result cross
+// the wire. Built entirely on the public HTTP surface (bearer /api/jobs + SSE), no secrets
+// and no provider SDK on the buyer's side.
+//
+//   npm i -g @shaidle/bridge                      (at launch; pre-launch: build from the repo)
+//   shaidle login --token sk-shaidle-… [--endpoint https://api.shaidle.io]
+//
+// Two ways to spend the credit after login:
+//   shaidle code                                  ← open your OWN Claude Code, wired to the
+//                                                   exchange for THIS session only (reverts on exit)
+//   shaidle run "add a health endpoint to server.ts"   ← run a one-off task on the exchange
+//
+import { readFileSync, writeFileSync, mkdirSync, rmSync, existsSync } from "node:fs";
+import { spawn } from "node:child_process";
+import { homedir } from "node:os";
+import { join } from "node:path";
+// This CLI is deliberately DEPENDENCY-FREE — Node built-ins only, no workspace packages. That's
+// what lets us ship it as a compiled artifact (publish `dist/*.js` with the source held back, or
+// wrap it into a single `shaidle` executable) without dragging the private monorepo along. The few
+// wire facts below mirror @shaidle/contract; they're stable public routes, kept local on purpose.
+const DEFAULT_API_BASE = "http://localhost:8787";
+const API = {
+    me: "/api/me",
+    jobs: "/api/jobs",
+    jobStream: (id) => `/api/jobs/${id}/stream`,
+};
+const CONFIG_DIR = join(homedir(), ".shaidle");
+const CONFIG_PATH = join(CONFIG_DIR, "config.json");
+function readConfig() {
+    try {
+        return JSON.parse(readFileSync(CONFIG_PATH, "utf8"));
+    }
+    catch {
+        return null;
+    }
+}
+function writeConfig(cfg) {
+    mkdirSync(CONFIG_DIR, { recursive: true });
+    // Owner-only perms where the platform honors them (POSIX). The token is a bearer secret.
+    writeFileSync(CONFIG_PATH, JSON.stringify(cfg, null, 2), { mode: 0o600 });
+}
+/** Pull a `--flag value` pair out of argv, returning the value (or undefined). */
+function takeFlag(args, name) {
+    const i = args.indexOf(name);
+    if (i === -1)
+        return undefined;
+    const val = args[i + 1];
+    args.splice(i, val !== undefined && !val.startsWith("--") ? 2 : 1);
+    return val;
+}
+function requireConfig() {
+    const cfg = readConfig();
+    if (!cfg?.token) {
+        console.error("Not logged in. Run:  shaidle login --token sk-shaidle-…");
+        process.exit(1);
+    }
+    return cfg;
+}
+async function api(cfg, path, init = {}) {
+    return fetch(cfg.endpoint + path, {
+        method: init.method ?? "GET",
+        headers: {
+            authorization: `Bearer ${cfg.token}`,
+            accept: init.stream ? "text/event-stream" : "application/json",
+            ...(init.body !== undefined ? { "content-type": "application/json" } : {}),
+        },
+        body: init.body === undefined ? undefined : JSON.stringify(init.body),
+    });
+}
+const USAGE = `Shaidle Local Bridge — run AI coding tasks on the exchange from your terminal.
+
+Usage:
+  shaidle login --token <sk-shaidle-…> [--endpoint <url>]   Save your credentials
+  shaidle whoami                                            Show the account the token belongs to
+  shaidle code [claude args…]                               Open YOUR Claude Code wired to the exchange
+                                                            for this session only — reverts on exit
+  shaidle run "<prompt>" [--provider auto|claude|codex|gemini|cursor]   Run a task, stream the result
+  shaidle env                                               Print env exports that point Claude Code
+                                                            (or any Anthropic tool) at the exchange
+  shaidle logout                                            Forget the saved token
+  shaidle help                                              Show this help
+
+Provider defaults to "auto": the exchange picks the best available account and fails over
+between sellers (even cross-provider) if one runs out of quota mid-way.
+Your token is minted in the web app under "Connect editor". Endpoint defaults to ${DEFAULT_API_BASE}.`;
+async function cmdLogin(args) {
+    const token = takeFlag(args, "--token");
+    const endpoint = (takeFlag(args, "--endpoint") ?? DEFAULT_API_BASE).replace(/\/$/, "");
+    if (!token || !token.startsWith("sk-shaidle-")) {
+        console.error("Provide a valid token:  shaidle login --token sk-shaidle-…");
+        process.exit(1);
+    }
+    writeConfig({ endpoint, token });
+    // Verify the token actually resolves before declaring success.
+    const res = await api({ endpoint, token }, API.me).catch(() => null);
+    if (!res || res.status !== 200) {
+        console.error(`Saved, but the token did not authenticate against ${endpoint} (HTTP ${res?.status ?? "offline"}).`);
+        process.exit(1);
+    }
+    const me = (await res.json());
+    console.log(`Logged in to ${endpoint} as ${me.email ?? "your account"}.`);
+}
+async function cmdWhoami() {
+    const cfg = requireConfig();
+    const res = await api(cfg, API.me);
+    if (res.status !== 200) {
+        console.error(`Not authenticated (HTTP ${res.status}). Re-run shaidle login.`);
+        process.exit(1);
+    }
+    const me = (await res.json());
+    console.log(`${me.email ?? "(unknown)"}  ·  ${cfg.endpoint}`);
+}
+async function cmdRun(args) {
+    const cfg = requireConfig();
+    // "auto" is the default — the exchange matches any available account and fails over.
+    const provider = takeFlag(args, "--provider") ?? "auto";
+    const prompt = args.filter((a) => !a.startsWith("--")).join(" ").trim();
+    if (!prompt) {
+        console.error('Give a prompt:  shaidle run "fix the failing test in utils.ts"');
+        process.exit(1);
+    }
+    const created = await api(cfg, API.jobs, { method: "POST", body: { provider, prompt } });
+    if (created.status === 401) {
+        console.error("Token rejected (401). Re-run shaidle login.");
+        process.exit(1);
+    }
+    if (created.status === 402) {
+        console.error("Insufficient Shaidle credit (402). Top up your wallet in the web app, then retry.");
+        process.exit(1);
+    }
+    if (created.status !== 201) {
+        console.error(`Could not start the job (HTTP ${created.status}): ${(await created.text()).slice(0, 200)}`);
+        process.exit(1);
+    }
+    const { jobId } = (await created.json());
+    // Stream the run — the endpoint is owner-guarded, so the bearer token rides along.
+    const stream = await api(cfg, API.jobStream(jobId), { stream: true });
+    if (!stream.body) {
+        console.error("No stream from the server.");
+        process.exit(1);
+    }
+    const reader = stream.body.getReader();
+    const dec = new TextDecoder();
+    let buf = "";
+    let exitCode = 0;
+    for (;;) {
+        const { value, done } = await reader.read();
+        if (done)
+            break;
+        buf += dec.decode(value, { stream: true });
+        const events = buf.split("\n\n");
+        buf = events.pop() ?? "";
+        for (const ev of events) {
+            const line = ev.split("\n").find((l) => l.startsWith("data:"));
+            if (!line)
+                continue;
+            let d;
+            try {
+                d = JSON.parse(line.slice(5).trim());
+            }
+            catch {
+                continue;
+            }
+            if (d.type === "chunk")
+                process.stdout.write(String(d.text ?? ""));
+            else if (d.type === "started")
+                process.stderr.write(`· running via ${String(d.provider)} on node ${String(d.nodeId)}\n`);
+            else if (d.type === "reissue")
+                // The serving account died (quota/auth); the exchange restarted the run elsewhere.
+                // Output printed so far belongs to the abandoned attempt — the fresh answer follows.
+                process.stderr.write(`\n⇄ account switch: ${String(d.fromNode)} → ${String(d.toNode)} (${String(d.provider)}) — restarting stream\n`);
+            else if (d.type === "usage")
+                process.stderr.write(`· charged ${String(d.buyerChargeMinor)} minor (${String(d.currency)})\n`);
+            else if (d.type === "done")
+                process.stdout.write("\n");
+            else if (d.type === "error") {
+                process.stderr.write(`\n✗ ${String(d.message)}\n`);
+                exitCode = 1;
+            }
+        }
+    }
+    process.exit(exitCode);
+}
+/**
+ * Launch the buyer's OWN Claude Code (or any command via --bin) with the exchange wired in for
+ * THIS child process only: ANTHROPIC_BASE_URL + ANTHROPIC_AUTH_TOKEN live on the child's env and
+ * vanish when it exits. Nothing is written to ~/.claude/settings.json or the shell profile, so the
+ * buyer's normal Claude setup is byte-for-byte untouched the moment the session ends. This is the
+ * ephemeral counterpart to `shaidle env` (which prints exports you'd paste — and later have to undo).
+ */
+function cmdCode(args) {
+    const cfg = requireConfig();
+    const bin = takeFlag(args, "--bin") ?? process.env.SHAIDLE_CLAUDE_BIN ?? "claude";
+    const env = { ...process.env };
+    // A stale global ANTHROPIC_API_KEY would shadow the gateway token — drop it for the child only.
+    delete env.ANTHROPIC_API_KEY;
+    env.ANTHROPIC_BASE_URL = cfg.endpoint;
+    env.ANTHROPIC_AUTH_TOKEN = cfg.token;
+    process.stderr.write(`· ${bin} → ${cfg.endpoint} — this session only, your normal Claude setup reverts on exit\n`);
+    const child = spawn(bin, args, {
+        stdio: "inherit",
+        env,
+        shell: process.platform === "win32", // resolve claude.cmd / claude.ps1 off the Windows PATH
+    });
+    child.on("error", (e) => {
+        const hint = e.code === "ENOENT" ? ` — is "${bin}" installed and on your PATH?` : "";
+        console.error(`Could not launch ${bin}${hint} (${e.message})`);
+        process.exit(1);
+    });
+    child.on("exit", (code) => process.exit(code ?? 0));
+}
+function cmdLogout() {
+    if (existsSync(CONFIG_PATH))
+        rmSync(CONFIG_PATH);
+    console.log("Logged out.");
+}
+/**
+ * Print the two env vars that point an unmodified Claude Code (or any Anthropic-SDK tool)
+ * straight at the exchange's /v1/messages passthrough — the zero-install Local mode.
+ */
+function cmdEnv() {
+    const cfg = requireConfig();
+    console.log(`# POSIX (bash/zsh) — eval "$(shaidle env)"`);
+    console.log(`export ANTHROPIC_BASE_URL=${cfg.endpoint}`);
+    console.log(`export ANTHROPIC_AUTH_TOKEN=${cfg.token}`);
+    console.log(`# PowerShell:`);
+    console.log(`#   $env:ANTHROPIC_BASE_URL = "${cfg.endpoint}"`);
+    console.log(`#   $env:ANTHROPIC_AUTH_TOKEN = "${cfg.token}"`);
+    console.log(`# Then run \`claude\` in your project as usual — requests are served from`);
+    console.log(`# pooled seller accounts with automatic failover, billed to your wallet.`);
+}
+async function main() {
+    const [cmd, ...rest] = process.argv.slice(2);
+    switch (cmd) {
+        case "login":
+            return cmdLogin(rest);
+        case "whoami":
+            return cmdWhoami();
+        case "code":
+            return cmdCode(rest);
+        case "run":
+            return cmdRun(rest);
+        case "env":
+            return cmdEnv();
+        case "logout":
+            return cmdLogout();
+        case undefined:
+        case "help":
+        case "--help":
+        case "-h":
+            console.log(USAGE);
+            return;
+        default:
+            console.error(`Unknown command: ${cmd}\n\n${USAGE}`);
+            process.exit(1);
+    }
+}
+main().catch((e) => {
+    console.error(e instanceof Error ? e.message : String(e));
+    process.exit(1);
+});
+//# sourceMappingURL=cli.js.map

package/package.json

@@ -0,0 +1,36 @@
+{
+  "name": "@shaidle/bridge",
+  "version": "0.1.0",
+  "type": "module",
+  "description": "Shaidle Local Bridge CLI — point your own Claude Code at the Shaidle exchange (per-session or always-on) and run coding tasks from your terminal, authenticated by a Shaidle API token.",
+  "keywords": [
+    "shaidle",
+    "claude",
+    "claude-code",
+    "cli",
+    "ai"
+  ],
+  "license": "UNLICENSED",
+  "bin": {
+    "shaidle": "./dist/cli.js"
+  },
+  "main": "./dist/cli.js",
+  "engines": {
+    "node": ">=18"
+  },
+  "files": [
+    "dist/cli.js"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "build": "tsc -p tsconfig.json",
+    "typecheck": "tsc -p tsconfig.json --noEmit",
+    "prepublishOnly": "npm run build"
+  },
+  "devDependencies": {
+    "@types/node": "^22.0.0",
+    "typescript": "^5.7.0"
+  }
+}