dsh-cliworker-now 0.0.0-stage → 0.7.7

package/lib/native-launch.mjs

@@ -0,0 +1,234 @@
+// Inspect fixed launcher data; never ask a shell to interpret CLI arguments.
+import { openSync, readSync, fstatSync, closeSync, realpathSync, statSync, existsSync } from 'node:fs'
+import { basename, dirname, extname, isAbsolute, relative, resolve, sep, delimiter, join } from 'node:path'
+import { homedir, userInfo } from 'node:os'
+
+const invalid = () => Object.assign(
+  new Error('CLI 启动入口无法确认，请配置原生程序或固定 Node/Bun 入口'),
+  { code: 'CLI_LAUNCHER_UNSUPPORTED' },
+)
+const batch = (value) => /\.(?:cmd|bat)$/i.test(value)
+function text(path, limit = 128 * 1024) {
+  const descriptor = openSync(path, 'r')
+  try {
+    const info = fstatSync(descriptor)
+    if (!info.isFile() || info.size > limit) throw invalid()
+    const bytes = Buffer.alloc(info.size + 1)
+    const read = readSync(descriptor, bytes, 0, bytes.length, 0)
+    const after = fstatSync(descriptor)
+    if (read !== info.size || info.size !== after.size || info.mtimeMs !== after.mtimeMs) throw invalid()
+    return bytes
+      .subarray(0, read)
+      .toString('utf8')
+      .replace(/^\uFEFF/, '')
+  } finally {
+    closeSync(descriptor)
+  }
+}
+function file(path) {
+  const canonical = realpathSync(path)
+  if (!statSync(canonical).isFile()) throw invalid()
+  return canonical
+}
+function scriptRuntime(path) {
+  const descriptor = openSync(path, 'r')
+  try {
+    const bytes = Buffer.alloc(256)
+    const length = readSync(descriptor, bytes, 0, bytes.length, 0)
+    const header = bytes.subarray(0, length).toString('utf8').split('\n')[0].trim()
+    if (header.startsWith('#!')) {
+      const match = /^#!\s*(?:\/usr\/bin\/env\s+(?:-S\s+)?)?(?:[^\s]*\/)?(node|bun)\s*$/.exec(header)
+      if (!match) throw invalid()
+      return match[1]
+    }
+    // A fixed npm bin entry can declare its runtime in the package manifest.
+    for (let directory = dirname(path), depth = 0; depth < 5; depth++, directory = dirname(directory)) {
+      const manifestPath = join(directory, 'package.json')
+      if (!existsSync(manifestPath)) continue
+      const manifest = JSON.parse(text(manifestPath))
+      const bins = typeof manifest.bin === 'string' ? [manifest.bin] : Object.values(manifest.bin ?? {})
+      if (bins.some((entry) => typeof entry === 'string' && resolve(directory, entry) === path)) {
+        if (manifest.engines?.bun && !manifest.engines?.node) return 'bun'
+        return 'node'
+      }
+      break
+    }
+    return /\.[cm]?js$/i.test(path) ? 'node' : undefined
+  } finally {
+    closeSync(descriptor)
+  }
+}
+function runtimeProgram(runtime, platform, launcherDirectory) {
+  if (runtime === 'node') return process.execPath
+  if (runtime !== 'bun') throw invalid()
+  const name = platform === 'win32' ? 'bun.exe' : 'bun'
+  const candidates = [
+    ...(launcherDirectory ? [join(launcherDirectory, name)] : []),
+    ...(process.env.PATH ?? '')
+      .split(delimiter)
+      .map((directory) => directory.replace(/^"|"$/g, ''))
+      .filter(isAbsolute)
+      .map((directory) => join(directory, name)),
+    ...(process.env.BUN_INSTALL ? [join(process.env.BUN_INSTALL, 'bin', name)] : []),
+    ...[homedir(), userInfo().homedir].map((home) => join(home, '.bun', 'bin', name)),
+  ]
+  const candidate = candidates.find((path) => existsSync(path) && statSync(path).isFile())
+  if (!candidate) throw new Error('未找到 Bun，请安装该 CLI 所需的 Bun 运行时')
+  return file(candidate)
+}
+/** npm's native bin shim is data, not a batch program to execute. */
+function nativePackageBin(shim, suffix) {
+  const parts = suffix.replace(/\\/g, '/').split('/')
+  if (parts[0] !== 'node_modules' || parts.some((part) => !part || part === '.' || part === '..'))
+    throw invalid()
+  const scoped = parts[1]?.startsWith('@')
+  const name = parts.slice(1, scoped ? 3 : 2).join('/')
+  if (!/^(?:@[a-z0-9._-]+\/)?[a-z0-9._-]+$/.test(name)) throw invalid()
+  const root = fileDirectory(resolve(dirname(shim), ...parts.slice(0, scoped ? 3 : 2)))
+  const entry = file(resolve(dirname(shim), ...parts))
+  const inside = relative(root, entry)
+  if (!inside || inside === '..' || inside.startsWith('..' + sep) || isAbsolute(inside)) throw invalid()
+  const manifest = JSON.parse(text(join(root, 'package.json')))
+  const command = basename(shim, extname(shim))
+  const declared = typeof manifest.bin === 'string'
+    ? name.split('/').at(-1) === command ? manifest.bin : undefined
+    : manifest.bin?.[command]
+  if (manifest.name !== name || typeof declared !== 'string' || isAbsolute(declared) ||
+    declared.replace(/\\/g, '/').split('/').includes('..') || file(resolve(root, declared)) !== entry)
+    throw invalid()
+  const descriptor = openSync(entry, 'r')
+  try {
+    const header = Buffer.alloc(64), signature = Buffer.alloc(4)
+    const size = fstatSync(descriptor).size
+    if (readSync(descriptor, header, 0, 64, 0) !== 64 || header.toString('ascii', 0, 2) !== 'MZ')
+      throw invalid()
+    const offset = header.readUInt32LE(0x3c)
+    if (offset < 64 || offset + 4 > size || readSync(descriptor, signature, 0, 4, offset) !== 4 ||
+      signature.toString('hex') !== '50450000') throw invalid()
+  } finally {
+    closeSync(descriptor)
+  }
+  return entry
+}
+function fileDirectory(path) {
+  const canonical = realpathSync(path)
+  if (!statSync(canonical).isDirectory()) throw invalid()
+  return canonical
+}
+function inspectBatch(executable, platform) {
+  const source = text(file(executable)).trim().replace(/\r\n/g, '\n')
+  // Nous' official fallback contains just a fixed interpreter and its encoded
+  // launcher. Preserve its own bootstrap; do not guess a virtualenv interpreter.
+  const hermes =
+    /^@echo off\n"([^"\n%]+)" -I -c "(import base64; exec\(base64\.b64decode\('([A-Za-z0-9+/]+={0,2})'\)\))" %\*$/i.exec(
+      source,
+    )
+  if (hermes) {
+    const decoded = Buffer.from(hermes[3], 'base64')
+    if (
+      !isAbsolute(hermes[1]) ||
+      decoded.toString('base64') !== hermes[3] ||
+      !decoded.toString('utf8').startsWith('import os, re, sys\n') ||
+      !decoded.toString('utf8').includes('import hermes_bootstrap') ||
+      !decoded.toString('utf8').includes('from hermes_cli.main import main')
+    )
+      throw invalid()
+    return { kind: 'python', argv: [file(hermes[1]), '-I', '-c', hermes[2]] }
+  }
+  const entries = new Set()
+  const runtimes = new Set()
+  for (const original of source.split('\n')) {
+    let line = original.trim()
+    if (!line || /^@?(?:echo off|rem\b.*)$/i.test(line)) continue
+    // npm cmd-shim's standard final control prefix is launcher boilerplate;
+    // it is discarded, and nothing from it is executed by this module.
+    line = line.replace(/^endLocal & goto #_undefined_# 2>NUL \|\| title [^&\n]+ & /i, '')
+    const native = /^@?"%(?:~dp0[\\/]?|dp0%[\\/])([^"\n%]+\.exe)"\s+%\*$/i.exec(line)
+    if (native) {
+      entries.add(nativePackageBin(executable, native[1]))
+      runtimes.add('native')
+      continue
+    }
+    const command =
+      /^@?(?:(node|bun)|"%_prog%"|"%(?:~dp0[\\/]?|dp0%[\\/])(node|bun)\.exe")\s+"%(?:~dp0[\\/]?|dp0%[\\/])([^"\n%]+)"\s+%\*$/i.exec(
+        line,
+      )
+    if (command) {
+      const path = file(resolve(dirname(executable), command[3].replace(/[\\/]/g, sep)))
+      if (!scriptRuntime(path)) throw invalid()
+      entries.add(path)
+      if (command[1] || command[2]) runtimes.add((command[1] || command[2]).toLowerCase())
+      continue
+    }
+    const program = /^@?set "?_prog=(?:%(?:~dp0[\\/]?|dp0%[\\/]))?(node|bun)(?:\.exe)?"?$/i.exec(line)
+    if (program) {
+      runtimes.add(program[1].toLowerCase())
+      continue
+    }
+    if (
+      /^@?(?:goto start|:find_dp0|:start|set dp0=%~dp0|exit \/b|setlocal|endlocal|call :find_dp0)$/i.test(
+        line,
+      ) ||
+      /^@?if (?:not )?exist "%(?:~dp0[\\/]?|dp0%[\\/])(?:node|bun)\.exe" \($/i.test(line) ||
+      /^\)(?: else \()?$/i.test(line) ||
+      /^@?set pathext=%pathext:;\.js;=;%$/i.test(line) ||
+      /^@?if (?:not )?defined node_path \($/i.test(line) ||
+      /^@?set "node_path=[^"\n&|<>]+"$/i.test(line)
+    )
+      continue
+    throw invalid()
+  }
+  if (entries.size !== 1 || runtimes.size !== 1) throw invalid()
+  const entry = [...entries][0],
+    runtime = [...runtimes][0]
+  if (runtime === 'native') return { kind: 'native', argv: [entry] }
+  if (scriptRuntime(entry) !== runtime) throw invalid()
+  return { kind: runtime, argv: [runtimeProgram(runtime, platform, dirname(executable)), entry] }
+}
+
+/** Canonical npm entry for installation identity checks; Python launchers keep their identity. */
+export function resolveNativeEntry(executable, platform = process.platform) {
+  if (platform !== 'win32') return executable
+  if (isAbsolute(executable) && !extname(executable) && !existsSync(executable)) {
+    const extensions = (process.env.PATHEXT || '.EXE;.COM;.CMD;.BAT')
+      .split(';')
+      .map((extension) => extension.toLowerCase())
+      .filter((extension) => /^\.(?:exe|com|cmd|bat)$/.test(extension))
+    const candidate = [...new Set(extensions)]
+      .map((extension) => executable + extension)
+      .find((path) => existsSync(path) && statSync(path).isFile())
+    if (candidate) executable = candidate
+  }
+  if (!batch(executable)) return executable
+  let inspected
+  try {
+    inspected = inspectBatch(executable, platform)
+  } catch {
+    // A present but invalid shim is not an absent CLI. Never forward raw paths or script text.
+    throw invalid()
+  }
+  // Keep Bun's fixed shim identity: it may pin a bundled bun.exe beside the
+  // shim which cannot be recovered from only the package's JS path.
+  return inspected.kind === 'node' ? inspected.argv[1] : inspected.kind === 'native' ? inspected.argv[0] : executable
+}
+
+/** Windows CreateProcess accepts real programs, not npm command files. */
+export function nativeLaunchArgv(argv, platform = process.platform) {
+  if (
+    !Array.isArray(argv) ||
+    !argv.length ||
+    argv.some((value) => typeof value !== 'string' || value.includes('\0'))
+  )
+    throw invalid()
+  if (platform !== 'win32') {
+    if (!/\.[cm]?js$/i.test(argv[0])) return [...argv]
+    const entry = file(argv[0])
+    return [runtimeProgram(scriptRuntime(entry), platform), entry, ...argv.slice(1)]
+  }
+  const executable = resolveNativeEntry(argv[0], platform),
+    arguments_ = argv.slice(1)
+  if (batch(executable)) return [...inspectBatch(executable, platform).argv, ...arguments_]
+  if (/\.[cm]?js$/i.test(executable) || (extname(executable) === '' && scriptRuntime(executable)))
+    return [runtimeProgram(scriptRuntime(executable), platform), file(executable), ...arguments_]
+  return [executable, ...arguments_]
+}

package/lib/native-spawn.mjs

@@ -0,0 +1,32 @@
+import { spawn } from 'node:child_process'
+
+/** Native CLI descendants keep their pipes/ConPTY and the enclosing Host Job.
+ * Window presentation is per child: hiding a wrapper does not hide its children.
+ * Node ignores windowsHide on POSIX, so both platforms use this one boundary.
+ */
+export function spawnNativeProcess(executable, argv, options) {
+  return spawn(executable, argv, { ...options, windowsHide: true })
+}
+
+/** Relay ordinary background pipes as bytes with Node's stream backpressure.
+ * Numeric/inherited descriptors make libuv omit CREATE_NO_WINDOW on Windows.
+ * This must never be used for a ConPTY: its console handles stay inherited. */
+export function forwardNativeStdio(child) {
+  const stopInput = () => {
+    process.stdin.unpipe(child.stdin)
+    process.stdin.destroy()
+  }
+  const fail = () => { child.kill('SIGTERM'); process.exitCode = 1 }
+  child.stdin.on('error', error => { stopInput(); if (error.code !== 'EPIPE') fail() })
+  child.stdin.once('close', stopInput)
+  child.once('exit', stopInput)
+  child.once('error', stopInput)
+  process.stdin.on('error', fail)
+  process.stdout.on('error', fail)
+  process.stderr.on('error', fail)
+  child.stdout.on('error', fail)
+  child.stderr.on('error', fail)
+  process.stdin.pipe(child.stdin)
+  child.stdout.pipe(process.stdout, { end: false })
+  child.stderr.pipe(process.stderr, { end: false })
+}

package/lib/own-account-lease.mjs

@@ -0,0 +1,105 @@
+import { constants } from 'node:fs'
+import { lstat, mkdir, open, realpath, rename, rm, writeFile } from 'node:fs/promises'
+import { join, resolve } from 'node:path'
+
+export const OWN_ACCOUNT_BUSY = '账号正被使用，请稍后刷新'
+const nonceValid = (value) => typeof value === 'string' && /^[a-f0-9-]{36}$/.test(value)
+async function privateRoot(root) {
+  const info = await lstat(root)
+  if (
+    !info.isDirectory() ||
+    info.isSymbolicLink() ||
+    (process.platform !== 'win32' && (info.mode & 0o077)) ||
+    (await realpath(root)) !== resolve(root)
+  )
+    throw new Error('账号运行目录无法安全使用')
+}
+/** A lease is not stolen after PID death: its descendants may still be alive.
+ * Only Host cleanup after confirmed process-range exit may release it. */
+export async function assertOwnAccountLeaseIdle(root) {
+  await privateRoot(root)
+  try {
+    await lstat(join(root, '.lease'))
+  } catch (error) {
+    if (error?.code === 'ENOENT') return
+    throw error
+  }
+  throw new Error(OWN_ACCOUNT_BUSY)
+}
+export async function acquireOwnAccountLease(root, nonce) {
+  if (!nonceValid(nonce)) throw new Error('Invalid account lease')
+  await privateRoot(root)
+  const lock = join(root, '.lease')
+  const pending = join(root, `.lease-${nonce}.pending`)
+  await assertOwnAccountLeaseIdle(root)
+  await mkdir(pending, { mode: 0o700 })
+  try {
+    await writeFile(join(pending, 'owner.json'), JSON.stringify({ nonce, pid: process.pid }), {
+      flag: 'wx',
+      mode: 0o600,
+    })
+    // Publish a complete, nonempty owner directory in one filesystem operation.
+    // A killed initializer leaves only its nonce-specific pending directory.
+    await rename(pending, lock)
+  } catch (error) {
+    await rm(pending, { recursive: true, force: true })
+    if (error?.code === 'EEXIST' || error?.code === 'ENOTEMPTY') throw new Error(OWN_ACCOUNT_BUSY)
+    throw error
+  }
+}
+export async function ownsOwnAccountLease(root, nonce) {
+  if (!nonceValid(nonce)) throw new Error('Invalid account lease')
+  await privateRoot(root)
+  let handle
+  try {
+    const lock = await lstat(join(root, '.lease'))
+    if (!lock.isDirectory() || lock.isSymbolicLink() || (process.platform !== 'win32' && (lock.mode & 0o077)))
+      throw new Error('账号使用状态无法确认')
+    handle = await open(
+      join(root, '.lease/owner.json'),
+      constants.O_RDONLY | constants.O_NOFOLLOW | constants.O_NONBLOCK,
+    )
+    const info = await handle.stat()
+    if (!info.isFile() || info.nlink !== 1 || (process.platform !== 'win32' && (info.mode & 0o077)) || info.size > 1024)
+      throw new Error('账号使用状态无法确认')
+    return JSON.parse(await handle.readFile('utf8')).nonce === nonce
+  } catch (error) {
+    if (error?.code === 'ENOENT') return false
+    throw error
+  } finally {
+    await handle?.close()
+  }
+}
+export async function releaseOwnAccountLease(root, nonce) {
+  if (!nonceValid(nonce)) throw new Error('Invalid account lease')
+  await privateRoot(root)
+  // Safe only at this API's contract boundary: Host confirmed this nonce's whole
+  // process range exited, including an initializer killed before publication.
+  await rm(join(root, `.lease-${nonce}.pending`), { recursive: true, force: true })
+  const lock = join(root, '.lease')
+  let handle
+  try {
+    const directory = await lstat(lock)
+    if (!directory.isDirectory() || directory.isSymbolicLink() || (process.platform !== 'win32' && (directory.mode & 0o077)))
+      throw new Error('账号使用状态无法安全清理')
+    handle = await open(
+      join(lock, 'owner.json'),
+      constants.O_RDONLY | constants.O_NOFOLLOW | constants.O_NONBLOCK,
+    )
+    const info = await handle.stat()
+    if (!info.isFile() || info.nlink !== 1 || (process.platform !== 'win32' && (info.mode & 0o077)) || info.size > 1024)
+      throw new Error('账号使用状态无法安全清理')
+    const owner = JSON.parse(await handle.readFile('utf8'))
+    if (owner.nonce !== nonce) return
+    const current = await lstat(lock)
+    if (current.dev !== directory.dev || current.ino !== directory.ino || current.isSymbolicLink())
+      throw new Error('账号使用状态在清理前改变')
+    await handle.close()
+    handle = undefined
+    await rm(lock, { recursive: true })
+  } catch (error) {
+    if (error?.code !== 'ENOENT') throw error
+  } finally {
+    await handle?.close()
+  }
+}

package/lib/pi-installation.mjs

@@ -0,0 +1,87 @@
+// One verified Pi package for the Host, account UI, native catalog and RPC entry.
+// Resolve installation metadata only; never execute an arbitrary shell launcher.
+import { readFileSync, realpathSync, statSync } from 'node:fs'
+import { createHash } from 'node:crypto'
+import { basename, dirname, isAbsolute, join, relative, resolve, sep } from 'node:path'
+import { resolveNativeEntry } from './native-launch.mjs'
+
+const versions = new Set(['1.0.2', '1.0.4', '1.1.0'])
+const failure = () =>
+  Object.assign(
+    new Error('Pi 安装身份或原生接口不匹配；需要 Pi Coding Agent 1.0.2、1.0.4 或 1.1.0，不能使用 OMP 入口'),
+    { code: 'CLI_IDENTITY_MISMATCH' },
+  )
+function metadata(path) {
+  const info = statSync(path)
+  if (!info.isFile() || info.size > 128 * 1024) throw failure()
+  return readFileSync(path, 'utf8')
+}
+// Exact official Windows managed launcher inspected from Pi 1.1.0. It is read as
+// installation metadata, never evaluated. Unknown bootstrap code fails closed.
+const managedWindowsLauncherSHA256 = '3d8b27bb3f5c07543303b0ee774ce215e4d6ae2b0ae43311c4acf51f517ffd13'
+function windowsManagedEntry(launcher) {
+  const source = metadata(launcher).trim().replace(/\r\n/g, '\n')
+  if (createHash('sha256').update(source).digest('hex') !== managedWindowsLauncherSHA256) throw failure()
+  const install = join(dirname(dirname(launcher)), 'install')
+  const version = metadata(join(install, 'current-version')).trim()
+  if (!versions.has(version)) throw failure()
+  const directory = resolve(install, 'releases', version, 'node_modules/@earendil-works/pi-coding-agent')
+  // A version pointer/package symlink must not select code outside this release.
+  if (realpathSync(directory) !== directory) throw failure()
+  const manifest = JSON.parse(metadata(join(directory, 'package.json')))
+  const bin = typeof manifest.bin === 'string' ? manifest.bin : manifest.bin?.pi
+  if (manifest.name !== '@earendil-works/pi-coding-agent' || manifest.version !== version ||
+    !['dist/cli.js', 'dist/bundle/cli.js'].includes(bin)) throw failure()
+  const entry = realpathSync(resolve(directory, bin))
+  const inside = relative(directory, entry)
+  if (!inside || inside === '..' || inside.startsWith('..' + sep) || isAbsolute(inside)) throw failure()
+  return entry
+}
+
+export function inspectPiInstallation(entry) {
+  try {
+    let executable = realpathSync(entry)
+    if (
+      ['pi', 'pi.cmd', 'pi.bat'].includes(basename(executable).toLowerCase()) &&
+      basename(dirname(executable)) === 'bin'
+    ) {
+      const launcher = metadata(executable)
+      if (launcher.includes('PI_MANAGED_INSTALL_ROOT=') && launcher.includes('install/current-version')) {
+        const install = join(dirname(dirname(executable)), 'install')
+        const version = metadata(join(install, 'current-version')).trim()
+        if (!versions.has(version)) throw failure()
+        executable = realpathSync(
+          join(install, 'releases', version, 'node_modules/@earendil-works/pi-coding-agent/dist/cli.js'),
+        )
+      }
+    }
+    executable = realpathSync(resolveNativeEntry(executable))
+    if (basename(executable).toLowerCase() === 'pi-launcher.js' && basename(dirname(executable)) === 'bin')
+      executable = windowsManagedEntry(executable)
+    let directory = dirname(executable)
+    for (let depth = 0; depth < 5; depth++, directory = dirname(directory)) {
+      let manifest
+      try {
+        manifest = JSON.parse(metadata(join(directory, 'package.json')))
+      } catch {
+        continue
+      }
+      if (manifest.name !== '@earendil-works/pi-coding-agent' || !versions.has(manifest.version))
+        throw failure()
+      const dist = join(directory, 'dist')
+      if (![join(dist, 'cli.js'), join(dist, 'bundle/cli.js')].includes(executable)) throw failure()
+      for (const relative of ['cli.js', 'index.js', 'core/model-runtime.js', 'core/auth-storage.js']) {
+        if (!statSync(join(dist, relative)).isFile()) throw failure()
+      }
+      return {
+        root: directory,
+        dist,
+        version: manifest.version,
+        executable: realpathSync(join(dist, 'cli.js')),
+      }
+    }
+  } catch {
+    throw failure()
+  }
+  throw failure()
+}

package/lib/pi-login.mjs

@@ -0,0 +1,80 @@
+// Pi 1.0.2 / 1.0.4 native UI compatibility entry. No initial prompt, injected keystrokes,
+// model request, or subscription validation: open its own provider login menu.
+import { join } from 'node:path'
+import { pathToFileURL } from 'node:url'
+import { inspectPiInstallation } from './pi-installation.mjs'
+
+process.umask(0o077)
+try {
+  const executable = process.argv[2]
+  const action = process.argv[3] ?? 'login'
+  if (!['login', 'logout'].includes(action)) throw new Error('Invalid account action')
+  if (!executable) throw new Error('Missing Pi entry')
+  const { dist } = inspectPiInstallation(executable)
+  const {
+    createAgentSessionServices,
+    createAgentSessionFromServices,
+    createAgentSessionRuntime,
+    SessionManager,
+    InteractiveMode,
+    ModelRuntime,
+  } = await import(pathToFileURL(join(dist, 'index.js')).href)
+  if (
+    [
+      createAgentSessionServices,
+      createAgentSessionFromServices,
+      createAgentSessionRuntime,
+      SessionManager?.inMemory,
+      InteractiveMode,
+    ].some((entry) => typeof entry !== 'function') ||
+    ['init', action === 'logout' ? 'showOAuthSelector' : 'handleLoginCommand', 'run'].some(
+      (method) => typeof InteractiveMode.prototype[method] !== 'function',
+    )
+  )
+    throw new Error('Unsupported Pi login SDK capabilities')
+  const cwd = process.cwd(),
+    agentDir = process.env.PI_CODING_AGENT_DIR
+  const runtime = await createAgentSessionRuntime(
+    async ({ cwd, agentDir, sessionManager }) => {
+      const services = await createAgentSessionServices({
+        cwd,
+        agentDir,
+        ...(action === 'logout'
+          ? {
+              modelRuntime: await ModelRuntime.create({
+                authPath: process.argv[4],
+                modelsPath: null,
+                modelsStorePath: join(agentDir, 'models-store.json'),
+                refreshOnCreate: false,
+                allowModelNetwork: false,
+              }),
+            }
+          : {}),
+        resourceLoaderOptions: {
+          noExtensions: true,
+          noSkills: true,
+          noPromptTemplates: true,
+          noThemes: true,
+          noContextFiles: true,
+        },
+      })
+      const created = await createAgentSessionFromServices({
+        services,
+        sessionManager,
+        noTools: 'all',
+        tools: [],
+      })
+      return { ...created, services, diagnostics: services.diagnostics }
+    },
+    { cwd, agentDir, sessionManager: SessionManager.inMemory(cwd) },
+  )
+  const ui = new InteractiveMode(runtime)
+  await ui.init()
+  if (action === 'logout') await ui.showOAuthSelector('logout')
+  else await ui.handleLoginCommand()
+  await ui.run()
+} catch {
+  // Native errors can contain authentication data. Keep this boundary generic.
+  process.stderr.write('无法打开 Pi 原生账号界面，请检查 Pi Coding Agent 安装与受支持的原生接口。\n')
+  process.exitCode = 1
+}