@extension.dev/mcp 10.10.8 → 10.10.9

package/dist/module.js

@@ -243,7 +243,7 @@ __webpack_require__.d(workspace_create_namespaceObject, {
     handler: ()=>workspace_create_handler,
     schema: ()=>workspace_create_schema
 });
-var package_namespaceObject = JSON.parse('{"rE":"10.10.8","El":{"OP":"4.1.31"}}');
+var package_namespaceObject = JSON.parse('{"rE":"10.10.9","El":{"OP":"4.1.31"}}');
 const ENVELOPE_SCHEMA = 1;
 const collectWarnings = (warnings)=>{
     if (!warnings) return [];
@@ -579,6 +579,21 @@ function writeCredentials(creds) {
         entries
     });
 }
+function writeCredentialBatch(batch) {
+    if (0 === batch.length) return null;
+    const existing = readCredentialStore();
+    const entries = {
+        ...existing?.entries ?? {}
+    };
+    for (const creds of batch)entries[credentialKey(creds.workspaceSlug, creds.projectSlug)] = creds;
+    const first = batch[0];
+    const active = existing?.active && entries[existing.active] ? existing.active : credentialKey(first.workspaceSlug, first.projectSlug);
+    return writeStore({
+        version: 2,
+        active,
+        entries
+    });
+}
 function clearCredentials(selector) {
     const file = credentialsPath();
     const store = readCredentialStore();
@@ -660,6 +675,91 @@ const PROJECT_TOKEN_INPUT = {
 function noStoredLoginHint(project) {
     return `No stored login for ${project}. extension_auth (action: status) lists the logins on this machine; extension_auth (action: login, project: "${project}") adds one. Logging in to another project no longer replaces this one.`;
 }
+const MAX_BATCH_PROJECTS = 20;
+const MAX_PROJECT_SLUG_LENGTH = 48;
+const MAX_WORKSPACE_SLUG_LENGTH = 64;
+const PLATFORM_CREATES_PER_HOUR = 10;
+const DEFAULT_CREATE_PROJECTS_PER_APPROVAL = 10;
+function capFrom(value, fallback) {
+    const count = Number(value);
+    if (!Number.isInteger(count) || count < 1) return fallback;
+    return Math.min(count, MAX_BATCH_PROJECTS);
+}
+function readBatchCapability(config) {
+    const raw = config?.batchOnboarding;
+    if (!raw || "object" != typeof raw || Array.isArray(raw)) return null;
+    const record = raw;
+    return {
+        createProjectsPerApproval: capFrom(record.createProjectsPerApproval, DEFAULT_CREATE_PROJECTS_PER_APPROVAL),
+        loginProjectsPerApproval: capFrom(record.loginProjectsPerApproval, MAX_BATCH_PROJECTS)
+    };
+}
+const BATCH_UNSUPPORTED_MESSAGE = "This platform does not advertise batch onboarding, so a list of projects was not sent and no device code was spent.";
+const PROJECT_SLUG = /^[a-z0-9]+(?:-[a-z0-9]+)*$/;
+function isExactProjectSlug(slug) {
+    return slug.length <= MAX_PROJECT_SLUG_LENGTH && PROJECT_SLUG.test(slug);
+}
+function parseProjectBatch(input) {
+    if (!Array.isArray(input)) return {
+        ok: false,
+        message: "projects must be an array of '<workspace>/<project>' names."
+    };
+    if (input.length < 1 || input.length > MAX_BATCH_PROJECTS) return {
+        ok: false,
+        message: `projects must name between 1 and ${MAX_BATCH_PROJECTS} projects; got ${input.length}. One approval covers at most ${MAX_BATCH_PROJECTS}, so split a longer list into separate calls.`
+    };
+    const refs = [];
+    const slugs = [];
+    let workspace = "";
+    for (const entry of input){
+        const raw = "string" == typeof entry ? entry.trim() : "";
+        if (!/^[^/]+\/[^/]+$/.test(raw)) return {
+            ok: false,
+            message: `Every entry in projects must be '<workspace>/<project>'; got ${JSON.stringify(entry)}.`
+        };
+        const slash = raw.indexOf("/");
+        const entryWorkspace = raw.slice(0, slash).trim().toLowerCase();
+        const slug = raw.slice(slash + 1).trim().toLowerCase();
+        if (!entryWorkspace || entryWorkspace.length > MAX_WORKSPACE_SLUG_LENGTH) return {
+            ok: false,
+            message: `The workspace in '${raw}' must be a slug of at most ${MAX_WORKSPACE_SLUG_LENGTH} characters.`
+        };
+        if (!isExactProjectSlug(slug)) return {
+            ok: false,
+            message: `'${raw}' does not name a project by its exact slug. A batch takes each project slug exactly as the platform registers it: lowercase letters and digits joined by single dashes, at most ${MAX_PROJECT_SLUG_LENGTH} characters. The console address bar shows it as console.extension.dev/<workspace>/<project>.`
+        };
+        if (workspace && entryWorkspace !== workspace) return {
+            ok: false,
+            message: `One approval covers one workspace: '${raw}' is in '${entryWorkspace}' but the list started in '${workspace}'. Make one call per workspace.`
+        };
+        workspace = entryWorkspace;
+        if (slugs.includes(slug)) return {
+            ok: false,
+            message: `'${entryWorkspace}/${slug}' is named twice in projects. Name each project once.`
+        };
+        slugs.push(slug);
+        refs.push(`${entryWorkspace}/${slug}`);
+    }
+    return {
+        ok: true,
+        batch: {
+            workspace,
+            slugs,
+            refs
+        }
+    };
+}
+function sameProjectSet(a, b) {
+    if (a.length !== b.length) return false;
+    const wanted = new Set(a.map((value)=>value.toLowerCase()));
+    return b.every((value)=>wanted.has(value.toLowerCase()));
+}
+function createRateLimitNote() {
+    return `The platform creates at most ${PLATFORM_CREATES_PER_HOUR} projects per hour for one approving account, and a provisioning grant lives 15 minutes. Creations the same account already made in the last hour count against it.`;
+}
+function createCapNote(cap) {
+    return `One approval creates at most ${cap} projects on this platform. Send the first ${cap}; the next ${cap} can start in a new call, with its own approval, once the hourly creation limit allows.`;
+}
 const DEFAULT_API = PROD_ORIGINS.www;
 function tokenTtlNote(workspaceSlug, projectSlug) {
     const tokensUrl = workspaceSlug && projectSlug ? consoleProjectUrl({
@@ -711,7 +811,8 @@ async function fetchLoginConfig(apiBase, fetchImpl = fetch) {
     return {
         deviceCodeUrl: String(data.deviceCodeUrl || "/api/cli/device/code"),
         deviceTokenUrl: String(data.deviceTokenUrl || "/api/cli/device/token"),
-        verificationUri: String(data.verificationUri || `${apiBase.replace(/\/+$/, "")}/device`)
+        verificationUri: String(data.verificationUri || `${apiBase.replace(/\/+$/, "")}/device`),
+        batch: readBatchCapability(data)
     };
 }
 function persistTokenResponse(args) {
@@ -735,6 +836,30 @@ function persistTokenResponse(args) {
     writeCredentials(creds);
     return creds;
 }
+function persistBatchTokenResponse(args) {
+    const raw = Array.isArray(args.data.tokens) ? args.data.tokens : null;
+    if (!raw) throw new Error("The platform answered this batch login with a single token and no per-project list, so nothing was stored. It may predate batch login: sign in to each project with its own extension_auth (action: login, project) call.");
+    const batch = raw.map((entry)=>{
+        const record = entry ?? {};
+        const token = String(record.token || "").trim();
+        const workspaceSlug = String(record.workspaceSlug || "").trim();
+        const projectSlug = String(record.projectSlug || "").trim();
+        if (!token || !workspaceSlug || !projectSlug) throw new Error("The batch login returned an entry without a token or a workspace/project scope; nothing was stored. Run extension_auth (action: login) again.");
+        return {
+            version: 1,
+            token,
+            workspaceSlug,
+            projectSlug,
+            expiresAt: Number(record.expiresAt || 0),
+            api: args.apiBase,
+            provider: "extensiondev"
+        };
+    });
+    const returned = batch.map((creds)=>`${creds.workspaceSlug}/${creds.projectSlug}`);
+    if (new Set(returned.map((ref)=>ref.toLowerCase())).size !== returned.length || !sameProjectSet(args.projects, returned)) throw new Error(`The batch login returned tokens scoped to [${returned.join(", ")}], not the requested [${args.projects.join(", ")}]; nothing was stored. Run extension_auth (action: login) again with the intended projects.`);
+    writeCredentialBatch(batch);
+    return batch;
+}
 const INSTALL_HEADER = "x-extensiondev-install";
 const SESSION_HEADER = "x-extensiondev-session";
 const TOOL_HEADER = "x-extensiondev-tool";
@@ -885,7 +1010,9 @@ class RegistryAccessTokens {
         return result;
     }
     async mint(ref, apiHint) {
-        const creds = readValidCredentials();
+        const creds = readValidCredentials(void 0, {
+            project: `${ref.workspace}/${ref.project}`
+        });
         const token = String(process.env.EXTENSION_DEV_TOKEN || creds?.token || "").trim();
         if (!token) return {
             status: "no-credential"
@@ -1065,14 +1192,33 @@ function consoleBase(apiHint) {
 function registryBase() {
     return mcpOrigins().registry;
 }
+function splitProjectName(name) {
+    const parts = name.split("/");
+    const workspace = String(parts[0] ?? "").trim();
+    const project = String(parts[1] ?? "").trim();
+    if (2 !== parts.length || !workspace || !project) return null;
+    return {
+        workspace,
+        project
+    };
+}
 function resolveProjectRef(overrides) {
-    const workspace = String(overrides?.workspace || "").trim();
-    const project = String(overrides?.project || "").trim();
+    let workspace = String(overrides?.workspace || "").trim();
+    let project = String(overrides?.project || "").trim();
+    if (project.includes("/")) {
+        const named = splitProjectName(project);
+        if (!named) return null;
+        if (workspace && workspace.toLowerCase() !== named.workspace.toLowerCase()) return null;
+        workspace = named.workspace;
+        project = named.project;
+    }
     if (workspace && project) return {
         workspace,
         project
     };
-    const creds = readCredentials();
+    const creds = (project ? readCredentials({
+        project
+    }) : null) ?? readCredentials();
     const ws = workspace || String(creds?.workspaceSlug || "").trim();
     const proj = project || String(creds?.projectSlug || "").trim();
     if (!ws || !proj) return null;
@@ -1081,6 +1227,20 @@ function resolveProjectRef(overrides) {
         project: proj
     };
 }
+function loginProjectRef(selector) {
+    const named = String(selector ?? "").trim();
+    if (!named) return resolveProjectRef();
+    const creds = readCredentials({
+        project: named
+    });
+    const workspace = String(creds?.workspaceSlug || "").trim();
+    const project = String(creds?.projectSlug || "").trim();
+    if (workspace && project) return {
+        workspace,
+        project
+    };
+    return splitProjectName(named);
+}
 function registryFileUrl(ref, file) {
     return `${registryBase()}/${encodeURIComponent(ref.workspace)}/${encodeURIComponent(ref.project)}/_extension-dev/${file}`;
 }
@@ -1744,6 +1904,7 @@ const LAUNCH_BROWSER = {
 };
 async function requestDeviceCode(args) {
     const doFetch = args.fetchImpl ?? fetch;
+    const batch = Array.isArray(args.projects) && args.projects.length > 0;
     const res = await doFetch(`${args.apiBase}${args.path}`, {
         method: "POST",
         headers: {
@@ -1751,7 +1912,10 @@ async function requestDeviceCode(args) {
             accept: "application/json"
         },
         body: JSON.stringify({
-            ...args.project ? {
+            ...batch ? {
+                projects: args.projects
+            } : {},
+            ...!batch && args.project ? {
                 project: args.project
             } : {},
             ...args.workspace ? {
@@ -1775,6 +1939,8 @@ async function requestDeviceCode(args) {
     if (!res.ok) {
         const error = new Error(`Device code request failed (${res.status}): ${data.message || "unknown error"}`);
         if ("string" == typeof data.message && data.message.trim()) error.serverMessage = data.message.trim();
+        if ("string" == typeof data.code && data.code.trim()) error.serverCode = data.code.trim();
+        error.httpStatus = res.status;
         throw error;
     }
     const deviceCode = String(data.device_code || "").trim();
@@ -1793,6 +1959,7 @@ async function pollDeviceGrant(args) {
     const doFetch = args.fetchImpl ?? fetch;
     const deadline = Date.now() + args.budgetMs;
     let interval = Math.max(1, args.interval);
+    const batch = Array.isArray(args.projects) && args.projects.length > 0;
     for(;;){
         const res = await doFetch(`${args.apiBase}${args.path}`, {
             method: "POST",
@@ -1802,7 +1969,10 @@ async function pollDeviceGrant(args) {
             },
             body: JSON.stringify({
                 device_code: args.deviceCode,
-                ...args.project ? {
+                ...batch ? {
+                    projects: args.projects
+                } : {},
+                ...!batch && args.project ? {
                     project: args.project
                 } : {},
                 ...args.workspace ? {
@@ -1824,9 +1994,18 @@ async function pollDeviceGrant(args) {
             data
         };
         const error = String(data.error || "");
+        const code = String(data.code || "").trim();
+        const refusal = code ? {
+            code,
+            body: data
+        } : {};
         if ("access_denied" === error) return {
             ok: false,
-            reason: "denied"
+            reason: "denied",
+            ...data.message ? {
+                message: String(data.message)
+            } : {},
+            ...refusal
         };
         if ("expired_token" === error) return {
             ok: false,
@@ -1836,12 +2015,14 @@ async function pollDeviceGrant(args) {
         else if (error && "authorization_pending" !== error) return {
             ok: false,
             reason: "error",
-            message: String(data.message || error)
+            message: String(data.message || error),
+            ...refusal
         };
         else if (!error && !res.ok) return {
             ok: false,
             reason: "error",
-            message: `Device token poll failed (${res.status}): ${String(data.message || text || "no response body").slice(0, 200)}`
+            message: `Device token poll failed (${res.status}): ${String(data.message || text || "no response body").slice(0, 200)}`,
+            ...refusal
         };
         if (Date.now() + 1000 * interval >= deadline) return {
             ok: false,
@@ -1870,49 +2051,710 @@ async function pollDeviceToken(args) {
             message: err?.message ? String(err.message) : String(err)
         };
     }
-}
-const FREE_ALLOWANCE_PHRASE = "counts against your free allowance";
-function allowanceWallUrl(apiHint) {
-    return `${mcpOrigins(apiHint).www.replace(/\/+$/, "")}/pricing`;
-}
-function allowance_asRecord(value) {
-    return value && "object" == typeof value && !Array.isArray(value) ? value : null;
-}
-function asCount(value) {
-    return "number" == typeof value && Number.isFinite(value) && value >= 0 ? value : null;
-}
-function readPlatformAllowance(body) {
-    const record = allowance_asRecord(body);
-    if (!record) return null;
-    for (const key of [
-        "allowance",
-        "quota"
-    ]){
-        const nested = allowance_asRecord(record[key]);
-        if (!nested) continue;
-        const used = asCount(nested.used);
-        const limit = asCount(nested.limit);
-        if (null !== used && null !== limit) return {
-            used,
-            limit
-        };
+}
+const FREE_ALLOWANCE_PHRASE = "counts against your free allowance";
+function allowanceWallUrl(apiHint) {
+    return `${mcpOrigins(apiHint).www.replace(/\/+$/, "")}/pricing`;
+}
+function allowance_asRecord(value) {
+    return value && "object" == typeof value && !Array.isArray(value) ? value : null;
+}
+function asCount(value) {
+    return "number" == typeof value && Number.isFinite(value) && value >= 0 ? value : null;
+}
+function readPlatformAllowance(body) {
+    const record = allowance_asRecord(body);
+    if (!record) return null;
+    for (const key of [
+        "allowance",
+        "quota"
+    ]){
+        const nested = allowance_asRecord(record[key]);
+        if (!nested) continue;
+        const used = asCount(nested.used);
+        const limit = asCount(nested.limit);
+        if (null !== used && null !== limit) return {
+            used,
+            limit
+        };
+    }
+    return null;
+}
+function spendNarration(options) {
+    const counted = readPlatformAllowance(options.body);
+    return {
+        spent: `${options.what} ran on extension.dev's machines and ${FREE_ALLOWANCE_PHRASE}.`,
+        remains: counted ? `The platform reports ${counted.used} of ${counted.limit} used.` : "The platform sent no remaining count on this call, and this client never invents one. When the allowance runs out, the platform refuses with its own numbers.",
+        wall: `What the free allowance covers and when the paid plan starts are published at ${allowanceWallUrl(options.api)}.`
+    };
+}
+function buildCreateBody(args) {
+    const installCommand = String(args.installCommand || "npm install").trim();
+    const buildCommand = String(args.buildCommand || "npm run build").trim();
+    const wanted = new Set((Array.isArray(args.browsers) && args.browsers.length ? args.browsers : [
+        "chrome"
+    ]).map((name)=>String(name).trim().toLowerCase()));
+    const several = wanted.size > 1;
+    const outputFor = (name)=>{
+        const override = args.outputDirectories?.[name];
+        if ("string" == typeof override && override.trim()) return override.trim();
+        const pattern = String(args.outputDirectory || "").trim();
+        if (pattern.includes("<browser>")) return pattern.replaceAll("<browser>", name);
+        if (pattern && !several) return pattern;
+        return `dist/${name}`;
+    };
+    const browser = (name)=>({
+            enabled: wanted.has(name),
+            installCommand,
+            buildCommand,
+            outputDirectory: outputFor(name)
+        });
+    return {
+        info: {
+            id: "",
+            name: args.projectSlug,
+            displayName: String(args.displayName || args.projectSlug).trim(),
+            description: String(args.description || `Browser extension project for ${args.owner}/${args.repoName}.`).trim()
+        },
+        build: {
+            chrome: browser("chrome"),
+            edge: browser("edge"),
+            firefox: browser("firefox")
+        },
+        deployment: {
+            branch: "",
+            nodeVersion: "",
+            runWhatsNew: false,
+            runExtensionExecutables: false
+        },
+        github: {
+            owner: args.owner,
+            repo: args.repoName,
+            installationId: args.installationId,
+            createdAt: new Date().toISOString(),
+            pullRequestComments: true,
+            commitComments: false
+        },
+        workspaceSlug: args.workspace,
+        createdFrom: {
+            kind: "repository",
+            ref: `${args.owner}/${args.repoName}`
+        }
+    };
+}
+const project_create_batch_COMMAND = "extension_project_create";
+const FIRST_CALL_BUDGET_MS = 8000;
+const RESUME_BUDGET_MS = 22000;
+const SLICE_BUDGET_MS = 20000;
+const GRANT_EXPIRY_MARGIN_SECONDS = 5;
+const ENTRY_KEYS = [
+    "project",
+    "repo",
+    "displayName",
+    "description",
+    "installCommand",
+    "buildCommand",
+    "outputDirectory",
+    "browsers",
+    "outputDirectories"
+];
+const ENTRY_STRING_KEYS = [
+    "displayName",
+    "description",
+    "installCommand",
+    "buildCommand",
+    "outputDirectory"
+];
+const BROWSERS = [
+    "chrome",
+    "edge",
+    "firefox"
+];
+const SINGLE_ONLY_KEYS = [
+    "project",
+    "repo",
+    "displayName",
+    "description"
+];
+const sessions = new Map();
+const SESSION_KEEP_SECONDS = 3600;
+function sweepSessions(nowSeconds) {
+    for (const [key, session] of sessions)if (!session.busy) {
+        if (session.grantExpiresAt <= nowSeconds) session.grant = "";
+        if (session.grantExpiresAt + SESSION_KEEP_SECONDS <= nowSeconds) sessions.delete(key);
+    }
+}
+function fail(name, message, status, code, extra) {
+    return envelope_envelope({
+        ok: false,
+        command: project_create_batch_COMMAND,
+        status,
+        error: {
+            code,
+            name,
+            message
+        },
+        ...extra?.value ? {
+            value: extra.value
+        } : {},
+        ...extra?.hint ? {
+            hint: extra.hint
+        } : {}
+    });
+}
+function laneClosedHint() {
+    return `Create the projects in the console at ${consoleBase()} (workspace page, New project), then run extension_auth (action: login) against them. While the public hold is on, headless creation is open only to workspaces on the platform's allowlist (WWW_MCP_ACTION_ALLOWED_WORKSPACES), the same list that already lets publish, submit and promote run headlessly; this workspace is not on it, so the console is the route.`;
+}
+function isRecord(value) {
+    return Boolean(value) && "object" == typeof value && !Array.isArray(value);
+}
+function parseBatchCreateArgs(args) {
+    for (const key of SINGLE_ONLY_KEYS){
+        const value = args[key];
+        if (null != value && "" !== String(value).trim()) return {
+            ok: false,
+            message: `With projects, ${key} belongs inside each entry, not beside the list. Pass either the single form (project, repo) or projects, not both.`
+        };
+    }
+    if (!Array.isArray(args.projects)) return {
+        ok: false,
+        message: "projects must be an array of entries shaped { project: '<workspace>/<project>', repo: '<owner>/<repo>' }."
+    };
+    const refs = [];
+    for (const entry of args.projects){
+        if (!isRecord(entry)) return {
+            ok: false,
+            message: `Every entry in projects must be an object shaped { project, repo }; got ${JSON.stringify(entry)}. Each new project needs its own source repository, so a bare name is not enough.`
+        };
+        const unknown = Object.keys(entry).filter((key)=>!ENTRY_KEYS.includes(key));
+        if (unknown.length) return {
+            ok: false,
+            message: `Unknown key ${unknown.map((key)=>`'${key}'`).join(", ")} in a projects entry. An entry takes: ${ENTRY_KEYS.join(", ")}.`
+        };
+        refs.push(entry.project);
+    }
+    const parsed = parseProjectBatch(refs);
+    if (!parsed.ok) return parsed;
+    const entries = [];
+    for (const [index, raw] of args.projects.entries()){
+        const ref = parsed.batch.refs[index];
+        const slug = parsed.batch.slugs[index];
+        const repo = "string" == typeof raw.repo ? raw.repo.trim() : "";
+        if (!/^[^/]+\/[^/]+$/.test(repo)) return {
+            ok: false,
+            message: `The entry for '${ref}' needs repo as '<owner>/<repo>', the GitHub repository that project's source is pushed to.`
+        };
+        for (const key of ENTRY_STRING_KEYS)if (void 0 !== raw[key] && "string" != typeof raw[key]) return {
+            ok: false,
+            message: `In the entry for '${ref}', ${key} must be a string.`
+        };
+        if (void 0 !== raw.browsers) {
+            const list = raw.browsers;
+            if (!Array.isArray(list) || 0 === list.length || list.some((name)=>!BROWSERS.includes(String(name)))) return {
+                ok: false,
+                message: `In the entry for '${ref}', browsers must be a non-empty array of: ${BROWSERS.join(", ")}.`
+            };
+        }
+        if (void 0 !== raw.outputDirectories && !isRecord(raw.outputDirectories)) return {
+            ok: false,
+            message: `In the entry for '${ref}', outputDirectories must be an object such as {"edge": "build/edge"}.`
+        };
+        const [owner = "", repoName = ""] = repo.split("/");
+        entries.push({
+            ref,
+            workspace: parsed.batch.workspace,
+            slug,
+            repo,
+            owner,
+            repoName,
+            displayName: raw.displayName,
+            description: raw.description,
+            installCommand: raw.installCommand ?? args.installCommand,
+            buildCommand: raw.buildCommand ?? args.buildCommand,
+            outputDirectory: raw.outputDirectory ?? args.outputDirectory,
+            browsers: raw.browsers ?? args.browsers,
+            outputDirectories: raw.outputDirectories ?? args.outputDirectories
+        });
+    }
+    return {
+        ok: true,
+        workspace: parsed.batch.workspace,
+        entries
+    };
+}
+function pendingEnvelope(args) {
+    const complete = String(args.verificationUriComplete || "").trim();
+    const hasCompleteLink = complete.length > 0 && complete !== args.verificationUri;
+    const again = "then call extension_project_create again with this deviceCode and the same arguments";
+    const page = `The page lists all ${args.refs.length} projects this one approval creates and says this device is also signed in to each for 7 days`;
+    const hint = args.userCode ? hasCompleteLink ? `Open ${complete} and approve creating the projects (code ${args.userCode} is pre-filled). ${page}; ${again}. If the page asks for a code, enter ${args.userCode} at ${args.verificationUri}.` : `Open ${args.verificationUri}, enter code ${args.userCode} and approve creating the projects. ${page}; ${again}.` : `Still waiting for approval at ${args.verificationUri}. Approve there, ${again}.`;
+    return envelope_envelope({
+        ok: true,
+        command: project_create_batch_COMMAND,
+        status: "authorization-pending",
+        value: {
+            ...args.userCode ? {
+                userCode: args.userCode
+            } : {},
+            verificationUri: args.verificationUri,
+            ...args.userCode && hasCompleteLink ? {
+                verificationUriComplete: complete
+            } : {},
+            deviceCode: args.deviceCode,
+            projects: args.refs
+        },
+        hint
+    });
+}
+const STOP_CODES = new Set([
+    "TOKEN_EXPIRED",
+    "BAD_TOKEN",
+    "AUTH_REQUIRED",
+    "NOT_A_PROVISIONING_GRANT",
+    "MEMBERSHIP_REVOKED",
+    "WORKSPACE_NOT_FOUND",
+    "CLI_PROJECT_CREATE_DISABLED",
+    "PLATFORM_NOT_OPEN",
+    "RATE_LIMITED",
+    "PROJECT_LIMIT_EXCEEDED",
+    "INSTALLATION_ABSENT",
+    "INSTALLATION_ORG_UNSUPPORTED",
+    "INSTALLATION_AMBIGUOUS"
+]);
+function refusalHint(code, ref, retryAfterSeconds) {
+    if ("PROJECT_EXISTS" === code) return `${ref} already exists, so there was nothing to create and no token came back. Sign in to it with extension_auth (action: login).`;
+    if ("RATE_LIMITED" === code) return `${createRateLimitNote()}${retryAfterSeconds ? ` The platform says to wait ${retryAfterSeconds} seconds.` : ""} The grant will have expired by then, so the projects not created need a new extension_project_create call, and its approval, after the wait.`;
+    if ("TOKEN_EXPIRED" === code) return "The provisioning grant lives 15 minutes and ran out. Start a new extension_project_create call for the projects not created.";
+    if ("PROJECT_LIMIT_EXCEEDED" === code) return "The workspace is at its plan's project limit. Nothing more can be created in it until a project is removed or the plan changes.";
+    if ("RESERVED_PROJECT_SLUG" === code) return "That slug is reserved on extension.dev. Pick another name for this project.";
+}
+async function createOne(session, entry, installationId) {
+    const url = `${session.apiBase}/api/cli/projects/create`;
+    const body = {
+        ...buildCreateBody({
+            workspace: entry.workspace,
+            projectSlug: entry.slug,
+            owner: entry.owner,
+            repoName: entry.repoName,
+            installationId,
+            displayName: entry.displayName,
+            description: entry.description,
+            installCommand: entry.installCommand,
+            buildCommand: entry.buildCommand,
+            outputDirectory: entry.outputDirectory,
+            browsers: entry.browsers,
+            outputDirectories: entry.outputDirectories
+        }),
+        project: entry.ref
+    };
+    let res;
+    try {
+        res = await fetch(url, {
+            method: "POST",
+            headers: {
+                authorization: `Bearer ${session.grant}`,
+                "content-type": "application/json",
+                ...identityHeaders(project_create_batch_COMMAND)
+            },
+            body: JSON.stringify(body)
+        });
+    } catch (err) {
+        session.unanswered += 1;
+        const message = `Could not reach ${url}: ${err?.message || err}`;
+        return {
+            row: {
+                project: entry.ref,
+                status: "unconfirmed",
+                message,
+                hint: `The request for ${entry.ref} left this machine and no answer came back, so the project may or may not exist. It is not retried, because a second create racing the first would be two builds claiming one name. Check the console at ${consoleBase()}; if it exists, sign in with extension_auth (action: login).`
+            },
+            halt: true,
+            ...session.unanswered >= 2 ? {
+                stop: {
+                    code: "PLATFORM_UNREACHABLE",
+                    message
+                }
+            } : {}
+        };
+    }
+    session.unanswered = 0;
+    const text = await res.text();
+    let data;
+    try {
+        data = JSON.parse(text);
+    } catch  {
+        data = {
+            message: text
+        };
+    }
+    if (!res.ok) {
+        const held = sawPlatformHold(res, data);
+        const code = held ? "PLATFORM_NOT_OPEN" : String(data.code || "").trim() || `HTTP_${res.status}`;
+        const message = String(data.message || data.error || text || "unknown error").slice(0, 500);
+        const connectUrl = String(data.connectUrl || "").trim();
+        const retryAfterSeconds = Number(data.retryAfterSeconds || res.headers.get("retry-after") || 0) || void 0;
+        const hint = refusalHint(code, entry.ref, retryAfterSeconds);
+        const row = {
+            project: entry.ref,
+            status: "refused",
+            httpStatus: res.status,
+            code,
+            message,
+            ...connectUrl ? {
+                connectUrl
+            } : {},
+            ...retryAfterSeconds ? {
+                retryAfterSeconds
+            } : {},
+            ...hint ? {
+                hint
+            } : {}
+        };
+        return STOP_CODES.has(code) ? {
+            row,
+            stop: {
+                code,
+                message,
+                body: data,
+                held
+            }
+        } : {
+            row
+        };
+    }
+    session.lastBody = data;
+    const finalWorkspace = String(data.workspaceSlug || entry.workspace).trim();
+    const finalProject = String(data.projectSlug || entry.slug).trim();
+    const consoleUrl = consoleProjectUrl({
+        workspace: finalWorkspace,
+        project: finalProject
+    }, "");
+    const token = String(data.token || "").trim();
+    const scoped = finalWorkspace.toLowerCase() === entry.workspace && finalProject.toLowerCase() === entry.slug;
+    if (true === data.tokenIssued && token && scoped) {
+        const expiresAt = Number(data.expiresAt || 0);
+        writeCredentialBatch([
+            {
+                version: 1,
+                token,
+                workspaceSlug: finalWorkspace,
+                projectSlug: finalProject,
+                expiresAt,
+                api: session.apiBase,
+                provider: "extensiondev"
+            }
+        ]);
+        return {
+            row: {
+                project: entry.ref,
+                status: "created",
+                loggedIn: true,
+                projectId: data.projectId ?? null,
+                consoleUrl,
+                expiresAt: expiresAt ? new Date(1000 * expiresAt).toISOString() : null
+            }
+        };
+    }
+    const tokenCode = scoped ? String(data.tokenCode || "").trim() || "NO_TOKEN_IN_RESPONSE" : "PROJECT_NAME_MISMATCH";
+    return {
+        row: {
+            project: entry.ref,
+            status: "created",
+            loggedIn: false,
+            projectId: data.projectId ?? null,
+            consoleUrl,
+            tokenCode,
+            hint: scoped ? `${entry.ref} was created but the platform issued no token for it. Sign in with extension_auth (action: login).` : `The platform registered this project as ${finalWorkspace}/${finalProject}, not the ${entry.ref} that was asked for, so no login was stored. Sign in to the name it has with extension_auth (action: login).`
+        }
+    };
+}
+function rowsInOrder(session) {
+    return session.entries.map((entry)=>session.rows.get(entry.ref) ?? {
+            project: entry.ref,
+            status: "pending"
+        });
+}
+function quoteList(refs) {
+    return `[${refs.map((ref)=>`'${ref}'`).join(", ")}]`;
+}
+function finalEnvelope(session) {
+    const stop = session.stop;
+    for (const entry of session.entries)if (!session.rows.has(entry.ref)) session.rows.set(entry.ref, {
+        project: entry.ref,
+        status: "not-attempted",
+        code: stop?.code ?? "NOT_ATTEMPTED",
+        message: stop ? `Not attempted: an earlier project in this list was refused with ${stop.code}, which applies to the whole approval.` : "Not attempted."
+    });
+    const rows = rowsInOrder(session);
+    const created = rows.filter((row)=>"created" === row.status);
+    const loggedIn = created.filter((row)=>"created" === row.status && row.loggedIn);
+    const needLogin = [
+        ...created.filter((row)=>"created" === row.status && !row.loggedIn),
+        ...rows.filter((row)=>"refused" === row.status && "PROJECT_EXISTS" === row.code)
+    ].map((row)=>row.project);
+    const retry = rows.filter((row)=>"not-attempted" === row.status || "refused" === row.status && "PROJECT_EXISTS" !== row.code).map((row)=>row.project);
+    const unconfirmed = rows.filter((row)=>"unconfirmed" === row.status).map((row)=>row.project);
+    if (0 === created.length && stop?.held) return platformHoldEnvelope({
+        command: project_create_batch_COMMAND,
+        name: "CreateHeld",
+        body: stop.body,
+        value: {
+            workspace: session.workspace,
+            projects: session.refs,
+            results: rows
+        }
+    });
+    if (0 === created.length && stop?.code === "CLI_PROJECT_CREATE_DISABLED") return fail("CreateClosed", stop.message, "lane-closed", "E_PLATFORM", {
+        hint: laneClosedHint(),
+        value: {
+            workspaceSlug: session.workspace,
+            results: rows
+        }
+    });
+    const nextSteps = [
+        ...needLogin.length ? [
+            `extension_auth (action: login, projects: ${quoteList(needLogin)})`
+        ] : [],
+        ...retry.length ? [
+            `extension_project_create with projects limited to ${quoteList(retry)}, once what refused them is fixed (a new approval; a create list may only name projects that do not exist yet)`
+        ] : [],
+        ...unconfirmed.length ? [
+            `check ${quoteList(unconfirmed)} in the console at ${consoleBase()} before creating them again`
+        ] : [],
+        ...loggedIn.length ? [
+            "extension_publish (project: one of the logged-in projects)"
+        ] : []
+    ];
+    const value = {
+        workspaceSlug: session.workspace,
+        results: rows,
+        counts: {
+            listed: rows.length,
+            created: created.length,
+            loggedIn: loggedIn.length,
+            refused: rows.filter((row)=>"refused" === row.status).length,
+            unconfirmed: unconfirmed.length,
+            notAttempted: rows.filter((row)=>"not-attempted" === row.status).length
+        },
+        ...created.length ? {
+            allowance: spendNarration({
+                what: `Creating ${created.length} project${1 === created.length ? "" : "s"}, including each first build,`,
+                body: session.lastBody ?? void 0,
+                api: session.apiBase
+            })
+        } : {},
+        nextSteps
+    };
+    const spent = "The provisioning grant is spent or discarded and was never written to this machine.";
+    if (created.length === rows.length) return envelope_envelope({
+        ok: true,
+        command: project_create_batch_COMMAND,
+        status: "created",
+        value,
+        hint: 0 === needLogin.length ? `All ${rows.length} projects exist, each first build was dispatched, and this machine is signed in to every one of them for 7 days. ${spent} Token-scoped tools take \`project\` to pick one.` : `All ${rows.length} projects exist and each first build was dispatched, but no token was stored for ${needLogin.join(", ")}. ${spent} Sign in to those with one batch login: ${nextSteps[0]}.`,
+        ...needLogin.length ? {
+            warnings: [
+                `Created without a stored login: ${needLogin.join(", ")}. Run ${nextSteps[0]}.`
+            ]
+        } : {}
+    });
+    return envelope_envelope({
+        ok: false,
+        command: project_create_batch_COMMAND,
+        status: "batch-incomplete",
+        error: {
+            code: "E_PLATFORM",
+            name: "BatchIncomplete",
+            message: `${created.length} of ${rows.length} projects were created. Each project has its own row in results with the platform's code; nothing is retried automatically.${stop ? ` The list stopped at ${stop.code}: ${stop.message}` : ""}`
+        },
+        value,
+        hint: `${spent} ${stop?.code === "RATE_LIMITED" ? `${createRateLimitNote()} ` : ""}Next: ${nextSteps.join("; then ") || "read results"}.`
+    });
+}
+async function runSlice(session, deviceCode, installationId) {
+    if (session.busy) return envelope_envelope({
+        ok: true,
+        command: project_create_batch_COMMAND,
+        status: "creating",
+        value: {
+            workspaceSlug: session.workspace,
+            deviceCode,
+            results: rowsInOrder(session)
+        },
+        hint: "Another call with this deviceCode is creating projects right now. Wait for it to answer, then call again with the same deviceCode and arguments if projects are still pending."
+    });
+    session.busy = true;
+    let halted = false;
+    try {
+        const started = Date.now();
+        let attempted = 0;
+        for (const entry of session.entries){
+            if (session.rows.has(entry.ref)) continue;
+            if (session.stop) break;
+            if (Math.floor(Date.now() / 1000) >= session.grantExpiresAt - GRANT_EXPIRY_MARGIN_SECONDS) {
+                session.stop = {
+                    code: "TOKEN_EXPIRED",
+                    message: "The provisioning grant expired; it lives fifteen minutes."
+                };
+                break;
+            }
+            if (attempted > 0 && Date.now() - started >= SLICE_BUDGET_MS) break;
+            attempted += 1;
+            const outcome = await createOne(session, entry, installationId);
+            session.rows.set(entry.ref, outcome.row);
+            if (outcome.stop) session.stop = outcome.stop;
+            if (outcome.halt) {
+                halted = true;
+                break;
+            }
+        }
+    } finally{
+        session.busy = false;
+    }
+    const remaining = session.entries.filter((entry)=>!session.rows.has(entry.ref));
+    if (remaining.length > 0 && !session.stop) {
+        const done = session.entries.length - remaining.length;
+        return envelope_envelope({
+            ok: true,
+            command: project_create_batch_COMMAND,
+            status: "creating",
+            value: {
+                workspaceSlug: session.workspace,
+                deviceCode,
+                results: rowsInOrder(session),
+                remaining: remaining.map((entry)=>entry.ref)
+            },
+            hint: `${done} of ${session.entries.length} projects handled so far; ${remaining.length} still to create. Call extension_project_create again with this same deviceCode and the same arguments to continue. No new approval is needed: the grant is held in this server's memory until ${new Date(1000 * session.grantExpiresAt).toISOString()} and is lost if the server restarts.${halted ? " The last request got no answer, so its project is marked unconfirmed and is not retried." : ""}`
+        });
+    }
+    sessions.delete(deviceCode);
+    return finalEnvelope(session);
+}
+async function createProjectBatch(args) {
+    const parsed = parseBatchCreateArgs(args);
+    if (!parsed.ok) return fail("BadRequest", parsed.message, "bad-request", "E_BAD_REQUEST", {
+        hint: parsed.hint
+    });
+    const installationId = String(args.installationId || "").trim();
+    if (installationId && !/^\d+$/.test(installationId)) return fail("BadRequest", "installationId is optional, and when given it must be the numeric extension.dev GitHub App installation id. Omit it and the platform resolves it from the approving account.", "bad-request", "E_BAD_REQUEST");
+    const refs = parsed.entries.map((entry)=>entry.ref);
+    const apiCheck = safeApiBase(resolveApiBase(args.api), args.api);
+    if (!apiCheck.ok) return fail("ConfigError", apiCheck.message, "bad-request", "E_BAD_REQUEST");
+    const apiBase = apiCheck.base;
+    sweepSessions(Math.floor(Date.now() / 1000));
+    let deviceCode = String(args.deviceCode || "").trim();
+    const held = deviceCode ? sessions.get(deviceCode) : void 0;
+    if (held) {
+        if (held.apiBase !== apiBase || !sameProjectSet(held.refs, refs)) return fail("BadRequest", `This deviceCode belongs to an approval for ${quoteList(held.refs)}. Call again with that same list, or start a new call without deviceCode for a different one.`, "bad-request", "E_BAD_REQUEST");
+        return runSlice(held, deviceCode, installationId || void 0);
+    }
+    let config;
+    try {
+        config = await fetchLoginConfig(apiBase);
+    } catch (err) {
+        return fail("ConfigError", err?.message || "Could not load login config.", "create-failed", "E_PLATFORM");
+    }
+    if (!config.batch) return fail("CreateBatchUnsupported", BATCH_UNSUPPORTED_MESSAGE, "batch-unsupported", "E_PLATFORM", {
+        value: {
+            projects: refs
+        },
+        hint: "Create the projects one extension_project_create call each (project, repo)."
+    });
+    const createCap = config.batch.createProjectsPerApproval;
+    if (refs.length > createCap) return fail("BadRequest", `projects names ${refs.length} projects to create, and one approval creates at most ${createCap} on this platform.`, "bad-request", "E_BAD_REQUEST", {
+        value: {
+            maxProjects: createCap,
+            listed: refs.length
+        },
+        hint: `${createCapNote(createCap)} ${createRateLimitNote()} Nothing was started and no device code was spent.`
+    });
+    let interval = 5;
+    let budgetMs = RESUME_BUDGET_MS;
+    let start = null;
+    if (!deviceCode) {
+        try {
+            start = await requestDeviceCode({
+                apiBase,
+                path: config.deviceCodeUrl,
+                projects: refs,
+                intent: "create"
+            });
+        } catch (err) {
+            const serverCode = String(err?.serverCode || "");
+            const serverMessage = "string" == typeof err?.serverMessage ? err.serverMessage.trim() : "";
+            if ("CLI_PROJECT_CREATE_DISABLED" === serverCode) return fail("CreateStartError", serverMessage || "Headless project creation is not open on this host yet.", "lane-closed", "E_PLATFORM", {
+                hint: laneClosedHint()
+            });
+            return fail("CreateStartError", String(err?.message || "Could not start the device flow."), "create-failed", "E_PLATFORM", {
+                hint: "No device code was issued and nothing was created. Fix what the platform refused and try the list again, or create the projects one extension_project_create call each (project, repo)."
+            });
+        }
+        deviceCode = start.deviceCode;
+        interval = start.interval;
+        budgetMs = FIRST_CALL_BUDGET_MS;
+    }
+    const poll = await pollDeviceGrant({
+        apiBase,
+        path: config.deviceTokenUrl,
+        projects: refs,
+        deviceCode,
+        interval,
+        budgetMs
+    });
+    if (!poll.ok) {
+        if ("pending" === poll.reason) return pendingEnvelope({
+            deviceCode,
+            refs,
+            verificationUri: start?.verificationUri ?? config.verificationUri,
+            userCode: start?.userCode,
+            verificationUriComplete: start?.verificationUriComplete
+        });
+        const code = String(poll.code || "");
+        if ("CLI_PROJECT_CREATE_DISABLED" === code) return fail("CreateClosed", poll.message || "Headless project creation is not open yet.", "lane-closed", "E_PLATFORM", {
+            hint: laneClosedHint()
+        });
+        if ("denied" === poll.reason) return fail("CreateDenied", "Creating the projects was denied at extension.dev/device.", "create-denied", "E_AUTH_DENIED");
+        if ("expired" === poll.reason) return fail("CreateExpired", "The device code expired or was already redeemed. If an earlier call with this deviceCode had started creating projects and this server restarted since, the grant it held is gone: the projects it created still exist.", "create-expired", "E_AUTH_EXPIRED", {
+            hint: `Check which of ${quoteList(refs)} exist in the console at ${consoleBase()}. Sign in to those with extension_auth (action: login, projects), and start a new extension_project_create call naming only the ones that do not exist yet.`
+        });
+        return fail("CreateAuthError", poll.message || "Device authorization failed.", "create-failed", "E_AUTH_FAILED", {
+            value: {
+                ...code ? {
+                    code
+                } : {},
+                projects: refs
+            }
+        });
     }
-    return null;
-}
-function spendNarration(options) {
-    const counted = readPlatformAllowance(options.body);
-    return {
-        spent: `${options.what} ran on extension.dev's machines and ${FREE_ALLOWANCE_PHRASE}.`,
-        remains: counted ? `The platform reports ${counted.used} of ${counted.limit} used.` : "The platform sent no remaining count on this call, and this client never invents one. When the allowance runs out, the platform refuses with its own numbers.",
-        wall: `What the free allowance covers and when the paid plan starts are published at ${allowanceWallUrl(options.api)}.`
+    const grant = poll.data;
+    const token = String(grant.token || "").trim();
+    const grantWorkspace = String(grant.workspaceSlug || "").trim().toLowerCase();
+    const grantSlugs = Array.isArray(grant.projectSlugs) ? grant.projectSlugs.map((slug)=>String(slug).toLowerCase()) : null;
+    if ("provisioning" !== String(grant.tokenKind || "") || !grantSlugs || grantWorkspace !== parsed.workspace || !sameProjectSet(grantSlugs, parsed.entries.map((entry)=>entry.slug))) return fail("CreateScopeError", `The approval did not come back as a provisioning grant for exactly ${quoteList(refs)}, so it was discarded and nothing was created. Run extension_project_create again.`, "create-failed", "E_AUTH_FAILED", {
+        hint: "If one of these projects already exists, a create list is refused: sign in to existing projects with extension_auth (action: login, projects) and list only new ones here."
+    });
+    const session = {
+        apiBase,
+        workspace: parsed.workspace,
+        refs,
+        entries: parsed.entries,
+        grant: token,
+        grantExpiresAt: Number(grant.expiresAt || 0) || Math.floor(Date.now() / 1000) + 900,
+        rows: new Map(),
+        busy: false,
+        stop: null,
+        lastBody: null,
+        unanswered: 0
     };
+    sessions.set(deviceCode, session);
+    return runSlice(session, deviceCode, installationId || void 0);
 }
 const project_create_COMMAND = "extension_project_create";
-const FIRST_CALL_BUDGET_MS = 8000;
-const RESUME_BUDGET_MS = 22000;
+const project_create_FIRST_CALL_BUDGET_MS = 8000;
+const project_create_RESUME_BUDGET_MS = 22000;
 const project_create_schema = {
     name: "extension_project_create",
-    description: "Create an extension.dev project for an extension that does not have one yet, without opening the console. Use it right after extension_create and extension_build, once the extension's source is pushed to a GitHub repository, and BEFORE extension_auth: extension_auth can only log in to a project that already exists, and this tool is what brings that project into existence. Ask for nothing but the project slug and the repo; the platform finds the GitHub App installation on the approving account itself, and if there is none it returns a connect link to open. Two-phase, like login: the first call returns a code and a URL where the signed-in workspace owner approves creating exactly this project; call again with the returned deviceCode to finish. The approval mints a provisioning grant that lives minutes, can only create the one named project, and is never stored on this machine. On success the platform creates the project, its mirror repository, and dispatches the first build. Then run extension_auth (action: login) against the new project, and extension_publish to share it.",
+    description: "Create an extension.dev project for an extension that does not have one yet, without opening the console. Use it right after extension_create and extension_build, once the extension's source is pushed to a GitHub repository, and BEFORE extension_auth: extension_auth can only log in to a project that already exists, and this tool is what brings that project into existence. Ask for nothing but the project slug and the repo; the platform finds the GitHub App installation on the approving account itself, and if there is none it returns a connect link to open. Two-phase, like login: the first call returns a code and a URL where the signed-in workspace owner approves creating exactly this project; call again with the returned deviceCode to finish. The approval mints a provisioning grant that lives minutes, can only create the one named project, and is never stored on this machine. On success the platform creates the project, its mirror repository, and dispatches the first build. Then run extension_auth (action: login) against the new project, and extension_publish to share it. To create several projects in one workspace under one approval, pass `projects` instead of `project` and `repo`: the approval page lists every name, each project is created by its own request, and each one's 7-day token is stored as that project's login, so no extension_auth call is needed afterwards. A list takes a few calls to finish: while projects remain the answer is status 'creating' with the same deviceCode to call again, and the grant is held in this server's memory only. One approval creates at most 10 projects, the cap the platform states in its login config, because it creates at most 10 per hour for one approving account; the next 10 can start in a new call once that limit allows. A longer list is refused before any approval is asked for, never split silently, and so is any list on a platform that does not advertise batch onboarding.",
     inputSchema: {
         type: "object",
         properties: {
@@ -1970,19 +2812,23 @@ const project_create_schema = {
                 type: "object",
                 description: "Per-browser output directory overrides, for example {\"edge\": \"build/manifestv3\"}. A browser named here wins over `outputDirectory`."
             },
+            projects: {
+                type: "array",
+                items: {
+                    type: "object"
+                },
+                description: "Create several projects in one workspace under one approval, instead of `project` and `repo`. 1 to 10 entries (the platform's cap per approval; never more than 20), each { project: '<workspace>/<project>', repo: '<owner>/<repo>' }, all in the same workspace, each project named by its exact slug (lowercase letters and digits joined by single dashes, at most 48 characters), none twice and none existing yet. An entry may also carry displayName, description, installCommand, buildCommand, outputDirectory, browsers and outputDirectories for that project alone; the same inputs at the top level are the shared default for every entry that leaves them out. The answer carries one row per project: created and logged in, created with no token (run a batch extension_auth login), refused with the platform's code, or not attempted. A refusal on one project never hides the others."
+            },
             deviceCode: {
                 type: "string",
-                description: "Resume token from the prior call's `deviceCode`; omit on the first call."
+                description: "Resume token from the prior call's `deviceCode`; omit on the first call. A batch returns the same deviceCode until every listed project has an answer."
             },
             api: API_BASE
         },
-        required: [
-            "project",
-            "repo"
-        ]
+        required: []
     }
 };
-function fail(name, message, status, code, hint) {
+function project_create_fail(name, message, status, code, hint) {
     return envelope_envelope({
         ok: false,
         command: project_create_COMMAND,
@@ -1997,10 +2843,10 @@ function fail(name, message, status, code, hint) {
         } : {}
     });
 }
-function laneClosedHint() {
+function project_create_laneClosedHint() {
     return `Create the project in the console at ${consoleBase()} (workspace page, New project), then run extension_auth (action: login) against it. While the public hold is on, headless creation is open only to workspaces on the platform's allowlist (WWW_MCP_ACTION_ALLOWED_WORKSPACES), the same list that already lets publish, submit and promote run headlessly; this workspace is not on it, so the console is the route.`;
 }
-function pendingEnvelope(start) {
+function project_create_pendingEnvelope(start) {
     const complete = String(start.verificationUriComplete || "").trim();
     const hasCompleteLink = complete.length > 0 && complete !== start.verificationUri;
     const message = hasCompleteLink ? `Open ${complete} and approve creating the project (code ${start.userCode} is pre-filled), then call extension_project_create again with this deviceCode and the same arguments. If the page asks for a code, enter ${start.userCode} at ${start.verificationUri}.` : `Open ${start.verificationUri}, enter code ${start.userCode}, approve creating the project, then call extension_project_create again with this deviceCode and the same arguments.`;
@@ -2019,79 +2865,26 @@ function pendingEnvelope(start) {
         hint: message
     });
 }
-function buildCreateBody(args) {
-    const installCommand = String(args.installCommand || "npm install").trim();
-    const buildCommand = String(args.buildCommand || "npm run build").trim();
-    const wanted = new Set((Array.isArray(args.browsers) && args.browsers.length ? args.browsers : [
-        "chrome"
-    ]).map((name)=>String(name).trim().toLowerCase()));
-    const several = wanted.size > 1;
-    const outputFor = (name)=>{
-        const override = args.outputDirectories?.[name];
-        if ("string" == typeof override && override.trim()) return override.trim();
-        const pattern = String(args.outputDirectory || "").trim();
-        if (pattern.includes("<browser>")) return pattern.replaceAll("<browser>", name);
-        if (pattern && !several) return pattern;
-        return `dist/${name}`;
-    };
-    const browser = (name)=>({
-            enabled: wanted.has(name),
-            installCommand,
-            buildCommand,
-            outputDirectory: outputFor(name)
-        });
-    return {
-        info: {
-            id: "",
-            name: args.projectSlug,
-            displayName: String(args.displayName || args.projectSlug).trim(),
-            description: String(args.description || `Browser extension project for ${args.owner}/${args.repoName}.`).trim()
-        },
-        build: {
-            chrome: browser("chrome"),
-            edge: browser("edge"),
-            firefox: browser("firefox")
-        },
-        deployment: {
-            branch: "",
-            nodeVersion: "",
-            runWhatsNew: false,
-            runExtensionExecutables: false
-        },
-        github: {
-            owner: args.owner,
-            repo: args.repoName,
-            installationId: args.installationId,
-            createdAt: new Date().toISOString(),
-            pullRequestComments: true,
-            commitComments: false
-        },
-        workspaceSlug: args.workspace,
-        createdFrom: {
-            kind: "repository",
-            ref: `${args.owner}/${args.repoName}`
-        }
-    };
-}
 async function project_create_handler(args) {
+    if (void 0 !== args.projects && null !== args.projects) return createProjectBatch(args);
     const project = String(args.project || "").trim();
-    if (!/^[^/]+\/[^/]+$/.test(project)) return fail("BadRequest", "project must be in the form '<workspace>/<project>'.", "bad-request", "E_BAD_REQUEST");
+    if (!/^[^/]+\/[^/]+$/.test(project)) return project_create_fail("BadRequest", "project must be in the form '<workspace>/<project>'.", "bad-request", "E_BAD_REQUEST");
     const repo = String(args.repo || "").trim();
-    if (!/^[^/]+\/[^/]+$/.test(repo)) return fail("BadRequest", "repo must be in the form '<owner>/<repo>', a GitHub repository the extension's source is pushed to.", "bad-request", "E_BAD_REQUEST");
+    if (!/^[^/]+\/[^/]+$/.test(repo)) return project_create_fail("BadRequest", "repo must be in the form '<owner>/<repo>', a GitHub repository the extension's source is pushed to.", "bad-request", "E_BAD_REQUEST");
     const installationId = String(args.installationId || "").trim();
-    if (installationId && !/^\d+$/.test(installationId)) return fail("BadRequest", "installationId is optional, and when given it must be the numeric extension.dev GitHub App installation id. Omit it and the platform resolves it from the approving account.", "bad-request", "E_BAD_REQUEST");
+    if (installationId && !/^\d+$/.test(installationId)) return project_create_fail("BadRequest", "installationId is optional, and when given it must be the numeric extension.dev GitHub App installation id. Omit it and the platform resolves it from the approving account.", "bad-request", "E_BAD_REQUEST");
     const apiCheck = safeApiBase(resolveApiBase(args.api), args.api);
-    if (!apiCheck.ok) return fail("ConfigError", apiCheck.message, "bad-request", "E_BAD_REQUEST");
+    if (!apiCheck.ok) return project_create_fail("ConfigError", apiCheck.message, "bad-request", "E_BAD_REQUEST");
     const apiBase = apiCheck.base;
     let config;
     try {
         config = await fetchLoginConfig(apiBase);
     } catch (err) {
-        return fail("ConfigError", err?.message || "Could not load login config.", "create-failed", "E_PLATFORM");
+        return project_create_fail("ConfigError", err?.message || "Could not load login config.", "create-failed", "E_PLATFORM");
     }
     let deviceCode = String(args.deviceCode || "").trim();
     let interval = 5;
-    let budgetMs = RESUME_BUDGET_MS;
+    let budgetMs = project_create_RESUME_BUDGET_MS;
     if (!deviceCode) {
         let start;
         try {
@@ -2105,11 +2898,11 @@ async function project_create_handler(args) {
             const message = err?.message || "Could not start the device flow.";
             const laneClosed = /CLI_PROJECT_CREATE_DISABLED|403/.test(String(message));
             const serverMessage = "string" == typeof err?.serverMessage ? err.serverMessage.trim() : "";
-            return fail("CreateStartError", laneClosed ? serverMessage || `Headless project creation is not open on this host yet. Create the project in the console instead, then run extension_auth (action: login) against it. (${message})` : String(message), laneClosed ? "lane-closed" : "create-failed", "E_PLATFORM", laneClosed ? laneClosedHint() : void 0);
+            return project_create_fail("CreateStartError", laneClosed ? serverMessage || `Headless project creation is not open on this host yet. Create the project in the console instead, then run extension_auth (action: login) against it. (${message})` : String(message), laneClosed ? "lane-closed" : "create-failed", "E_PLATFORM", laneClosed ? project_create_laneClosedHint() : void 0);
         }
         deviceCode = start.deviceCode;
         interval = start.interval;
-        budgetMs = FIRST_CALL_BUDGET_MS;
+        budgetMs = project_create_FIRST_CALL_BUDGET_MS;
         const early = await pollDeviceGrant({
             apiBase,
             path: config.deviceTokenUrl,
@@ -2118,7 +2911,7 @@ async function project_create_handler(args) {
             interval,
             budgetMs
         });
-        if (!early.ok && "pending" === early.reason) return pendingEnvelope(start);
+        if (!early.ok && "pending" === early.reason) return project_create_pendingEnvelope(start);
         return finishFromPoll(early, {
             apiBase,
             project,
@@ -2155,16 +2948,16 @@ async function finishFromPoll(poll, ctx) {
             },
             hint: `Still waiting for approval at ${ctx.verificationUri}. Approve there, then call extension_project_create again with this same deviceCode.`
         });
-        if ("denied" === poll.reason) return fail("CreateDenied", "Creating the project was denied at extension.dev/device.", "create-denied", "E_AUTH_DENIED");
-        if ("expired" === poll.reason) return fail("CreateExpired", "The device code expired. Run extension_project_create again to restart.", "create-expired", "E_AUTH_EXPIRED");
-        return fail("CreateAuthError", poll.message || "Device authorization failed.", "create-failed", "E_AUTH_FAILED");
+        if ("denied" === poll.reason) return project_create_fail("CreateDenied", "Creating the project was denied at extension.dev/device.", "create-denied", "E_AUTH_DENIED");
+        if ("expired" === poll.reason) return project_create_fail("CreateExpired", "The device code expired. Run extension_project_create again to restart.", "create-expired", "E_AUTH_EXPIRED");
+        return project_create_fail("CreateAuthError", poll.message || "Device authorization failed.", "create-failed", "E_AUTH_FAILED");
     }
     const grant = poll.data;
     const token = String(grant.token || "").trim();
     const workspaceSlug = String(grant.workspaceSlug || "").trim();
     const projectSlug = String(grant.projectSlug || "").trim();
     const [wantWorkspace = "", wantProject = ""] = ctx.project.split("/");
-    if (workspaceSlug.toLowerCase() !== wantWorkspace.toLowerCase() || projectSlug.toLowerCase() !== wantProject.toLowerCase()) return fail("CreateScopeError", `The approval was scoped to ${workspaceSlug}/${projectSlug}, not the requested ${ctx.project}. Nothing was created. Run extension_project_create again with the intended project.`, "create-failed", "E_AUTH_FAILED");
+    if (workspaceSlug.toLowerCase() !== wantWorkspace.toLowerCase() || projectSlug.toLowerCase() !== wantProject.toLowerCase()) return project_create_fail("CreateScopeError", `The approval was scoped to ${workspaceSlug}/${projectSlug}, not the requested ${ctx.project}. Nothing was created. Run extension_project_create again with the intended project.`, "create-failed", "E_AUTH_FAILED");
     if ("provisioning" !== String(grant.tokenKind || "")) return envelope_envelope({
         ok: false,
         command: project_create_COMMAND,
@@ -2175,7 +2968,7 @@ async function finishFromPoll(poll, ctx) {
         },
         hint: `Run extension_auth (action: login) with project '${ctx.project}' instead; the login lane mints the project token this tool deliberately does not.`
     });
-    const [owner = "", repoName = ""] = ctx.args.repo.split("/");
+    const [owner = "", repoName = ""] = String(ctx.args.repo || "").split("/");
     const body = buildCreateBody({
         workspace: wantWorkspace,
         projectSlug: wantProject,
@@ -2203,7 +2996,7 @@ async function finishFromPoll(poll, ctx) {
             body: JSON.stringify(body)
         });
     } catch (err) {
-        return fail("CreateNetworkError", `Could not reach ${url}: ${err?.message || err}`, "create-failed", "E_NETWORK");
+        return project_create_fail("CreateNetworkError", `Could not reach ${url}: ${err?.message || err}`, "create-failed", "E_NETWORK");
     }
     const text = await res.text();
     let data;
@@ -2225,7 +3018,7 @@ async function finishFromPoll(poll, ctx) {
                 project: wantProject
             }
         });
-        if ("CLI_PROJECT_CREATE_DISABLED" === code) return fail("CreateClosed", String(data.message || "Headless project creation is not open yet."), "lane-closed", "E_PLATFORM", laneClosedHint());
+        if ("CLI_PROJECT_CREATE_DISABLED" === code) return project_create_fail("CreateClosed", String(data.message || "Headless project creation is not open yet."), "lane-closed", "E_PLATFORM", project_create_laneClosedHint());
         const connectUrl = String(data.connectUrl || "").trim();
         if ("INSTALLATION_ABSENT" === code || "INSTALLATION_ORG_UNSUPPORTED" === code || "INSTALLATION_AMBIGUOUS" === code) return envelope_envelope({
             ok: false,
@@ -2253,7 +3046,7 @@ async function finishFromPoll(poll, ctx) {
             },
             hint: `Run extension_auth (action: login) with project '${ctx.project}'.`
         });
-        return fail("CreateError", `create failed (${res.status}): ${String(data.message || data.error || text || "unknown error").slice(0, 500)}`, "create-failed", "E_PLATFORM");
+        return project_create_fail("CreateError", `create failed (${res.status}): ${String(data.message || data.error || text || "unknown error").slice(0, 500)}`, "create-failed", "E_PLATFORM");
     }
     const finalWorkspace = String(data.workspaceSlug || wantWorkspace);
     const finalProject = String(data.projectSlug || wantProject);
@@ -3054,7 +3847,7 @@ async function outputFlagRefusalMessage(command, cliName, projectPath) {
     if (true === verdict.supported) return `${preamble} It reports ${verdict.version}, which is at or above ${verdict.floor}, the release where that flag reached \`extension ${cliName}\`, so the binary being run is not the version it claims to be. ${why} Check the project's node_modules/.bin/extension and reinstall it, rather than upgrading a version that already looks new enough.`;
     return `${preamble} Its version could not be read, so the cause cannot be confirmed, but that flag only reached \`extension ${cliName}\` in ${verdict.floor} and a refusal is what an engine below that does. ${why} Check the project's Extension.js install and bring it to ${verdict.floor} or newer.`;
 }
-const sessions = new Map();
+const process_manager_sessions = new Map();
 const registrationStamps = new Map();
 function sessionKey(projectPath, browser) {
     return `${node_path.resolve(projectPath)}::${browser}`;
@@ -3115,7 +3908,7 @@ function registerSession(info) {
         pid: info.pid,
         at
     });
-    sessions.set(key, info);
+    process_manager_sessions.set(key, info);
     writeMarkerBestEffort(info, at);
 }
 function sessionSinceMs(projectPath, browser) {
@@ -3133,19 +3926,19 @@ function sessionSinceMs(projectPath, browser) {
     return null;
 }
 function findSessionInfo(projectPath, browser) {
-    const inMemory = sessions.get(sessionKey(projectPath, browser));
+    const inMemory = process_manager_sessions.get(sessionKey(projectPath, browser));
     if (inMemory) return inMemory;
     const resolved = node_path.resolve(projectPath);
     for (const marker of listSessionMarkers())if (node_path.resolve(marker.projectPath) === resolved && marker.browser === browser) return marker;
 }
 function removeSession(projectPath, browser, pid) {
     const key = sessionKey(projectPath, browser);
-    if (void 0 !== pid && sessions.get(key)?.pid !== pid) return;
-    sessions.delete(key);
+    if (void 0 !== pid && process_manager_sessions.get(key)?.pid !== pid) return;
+    process_manager_sessions.delete(key);
     registrationStamps.delete(key);
 }
 function listSessions() {
-    return Array.from(sessions.values());
+    return Array.from(process_manager_sessions.values());
 }
 const PROJECT_MANIFEST_FILENAMES = [
     "package.json",
@@ -15940,7 +16733,7 @@ async function publish_handler(args) {
     let note = null;
     if (null != args.ttlHours && "public" === data.visibility) note = "ttlHours was ignored: this is a public project, whose share URL is its canonical public page.";
     let buildNote = null;
-    const ref = resolveProjectRef();
+    const ref = loginProjectRef(args.project);
     if (ref) {
         const buildsUrl = registryFileUrl(ref, "builds/index.json");
         const buildsRes = await fetchRegistryJson(buildsUrl, fetch, {
@@ -16144,7 +16937,7 @@ async function release_promote_handler(args) {
         const code = "string" == typeof data?.code ? data.code : void 0;
         const enrich = {};
         let hint = "";
-        const ref = resolveProjectRef();
+        const ref = loginProjectRef(args.project);
         if (404 === res.status || "UNKNOWN_BUILD" === code) {
             enrich.buildsPageUrl = consoleProjectUrl(ref, "builds", args.api);
             hint = "Run extension_release_status to see this project's channels, their promoted shas, and recent builds.";
@@ -16180,7 +16973,7 @@ async function release_promote_handler(args) {
             hint
         });
     }
-    const promotedRef = resolveProjectRef();
+    const promotedRef = loginProjectRef(args.project);
     const publicChannelUrl = userlandProjectUrl(promotedRef, UserlandProjectPage.channel(channel), args.api);
     const publicBuildUrl = userlandProjectUrl(promotedRef, UserlandProjectPage.build(buildId), args.api);
     const allowance = spendNarration({
@@ -16854,7 +17647,7 @@ async function submit_handler(args) {
     let channelNote = null;
     let statusNote = null;
     if (dryRun) {
-        const ref = resolveProjectRef();
+        const ref = loginProjectRef(args.project);
         const consoleStoresUrl = consoleProjectUrl(ref, ConsoleProjectPage.submissions, args.api);
         const storeModeNote = `Store publish mode (draft / skip-publish / live) is not readable with the CLI token, so it cannot be verified from here; check per-store settings at ${consoleStoresUrl}.`;
         let health = null;
@@ -17449,7 +18242,7 @@ async function add_feature_handler(args) {
 const login_FIRST_CALL_BUDGET_MS = 8000;
 const login_RESUME_BUDGET_MS = 22000;
 const PENDING_TTL_NOTE = "Once authorized, the minted token lives at most 7 days (server-enforced); CI must re-mint before expiry (console: project settings -> Access tokens).";
-function login_fail(name, message, status, code) {
+function login_fail(name, message, status, code, extra) {
     return envelope_envelope({
         ok: false,
         command: "extension_auth",
@@ -17458,7 +18251,13 @@ function login_fail(name, message, status, code) {
             code,
             name,
             message
-        }
+        },
+        ...extra?.value ? {
+            value: extra.value
+        } : {},
+        ...extra?.hint ? {
+            hint: extra.hint
+        } : {}
     });
 }
 function success(creds) {
@@ -17574,6 +18373,156 @@ async function loginToProject(args) {
         verificationUriComplete: start.verificationUriComplete
     });
 }
+const BATCH_FINAL_POLL_NOTE = "The platform records one token per project before it answers, so the call that completes a batch login can take up to a minute. Let it finish: the device code is spent the moment minting starts, and a call abandoned midway cannot be resumed.";
+function batchPending(args) {
+    const complete = String(args.verificationUriComplete || "").trim();
+    const hasCompleteLink = complete.length > 0 && complete !== args.verificationUri;
+    const again = "then call extension_auth (action: login) again with this deviceCode and the same projects";
+    const hint = args.userCode ? hasCompleteLink ? `Open ${complete} and approve (code ${args.userCode} is pre-filled). The page lists all ${args.projects.length} projects this one approval signs in to; ${again}. If the page asks for a code, enter ${args.userCode} at ${args.verificationUri}.` : `Open ${args.verificationUri} and enter code ${args.userCode}. The page lists all ${args.projects.length} projects this one approval signs in to; ${again}.` : `Still waiting for authorization. The link and code from the previous response are still valid: approve at ${args.verificationUri}, ${again}.`;
+    return envelope_envelope({
+        ok: true,
+        command: "extension_auth",
+        status: "authorization-pending",
+        value: {
+            ...args.userCode ? {
+                userCode: args.userCode
+            } : {},
+            verificationUri: args.verificationUri,
+            ...args.userCode && hasCompleteLink ? {
+                verificationUriComplete: complete
+            } : {},
+            deviceCode: args.deviceCode,
+            projects: args.projects,
+            legacyStatus: "authorization_pending"
+        },
+        hint,
+        warnings: [
+            PENDING_TTL_NOTE,
+            BATCH_FINAL_POLL_NOTE
+        ]
+    });
+}
+function batchRefusal(poll, projects) {
+    if ("expired" === poll.reason) return login_fail("LoginExpired", "The device code expired or was already spent. Run extension_auth (action: login) again with the same projects to restart.", "login-expired", "E_AUTH_EXPIRED");
+    const code = String(poll.code || "");
+    if ("PROJECT_NOT_FOUND" === code) {
+        const missing = Array.isArray(poll.body?.missingProjects) ? (poll.body?.missingProjects).map(String) : [];
+        return login_fail("LoginProjectNotFound", poll.message || "At least one listed project does not exist, so no token was minted for any of them.", "login-failed", "E_AUTH_FAILED", {
+            value: {
+                code,
+                missingProjects: missing,
+                projects
+            },
+            hint: `A batch login is all or nothing and covers only projects that already exist. ${missing.length ? `Drop or fix ${missing.join(", ")} and run extension_auth (action: login) again with the rest` : "Check each name against the console and run extension_auth (action: login) again"}; create missing projects with extension_project_create or at ${consoleBase()}.`
+        });
+    }
+    if ("MEMBERSHIP_REVOKED" === code) return login_fail("LoginMembershipRevoked", poll.message || "The member who approved this login is no longer in the workspace, so no token was minted.", "login-failed", "E_AUTH_FAILED", {
+        value: {
+            code,
+            projects
+        }
+    });
+    if ("denied" === poll.reason) return login_fail("LoginDenied", "Authorization was denied at extension.dev/device.", "login-denied", "E_AUTH_DENIED");
+    return login_fail("LoginError", poll.message || "Device login failed.", "login-failed", "E_AUTH_FAILED", {
+        value: {
+            ...code ? {
+                code
+            } : {},
+            projects
+        },
+        hint: "No token from this batch was stored. Run extension_auth (action: login) again with the same projects; a batch that was refused or failed midway is closed on the platform and needs a fresh approval."
+    });
+}
+async function loginToProjects(args) {
+    const parsed = parseProjectBatch(args.projects);
+    if (!parsed.ok) return login_fail("BadRequest", parsed.message, "bad-request", "E_BAD_REQUEST");
+    const projects = parsed.batch.refs;
+    const apiCheck = safeApiBase(resolveApiBase(args.api), args.api);
+    if (!apiCheck.ok) return login_fail("LoginConfigError", apiCheck.message, "login-failed", "E_AUTH_FAILED");
+    const apiBase = apiCheck.base;
+    let config;
+    try {
+        config = await fetchLoginConfig(apiBase);
+    } catch (err) {
+        return login_fail("LoginConfigError", err?.message || "Could not load login config.", "login-failed", "E_AUTH_FAILED");
+    }
+    if (!config.batch) return login_fail("LoginBatchUnsupported", BATCH_UNSUPPORTED_MESSAGE, "batch-unsupported", "E_PLATFORM", {
+        value: {
+            projects
+        },
+        hint: "Sign in to each project with its own extension_auth (action: login, project) call."
+    });
+    if (projects.length > config.batch.loginProjectsPerApproval) return login_fail("BadRequest", `projects names ${projects.length} projects, and one approval signs in to at most ${config.batch.loginProjectsPerApproval} on this platform.`, "bad-request", "E_BAD_REQUEST", {
+        hint: `Split the list into calls of ${config.batch.loginProjectsPerApproval} or fewer; each call is its own approval. No device code was spent.`
+    });
+    let deviceCode = String(args.deviceCode || "").trim();
+    let interval = 5;
+    let budgetMs = login_RESUME_BUDGET_MS;
+    let start = null;
+    if (!deviceCode) {
+        try {
+            start = await requestDeviceCode({
+                apiBase,
+                path: config.deviceCodeUrl,
+                projects
+            });
+        } catch (err) {
+            return login_fail("LoginStartError", err?.message || "Could not start the device flow.", "login-failed", "E_AUTH_FAILED", {
+                hint: "No device code was issued. Sign in to each project with its own extension_auth (action: login, project) call, or fix what the platform refused and try the list again."
+            });
+        }
+        deviceCode = start.deviceCode;
+        interval = start.interval;
+        budgetMs = login_FIRST_CALL_BUDGET_MS;
+    }
+    const poll = await pollDeviceGrant({
+        apiBase,
+        path: config.deviceTokenUrl,
+        projects,
+        deviceCode,
+        interval,
+        budgetMs
+    });
+    if (!poll.ok) {
+        if ("pending" === poll.reason) return batchPending({
+            deviceCode,
+            projects,
+            verificationUri: start?.verificationUri ?? config.verificationUri,
+            userCode: start?.userCode,
+            verificationUriComplete: start?.verificationUriComplete
+        });
+        return batchRefusal(poll, projects);
+    }
+    let stored;
+    try {
+        stored = persistBatchTokenResponse({
+            apiBase,
+            projects,
+            data: poll.data
+        });
+    } catch (err) {
+        return login_fail("LoginError", err?.message ? String(err.message) : String(err), "login-failed", "E_AUTH_FAILED");
+    }
+    const logins = stored.map((creds)=>({
+            project: `${creds.workspaceSlug}/${creds.projectSlug}`,
+            workspaceSlug: creds.workspaceSlug,
+            projectSlug: creds.projectSlug,
+            expiresAt: creds.expiresAt ? new Date(1000 * creds.expiresAt).toISOString() : null
+        }));
+    return envelope_envelope({
+        ok: true,
+        command: "extension_auth",
+        status: "logged-in",
+        value: {
+            workspaceSlug: parsed.batch.workspace,
+            logins
+        },
+        hint: `Logged in to ${logins.length} project${1 === logins.length ? "" : "s"} in ${parsed.batch.workspace}: ${logins.map((login)=>login.projectSlug).join(", ")}. Each has its own stored token; token-scoped tools take \`project\` to pick one, and extension_auth (action: status) lists them. The default login was left as it was unless none existed. Every token expires within 7 days, so one batch login renews them together.`,
+        warnings: [
+            tokenTtlNote()
+        ]
+    });
+}
 const server_identity_DEFAULT_TIMEOUT_MS = 5000;
 async function askServerIdentity(args) {
     const fetchImpl = args.fetchImpl ?? fetch;
@@ -17763,7 +18712,7 @@ async function clearLocalCredentials(project) {
 }
 const auth_schema = {
     name: "extension_auth",
-    description: "Sign this machine in to extension.dev, report that login, or clear it. Pass action:'status' (the default) to name the workspace and project the stored token is scoped to and when it expires, never the token itself; that identity comes from the stored token alone, and does not change with the current working directory or whichever project folder you are in. Status also asks the platform's whoami endpoint whether that credential actually resolves there: the answer is reported as confirmed, refused-by-server, or unverified when the server cannot be reached, so a local file claiming a login the server would refuse is never reported as simply logged in. Pass action:'login' for a two-phase flow: call with `project` to get a code plus a URL the user authorizes at extension.dev/device, then call again with the returned `deviceCode`. GitHub federation happens server-side, so no GitHub token lands on this machine. Minted tokens live at most 7 days, server-enforced, so CI must re-mint before expiry on the console's project settings, Access tokens page. Pass action:'logout' to delete the local credentials only (with `project`, just that project's login); the token stays valid server-side until it is revoked at the URL the response returns. Several logins live side by side on one machine, one per workspace/project, and status lists them all under `logins`.",
+    description: "Sign this machine in to extension.dev, report that login, or clear it. Pass action:'status' (the default) to name the workspace and project the stored token is scoped to and when it expires, never the token itself; that identity comes from the stored token alone, and does not change with the current working directory or whichever project folder you are in. Status also asks the platform's whoami endpoint whether that credential actually resolves there: the answer is reported as confirmed, refused-by-server, or unverified when the server cannot be reached, so a local file claiming a login the server would refuse is never reported as simply logged in. Pass action:'login' for a two-phase flow: call with `project` to get a code plus a URL the user authorizes at extension.dev/device, then call again with the returned `deviceCode`. GitHub federation happens server-side, so no GitHub token lands on this machine. Minted tokens live at most 7 days, server-enforced, so CI must re-mint before expiry on the console's project settings, Access tokens page. Pass action:'logout' to delete the local credentials only (with `project`, just that project's login); the token stays valid server-side until it is revoked at the URL the response returns. Several logins live side by side on one machine, one per workspace/project, and status lists them all under `logins`. To sign in to several existing projects of one workspace at once, pass `projects` instead of `project`: one approval, one stored token per project.",
     inputSchema: {
         type: "object",
         properties: {
@@ -17780,6 +18729,13 @@ const auth_schema = {
                 type: "string",
                 description: "login: target project as '<workspace>/<project>'; the token is scoped to it. The slug pair is the console address bar: an existing project's page is console.extension.dev/<workspace>/<project>. Create one at extension.dev/new if none exists yet. Logins to several projects are all kept, the latest is the default; token-scoped tools take `project` to pick another. logout: remove only this project's login (omitted, every stored login goes)."
             },
+            projects: {
+                type: "array",
+                items: {
+                    type: "string"
+                },
+                description: "login: sign in to several existing projects of one workspace with one approval, instead of one approval each. 1 to 20 names as '<workspace>/<project>', all in the same workspace, each by its exact slug (lowercase letters and digits joined by single dashes, at most 48 characters), none twice. Pass it instead of `project`, never beside it. The approval page lists every name; one missing project refuses the whole list and mints nothing. Resume with the returned `deviceCode` and the same list. Every token is stored as that project's own login and all expire within 7 days, so the same call renews them together."
+            },
             deviceCode: {
                 type: "string",
                 description: "login: resume token from the prior call's `deviceCode`; omit on the first call."
@@ -17789,9 +18745,31 @@ const auth_schema = {
         required: []
     }
 };
+function listMisuse(message) {
+    return envelope_envelope({
+        ok: false,
+        command: "extension_auth",
+        status: "bad-request",
+        error: {
+            code: "E_BAD_REQUEST",
+            name: "BadRequest",
+            message
+        }
+    });
+}
 async function auth_handler(args) {
     const action = args.action ?? "status";
+    const hasList = void 0 !== args.projects && null !== args.projects;
+    if (hasList && "login" !== action) return listMisuse(`projects is a login input: action '${action}' does not take a list. Use project to name one login, or call once per project.`);
     if ("logout" === action) return clearLocalCredentials(args.project);
+    if ("login" === action && hasList) {
+        if (String(args.project ?? "").trim()) return listMisuse("Pass either project (one login) or projects (one approval for several), not both.");
+        return loginToProjects({
+            projects: args.projects,
+            deviceCode: args.deviceCode,
+            api: args.api
+        });
+    }
     if ("login" === action) return loginToProject({
         project: String(args.project ?? ""),
         deviceCode: args.deviceCode,
@@ -18985,6 +19963,35 @@ function pinProjectArgs(name, args, inputSchema, options) {
     if (!pinned) return {
         args
     };
+    if (void 0 !== args.projects && null !== args.projects) {
+        const entries = Array.isArray(args.projects) ? args.projects : [
+            args.projects
+        ];
+        const names = entries.map((entry)=>"string" == typeof entry ? entry.trim() : entry && "object" == typeof entry && !Array.isArray(entry) ? String(entry.project ?? "").trim() : "");
+        const others = names.filter((entry)=>!entry.includes("/") || !sameProject(entry, pinned));
+        if (others.length > 0 || 0 === entries.length) {
+            const shown = others.map((entry)=>entry || "(an unnamed entry)");
+            return {
+                refused: envelope_envelope({
+                    ok: false,
+                    command: name,
+                    status: "project-pinned",
+                    error: {
+                        code: "E_TOOL_DISABLED",
+                        message: `This server is pinned to ${pinned} and was asked to act on a list naming ${shown.length ? shown.join(", ") : "no project"}.`
+                    },
+                    value: {
+                        pinned,
+                        named: shown
+                    },
+                    hint: `A pinned server takes a batch only when every entry is ${pinned}. Work on other projects through an MCP server configured without --project, or with its own --project (or ${PROJECT_PIN_ENV}).`
+                })
+            };
+        }
+        return {
+            args
+        };
+    }
     const named = "string" == typeof args.project ? args.project : "";
     if (named && !sameProject(named, pinned)) return {
         refused: envelope_envelope({