@moxxy/sdk 0.38.0 → 0.40.0

package/src/process-invocation.test.ts

@@ -0,0 +1,281 @@
+import { spawnSync } from 'node:child_process';
+import {
+  chmodSync,
+  mkdtempSync,
+  mkdirSync,
+  readFileSync,
+  rmSync,
+  writeFileSync,
+} from 'node:fs';
+import { tmpdir } from 'node:os';
+import * as path from 'node:path';
+
+import { afterEach, beforeEach, describe, expect, it } from 'vitest';
+
+import {
+  executableCandidates,
+  execExecutableTargetSync,
+  findExecutable,
+  resolveExecutableTarget,
+  spawnExecutableTarget,
+} from './process-invocation.js';
+
+let root: string;
+
+beforeEach(() => {
+  root = mkdtempSync(path.join(tmpdir(), 'moxxy-process-invocation-'));
+});
+
+afterEach(() => {
+  rmSync(root, { recursive: true, force: true });
+});
+
+function put(relative: string, body = ''): string {
+  const file = path.join(root, relative);
+  mkdirSync(path.dirname(file), { recursive: true });
+  writeFileSync(file, body);
+  chmodSync(file, 0o755);
+  return file;
+}
+
+describe('executableCandidates', () => {
+  it('uses PATHEXT order on Windows and never selects an extensionless Unix shim', () => {
+    expect(executableCandidates('moxxy', 'win32', '.EXE;.CMD;.PS1')).toEqual([
+      'moxxy.exe',
+      'moxxy.cmd',
+      'moxxy.ps1',
+    ]);
+  });
+
+  it('keeps a caller-supplied extension verbatim and uses bare names off Windows', () => {
+    expect(executableCandidates('npm.cmd', 'win32', '.EXE;.CMD')).toEqual(['npm.cmd']);
+    expect(executableCandidates('npm', 'linux')).toEqual(['npm']);
+  });
+});
+
+describe('findExecutable', () => {
+  it('ignores an extensionless Windows shim and finds the first PATHEXT candidate', () => {
+    put('moxxy', 'a Unix npm shim');
+    const command = put('moxxy.cmd', '@echo off');
+
+    expect(
+      findExecutable('moxxy', [], {
+        platform: 'win32',
+        pathEnv: root,
+        pathext: '.EXE;.CMD',
+      }),
+    ).toBe(command);
+  });
+});
+
+describe('resolveExecutableTarget', () => {
+  it('maps npm.cmd to npm-cli.js and runs it through Node without a shell', () => {
+    put('npm.cmd', '@echo off');
+    const npmCli = put(
+      path.join('node_modules', 'npm', 'bin', 'npm-cli.js'),
+      'process.stdout.write(JSON.stringify(process.argv.slice(2)))',
+    );
+    const args = ['install', '--prefix', path.join(root, 'A&B workspace'), 'pkg@1.2.3'];
+
+    const target = resolveExecutableTarget('npm', {
+      platform: 'win32',
+      pathEnv: root,
+      pathext: '.CMD',
+      nodeCommand: process.execPath,
+    });
+
+    expect(target).toEqual({
+      kind: 'node',
+      command: process.execPath,
+      entry: npmCli,
+      env: {},
+    });
+    expect(target).not.toBeNull();
+    if (!target) throw new Error('npm target must resolve');
+
+    const child = spawnSync(
+      target.command,
+      target.kind === 'node' ? [target.entry, ...args] : args,
+      { encoding: 'utf8', env: process.env },
+    );
+    expect(child.status).toBe(0);
+    expect(JSON.parse(child.stdout)).toEqual(args);
+  });
+
+  it('recognizes an explicitly supplied Windows launcher case-insensitively', () => {
+    const shim = put('NPM.CMD', '@echo off');
+    const entry = put(path.join('node_modules', 'npm', 'bin', 'npm-cli.js'));
+
+    expect(
+      resolveExecutableTarget(shim, {
+        platform: 'win32',
+        nodeCommand: process.execPath,
+      }),
+    ).toMatchObject({ kind: 'node', entry });
+  });
+
+  it('maps a global moxxy.cmd to the installed CLI JavaScript entry', () => {
+    put('moxxy.cmd', '@echo off');
+    const entry = put(path.join('node_modules', '@moxxy', 'cli', 'dist', 'bin.js'));
+
+    expect(
+      resolveExecutableTarget('moxxy', {
+        platform: 'win32',
+        pathEnv: root,
+        pathext: '.CMD',
+        nodeCommand: 'C:\\Moxxy\\Moxxy.exe',
+        electron: true,
+      }),
+    ).toEqual({
+      kind: 'node',
+      command: 'C:\\Moxxy\\Moxxy.exe',
+      entry,
+      env: { ELECTRON_RUN_AS_NODE: '1' },
+    });
+  });
+
+  it('maps a project-local node_modules/.bin/moxxy.cmd to its sibling package', () => {
+    const project = path.join(root, 'project');
+    const binDir = path.join(project, 'node_modules', '.bin');
+    mkdirSync(binDir, { recursive: true });
+    writeFileSync(path.join(binDir, 'moxxy.cmd'), '@echo off');
+    const entry = path.join(project, 'node_modules', '@moxxy', 'cli', 'dist', 'bin.js');
+    mkdirSync(path.dirname(entry), { recursive: true });
+    writeFileSync(entry, '');
+
+    expect(
+      resolveExecutableTarget('moxxy', {
+        platform: 'win32',
+        pathEnv: binDir,
+        pathext: '.CMD',
+      }),
+    ).toMatchObject({ kind: 'node', entry });
+  });
+
+  it('maps pnpm.cmd and yarn.cmd to Corepack JavaScript entrypoints', () => {
+    put('pnpm.cmd', '@echo off');
+    put('yarn.cmd', '@echo off');
+    const pnpmEntry = put(path.join('node_modules', 'corepack', 'dist', 'pnpm.js'));
+    const yarnEntry = put(path.join('node_modules', 'corepack', 'dist', 'yarn.js'));
+    const options = {
+      platform: 'win32' as const,
+      pathEnv: root,
+      pathext: '.CMD',
+      nodeCommand: process.execPath,
+    };
+
+    expect(resolveExecutableTarget('pnpm', options)).toMatchObject({
+      kind: 'node',
+      entry: pnpmEntry,
+    });
+    expect(resolveExecutableTarget('yarn', options)).toMatchObject({
+      kind: 'node',
+      entry: yarnEntry,
+    });
+  });
+
+  it('accepts an explicit non-adjacent entrypoint for a known Windows launcher', () => {
+    put('pnpm.cmd', '@echo off');
+    const entry = put(path.join('tools', 'pnpm', 'bin', 'pnpm.cjs'));
+
+    expect(
+      resolveExecutableTarget('pnpm', {
+        platform: 'win32',
+        pathEnv: root,
+        pathext: '.CMD',
+        nodeEntryHint: entry,
+      }),
+    ).toMatchObject({ kind: 'node', entry });
+  });
+
+  it('fails clearly instead of passing an unknown .cmd file through a shell', () => {
+    put('custom.cmd', '@echo off');
+
+    expect(() =>
+      resolveExecutableTarget('custom', {
+        platform: 'win32',
+        pathEnv: root,
+        pathext: '.CMD',
+      }),
+    ).toThrow(/refusing to execute unknown Windows command shim.*custom\.cmd/i);
+  });
+
+  it('fails clearly when a known shim has no matching JavaScript entry', () => {
+    const shim = put('npm.cmd', '@echo off');
+
+    expect(() =>
+      resolveExecutableTarget('npm', {
+        platform: 'win32',
+        pathEnv: root,
+        pathext: '.CMD',
+      }),
+    ).toThrow(new RegExp(`cannot resolve npm JavaScript entry.*${path.basename(shim)}`, 'i'));
+  });
+
+  it('runs native Windows executables directly', () => {
+    const executable = put('bun.exe');
+
+    expect(
+      resolveExecutableTarget('bun', {
+        platform: 'win32',
+        pathEnv: root,
+        pathext: '.EXE;.CMD',
+      }),
+    ).toEqual({ kind: 'direct', command: executable });
+  });
+});
+
+describe('spawnExecutableTarget', () => {
+  it('prepends the mapped JavaScript entry and preserves each caller argument', () => {
+    const entry = put(
+      'cli.js',
+      'process.stdout.write(JSON.stringify(process.argv.slice(2)))',
+    );
+    const target = {
+      kind: 'node' as const,
+      command: process.execPath,
+      entry,
+      env: {},
+    };
+    const args = ['one argument', 'A&B', 'value|still-one-argv'];
+
+    const child = spawnExecutableTarget(target, args, {
+      stdio: ['ignore', 'pipe', 'pipe'],
+    });
+    let stdout = '';
+    child.stdout?.setEncoding('utf8');
+    child.stdout?.on('data', (chunk: string) => {
+      stdout += chunk;
+    });
+
+    return new Promise<void>((resolve, reject) => {
+      child.once('error', reject);
+      child.once('close', (code) => {
+        try {
+          expect(code).toBe(0);
+          expect(JSON.parse(stdout)).toEqual(args);
+          resolve();
+        } catch (error) {
+          reject(error);
+        }
+      });
+    });
+  });
+
+  it('runs a mapped target synchronously while preserving argv boundaries', () => {
+    const entry = put(
+      'sync-cli.js',
+      "require('node:fs').writeFileSync(process.argv[2], JSON.stringify(process.argv.slice(3)))",
+    );
+    const observed = path.join(root, 'sync-argv.json');
+    const args = [observed, 'A&B', 'two words', 'still|one'];
+
+    execExecutableTargetSync(
+      { kind: 'node', command: process.execPath, entry, env: {} },
+      args,
+      { stdio: 'ignore' },
+    );
+
+    expect(JSON.parse(readFileSync(observed, 'utf8'))).toEqual(args.slice(1));
+  });
+});

package/src/process-invocation.ts

@@ -0,0 +1,237 @@
+import {
+  execFileSync,
+  spawn,
+  type ChildProcess,
+  type ExecFileSyncOptions,
+  type SpawnOptions,
+} from 'node:child_process';
+import { statSync } from 'node:fs';
+import * as path from 'node:path';
+
+const DEFAULT_WINDOWS_PATHEXT = '.COM;.EXE;.BAT;.CMD';
+const WINDOWS_NATIVE_EXTENSIONS = new Set(['.com', '.exe']);
+const WINDOWS_SCRIPT_EXTENSIONS = new Set(['.bat', '.cmd', '.ps1']);
+const KNOWN_NODE_CLIS = new Set<KnownNodeCli>(['moxxy', 'npm', 'pnpm', 'yarn']);
+
+type KnownNodeCli = 'moxxy' | 'npm' | 'pnpm' | 'yarn';
+
+export type ExecutableTarget =
+  | { readonly kind: 'direct'; readonly command: string }
+  | {
+      readonly kind: 'node';
+      readonly command: string;
+      readonly entry: string;
+      readonly env: Readonly<Record<string, string>>;
+    };
+
+export interface ExecutableSearchOptions {
+  readonly extraPaths?: ReadonlyArray<string>;
+  readonly platform?: NodeJS.Platform;
+  readonly pathEnv?: string;
+  readonly pathext?: string;
+  readonly nodeCommand?: string;
+  /** Trusted JS entrypoint for a known launcher whose package is not adjacent to its shim. */
+  readonly nodeEntryHint?: string;
+  readonly electron?: boolean;
+}
+
+/** Spawn options that cannot opt back into a command shell. */
+export type SafeSpawnOptions = Omit<SpawnOptions, 'shell'> & { readonly shell?: never };
+export type SafeExecFileSyncOptions = Omit<ExecFileSyncOptions, 'shell'> & {
+  readonly shell?: never;
+};
+
+/**
+ * Filenames Windows itself considers for a bare command name, in PATHEXT order.
+ *
+ * The extensionless npm shim is deliberately absent: npm writes a POSIX script
+ * beside its Windows launchers, but CreateProcess cannot safely execute it.
+ * Off Windows the bare name remains the executable.
+ */
+export function executableCandidates(
+  name: string,
+  platform: NodeJS.Platform = process.platform,
+  pathext: string | undefined = process.env.PATHEXT,
+): string[] {
+  if (platform !== 'win32' || path.extname(name)) return [name];
+  const seen = new Set<string>();
+  const out: string[] = [];
+  for (const raw of (pathext ?? DEFAULT_WINDOWS_PATHEXT).split(';')) {
+    const trimmed = raw.trim();
+    if (!trimmed) continue;
+    const extension = (trimmed.startsWith('.') ? trimmed : `.${trimmed}`).toLowerCase();
+    if (seen.has(extension)) continue;
+    seen.add(extension);
+    out.push(`${name}${extension}`);
+  }
+  return out;
+}
+
+/** Find the first readable file using PATH-directory order, then PATHEXT order. */
+export function findExecutable(
+  name: string,
+  extraPaths: ReadonlyArray<string> = [],
+  opts: ExecutableSearchOptions = {},
+): string | null {
+  const platform = opts.platform ?? process.platform;
+  if (hasPathSeparator(name, platform)) return isFile(name) ? name : null;
+
+  const separator = platform === 'win32' ? ';' : path.delimiter;
+  const dirs = (opts.pathEnv ?? process.env.PATH ?? '')
+    .split(separator)
+    .concat(extraPaths)
+    .filter(Boolean);
+  const candidates = executableCandidates(name, platform, opts.pathext);
+  for (const dir of dirs) {
+    for (const candidate of candidates) {
+      const full = path.join(dir, candidate);
+      if (isFile(full)) return full;
+    }
+  }
+  return null;
+}
+
+/**
+ * Resolve a command without ever delegating argument parsing to a shell.
+ *
+ * Native executables and POSIX commands run directly. On Windows, supported
+ * Node launchers are mapped to their known JS entrypoints and run through the
+ * current Node/Electron runtime. Any other Windows script shim fails closed:
+ * parsing an arbitrary .cmd/.bat/.ps1 would recreate the shell-injection
+ * boundary this helper exists to remove.
+ */
+export function resolveExecutableTarget(
+  name: string,
+  opts: ExecutableSearchOptions = {},
+): ExecutableTarget | null {
+  const platform = opts.platform ?? process.platform;
+  const executable = findExecutable(name, opts.extraPaths ?? [], opts);
+  if (!executable) return null;
+  if (platform !== 'win32') return { kind: 'direct', command: executable };
+
+  const rawExtension = path.extname(executable);
+  const extension = rawExtension.toLowerCase();
+  if (WINDOWS_NATIVE_EXTENSIONS.has(extension)) {
+    return { kind: 'direct', command: executable };
+  }
+  if (!WINDOWS_SCRIPT_EXTENSIONS.has(extension)) {
+    throw new Error(
+      `Refusing to execute extensionless Windows command "${executable}". ` +
+        'Install a native executable or a supported Node .cmd launcher.',
+    );
+  }
+  if (extension !== '.cmd') {
+    throw unknownWindowsShim(executable);
+  }
+
+  const commandName = path.basename(executable, rawExtension).toLowerCase();
+  if (!isKnownNodeCli(commandName)) {
+    throw unknownWindowsShim(executable);
+  }
+  const entries = opts.nodeEntryHint
+    ? [opts.nodeEntryHint, ...knownNodeCliEntries(executable, commandName)]
+    : knownNodeCliEntries(executable, commandName);
+  const entry = entries.find(isFile);
+  if (!entry) {
+    throw new Error(
+      `Cannot resolve ${commandName} JavaScript entry beside Windows shim "${executable}". ` +
+        'Refusing to run the .cmd file through a shell.',
+    );
+  }
+
+  const electron = opts.electron ?? Boolean(process.versions.electron);
+  return {
+    kind: 'node',
+    command: opts.nodeCommand ?? process.execPath,
+    entry,
+    env: electron ? { ELECTRON_RUN_AS_NODE: '1' } : {},
+  };
+}
+
+/** Spawn a resolved target with an argv array and an explicitly shell-free API. */
+export function spawnExecutableTarget(
+  target: ExecutableTarget,
+  args: ReadonlyArray<string>,
+  opts: SafeSpawnOptions = {},
+): ChildProcess {
+  const argv = target.kind === 'node' ? [target.entry, ...args] : [...args];
+  const targetEnv = target.kind === 'node' ? target.env : {};
+  return spawn(target.command, argv, {
+    ...opts,
+    env: { ...process.env, ...opts.env, ...targetEnv },
+    shell: false,
+  });
+}
+
+/** Synchronous counterpart for build scripts that must finish one command at a time. */
+export function execExecutableTargetSync(
+  target: ExecutableTarget,
+  args: ReadonlyArray<string>,
+  opts: SafeExecFileSyncOptions = {},
+): void {
+  const argv = target.kind === 'node' ? [target.entry, ...args] : [...args];
+  const targetEnv = target.kind === 'node' ? target.env : {};
+  execFileSync(target.command, argv, {
+    ...opts,
+    env: { ...process.env, ...opts.env, ...targetEnv },
+    shell: false,
+  });
+}
+
+function knownNodeCliEntries(shim: string, command: KnownNodeCli): string[] {
+  const binDir = path.dirname(shim);
+  if (command === 'npm') {
+    return [
+      path.join(binDir, 'node_modules', 'npm', 'bin', 'npm-cli.js'),
+      path.join(binDir, '..', 'npm', 'bin', 'npm-cli.js'),
+    ];
+  }
+  if (command === 'moxxy') {
+    return [
+      path.join(binDir, 'node_modules', '@moxxy', 'cli', 'dist', 'bin.js'),
+      path.join(binDir, '..', '@moxxy', 'cli', 'dist', 'bin.js'),
+    ];
+  }
+  if (command === 'pnpm') {
+    return [
+      path.join(binDir, 'node_modules', 'corepack', 'dist', 'pnpm.js'),
+      path.join(binDir, 'node_modules', 'pnpm', 'bin', 'pnpm.cjs'),
+      path.join(binDir, '..', 'corepack', 'dist', 'pnpm.js'),
+      path.join(binDir, '..', 'pnpm', 'bin', 'pnpm.cjs'),
+    ];
+  }
+  return [
+    path.join(binDir, 'node_modules', 'corepack', 'dist', 'yarn.js'),
+    path.join(binDir, 'node_modules', 'yarn', 'bin', 'yarn.js'),
+    path.join(binDir, 'node_modules', '@yarnpkg', 'cli-dist', 'bin', 'yarn.js'),
+    path.join(binDir, '..', 'corepack', 'dist', 'yarn.js'),
+    path.join(binDir, '..', 'yarn', 'bin', 'yarn.js'),
+    path.join(binDir, '..', '@yarnpkg', 'cli-dist', 'bin', 'yarn.js'),
+  ];
+}
+
+function isKnownNodeCli(command: string): command is KnownNodeCli {
+  return KNOWN_NODE_CLIS.has(command as KnownNodeCli);
+}
+
+function hasPathSeparator(name: string, platform: NodeJS.Platform): boolean {
+  return platform === 'win32'
+    ? name.includes('\\') || name.includes('/')
+    : name.includes(path.sep);
+}
+
+function isFile(file: string): boolean {
+  try {
+    return statSync(file).isFile();
+  } catch {
+    return false;
+  }
+}
+
+function unknownWindowsShim(executable: string): Error {
+  return new Error(
+    `Refusing to execute unknown Windows command shim "${executable}". ` +
+      'Only moxxy.cmd, npm.cmd, pnpm.cmd, and yarn.cmd are mapped to known JavaScript entrypoints; ' +
+      'shell execution is disabled.',
+  );
+}

package/src/provider-login-bridge.test.ts

@@ -1,7 +1,9 @@
 import { describe, expect, it } from 'vitest';
 import {
   createLoginStreamScanner,
+  decodeLoginAuthUrl,
   decodeLoginPrompt,
+  encodeLoginAuthUrl,
   encodeLoginPrompt,
   type LoginStreamItem,
 } from './provider-login-bridge.js';
@@ -23,6 +25,35 @@ describe('encode/decode login prompt', () => {
   });
 });
 
+describe('encode/decode login auth URL', () => {
+  const authUrl =
+    'https://auth.example.test/authorize?client_id=moxxy&state=opaque&redirect_uri=http%3A%2F%2Flocalhost%3A1455%2Fcallback';
+
+  it('round-trips a credential-free http(s) URL', () => {
+    const marker = encodeLoginAuthUrl(authUrl);
+    expect(marker.startsWith('\u0000')).toBe(true);
+    expect(marker.endsWith('\u0000')).toBe(true);
+    expect(decodeLoginAuthUrl(marker.slice(1, -1))).toBe(authUrl);
+  });
+
+  it.each([
+    'file:///etc/passwd',
+    'javascript:alert(1)',
+    'data:text/html,<script>alert(1)</script>',
+    'https://alice:secret@auth.example.test/authorize',
+  ])('rejects an unsafe URL before encoding: %s', (url) => {
+    expect(() => encodeLoginAuthUrl(url)).toThrow();
+  });
+
+  it.each([
+    '{"tag":"moxxy.login.auth_url","url":"file:///etc/passwd"}',
+    '{"tag":"moxxy.login.auth_url","url":"https://alice:secret@auth.example.test/"}',
+    '{"tag":"moxxy.login.auth_url","url":42}',
+  ])('rejects a forged unsafe marker: %s', (segment) => {
+    expect(decodeLoginAuthUrl(segment)).toBeNull();
+  });
+});
+
 /** Drain a scanner across the given chunks into a flat item list. */
 function scanAll(chunks: string[]): LoginStreamItem[] {
   const scanner = createLoginStreamScanner();
@@ -63,6 +94,17 @@ describe('createLoginStreamScanner', () => {
     ]);
   });
 
+  it('reassembles an auth_url marker and keeps it distinct from plain output', () => {
+    const url = 'https://auth.example.test/authorize?state=opaque';
+    const marker = encodeLoginAuthUrl(url);
+    const mid = Math.floor(marker.length / 2);
+    expect(scanAll(['opening\n' + marker.slice(0, mid), marker.slice(mid), 'waiting\n'])).toEqual([
+      { type: 'output', text: 'opening\n' },
+      { type: 'auth_url', url },
+      { type: 'output', text: 'waiting\n' },
+    ]);
+  });
+
   it('holds back a lone opening NUL until its partner arrives', () => {
     const scanner = createLoginStreamScanner();
     const marker = encodeLoginPrompt({ question: 'q', mask: false });

package/src/provider-login-bridge.ts

@@ -17,12 +17,40 @@
  * depend on, so the two ends can never drift.
  */
 
+import { z } from 'zod';
+
 /** The byte that brackets a prompt marker. Absent from normal CLI output. */
 const NUL = '\u0000';
 
 /** Tag distinguishing a login-prompt marker from any other NUL-bracketed run. */
 const PROMPT_TAG = 'moxxy.login.prompt';
 
+/** Tag distinguishing a browser-authorization URL from normal login output. */
+const AUTH_URL_TAG = 'moxxy.login.auth_url';
+
+const LoginAuthUrlSchema = z
+  .string()
+  .max(8192)
+  .refine((value) => {
+    try {
+      const url = new URL(value);
+      return (
+        (url.protocol === 'http:' || url.protocol === 'https:') &&
+        url.username === '' &&
+        url.password === ''
+      );
+    } catch {
+      return false;
+    }
+  }, 'must be an http(s) URL without embedded credentials');
+
+const LoginAuthUrlMarkerSchema = z
+  .object({
+    tag: z.literal(AUTH_URL_TAG),
+    url: LoginAuthUrlSchema,
+  })
+  .strict();
+
 export interface LoginPromptRequest {
   /** The question to show the user, verbatim from `ctx.prompt`. */
   readonly question: string;
@@ -33,7 +61,8 @@ export interface LoginPromptRequest {
 /** One decoded item from a login subprocess's stdout stream. */
 export type LoginStreamItem =
   | { readonly type: 'output'; readonly text: string }
-  | { readonly type: 'prompt'; readonly prompt: LoginPromptRequest };
+  | { readonly type: 'prompt'; readonly prompt: LoginPromptRequest }
+  | { readonly type: 'auth_url'; readonly url: string };
 
 /**
  * Serialize a prompt request as a NUL-bracketed marker for stdout. The
@@ -59,6 +88,28 @@ export function decodeLoginPrompt(segment: string): LoginPromptRequest | null {
   }
 }
 
+/**
+ * Serialize the browser authorization URL for a GUI host. Validation happens
+ * before a marker reaches stdout: a provider-controlled URL may only be a
+ * credential-free HTTP(S) URL, never a shell-adjacent custom/file scheme.
+ */
+export function encodeLoginAuthUrl(url: string): string {
+  const marker = LoginAuthUrlMarkerSchema.parse({ tag: AUTH_URL_TAG, url });
+  return NUL + JSON.stringify(marker) + NUL;
+}
+
+/** Decode and validate one inter-NUL authorization-URL marker. */
+export function decodeLoginAuthUrl(segment: string): string | null {
+  if (!segment.startsWith('{')) return null;
+  try {
+    const parsed: unknown = JSON.parse(segment);
+    const marker = LoginAuthUrlMarkerSchema.safeParse(parsed);
+    return marker.success ? marker.data.url : null;
+  } catch {
+    return null;
+  }
+}
+
 /**
  * Streaming scanner for a login subprocess's stdout. Feed it chunks; it
  * returns the ordered output / prompt items decoded so far, holding back any
@@ -84,9 +135,16 @@ export function createLoginStreamScanner(): {
         if (open > 0) out.push({ type: 'output', text: buf.slice(0, open) });
         const segment = buf.slice(open + 1, close);
         const prompt = decodeLoginPrompt(segment);
+        const authUrl = prompt ? null : decodeLoginAuthUrl(segment);
         // A NUL-bracketed run that isn't a valid marker is anomalous; surface
         // its inner text as output rather than swallowing it.
-        out.push(prompt ? { type: 'prompt', prompt } : { type: 'output', text: segment });
+        out.push(
+          prompt
+            ? { type: 'prompt', prompt }
+            : authUrl !== null
+              ? { type: 'auth_url', url: authUrl }
+              : { type: 'output', text: segment },
+        );
         buf = buf.slice(close + 1);
       }
       // Flush any plain text that precedes a still-incomplete marker (or all