@meistrari/tela-cli 0.6.0 → 0.7.4

package/src/auth.ts

@@ -1,432 +0,0 @@
-import {
-    DeviceAccessDeniedError,
-    DeviceCodeExpiredError,
-    DeviceFlow,
-    DeviceFlowAbortedError,
-    RefreshTokenExpiredError,
-} from '@meistrari/auth-cli'
-import {
-    clearSavedAuth,
-    isPlaceholderApplicationId,
-    saveConfig,
-} from './config.ts'
-import { createUserFacingError } from './errors.ts'
-import { runCommand } from './process.ts'
-import type {
-    TelaCliAuthState,
-    TelaCliConfig,
-    TelaCliUser,
-    TelaCliWorkspace,
-} from './types.ts'
-
-export type FetchLike = (input: string | URL | Request, init?: RequestInit) => Promise<Response>
-
-type StoredTokensLike = {
-    accessToken: string
-    refreshToken: string
-    expiresAt: number
-    user: {
-        id: string
-        email: string
-        name?: string | null
-    }
-    organization: {
-        id: string
-        name?: string | null
-        title?: string | null
-        slug?: string | null
-    }
-}
-
-export interface DeviceFlowLike {
-    on(
-        eventName: 'userCode',
-        listener: (payload: {
-            userCode: string
-            verificationUri: string
-            verificationUriComplete: string
-            expiresIn: number
-            interval: number
-        }) => void | Promise<void>,
-    ): unknown
-    on(
-        eventName: 'pending',
-        listener: (payload: { attempt: number, elapsedMs: number }) => void | Promise<void>,
-    ): unknown
-    on(
-        eventName: 'slowDown',
-        listener: (payload: { previousInterval: number, newInterval: number }) => void | Promise<void>,
-    ): unknown
-    on(
-        eventName: 'transientError',
-        listener: (payload: { attempt: number }) => void | Promise<void>,
-    ): unknown
-    authenticate(): Promise<StoredTokensLike>
-    refresh(refreshToken?: string): Promise<StoredTokensLike>
-}
-
-export type DeviceFlowFactory = (input: {
-    apiUrl: string
-    requesterApplicationId: string
-    targetApplicationId: string
-    signal?: AbortSignal
-}) => DeviceFlowLike
-
-export interface SetupAuthEvent {
-    type: 'message' | 'user_code' | 'browser_opened' | 'browser_open_failed' | 'success'
-    message: string
-    title?: string
-    verificationUrl?: string
-    userCode?: string
-    expiresInSeconds?: number
-}
-
-export interface AuthenticateWithDeviceFlowOptions {
-    createDeviceFlow?: DeviceFlowFactory
-    openBrowser?: (url: string) => Promise<boolean>
-    timeoutMs?: number
-    onEvent?: (event: SetupAuthEvent) => void
-}
-
-export interface BuildAgentApiHeadersOptions {
-    clearAuth?: (config: TelaCliConfig) => TelaCliConfig
-    createDeviceFlow?: DeviceFlowFactory
-    fetchFn?: FetchLike
-    nowMs?: number
-    persistConfig?: (config: TelaCliConfig) => void
-}
-
-function defaultDeviceFlowFactory(input: ConstructorParameters<typeof DeviceFlow>[0]): DeviceFlowLike {
-    return new DeviceFlow(input)
-}
-
-function createAuthRequiredError(summary: string): ReturnType<typeof createUserFacingError> {
-    return createUserFacingError({
-        code: 'auth_required',
-        summary,
-        fixes: ['Run `tela setup` in an interactive terminal to sign in again.'],
-    })
-}
-
-function mapUser(user: StoredTokensLike['user']): TelaCliUser {
-    return {
-        id: user.id,
-        email: user.email,
-        name: user.name?.trim() || user.email,
-    }
-}
-
-function mapWorkspace(organization: StoredTokensLike['organization']): TelaCliWorkspace {
-    return {
-        id: organization.id,
-        title: organization.name?.trim()
-            || organization.title?.trim()
-            || organization.slug?.trim()
-            || organization.id,
-    }
-}
-
-function mapTokens(tokens: StoredTokensLike): TelaCliAuthState {
-    return {
-        user: mapUser(tokens.user),
-        workspace: mapWorkspace(tokens.organization),
-        session: {
-            accessToken: tokens.accessToken,
-            refreshToken: tokens.refreshToken,
-            expiresAt: tokens.expiresAt,
-        },
-    }
-}
-
-function buildDashboardVerificationUrl(dashboardUrl: string, userCode: string, fallbackUrl: string): string {
-    try {
-        const url = new URL('/applications/device', dashboardUrl)
-        url.searchParams.set('user_code', userCode)
-        return url.toString()
-    }
-    catch {
-        return fallbackUrl
-    }
-}
-
-async function defaultOpenBrowser(url: string): Promise<boolean> {
-    const command = (() => {
-        switch (process.platform) {
-            case 'darwin':
-                return ['open', url]
-            case 'win32':
-                return ['cmd', '/c', 'start', '', url]
-            default:
-                return ['xdg-open', url]
-        }
-    })()
-
-    try {
-        const result = await runCommand(command, { allowFailure: true })
-        return result.exitCode === 0
-    }
-    catch {
-        return false
-    }
-}
-
-function ensurePresetApplicationIds(input: {
-    environment: TelaCliConfig['environment']
-    requesterApplicationId: string
-    targetApplicationId: string
-}): void {
-    if (input.environment === 'custom') {
-        return
-    }
-
-    if (!isPlaceholderApplicationId(input.requesterApplicationId) && !isPlaceholderApplicationId(input.targetApplicationId)) {
-        return
-    }
-
-    throw createUserFacingError({
-        code: 'setup_preset_incomplete',
-        summary: `The ${input.environment} auth preset is missing the real Tela CLI application IDs.`,
-        fixes: [
-            'Update the production/staging requester and target application IDs in `src/config.ts`, or use the custom setup target.',
-        ],
-    })
-}
-
-export async function authenticateWithDeviceFlow(
-    input: Pick<TelaCliConfig, 'environment' | 'authApiUrl' | 'authDashboardUrl' | 'requesterApplicationId' | 'targetApplicationId'>,
-    options: AuthenticateWithDeviceFlowOptions = {},
-): Promise<TelaCliAuthState> {
-    ensurePresetApplicationIds(input)
-
-    const timeoutMs = options.timeoutMs ?? (15 * 60 * 1000)
-    const signal = AbortSignal.timeout(timeoutMs)
-    const createDeviceFlow = options.createDeviceFlow ?? defaultDeviceFlowFactory
-    const openBrowser = options.openBrowser ?? defaultOpenBrowser
-    const emit = (event: SetupAuthEvent) => {
-        options.onEvent?.(event)
-    }
-
-    const flow = createDeviceFlow({
-        apiUrl: input.authApiUrl,
-        requesterApplicationId: input.requesterApplicationId,
-        targetApplicationId: input.targetApplicationId,
-        signal,
-    })
-
-    flow.on('userCode', async ({ userCode, verificationUriComplete, expiresIn }) => {
-        const verificationUrl = buildDashboardVerificationUrl(
-            input.authDashboardUrl,
-            userCode,
-            verificationUriComplete,
-        )
-
-        emit({
-            type: 'user_code',
-            title: 'Authentication',
-            message: `Open ${verificationUrl}\nUser code: ${userCode}\nCode expires in ${expiresIn}s`,
-            verificationUrl,
-            userCode,
-            expiresInSeconds: expiresIn,
-        })
-
-        const opened = await openBrowser(verificationUrl)
-        emit(opened
-            ? {
-                type: 'browser_opened',
-                title: 'Authentication',
-                message: 'Opened the verification URL in your browser.',
-                verificationUrl,
-            }
-            : {
-                type: 'browser_open_failed',
-                title: 'Authentication',
-                message: 'Could not open the browser automatically. Open the verification URL manually.',
-                verificationUrl,
-            })
-    })
-
-    flow.on('pending', ({ attempt }) => {
-        emit({
-            type: 'message',
-            title: 'Authentication',
-            message: `[poll ${attempt}] Waiting for approval...`,
-        })
-    })
-
-    flow.on('slowDown', ({ newInterval }) => {
-        emit({
-            type: 'message',
-            title: 'Authentication',
-            message: `Server requested a slower polling interval (${newInterval}s).`,
-        })
-    })
-
-    flow.on('transientError', ({ attempt }) => {
-        emit({
-            type: 'message',
-            title: 'Authentication',
-            message: `[poll ${attempt}] Temporary auth server error. Retrying...`,
-        })
-    })
-
-    try {
-        const tokens = await flow.authenticate()
-        const auth = mapTokens(tokens)
-        emit({
-            type: 'success',
-            title: 'Authentication',
-            message: `Signed in as ${auth.user.email} for workspace ${auth.workspace.title}.`,
-        })
-        return auth
-    }
-    catch (error) {
-        if (error instanceof DeviceAccessDeniedError) {
-            throw createUserFacingError({
-                code: 'device_access_denied',
-                summary: 'The device authorization request was denied.',
-                fixes: ['Run `tela setup` again and approve the request in the browser.'],
-            })
-        }
-
-        if (error instanceof DeviceCodeExpiredError) {
-            throw createUserFacingError({
-                code: 'device_code_expired',
-                summary: 'The device authorization expired before approval completed.',
-                fixes: ['Run `tela setup` again and approve the request before the code expires.'],
-            })
-        }
-
-        if (error instanceof DeviceFlowAbortedError) {
-            throw createUserFacingError({
-                code: 'device_flow_timeout',
-                summary: `Timed out waiting for device authorization after ${Math.round(timeoutMs / 60_000)} minutes.`,
-                fixes: ['Run `tela setup` again and complete the browser approval before the timeout.'],
-            })
-        }
-
-        throw error
-    }
-}
-
-async function refreshAuthState(
-    config: TelaCliConfig,
-    options: BuildAgentApiHeadersOptions,
-): Promise<TelaCliAuthState> {
-    if (!config.auth?.session.refreshToken) {
-        throw createAuthRequiredError('Tela CLI is not authenticated.')
-    }
-
-    const createDeviceFlow = options.createDeviceFlow ?? defaultDeviceFlowFactory
-    const flow = createDeviceFlow({
-        apiUrl: config.authApiUrl,
-        requesterApplicationId: config.requesterApplicationId,
-        targetApplicationId: config.targetApplicationId,
-        signal: AbortSignal.timeout(10_000),
-    })
-
-    try {
-        const refreshed = await flow.refresh(config.auth.session.refreshToken)
-        const nextAuth = mapTokens(refreshed)
-        const nextConfig: TelaCliConfig = {
-            ...config,
-            auth: nextAuth,
-        }
-        ;(options.persistConfig ?? saveConfig)(nextConfig)
-        config.auth = nextAuth
-        return nextAuth
-    }
-    catch (error) {
-        if (error instanceof RefreshTokenExpiredError) {
-            ;(options.clearAuth ?? clearSavedAuth)(config)
-            config.auth = null
-            throw createAuthRequiredError('The saved Tela session expired and must be reauthenticated.')
-        }
-
-        throw error
-    }
-}
-
-async function getValidAccessToken(
-    config: TelaCliConfig,
-    options: BuildAgentApiHeadersOptions = {},
-): Promise<string> {
-    if (!config.auth?.session.accessToken) {
-        throw createAuthRequiredError('Tela CLI is not authenticated.')
-    }
-
-    const nowMs = options.nowMs ?? Date.now()
-    if (config.auth.session.expiresAt > nowMs + 30_000) {
-        return config.auth.session.accessToken
-    }
-
-    const nextAuth = await refreshAuthState(config, options)
-    return nextAuth.session.accessToken
-}
-
-type DataTokenResponse = {
-    dataToken?: string
-    error?: string
-}
-
-async function exchangeDataToken(
-    config: TelaCliConfig,
-    accessToken: string,
-    fetchFn: FetchLike,
-): Promise<string> {
-    const dataTokenUrl = new URL('/data-token', config.authApiUrl)
-    dataTokenUrl.searchParams.set('expiresAt', '1d')
-
-    const response = await fetchFn(dataTokenUrl.toString(), {
-        method: 'GET',
-        headers: {
-            Authorization: `Bearer ${accessToken}`,
-            Accept: 'application/json',
-        },
-        signal: AbortSignal.timeout(10_000),
-    })
-
-    const responseText = await response.text()
-    let payload: DataTokenResponse | null = null
-    try {
-        payload = responseText ? JSON.parse(responseText) as DataTokenResponse : null
-    }
-    catch {
-        payload = null
-    }
-
-    if (!response.ok) {
-        throw createUserFacingError({
-            code: 'data_token_exchange_failed',
-            summary: payload?.error ?? `Tela data-token exchange failed with status ${response.status}.`,
-            fixes: ['Run `tela setup` again if the saved session is stale.'],
-            evidence: responseText ? [responseText] : [],
-        })
-    }
-
-    const headerToken = response.headers.get('x-data-token')?.trim()
-    const dataToken = headerToken || payload?.dataToken?.trim()
-    if (!dataToken) {
-        throw createUserFacingError({
-            code: 'data_token_exchange_invalid',
-            summary: 'Tela data-token exchange returned an invalid response.',
-            fixes: ['Run `tela setup` again if the saved session is stale.'],
-            evidence: responseText ? [responseText] : [],
-        })
-    }
-
-    return dataToken
-}
-
-export async function buildAgentApiHeaders(
-    config: TelaCliConfig,
-    options: BuildAgentApiHeadersOptions = {},
-): Promise<Record<string, string>> {
-    const fetchFn = options.fetchFn ?? fetch
-    const accessToken = await getValidAccessToken(config, options)
-    const dataToken = await exchangeDataToken(config, accessToken, fetchFn)
-
-    return {
-        'x-data-token': dataToken,
-        Accept: 'application/json',
-    }
-}

package/src/claude.ts

@@ -1,101 +0,0 @@
-import { commandExists, runCommand } from './process.ts'
-
-export interface ClaudeCliVersion {
-    major: number
-    minor: number
-    patch: number
-}
-
-export interface ClaudeCliInspection {
-    available: boolean
-    version?: string
-    parsedVersion?: ClaudeCliVersion
-    supportsProjectScopedRun: boolean
-    problem?: 'missing' | 'unparseable' | 'unsupported'
-    detail?: string
-}
-
-export const MIN_CLAUDE_VERSION_FOR_PROJECT_SCOPED_RUN: ClaudeCliVersion = {
-    major: 2,
-    minor: 1,
-    patch: 108,
-}
-
-export function formatClaudeCliVersion(version: ClaudeCliVersion): string {
-    return `${version.major}.${version.minor}.${version.patch}`
-}
-
-export function compareClaudeCliVersions(left: ClaudeCliVersion, right: ClaudeCliVersion): number {
-    if (left.major !== right.major) {
-        return left.major - right.major
-    }
-
-    if (left.minor !== right.minor) {
-        return left.minor - right.minor
-    }
-
-    return left.patch - right.patch
-}
-
-export function parseClaudeCliVersion(raw: string): ClaudeCliVersion | null {
-    const match = raw.match(/\b(\d+)\.(\d+)\.(\d+)\b/)
-    if (!match) {
-        return null
-    }
-
-    return {
-        major: Number(match[1]),
-        minor: Number(match[2]),
-        patch: Number(match[3]),
-    }
-}
-
-export async function inspectClaudeCli(options: {
-    commandExistsFn?: typeof commandExists
-    runCommandFn?: typeof runCommand
-} = {}): Promise<ClaudeCliInspection> {
-    const commandExistsFn = options.commandExistsFn ?? commandExists
-    const runCommandFn = options.runCommandFn ?? runCommand
-
-    if (!await commandExistsFn('claude')) {
-        return {
-            available: false,
-            supportsProjectScopedRun: false,
-            problem: 'missing',
-            detail: '`claude` is not available on PATH.',
-        }
-    }
-
-    const result = await runCommandFn(['claude', '--version'], { allowFailure: true })
-    const output = `${result.stdout}\n${result.stderr}`.trim()
-    const parsedVersion = parseClaudeCliVersion(output)
-
-    if (!parsedVersion) {
-        return {
-            available: true,
-            supportsProjectScopedRun: false,
-            problem: 'unparseable',
-            detail: output || 'Claude CLI version output was empty.',
-        }
-    }
-
-    const version = formatClaudeCliVersion(parsedVersion)
-    if (compareClaudeCliVersions(parsedVersion, MIN_CLAUDE_VERSION_FOR_PROJECT_SCOPED_RUN) < 0) {
-        return {
-            available: true,
-            version,
-            parsedVersion,
-            supportsProjectScopedRun: false,
-            problem: 'unsupported',
-            detail: `Claude CLI ${version} is older than the required ${formatClaudeCliVersion(MIN_CLAUDE_VERSION_FOR_PROJECT_SCOPED_RUN)}.`,
-        }
-    }
-
-    return {
-        available: true,
-        version,
-        parsedVersion,
-        supportsProjectScopedRun: true,
-        detail: `Claude CLI ${version} supports project-scoped runs.`,
-    }
-}

package/src/commands/doctor.ts

@@ -1,35 +0,0 @@
-import { createDoctorReport, type DoctorReport } from '../diagnostics.ts'
-import { nextActions, resultCard, section, table, type RenderOptions } from '../ui.ts'
-
-const STATUS_LABEL: Record<'pass' | 'warn' | 'fail', string> = {
-    pass: 'PASS',
-    warn: 'WARN',
-    fail: 'FAIL',
-}
-
-export function renderDoctorReport(report: DoctorReport, options: RenderOptions = {}): string {
-    const rows = report.checks.map(check => [
-        check.group,
-        STATUS_LABEL[check.status],
-        check.summary,
-    ])
-
-    const remediation = report.checks
-        .filter(check => check.status !== 'pass')
-        .map((check) => {
-            const fixes = check.fixes.map(fix => `- ${fix}`).join('\n')
-            const evidence = check.evidence?.length ? `\n\nEvidence\n${check.evidence.map(item => `- ${item}`).join('\n')}` : ''
-            return `${check.summary}\n${fixes}${evidence}`
-        })
-        .join('\n\n')
-
-    return resultCard('Tela doctor', [
-        section('Checks', table(['Group', 'Status', 'Summary'], rows, options), options),
-        remediation ? section('Remediation', remediation, options) : undefined,
-        nextActions(report.nextActions, options),
-    ], options)
-}
-
-export async function getDoctorReport(cwd = process.cwd(), fetchFn: typeof fetch = fetch): Promise<DoctorReport> {
-    return await createDoctorReport(cwd, fetchFn)
-}