@meistrari/tela-cli 0.4.0 → 0.5.0

package/src/diagnostics.ts

@@ -1,7 +1,13 @@
 import { accessSync, constants, existsSync, statSync } from 'node:fs'
 import { dirname } from 'node:path'
 import { buildAgentApiHeaders } from './auth.ts'
+import {
+    formatClaudeCliVersion,
+    inspectClaudeCli,
+    MIN_CLAUDE_VERSION_FOR_PROJECT_SCOPED_RUN,
+} from './claude.ts'
 import { inspectSavedConfig, redactSecret } from './config.ts'
+import { resolveSshPrivateKeyPath } from './forgejo.ts'
 import {
     findRepositoryRoot,
     getCurrentBranch,
@@ -57,6 +63,9 @@ export interface StatusReport {
         workspace?: string
         forgejoOrganization?: string
         forgejoUserRegistered?: boolean
+        gitSshKeyTitle?: string
+        gitSshPublicKeyPath?: string
+        gitSshPrivateKeyPath?: string
         accessToken?: string
         sessionExpiresAt?: number
         hasRefreshToken?: boolean
@@ -66,6 +75,9 @@ export interface StatusReport {
     tools: {
         git: boolean
         claude: boolean
+        claudeVersion?: string
+        claudeProjectScopedRunSupported?: boolean | null
+        claudeDetail?: string
         agentApiReachable: boolean | null
         agentApiCategory?: AgentApiReachabilityCategory
         agentApiStatus?: number
@@ -264,6 +276,8 @@ function buildStatusNextActions(
     hasAuth: boolean,
     hasForgejoOrganization: boolean,
     hasForgejoAccess: boolean,
+    hasGitSshKey: boolean,
+    claudeFix?: string,
 ): string[] {
     const actions: string[] = []
 
@@ -279,6 +293,9 @@ function buildStatusNextActions(
     else if (!hasForgejoAccess) {
         actions.push('Run `tela setup` again to provision Forgejo access with your SSH key.')
     }
+    else if (!hasGitSshKey) {
+        actions.push('Run `tela setup` again to choose the SSH key Tela should force on Git operations.')
+    }
 
     if (!repo.inRepository) {
         actions.push('Run `tela sync <repo>` or change into a cloned repository before mutating commands.')
@@ -292,6 +309,10 @@ function buildStatusNextActions(
         actions.push('Review local changes before syncing, or use `tela push` to stage and commit them.')
     }
 
+    if (claudeFix) {
+        actions.push(claudeFix)
+    }
+
     if (warnings.length === 0) {
         actions.push('Run `tela sync --current`, `tela run`, or `tela push` when you are ready.')
     }
@@ -303,15 +324,16 @@ export async function createStatusReport(
     cwd = process.cwd(),
     fetchFn: typeof fetch = fetch,
 ): Promise<StatusReport> {
-    const [configInspection, gitAvailable, claudeAvailable, repo] = await Promise.all([
+    const [configInspection, gitAvailable, claudeInspection, repo] = await Promise.all([
         Promise.resolve(inspectSavedConfig()),
         commandExists('git'),
-        commandExists('claude'),
+        inspectClaudeCli(),
         inspectCurrentRepository(cwd),
     ])
 
     const warnings: string[] = []
     let reachability: AgentApiReachability | undefined
+    let claudeFix: string | undefined
 
     if (!configInspection.exists) {
         warnings.push('Tela CLI is not configured yet.')
@@ -329,14 +351,35 @@ export async function createStatusReport(
         if (!configInspection.config.forgejoUserRegistered) {
             warnings.push('Forgejo user access is not provisioned yet.')
         }
+        if (!configInspection.config.gitSshKey) {
+            warnings.push('Git SSH key selection is missing.')
+        }
+        else {
+            try {
+                resolveSshPrivateKeyPath(configInspection.config.gitSshKey.privateKeyPath)
+            }
+            catch (error) {
+                warnings.push(`Configured Git SSH private key is unavailable: ${error instanceof Error ? error.message : String(error)}`)
+            }
+        }
     }
 
     if (!gitAvailable) {
         warnings.push('`git` is not available on PATH.')
     }
 
-    if (!claudeAvailable) {
+    if (!claudeInspection.available) {
         warnings.push('`claude` is not available on PATH.')
+        claudeFix = 'Install the Claude CLI before using `tela run`, `tela push --claude`, or `tela feedback`.'
+    }
+    else if (!claudeInspection.supportsProjectScopedRun) {
+        const requiredVersion = formatClaudeCliVersion(MIN_CLAUDE_VERSION_FOR_PROJECT_SCOPED_RUN)
+        warnings.push(
+            claudeInspection.problem === 'unparseable'
+                ? `Claude CLI version could not be determined for project-scoped runs: ${claudeInspection.detail ?? 'unknown output'}`
+                : `Claude CLI must be updated to ${requiredVersion} or newer for project-scoped \`tela run\`.`,
+        )
+        claudeFix = `Update Claude CLI to version ${requiredVersion} or newer before using \`tela run\`.`
     }
 
     if (repo.detached) {
@@ -362,6 +405,8 @@ export async function createStatusReport(
         Boolean(configInspection.config?.auth),
         Boolean(configInspection.config?.forgejoOrganization),
         Boolean(configInspection.config?.forgejoUserRegistered),
+        Boolean(configInspection.config?.gitSshKey),
+        claudeFix,
     )
 
     return {
@@ -379,6 +424,9 @@ export async function createStatusReport(
             workspace: configInspection.config?.auth?.workspace.title,
             forgejoOrganization: configInspection.config?.forgejoOrganization?.name,
             forgejoUserRegistered: configInspection.config?.forgejoUserRegistered,
+            gitSshKeyTitle: configInspection.config?.gitSshKey?.title,
+            gitSshPublicKeyPath: configInspection.config?.gitSshKey?.publicKeyPath,
+            gitSshPrivateKeyPath: configInspection.config?.gitSshKey?.privateKeyPath,
             accessToken: configInspection.config?.auth ? redactSecret(configInspection.config.auth.session.accessToken) : undefined,
             sessionExpiresAt: configInspection.config?.auth?.session.expiresAt,
             hasRefreshToken: Boolean(configInspection.config?.auth?.session.refreshToken),
@@ -387,7 +435,12 @@ export async function createStatusReport(
         repo,
         tools: {
             git: gitAvailable,
-            claude: claudeAvailable,
+            claude: claudeInspection.available,
+            claudeVersion: claudeInspection.version,
+            claudeProjectScopedRunSupported: claudeInspection.available
+                ? claudeInspection.supportsProjectScopedRun
+                : null,
+            claudeDetail: claudeInspection.detail,
             agentApiReachable: reachability?.reachable ?? null,
             agentApiCategory: reachability?.category,
             agentApiStatus: reachability?.statusCode,
@@ -474,6 +527,47 @@ function buildCloneRootCheck(cloneRoot: string | undefined): DoctorCheck {
     }
 }
 
+function buildGitSshKeyCheck(gitSshKey: {
+    title?: string
+    publicKeyPath?: string
+    privateKeyPath?: string
+}): DoctorCheck {
+    if (!gitSshKey.privateKeyPath) {
+        return {
+            id: 'git-ssh-key',
+            group: 'access',
+            status: 'warn',
+            summary: 'No Git SSH key is configured.',
+            fixes: ['Run `tela setup` again and choose the SSH key to force on Git operations.'],
+        }
+    }
+
+    try {
+        const privateKeyPath = resolveSshPrivateKeyPath(gitSshKey.privateKeyPath)
+        return {
+            id: 'git-ssh-key',
+            group: 'access',
+            status: 'pass',
+            summary: `Git SSH key is configured: ${gitSshKey.title ?? '<unnamed>'}.`,
+            fixes: ['No action required.'],
+            evidence: [
+                gitSshKey.publicKeyPath ? `public key: ${gitSshKey.publicKeyPath}` : '',
+                `private key: ${privateKeyPath}`,
+            ].filter(Boolean),
+        }
+    }
+    catch (error) {
+        return {
+            id: 'git-ssh-key',
+            group: 'access',
+            status: 'fail',
+            summary: 'Configured Git SSH private key is unavailable.',
+            fixes: ['Restore the private key file or run `tela setup` again and choose another SSH key.'],
+            evidence: [error instanceof Error ? error.message : String(error)],
+        }
+    }
+}
+
 function buildRepoChecks(repo: RepoSnapshot): DoctorCheck[] {
     if (!repo.inRepository) {
         return [
@@ -568,10 +662,10 @@ export async function createDoctorReport(
     cwd = process.cwd(),
     fetchFn: typeof fetch = fetch,
 ): Promise<DoctorReport> {
-    const [configInspection, gitAvailable, claudeAvailable, repo] = await Promise.all([
+    const [configInspection, gitAvailable, claudeInspection, repo] = await Promise.all([
         Promise.resolve(inspectSavedConfig()),
         commandExists('git'),
-        commandExists('claude'),
+        inspectClaudeCli(),
         inspectCurrentRepository(cwd),
     ])
 
@@ -611,9 +705,22 @@ export async function createDoctorReport(
         {
             id: 'tool-claude',
             group: 'tools',
-            status: claudeAvailable ? 'pass' : 'warn',
-            summary: claudeAvailable ? '`claude` is available.' : '`claude` is not available on PATH.',
-            fixes: claudeAvailable ? ['No action required.'] : ['Install the Claude CLI before using `tela run`, `tela push --claude`, or `tela feedback`.'],
+            status: !claudeInspection.available
+                ? 'warn'
+                : (claudeInspection.supportsProjectScopedRun ? 'pass' : 'fail'),
+            summary: !claudeInspection.available
+                ? '`claude` is not available on PATH.'
+                : (claudeInspection.supportsProjectScopedRun
+                    ? `Claude CLI is available (${claudeInspection.version ?? 'unknown version'}) and supports project-scoped runs.`
+                    : (claudeInspection.problem === 'unparseable'
+                        ? 'Claude CLI version could not be determined for project-scoped runs.'
+                        : `Claude CLI ${claudeInspection.version ?? '<unknown>'} is too old for project-scoped runs.`)),
+            fixes: !claudeInspection.available
+                ? ['Install the Claude CLI before using `tela run`, `tela push --claude`, or `tela feedback`.']
+                : (claudeInspection.supportsProjectScopedRun
+                    ? ['No action required.']
+                    : [`Update Claude CLI to version ${formatClaudeCliVersion(MIN_CLAUDE_VERSION_FOR_PROJECT_SCOPED_RUN)} or newer before using \`tela run\`.`]),
+            evidence: claudeInspection.available && claudeInspection.detail ? [claudeInspection.detail] : undefined,
         },
         ...buildRepoChecks(repo),
     ]
@@ -688,6 +795,12 @@ export async function createDoctorReport(
                 ? ['No action required.']
                 : ['Run `tela setup` again and complete SSH-key provisioning for Forgejo access.'],
         })
+
+        checks.push(buildGitSshKeyCheck({
+            title: configInspection.config.gitSshKey?.title,
+            publicKeyPath: configInspection.config.gitSshKey?.publicKeyPath,
+            privateKeyPath: configInspection.config.gitSshKey?.privateKeyPath,
+        }))
     }
 
     const nextActions = buildNextActions(checks)

package/src/forgejo.ts

@@ -8,6 +8,7 @@ import type {
     ForgejoUserCreateResponse,
     ForgejoUserSshKeyInput,
     TelaCliConfig,
+    TelaCliGitSshKey,
     TelaCliForgejoOrganization,
 } from './types.ts'
 
@@ -95,6 +96,49 @@ export function validateSshPublicKeyPath(value: string): string | undefined {
     }
 }
 
+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)) {