@askalf/dario 4.8.105 → 4.8.106

package/dist/accounts.d.ts

@@ -39,6 +39,27 @@ export declare function addAccountViaOAuth(alias: string): Promise<AccountCreden
  * full URL to the browser.
  */
 export declare function addAccountViaManualOAuth(alias: string): Promise<AccountCredentials>;
+/**
+ * Non-interactive first half of the manual add-account flow (#599): validate
+ * the alias, generate PKCE + state, and build the authorize URL the user opens
+ * in a browser. The caller keeps `codeVerifier` + `state` and passes them back
+ * to `completeAddAccount` after the user supplies the displayed code. Shared by
+ * the `dario accounts add --manual` CLI and the headless admin API — the secret
+ * (codeVerifier) never leaves the process that started the flow.
+ */
+export declare function startAddAccount(alias: string): Promise<{
+    authorizeUrl: string;
+    codeVerifier: string;
+    state: string;
+}>;
+/**
+ * Non-interactive second half (#599): exchange the authorization `code` for
+ * tokens (PKCE-verified server-side), attach a device/account identity, and
+ * persist the account to `~/.dario/accounts/<alias>.json`. Throws — with any
+ * upstream secrets redacted — on a failed exchange. Shared by the CLI and the
+ * admin API.
+ */
+export declare function completeAddAccount(alias: string, code: string, codeVerifier: string, state: string): Promise<AccountCredentials>;
 export declare function getAccountsDir(): string;
 /**
  * Error subclass for the keychain-import path so the CLI can render

package/dist/accounts.js

@@ -329,15 +329,11 @@ export async function addAccountViaOAuth(alias) {
  * full URL to the browser.
  */
 export async function addAccountViaManualOAuth(alias) {
-    const cfg = await detectCCOAuthConfig();
-    const { codeVerifier, codeChallenge } = generatePKCE();
-    // 32-byte state — same constraint as the auto flow. See dario#71.
-    const state = base64url(randomBytes(32));
-    const authUrl = buildManualAuthorizeUrl(cfg, codeChallenge, state);
+    const { authorizeUrl, codeVerifier, state } = await startAddAccount(alias);
     console.log('');
     console.log(`  Open this URL in any browser to add account "${alias}":`);
     console.log('');
-    console.log(`    ${authUrl}`);
+    console.log(`    ${authorizeUrl}`);
     console.log('');
     console.log('  Sign in with the Claude account you want to add. After you approve,');
     console.log('  Anthropic will display an authorization code. Paste it below');
@@ -351,6 +347,39 @@ export async function addAccountViaManualOAuth(alias) {
     if (returnedState && returnedState !== state) {
         throw new Error(`State mismatch — the pasted code is from a different login attempt. Re-run \`dario accounts add ${alias} --manual\` and paste the most recent code.`);
     }
+    return completeAddAccount(alias, code, codeVerifier, state);
+}
+/**
+ * Non-interactive first half of the manual add-account flow (#599): validate
+ * the alias, generate PKCE + state, and build the authorize URL the user opens
+ * in a browser. The caller keeps `codeVerifier` + `state` and passes them back
+ * to `completeAddAccount` after the user supplies the displayed code. Shared by
+ * the `dario accounts add --manual` CLI and the headless admin API — the secret
+ * (codeVerifier) never leaves the process that started the flow.
+ */
+export async function startAddAccount(alias) {
+    if (!safeAliasPath(alias)) {
+        throw new Error(`invalid account alias "${alias}" (allowed: letters, digits, _-. — up to 64 chars, no path separators)`);
+    }
+    const cfg = await detectCCOAuthConfig();
+    const { codeVerifier, codeChallenge } = generatePKCE();
+    // 32-byte state — same constraint as the auto flow. See dario#71.
+    const state = base64url(randomBytes(32));
+    const authorizeUrl = buildManualAuthorizeUrl(cfg, codeChallenge, state);
+    return { authorizeUrl, codeVerifier, state };
+}
+/**
+ * Non-interactive second half (#599): exchange the authorization `code` for
+ * tokens (PKCE-verified server-side), attach a device/account identity, and
+ * persist the account to `~/.dario/accounts/<alias>.json`. Throws — with any
+ * upstream secrets redacted — on a failed exchange. Shared by the CLI and the
+ * admin API.
+ */
+export async function completeAddAccount(alias, code, codeVerifier, state) {
+    if (!safeAliasPath(alias)) {
+        throw new Error(`invalid account alias "${alias}"`);
+    }
+    const cfg = await detectCCOAuthConfig();
     const tokenRes = await fetch(cfg.tokenUrl, {
         method: 'POST',
         headers: { 'Content-Type': 'application/json' },

package/dist/admin-api.d.ts

@@ -0,0 +1,40 @@
+/**
+ * Headless admin API (#599) — an opt-in HTTP control plane for managing the
+ * account pool without console access. Mounted at `/admin/*` by the proxy
+ * (src/proxy.ts) ONLY when `DARIO_ADMIN=1`.
+ *
+ * Endpoints (all require the admin bearer token — `DARIO_ADMIN_TOKEN`, or
+ * `DARIO_API_KEY` as a fallback — even on loopback, since they add/remove
+ * OAuth credentials):
+ *
+ *   POST   /admin/login/start     { alias }            -> { login_id, authorize_url, expires_at }
+ *   POST   /admin/login/complete  { login_id, code }   -> { alias, status, expires_at }
+ *   GET    /admin/accounts                              -> { accounts: [...], count }
+ *   DELETE /admin/accounts/<alias>                      -> { alias, removed }
+ *
+ * The login flow mirrors `dario accounts add --manual` (PKCE + manual paste):
+ * `/start` returns the authorize URL the operator opens in a browser; they POST
+ * the code Anthropic displays back to `/complete`. The PKCE verifier + state
+ * live in an in-memory map keyed by `login_id` with a short TTL — never on
+ * disk, never returned to the client, single-use.
+ *
+ * Account changes take effect on the next proxy restart (the pool is built at
+ * startup, src/proxy.ts). Hot-reload of a running pool is a deliberate
+ * follow-up — keeping this surface small while it manipulates credentials.
+ */
+import type { IncomingMessage, ServerResponse } from 'node:http';
+export interface AdminDeps {
+    /** Admin bearer token buffer; `null` = enabled but no token configured (fail closed). */
+    adminTokenBuf: Buffer | null;
+    /** Invoked after an account is added or removed (e.g. to log / signal a reload). */
+    onAccountsChanged?: () => void;
+}
+/**
+ * Handle an `/admin/*` request. Returns `true` if it owned the request (matched
+ * one of its routes and wrote a response), `false` if the path isn't one of
+ * ours — so the caller's existing routing (incl. the pre-existing
+ * `/admin/resume`) and the `DARIO_API_KEY` gate still run.
+ */
+export declare function handleAdminRequest(req: IncomingMessage, res: ServerResponse, urlPath: string, deps: AdminDeps): Promise<boolean>;
+/** Test-only: clear the pending-login map between cases. */
+export declare function _resetAdminStateForTest(): void;

package/dist/admin-api.js

@@ -0,0 +1,199 @@
+import { randomUUID, timingSafeEqual } from 'node:crypto';
+import { startAddAccount, completeAddAccount, removeAccount, listAccountAliases, loadAccount, } from './accounts.js';
+import { parseManualPaste } from './oauth.js';
+const PENDING_TTL_MS = 10 * 60_000;
+const MAX_PENDING = 64; // backstop against unbounded growth from repeated /start
+const ACCOUNTS_PREFIX = '/admin/accounts/';
+const pendingLogins = new Map();
+function prunePending(now) {
+    for (const [id, p] of pendingLogins) {
+        if (p.expiresAt <= now)
+            pendingLogins.delete(id);
+    }
+}
+const HEADERS = {
+    'Content-Type': 'application/json',
+    'X-Content-Type-Options': 'nosniff',
+    'Cache-Control': 'no-store',
+};
+function send(res, status, body) {
+    res.writeHead(status, HEADERS);
+    res.end(JSON.stringify(body));
+}
+/** Constant-time bearer / x-api-key check. Fails closed when no token configured. */
+function adminAuthOk(req, tokenBuf) {
+    if (!tokenBuf)
+        return false;
+    const provided = req.headers['x-api-key']
+        || req.headers.authorization?.replace(/^Bearer\s+/i, '');
+    if (!provided)
+        return false;
+    const providedBuf = Buffer.from(provided);
+    if (providedBuf.length !== tokenBuf.length)
+        return false;
+    return timingSafeEqual(providedBuf, tokenBuf);
+}
+async function readJsonBody(req, limitBytes = 64 * 1024) {
+    return new Promise((resolve, reject) => {
+        const chunks = [];
+        let size = 0;
+        req.on('data', (c) => {
+            size += c.length;
+            if (size > limitBytes) {
+                req.destroy();
+                reject(new Error('request body too large'));
+                return;
+            }
+            chunks.push(c);
+        });
+        req.on('end', () => {
+            const raw = Buffer.concat(chunks).toString('utf-8').trim();
+            if (!raw) {
+                resolve({});
+                return;
+            }
+            try {
+                resolve(JSON.parse(raw));
+            }
+            catch {
+                reject(new Error('invalid JSON body'));
+            }
+        });
+        req.on('error', reject);
+    });
+}
+/**
+ * Handle an `/admin/*` request. Returns `true` if it owned the request (matched
+ * one of its routes and wrote a response), `false` if the path isn't one of
+ * ours — so the caller's existing routing (incl. the pre-existing
+ * `/admin/resume`) and the `DARIO_API_KEY` gate still run.
+ */
+export async function handleAdminRequest(req, res, urlPath, deps) {
+    const method = req.method ?? 'GET';
+    const isAccountDelete = method === 'DELETE' && urlPath.startsWith(ACCOUNTS_PREFIX) && urlPath.length > ACCOUNTS_PREFIX.length;
+    const known = urlPath === '/admin/login/start' ||
+        urlPath === '/admin/login/complete' ||
+        urlPath === '/admin/accounts' ||
+        isAccountDelete;
+    if (!known)
+        return false;
+    // Auth — always required, even on loopback (these mutate OAuth credentials).
+    if (!adminAuthOk(req, deps.adminTokenBuf)) {
+        if (!deps.adminTokenBuf) {
+            send(res, 403, { error: 'admin API enabled but no token configured — set DARIO_ADMIN_TOKEN (or DARIO_API_KEY)' });
+        }
+        else {
+            send(res, 401, { error: 'Unauthorized', message: 'invalid or missing admin token' });
+        }
+        return true;
+    }
+    const now = Date.now();
+    prunePending(now);
+    try {
+        // POST /admin/login/start  { alias }
+        if (urlPath === '/admin/login/start') {
+            if (method !== 'POST') {
+                send(res, 405, { error: 'Method not allowed (use POST)' });
+                return true;
+            }
+            const body = await readJsonBody(req);
+            const alias = typeof body.alias === 'string' ? body.alias.trim() : '';
+            if (!alias) {
+                send(res, 400, { error: 'missing "alias"' });
+                return true;
+            }
+            if (pendingLogins.size >= MAX_PENDING) {
+                send(res, 429, { error: 'too many pending logins; complete or wait for one to expire' });
+                return true;
+            }
+            const { authorizeUrl, codeVerifier, state } = await startAddAccount(alias); // throws on invalid alias
+            const loginId = randomUUID();
+            const expiresAt = now + PENDING_TTL_MS;
+            pendingLogins.set(loginId, { alias, codeVerifier, state, expiresAt });
+            send(res, 200, {
+                login_id: loginId,
+                authorize_url: authorizeUrl,
+                expires_at: new Date(expiresAt).toISOString(),
+                instructions: 'Open authorize_url, approve, then POST the displayed code to /admin/login/complete with this login_id.',
+            });
+            return true;
+        }
+        // POST /admin/login/complete  { login_id, code }
+        if (urlPath === '/admin/login/complete') {
+            if (method !== 'POST') {
+                send(res, 405, { error: 'Method not allowed (use POST)' });
+                return true;
+            }
+            const body = await readJsonBody(req);
+            const loginId = typeof body.login_id === 'string' ? body.login_id : '';
+            const rawCode = typeof body.code === 'string' ? body.code : '';
+            if (!loginId || !rawCode) {
+                send(res, 400, { error: 'missing "login_id" or "code"' });
+                return true;
+            }
+            const p = pendingLogins.get(loginId);
+            if (!p || p.expiresAt <= now) {
+                pendingLogins.delete(loginId);
+                send(res, 410, { error: 'login_id unknown or expired — start a new login' });
+                return true;
+            }
+            // Accept "code#state" or a bare code; verify the embedded state if present.
+            const { code, state: pastedState } = parseManualPaste(rawCode);
+            if (!code) {
+                send(res, 400, { error: 'no authorization code found in "code"' });
+                return true;
+            }
+            if (pastedState && pastedState !== p.state) {
+                send(res, 400, { error: 'state mismatch — code is from a different login attempt' });
+                return true;
+            }
+            pendingLogins.delete(loginId); // single-use, regardless of exchange outcome
+            const creds = await completeAddAccount(p.alias, code, p.codeVerifier, p.state);
+            deps.onAccountsChanged?.();
+            send(res, 200, { alias: creds.alias, status: 'added', expires_at: new Date(creds.expiresAt).toISOString() });
+            return true;
+        }
+        // GET /admin/accounts
+        if (urlPath === '/admin/accounts') {
+            if (method !== 'GET') {
+                send(res, 405, { error: 'Method not allowed (use GET)' });
+                return true;
+            }
+            const aliases = await listAccountAliases();
+            const accounts = (await Promise.all(aliases.map(async (alias) => {
+                const a = await loadAccount(alias);
+                if (!a)
+                    return null;
+                return { alias: a.alias, scopes: a.scopes, expires_in_ms: Math.max(0, a.expiresAt - now) };
+            }))).filter((a) => a !== null);
+            send(res, 200, {
+                accounts,
+                count: accounts.length,
+                note: 'live rate-limit / utilization is at GET /accounts when pool mode is active',
+            });
+            return true;
+        }
+        // DELETE /admin/accounts/<alias>
+        if (isAccountDelete) {
+            const alias = decodeURIComponent(urlPath.slice(ACCOUNTS_PREFIX.length));
+            const removed = await removeAccount(alias); // validates alias internally
+            if (removed)
+                deps.onAccountsChanged?.();
+            send(res, removed ? 200 : 404, { alias, removed });
+            return true;
+        }
+        send(res, 405, { error: 'Method not allowed' });
+        return true;
+    }
+    catch (err) {
+        // startAddAccount throws on an invalid alias; completeAddAccount throws
+        // (with secrets redacted) on a failed token exchange; readJsonBody throws
+        // on oversized / malformed bodies.
+        send(res, 400, { error: err.message });
+        return true;
+    }
+}
+/** Test-only: clear the pending-login map between cases. */
+export function _resetAdminStateForTest() {
+    pendingLogins.clear();
+}

package/dist/proxy.js

@@ -16,6 +16,7 @@ import { Analytics, billingBucketFromClaim } from './analytics.js';
 import { OverageGuard, buildHaltErrorBody } from './overage-guard.js';
 import { notify as osNotify } from './notify.js';
 import { loadAllAccounts, loadAccount, refreshAccountToken, resyncLoginFromCredentialsIfStale } from './accounts.js';
+import { handleAdminRequest } from './admin-api.js';
 import { getOpenAIBackend, isOpenAIModel, forwardToOpenAI } from './openai-backend.js';
 import { RequestQueue, QueueFullError, QueueTimeoutError, DEFAULT_MAX_CONCURRENT, DEFAULT_MAX_QUEUED, DEFAULT_QUEUE_TIMEOUT_MS } from './request-queue.js';
 import { redactSecrets } from './redact.js';
@@ -1115,6 +1116,17 @@ export async function startProxy(opts = {}) {
     // Optional proxy authentication — pre-encode key buffer for performance
     const apiKey = process.env.DARIO_API_KEY;
     const apiKeyBuf = apiKey ? Buffer.from(apiKey) : null;
+    // Admin API (#599) — opt-in headless account management at /admin/*. Off
+    // unless DARIO_ADMIN=1. Auth is ALWAYS required (even on loopback) because
+    // these endpoints add/remove OAuth accounts: the admin token is
+    // DARIO_ADMIN_TOKEN, falling back to DARIO_API_KEY. Enabled-but-tokenless
+    // fails closed (403) so account control is never left open on loopback.
+    const adminEnabled = process.env.DARIO_ADMIN === '1';
+    const adminToken = process.env.DARIO_ADMIN_TOKEN || process.env.DARIO_API_KEY || '';
+    const adminTokenBuf = adminToken ? Buffer.from(adminToken) : null;
+    if (adminEnabled) {
+        console.log(`[dario] admin API enabled at /admin/* (token ${adminTokenBuf ? 'configured' : 'MISSING — endpoints return 403 until DARIO_ADMIN_TOKEN is set'})`);
+    }
     // CORS origin defaults to the localhost URL the proxy is served at. Users
     // binding to a non-loopback address (e.g. a Tailscale interface) can
     // override via DARIO_CORS_ORIGIN — otherwise browser-based clients hitting
@@ -1179,6 +1191,23 @@ export async function startProxy(opts = {}) {
             res.end(JSON.stringify(body));
             return;
         }
+        // Admin API (#599) — self-authenticating with the admin token, mounted
+        // BEFORE the DARIO_API_KEY gate so it requires its own token even on
+        // loopback (where the proxy key is otherwise optional). handleAdminRequest
+        // only acts on its own routes (/admin/login/*, /admin/accounts) and returns
+        // false otherwise, so the pre-existing /admin/resume + the key gate below
+        // still apply unchanged.
+        if (adminEnabled && urlPath.startsWith('/admin/')) {
+            const handled = await handleAdminRequest(req, res, urlPath, {
+                adminTokenBuf,
+                onAccountsChanged: () => {
+                    if (verbose)
+                        console.log('[dario] admin: account pool changed on disk (effective on next proxy restart)');
+                },
+            });
+            if (handled)
+                return;
+        }
         if (!checkAuth(req)) {
             if (verbose) {
                 // Silent auth rejects are hard to diagnose when a client's config

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@askalf/dario",
-  "version": "4.8.105",
+  "version": "4.8.106",
   "description": "Use your Claude Pro/Max subscription in any tool — Cursor, Cline, Aider, the Agent SDK, your scripts — at subscription pricing, not per-token API bills. One local Anthropic + OpenAI-compatible endpoint.",
   "type": "module",
   "bin": {