sprag-cli 3.75.1 → 3.75.2

package/docs/TEAM.ko.md

@@ -16,14 +16,14 @@ Sprag 은 기본적으로 로컬에서만 동작합니다. 팀 기능은 켜야
 | 모델 계열 비중 | 위임 실행 중 모델 계열별 비율 |
 | Sprag 버전 | 설치된 버전 |
 | 에이전트 | `claude` 또는 `codex` |
-| 표시 이름 | 참여할 때 정한 이름이며, 기본값은 OS 사용자 이름 |
-| 운영체제 | OS 이름과 버전(예: macOS 26, Windows 11, Ubuntu 24.04), CPU 아키텍처(arm64, x64)입니다. 참여한 직후 한 번 보내고, 바뀔 때만 다시 보냅니다. 호스트 이름, 사용자 이름, 경로처럼 컴퓨터를 이름으로 알아볼 수 있는 값은 보내지 않습니다 |
+| 표시 이름 | 참여할 때 정한 이름이며, 기본값은 컴퓨터마다 한 번 만드는 `member-3f9a2c71` 같은 무작위 구성원 ID |
+| 운영체제 | OS 이름과 버전(예: macOS 26, Windows 11, Ubuntu 24.04)입니다. 참여한 직후 한 번 보내고, 바뀔 때만 다시 보냅니다. 호스트 이름, 사용자 이름, 경로처럼 컴퓨터를 이름으로 알아볼 수 있는 값은 보내지 않습니다 |
 
 보내지 않는 것은 프롬프트, 대화 기록, 파일 경로, 프로젝트 이름, 룰 내용, API 키입니다. 프롬프트 수집을 켠 엔터프라이즈 팀의 옵트인 프롬프트 업로드만 예외이며 "프롬프트 사용량 (엔터프라이즈)" 절에 적었습니다. 룰은 직접 `sprag team propose` 를 실행할 때만 밖으로 나갑니다.
 
 하루 단위 집계 업로드는 마지막 성공 이후 6시간에 한 번 이하로 실행됩니다. SessionStart 훅(그리고 작은 로컬 파일만 읽는 프롬프트 훅)이 띄운 분리된 자식 프로세스가 보냅니다. 네트워크가 끊기는 등 동기화가 실패하면 6시간을 기다리지 않고 15분, 30분, 60분 뒤에 다시 시도합니다(최대 60분 간격). 마지막으로 올린 날짜를 기억해 두었다가 그 전날부터 최대 30일 치를 다시 보내므로, 며칠 꺼져 있던 컴퓨터도 처음 성공하는 동기화에서 빠진 날을 따라잡습니다. 하루 단위 행은 덮어쓰기라 다시 보내도 안전합니다. 프롬프트 수집을 켠 엔터프라이즈 팀의 프롬프트 업로드는 따로 30분 타이머로 움직입니다("프롬프트 사용량 (엔터프라이즈)" 절 참고). statusline 을 그리는 경로에서는 절대 실행되지 않습니다.
 
-목적지는 `https://hiycfjwswtkixyoqkznm.supabase.co/rest/v1/rpc/*` 입니다(Supabase, ap-northeast-2 리전). 호출하는 RPC 는 `team_join`, `ledger_upsert`, `team_rules_get`, `team_rule_propose`, `team_leave`, `prompt_chunk_put`(엔터프라이즈 프롬프트 수집일 때만), `member_set_sync`(업로드 스위치 상태 호출, "업로드 스위치" 참고) 입니다.
+목적지는 `https://hiycfjwswtkixyoqkznm.supabase.co/rest/v1/rpc/*` 입니다(Supabase, ap-northeast-2 리전). 호출하는 RPC 는 `team_join`, `ledger_upsert`, `team_rules_get`, `team_rule_propose`, `team_leave`, `prompt_chunk_put`(엔터프라이즈 프롬프트 수집일 때만), `member_set_sync`(업로드 스위치 상태 호출, "업로드 스위치" 참고), `member_set_info`(OS 이름과 버전, `arch` 인자는 항상 빈 값) 입니다.
 
 ## CLI에서 팀 만들기
 
@@ -55,7 +55,7 @@ sprag team create --email you@example.com --name "Acme" --code 123456
 sprag team join <토큰> --name "미나"
 ```
 
-Sprag 이 올라갈 항목 목록을 보여 주고 확인을 묻습니다. `--name` 은 표시 이름이며 기본값은 OS 사용자 이름입니다. 터미널이 없는 셸에서는 `--yes` 를 붙여 확인을 대신합니다. 토큰을 생략하면 `SPRAG_TEAM_TOKEN` 을 읽습니다.
+Sprag 이 올라갈 항목 목록을 보여 주고 확인을 묻습니다. `--name` 은 표시 이름이며 기본값은 `member-3f9a2c71` 같은 무작위 구성원 ID입니다. 이 ID는 컴퓨터마다 한 번 만들어 사용자 데이터 디렉터리에 보관하며, `--name` 으로 바꿀 수 있습니다. 이 변경 전에 참여한 구성원은 서버에 이미 저장된 이름을 그대로 씁니다. 터미널이 없는 셸에서는 `--yes` 를 붙여 확인을 대신합니다. 토큰을 생략하면 `SPRAG_TEAM_TOKEN` 을 읽습니다.
 
 결과는 `sprag team status` 로 확인합니다.
 

package/docs/TEAM.md

@@ -16,14 +16,14 @@ After you join, Sprag uploads one row per local calendar day:
 | Model-family share | the share of those runs that went to each model family |
 | Sprag version | the installed version |
 | Agent | `claude` or `codex` |
-| Display name | the name you chose at join; the default is your OS user name |
-| Operating system | OS name and version (for example macOS 26, Windows 11, Ubuntu 24.04) and CPU architecture (arm64 or x64); sent once after joining and again only if it changes. Nothing that identifies the machine by name: no hostname, no user name, no path |
+| Display name | the name you chose at join; the default is a random member ID such as `member-3f9a2c71`, created once per machine |
+| Operating system | OS name and version (for example macOS 26, Windows 11, Ubuntu 24.04); sent once after joining and again only if it changes. Nothing that identifies the machine by name: no hostname, no user name, no path |
 
 Not sent: prompts, transcripts, file paths, project names, rule text, API keys. The one exception is the opt-in prompt upload of an Enterprise team with prompt capture on, described under "Prompt usage (Enterprise)". A rule leaves your machine only when you run `sprag team propose` yourself.
 
 The daily aggregate upload runs at most once every 6 hours after the last successful one, from a detached child process that the SessionStart hook (and the prompt hook, which only reads a small local file) spawns. If a sync fails, for example because the network is down, it is retried after 15, then 30, then 60 minutes (60 at most) instead of waiting 6 hours. The CLI remembers the last day it uploaded and re-sends from the day before it, up to 30 days, so a machine that was offline for days catches up on its first successful sync. Re-sending a day is safe because each day is an upsert. The prompt upload of an Enterprise team with capture on has its own 30-minute timer (see "Prompt usage (Enterprise)"). It never runs on the statusline path.
 
-Destination: `https://hiycfjwswtkixyoqkznm.supabase.co/rest/v1/rpc/*` (Supabase, region ap-northeast-2). The calls are the RPCs `team_join`, `ledger_upsert`, `team_rules_get`, `team_rule_propose`, `team_leave`, `prompt_chunk_put` (Enterprise prompt capture only) and `member_set_sync` (the upload-switch status call, see "The upload switch"); `sprag team create` also calls `team_create` with your sign-in session.
+Destination: `https://hiycfjwswtkixyoqkznm.supabase.co/rest/v1/rpc/*` (Supabase, region ap-northeast-2). The calls are the RPCs `team_join`, `ledger_upsert`, `team_rules_get`, `team_rule_propose`, `team_leave`, `prompt_chunk_put` (Enterprise prompt capture only), `member_set_sync` (the upload-switch status call, see "The upload switch") and `member_set_info` (OS name and version; the `arch` argument is always empty); `sprag team create` also calls `team_create` with your sign-in session.
 
 ## Create a team from the CLI
 
@@ -55,7 +55,7 @@ An owner or admin gives you an invite token. Then:
 sprag team join <token> --name "Mina"
 ```
 
-Sprag prints the list of what will be uploaded and asks for confirmation. `--name` sets the display name (default: your OS user name). In a shell without a terminal, pass `--yes` to confirm. If you leave the token out, Sprag reads `SPRAG_TEAM_TOKEN`.
+Sprag prints the list of what will be uploaded and asks for confirmation. `--name` sets the display name (default: a random member ID like `member-3f9a2c71`, created once per machine and kept in the user data dir, so it is the same on every join from that machine). Members who joined before this change keep the name already stored on the server. In a shell without a terminal, pass `--yes` to confirm. If you leave the token out, Sprag reads `SPRAG_TEAM_TOKEN`.
 
 Check the result with `sprag team status`.
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "sprag-cli",
-  "version": "3.75.1",
+  "version": "3.75.2",
   "description": "Model-delegation router for Claude Code and Codex: lookups, checks and test runs go to cheaper models, documents go in as compact Markdown, and a live statusline shows spend and savings.",
   "type": "module",
   "bin": {

package/src/commands/team.js

@@ -10,9 +10,9 @@
 
 import { createInterface } from 'node:readline';
 import { readFileSync } from 'node:fs';
-import { userInfo } from 'node:os';
 import { userLanguage } from '../config.js';
 import { pendingPrompts } from '../team-prompts.js';
+import { memberId } from '../member-id.js';
 import {
   loadTeamState, deviceInfo, isJoined, joinTeam, leaveTeam, syncTeam, autoJoin, aggregateDaily, rpc,
   teamRulesCachePath, teamSyncDisabled, requestSignInCode, verifySignInCode, createTeam, isSeatLimitError,
@@ -191,9 +191,7 @@ async function createFlow({ m, out, hasFlag, getArg, version, fetch, interactive
   if (!email) { console.error(m.needEmail); return process.exit(2); }
   if (!EMAIL_RE.test(email)) { console.error(m.badEmail); return process.exit(2); }
 
-  let osName = 'my';
-  try { osName = userInfo().username || 'my'; } catch { /* no passwd entry */ }
-  const defaultName = `${osName}'s team`;
+  const defaultName = `${memberId()}'s team`;
 
   let useCode = code;
   if (!useCode) {
@@ -221,8 +219,7 @@ async function createFlow({ m, out, hasFlag, getArg, version, fetch, interactive
   out(m.dashboard(email));
 
   if (noJoin) { out(m.noJoinNote); return undefined; }
-  let display = 'member';
-  try { display = userInfo().username || 'member'; } catch { /* no passwd entry */ }
+  const display = memberId();
   const joined = await joinTeam({ token: team.inviteToken, displayName: display, fetch, version });
   if (joined.orgName && joined.seatsUsed != null && joined.seatLimit != null) out(m.orgCreated(joined.orgName, joined.seatsUsed, joined.seatLimit));
   if (!teamSyncDisabled()) {
@@ -248,14 +245,14 @@ export async function run({ args, hasFlag, getArg, version, fetch, interactive,
         const token = (args[2] && !args[2].startsWith('--') ? args[2] : null) || process.env.SPRAG_TEAM_TOKEN;
         if (!token) { console.error(m.noToken); return process.exit(2); }
         let name = getArg('--name');
-        if (!name) { try { name = userInfo().username; } catch { name = 'member'; } }
+        if (!name) name = memberId();
         out(m.willSend);
         out(m.asName(name));
         if (!hasFlag('--yes')) {
           if (!process.stdin.isTTY || !process.stdout.isTTY) { console.error(m.needYes); return process.exit(2); }
           if (!(await confirm(m.ask))) { out(m.aborted); return undefined; }
         }
-        const st = await joinTeam({ token, displayName: name, version });
+        const st = await joinTeam({ token, displayName: name, fetch, version });
         out(m.joined(st.teamName));
         if (st.orgName && st.seatsUsed != null && st.seatLimit != null) out(m.orgCreated(st.orgName, st.seatsUsed, st.seatLimit));
         return undefined;

package/src/member-id.js

@@ -0,0 +1,64 @@
+/**
+ * member-id — the default display name for the team layer.
+ *
+ * The OS login name used to fill this slot, which sent a real username to the
+ * team server. A random id created once per machine names the member without
+ * naming the person. It lives in its own file in the user data dir, so
+ * `team leave` (which only touches team.json) keeps it and a rejoin on the same
+ * machine shows up under the same name.
+ *
+ * One id per machine holds even when things go wrong: an id that could not be
+ * written is remembered for the life of the process, and a missing file is
+ * created exclusively (temp file + hard link), so two processes starting at
+ * once end up with the id of whichever linked first.
+ */
+
+import { readFileSync, existsSync, mkdirSync, writeFileSync, linkSync, unlinkSync } from 'node:fs';
+import { join, dirname } from 'node:path';
+import { randomBytes } from 'node:crypto';
+import { userDataDir } from './paths.js';
+import { writeStateFile } from './state-file.js';
+import { debug } from './debug.js';
+
+const ID_RE = /^member-[0-9a-f]{8}$/;
+const cache = new Map();
+
+export const memberIdPath = (dir = userDataDir()) => join(dir, 'member-id');
+
+function readValid(file) {
+  try {
+    const text = readFileSync(file, 'utf8').trim();
+    return ID_RE.test(text) ? text : null;
+  } catch (e) { debug('member-id', e); return null; }
+}
+
+// Never throws: a failed write still returns the id it generated, and the
+// cache hands the same one back on the next call.
+export function memberId({ dir = userDataDir(), random = () => randomBytes(4).toString('hex') } = {}) {
+  const file = memberIdPath(dir);
+  const existing = readValid(file);
+  if (existing) { cache.set(file, existing); return existing; }
+  let id = cache.get(file) || `member-${random()}`;
+  try {
+    if (existsSync(file)) {
+      writeStateFile(file, `${id}\n`);
+    } else {
+      mkdirSync(dirname(file), { recursive: true });
+      const tmp = `${file}.${process.pid}.tmp`;
+      try {
+        writeFileSync(tmp, `${id}\n`);
+        linkSync(tmp, file);
+      } catch (e) {
+        // A file system without hard links still gets the file, just not exclusively.
+        if (e.code !== 'EEXIST') { debug('member-id', e); writeStateFile(file, `${id}\n`); } else {
+          const winner = readValid(file); // another process created it first
+          if (winner) id = winner;
+        }
+      } finally {
+        try { unlinkSync(tmp); } catch { /* never created */ }
+      }
+    }
+  } catch (e) { debug('member-id', e); }
+  cache.set(file, id);
+  return id;
+}

package/src/team-sync.js

@@ -24,10 +24,11 @@ import { envVar } from './env.js';
 import { readFileSync, existsSync, rmSync, chmodSync } from 'node:fs';
 import { execFileSync } from 'node:child_process';
 import { join } from 'node:path';
-import { userInfo, release as osRelease } from 'node:os';
+import { release as osRelease } from 'node:os';
 import { createRequire } from 'node:module';
 import { userDataDir } from './paths.js';
 import { writeStateFile } from './state-file.js';
+import { memberId } from './member-id.js';
 import { debug } from './debug.js';
 import { loadLedger, modelFamily, roundUsd } from './savings-ledger.js';
 import { sessionCost, pricedParts } from './claude-price.js';
@@ -330,12 +331,14 @@ export async function aggregateDaily({ now = Date.now(), dir = userDataDir(), da
     }));
 }
 
-// Device info: OS name, OS version and CPU architecture. Nothing that names the
-// machine (no hostname, username or path) is read or sent.
+// Device info: OS name and OS version. The CPU architecture is not sent: the
+// `arch` key stays in the payload (the member_set_info RPC takes it as an
+// argument) but is always empty. Nothing that names the machine (no hostname,
+// username or path) is read or sent.
 const DARWIN_TO_MACOS = { 20: '11', 21: '12', 22: '13', 23: '14', 24: '15', 25: '26' };
 
 export function deviceInfo({
-  platform = process.platform, arch = process.arch, release = osRelease(),
+  platform = process.platform, release = osRelease(),
   exec = (cmd, args) => execFileSync(cmd, args, { timeout: 2000, encoding: 'utf8', stdio: ['ignore', 'pipe', 'ignore'] }),
   readText = (f) => readFileSync(f, 'utf8'),
 } = {}) {
@@ -363,7 +366,7 @@ export function deviceInfo({
       } catch (e) { debug('team-sync', e); }
     }
   } catch (e) { debug('team-sync', e); }
-  return { os: os.slice(0, 40), os_version: osVersion.slice(0, 40), arch: String(arch).slice(0, 40) };
+  return { os: os.slice(0, 40), os_version: osVersion.slice(0, 40), arch: '' };
 }
 
 // Reports device info once after a join and again only when it changes. Fails
@@ -387,7 +390,7 @@ export async function joinTeam({
   token, displayName, agent = 'claude', autoJoined = false, fetch, dir = userDataDir(), version, now = Date.now(), env = process.env,
 } = {}) {
   if (!TOKEN_RE.test(String(token || ''))) throw new Error('invalid invite token (expected spt_ + 32 hex characters)');
-  const name = String(displayName || '').trim() || 'member';
+  const name = String(displayName || '').trim() || memberId({ dir });
   let r;
   try {
     r = await rpc('team_join', {
@@ -604,8 +607,7 @@ export async function autoJoin({ env = process.env, fetch, dir = userDataDir(),
   // A state with `left: true` never auto-rejoins: leaving must beat the
   // environment, or `sprag team leave` would be undone by the next session.
   if (isJoined(state) || state.left) return null;
-  let name = 'member';
-  try { name = userInfo().username || 'member'; } catch { /* no passwd entry */ }
+  const name = memberId({ dir });
   try {
     return await joinTeam({ token, displayName: name, autoJoined: true, fetch, dir, version, now, env });
   } catch (e) {

package/src/update-check.js

@@ -29,12 +29,19 @@
  * once-a-day pass as the version check, and its absence never blocks the
  * notice — a version number alone is still worth saying.
  *
+ * The version is asked of the npm registry the user has configured
+ * (npm_config_registry, then the `registry=` line of ~/.npmrc, then
+ * registry.npmjs.org), so a machine behind a corporate mirror checks the
+ * mirror instead of a host it may not be able to reach. A mirror that fails is
+ * reported as a failure; there is no silent fallback to npmjs.
+ *
  * Opt out with SPRAG_NO_UPDATE_CHECK=1 or NO_UPDATE_NOTIFIER (the de-facto
  * standard env var — anyone who set it for other CLIs meant us too).
  */
 
 import { envVar } from './env.js';
 import { readFileSync, writeFileSync, existsSync, mkdirSync } from 'node:fs';
+import { homedir } from 'node:os';
 import { spawn } from 'node:child_process';
 import { join, dirname, sep } from 'node:path';
 import { fileURLToPath } from 'node:url';
@@ -334,6 +341,48 @@ function releaseTagUrl(version) {
   return url;
 }
 
+/**
+ * The npm registry base URL the user has configured. Order: the
+ * npm_config_registry env var (either case), the `registry=` line of
+ * ~/.npmrc, then the public registry. `@scope:registry=` lines are ignored:
+ * they route other packages, not this one.
+ */
+export function npmRegistry({
+  env = process.env, readText = (f) => readFileSync(f, 'utf8'), home = homedir(),
+} = {}) {
+  const unquote = (v) => v.trim().replace(/^(["'])(.*)\1$/, '$2');
+  const fromEnv = unquote(env.npm_config_registry || env.NPM_CONFIG_REGISTRY || '');
+  if (fromEnv) return fromEnv;
+  try {
+    for (const raw of readText(join(home, '.npmrc')).split(/\r?\n/)) {
+      const line = raw.trim();
+      if (!line || line.startsWith('#') || line.startsWith(';')) continue;
+      const m = line.match(/^registry\s*=\s*(.+)$/);
+      if (m && unquote(m[1])) return unquote(m[1]);
+    }
+  } catch (e) { debug('update-check:npmrc', e); }
+  return 'https://registry.npmjs.org/';
+}
+
+/**
+ * The `latest` dist-tag URL under a registry base, or a throw. The base comes
+ * from the environment or a config file, so it is checked rather than trusted:
+ * https only, and the parsed result must still sit under the base (`new URL`
+ * has collapsed any `../` by then, so the prefix test runs on the parsed href).
+ */
+export function latestUrl(registry) {
+  const base = new URL(String(registry).endsWith('/') ? String(registry) : `${registry}/`);
+  if (base.protocol !== 'https:') {
+    // origin has no userinfo; it is "null" for non-http(s) schemes
+    throw new Error(`refusing to request ${base.origin === 'null' ? base.protocol : base.origin}: registry must use https`);
+  }
+  const url = new URL(`${CANONICAL_NAME}/latest`, base);
+  if (!url.href.startsWith(base.href)) {
+    throw new Error(`refusing to request ${url.origin}${url.pathname}: outside the registry base`);
+  }
+  return url;
+}
+
 /**
  * Fetch the highlights for one version. Returns [] on any failure: the notice
  * is worth showing with a bare version number, so a missing release, a rate
@@ -370,13 +419,16 @@ export async function fetchHighlights(version, { timeoutMs = FETCH_TIMEOUT_MS, l
  * Actually hit the registry and persist the answer. Only the detached child
  * and the explicit `update-check --refresh` command call this.
  */
-export async function refreshUpdateState(currentVersion) {
+export async function refreshUpdateState(currentVersion, { env, home } = {}) {
   const controller = new AbortController();
   const timer = setTimeout(() => controller.abort(), FETCH_TIMEOUT_MS);
   try {
     // The `latest` dist-tag endpoint returns a few hundred bytes, unlike the
     // full packument which is megabytes for a package with this many releases.
-    const res = await fetch(`https://registry.npmjs.org/${CANONICAL_NAME}/latest`, {
+    // The URL is a checked https registry base plus a constant package path.
+    // Same scanner false positive as the releases request above.
+    // nosemgrep: rules.lgpl.nodejs_scan.javascript-ssrf-rule-node_ssrf
+    const res = await fetch(latestUrl(npmRegistry({ env, home })), {
       signal: controller.signal,
       headers: { accept: 'application/json' },
     });