@raidiant/notifai 10.1.1 → 10.1.2

package/src/cli-bin.ts

@@ -1,233 +0,0 @@
-import {
-  accessSync,
-  constants,
-  existsSync,
-  lstatSync,
-  readFileSync,
-  realpathSync,
-} from 'node:fs'
-import path from 'node:path'
-import type { ReadinessState } from './readiness.js'
-import { packageVersion } from './release.js'
-import { cliUpdateRecoveryCommand } from './cli-update-contract.js'
-
-const POSIX_NAMES = ['notifai']
-const WINDOWS_NAMES = ['notifai.cmd', 'notifai.exe', 'notifai']
-
-export interface CliBinReadinessOptions {
-  runningArtifactPath?: string
-  currentVersion?: string | null
-}
-
-export interface CliPathEntry {
-  command_path: string
-  executable: boolean
-  artifact_path: string | null
-  version: string | null
-  install_prefix: string | null
-}
-
-export interface CliInstallationInspection {
-  current: { artifact_path: string; version: string | null }
-  effective: CliPathEntry | null
-  entries: CliPathEntry[]
-}
-
-export function pathNotifaiEntries(
-  env: NodeJS.ProcessEnv,
-  platform: NodeJS.Platform = process.platform,
-): string[] {
-  const raw = platform === 'win32' ? (env['Path'] ?? env['PATH'] ?? '') : (env['PATH'] ?? '')
-  const delimiter = platform === 'win32' ? ';' : ':'
-  const names = platform === 'win32' ? WINDOWS_NAMES : POSIX_NAMES
-  const found: string[] = []
-  for (const directory of raw.split(delimiter)) {
-    if (directory === '') continue
-    for (const name of names) {
-      const candidate = path.join(directory, name)
-      if (!existsSync(candidate)) continue
-      if (!found.includes(candidate)) found.push(candidate)
-    }
-  }
-  return found
-}
-
-export function isExecutablePath(file: string, platform: NodeJS.Platform = process.platform): boolean {
-  if (!existsSync(file)) return false
-  if (platform === 'win32') return true
-  try {
-    const target = lstatSync(file).isSymbolicLink() ? realpathSync(file) : file
-    accessSync(target, constants.X_OK)
-    return true
-  } catch {
-    return false
-  }
-}
-
-function canonicalPath(file: string): string {
-  try {
-    return realpathSync(file)
-  } catch {
-    return path.resolve(file)
-  }
-}
-
-function windowsShimArtifact(file: string): string | null {
-  if (path.extname(file).toLowerCase() !== '.cmd') return null
-  try {
-    const source = readFileSync(file, 'utf8')
-    const match = /(?:%dp0%|%~dp0)?([^"\r\n]*node_modules[\\/]@raidiant[\\/]notifai[\\/]dist[\\/]main\.js)/i.exec(source)
-    if (match?.[0] === undefined) return null
-    const expanded = match[0]
-      .replace(/^%~?dp0%/i, `${path.dirname(file)}${path.sep}`)
-      .replaceAll('\\', path.sep)
-    return canonicalPath(expanded)
-  } catch {
-    return null
-  }
-}
-
-function artifactForCommand(file: string, platform: NodeJS.Platform): string | null {
-  const shim = platform === 'win32' ? windowsShimArtifact(file) : null
-  if (shim !== null) return shim
-  try {
-    return canonicalPath(file)
-  } catch {
-    return null
-  }
-}
-
-function artifactVersion(artifact: string | null): string | null {
-  if (artifact === null) return null
-  try {
-    const parsed: unknown = JSON.parse(
-      readFileSync(path.join(path.dirname(artifact), '..', 'package.json'), 'utf8'),
-    )
-    if (typeof parsed !== 'object' || parsed === null) return null
-    const version = (parsed as { version?: unknown }).version
-    return typeof version === 'string' && version !== '' ? version : null
-  } catch {
-    return null
-  }
-}
-
-function installPrefix(artifact: string | null): string | null {
-  if (artifact !== null) {
-    const marker = /[\\/]lib[\\/]node_modules[\\/]@raidiant[\\/]notifai[\\/]/i.exec(artifact)
-      ?? /[\\/]node_modules[\\/]@raidiant[\\/]notifai[\\/]/i.exec(artifact)
-    if (marker?.index !== undefined) return artifact.slice(0, marker.index)
-  }
-  return null
-}
-
-export function inspectCliInstallations(
-  env: NodeJS.ProcessEnv,
-  platform: NodeJS.Platform = process.platform,
-  options: CliBinReadinessOptions = {},
-): CliInstallationInspection {
-  const runningArtifact = canonicalPath(options.runningArtifactPath ?? process.argv[1] ?? 'notifai')
-  const entries = pathNotifaiEntries(env, platform).map((command): CliPathEntry => {
-    const artifact = artifactForCommand(command, platform)
-    return {
-      command_path: command,
-      executable: isExecutablePath(command, platform),
-      artifact_path: artifact,
-      version: artifactVersion(artifact),
-      install_prefix: installPrefix(artifact),
-    }
-  })
-  return {
-    current: {
-      artifact_path: runningArtifact,
-      version: options.currentVersion === undefined ? packageVersion() : options.currentVersion,
-    },
-    effective: entries.find((entry) => entry.executable) ?? null,
-    entries,
-  }
-}
-
-export function cliBinReadiness(
-  env: NodeJS.ProcessEnv,
-  platform: NodeJS.Platform = process.platform,
-  options: CliBinReadinessOptions = {},
-): ReadinessState {
-  const inspection = inspectCliInstallations(env, platform, options)
-  const { current, effective, entries } = inspection
-  const updateCommand = cliUpdateRecoveryCommand()
-  if (effective === null && entries.length > 0) {
-    return {
-      id: 'cli-bin',
-      title: 'notifai command',
-      status: 'gap',
-      detail: 'the notifai command is on PATH but cannot run',
-      technical: inspection,
-      remedy: {
-        by: 'user-here',
-        summary: 'repair the global notifai command so it can run',
-        command: updateCommand,
-      },
-    }
-  }
-  // A global install that landed outside PATH used to report `ready` with
-  // "this process can run" — which is true of the running process and false of
-  // every instruction it goes on to print. Hooks embed absolute paths, so
-  // nothing visibly breaks until the reader types `notifai` themselves.
-  //
-  // Not a blocker: this process is already running, so the whole setup —
-  // pairing, the app, the delivery proof — still completes. It is the later
-  // `notifai …` lines that will not be found, and saying so is the fix.
-  if (effective === null) {
-    return {
-      id: 'cli-bin',
-      title: 'notifai command',
-      status: 'optional-gap',
-      detail:
-        'no `notifai` on PATH — this process runs, but a typed `notifai …` command will not be found',
-      remedy: {
-        by: 'user-here',
-        summary: 'install notifai globally so the command is on your PATH',
-        command: updateCommand,
-      },
-    }
-  }
-
-  const effectiveIsCurrent =
-    effective.artifact_path === current.artifact_path ||
-    (effective.version !== null && current.version !== null && effective.version === current.version)
-  if (!effectiveIsCurrent) {
-    return {
-      id: 'cli-bin',
-      title: 'notifai command',
-      status: 'gap',
-      detail: 'the notifai command resolves to a different installation than this current CLI',
-      technical: inspection,
-      remedy: {
-        by: 'user-here',
-        summary: 'update the notifai command that wins PATH',
-        command: updateCommand,
-      },
-    }
-  }
-
-  const duplicateNeedsCleanup = entries.some(
-    (entry) =>
-      entry !== effective &&
-      (!entry.executable || entry.artifact_path !== effective.artifact_path),
-  )
-  if (duplicateNeedsCleanup) {
-    return {
-      id: 'cli-bin',
-      title: 'notifai command',
-      status: 'optional-gap',
-      detail: 'the notifai command is ready; another installation remains for cleanup',
-      technical: inspection,
-    }
-  }
-  return {
-    id: 'cli-bin',
-    title: 'notifai command',
-    status: 'ready',
-    detail: 'the notifai command is ready',
-    technical: inspection,
-  }
-}

package/src/cli-release.test.ts

@@ -1,46 +0,0 @@
-import { afterEach, describe, expect, it } from 'vitest'
-import {
-  compareCliSemVer,
-  latestPublishedCliVersion,
-  newerPublishedCli,
-  resetLatestPublishedCliVersionForTest,
-  shouldConsultCliRegistry,
-} from './cli-release.js'
-
-afterEach(() => {
-  resetLatestPublishedCliVersionForTest()
-})
-
-describe('CLI registry recommendation', () => {
-  it('is suppressed for JSON, non-interactive, and CI callers', () => {
-    expect(shouldConsultCliRegistry({ interactive: true })).toBe(true)
-    expect(shouldConsultCliRegistry({ interactive: true, json: true })).toBe(false)
-    expect(shouldConsultCliRegistry({ interactive: false })).toBe(false)
-    expect(shouldConsultCliRegistry({ interactive: true, env: { CI: 'true' } })).toBe(false)
-  })
-
-  it('never throws when the registry is unreachable', async () => {
-    const latest = await latestPublishedCliVersion(async () => {
-      throw new Error('network down')
-    })
-    expect(latest).toBeNull()
-  })
-
-  it('caches a successful dist-tag read', async () => {
-    let calls = 0
-    const fetchImpl: typeof fetch = async () => {
-      calls += 1
-      return new Response(JSON.stringify({ latest: '9.1.0' }), { status: 200 })
-    }
-    expect(await latestPublishedCliVersion(fetchImpl)).toBe('9.1.0')
-    expect(await latestPublishedCliVersion(fetchImpl)).toBe('9.1.0')
-    expect(calls).toBe(1)
-  })
-
-  it('only recommends a strictly newer published version', () => {
-    expect(newerPublishedCli('8.0.0', '8.0.1')).toBe('8.0.1')
-    expect(newerPublishedCli('8.0.0', '8.0.0')).toBeNull()
-    expect(newerPublishedCli('8.0.1', '8.0.0')).toBeNull()
-    expect(compareCliSemVer('8.0.0', '7.0.2')).toBeGreaterThan(0)
-  })
-})

package/src/cli-release.ts

@@ -1,78 +0,0 @@
-import { packageVersion } from './release.js'
-
-/**
- * The newest published CLI, read from the registry that publishes it.
- *
- * Which version is newest is a registry fact. Doctor consults it as a
- * best-effort, cached, short-timeout hint: never fatal, and never on a
- * non-interactive or CI invocation — those callers already get structured
- * support state from the server when they are signed in.
- */
-const DIST_TAGS_URL = 'https://registry.npmjs.org/-/package/@raidiant/notifai/dist-tags'
-const REQUEST_TIMEOUT_MS = 2_000
-const CACHE_TTL_MS = 60 * 60 * 1000
-
-let cached: { value: string | null; at: number } | null = null
-
-export function compareCliSemVer(left: string, right: string): number | null {
-  const parse = (value: string): [number, number, number] | null => {
-    const match = /^(\d+)\.(\d+)\.(\d+)(?:[-+].*)?$/.exec(value)
-    if (!match) return null
-    return [Number(match[1]), Number(match[2]), Number(match[3])]
-  }
-  const a = parse(left)
-  const b = parse(right)
-  if (a === null || b === null) return null
-  for (let index = 0; index < 3; index += 1) {
-    if (a[index] !== b[index]) return a[index]! - b[index]!
-  }
-  return 0
-}
-
-export function shouldConsultCliRegistry(input: {
-  interactive?: boolean
-  json?: boolean
-  env?: NodeJS.ProcessEnv
-}): boolean {
-  if (input.json === true) return false
-  if (input.interactive !== true) return false
-  const ci = input.env?.['CI']
-  return ci !== '1' && ci !== 'true'
-}
-
-export async function latestPublishedCliVersion(
-  fetchImpl: typeof fetch = fetch,
-): Promise<string | null> {
-  if (cached !== null && Date.now() - cached.at < CACHE_TTL_MS) return cached.value
-  try {
-    const response = await fetchImpl(DIST_TAGS_URL, {
-      headers: { accept: 'application/json' },
-      signal: AbortSignal.timeout(REQUEST_TIMEOUT_MS),
-    })
-    if (!response.ok) return cached?.value ?? null
-    const body: unknown = await response.json()
-    if (typeof body !== 'object' || body === null) return cached?.value ?? null
-    const latest = (body as { latest?: unknown }).latest
-    if (typeof latest !== 'string' || compareCliSemVer(latest, '0.0.0') === null) {
-      return cached?.value ?? null
-    }
-    cached = { value: latest, at: Date.now() }
-    return latest
-  } catch {
-    return cached?.value ?? null
-  }
-}
-
-export function newerPublishedCli(local: string | null, latest: string | null): string | null {
-  if (local === null || latest === null) return null
-  const comparison = compareCliSemVer(latest, local)
-  return comparison !== null && comparison > 0 ? latest : null
-}
-
-export function thisCliVersion(): string | null {
-  return packageVersion()
-}
-
-export function resetLatestPublishedCliVersionForTest(): void {
-  cached = null
-}

package/src/cli-update-contract.ts

@@ -1,9 +0,0 @@
-/**
- * Resolve the current published CLI independently of every installed
- * `notifai` command. The fetched build owns the locally derived prefix repair,
- * so this action neither invokes the stale PATH winner nor exposes local
- * installation paths.
- */
-export function cliUpdateRecoveryCommand(): string {
-  return 'npx --yes @raidiant/notifai@latest update'
-}

package/src/cli-update.test.ts

@@ -1,125 +0,0 @@
-import { spawnSync } from 'node:child_process'
-import {
-  chmodSync,
-  mkdirSync,
-  mkdtempSync,
-  readFileSync,
-  realpathSync,
-  symlinkSync,
-  writeFileSync,
-} from 'node:fs'
-import os from 'node:os'
-import path from 'node:path'
-import { describe, expect, it } from 'vitest'
-import type { CommandDeps, CommandIo } from './commands-core.js'
-import { cliUpdateCommand } from './commands-update.js'
-import { installHookAdapter, inspectHookAdapter } from './hook-adapter.js'
-import { packageVersion } from './release.js'
-
-class CapturedIo implements CommandIo {
-  outLines: string[] = []
-  errLines: string[] = []
-  out(line: string) { this.outLines.push(line) }
-  err(line: string) { this.errLines.push(line) }
-  async confirm() { return false }
-  openUrl() {}
-}
-
-function npmInstall(root: string, name: string, version: string) {
-  const prefix = path.join(root, name)
-  const packageRoot = path.join(prefix, 'lib', 'node_modules', '@raidiant', 'notifai')
-  const artifact = path.join(packageRoot, 'dist', 'main.js')
-  const command = path.join(prefix, 'bin', 'notifai')
-  mkdirSync(path.dirname(artifact), { recursive: true })
-  mkdirSync(path.dirname(command), { recursive: true })
-  writeFileSync(path.join(packageRoot, 'package.json'), JSON.stringify({ version }))
-  writeFileSync(artifact, `#!${process.execPath}\nprocess.stdout.write(${JSON.stringify(version)} + "\\n")\n`)
-  chmodSync(artifact, 0o755)
-  symlinkSync(path.relative(path.dirname(command), artifact), command)
-  return { prefix, packageRoot, artifact, command }
-}
-
-describe('CLI update recovery', () => {
-  it('updates the PATH winner prefix and retargets the shared hook adapter in one action', () => {
-    const root = mkdtempSync(path.join(os.tmpdir(), 'notifai-update-loop-'))
-    const currentVersion = packageVersion()
-    if (currentVersion === null) throw new Error('test build has no package version')
-    const stale = npmInstall(root, 'stale-prefix', '3.0.1')
-    const current = npmInstall(root, 'current-prefix', currentVersion)
-    const managerPrefix = path.join(root, 'manager-prefix')
-    const managerBin = path.join(managerPrefix, 'bin')
-    const npm = path.join(managerBin, 'npm')
-    const calls = path.join(root, 'npm-calls.jsonl')
-    mkdirSync(managerBin, { recursive: true })
-    writeFileSync(
-      npm,
-      `#!${process.execPath}
-const fs = require('node:fs');
-const path = require('node:path');
-const args = process.argv.slice(2);
-fs.appendFileSync(${JSON.stringify(calls)}, JSON.stringify(args) + '\\n');
-if (args[0] === 'prefix') {
-  process.stdout.write(${JSON.stringify(managerPrefix)} + '\\n');
-  process.exit(0);
-}
-const prefix = args[args.indexOf('--prefix') + 1];
-const packageRoot = path.join(prefix, 'lib', 'node_modules', '@raidiant', 'notifai');
-const artifact = path.join(packageRoot, 'dist', 'main.js');
-fs.mkdirSync(path.dirname(artifact), { recursive: true });
-fs.writeFileSync(path.join(packageRoot, 'package.json'), JSON.stringify({ version: ${JSON.stringify(currentVersion)} }));
-fs.writeFileSync(artifact, '#!${process.execPath}\\nprocess.stdout.write(${JSON.stringify(`${currentVersion}\\n`)})\\n', { mode: 0o755 });
-`,
-    )
-    chmodSync(npm, 0o755)
-
-    const home = path.join(root, 'home')
-    installHookAdapter({ execPath: process.execPath, scriptPath: stale.artifact }, home)
-    const io = new CapturedIo()
-    const deps: CommandDeps = {
-      io,
-      store: { load: () => null, save: () => {}, clear: () => {}, describe: () => 'test' },
-      env: {
-        PATH: [managerBin, path.dirname(stale.command), path.dirname(current.command)].join(':'),
-      },
-      cwd: root,
-      hookAdapterHome: home,
-      hookInstallTarget: { execPath: process.execPath, scriptPath: current.artifact },
-      hookPlatform: 'darwin',
-    }
-
-    expect(cliUpdateCommand(deps, {})).toBe(0)
-    expect(JSON.parse(readFileSync(path.join(stale.packageRoot, 'package.json'), 'utf8'))).toMatchObject({
-      version: currentVersion,
-    })
-    expect(
-      readFileSync(calls, 'utf8').trim().split('\n').map((line) => JSON.parse(line)),
-    ).toEqual([
-      ['prefix', '--global'],
-      ['install', '--global', '--prefix', realpathSync(stale.prefix), '@raidiant/notifai'],
-    ])
-    expect(spawnSync(stale.command, ['--version'], { encoding: 'utf8' }).stdout.trim()).toBe(currentVersion)
-    expect(inspectHookAdapter(home).target).toMatchObject({ scriptPath: realpathSync(stale.artifact) })
-    expect(io.outLines).toEqual(['Notifai is updated. Re-run `notifai init` to continue setup.'])
-    expect(io.outLines.join('\n')).not.toContain(root)
-    expect(io.errLines).toEqual([])
-
-    io.outLines = []
-    expect(cliUpdateCommand(deps, { json: true })).toBe(0)
-    const result = JSON.parse(io.outLines[0] ?? '{}') as Record<string, unknown>
-    expect(result).toMatchObject({
-      ok: true,
-      package_manager_prefix: managerPrefix,
-      update_prefix: realpathSync(stale.prefix),
-      after: {
-        effective: {
-          command_path: stale.command,
-          artifact_path: realpathSync(stale.artifact),
-          version: currentVersion,
-        },
-      },
-      hook_adapter: {
-        target: { scriptPath: realpathSync(stale.artifact) },
-      },
-    })
-  })
-})