@stage-labs/metro 0.1.0-beta.149 → 0.1.0-beta.150

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@stage-labs/metro",
-  "version": "0.1.0-beta.149",
+  "version": "0.1.0-beta.150",
   "description": "The metro command line. Sign in once per machine, then hand your MCP connector list to Claude Code without the credentials touching disk, argv or shell history.",
   "license": "MIT",
   "repository": {

package/runtime/marketplace/plugin/.claude-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "metro",
-  "version": "0.1.0-beta.149",
+  "version": "0.1.0-beta.150",
   "description": "Metro for Claude Code, installed by the metro daemon on this machine: every connector the agent holds as its own MCP server relayed through the daemon, the orchestrator-only guard on the main thread, and the standing rules loaded at each session start. No vendor credential ever sits in a config file.",
   "author": {
     "name": "Bonustrack",

package/runtime/node_modules/@metro-labs/daemon/src/gateway/gemini-setup.ts

@@ -5,7 +5,9 @@ import { GeminiAuthError, type GeminiTokens } from './gemini-auth.js';
 export const CODE_ASSIST_BASE = 'https://cloudcode-pa.googleapis.com';
 const API = 'v1internal';
 const METADATA = { ideType: 'IDE_UNSPECIFIED', platform: 'PLATFORM_UNSPECIFIED', pluginType: 'GEMINI' };
+const CLI_VERSION = '0.60.0';
 const FREE_TIER = 'free-tier';
+const PROJECT_RE = /^[a-z][a-z0-9-]{4,28}[a-z0-9]$/;
 const POLL_MS = 5000;
 const POLL_MAX = 24;
 
@@ -16,12 +18,23 @@ export interface Onboarded {
 
 const text = (value: unknown): string | null => (typeof value === 'string' && value !== '' ? value : null);
 
+export const userAgent = (model: string): string => `GeminiCLI/${CLI_VERSION}/${model} (${process.platform}; ${process.arch}; terminal)`;
+
+export function parseGeminiProject(value: unknown): string | null {
+  const project = typeof value === 'string' ? value.trim() : '';
+  if (project === '') return null;
+  if (!PROJECT_RE.test(project)) throw new GeminiAuthError('that is not a Google Cloud project id: 6 to 30 lowercase letters, digits and dashes, starting with a letter');
+  return project;
+}
+
+const metadataFor = (project: string | null): Record<string, string> => (project === null ? METADATA : { ...METADATA, duetProject: project });
+
 async function call(base: string, method: string, token: string, body: unknown, fetchImpl: typeof fetch): Promise<Record<string, unknown>> {
   let res: Response;
   try {
     res = await fetchImpl(`${base}/${API}:${method}`, {
       method: 'POST',
-      headers: { authorization: `Bearer ${token}`, 'content-type': 'application/json' },
+      headers: { authorization: `Bearer ${token}`, 'content-type': 'application/json', 'user-agent': userAgent('auto') },
       body: JSON.stringify(body),
       signal: AbortSignal.timeout(30_000),
     });
@@ -62,6 +75,7 @@ const REASONS: Record<string, string> = {
   UNKNOWN_LOCATION: 'Google could not tell where this account is located',
   RESTRICTED_NETWORK: 'the network this box is on is restricted',
   INELIGIBLE_ACCOUNT: 'Google marks this account as not eligible',
+  UNSUPPORTED_CLIENT: 'Google closed Gemini CLI sign-in for personal accounts on 2026-06-18; a Gemini Code Assist Standard or Enterprise licence on a Google Cloud project is what still works, enter that project id',
 };
 
 function refuseIneligible(load: Record<string, unknown>): void {
@@ -74,8 +88,7 @@ function refuseIneligible(load: Record<string, unknown>): void {
   throw new GeminiAuthError(said.join('; '));
 }
 
-const MANAGED =
-  'Google treats this account as a managed (Workspace) one: it has a Code Assist tier but no project of its own, and the individual tier is for personal Google accounts (gmail.com). Sign in with the personal account that holds your Google AI plan';
+const NO_PROJECT = 'this account holds a Code Assist licence but Google named no project for it: enter the id of the Google Cloud project that carries the licence and connect again';
 
 function tierToOnboard(load: Record<string, unknown>): { id: string; name: string | null } {
   const allowed = Array.isArray(load.allowedTiers) ? load.allowedTiers.filter(isRecord) : [];
@@ -91,18 +104,36 @@ const summary = (load: Record<string, unknown>): Record<string, unknown> => ({
   project: text(load.cloudaicompanionProject),
 });
 
-export async function onboard(tokens: GeminiTokens, base = CODE_ASSIST_BASE, fetchImpl: typeof fetch = fetch): Promise<Onboarded> {
-  const load = await call(base, 'loadCodeAssist', tokens.accessToken, { metadata: METADATA }, fetchImpl);
+function onboardBody(load: Record<string, unknown>, project: string | null): { body: Record<string, unknown>; name: string | null } {
+  const wanted = tierToOnboard(load);
+  const paid = wanted.id !== FREE_TIER && project !== null;
+  return { body: { tierId: wanted.id, metadata: metadataFor(paid ? project : null), ...withProject(paid ? project : null) }, name: wanted.name ?? wanted.id };
+}
+
+const NO_ASSIGNMENT = 'Google did not assign a Code Assist project to this account; enter the id of the Google Cloud project that carries your licence and connect again';
+
+const withProject = (project: string | null): Record<string, unknown> => (project === null ? {} : { cloudaicompanionProject: project });
+
+const assignedProject = (op: Record<string, unknown>): string | null => {
+  const response = isRecord(op.response) ? op.response : {};
+  return isRecord(response.cloudaicompanionProject) ? text(response.cloudaicompanionProject.id) : null;
+};
+
+async function onboardNew(load: Record<string, unknown>, tokens: GeminiTokens, project: string | null, base: string, fetchImpl: typeof fetch): Promise<Onboarded> {
+  const { body, name } = onboardBody(load, project);
+  const op = await waitOperation(base, tokens.accessToken, await call(base, 'onboardUser', tokens.accessToken, body, fetchImpl), fetchImpl);
+  const assigned = assignedProject(op) ?? project;
+  if (assigned === null) throw new GeminiAuthError(NO_ASSIGNMENT);
+  return { project: assigned, tier: name };
+}
+
+export async function onboard(tokens: GeminiTokens, project: string | null = null, base = CODE_ASSIST_BASE, fetchImpl: typeof fetch = fetch): Promise<Onboarded> {
+  const load = await call(base, 'loadCodeAssist', tokens.accessToken, { metadata: metadataFor(project), ...withProject(project) }, fetchImpl);
   log.info(summary(load), 'gemini: Code Assist answered loadCodeAssist');
   refuseIneligible(load);
+  if (!isRecord(load.currentTier)) return onboardNew(load, tokens, project, base, fetchImpl);
+  const known = text(load.cloudaicompanionProject) ?? project;
+  if (known === null) throw new GeminiAuthError(NO_PROJECT);
   const tier = tierOf(load);
-  const known = text(load.cloudaicompanionProject);
-  if (known !== null) return { project: known, tier: tier.name ?? tier.id };
-  if (isRecord(load.currentTier)) throw new GeminiAuthError(MANAGED);
-  const wanted = tierToOnboard(load);
-  const op = await waitOperation(base, tokens.accessToken, await call(base, 'onboardUser', tokens.accessToken, { tierId: wanted.id, metadata: METADATA }, fetchImpl), fetchImpl);
-  const response = isRecord(op.response) ? op.response : {};
-  const project = isRecord(response.cloudaicompanionProject) ? text(response.cloudaicompanionProject.id) : null;
-  if (project === null) throw new GeminiAuthError('Google did not assign a Code Assist project to this account; sign in to https://geminicli.com once with the Gemini CLI, then try again');
-  return { project, tier: wanted.name ?? wanted.id };
+  return { project: known, tier: tier.name ?? tier.id };
 }

package/runtime/node_modules/@metro-labs/daemon/src/gateway/gemini.ts

@@ -2,7 +2,7 @@ import type { IncomingMessage, ServerResponse } from 'node:http';
 import { isRecord } from '@metro-labs/core/is-record';
 import { errMsg } from '@metro-labs/core/log';
 import { refreshTokens, tokensStale, type GeminiTokens } from './gemini-auth.js';
-import { CODE_ASSIST_BASE } from './gemini-setup.js';
+import { CODE_ASSIST_BASE, userAgent } from './gemini-setup.js';
 import { GeminiStreamTranslator } from './gemini-stream.js';
 import { toGeminiRequest } from './gemini-translate.js';
 import { ToolNames } from './codex-translate.js';
@@ -12,7 +12,6 @@ import type { ModelConfig } from './model-config.js';
 import { UsageScanner } from './usage.js';
 
 const PING_MS = 25_000;
-const CLI_VERSION = '0.62.0';
 const STATUS_OF: Record<string, number> = { rate_limit_error: 429, invalid_request_error: 400, permission_error: 403, overloaded_error: 529 };
 
 export const KNOWN_GEMINI_MODELS = ['gemini-3.1-pro-preview', 'gemini-3-pro-preview', 'gemini-3-flash-preview', 'gemini-3.1-flash-lite', 'gemini-2.5-pro', 'gemini-2.5-flash'];
@@ -31,8 +30,6 @@ export interface GeminiState {
 
 export const freshGeminiState = (): GeminiState => ({ refreshing: null, latest: null });
 
-export const userAgent = (model: string): string => `GeminiCLI/${CLI_VERSION}/${model} (${process.platform}; ${process.arch}; metro)`;
-
 const newerThan = (a: GeminiTokens, b: GeminiTokens): boolean => Date.parse(a.savedAt) > Date.parse(b.savedAt);
 
 function refreshed(tokens: GeminiTokens, deps: GeminiDeps, state: GeminiState): Promise<GeminiTokens> {

package/runtime/node_modules/@metro-labs/daemon/src/gateway/model-api.ts

@@ -7,7 +7,7 @@ import { beginLogin, CodexAuthError, finishLogin, readCodexCliAuth } from './cod
 import { beginDeviceLogin, pollDeviceLogin } from './codex-device.js';
 import { codexModels, currentTokens, freshCodexState } from './codex.js';
 import { beginLogin as beginGeminiLogin, exchangeCode as exchangeGeminiCode, GeminiAuthError, userEmail } from './gemini-auth.js';
-import { onboard } from './gemini-setup.js';
+import { onboard, parseGeminiProject } from './gemini-setup.js';
 import { KNOWN_GEMINI_MODELS } from './gemini.js';
 import { openrouterCredits, openrouterModels, openrouterZdrModels } from './openrouter.js';
 import { anthropicModels, bedrockModels } from './provider-models.js';
@@ -181,13 +181,22 @@ const CODEX_ROUTES: Record<string, Route> = {
   },
 };
 
+function projectOf(body: unknown): string | null {
+  try {
+    return parseGeminiProject(isRecord(body) ? body.project : null);
+  } catch (err) {
+    return asApiError(err);
+  }
+}
+
 async function connectGemini(req: IncomingMessage, deps: ModelApiDeps, store: Store): Promise<unknown> {
   const body = await readJsonBody(req, BODY_MAX);
   const code = isRecord(body) && typeof body.code === 'string' ? body.code : '';
   const state = isRecord(body) && typeof body.state === 'string' ? body.state : '';
+  const project = projectOf(body);
   const tokens = await exchangeGeminiCode(code, state, deps.geminiTokenBase, deps.fetchImpl).catch(asApiError);
   const email = await userEmail(tokens, deps.geminiUserBase, deps.fetchImpl);
-  const onboarded = await onboard(tokens, deps.geminiBase, deps.fetchImpl).catch(asApiError);
+  const onboarded = await onboard(tokens, project, deps.geminiBase, deps.fetchImpl).catch(asApiError);
   const cfg = setGeminiAuth(store.read(), { ...tokens, email, project: onboarded.project, tier: onboarded.tier });
   store.write(cfg);
   log.info({ tier: onboarded.tier }, 'model-api: Gemini connected');

package/runtime/runtime.json

@@ -1,3 +1,3 @@
 {
-  "version": "0.1.0-beta.149"
+  "version": "0.1.0-beta.150"
 }