nansen-cli 1.46.0 → 2.0.1
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/CHANGELOG.md +122 -0
- package/README.md +157 -14
- package/docs/browser-login.md +123 -0
- package/package.json +11 -2
- package/scripts/postinstall.js +35 -30
- package/skills/nansen-agent-guide/SKILL.md +13 -2
- package/skills/nansen-alerts-webhook-listener/SKILL.md +5 -2
- package/skills/nansen-dca-tracker/SKILL.md +10 -2
- package/skills/nansen-defi-positions/SKILL.md +5 -2
- package/skills/nansen-exit-signals/SKILL.md +10 -2
- package/skills/nansen-fund-tracker/SKILL.md +10 -2
- package/skills/nansen-general-search/SKILL.md +10 -2
- package/skills/nansen-holder-analysis/SKILL.md +10 -2
- package/skills/nansen-limit-orders/SKILL.md +6 -3
- package/skills/nansen-perp-screener/SKILL.md +10 -2
- package/skills/nansen-perp-trader-profile/SKILL.md +10 -2
- package/skills/nansen-polymarket-deep-dive/SKILL.md +10 -2
- package/skills/nansen-polymarket-insider-scan/SKILL.md +10 -2
- package/skills/nansen-polymarket-trader-profile/SKILL.md +10 -2
- package/skills/nansen-portfolio-tracker/SKILL.md +10 -2
- package/skills/nansen-prediction-markets/SKILL.md +10 -2
- package/skills/nansen-sm-cross-chain-flows/SKILL.md +10 -2
- package/skills/nansen-smart-alerts/SKILL.md +9 -4
- package/skills/nansen-smart-money-alpha/SKILL.md +10 -2
- package/skills/nansen-smart-money-tracker/SKILL.md +10 -2
- package/skills/nansen-smart-money-trend/SKILL.md +10 -2
- package/skills/nansen-token-research/SKILL.md +10 -2
- package/skills/nansen-token-screener/SKILL.md +14 -4
- package/skills/nansen-token-transfer-analysis/SKILL.md +10 -2
- package/skills/nansen-trading/SKILL.md +8 -2
- package/skills/nansen-wallet-batch/SKILL.md +10 -2
- package/skills/nansen-wallet-clustering/SKILL.md +10 -2
- package/skills/nansen-wallet-deep-dive/SKILL.md +10 -2
- package/skills/nansen-wallet-keychain-migration/SKILL.md +5 -2
- package/skills/nansen-wallet-manager/SKILL.md +11 -9
- package/skills/nansen-wallet-profiler/SKILL.md +10 -2
- package/skills/nansen-web-fetcher/SKILL.md +5 -2
- package/skills/nansen-web-searcher/SKILL.md +5 -2
- package/src/api.js +202 -104
- package/src/auth-browser.js +16 -0
- package/src/auth-credentials.js +73 -0
- package/src/auth-device.js +242 -0
- package/src/auth-key-input.js +46 -0
- package/src/auth-login.js +89 -0
- package/src/auth-state.js +487 -0
- package/src/auth-store-native.js +20 -0
- package/src/auth-store-worker.js +64 -0
- package/src/auth-store.js +140 -0
- package/src/auto-paginate.js +288 -0
- package/src/bridge.js +126 -21
- package/src/cache-inspect.js +345 -0
- package/src/cli.js +473 -199
- package/src/commands/agent.js +15 -7
- package/src/commands/completion.js +2 -15
- package/src/commands/mcp.js +20 -18
- package/src/cost-cache.js +16 -2
- package/src/debug.js +348 -0
- package/src/doctor.js +22 -45
- package/src/hl-action.js +41 -13
- package/src/limit-order.js +1 -1
- package/src/mcp-client-config.js +169 -0
- package/src/mcp-client-config.json +17 -0
- package/src/mcp-verify.js +6 -5
- package/src/perp.js +41 -0
- package/src/privy.js +12 -12
- package/src/response-meta.js +56 -1
- package/src/rpc-urls.js +9 -11
- package/src/schema.json +185 -8
- package/src/semver.js +23 -4
- package/src/swap-simulation.js +35 -30
- package/src/telemetry.js +20 -0
- package/src/trading.js +266 -29
- package/src/transfer.js +53 -6
- package/src/update-check.js +9 -1
- package/src/wallet.js +107 -17
- package/src/walletconnect-trading.js +24 -5
- package/src/x402-svm.js +123 -64
- package/src/x402.js +46 -14
|
@@ -0,0 +1,73 @@
|
|
|
1
|
+
import fs from 'node:fs';
|
|
2
|
+
import path from 'node:path';
|
|
3
|
+
import os from 'node:os';
|
|
4
|
+
import { fileURLToPath } from 'node:url';
|
|
5
|
+
|
|
6
|
+
export const DEFAULT_API_ORIGIN = 'https://api.nansen.ai';
|
|
7
|
+
const DEV_CONFIG = fileURLToPath(new URL('../config.json', import.meta.url));
|
|
8
|
+
export class AuthError extends Error {
|
|
9
|
+
constructor(code, message) { super(message); this.code = code; }
|
|
10
|
+
}
|
|
11
|
+
export function authDirectory(env = process.env) {
|
|
12
|
+
let home = env.HOME || env.USERPROFILE;
|
|
13
|
+
try { home ||= os.homedir(); } catch { /* use the fixed actionable error below */ }
|
|
14
|
+
if (typeof home !== 'string' || !path.isAbsolute(home)) throw new AuthError('AUTH_HOME_UNAVAILABLE', 'Cannot locate an absolute home directory for authentication. Set HOME or USERPROFILE before using nansen.');
|
|
15
|
+
return path.join(home, '.nansen');
|
|
16
|
+
}
|
|
17
|
+
export function trustedIssuer(audience) {
|
|
18
|
+
const issuer = {
|
|
19
|
+
'https://api.nansen.ai': 'https://idp.nansen.ai',
|
|
20
|
+
'https://api.banansen.dev': 'https://idp.banansen.dev',
|
|
21
|
+
}[audience];
|
|
22
|
+
if (!issuer) throw new AuthError('AUTH_ORIGIN_UNSUPPORTED', 'Browser sessions require the Nansen production or staging API origin. Check the selected origin in NANSEN_BASE_URL or config.json baseUrl; plain login preserves it.');
|
|
23
|
+
return issuer;
|
|
24
|
+
}
|
|
25
|
+
export function validAuthPointer(auth) {
|
|
26
|
+
if (!auth || ![1, 2].includes(auth.version) || !['none', 'api-key', 'session'].includes(auth.active?.kind)) return false;
|
|
27
|
+
if (auth.version === 1) return true; // Preserve the pre-renewal reader's format contract.
|
|
28
|
+
if (auth.version === 2 && (typeof auth.selectionEpoch !== 'string' || !/^[a-f0-9-]{36}$/.test(auth.selectionEpoch))) return false;
|
|
29
|
+
return auth.active.kind !== 'session' || (typeof auth.active.generation === 'string' && /^[a-f0-9-]{36}$/.test(auth.active.generation) &&
|
|
30
|
+
typeof auth.selectionEpoch === 'string' && /^[a-f0-9-]{36}$/.test(auth.selectionEpoch) &&
|
|
31
|
+
['issuer', 'audience', 'accountId'].every(k => typeof auth.active[k] === 'string' && auth.active[k].length > 0 && auth.active[k].length <= 255) && Number.isFinite(auth.active.expiresAt));
|
|
32
|
+
}
|
|
33
|
+
export function readAuthConfig(env = process.env, devConfigPath = DEV_CONFIG) {
|
|
34
|
+
const userPath = path.join(authDirectory(env), 'config.json');
|
|
35
|
+
const configPath = fs.existsSync(userPath) ? userPath : fs.existsSync(devConfigPath) ? devConfigPath : null;
|
|
36
|
+
let config = {};
|
|
37
|
+
let configError = null;
|
|
38
|
+
if (configPath) {
|
|
39
|
+
try {
|
|
40
|
+
config = JSON.parse(fs.readFileSync(configPath, 'utf8'));
|
|
41
|
+
if (!config || typeof config !== 'object' || Array.isArray(config)) throw new Error();
|
|
42
|
+
} catch (err) { config = {}; configError = err instanceof SyntaxError ? 'parse' : 'unreadable'; }
|
|
43
|
+
}
|
|
44
|
+
if (config.auth && !validAuthPointer(config.auth)) configError = 'format';
|
|
45
|
+
return { config, configPath, configError, configFileExists: fs.existsSync(userPath), devConfigPath };
|
|
46
|
+
}
|
|
47
|
+
export function resolveCredential({ env = process.env, explicitKey, snapshot = readAuthConfig(env) } = {}) {
|
|
48
|
+
if (explicitKey !== undefined) return explicitKey === null ? { kind: 'anonymous', source: null } : { kind: 'api-key', source: 'explicit', apiKey: explicitKey };
|
|
49
|
+
if (typeof env.NANSEN_API_KEY === 'string' && env.NANSEN_API_KEY.trim()) return { kind: 'api-key', source: 'env', apiKey: env.NANSEN_API_KEY };
|
|
50
|
+
if (snapshot.configError) return { kind: 'invalid', source: 'config', error: snapshot.configError };
|
|
51
|
+
const { config } = snapshot;
|
|
52
|
+
if (config.auth?.active?.kind === 'session') return { kind: 'session', source: 'session', ...config.auth.active, selectionEpoch: config.auth.selectionEpoch };
|
|
53
|
+
if (config.auth?.active?.kind === 'none') return { kind: 'anonymous', source: null };
|
|
54
|
+
if (config.apiKey !== undefined && config.apiKey !== null) return { kind: 'api-key', source: snapshot.configPath === snapshot.devConfigPath ? 'dev-config' : 'config', apiKey: config.apiKey };
|
|
55
|
+
if (config.auth?.active?.kind === 'api-key') return { kind: 'invalid', source: 'config' };
|
|
56
|
+
return { kind: 'anonymous', source: null };
|
|
57
|
+
}
|
|
58
|
+
export function assertUsableSelection(selection) {
|
|
59
|
+
if (selection.kind === 'invalid') throw new AuthError('AUTH_STATE_INVALID', 'Saved authentication is unreadable. Restore config.json or run nansen logout after repairing its permissions.');
|
|
60
|
+
if (selection.kind === 'api-key' && (typeof selection.apiKey !== 'string' || !selection.apiKey.trim())) throw new AuthError('INVALID_API_KEY', 'The selected API key is empty or invalid. Correct it or unset NANSEN_API_KEY.');
|
|
61
|
+
}
|
|
62
|
+
export function authConfigView(env = process.env, devConfigPath) {
|
|
63
|
+
const snapshot = readAuthConfig(env, devConfigPath);
|
|
64
|
+
const selected = resolveCredential({ env, snapshot });
|
|
65
|
+
return {
|
|
66
|
+
...snapshot,
|
|
67
|
+
apiKey: selected.kind === 'api-key' ? selected.apiKey : null,
|
|
68
|
+
apiKeySource: selected.kind === 'api-key' ? selected.source : null,
|
|
69
|
+
selected,
|
|
70
|
+
baseUrl: env.NANSEN_BASE_URL || snapshot.config.baseUrl || DEFAULT_API_ORIGIN,
|
|
71
|
+
baseUrlSource: env.NANSEN_BASE_URL ? 'env' : snapshot.config.baseUrl ? 'config' : 'default',
|
|
72
|
+
};
|
|
73
|
+
}
|
|
@@ -0,0 +1,242 @@
|
|
|
1
|
+
import { generateKeyPairSync, createPrivateKey, createPublicKey, createHash, randomUUID, sign } from 'node:crypto';
|
|
2
|
+
import { setTimeout as delay } from 'node:timers/promises';
|
|
3
|
+
import { AsyncLocalStorage } from 'node:async_hooks';
|
|
4
|
+
import { channel } from 'node:diagnostics_channel';
|
|
5
|
+
import { isIP } from 'node:net';
|
|
6
|
+
import { AuthError, trustedIssuer } from './auth-credentials.js';
|
|
7
|
+
|
|
8
|
+
const encode = value => Buffer.from(JSON.stringify(value)).toString('base64url');
|
|
9
|
+
export function createDeviceKey() {
|
|
10
|
+
return generateKeyPairSync('ec', { namedCurve: 'prime256v1' }).privateKey.export({ format: 'jwk' });
|
|
11
|
+
}
|
|
12
|
+
export function deviceProof(privateJwk, url, nonce, now = Date.now()) {
|
|
13
|
+
const key = createPrivateKey({ key: privateJwk, format: 'jwk' });
|
|
14
|
+
const jwk = createPublicKey(key).export({ format: 'jwk' });
|
|
15
|
+
const input = `${encode({ typ: 'dpop+jwt', alg: 'ES256', jwk })}.${encode({ htm: 'POST', htu: url, jti: randomUUID(), iat: Math.floor(now / 1000), ...(nonce && { nonce }) })}`;
|
|
16
|
+
return `${input}.${sign('sha256', Buffer.from(input), { key, dsaEncoding: 'ieee-p1363' }).toString('base64url')}`;
|
|
17
|
+
}
|
|
18
|
+
const lifetimeError = () => new AuthError('BROWSER_SESSION_SETUP_REQUIRED', 'The issuer returned a session lifetime above the supported 3600 seconds. Ask the session operator to reconcile issuer lifetime configuration and CLI compatibility before pairing again.');
|
|
19
|
+
const transportError = () => new AuthError('AUTH_NETWORK_ERROR', 'Authentication service unavailable or timed out. Retry later. If token issuance completed but its response was lost, run nansen login again; remote cleanup may be unconfirmed.');
|
|
20
|
+
// Only native Undici lifecycle evidence for this exact invocation can establish
|
|
21
|
+
// a pre-connection failure. Proxy CONNECTs, retries, wrappers without evidence,
|
|
22
|
+
// response-body errors and arbitrary injected cause codes remain ambiguous.
|
|
23
|
+
const dispatchScope = new AsyncLocalStorage();
|
|
24
|
+
const connectionFailures = new WeakSet();
|
|
25
|
+
async function fetchWithDispatchEvidence(fetchFn, url, options) {
|
|
26
|
+
const scope = {}; const requests = new Map();
|
|
27
|
+
const created = ({ request }) => { if (dispatchScope.getStore() === scope) requests.set(request, { sent: false }); };
|
|
28
|
+
const sent = ({ request }) => { if (requests.has(request)) requests.get(request).sent = true; };
|
|
29
|
+
const failed = ({ request, error }) => { if (requests.has(request)) requests.get(request).error = error; };
|
|
30
|
+
const listeners = [['undici:request:create', created], ['undici:client:sendHeaders', sent], ['undici:request:error', failed]];
|
|
31
|
+
for (const [name, listener] of listeners) channel(name).subscribe(listener);
|
|
32
|
+
try { return await dispatchScope.run(scope, () => fetchFn(url, options)); }
|
|
33
|
+
catch (error) {
|
|
34
|
+
const target = new URL(url); const [entry] = requests;
|
|
35
|
+
const [request, outcome] = entry || [];
|
|
36
|
+
const cause = error?.cause;
|
|
37
|
+
const direct = requests.size === 1 && request.origin === target.origin && request.path === target.pathname && request.method === 'POST' && !outcome.sent && outcome.error === cause;
|
|
38
|
+
const lookup = ['ENOTFOUND', 'EAI_AGAIN'].includes(cause?.code) && cause.syscall === 'getaddrinfo' && cause.hostname === target.hostname;
|
|
39
|
+
const refused = cause?.code === 'ECONNREFUSED' && cause.syscall === 'connect' && isIP(cause.address || '') && cause.port === Number(target.port || (target.protocol === 'https:' ? 443 : 80));
|
|
40
|
+
if (direct && error instanceof TypeError && error.message === 'fetch failed' && cause instanceof Error && Number.isInteger(cause.errno) && (lookup || refused)) {
|
|
41
|
+
const failure = new AuthError('AUTH_CONNECT_UNAVAILABLE', 'Could not establish a connection to the authentication service. Check connectivity and retry later.');
|
|
42
|
+
connectionFailures.add(failure); throw failure;
|
|
43
|
+
}
|
|
44
|
+
throw error;
|
|
45
|
+
} finally { for (const [name, listener] of listeners) channel(name).unsubscribe(listener); }
|
|
46
|
+
}
|
|
47
|
+
async function readResponse(response) {
|
|
48
|
+
// Read incrementally: never buffer an unbounded credential-bearing response.
|
|
49
|
+
if (!response.body?.getReader) return response.json(); // injected test transports
|
|
50
|
+
const reader = response.body.getReader();
|
|
51
|
+
const chunks = [];
|
|
52
|
+
let length = 0;
|
|
53
|
+
try {
|
|
54
|
+
while (true) {
|
|
55
|
+
const { done, value } = await reader.read();
|
|
56
|
+
if (done) break;
|
|
57
|
+
length += value.length;
|
|
58
|
+
if (length > 32768) { await reader.cancel(); throw new Error(); }
|
|
59
|
+
chunks.push(value);
|
|
60
|
+
}
|
|
61
|
+
return JSON.parse(Buffer.concat(chunks).toString());
|
|
62
|
+
} finally { reader.releaseLock(); }
|
|
63
|
+
}
|
|
64
|
+
export function createDeviceClient({ audience, privateJwk = createDeviceKey(), fetchFn = globalThis.fetch, now = Date.now } = {}) {
|
|
65
|
+
const issuer = trustedIssuer(audience);
|
|
66
|
+
let nonce;
|
|
67
|
+
async function request(route, body, signal, timeout = 15000) {
|
|
68
|
+
const deadline = performance.now() + timeout;
|
|
69
|
+
for (let attempt = 0; attempt < 2; attempt++) {
|
|
70
|
+
signal?.throwIfAborted();
|
|
71
|
+
if (performance.now() >= deadline) throw transportError();
|
|
72
|
+
const controller = new AbortController();
|
|
73
|
+
const abort = () => controller.abort();
|
|
74
|
+
signal?.addEventListener('abort', abort, { once: true });
|
|
75
|
+
const timer = setTimeout(abort, Math.max(1, deadline - performance.now()));
|
|
76
|
+
try {
|
|
77
|
+
const url = issuer + route;
|
|
78
|
+
const response = await fetchWithDispatchEvidence(fetchFn, url, { method: 'POST', redirect: 'error', signal: controller.signal, headers: { 'Content-Type': 'application/json', DPoP: deviceProof(privateJwk, url, nonce, now()) }, body: JSON.stringify(body) });
|
|
79
|
+
const data = await readResponse(response);
|
|
80
|
+
const nextNonce = response.headers.get('dpop-nonce');
|
|
81
|
+
if (nextNonce && nextNonce.length <= 1024) nonce = nextNonce;
|
|
82
|
+
if (response.status === 401 && data?.error === 'use_dpop_nonce' && nextNonce && nextNonce.length <= 1024 && attempt === 0) continue;
|
|
83
|
+
return { response, data };
|
|
84
|
+
} catch (error) {
|
|
85
|
+
signal?.throwIfAborted();
|
|
86
|
+
if (connectionFailures.has(error)) throw error;
|
|
87
|
+
throw transportError();
|
|
88
|
+
} finally { clearTimeout(timer); signal?.removeEventListener('abort', abort); }
|
|
89
|
+
}
|
|
90
|
+
}
|
|
91
|
+
return {
|
|
92
|
+
issuer, audience, privateJwk, request,
|
|
93
|
+
async verify(accessToken, signal) {
|
|
94
|
+
const controller = new AbortController();
|
|
95
|
+
const abort = () => controller.abort();
|
|
96
|
+
signal?.throwIfAborted();
|
|
97
|
+
signal?.addEventListener('abort', abort, { once: true });
|
|
98
|
+
const timer = setTimeout(abort, 15000);
|
|
99
|
+
try {
|
|
100
|
+
const response = await fetchFn(`${audience}/api/v1/account`, { method: 'GET', redirect: 'error', signal: controller.signal, headers: { Authorization: `Bearer ${accessToken}` } });
|
|
101
|
+
if (!response.ok) throw new AuthError(response.status === 401 ? 'INVALID_BROWSER_SESSION' : 'SESSION_VERIFICATION_FAILED', response.status === 401 ? 'The new browser session was rejected. Run nansen login again.' : 'Could not verify the new session. The previous credential is unchanged. Retry later.');
|
|
102
|
+
const data = await readResponse(response);
|
|
103
|
+
if (typeof data.user_id !== 'string' || !data.user_id || data.user_id.length > 255 || [...data.user_id].some(c => c.charCodeAt(0) < 32 || c.charCodeAt(0) === 127)) throw new AuthError('SESSION_VERIFICATION_FAILED', 'Account verification returned an invalid account identity. The previous credential is unchanged.');
|
|
104
|
+
return data.user_id;
|
|
105
|
+
} catch (error) {
|
|
106
|
+
signal?.throwIfAborted();
|
|
107
|
+
if (error instanceof AuthError) throw error;
|
|
108
|
+
throw transportError();
|
|
109
|
+
} finally { clearTimeout(timer); signal?.removeEventListener('abort', abort); }
|
|
110
|
+
},
|
|
111
|
+
};
|
|
112
|
+
}
|
|
113
|
+
export function validateSession(bundle, now = Date.now(), { allowExpired = false } = {}) {
|
|
114
|
+
try {
|
|
115
|
+
if (bundle.issuer !== trustedIssuer(bundle.audience) || bundle.scope !== 'nansen:api' || typeof bundle.refreshToken !== 'string' || !bundle.refreshToken || bundle.refreshToken.length > 4096 || typeof bundle.accessToken !== 'string') throw new Error();
|
|
116
|
+
const [header, payload, signature, extra] = bundle.accessToken.split('.');
|
|
117
|
+
const h = JSON.parse(Buffer.from(header, 'base64url'));
|
|
118
|
+
const claims = JSON.parse(Buffer.from(payload, 'base64url'));
|
|
119
|
+
const publicJwk = createPublicKey(createPrivateKey({ key: bundle.privateJwk, format: 'jwk' })).export({ format: 'jwk' });
|
|
120
|
+
const jkt = createHash('sha256').update(JSON.stringify({ crv: publicJwk.crv, kty: publicJwk.kty, x: publicJwk.x, y: publicJwk.y })).digest('base64url');
|
|
121
|
+
if (extra || !signature || h.alg !== 'ES256' || publicJwk.crv !== 'P-256' || claims.iss !== bundle.issuer || claims.aud !== bundle.audience || claims.scope !== 'nansen:api' || claims.cnf?.jkt !== jkt || !Number.isFinite(claims.exp) || !Number.isFinite(bundle.expiresAt) || bundle.expiresAt > claims.exp * 1000) throw new Error();
|
|
122
|
+
if (claims.session_access_revocation_version !== 1) throw new AuthError('BROWSER_SESSION_SETUP_REQUIRED', "The session lacks supported revocation coverage. Run nansen login again. If this persists, ask support to check the session issuer's API audience and revocation claim.");
|
|
123
|
+
if (!Number.isFinite(claims.iat) || !Number.isFinite(claims.nbf) || claims.exp <= claims.iat || typeof claims.sub !== 'string' || !claims.sub || (bundle.accountId !== undefined && claims.sub !== bundle.accountId)) throw new Error();
|
|
124
|
+
if (claims.exp - claims.iat > 3600) throw lifetimeError();
|
|
125
|
+
if (claims.nbf > now / 1000 + 60) throw new AuthError('SESSION_CLOCK_SKEW', 'Session time is ahead of the local clock. Synchronize system time and check issuer clock configuration before retrying login.');
|
|
126
|
+
if (!allowExpired && bundle.expiresAt <= now) throw new AuthError('SESSION_EXPIRED', 'The browser access token has expired. Check system time and issuer lifetime configuration; run nansen login if renewal cannot recover.');
|
|
127
|
+
} catch (error) {
|
|
128
|
+
if (error instanceof AuthError) throw error;
|
|
129
|
+
throw new AuthError('INVALID_BROWSER_SESSION', 'The selected browser session is invalid. Run: nansen login.');
|
|
130
|
+
}
|
|
131
|
+
}
|
|
132
|
+
export async function pairDevice(client, { signal, onPending, onIssued, onBeforePoll, now = Date.now, wait = (ms, signal) => delay(ms, undefined, { signal }) } = {}) {
|
|
133
|
+
const { response, data } = await client.request('/auth/device/authorize', { audience: client.audience, scope: 'nansen:api', client_label: 'nansen CLI' }, signal);
|
|
134
|
+
if (!response.ok) throw new AuthError('PAIRING_FAILED', 'Could not start browser approval. Retry nansen login later.');
|
|
135
|
+
if (typeof data.device_code !== 'string' || !data.device_code || typeof data.user_code !== 'string' || !/^[A-Za-z0-9-]{4,32}$/.test(data.user_code) || !Number.isFinite(data.expires_in) || data.expires_in <= 0 || data.expires_in > 3600 || !Number.isFinite(data.interval) || data.interval < 1 || data.interval > 600) throw new AuthError('PAIRING_FAILED', 'The pairing service returned an invalid grant. Retry later.');
|
|
136
|
+
const expected = `${client.issuer}/device`;
|
|
137
|
+
const complete = new URL(expected);
|
|
138
|
+
complete.searchParams.set('user_code', data.user_code);
|
|
139
|
+
if (data.verification_uri !== expected || data.verification_uri_complete !== complete.toString()) throw new AuthError('PAIRING_FAILED', 'The pairing service returned an untrusted verification URL.');
|
|
140
|
+
const deadline = now() + data.expires_in * 1000;
|
|
141
|
+
await onPending({ verification_uri: complete.toString(), user_code: data.user_code, expires_at: new Date(deadline).toISOString() });
|
|
142
|
+
let interval = data.interval * 1000;
|
|
143
|
+
let failures = 0;
|
|
144
|
+
let pollInFlight = false;
|
|
145
|
+
try {
|
|
146
|
+
while (now() < deadline) {
|
|
147
|
+
await wait(Math.min(interval, deadline - now()), signal);
|
|
148
|
+
if (now() >= deadline) break;
|
|
149
|
+
let result;
|
|
150
|
+
await onBeforePoll?.();
|
|
151
|
+
signal?.throwIfAborted();
|
|
152
|
+
pollInFlight = true;
|
|
153
|
+
try { result = await client.request('/auth/device/token', { device_code: data.device_code }, signal, Math.min(15000, deadline - now())); }
|
|
154
|
+
catch (error) {
|
|
155
|
+
if (!['AUTH_NETWORK_ERROR', 'AUTH_CONNECT_UNAVAILABLE'].includes(error.code) || ++failures > 2) throw error;
|
|
156
|
+
interval = Math.min(interval * 2, 60000); continue;
|
|
157
|
+
}
|
|
158
|
+
const { response: poll, data: tokens } = result;
|
|
159
|
+
if (poll.ok) {
|
|
160
|
+
const bundle = { issuer: client.issuer, audience: client.audience, privateJwk: client.privateJwk, accessToken: tokens.access_token, refreshToken: tokens.refresh_token, scope: tokens.scope };
|
|
161
|
+
// Retain cleanup authority even if the rest of the issuance is malformed.
|
|
162
|
+
onIssued?.(bundle);
|
|
163
|
+
if (tokens.token_type !== 'Bearer' || !Number.isFinite(tokens.expires_in) || tokens.expires_in <= 0) throw new AuthError('PAIRING_FAILED', 'Invalid token response. Run nansen login again.');
|
|
164
|
+
if (tokens.expires_in > 3600) throw lifetimeError();
|
|
165
|
+
let exp;
|
|
166
|
+
try { exp = JSON.parse(Buffer.from(tokens.access_token.split('.')[1], 'base64url')).exp * 1000; } catch { /* validation below */ }
|
|
167
|
+
if (!Number.isFinite(exp)) throw new AuthError('PAIRING_FAILED', 'Invalid token response. Run nansen login again.');
|
|
168
|
+
bundle.expiresAt = Math.min(now() + tokens.expires_in * 1000, exp);
|
|
169
|
+
validateSession(bundle, now());
|
|
170
|
+
bundle.accountId = await client.verify(bundle.accessToken, signal);
|
|
171
|
+
return bundle;
|
|
172
|
+
}
|
|
173
|
+
const retryAfter = Number(poll.headers.get('retry-after')) * 1000;
|
|
174
|
+
if (poll.status === 429 || poll.status >= 500) {
|
|
175
|
+
if (++failures <= 2) { interval = Math.max(interval * 2, Number.isFinite(retryAfter) ? retryAfter : 0); continue; }
|
|
176
|
+
throw transportError();
|
|
177
|
+
}
|
|
178
|
+
if (poll.status === 400 && tokens.error === 'authorization_pending') { pollInFlight = false; continue; }
|
|
179
|
+
if (poll.status === 400 && tokens.error === 'slow_down') { pollInFlight = false; interval = Math.max(interval + 5000, Number.isFinite(retryAfter) ? retryAfter : 0); continue; }
|
|
180
|
+
if (tokens.error === 'access_denied') throw Object.assign(new AuthError('PAIRING_DENIED', 'Browser approval was denied. The previous credential is unchanged.'), { provenUnissued: failures === 0 });
|
|
181
|
+
if (tokens.error === 'expired_token') break;
|
|
182
|
+
throw new AuthError('PAIRING_FAILED', 'Browser approval could not be redeemed. Run nansen login again.');
|
|
183
|
+
}
|
|
184
|
+
throw Object.assign(new AuthError('PAIRING_EXPIRED', 'The approval code expired or was consumed. Run nansen login again.'), { provenUnissued: failures === 0 });
|
|
185
|
+
} catch (error) {
|
|
186
|
+
// Only this live attempt can prove cancellation before issuance. Never
|
|
187
|
+
// rewrite the durable marker on pending: a later crash stays conservative.
|
|
188
|
+
if (signal?.aborted) error.provenUnissued = failures === 0 && !pollInFlight;
|
|
189
|
+
throw error;
|
|
190
|
+
}
|
|
191
|
+
}
|
|
192
|
+
export async function retireSession(bundle, options = {}) {
|
|
193
|
+
try {
|
|
194
|
+
if (bundle.issuer !== trustedIssuer(bundle.audience) || typeof bundle.refreshToken !== 'string' || !bundle.refreshToken) return { remote: 'unconfirmed' };
|
|
195
|
+
const client = createDeviceClient({ ...options, audience: bundle.audience, privateJwk: bundle.privateJwk });
|
|
196
|
+
const { response, data } = await client.request('/token/revoke', { refresh_token: bundle.refreshToken }, options.signal);
|
|
197
|
+
if (!response.ok || data.refresh_family_revoked !== true) return { remote: 'unconfirmed' };
|
|
198
|
+
if (data.access_revocation?.status === 'recorded' && data.access_revocation.coverage === 'complete_family' && data.access_revocation.propagation === 'pending' && data.access_revocation.version === 1) return { remote: 'recorded_pending' };
|
|
199
|
+
// Only the pinned recorded/pending and legacy refresh-only receipts are
|
|
200
|
+
// supported. An invented access_tokens_revoked:true is not proof of
|
|
201
|
+
// gateway propagation; unknown/future shapes remain unconfirmed.
|
|
202
|
+
if (data.access_tokens_revoked === false) return { remote: 'refresh_only' };
|
|
203
|
+
} catch { /* bounded best effort, never expose transport or proof material */ }
|
|
204
|
+
return { remote: 'unconfirmed' };
|
|
205
|
+
}
|
|
206
|
+
|
|
207
|
+
// Only the owner calls this after durably recording possible consumption.
|
|
208
|
+
export async function refreshSession(bundle, { signal, now = Date.now, fetchFn = globalThis.fetch } = {}) {
|
|
209
|
+
const uncertain = () => new AuthError('SESSION_RENEWAL_UNCERTAIN', 'Session renewal outcome is unknown. Run: nansen login. The saved refresh credential was not retried.');
|
|
210
|
+
const started = now();
|
|
211
|
+
const client = createDeviceClient({ audience: bundle.audience, privateJwk: bundle.privateJwk, now, fetchFn });
|
|
212
|
+
let result;
|
|
213
|
+
try { result = await client.request('/token/refresh', { refresh_token: bundle.refreshToken, audience: bundle.audience }, signal, 20000); }
|
|
214
|
+
catch (error) {
|
|
215
|
+
if (connectionFailures.has(error)) throw Object.assign(new AuthError('SESSION_REFRESH_RETRYABLE', error.message), { retryNotBefore: now() + 1000 });
|
|
216
|
+
throw uncertain();
|
|
217
|
+
}
|
|
218
|
+
const { response, data } = result;
|
|
219
|
+
if (!response.ok) {
|
|
220
|
+
if (response.status === 401 && data?.error === 'invalid_refresh_token') throw new AuthError('SESSION_REFRESH_REJECTED', 'The saved session cannot be renewed. Run: nansen login.');
|
|
221
|
+
if (response.status === 400 && data?.error === 'invalid_request') throw new AuthError('SESSION_REFRESH_PROTOCOL_ERROR', 'The issuer rejected the refresh request format. Check CLI/issuer compatibility with the operator before running nansen login.');
|
|
222
|
+
if ((response.status === 429 && data?.error === 'rate_limited') ||
|
|
223
|
+
(response.status === 401 && ['use_dpop_nonce', 'use_dpop_proof', 'invalid_dpop_proof'].includes(data?.error))) {
|
|
224
|
+
const seconds = Number(response.headers.get('retry-after'));
|
|
225
|
+
throw Object.assign(new AuthError('SESSION_REFRESH_RETRYABLE', 'Session renewal was refused before rotation. Check connectivity and system time, then retry later, or run nansen login to start a new approval.'), {
|
|
226
|
+
retryNotBefore: now() + (Number.isFinite(seconds) && seconds > 0 ? Math.min(seconds, 86400) * 1000 : 1000),
|
|
227
|
+
});
|
|
228
|
+
}
|
|
229
|
+
throw uncertain();
|
|
230
|
+
}
|
|
231
|
+
try {
|
|
232
|
+
if ((data.scope !== undefined && data.scope !== 'nansen:api') || data.token_type !== 'Bearer' || !Number.isFinite(data.expires_in) || data.expires_in <= 0 || data.refresh_token === bundle.refreshToken || data.access_token === bundle.accessToken) throw new Error();
|
|
233
|
+
if (data.expires_in > 3600) throw lifetimeError();
|
|
234
|
+
const exp = JSON.parse(Buffer.from(data.access_token.split('.')[1], 'base64url')).exp * 1000;
|
|
235
|
+
const replacement = { ...bundle, accessToken: data.access_token, refreshToken: data.refresh_token, expiresAt: Math.min(started + data.expires_in * 1000, exp) };
|
|
236
|
+
validateSession(replacement, now());
|
|
237
|
+
return replacement;
|
|
238
|
+
} catch (error) {
|
|
239
|
+
if (error instanceof AuthError && ['BROWSER_SESSION_SETUP_REQUIRED', 'SESSION_CLOCK_SKEW', 'SESSION_EXPIRED'].includes(error.code)) throw error;
|
|
240
|
+
throw uncertain();
|
|
241
|
+
}
|
|
242
|
+
}
|
|
@@ -0,0 +1,46 @@
|
|
|
1
|
+
import { CommandError } from './api.js';
|
|
2
|
+
|
|
3
|
+
const MAX_KEY_BYTES = 4096;
|
|
4
|
+
|
|
5
|
+
function inputError(message, code) {
|
|
6
|
+
return new CommandError(message, code, { error: code, message });
|
|
7
|
+
}
|
|
8
|
+
|
|
9
|
+
// Explicit stdin input keeps secrets out of command arguments and shell history.
|
|
10
|
+
export async function readApiKeyInput(input, isTTY = input.isTTY, { timeoutMs = 30_000 } = {}) {
|
|
11
|
+
if (isTTY) throw inputError('Pipe an API key or redirect a key file into --api-key-stdin. For a hidden terminal prompt, use nansen login --human.', 'NOT_A_PIPE');
|
|
12
|
+
const chunks = [];
|
|
13
|
+
let size = 0;
|
|
14
|
+
const timeoutError = inputError('Timed out reading the API key from stdin. Close the pipe after writing a single key, or redirect a key file.', 'API_KEY_INPUT_TIMEOUT');
|
|
15
|
+
let timer;
|
|
16
|
+
let iterator;
|
|
17
|
+
let exhausted = false;
|
|
18
|
+
const timeout = new Promise((_, reject) => { timer = setTimeout(() => reject(timeoutError), timeoutMs); });
|
|
19
|
+
try {
|
|
20
|
+
iterator = input[Symbol.asyncIterator]();
|
|
21
|
+
while (true) {
|
|
22
|
+
const { done, value } = await Promise.race([iterator.next(), timeout]);
|
|
23
|
+
if (done) { exhausted = true; break; }
|
|
24
|
+
const bytes = Buffer.isBuffer(value) ? value : Buffer.from(value);
|
|
25
|
+
size += bytes.length;
|
|
26
|
+
if (size > MAX_KEY_BYTES) break;
|
|
27
|
+
chunks.push(bytes);
|
|
28
|
+
}
|
|
29
|
+
} catch (error) {
|
|
30
|
+
if (error === timeoutError) throw timeoutError;
|
|
31
|
+
throw inputError('Could not read the API key from stdin. Check the input and try again.', 'API_KEY_INPUT_FAILED');
|
|
32
|
+
} finally {
|
|
33
|
+
clearTimeout(timer);
|
|
34
|
+
try { input.destroy?.(); } catch { /* Never expose input cleanup errors. */ }
|
|
35
|
+
// A pending next() can keep return() pending too. Request finalization,
|
|
36
|
+
// but never let a custom iterator extend the input deadline.
|
|
37
|
+
if (!exhausted) {
|
|
38
|
+
try { Promise.resolve(iterator?.return?.()).catch(() => {}); } catch { /* Preserve the sanitized input error. */ }
|
|
39
|
+
}
|
|
40
|
+
}
|
|
41
|
+
if (size > MAX_KEY_BYTES) throw inputError('API key input exceeds 4096 bytes. Provide a single API key.', 'INVALID_PARAMS');
|
|
42
|
+
const key = Buffer.concat(chunks).toString('utf8').trim();
|
|
43
|
+
if (!key) throw inputError('No API key received on stdin. Pipe a single key or redirect a key file.', 'API_KEY_REQUIRED');
|
|
44
|
+
if (/\s|\ufffd/u.test(key) || [...key].some(char => char.charCodeAt(0) < 32 || char.charCodeAt(0) === 127)) throw inputError('API key input must contain a single key without whitespace or control characters.', 'INVALID_PARAMS');
|
|
45
|
+
return key;
|
|
46
|
+
}
|
|
@@ -0,0 +1,89 @@
|
|
|
1
|
+
import { AuthError, authConfigView } from './auth-credentials.js';
|
|
2
|
+
import { createAuthState } from './auth-state.js';
|
|
3
|
+
import { createDeviceClient, pairDevice, retireSession } from './auth-device.js';
|
|
4
|
+
import { openAuthBrowser } from './auth-browser.js';
|
|
5
|
+
|
|
6
|
+
export function defaultAuthState() { return createAuthState({ retire: retireSession }); }
|
|
7
|
+
export function cleanupMessage(results = []) {
|
|
8
|
+
const messages = [];
|
|
9
|
+
if (results.some(r => r.code === 'AUTH_JOURNAL_INVALID')) messages.push('Authentication recovery cannot safely read auth-operations. Preserve its files and secure-store entries; see docs/browser-login.md#damaged-or-unrecognized-journals before retrying cleanup.');
|
|
10
|
+
if (results.some(r => r.code === 'AUTH_STATE_INVALID')) messages.push('Saved authentication and recovery metadata disagree. Preserve config.json, auth-operations and secure-store entries; contact the session operator before retrying cleanup.');
|
|
11
|
+
if (results.some(r => r.local === 'unrecognized')) messages.push('Unrecognized JSON files remain in auth-operations. They were preserved and not treated as credential journals. See docs/browser-login.md#damaged-or-unrecognized-journals.');
|
|
12
|
+
if (results.some(r => r.local === 'incomplete' && !['AUTH_JOURNAL_INVALID', 'AUTH_STATE_INVALID'].includes(r.code))) messages.push('Secure-store deletion incomplete. Unlock the credential store and run nansen logout to finish cleanup.');
|
|
13
|
+
if (results.some(r => r.local === 'pending')) messages.push('Authentication cleanup remains pending. After other login attempts finish and the credential store is unlocked, rerun nansen logout to process the next bounded batch.');
|
|
14
|
+
if (results.some(r => r.remote === 'unconfirmed')) messages.push('Remote revocation unconfirmed. Contact the session/revocation operator to revoke the affected session; local deselection does not confirm remote invalidation.');
|
|
15
|
+
if (results.some(r => r.remote === 'recorded_pending')) messages.push('Session revoked. Existing access tokens may take a short time to stop working across API servers.');
|
|
16
|
+
if (results.some(r => r.remote === 'refresh_only')) messages.push('Refresh family retired; issued access tokens may remain valid until expiry.');
|
|
17
|
+
return messages;
|
|
18
|
+
}
|
|
19
|
+
export async function browserLogin({ flags = {}, env = process.env, isTTY = process.stdout.isTTY, log = console.log, errorOutput = console.error, state = defaultAuthState(), clientFactory = createDeviceClient, pair = pairDevice, retire = retireSession, openBrowser = openAuthBrowser, signals = process } = {}) {
|
|
20
|
+
const machine = flags.json || !isTTY;
|
|
21
|
+
const emit = (event, data) => { if (machine) log(JSON.stringify({ version: 1, event, ...data })); };
|
|
22
|
+
const progress = machine ? errorOutput : log;
|
|
23
|
+
const controller = new AbortController();
|
|
24
|
+
const cancel = () => controller.abort();
|
|
25
|
+
signals.on('SIGINT', cancel); signals.on('SIGTERM', cancel);
|
|
26
|
+
let attempt;
|
|
27
|
+
let candidate;
|
|
28
|
+
let saved = false;
|
|
29
|
+
let cleanup = [];
|
|
30
|
+
try {
|
|
31
|
+
const view = authConfigView(env);
|
|
32
|
+
const audience = view.baseUrl;
|
|
33
|
+
// Origin validation and native preflight both precede any approval request.
|
|
34
|
+
let client;
|
|
35
|
+
try { client = clientFactory({ audience }); }
|
|
36
|
+
catch (error) {
|
|
37
|
+
if (error.code === 'AUTH_ORIGIN_UNSUPPORTED') throw new AuthError(error.code, `Browser sessions require the Nansen production or staging API origin. Correct ${view.baseUrlSource === 'env' ? 'NANSEN_BASE_URL' : 'baseUrl in config.json'}; plain login preserves the selected origin.`);
|
|
38
|
+
throw error;
|
|
39
|
+
}
|
|
40
|
+
attempt = await state.begin({ signal: controller.signal });
|
|
41
|
+
cleanup.push(...attempt.cleanup);
|
|
42
|
+
const bundle = await pair(client, {
|
|
43
|
+
signal: controller.signal,
|
|
44
|
+
onBeforePoll: () => state.markIssuancePossible(attempt, controller.signal),
|
|
45
|
+
onIssued: value => { candidate = value; attempt.journal.unissued = false; },
|
|
46
|
+
onPending: async pending => {
|
|
47
|
+
emit('pending', pending);
|
|
48
|
+
progress(`Approve nansen CLI in your browser: ${pending.verification_uri}\nCode: ${pending.user_code}`);
|
|
49
|
+
if (!flags['no-browser'] && !await openBrowser(pending.verification_uri, audience)) progress('Could not open a browser. Open the displayed link on a trusted device.');
|
|
50
|
+
},
|
|
51
|
+
});
|
|
52
|
+
const result = await state.install(attempt, { bundle, baseUrl: audience }, controller.signal);
|
|
53
|
+
saved = true;
|
|
54
|
+
cleanup.push(...result.cleanup);
|
|
55
|
+
try { cleanup.push(...await state.finish(attempt)); } catch { cleanup.push({ local: 'incomplete', remote: 'unconfirmed' }); }
|
|
56
|
+
attempt = null;
|
|
57
|
+
const override = Boolean(env.NANSEN_API_KEY?.trim());
|
|
58
|
+
progress(override
|
|
59
|
+
? `Browser session saved for ${bundle.accountId}. Commands still use NANSEN_API_KEY. Unset it to use this session.`
|
|
60
|
+
: `Browser session saved for ${bundle.accountId}.`);
|
|
61
|
+
for (const message of cleanupMessage(cleanup)) progress(message);
|
|
62
|
+
emit('saved', { account_id: bundle.accountId, effective_source: override ? 'env' : 'session', cleanup });
|
|
63
|
+
} catch (error) {
|
|
64
|
+
// A pointer commit is authoritative even if acknowledgement/cleanup failed.
|
|
65
|
+
saved ||= attempt?.committed === true;
|
|
66
|
+
if (!saved && attempt && !attempt.uncertain && candidate) {
|
|
67
|
+
const result = await retire(candidate);
|
|
68
|
+
attempt.journal.candidateRemote = result.remote;
|
|
69
|
+
} else if (attempt && error.provenUnissued === true) attempt.journal.unissued = true;
|
|
70
|
+
if (attempt) {
|
|
71
|
+
try { cleanup.push(...await state.finish(attempt)); } catch { cleanup.push({ local: 'incomplete', remote: 'unconfirmed' }); }
|
|
72
|
+
attempt = null;
|
|
73
|
+
}
|
|
74
|
+
if (saved) {
|
|
75
|
+
progress('Browser session saved; cleanup is incomplete. Run nansen auth status.');
|
|
76
|
+
emit('saved', { cleanup, cleanup_incomplete: true });
|
|
77
|
+
return;
|
|
78
|
+
}
|
|
79
|
+
const cancelled = controller.signal.aborted;
|
|
80
|
+
const safe = error instanceof AuthError ? error : new AuthError('PAIRING_FAILED', 'Could not save browser authentication. The previous selection is unchanged. Retry after checking storage and connectivity.');
|
|
81
|
+
if (cancelled) { safe.code = 'PAIRING_CANCELLED'; safe.message = 'Login cancelled. The previous saved credential is unchanged.'; }
|
|
82
|
+
for (const message of cleanupMessage(cleanup)) progress(message);
|
|
83
|
+
if (machine) { emit(cancelled ? 'cancelled' : 'error', { code: safe.code, message: safe.message, cleanup }); safe.reported = true; }
|
|
84
|
+
throw safe;
|
|
85
|
+
} finally {
|
|
86
|
+
signals.removeListener('SIGINT', cancel); signals.removeListener('SIGTERM', cancel);
|
|
87
|
+
if (attempt) await state.finish(attempt);
|
|
88
|
+
}
|
|
89
|
+
}
|