@meistrari/tela-cli 0.7.0 → 0.7.4

package/src/errors.ts

@@ -1,122 +0,0 @@
-import { CommandError } from './process.ts'
-import { errorCard, type RenderOptions } from './ui.ts'
-
-export interface UserFacingErrorInput {
-    code: string
-    summary: string
-    details?: string
-    fixes?: string[]
-    evidence?: string[]
-    exitCode?: number
-    cause?: unknown
-}
-
-export class UserFacingError extends Error {
-    public readonly code: string
-    public readonly summary: string
-    public readonly details?: string
-    public readonly fixes: string[]
-    public readonly evidence: string[]
-    public readonly exitCode: number
-    public readonly cause?: unknown
-
-    constructor(input: UserFacingErrorInput) {
-        super(input.summary)
-        this.name = 'UserFacingError'
-        this.code = input.code
-        this.summary = input.summary
-        this.details = input.details
-        this.fixes = input.fixes ?? []
-        this.evidence = input.evidence ?? []
-        this.exitCode = input.exitCode ?? 1
-        this.cause = input.cause
-    }
-}
-
-export function createUserFacingError(input: UserFacingErrorInput): UserFacingError {
-    return new UserFacingError(input)
-}
-
-export function isUserFacingError(error: unknown): error is UserFacingError {
-    return error instanceof UserFacingError
-}
-
-export function toUserFacingError(error: unknown): UserFacingError {
-    if (isUserFacingError(error)) {
-        return error
-    }
-
-    if (error instanceof CommandError) {
-        const stdout = error.result.stdout.trim()
-        const stderr = error.result.stderr.trim()
-        const evidence = [
-            `Command: ${error.result.command.join(' ')}`,
-            stdout ? `stdout: ${stdout}` : '',
-            stderr ? `stderr: ${stderr}` : '',
-        ].filter(Boolean)
-
-        return new UserFacingError({
-            code: 'command_failed',
-            summary: 'A local command failed.',
-            details: error.message,
-            evidence,
-            exitCode: 1,
-            cause: error,
-        })
-    }
-
-    if (error instanceof Error) {
-        return new UserFacingError({
-            code: 'unexpected_error',
-            summary: error.message,
-            exitCode: 1,
-            cause: error,
-        })
-    }
-
-    return new UserFacingError({
-        code: 'unexpected_error',
-        summary: String(error),
-        exitCode: 1,
-        cause: error,
-    })
-}
-
-export function renderUserFacingError(
-    error: unknown,
-    options: RenderOptions & { verbose?: boolean } = {},
-): string {
-    const userError = toUserFacingError(error)
-    const evidence = options.verbose ? userError.evidence : []
-
-    return errorCard({
-        summary: userError.summary,
-        details: userError.details,
-        fixes: userError.fixes,
-        evidence,
-    }, options)
-}
-
-export function serializeError(error: unknown): {
-    ok: false
-    error: {
-        code: string
-        summary: string
-        details?: string
-        fixes: string[]
-        evidence: string[]
-    }
-} {
-    const userError = toUserFacingError(error)
-
-    return {
-        ok: false,
-        error: {
-            code: userError.code,
-            summary: userError.summary,
-            details: userError.details,
-            fixes: userError.fixes,
-            evidence: userError.evidence,
-        },
-    }
-}

package/src/forgejo.ts

@@ -1,233 +0,0 @@
-import { existsSync, readFileSync, readdirSync, statSync } from 'node:fs'
-import { homedir } from 'node:os'
-import { basename, extname, join } from 'node:path'
-import { provisionForgejoUser, type AgentApiError } from './agent-api.ts'
-import type { FetchLike } from './auth.ts'
-import { createUserFacingError } from './errors.ts'
-import type {
-    ForgejoUserCreateResponse,
-    ForgejoUserSshKeyInput,
-    TelaCliConfig,
-    TelaCliGitSshKey,
-    TelaCliForgejoOrganization,
-} from './types.ts'
-
-export interface SelectedSshPublicKey extends ForgejoUserSshKeyInput {
-    path: string
-}
-
-export interface EnsureForgejoUserAccessOptions {
-    config: TelaCliConfig
-    organization: TelaCliForgejoOrganization
-    sshKey: SelectedSshPublicKey
-    fetchFn?: FetchLike
-    onProgress?: (message: string, title?: string) => void
-    provisionFn?: typeof provisionForgejoUser
-    saveConfig: (config: TelaCliConfig) => void
-}
-
-export interface ForgejoAccessResult {
-    config: TelaCliConfig
-    detail: string
-    response: ForgejoUserCreateResponse
-}
-
-function getHomeDir(): string {
-    return process.env.HOME || homedir()
-}
-
-function expandHome(input: string): string {
-    if (input === '~') {
-        return getHomeDir()
-    }
-
-    if (input.startsWith('~/')) {
-        return join(getHomeDir(), input.slice(2))
-    }
-
-    return input
-}
-
-function getSshDirectory(): string {
-    return join(getHomeDir(), '.ssh')
-}
-
-function sshKeyTitleFromPath(filePath: string): string {
-    const base = basename(filePath)
-    return extname(base) === '.pub'
-        ? base.slice(0, -4)
-        : base
-}
-
-export function loadSshPublicKey(filePath: string): SelectedSshPublicKey {
-    const expandedPath = expandHome(filePath.trim())
-    if (!expandedPath) {
-        throw new Error('SSH public key path is required')
-    }
-
-    if (!existsSync(expandedPath)) {
-        throw new Error(`SSH public key file does not exist: ${expandedPath}`)
-    }
-
-    const stats = statSync(expandedPath)
-    if (!stats.isFile()) {
-        throw new Error(`SSH public key path is not a file: ${expandedPath}`)
-    }
-
-    const key = readFileSync(expandedPath, 'utf-8').trim()
-    if (!key) {
-        throw new Error(`SSH public key file is empty: ${expandedPath}`)
-    }
-
-    return {
-        path: expandedPath,
-        title: sshKeyTitleFromPath(expandedPath),
-        key,
-    }
-}
-
-export function validateSshPublicKeyPath(value: string): string | undefined {
-    try {
-        loadSshPublicKey(value)
-        return undefined
-    }
-    catch (error) {
-        return error instanceof Error ? error.message : 'SSH public key path is invalid'
-    }
-}
-
-export function inferSshPrivateKeyPath(publicKeyPath: string): string {
-    const expandedPath = expandHome(publicKeyPath.trim())
-    return expandedPath.endsWith('.pub')
-        ? expandedPath.slice(0, -4)
-        : expandedPath
-}
-
-export function resolveSshPrivateKeyPath(filePath: string): string {
-    const expandedPath = expandHome(filePath.trim())
-    if (!expandedPath) {
-        throw new Error('SSH private key path is required')
-    }
-
-    if (!existsSync(expandedPath)) {
-        throw new Error(`SSH private key file does not exist: ${expandedPath}`)
-    }
-
-    const stats = statSync(expandedPath)
-    if (!stats.isFile()) {
-        throw new Error(`SSH private key path is not a file: ${expandedPath}`)
-    }
-
-    return expandedPath
-}
-
-export function validateSshPrivateKeyPath(value: string): string | undefined {
-    try {
-        resolveSshPrivateKeyPath(value)
-        return undefined
-    }
-    catch (error) {
-        return error instanceof Error ? error.message : 'SSH private key path is invalid'
-    }
-}
-
-export function createGitSshKey(sshKey: SelectedSshPublicKey, privateKeyPath: string): TelaCliGitSshKey {
-    return {
-        title: sshKey.title,
-        publicKeyPath: sshKey.path,
-        privateKeyPath: resolveSshPrivateKeyPath(privateKeyPath),
-    }
-}
-
-export function listDiscoveredSshPublicKeys(): SelectedSshPublicKey[] {
-    const sshDirectory = getSshDirectory()
-    if (!existsSync(sshDirectory)) {
-        return []
-    }
-
-    return readdirSync(sshDirectory, { withFileTypes: true })
-        .filter(entry => entry.isFile() && entry.name.endsWith('.pub'))
-        .map(entry => loadSshPublicKey(join(sshDirectory, entry.name)))
-        .sort((left, right) => left.title.localeCompare(right.title) || left.path.localeCompare(right.path))
-}
-
-function buildProvisioningDetail(result: ForgejoUserCreateResponse, sshKey: SelectedSshPublicKey): string {
-    const userState = result.userCreated ? 'user created' : 'user already existed'
-    const keyState = result.sshKeyCreated ? 'SSH key added' : 'SSH key already present'
-    const teamState = result.teamCreated ? 'team created' : 'team ensured'
-    const username = result.username ?? '<unknown>'
-    const teamName = result.teamName ?? '<unknown>'
-
-    return `${username} in ${teamName}; ${userState}, ${teamState}, ${keyState} (${sshKey.title})`
-}
-
-function toProvisioningError(error: unknown): never {
-    const agentApiError = error as AgentApiError
-    if (agentApiError && typeof agentApiError.status === 'number' && typeof agentApiError.responseBody === 'string') {
-        throw createUserFacingError({
-            code: 'forgejo_user_provision_failed',
-            summary: 'Forgejo user provisioning failed.',
-            details: agentApiError.message,
-            fixes: [
-                'Run `tela setup` again to refresh the Tela session and retry SSH-key provisioning.',
-                'Use `--verbose` if you need the full Agent API response details.',
-            ],
-            evidence: [
-                `Agent API status: ${agentApiError.status}`,
-                agentApiError.responseBody ? `Response body: ${agentApiError.responseBody}` : '',
-            ].filter(Boolean),
-            cause: error,
-        })
-    }
-
-    throw createUserFacingError({
-        code: 'forgejo_user_provision_failed',
-        summary: 'Forgejo user provisioning failed.',
-        details: error instanceof Error ? error.message : String(error),
-        fixes: [
-            'Run `tela setup` again to refresh the Tela session and retry SSH-key provisioning.',
-        ],
-        cause: error,
-    })
-}
-
-export async function ensureForgejoUserAccess(options: EnsureForgejoUserAccessOptions): Promise<ForgejoAccessResult> {
-    const provisionFn = options.provisionFn ?? provisionForgejoUser
-    const baseConfig: TelaCliConfig = {
-        ...options.config,
-        forgejoOrganization: options.organization,
-        forgejoUserRegistered: false,
-    }
-
-    options.saveConfig(baseConfig)
-    options.onProgress?.(
-        `Provisioning Forgejo access for ${options.organization.name} with ${options.sshKey.title}.`,
-        'Forgejo',
-    )
-
-    let response: ForgejoUserCreateResponse
-    try {
-        response = await provisionFn({
-            organizationName: options.organization.name,
-            sshKey: options.sshKey,
-        }, baseConfig, options.fetchFn)
-    }
-    catch (error) {
-        toProvisioningError(error)
-    }
-
-    const finalConfig: TelaCliConfig = {
-        ...baseConfig,
-        forgejoUserRegistered: true,
-    }
-    options.saveConfig(finalConfig)
-
-    const detail = buildProvisioningDetail(response, options.sshKey)
-    options.onProgress?.(`Forgejo access ready: ${detail}`, 'Forgejo')
-
-    return {
-        config: finalConfig,
-        detail,
-        response,
-    }
-}