@thegitai/cli 1.0.0-beta.9 → 1.0.0-preview.10

package/README.md

@@ -1,7 +1,10 @@
-# TheGitAI
+# TheGitAI — AI coding agent for your terminal
 
-Interactive terminal coding agent. Talk to your repo in plain English — it
-reads code, edits files, and runs commands with your approval.
+TheGitAI is an AI coding agent for your terminal. It indexes your repository,
+writes and edits files, runs commands, and builds features with you.
+
+Talk to your repo in plain English. TheGitAI can keep long-running processes
+going while you work, all with your approval.
 
 ## Install
 
@@ -25,6 +28,49 @@ ai --version        print the version and exit
 
 Run `ai --help` for sessions, modes, keys, and chat commands.
 
+Coding sessions require an interactive terminal on stdin and stdout. Piped
+one-shot prompts are not supported. Saved history is local to the repo and can
+always be viewed or resumed from that computer. Continuing it through the
+service requires the TheGitAI account used for that session. Local sessions can
+also be listed while signed out or offline.
+
+CLI login tokens use a rolling 24-hour inactivity timeout. If one expires during
+any server request, the CLI saves the local session, removes the expired
+credential, and asks you to run `ai login` before resuming.
+
+## Visible to-do list
+
+For larger multi-step tasks, the agent keeps a compact to-do list on screen so
+you can see what it plans to do, what it is working on right now, and what is
+already done.
+
+- While the agent works, the list sits at the bottom of the live **Working**
+  area, right above where you type, and updates as steps start and finish —
+  one step in progress at a time — so it stays visible even when tool output
+  above it runs long.
+- When the turn ends, a final snapshot of the list stays readable in the
+  transcript, and the footer shows a small progress chip (e.g. `◐ 4/6 to-dos`)
+  while steps remain open.
+- The agent's current reasoning stays visible too, right below the list, in a
+  compact one-line form so it doesn't compete with the list for space.
+- The list is managed entirely by the agent; simple one-step requests skip it.
+
+## Background jobs
+
+Some commands are meant to keep running — a dev server, a file watcher, a local
+API. TheGitAI runs these as **background jobs**, so the agent can start a server,
+work against it live, and stop it when the task is done, all in one session.
+
+- Each job's block in the transcript updates on its own with a live tail of its
+  latest output, and a compact indicator keeps you aware of what's still running.
+- Type `/jobs` to open a picker: **↑ / ↓** to move, **Enter** to expand a job and
+  read its output inline, **k** to stop it, **Esc** to close.
+- `/jobs output <id>` prints a job's full output, and `/jobs kill <id>` stops one
+  by id.
+- When you end the session, TheGitAI stops its background jobs for you.
+
+Full documentation: <https://thegit.ai/docs>
+
 ## License
 
 Proprietary — see the LICENSE file included in this package. Source is

package/dist/bin/ai.js

@@ -1,15 +1,15 @@
 #!/usr/bin/env node
-import chalk from 'chalk';
+import chalk from '../src/colors.js';
 import { stdin as input, stdout as output } from 'node:process';
 import readline from 'node:readline/promises';
 import { ServerApi } from '../src/api/index.js';
 import { loginViaBrowser } from '../src/api/browser-login.js';
-import { formatCliHelpText, formatInteractiveHelpText, } from '../src/help-text.js';
-import { renderMarkdownForTerminal } from '../src/markdown-renderer.js';
+import { authenticationErrorMessage, isAuthenticationError, isTransientNetworkError, } from '../src/api/http.js';
+import { formatCliHelpText } from '../src/help-text.js';
 import { createIndex } from '../src/project-index.js';
-import { createSession, clearConversation } from '../src/session.js';
-import { applySessionSnapshot, listSessionMetadata, loadSessionSnapshot, saveSessionState, } from '../src/session-store.js';
-import { runClientInteractive, shouldUseClientRatatuiShell, } from '../src/ui/repl.js';
+import { createSession } from '../src/session.js';
+import { applySessionSnapshot, listSessionMetadata, loadSessionSnapshot, saveSessionState, sessionHasUserMessage, } from '../src/session-store.js';
+import { runClientInteractive } from '../src/ui/repl.js';
 import { appendPromptToFile } from '../src/ui/prompt-history-store.js';
 import { formatSessionExitNotice } from '../src/session-exit.js';
 import { formatUsageText } from '../src/usage.js';
@@ -36,9 +36,6 @@ function appendPromptHistory(prompt, env = process.env) {
 }
 async function runAuthCommand(command, args) {
     if (command === 'login') {
-        // The public CLI always authenticates against the official TheGitAI host.
-        // There is intentionally no server/website override here — internal dev
-        // uses private tooling, not a customer-visible runtime override path.
         const serverUrl = DEFAULT_SERVER_URL;
         const noBrowser = args.includes('--no-browser');
         console.log(chalk.dim(noBrowser
@@ -111,45 +108,16 @@ function printSessionList(rootDir, sessions, serverModels) {
         }
     }
 }
-function printStartupBanner(rootDir, modelLabel, autoYes) {
-    console.log(chalk.dim(`Project: ${rootDir}`));
-    console.log(chalk.dim(`Model: ${modelLabel}`));
-    if (autoYes) {
-        console.log(chalk.dim('Auto-confirm: enabled'));
-    }
-}
-function printSessionStartup(session) {
-    console.log(chalk.dim(`Session: ${session.sessionName ? `${session.sessionName} ` : ''}${session.sessionId}`));
-}
 function printSessionExit(session) {
     console.log(chalk.dim(`\n${formatSessionExitNotice(session.sessionId)}\n`));
 }
 function modelLabel(serverModels, modelId) {
-    return (serverModels.models.find((model) => model.id === modelId)?.label ??
-        'Unknown model');
-}
-function makeConfirmCommand(session) {
-    return async (command) => {
-        console.log(chalk.bold(`\nCommand approval needed:\n${command}\n`));
-        const answer = (await promptText('Approve? [y]es/[a]ll/[n]o', 'n')).toLowerCase();
-        if (answer === 'a' || answer === 'all') {
-            session.autoYes = true;
-            return true;
-        }
-        return answer === 'y' || answer === 'yes';
-    };
-}
-function makeConfirmPatch(session) {
-    return async (filePath) => {
-        const answer = (await promptText(`Apply patch to ${filePath}? [y]es/[a]ll/[n]o`, 'n')).toLowerCase();
-        if (answer === 'a' || answer === 'all') {
-            session.autoYes = true;
-            return true;
-        }
-        return answer === 'y' || answer === 'yes';
-    };
+    return (serverModels?.models.find((model) => model.id === modelId)?.label ??
+        `Model ${modelId}`);
 }
 async function saveSessionBoth({ session, serverSessionClient, }) {
+    if (!sessionHasUserMessage(session))
+        return;
     saveSessionState(session);
     try {
         await serverSessionClient.save(session);
@@ -158,133 +126,18 @@ async function saveSessionBoth({ session, serverSessionClient, }) {
         console.error(chalk.yellow(`Warning: session save failed: ${error.message}`));
     }
 }
-async function promptForModelSelection(currentModelId, authConfig) {
-    const serverModels = await models.fetchServerModels({ config: authConfig });
-    console.log(chalk.bold('\nAvailable models'));
-    for (const model of serverModels.models) {
-        const marker = model.id === currentModelId ? '*' : ' ';
-        console.log(`${marker} ${model.id}  ${model.label}`);
-    }
-    console.log();
-    const selected = (await promptText('Model id', '')).trim() || null;
-    if (!selected) {
-        return { selected: null, serverModels };
-    }
-    return {
-        selected: models.validateServerModel(selected, serverModels),
-        serverModels,
-    };
-}
-async function promptForResumeSession(rootDir, serverModels) {
-    const sessions = listSessionMetadata(rootDir);
-    if (!sessions.length) {
-        console.log(chalk.dim('No saved sessions for this repo.\n'));
-        return null;
-    }
-    printSessionList(rootDir, sessions, serverModels);
-    console.log();
-    const identifier = (await promptText('Session id or name', '')).trim();
-    if (!identifier) {
-        return null;
-    }
-    return loadSessionSnapshot(rootDir, identifier);
-}
-async function runTurn({ authConfig, projectIndex, serverSessionClient, session, inputText, }) {
-    const prompt = String(inputText ?? '').trim();
-    if (!prompt)
-        return;
-    appendPromptHistory(prompt, session.env);
-    const result = await chat.sendServerUserMessage({
-        config: authConfig,
-        projectIndex,
-        session,
-        input: prompt,
-    });
-    if (result.text) {
-        console.log(`\n${chalk.green('TheGitAI>')}`);
-        console.log(renderMarkdownForTerminal(result.text));
-        console.log();
-    }
-    await saveSessionBoth({ session, serverSessionClient });
-}
-async function mainInteractive({ authConfig, projectIndex, serverModels, serverSessionClient, session, usageText, initialPrompt, }) {
-    if (initialPrompt) {
-        console.log(chalk.dim(`Prompt: "${initialPrompt}"`));
-        await runTurn({
-            authConfig,
-            projectIndex,
-            serverSessionClient,
-            session,
-            inputText: initialPrompt,
-        });
+function requireInteractiveTerminal() {
+    if (process.stdin.isTTY !== true) {
+        console.error('Error: stdin is not a terminal');
+        process.exitCode = 1;
+        return false;
     }
-    while (true) {
-        const inputText = await promptText('you');
-        const trimmed = inputText.trim();
-        if (!trimmed)
-            continue;
-        if (trimmed === '/exit')
-            return;
-        if (trimmed === '/help') {
-            console.log(renderMarkdownForTerminal(formatInteractiveHelpText()));
-            continue;
-        }
-        if (trimmed === '/usage') {
-            console.log(await usageText());
-            continue;
-        }
-        if (trimmed === '/clear') {
-            clearConversation(session);
-            await saveSessionBoth({ session, serverSessionClient });
-            console.log(chalk.dim('Conversation cleared.\n'));
-            continue;
-        }
-        if (trimmed === '/resume') {
-            const snapshot = await promptForResumeSession(session.rootDir, serverModels);
-            if (!snapshot) {
-                console.log(chalk.dim('Resume cancelled.\n'));
-                continue;
-            }
-            applySessionSnapshot(session, snapshot);
-            await saveSessionBoth({ session, serverSessionClient });
-            console.log(chalk.dim(`Resumed session${session.sessionName ? ` "${session.sessionName}"` : ''} (${session.sessionId})\n`));
-            continue;
-        }
-        if (trimmed === '/model' || trimmed.startsWith('/model ')) {
-            const inline = trimmed.slice('/model'.length).trim();
-            let serverModels;
-            let selected = null;
-            if (inline) {
-                serverModels = await models.fetchServerModels({ config: authConfig });
-                selected = models.validateServerModel(inline, serverModels);
-            }
-            else {
-                const response = await promptForModelSelection(session.modelId, authConfig);
-                serverModels = response.serverModels;
-                selected = response.selected;
-            }
-            if (!selected) {
-                console.log(chalk.dim('Model selection cancelled.\n'));
-                continue;
-            }
-            session.modelId = selected;
-            models.updateSelectedModelCache({
-                config: authConfig,
-                selectedModelId: selected,
-                serverModels,
-            });
-            await saveSessionBoth({ session, serverSessionClient });
-            console.log(chalk.dim(`Switched to ${modelLabel(serverModels, selected)}.\n`));
-            continue;
-        }
-        await runTurn({
-            authConfig,
-            projectIndex,
-            serverSessionClient,
-            session,
-            inputText: trimmed,
-        });
+    if (process.stdout.isTTY !== true) {
+        console.error('Error: stdout is not a terminal');
+        process.exitCode = 1;
+        return false;
     }
+    return true;
 }
 export async function main() {
     const { autoYes, help, version, usage, command, commandArgs, session: sessionIdentifier, listSessions, unknownOption, prompt, } = parseArgs(process.argv);
@@ -312,18 +165,64 @@ export async function main() {
         return;
     }
     const rootDir = process.cwd();
-    const authConfig = requireCliAuthConfig();
-    const serverSessionClient = sessions.createServerSessionClient({ config: authConfig });
-    const cachedModels = models.readCachedServerModels();
-    const serverModels = await models.fetchServerModels({ config: authConfig });
-    const whoami = await auth.fetchWhoamiResponse({ config: authConfig });
     if (listSessions) {
-        printSessionList(rootDir, listSessionMetadata(rootDir), serverModels);
+        const activeServerUrl = auth.readCliAuthConfig()?.serverUrl ?? DEFAULT_SERVER_URL;
+        printSessionList(rootDir, listSessionMetadata(rootDir), models.selectCacheForServer(models.readCachedServerModels(), activeServerUrl));
         return;
     }
     const sourceSnapshot = sessionIdentifier
         ? loadSessionSnapshot(rootDir, sessionIdentifier)
         : null;
+    if (sessionIdentifier && !sourceSnapshot) {
+        console.error(`Error: No saved session named or identified by "${sessionIdentifier}" is available for this repo. Run \`ai --list-sessions\`.`);
+        process.exitCode = 1;
+        return;
+    }
+    if (!requireInteractiveTerminal()) {
+        return;
+    }
+    const authConfig = requireCliAuthConfig();
+    const serverSessionClient = sessions.createServerSessionClient({ config: authConfig });
+    const cachedModels = models.selectCacheForServer(models.readCachedServerModels(), authConfig.serverUrl);
+    let offlineNotice = null;
+    let serverModels;
+    try {
+        serverModels = await models.fetchServerModels({ config: authConfig });
+    }
+    catch (error) {
+        if (isTransientNetworkError(error) && cachedModels?.models.length) {
+            serverModels = { models: cachedModels.models };
+            offlineNotice = error?.message ? String(error.message) : 'network error';
+        }
+        else {
+            throw error;
+        }
+    }
+    let whoami;
+    try {
+        whoami = await auth.fetchWhoamiResponse({ config: authConfig });
+    }
+    catch (error) {
+        if (isTransientNetworkError(error)) {
+            whoami = {
+                customer: {
+                    id: '',
+                    uuid: '',
+                    email: authConfig.email,
+                    customer_type: authConfig.customerType ?? 'USER',
+                    scopes: [],
+                },
+                debugUi: { showSessionId: false },
+            };
+            offlineNotice ??= error?.message ? String(error.message) : 'network error';
+        }
+        else {
+            throw error;
+        }
+    }
+    if (offlineNotice) {
+        console.error(chalk.yellow(`⚠ Couldn't reach TheGitAI (${offlineNotice}). Starting with cached settings — it will reconnect on your next message.`));
+    }
     const selectedModelId = models.selectServerModel({
         requestedModelId: sourceSnapshot?.modelId ?? null,
         cached: cachedModels,
@@ -339,11 +238,8 @@ export async function main() {
         autoYes,
         modelId: selectedModelId,
     });
-    session.confirmCommand = makeConfirmCommand(session);
-    session.confirmPatch = makeConfirmPatch(session);
     if (sourceSnapshot) {
         applySessionSnapshot(session, sourceSnapshot);
-        await saveSessionBoth({ session, serverSessionClient });
     }
     const projectIndex = createIndex({
         rootDir,
@@ -359,37 +255,27 @@ export async function main() {
         },
     });
     const initialPrompt = prompt || undefined;
-    if (shouldUseClientRatatuiShell()) {
-        await runClientInteractive({
-            appendPromptHistory: (value) => appendPromptHistory(value, session.env),
-            authConfig,
-            debugUi: whoami.debugUi,
-            projectIndex,
-            serverModels,
-            serverSessionClient,
-            session,
-            initialPrompt,
-            usageText: async () => formatUsageText(await auth.fetchWhoamiResponse({ config: authConfig })),
-        });
-        await saveSessionBoth({ session, serverSessionClient });
-        printSessionExit(session);
-        return;
-    }
-    printStartupBanner(rootDir, modelLabel(serverModels, session.modelId), session.autoYes);
-    printSessionStartup(session);
-    await mainInteractive({
+    await runClientInteractive({
+        appendPromptHistory: (value) => appendPromptHistory(value, session.env),
         authConfig,
+        debugUi: whoami.debugUi,
         projectIndex,
         serverModels,
         serverSessionClient,
         session,
-        usageText: async () => formatUsageText(await auth.fetchWhoamiResponse({ config: authConfig })),
         initialPrompt,
+        usageText: async () => formatUsageText(await auth.fetchWhoamiResponse({ config: authConfig })),
     });
     await saveSessionBoth({ session, serverSessionClient });
     printSessionExit(session);
 }
 main().catch((error) => {
-    console.error(chalk.red(`\n✖ Error: ${error.message}\n`));
+    if (isAuthenticationError(error)) {
+        auth.clearCliAuthConfig();
+        console.error(chalk.red(`\n✖ Error: ${authenticationErrorMessage(error)}\n`));
+    }
+    else {
+        console.error(chalk.red(`\n✖ Error: ${error.message}\n`));
+    }
     process.exit(1);
 });

package/dist/parsers/NOTICE

@@ -0,0 +1,18 @@
+Tree-sitter grammar parsers
+===========================
+
+The `tree-sitter-*.wasm` files in this directory are precompiled tree-sitter
+grammar parsers, vendored so the published `@thegitai/cli` package ships local
+code intelligence without a runtime dependency. They are used unmodified, only
+as parsing inputs to the vendored web-tree-sitter runtime
+(see ../vendor/web-tree-sitter/NOTICE).
+
+Each grammar is the work of its respective tree-sitter grammar project and is
+distributed under that project's license (the tree-sitter grammars are
+MIT-licensed). Grammars included:
+
+  c, c-sharp, cpp, css, go, html, java, javascript, objc, php, python, ruby,
+  rust, tsx, typescript
+
+Upstream organization: https://github.com/tree-sitter
+Individual grammars:    https://github.com/tree-sitter/tree-sitter-<language>

package/dist/src/agent-mode.js

@@ -12,6 +12,8 @@ const PLAN_MODE_TOOL_NAMES = new Set([
     'read_document',
     'analyze_image',
     'run_command',
+    'shell_job_output',
+    'update_todos',
 ]);
 const PLAN_MODE_RUN_COMMAND_NAMES = new Set([
     'pwd',
@@ -117,6 +119,9 @@ export function buildAgentModeToolBlockedResult(mode, call) {
     }
     if (call.name !== 'run_command')
         return null;
+    if (call.args?.background === true) {
+        return buildPlanModeToolBlockedResult(call.name, PLAN_MODE_RUN_COMMAND_ACTION);
+    }
     const command = String(call.args?.command ?? call.args?.cmd ?? '');
     const reason = planModeRunCommandBlockReason(command);
     return reason ? buildPlanModeToolBlockedResult(call.name, reason) : null;

package/dist/src/api/auth.js

@@ -1,7 +1,7 @@
 import { existsSync, mkdirSync, readFileSync, rmSync, writeFileSync, } from 'node:fs';
 import path from 'node:path';
 import { getClientStateDir } from '../client-state.js';
-import { ServerApiError, authorizedJson, createTraceContext, failureMessage, normalizeServerUrl, readJsonResponse, } from './http.js';
+import { ServerApiError, authorizedJson, createTraceContext, failureCode, failureMessage, normalizeServerUrl, readJsonResponse, retryTransient, } from './http.js';
 export function getAuthConfigPath(env = process.env) {
     const configured = String(env.THEGITAI_AUTH_CONFIG ?? '').trim();
     if (configured) {
@@ -51,11 +51,11 @@ export async function fetchWhoami({ config, fetchImpl = globalThis.fetch, }) {
     return data.customer;
 }
 export async function fetchWhoamiResponse({ config, fetchImpl = globalThis.fetch, }) {
-    const data = (await authorizedJson({
+    const data = (await retryTransient(() => authorizedJson({
         config,
         path: '/v1/auth/whoami',
         fetchImpl,
-    }));
+    })));
     if (!data?.customer?.email) {
         throw new Error('Server returned an invalid whoami response.');
     }
@@ -78,6 +78,6 @@ export async function logoutFromServer({ config, fetchImpl = globalThis.fetch, }
     });
     if (!response.ok && response.status !== 401) {
         const data = (await readJsonResponse(response));
-        throw new ServerApiError(failureMessage(data, response.status), response.status, trace.traceId);
+        throw new ServerApiError(failureMessage(data, response.status), response.status, trace.traceId, failureCode(data));
     }
 }

package/dist/src/api/browser-login.js

@@ -1,21 +1,18 @@
+import { execSync } from 'node:child_process';
 import crypto from 'node:crypto';
+import { readFileSync } from 'node:fs';
 import http from 'node:http';
 import os from 'node:os';
 import { openUrl } from '../core/open-url.js';
-import { ServerApiError, createTraceContext, failureMessage, normalizeServerUrl, readJsonResponse, } from './http.js';
+import { ServerApiError, createTraceContext, failureCode, failureMessage, normalizeServerUrl, readJsonResponse, } from './http.js';
 const DEFAULT_WEBSITE_URL = 'https://thegit.ai';
 const DEFAULT_SERVER_URL = 'https://thegit.ai';
 const DEFAULT_TIMEOUT_MS = 5 * 60 * 1000;
 function shutDownServer(server) {
-    // Drop any lingering (keep-alive) connections so the event loop empties and
-    // the CLI exits instead of hanging after a successful login.
     server.closeAllConnections?.();
     server.close();
 }
 export function resolveWebsiteUrl() {
-    // The public CLI always signs in through the official TheGitAI website. There
-    // is no override path here so the published package cannot be pointed at a
-    // clone host.
     return DEFAULT_WEBSITE_URL.replace(/\/+$/, '');
 }
 function defaultDeviceName() {
@@ -26,7 +23,73 @@ function defaultDeviceName() {
         return os.hostname();
     }
 }
-/** PKCE (RFC 7636, S256): a random verifier and its SHA-256 challenge. */
+function readLinuxOsPrettyName() {
+    try {
+        const content = readFileSync('/etc/os-release', 'utf8');
+        return content.match(/^PRETTY_NAME="?([^"\n]*)"?$/m)?.[1]?.trim() ?? '';
+    }
+    catch {
+        return '';
+    }
+}
+function macArchLabel() {
+    try {
+        if (process.arch === 'arm64')
+            return 'Apple Silicon';
+        if (os.cpus().some((cpu) => cpu.model.includes('Apple'))) {
+            return 'Apple Silicon';
+        }
+    }
+    catch {
+    }
+    return 'Intel';
+}
+export function describeOperatingSystem() {
+    try {
+        if (process.platform === 'linux') {
+            const base = readLinuxOsPrettyName() || `Linux ${os.release()}`;
+            return process.arch === 'arm64' ? `${base}, ARM64` : base;
+        }
+        if (process.platform === 'darwin') {
+            let version = '';
+            try {
+                version = execSync('sw_vers -productVersion', {
+                    stdio: ['ignore', 'pipe', 'ignore'],
+                })
+                    .toString()
+                    .trim();
+            }
+            catch {
+            }
+            return `${version ? `macOS ${version}` : 'macOS'}, ${macArchLabel()}`;
+        }
+        if (process.platform === 'win32') {
+            let label = '';
+            try {
+                label = os.version();
+            }
+            catch {
+            }
+            const build = Number(os.release().split('.')[2] ?? '0');
+            if (build >= 22000)
+                label = label.replace(/Windows 10/i, 'Windows 11');
+            const base = label || `Windows ${os.release()}`;
+            return process.arch === 'arm64' ? `${base}, ARM64` : base;
+        }
+        return `${process.platform} ${os.release()}`;
+    }
+    catch {
+        return process.platform;
+    }
+}
+export function withOperatingSystemInfo(name) {
+    const trimmed = name.trim();
+    const osLabel = describeOperatingSystem();
+    const combined = osLabel && !trimmed.includes(osLabel)
+        ? `${trimmed} (${osLabel})`
+        : trimmed;
+    return combined.slice(0, 180);
+}
 export function generatePkce() {
     const verifier = crypto.randomBytes(32).toString('base64url');
     const challenge = crypto
@@ -62,7 +125,7 @@ async function exchangeCodeForToken({ serverUrl, code, codeVerifier, fetchImpl,
     });
     const data = (await readJsonResponse(response));
     if (!response.ok) {
-        throw new ServerApiError(failureMessage(data, response.status), response.status, trace.traceId);
+        throw new ServerApiError(failureMessage(data, response.status), response.status, trace.traceId, failureCode(data));
     }
     const token = String(data?.token ?? '').trim();
     const customer = data?.customer;
@@ -77,19 +140,13 @@ async function exchangeCodeForToken({ serverUrl, code, codeVerifier, fetchImpl,
         customer,
     };
 }
-/**
- * Browser-based login. Starts a loopback server so the website can redirect the
- * one-time code back automatically; the code is then exchanged for a token
- * using the PKCE verifier. With `noBrowser`, the user pastes the code instead.
- * The CLI never sees the user's credentials.
- */
 export async function loginViaBrowser(options) {
     const serverUrl = normalizeServerUrl(options.serverUrl ?? DEFAULT_SERVER_URL);
     const websiteUrl = resolveWebsiteUrl();
     const fetchImpl = options.fetchImpl ?? globalThis.fetch;
     const openBrowser = options.openBrowser ?? openUrl;
     const onUrl = options.onUrl ?? (() => { });
-    const deviceName = options.deviceName ?? defaultDeviceName();
+    const deviceName = withOperatingSystemInfo(options.deviceName ?? defaultDeviceName());
     const { verifier, challenge } = generatePkce();
     if (options.noBrowser) {
         const authUrl = buildAuthUrl(websiteUrl, {
@@ -97,8 +154,6 @@ export async function loginViaBrowser(options) {
             deviceName,
             paste: true,
         });
-        // Headless mode: only print the URL for the user to open on another device.
-        // Never launch a browser here — that is the whole point of --no-browser.
         onUrl(authUrl);
         if (!options.promptCode) {
             throw new Error('No way to read the authorization code in this context.');
@@ -125,8 +180,6 @@ export async function loginViaBrowser(options) {
             }
             const code = requestUrl.searchParams.get('code') ?? '';
             const returnedState = requestUrl.searchParams.get('state') ?? '';
-            // `Connection: close` plus closeAllConnections() ensures the browser's
-            // keep-alive socket is torn down so the process can exit after login.
             if (!code || returnedState !== state) {
                 res.writeHead(400, { 'content-type': 'text/html', connection: 'close' });
                 res.end(RESULT_PAGE('Login failed', 'The request could not be verified. Please run ai login again.'));