open-wadah 1.0.5 → 1.0.6

package/README.md

@@ -35,11 +35,39 @@ wadah complete <task-id>
 
 - `wadah --help`
 - `wadah whoami`
+- `wadah doctor`
 - `wadah list --open`
 - `wadah move <task-id> <bucket>`
 - `wadah update <task-id> --title "New title"`
 - `wadah state`
 
+## Global Flags
+
+- `--profile <name>`: use a named profile (defaults to `default`)
+- `--token <token>`: use a token for this command only
+- `--json`: force machine-readable JSON output
+- `--quiet`: silence non-error output (also machine-friendly)
+
+## Stable Error Codes
+
+When `--json` is enabled (or output is non-interactive), errors return:
+
+```json
+{"error":{"code":"auth_error","message":"Not authenticated"}}
+```
+
+Common codes:
+
+- `auth_error`
+- `validation_error`
+- `network_error`
+- `api_error`
+- `server_error`
+- `authorization_pending`
+- `invalid_device_code`
+- `token_expired`
+- `login_timeout`
+
 ## API URL Override
 
 Use env var:

package/cli.js

@@ -6,10 +6,20 @@ import Conf from 'conf'
 import { input, password as promptPassword } from '@inquirer/prompts'
 import { webcrypto } from 'node:crypto'
 import { spawn } from 'node:child_process'
+import { readFileSync } from 'node:fs'
+import { dirname, resolve } from 'node:path'
+import { fileURLToPath } from 'node:url'
 
 const randomUUID = () => webcrypto.randomUUID()
 let runtimeApiBase = null
 const DEFAULT_API_BASE = 'https://api.openwadah.com'
+let runtimeProfile = null
+let runtimeToken = null
+let runtimeJsonOutput = false
+let runtimeQuietOutput = false
+
+const __dirname = dirname(fileURLToPath(import.meta.url))
+const CLI_VERSION = JSON.parse(readFileSync(resolve(__dirname, 'package.json'), 'utf8')).version
 
 function normalizeApiUrl(url) {
   return String(url ?? '').trim().replace(/\/$/, '')
@@ -19,18 +29,42 @@ function normalizeApiUrl(url) {
 
 const conf = new Conf({ projectName: 'open-wadah' })
 
+function getProfile() {
+  const profile = (process.env.TASK_MANAGER_PROFILE ?? runtimeProfile ?? 'default').trim()
+  return profile || 'default'
+}
+
+function profileKey(key) {
+  return `profiles.${getProfile()}.${key}`
+}
+
+function confGet(key) {
+  const scoped = conf.get(profileKey(key))
+  if (scoped !== undefined) return scoped
+  return conf.get(key)
+}
+
+function confSet(key, value) {
+  conf.set(profileKey(key), value)
+}
+
+function confDelete(key) {
+  conf.delete(profileKey(key))
+}
+
 function getApiBase() {
   return (
     (process.env.TASK_MANAGER_API_URL ?? '').trim() ||
     runtimeApiBase ||
-    conf.get('api_url') ||
+    confGet('api_url') ||
     DEFAULT_API_BASE
   )
 }
 
 function getAuthToken() {
   if (process.env.TASK_MANAGER_TOKEN) return process.env.TASK_MANAGER_TOKEN
-  return conf.get('access_token') ?? null
+  if (runtimeToken) return runtimeToken
+  return confGet('access_token') ?? null
 }
 
 function authHeaders() {
@@ -44,7 +78,7 @@ function authHeaders() {
 // ── token refresh ─────────────────────────────────────────────────────────────
 
 async function refreshAccessToken() {
-  const refreshToken = conf.get('refresh_token')
+  const refreshToken = confGet('refresh_token')
   if (!refreshToken) return false
   try {
     const res  = await fetch(`${getApiBase()}/api/auth/refresh`, {
@@ -54,9 +88,9 @@ async function refreshAccessToken() {
     })
     if (!res.ok) return false
     const data = await res.json()
-    conf.set('access_token',   data.access_token)
-    conf.set('refresh_token',  data.refresh_token)
-    conf.set('token_expires',  data.expires_at)
+    confSet('access_token',   data.access_token)
+    confSet('refresh_token',  data.refresh_token)
+    confSet('token_expires',  data.expires_at)
     return true
   } catch {
     return false
@@ -65,7 +99,7 @@ async function refreshAccessToken() {
 
 async function ensureAuth() {
   if (process.env.TASK_MANAGER_TOKEN) return   // agent token, no refresh needed
-  const expires = conf.get('token_expires')
+  const expires = confGet('token_expires')
   // Refresh if within 5 minutes of expiry or already expired
   if (expires && Date.now() > (expires * 1000) - 300_000) {
     await refreshAccessToken()
@@ -77,7 +111,12 @@ async function ensureAuth() {
 async function api(path, options = {}, retry = true) {
   await ensureAuth()
   const url = `${getApiBase()}${path}`
-  const res = await fetch(url, { headers: authHeaders(), ...options })
+  let res
+  try {
+    res = await fetch(url, { headers: authHeaders(), ...options })
+  } catch (err) {
+    throw new CliError('network_error', err.message ?? 'Network request failed')
+  }
 
   // If 401 and we have a refresh token, try once more
   if (res.status === 401 && retry && !process.env.TASK_MANAGER_TOKEN) {
@@ -86,7 +125,9 @@ async function api(path, options = {}, retry = true) {
   }
 
   const body = await res.json().catch(() => ({}))
-  if (!res.ok) throw new Error(body.error ?? body.message ?? res.statusText)
+  if (!res.ok) {
+    throw new CliError(mapApiErrorCode(res.status, body.error ?? body.message ?? res.statusText), body.error ?? body.message ?? res.statusText)
+  }
   return body
 }
 
@@ -106,6 +147,11 @@ function formatDate(ts) {
 }
 
 function printTaskList(tasks, state) {
+  if (isMachineOutput()) {
+    console.log(JSON.stringify({ tasks }, null, runtimeJsonOutput ? 2 : 0))
+    return
+  }
+
   const bucketMap   = Object.fromEntries(state.buckets.map((b)  => [b.id, b.title]))
   const assigneeMap = Object.fromEntries(state.assignees.map((a) => [a.id, a.name]))
   const boardMap    = Object.fromEntries(state.boards.map((b)   => [b.id, b.name]))
@@ -134,13 +180,17 @@ function printTaskList(tasks, state) {
 }
 
 function handleError(err) {
-  const msg = err.message ?? ''
-  if (
-    msg.includes('401') ||
+  const msg = err.message ?? 'Unexpected error'
+  const code = err.code ?? 'unknown_error'
+  const authLike =
+    code === 'auth_error' ||
     msg.toLowerCase().includes('missing token') ||
     msg.toLowerCase().includes('invalid token') ||
     msg.toLowerCase().includes('not authenticated')
-  ) {
+
+  if (isMachineOutput()) {
+    console.log(JSON.stringify({ error: { code, message: msg } }))
+  } else if (authLike) {
     console.error(chalk.red('\n✗ Not authenticated.'))
     console.error(chalk.gray('  Humans:  wadah login'))
     console.error(chalk.gray('  Agents:  TASK_MANAGER_TOKEN=<token> wadah open\n'))
@@ -182,12 +232,34 @@ function parseCompletedFlag(value) {
   const v = value.trim().toLowerCase()
   if (['true', '1', 'yes', 'y'].includes(v)) return true
   if (['false', '0', 'no', 'n'].includes(v)) return false
-  throw new Error('--completed must be true or false')
+  throw new CliError('validation_error', '--completed must be true or false')
 }
 
 function fail(message) {
-  console.error(chalk.red(`\n✗ ${message}\n`))
-  process.exitCode = 1
+  throw new CliError('validation_error', message)
+}
+
+class CliError extends Error {
+  constructor(code, message) {
+    super(message)
+    this.code = code
+  }
+}
+
+function mapApiErrorCode(status, message) {
+  const msg = String(message ?? '').toLowerCase()
+  if (status === 401 || msg.includes('missing token') || msg.includes('invalid token') || msg.includes('not authenticated')) {
+    return 'auth_error'
+  }
+  if (status === 404 && msg.includes('invalid_device_code')) return 'invalid_device_code'
+  if (status === 410 && msg.includes('expired')) return 'token_expired'
+  if (status === 428 && msg.includes('authorization_pending')) return 'authorization_pending'
+  if (status >= 500) return 'server_error'
+  return 'api_error'
+}
+
+function isMachineOutput() {
+  return runtimeJsonOutput || runtimeQuietOutput || !process.stdout.isTTY
 }
 
 function sleep(ms) {
@@ -220,12 +292,20 @@ function openBrowser(url) {
 program
   .name('wadah')
   .description('Open Wadah CLI — shared task board for humans and agents')
-  .version('1.0.0')
+  .version(CLI_VERSION)
   .option('--api <url>', 'Override API base URL for this command')
+  .option('--profile <name>', 'Use a named profile (default: default)')
+  .option('--token <token>', 'Use a token for this command only')
+  .option('--json', 'Print machine-readable JSON output')
+  .option('--quiet', 'Silence non-error output')
 
 program.hook('preAction', (_, actionCommand) => {
   const opts = actionCommand.optsWithGlobals()
   if (opts.api) runtimeApiBase = normalizeApiUrl(opts.api)
+  if (opts.profile) runtimeProfile = String(opts.profile).trim()
+  if (opts.token) runtimeToken = String(opts.token).trim()
+  runtimeJsonOutput = Boolean(opts.json)
+  runtimeQuietOutput = Boolean(opts.quiet)
 })
 
 // ── tm login ──────────────────────────────────────────────────────────────────
@@ -237,7 +317,7 @@ program
   .option('--password', 'Use terminal email/password instead of browser login')
   .option('--no-browser', "Don't auto-open browser; print URL only")
   .action(async (opts) => {
-    if (opts.apiUrl) conf.set('api_url', opts.apiUrl.trim().replace(/\/$/, ''))
+    if (opts.apiUrl) confSet('api_url', opts.apiUrl.trim().replace(/\/$/, ''))
 
     // Browser-based login (device flow) is default so password managers can autofill.
     if (!opts.password) {
@@ -248,7 +328,12 @@ program
           body: JSON.stringify({ client: 'open-wadah-cli' }),
         })
         const startBody = await startRes.json().catch(() => ({}))
-        if (!startRes.ok) throw new Error(startBody.error ?? 'Could not start browser login')
+        if (!startRes.ok) {
+          throw new CliError(
+            mapApiErrorCode(startRes.status, startBody.error ?? 'Could not start browser login'),
+            startBody.error ?? 'Could not start browser login'
+          )
+        }
 
         const verificationUrl = startBody.verification_uri_complete ?? startBody.verification_uri
         const pollEveryMs = Math.max(1000, Number(startBody.interval ?? 2) * 1000)
@@ -276,11 +361,11 @@ program
           const pollBody = await pollRes.json().catch(() => ({}))
 
           if (pollRes.ok && pollBody.access_token) {
-            conf.set('access_token',  pollBody.access_token)
-            conf.set('refresh_token', pollBody.refresh_token)
-            conf.set('token_expires', pollBody.expires_at)
-            conf.set('user_email',    pollBody.user?.email ?? null)
-            conf.set('user_id',       pollBody.user?.id ?? null)
+            confSet('access_token',  pollBody.access_token)
+            confSet('refresh_token', pollBody.refresh_token)
+            confSet('token_expires', pollBody.expires_at)
+            confSet('user_email',    pollBody.user?.email ?? null)
+            confSet('user_id',       pollBody.user?.id ?? null)
             console.log(chalk.green(`\n✓ Signed in${pollBody.user?.email ? ` as ${pollBody.user.email}` : ''}\n`))
             return
           }
@@ -291,21 +376,24 @@ program
           const pending = pollRes.status === 428 || pollBody.error === 'authorization_pending' || invalidCodeRace
           if (!pending) {
             if (pollRes.status === 410 || pollBody.error === 'expired_token') {
-              throw new Error('Browser login expired. Please run wadah login again.')
+              throw new CliError('token_expired', 'Browser login expired. Please run wadah login again.')
             }
-            throw new Error(pollBody.error ?? 'Browser login failed')
+            throw new CliError(mapApiErrorCode(pollRes.status, pollBody.error ?? 'Browser login failed'), pollBody.error ?? 'Browser login failed')
           }
           await sleep(pollEveryMs)
         }
 
-        throw new Error('Browser login timed out. Please run wadah login again.')
+        throw new CliError('login_timeout', 'Browser login timed out. Please run wadah login again.')
       } catch (err) {
-        console.error(chalk.red(`\n✗ ${err.message}\n`))
-        process.exit(1)
+        handleError(err)
       }
       return
     }
 
+    if (!process.stdin.isTTY) {
+      fail('Password login requires an interactive terminal')
+    }
+
     console.log(chalk.bold('\nOpen Wadah — Sign in\n'))
     const email = await input({ message: 'Email:' })
     const pass  = await promptPassword({ message: 'Password:' })
@@ -317,17 +405,16 @@ program
         body:    JSON.stringify({ email, password: pass }),
       })
       const body = await data.json()
-      if (!data.ok) throw new Error(body.error ?? 'Login failed')
+      if (!data.ok) throw new CliError(mapApiErrorCode(data.status, body.error ?? 'Login failed'), body.error ?? 'Login failed')
 
-      conf.set('access_token',  body.access_token)
-      conf.set('refresh_token', body.refresh_token)
-      conf.set('token_expires', body.expires_at)
-      conf.set('user_email',    body.user.email)
-      conf.set('user_id',       body.user.id)
+      confSet('access_token',  body.access_token)
+      confSet('refresh_token', body.refresh_token)
+      confSet('token_expires', body.expires_at)
+      confSet('user_email',    body.user.email)
+      confSet('user_id',       body.user.id)
       console.log(chalk.green(`\n✓ Signed in as ${body.user.email}\n`))
     } catch (err) {
-      console.error(chalk.red(`\n✗ ${err.message}\n`))
-      process.exit(1)
+      handleError(err)
     }
   })
 
@@ -338,7 +425,11 @@ program
   .description('Create a new account')
   .option('--api-url <url>', 'Override API base URL and save it')
   .action(async (opts) => {
-    if (opts.apiUrl) conf.set('api_url', opts.apiUrl.trim().replace(/\/$/, ''))
+    if (opts.apiUrl) confSet('api_url', opts.apiUrl.trim().replace(/\/$/, ''))
+
+    if (!process.stdin.isTTY) {
+      fail('Signup requires an interactive terminal')
+    }
 
     console.log(chalk.bold('\nOpen Wadah — Create account\n'))
     const name  = await input({ message: 'Name:' })
@@ -353,7 +444,7 @@ program
         body:    JSON.stringify({ name, email, password: pass }),
       })
       const signupBody = await signupRes.json()
-      if (!signupRes.ok) throw new Error(signupBody.error ?? 'Signup failed')
+      if (!signupRes.ok) throw new CliError(mapApiErrorCode(signupRes.status, signupBody.error ?? 'Signup failed'), signupBody.error ?? 'Signup failed')
 
       // Auto login
       const loginRes  = await fetch(`${getApiBase()}/api/auth/login`, {
@@ -369,18 +460,17 @@ program
           console.log(chalk.gray('  Check your inbox and confirm your email, then run: wadah login\n'))
           return
         }
-        throw new Error(msg)
+        throw new CliError(mapApiErrorCode(loginRes.status, msg), msg)
       }
 
-      conf.set('access_token',  loginBody.access_token)
-      conf.set('refresh_token', loginBody.refresh_token)
-      conf.set('token_expires', loginBody.expires_at)
-      conf.set('user_email',    loginBody.user.email)
-      conf.set('user_id',       loginBody.user.id)
+      confSet('access_token',  loginBody.access_token)
+      confSet('refresh_token', loginBody.refresh_token)
+      confSet('token_expires', loginBody.expires_at)
+      confSet('user_email',    loginBody.user.email)
+      confSet('user_id',       loginBody.user.id)
       console.log(chalk.green(`\n✓ Account created and signed in as ${email}\n`))
     } catch (err) {
-      console.error(chalk.red(`\n✗ ${err.message}\n`))
-      process.exit(1)
+      handleError(err)
     }
   })
 
@@ -390,12 +480,12 @@ program
   .command('logout')
   .description('Sign out and clear stored credentials')
   .action(() => {
-    conf.delete('access_token')
-    conf.delete('refresh_token')
-    conf.delete('token_expires')
-    conf.delete('user_email')
-    conf.delete('user_id')
-    console.log(chalk.green('✓ Signed out\n'))
+    confDelete('access_token')
+    confDelete('refresh_token')
+    confDelete('token_expires')
+    confDelete('user_email')
+    confDelete('user_id')
+    if (!runtimeQuietOutput) console.log(chalk.green('✓ Signed out\n'))
   })
 
 // ── tm whoami ─────────────────────────────────────────────────────────────────
@@ -404,12 +494,47 @@ program
   .command('whoami')
   .description('Show current identity and workspace')
   .action(async () => {
+    if (isMachineOutput()) {
+      try {
+        if (process.env.TASK_MANAGER_TOKEN || runtimeToken) {
+          const me = await api('/api/auth/me')
+          const ws = me.workspaces?.[0] ?? null
+          console.log(JSON.stringify({
+            mode: 'agent',
+            api: getApiBase(),
+            email: me.user?.email ?? null,
+            workspace: ws ? { id: ws.id, name: ws.name, role: ws.role } : null,
+            profile: getProfile(),
+          }, null, runtimeJsonOutput ? 2 : 0))
+          return
+        }
+
+        const email = confGet('user_email')
+        if (!email) {
+          console.log(JSON.stringify({ signed_in: false, api: getApiBase(), profile: getProfile() }, null, runtimeJsonOutput ? 2 : 0))
+          return
+        }
+        const me = await api('/api/auth/me')
+        const ws = me.workspaces?.[0] ?? null
+        console.log(JSON.stringify({
+          signed_in: true,
+          api: getApiBase(),
+          email: me.user?.email ?? email,
+          workspace: ws ? { id: ws.id, name: ws.name, role: ws.role } : null,
+          profile: getProfile(),
+        }, null, runtimeJsonOutput ? 2 : 0))
+      } catch (err) {
+        handleError(err)
+      }
+      return
+    }
+
     if (process.env.TASK_MANAGER_TOKEN) {
       console.log(chalk.bold('\nAgent') + '  (TASK_MANAGER_TOKEN)')
     } else {
-      const email = conf.get('user_email')
+      const email = confGet('user_email')
       if (!email) {
-        console.log(chalk.gray('\nNot signed in.  Run: tm login\n'))
+        console.log(chalk.gray('\nNot signed in.  Run: wadah login\n'))
         return
       }
       try {
@@ -421,7 +546,7 @@ program
         console.log(chalk.gray(`API:       ${getApiBase()}`))
         console.log()
       } catch {
-        console.log(chalk.gray(`\n${email}  (token may be expired — run: tm login)\n`))
+        console.log(chalk.gray(`\n${email}  (token may be expired — run: wadah login)\n`))
       }
     }
   })
@@ -840,6 +965,103 @@ program
     } catch (err) { handleError(err) }
   })
 
+program
+  .command('doctor')
+  .description('Run CLI diagnostics for API/auth/profile setup')
+  .action(async () => {
+    const checks = []
+    const addCheck = (id, status, message, details = null) => checks.push({ id, status, message, details })
+
+    addCheck('profile', 'pass', `Using profile "${getProfile()}"`)
+    addCheck('api_base', 'pass', `API base is ${getApiBase()}`)
+
+    let pingOk = false
+    try {
+      const pingRes = await fetch(`${getApiBase()}/api/ping`, { headers: { 'Content-Type': 'application/json' } })
+      if (pingRes.ok) {
+        pingOk = true
+        addCheck('api_ping', 'pass', 'API is reachable')
+      } else {
+        addCheck('api_ping', 'fail', `API ping failed with status ${pingRes.status}`)
+      }
+    } catch (err) {
+      addCheck('api_ping', 'fail', `API ping failed: ${err.message}`)
+    }
+
+    const hasEnvToken = Boolean(process.env.TASK_MANAGER_TOKEN || runtimeToken)
+    const hasSavedToken = Boolean(confGet('access_token'))
+    if (!hasEnvToken && !hasSavedToken) {
+      addCheck('auth_token', 'warn', 'No token available. Run wadah login.')
+    } else if (hasEnvToken) {
+      addCheck('auth_token', 'pass', 'Using token from env/flag')
+    } else {
+      addCheck('auth_token', 'pass', 'Using token from profile config')
+    }
+
+    if (pingOk) {
+      try {
+        const meRes = await fetch(`${getApiBase()}/api/auth/me`, { headers: authHeaders() })
+        if (meRes.ok) {
+          const meBody = await meRes.json().catch(() => ({}))
+          addCheck('auth_me', 'pass', `Authenticated as ${meBody.user?.email ?? 'unknown user'}`)
+        } else if (meRes.status === 401) {
+          addCheck('auth_me', 'warn', 'Token is missing/expired. Run wadah login.')
+        } else {
+          addCheck('auth_me', 'warn', `Auth check returned status ${meRes.status}`)
+        }
+      } catch (err) {
+        addCheck('auth_me', 'warn', `Auth check failed: ${err.message}`)
+      }
+
+      try {
+        const deviceRes = await fetch(`${getApiBase()}/api/auth/device/start`, {
+          method: 'POST',
+          headers: { 'Content-Type': 'application/json' },
+          body: JSON.stringify({ client: 'open-wadah-cli-doctor' }),
+        })
+        if (deviceRes.ok) {
+          addCheck('device_login', 'pass', 'Browser login endpoint is available')
+        } else {
+          addCheck('device_login', 'warn', `Browser login endpoint returned ${deviceRes.status}`)
+        }
+      } catch (err) {
+        addCheck('device_login', 'warn', `Browser login endpoint failed: ${err.message}`)
+      }
+    }
+
+    const failed = checks.filter((c) => c.status === 'fail').length
+    const warned = checks.filter((c) => c.status === 'warn').length
+    const report = {
+      ok: failed === 0,
+      summary: { failed, warned, total: checks.length },
+      checks,
+    }
+
+    if (isMachineOutput()) {
+      console.log(JSON.stringify(report, null, runtimeJsonOutput ? 2 : 0))
+      if (failed > 0) process.exit(1)
+      return
+    }
+
+    console.log()
+    console.log(chalk.bold('Open Wadah Doctor'))
+    checks.forEach((check) => {
+      const mark = check.status === 'pass' ? chalk.green('✓') : check.status === 'warn' ? chalk.yellow('!') : chalk.red('✗')
+      console.log(`  ${mark} ${check.id}: ${check.message}`)
+    })
+    console.log()
+    if (failed > 0) {
+      console.log(chalk.red(`  ${failed} check(s) failed. Resolve failures and rerun wadah doctor.`))
+      console.log()
+      process.exit(1)
+    } else if (warned > 0) {
+      console.log(chalk.yellow(`  Completed with ${warned} warning(s).`))
+      console.log()
+    } else {
+      console.log(chalk.green('  All checks passed.\n'))
+    }
+  })
+
 // ── tm invite ─────────────────────────────────────────────────────────────────
 
 program
@@ -868,16 +1090,28 @@ program
   .option('--api-url <url>', 'Set API base URL')
   .action((opts) => {
     if (opts.apiUrl) {
-      conf.set('api_url', opts.apiUrl.trim().replace(/\/$/, ''))
-      console.log(chalk.green(`\n✓ API URL set to ${opts.apiUrl}\n`))
+      confSet('api_url', opts.apiUrl.trim().replace(/\/$/, ''))
+      if (!runtimeQuietOutput) console.log(chalk.green(`\n✓ API URL set to ${opts.apiUrl}\n`))
+      return
+    }
+    const config = {
+      api_url: getApiBase(),
+      signed_in_as: confGet('user_email') ?? null,
+      agent_mode: Boolean(process.env.TASK_MANAGER_TOKEN || runtimeToken),
+      profile: getProfile(),
+      config_file: conf.path,
+    }
+    if (isMachineOutput()) {
+      console.log(JSON.stringify(config, null, runtimeJsonOutput ? 2 : 0))
       return
     }
     console.log()
     console.log(chalk.bold('CLI config'))
-    console.log(chalk.gray(`  API URL:      ${getApiBase()}`))
-    console.log(chalk.gray(`  Signed in as: ${conf.get('user_email') ?? '—'}`))
-    console.log(chalk.gray(`  Agent mode:   ${process.env.TASK_MANAGER_TOKEN ? 'yes (TASK_MANAGER_TOKEN set)' : 'no'}`))
-    console.log(chalk.gray(`  Config file:  ${conf.path}`))
+    console.log(chalk.gray(`  API URL:      ${config.api_url}`))
+    console.log(chalk.gray(`  Signed in as: ${config.signed_in_as ?? '—'}`))
+    console.log(chalk.gray(`  Agent mode:   ${config.agent_mode ? 'yes (TASK_MANAGER_TOKEN set)' : 'no'}`))
+    console.log(chalk.gray(`  Profile:      ${getProfile()}`))
+    console.log(chalk.gray(`  Config file:  ${config.config_file}`))
     console.log()
   })
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "open-wadah",
-  "version": "1.0.5",
+  "version": "1.0.6",
   "description": "Open Wadah CLI — shared task board for humans and agents",
   "type": "module",
   "bin": {