@meistrari/tela-cli 0.1.0 → 0.2.0

package/src/diagnostics.ts

@@ -1,6 +1,7 @@
 import { accessSync, constants, existsSync, statSync } from 'node:fs'
 import { dirname } from 'node:path'
-import { inspectSavedConfig, redactApiKey } from './config.ts'
+import { buildAgentApiHeaders } from './auth.ts'
+import { inspectSavedConfig, redactSecret } from './config.ts'
 import {
     findRepositoryRoot,
     getCurrentBranch,
@@ -47,9 +48,18 @@ export interface StatusReport {
         present: boolean
         valid: boolean
         path: string
+        environment?: string
         agentApiUrl?: string
+        authApiUrl?: string
+        telaApiUrl?: string
         cloneRoot?: string
-        apiKey?: string
+        user?: string
+        workspace?: string
+        forgejoOrganization?: string
+        forgejoUserRegistered?: boolean
+        accessToken?: string
+        sessionExpiresAt?: number
+        hasRefreshToken?: boolean
         error?: string
     }
     repo: RepoSnapshot
@@ -65,6 +75,15 @@ export interface StatusReport {
     nextActions: string[]
 }
 
+function formatSessionState(expiresAt: number | undefined, hasRefreshToken: boolean | undefined): string | undefined {
+    if (!expiresAt) {
+        return undefined
+    }
+
+    const relative = expiresAt <= Date.now() ? 'expired' : 'active'
+    return `${relative}${hasRefreshToken ? ' · refresh token saved' : ''}`
+}
+
 export interface DoctorCheck {
     id: string
     group: string
@@ -238,12 +257,28 @@ export async function inspectCurrentRepository(cwd = process.cwd()): Promise<Rep
     }
 }
 
-function buildStatusNextActions(warnings: string[], repo: RepoSnapshot, hasConfig: boolean): string[] {
+function buildStatusNextActions(
+    warnings: string[],
+    repo: RepoSnapshot,
+    hasConfig: boolean,
+    hasAuth: boolean,
+    hasForgejoOrganization: boolean,
+    hasForgejoAccess: boolean,
+): string[] {
     const actions: string[] = []
 
     if (!hasConfig) {
         actions.push('Run `tela setup` to configure the CLI.')
     }
+    else if (!hasAuth) {
+        actions.push('Run `tela setup` to sign in again.')
+    }
+    else if (!hasForgejoOrganization) {
+        actions.push('Run `tela setup` again to choose a workspace organization for Forgejo access.')
+    }
+    else if (!hasForgejoAccess) {
+        actions.push('Run `tela setup` again to provision Forgejo access with your SSH key.')
+    }
 
     if (!repo.inRepository) {
         actions.push('Run `tela sync <repo>` or change into a cloned repository before mutating commands.')
@@ -284,6 +319,17 @@ export async function createStatusReport(
     else if (!configInspection.valid) {
         warnings.push(`Tela CLI config is invalid: ${configInspection.error ?? 'unknown error'}`)
     }
+    else if (!configInspection.config?.auth) {
+        warnings.push('Tela CLI is signed out.')
+    }
+    else {
+        if (!configInspection.config.forgejoOrganization) {
+            warnings.push('Forgejo organization selection is missing.')
+        }
+        if (!configInspection.config.forgejoUserRegistered) {
+            warnings.push('Forgejo user access is not provisioned yet.')
+        }
+    }
 
     if (!gitAvailable) {
         warnings.push('`git` is not available on PATH.')
@@ -309,7 +355,14 @@ export async function createStatusReport(
         }
     }
 
-    const nextActions = buildStatusNextActions(warnings, repo, Boolean(configInspection.valid))
+    const nextActions = buildStatusNextActions(
+        warnings,
+        repo,
+        Boolean(configInspection.valid),
+        Boolean(configInspection.config?.auth),
+        Boolean(configInspection.config?.forgejoOrganization),
+        Boolean(configInspection.config?.forgejoUserRegistered),
+    )
 
     return {
         ok: warnings.length === 0,
@@ -317,9 +370,18 @@ export async function createStatusReport(
             present: configInspection.exists,
             valid: configInspection.valid,
             path: configInspection.path,
+            environment: configInspection.config?.environment,
             agentApiUrl: configInspection.config?.agentApiUrl,
+            authApiUrl: configInspection.config?.authApiUrl,
+            telaApiUrl: configInspection.config?.telaApiUrl,
             cloneRoot: configInspection.config?.cloneRoot,
-            apiKey: configInspection.config ? redactApiKey(configInspection.config.apiKey) : undefined,
+            user: configInspection.config?.auth?.user.email,
+            workspace: configInspection.config?.auth?.workspace.title,
+            forgejoOrganization: configInspection.config?.forgejoOrganization?.name,
+            forgejoUserRegistered: configInspection.config?.forgejoUserRegistered,
+            accessToken: configInspection.config?.auth ? redactSecret(configInspection.config.auth.session.accessToken) : undefined,
+            sessionExpiresAt: configInspection.config?.auth?.session.expiresAt,
+            hasRefreshToken: Boolean(configInspection.config?.auth?.session.refreshToken),
             error: configInspection.error,
         },
         repo,
@@ -566,6 +628,66 @@ export async function createDoctorReport(
             fixes: getAgentApiOriginFixes(reachability),
             evidence: reachability.reachable ? undefined : [reachability.detail],
         })
+
+        if (configInspection.config.auth) {
+            try {
+                const headers = await buildAgentApiHeaders(configInspection.config, { fetchFn })
+                checks.push({
+                    id: 'auth-session',
+                    group: 'auth',
+                    status: 'pass',
+                    summary: `Saved session is usable for ${configInspection.config.auth.user.email} in ${configInspection.config.auth.workspace.title}.`,
+                    fixes: ['No action required.'],
+                    evidence: [
+                        `data-token header: ${redactSecret(headers['x-data-token'])}`,
+                    ],
+                })
+            }
+            catch (error) {
+                const message = error instanceof Error ? error.message : String(error)
+                checks.push({
+                    id: 'auth-session',
+                    group: 'auth',
+                    status: 'fail',
+                    summary: 'Saved Tela session could not be refreshed or exchanged for a data token.',
+                    fixes: ['Run `tela setup` in an interactive terminal to sign in again.'],
+                    evidence: [message],
+                })
+            }
+        }
+        else {
+            checks.push({
+                id: 'auth-session',
+                group: 'auth',
+                status: 'fail',
+                summary: 'No saved Tela session is available.',
+                fixes: ['Run `tela setup` in an interactive terminal to sign in.'],
+            })
+        }
+
+        checks.push({
+            id: 'forgejo-organization',
+            group: 'access',
+            status: configInspection.config.forgejoOrganization ? 'pass' : 'warn',
+            summary: configInspection.config.forgejoOrganization
+                ? `Forgejo organization is selected: ${configInspection.config.forgejoOrganization.name}.`
+                : 'No Forgejo organization is selected.',
+            fixes: configInspection.config.forgejoOrganization
+                ? ['No action required.']
+                : ['Run `tela setup` again and choose a workspace organization for Forgejo access.'],
+        })
+
+        checks.push({
+            id: 'forgejo-user',
+            group: 'access',
+            status: configInspection.config.forgejoUserRegistered ? 'pass' : 'warn',
+            summary: configInspection.config.forgejoUserRegistered
+                ? 'Forgejo user access is provisioned.'
+                : 'Forgejo user access has not been provisioned yet.',
+            fixes: configInspection.config.forgejoUserRegistered
+                ? ['No action required.']
+                : ['Run `tela setup` again and complete SSH-key provisioning for Forgejo access.'],
+        })
     }
 
     const nextActions = buildNextActions(checks)

package/src/forgejo.ts

@@ -0,0 +1,189 @@
+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,
+    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 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,
+    }
+}

package/src/ink/bark.tsx

@@ -1,8 +1,9 @@
-import { existsSync, mkdtempSync, rmSync, writeFileSync } from 'node:fs'
+import { existsSync, mkdtempSync, rmSync } from 'node:fs'
 import { tmpdir } from 'node:os'
 import { join } from 'node:path'
 import React, { useEffect, useMemo, useState } from 'react'
 import { Text } from 'ink'
+import barkAudioAssetPath from './assets/160092__jorickhoofd__dog-bark-1.mp3' with { type: 'file' }
 import { getBootstrapPixelRows } from '../ui.ts'
 import { AppFrame } from './components.tsx'
 import {
@@ -51,11 +52,6 @@ const BARK_FRAME_ROWS = [
     [...BARKING_PIXEL_ROWS],
 ] as const
 
-function pseudoNoise(seed: number): number {
-    const raw = Math.sin((seed + 1) * 12.9898) * 43758.5453
-    return (raw - Math.floor(raw)) * 2 - 1
-}
-
 export interface BarkAudioWriteResult {
     directory: string
     filePath: string
@@ -71,7 +67,7 @@ export interface BarkAudioPlaybackOptions {
     platform?: string
     afplayPath?: string
     audioPlayerExists?: (path: string) => boolean
-    writeAudioFile?: () => BarkAudioWriteResult
+    writeAudioFile?: () => BarkAudioWriteResult | Promise<BarkAudioWriteResult>
     spawnAudio?: (command: string[]) => { exited?: Promise<unknown> } | void
 }
 
@@ -129,58 +125,10 @@ export function shouldPlayBarkAudio(options: {
     return audioPlayerExists(afplayPath)
 }
 
-export function buildBarkWavBuffer(): Uint8Array {
-    const sampleRate = 22_050
-    const durationSeconds = 0.18
-    const sampleCount = Math.floor(sampleRate * durationSeconds)
-    const pcm = new Int16Array(sampleCount)
-
-    for (let index = 0; index < sampleCount; index += 1) {
-        const t = index / sampleRate
-        const attack = Math.min(1, t * 40)
-        const decay = Math.exp(-15 * t)
-        const envelope = attack * decay
-        const pitch = 760 - (420 * t)
-        const body = Math.sin((2 * Math.PI * pitch) * t) * 0.58
-        const growl = Math.sin((2 * Math.PI * (pitch * 0.47)) * t + 0.8) * 0.22
-        const snap = pseudoNoise(index) * (t < 0.035 ? 0.28 : 0.08)
-        const sample = Math.max(-1, Math.min(1, (body + growl + snap) * envelope))
-        pcm[index] = Math.round(sample * 0x7fff)
-    }
-
-    const dataSize = pcm.byteLength
-    const buffer = new ArrayBuffer(44 + dataSize)
-    const view = new DataView(buffer)
-    const bytes = new Uint8Array(buffer)
-
-    const writeString = (offset: number, value: string) => {
-        for (let index = 0; index < value.length; index += 1) {
-            view.setUint8(offset + index, value.charCodeAt(index))
-        }
-    }
-
-    writeString(0, 'RIFF')
-    view.setUint32(4, 36 + dataSize, true)
-    writeString(8, 'WAVE')
-    writeString(12, 'fmt ')
-    view.setUint32(16, 16, true)
-    view.setUint16(20, 1, true)
-    view.setUint16(22, 1, true)
-    view.setUint32(24, sampleRate, true)
-    view.setUint32(28, sampleRate * 2, true)
-    view.setUint16(32, 2, true)
-    view.setUint16(34, 16, true)
-    writeString(36, 'data')
-    view.setUint32(40, dataSize, true)
-    bytes.set(new Uint8Array(pcm.buffer), 44)
-
-    return bytes
-}
-
-export function writeBarkAudioFile(baseDirectory = tmpdir()): BarkAudioWriteResult {
+export async function writeBarkAudioFile(baseDirectory = tmpdir()): Promise<BarkAudioWriteResult> {
     const directory = mkdtempSync(join(baseDirectory, 'tela-bark-'))
-    const filePath = join(directory, 'bark.wav')
-    writeFileSync(filePath, buildBarkWavBuffer())
+    const filePath = join(directory, 'bark.mp3')
+    await Bun.write(filePath, Bun.file(barkAudioAssetPath))
     return { directory, filePath }
 }
 
@@ -202,19 +150,23 @@ export async function playBarkAudio(options: BarkAudioPlaybackOptions = {}): Pro
     const writeAudioFile = options.writeAudioFile ?? writeBarkAudioFile
     const spawnAudio = options.spawnAudio ?? spawnAudioCommand
     const afplayPath = options.afplayPath ?? '/usr/bin/afplay'
-    const audioFile = writeAudioFile()
+    let audioFile: BarkAudioWriteResult | undefined
 
     try {
-        const result = spawnAudio([afplayPath, audioFile.filePath])
+        audioFile = await writeAudioFile()
+        const writtenAudioFile = audioFile
+        const result = spawnAudio([afplayPath, writtenAudioFile.filePath])
         void Promise.resolve(result?.exited)
             .catch(() => {})
             .finally(() => {
-                rmSync(audioFile.directory, { recursive: true, force: true })
+                rmSync(writtenAudioFile.directory, { recursive: true, force: true })
             })
         return { attempted: true }
     }
     catch {
-        rmSync(audioFile.directory, { recursive: true, force: true })
+        if (audioFile) {
+            rmSync(audioFile.directory, { recursive: true, force: true })
+        }
         return { attempted: false }
     }
 }

package/src/ink/screens/setup/breadcrumb.tsx

@@ -0,0 +1,23 @@
+import React from 'react'
+import { Box, Text } from 'ink'
+
+export interface BreadcrumbEntry {
+    label: string
+    value: string
+}
+
+export function Breadcrumb(props: { entries: BreadcrumbEntry[] }): React.ReactElement | null {
+    if (props.entries.length === 0) {
+        return null
+    }
+
+    return (
+        <Box flexDirection="column" marginBottom={1}>
+            {props.entries.map(entry => (
+                <Text key={entry.label} dimColor>
+                    {entry.label}: {entry.value || '—'}
+                </Text>
+            ))}
+        </Box>
+    )
+}