@chatlane/cli 0.1.0

package/README.md

@@ -0,0 +1,15 @@
+# `@chatlane/cli`
+
+Install globally:
+
+```bash
+npm i -g @chatlane/cli
+```
+
+Commands:
+
+- `chatlane --help`
+- `chatlane login`
+- `chatlane logout`
+- `chatlane whoami`
+- `chatlane ask "<question>"`

package/package.json

@@ -0,0 +1,25 @@
+{
+  "name": "@chatlane/cli",
+  "version": "0.1.0",
+  "description": "Chatlane CLI",
+  "type": "module",
+  "bin": {
+    "chatlane": "./src/index.js"
+  },
+  "files": [
+    "src",
+    "README.md"
+  ],
+  "license": "MIT",
+  "scripts": {
+    "check": "node --check src/index.js && node --check src/cli-error.js && node --check src/config.js && node --check src/constants.js && node --check src/output.js && node --check src/runtime.js && node --check src/help-text.js && node --check src/api.js && node --check src/open-browser.js && node --check src/commands/utils.js && node --check src/commands/help.js && node --check src/commands/login.js && node --check src/commands/logout.js && node --check src/commands/whoami.js && node --check src/commands/ask.js",
+    "test": "node --test test/**/*.test.js",
+    "prepublishOnly": "npm run check && npm run test"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "engines": {
+    "node": ">=18.17.0"
+  }
+}

package/src/api.js

@@ -0,0 +1,155 @@
+export function getErrorDescription(payload) {
+  if (!payload || typeof payload !== 'object') return null
+  const p = payload
+  if (typeof p.error_description === 'string') return p.error_description
+  if (typeof p.error === 'string') return p.error
+  return null
+}
+
+/**
+ * @typedef {{
+ *   deviceCode: string
+ *   userCode: string
+ *   verificationUri: string
+ *   verificationUriComplete: string
+ *   expiresIn: number
+ *   interval: number
+ * }} DeviceCodePayload
+ */
+
+/**
+ * @typedef {{
+ *   accessToken: string
+ *   errorCode: string | null
+ *   errorDescription: string | null
+ * }} DeviceTokenPayload
+ */
+
+/**
+ * @typedef {{
+ *   userId: string
+ *   email: string | null
+ *   organizationId: string
+ *   organizationName: string | null
+ * }} WhoamiPayload
+ */
+
+export async function requestJson(url, init) {
+  const response = await fetch(url, init)
+  const payload = await response.json().catch(() => null)
+  return { response, payload }
+}
+
+export async function requestText(url, init) {
+  const response = await fetch(url, init)
+  const text = await response.text()
+  return { response, text }
+}
+
+function withAuthHeaders(init, token) {
+  const headers = {
+    ...(init?.headers || {}),
+    authorization: `Bearer ${token}`,
+  }
+
+  return {
+    ...init,
+    headers,
+  }
+}
+
+export function requestAuthedJson(apiBaseUrl, path, token, init) {
+  return requestJson(`${apiBaseUrl}${path}`, withAuthHeaders(init, token))
+}
+
+export function requestAuthedText(apiBaseUrl, path, token, init) {
+  return requestText(`${apiBaseUrl}${path}`, withAuthHeaders(init, token))
+}
+
+export function parseDeviceCodePayload(payload) {
+  if (!payload || typeof payload !== 'object') return null
+  const p = payload
+
+  const deviceCode =
+    typeof p.device_code === 'string' && p.device_code ? p.device_code : null
+  const userCode =
+    typeof p.user_code === 'string' && p.user_code ? p.user_code : null
+  const verificationUriComplete =
+    typeof p.verification_uri_complete === 'string' &&
+    p.verification_uri_complete
+      ? p.verification_uri_complete
+      : null
+
+  if (!deviceCode || !userCode || !verificationUriComplete) {
+    return null
+  }
+
+  const verificationUri =
+    typeof p.verification_uri === 'string' && p.verification_uri
+      ? p.verification_uri
+      : verificationUriComplete
+  let expiresIn = Number(p.expires_in)
+  let interval = Number(p.interval)
+  if (!Number.isFinite(expiresIn) || expiresIn <= 0) expiresIn = 1800
+  if (!Number.isFinite(interval) || interval <= 0) interval = 5
+
+  /** @type {DeviceCodePayload} */
+  const parsed = {
+    deviceCode,
+    userCode,
+    verificationUri,
+    verificationUriComplete,
+    expiresIn,
+    interval,
+  }
+  return parsed
+}
+
+export function parseDeviceTokenPayload(payload) {
+  if (!payload || typeof payload !== 'object') {
+    return { accessToken: '', errorCode: null, errorDescription: null }
+  }
+
+  const p = payload
+  const accessToken =
+    typeof p.access_token === 'string' && p.access_token ? p.access_token : ''
+  const errorCode = typeof p.error === 'string' ? p.error : null
+  const errorDescription = getErrorDescription(p)
+
+  /** @type {DeviceTokenPayload} */
+  const parsed = {
+    accessToken,
+    errorCode,
+    errorDescription,
+  }
+  return parsed
+}
+
+export function parseWhoamiPayload(payload) {
+  if (!payload || typeof payload !== 'object') return null
+  const p = payload
+  if (typeof p.userId !== 'string' || !p.userId) return null
+  if (typeof p.organizationId !== 'string' || !p.organizationId) return null
+
+  /** @type {WhoamiPayload} */
+  const parsed = {
+    userId: p.userId,
+    email: typeof p.email === 'string' && p.email ? p.email : null,
+    organizationId: p.organizationId,
+    organizationName:
+      typeof p.organizationName === 'string' && p.organizationName
+        ? p.organizationName
+        : null,
+  }
+  return parsed
+}
+
+export function getErrorFromTextResponse(text, fallback = 'Request failed.') {
+  try {
+    const payload = JSON.parse(text)
+    return getErrorDescription(payload) || fallback
+  } catch {
+    if (text.trim()) return text.trim()
+  }
+  return fallback
+}

package/src/cli-error.js

@@ -0,0 +1,14 @@
+export class CliError extends Error {
+  constructor(message, options = 1) {
+    super(message)
+    this.name = 'CliError'
+    if (typeof options === 'number') {
+      this.exitCode = options
+      this.showHelp = false
+      return
+    }
+    this.exitCode =
+      typeof options?.exitCode === 'number' ? options.exitCode : 1
+    this.showHelp = options?.showHelp === true
+  }
+}

package/src/commands/ask.js

@@ -0,0 +1,48 @@
+import { getErrorFromTextResponse, requestAuthedText } from '../api.js'
+import { CliError } from '../cli-error.js'
+import { MESSAGES } from '../constants.js'
+import { askHelp } from '../help-text.js'
+import { isHelpFlag } from '../output.js'
+import { getApiBaseUrl, requireToken } from '../runtime.js'
+
+export async function runAsk(args, ctx) {
+  if (args.length === 1 && isHelpFlag(args[0])) {
+    ctx.print(askHelp())
+    return
+  }
+
+  if (args.length === 0) {
+    throw new CliError(MESSAGES.missingQuestion)
+  }
+
+  const question = args.join(' ').trim()
+  if (!question) {
+    throw new CliError(MESSAGES.missingQuestion)
+  }
+
+  const token = requireToken()
+  const apiBaseUrl = getApiBaseUrl()
+
+  const { response, text } = await requestAuthedText(
+    apiBaseUrl,
+    '/cli/ask',
+    token,
+    {
+    method: 'POST',
+    headers: {
+      'content-type': 'application/json',
+    },
+    body: JSON.stringify({ question }),
+  },
+  )
+
+  if (!response.ok) {
+    if (response.status === 401) {
+      throw new CliError(MESSAGES.unauthorized)
+    }
+
+    throw new CliError(getErrorFromTextResponse(text))
+  }
+
+  ctx.print(text.trim())
+}

package/src/commands/help.js

@@ -0,0 +1,8 @@
+import { rootHelp } from '../help-text.js'
+import { ensureNoExtraArgs } from './utils.js'
+
+export async function runHelp(args, ctx) {
+  const handled = ensureNoExtraArgs(args, rootHelp(), ctx.print)
+  if (handled) return
+  ctx.print(rootHelp())
+}

package/src/commands/login.js

@@ -0,0 +1,99 @@
+import {
+  getErrorDescription,
+  parseDeviceCodePayload,
+  parseDeviceTokenPayload,
+  requestJson,
+} from '../api.js'
+import { CliError } from '../cli-error.js'
+import { DEVICE_GRANT_TYPE } from '../constants.js'
+import { getConfigPath, updateConfig } from '../config.js'
+import { loginHelp } from '../help-text.js'
+import { openBrowser } from '../open-browser.js'
+import { getApiBaseUrl, getClientId } from '../runtime.js'
+import { ensureNoExtraArgs } from './utils.js'
+
+export async function runLogin(args, ctx) {
+  const handled = ensureNoExtraArgs(args, loginHelp(getConfigPath()), ctx.print)
+  if (handled) return
+
+  const apiBaseUrl = getApiBaseUrl()
+  const clientId = getClientId()
+
+  const { response, payload } = await requestJson(
+    `${apiBaseUrl}/auth/device/code`,
+    {
+      method: 'POST',
+      headers: { 'content-type': 'application/json' },
+      body: JSON.stringify({ client_id: clientId }),
+    },
+  )
+
+  if (!response.ok) {
+    const description = getErrorDescription(payload) || 'Failed to start login.'
+    throw new CliError(description)
+  }
+
+  const deviceCodePayload = parseDeviceCodePayload(payload)
+  if (!deviceCodePayload) {
+    throw new CliError('Invalid device authorization response.')
+  }
+
+  ctx.print(`User code: ${deviceCodePayload.userCode}`)
+  ctx.print(`Verification URL: ${deviceCodePayload.verificationUri}`)
+  const opened = openBrowser(deviceCodePayload.verificationUriComplete)
+  if (opened) {
+    ctx.print('Opened your browser for approval.')
+  } else {
+    ctx.print('Could not open browser automatically. Open the URL above manually.')
+  }
+
+  const deadline = Date.now() + deviceCodePayload.expiresIn * 1000
+  let interval = deviceCodePayload.interval
+
+  while (Date.now() < deadline) {
+    await new Promise((resolve) => setTimeout(resolve, interval * 1000))
+
+    const tokenResponse = await requestJson(`${apiBaseUrl}/auth/device/token`, {
+      method: 'POST',
+      headers: { 'content-type': 'application/json' },
+      body: JSON.stringify({
+        grant_type: DEVICE_GRANT_TYPE,
+        device_code: deviceCodePayload.deviceCode,
+        client_id: clientId,
+      }),
+    })
+
+    const tokenPayload = parseDeviceTokenPayload(tokenResponse.payload)
+    if (tokenResponse.response.ok) {
+      if (!tokenPayload.accessToken) {
+        throw new CliError('Login succeeded but access token was missing.')
+      }
+
+      updateConfig({
+        apiBaseUrl,
+        token: tokenPayload.accessToken,
+      })
+      ctx.print('Login successful.')
+      return
+    }
+
+    const errorCode = tokenPayload.errorCode
+    if (errorCode === 'authorization_pending') continue
+    if (errorCode === 'slow_down') {
+      interval += 5
+      continue
+    }
+    if (errorCode === 'access_denied') {
+      throw new CliError('Login was denied in browser.')
+    }
+    if (errorCode === 'expired_token') {
+      throw new CliError('Login request expired. Run `chatlane login` again.')
+    }
+
+    const description =
+      tokenPayload.errorDescription || 'Device login failed.'
+    throw new CliError(description)
+  }
+
+  throw new CliError('Login timed out. Run `chatlane login` again.')
+}

package/src/commands/logout.js

@@ -0,0 +1,11 @@
+import { updateConfig } from '../config.js'
+import { logoutHelp } from '../help-text.js'
+import { ensureNoExtraArgs } from './utils.js'
+
+export async function runLogout(args, ctx) {
+  const handled = ensureNoExtraArgs(args, logoutHelp(), ctx.print)
+  if (handled) return
+
+  updateConfig({ token: null })
+  ctx.print('Logged out.')
+}

package/src/commands/utils.js

@@ -0,0 +1,13 @@
+import { CliError } from '../cli-error.js'
+import { isHelpFlag } from '../output.js'
+
+export function ensureNoExtraArgs(args, helpText, print) {
+  if (args.length === 0) return false
+  if (args.length === 1 && isHelpFlag(args[0])) {
+    print(helpText)
+    return true
+  }
+  throw new CliError(`Unexpected arguments: ${args.join(' ')}`, {
+    showHelp: true,
+  })
+}

package/src/commands/whoami.js

@@ -0,0 +1,44 @@
+import {
+  getErrorDescription,
+  parseWhoamiPayload,
+  requestAuthedJson,
+} from '../api.js'
+import { CliError } from '../cli-error.js'
+import { MESSAGES } from '../constants.js'
+import { requireToken, getApiBaseUrl } from '../runtime.js'
+import { whoamiHelp } from '../help-text.js'
+import { ensureNoExtraArgs } from './utils.js'
+
+export async function runWhoami(args, ctx) {
+  const handled = ensureNoExtraArgs(args, whoamiHelp(), ctx.print)
+  if (handled) return
+
+  const token = requireToken()
+  const apiBaseUrl = getApiBaseUrl()
+
+  const { response, payload } = await requestAuthedJson(
+    apiBaseUrl,
+    '/cli/whoami',
+    token,
+    { method: 'GET' },
+  )
+
+  if (!response.ok) {
+    if (response.status === 401) {
+      throw new CliError(MESSAGES.unauthorized)
+    }
+    throw new CliError(
+      getErrorDescription(payload) || 'Failed to fetch identity.',
+    )
+  }
+
+  const whoami = parseWhoamiPayload(payload)
+  if (!whoami) {
+    throw new CliError('Invalid whoami response payload.')
+  }
+
+  ctx.print(`User: ${whoami.email || 'unknown'} (${whoami.userId})`)
+  ctx.print(
+    `Workspace: ${whoami.organizationName || 'unknown'} (${whoami.organizationId})`,
+  )
+}

package/src/config.js

@@ -0,0 +1,38 @@
+import { chmodSync, existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs'
+import { homedir } from 'node:os'
+import path from 'node:path'
+
+const CONFIG_DIR = path.join(homedir(), '.config', 'chatlane')
+const CONFIG_PATH = path.join(CONFIG_DIR, 'config.json')
+
+export function getConfigPath() {
+  return CONFIG_PATH
+}
+
+export function readConfig() {
+  if (!existsSync(CONFIG_PATH)) return {}
+
+  try {
+    const raw = readFileSync(CONFIG_PATH, 'utf8')
+    const parsed = JSON.parse(raw)
+    if (!parsed || typeof parsed !== 'object') return {}
+    return parsed
+  } catch {
+    return {}
+  }
+}
+
+export function writeConfig(nextConfig) {
+  mkdirSync(CONFIG_DIR, { recursive: true })
+  writeFileSync(CONFIG_PATH, `${JSON.stringify(nextConfig, null, 2)}\n`, 'utf8')
+  try {
+    chmodSync(CONFIG_PATH, 0o600)
+  } catch {
+    // Ignore permission change failures on unsupported platforms.
+  }
+}
+
+export function updateConfig(patch) {
+  const current = readConfig()
+  writeConfig({ ...current, ...patch })
+}

package/src/constants.js

@@ -0,0 +1,9 @@
+export const DEFAULT_API_BASE_URL = 'https://api.chatlane.co'
+export const DEFAULT_CLIENT_ID = 'chatlane-cli'
+export const DEVICE_GRANT_TYPE = 'urn:ietf:params:oauth:grant-type:device_code'
+
+export const MESSAGES = {
+  missingQuestion: 'Missing question. Usage: chatlane ask "<question>"',
+  notLoggedIn: 'Not logged in. Run `chatlane login` first.',
+  unauthorized: 'Unauthorized. Run `chatlane login` again.',
+}

package/src/help-text.js

@@ -0,0 +1,62 @@
+export function rootHelp() {
+  return `Chatlane CLI
+
+Usage:
+  chatlane <command> [options]
+  chatlane --help
+
+Commands:
+  help                 Show this help output
+  login                Sign in via browser device flow
+  logout               Clear local credentials
+  whoami               Show authenticated user and workspace
+  ask "<question>"     Ask a question using workspace memory
+
+Examples:
+  chatlane login
+  chatlane whoami
+  chatlane ask "How does onboarding work?"
+  chatlane logout
+`
+}
+
+export function loginHelp(configPath) {
+  return `Usage:
+  chatlane login
+  chatlane login --help
+
+Description:
+  Starts browser-based device login and stores token in:
+  ${configPath}
+`
+}
+
+export function logoutHelp() {
+  return `Usage:
+  chatlane logout
+  chatlane logout --help
+
+Description:
+  Clears locally stored credentials.
+`
+}
+
+export function whoamiHelp() {
+  return `Usage:
+  chatlane whoami
+  chatlane whoami --help
+
+Description:
+  Shows authenticated user and active workspace context.
+`
+}
+
+export function askHelp() {
+  return `Usage:
+  chatlane ask "<question>"
+  chatlane ask --help
+
+Description:
+  Returns a single plain-text answer grounded in workspace memory.
+`
+}

package/src/index.js

@@ -0,0 +1,51 @@
+#!/usr/bin/env node
+
+import { CliError } from './cli-error.js'
+import { rootHelp } from './help-text.js'
+import { isHelpFlag, print, printErr } from './output.js'
+import { runAsk } from './commands/ask.js'
+import { runHelp } from './commands/help.js'
+import { runLogin } from './commands/login.js'
+import { runLogout } from './commands/logout.js'
+import { runWhoami } from './commands/whoami.js'
+
+const commandMap = {
+  ask: runAsk,
+  help: runHelp,
+  login: runLogin,
+  logout: runLogout,
+  whoami: runWhoami,
+}
+
+async function main() {
+  const args = process.argv.slice(2)
+  const [command, ...rest] = args
+
+  if (!command || isHelpFlag(command)) {
+    print(rootHelp())
+    return
+  }
+
+  const commandHandler = commandMap[command]
+  if (!commandHandler) {
+    throw new CliError(`Unknown command: ${command}`, { showHelp: true })
+  }
+
+  await commandHandler(rest, { print })
+}
+
+main().catch((error) => {
+  const exitCode =
+    error instanceof CliError && typeof error.exitCode === 'number'
+      ? error.exitCode
+      : 1
+  const message =
+    error instanceof Error && error.message ? error.message : 'Unknown error'
+  printErr(message)
+  if (!(error instanceof CliError && error.showHelp)) {
+    process.exit(exitCode)
+    return
+  }
+  print(rootHelp())
+  process.exit(exitCode)
+})

package/src/open-browser.js

@@ -0,0 +1,28 @@
+import { spawn } from 'node:child_process'
+
+function spawnDetached(command, args) {
+  const child = spawn(command, args, {
+    detached: true,
+    stdio: 'ignore',
+  })
+  child.unref()
+}
+
+export function openBrowser(url) {
+  try {
+    if (process.platform === 'darwin') {
+      spawnDetached('open', [url])
+      return true
+    }
+
+    if (process.platform === 'win32') {
+      spawnDetached('cmd', ['/c', 'start', '', url])
+      return true
+    }
+
+    spawnDetached('xdg-open', [url])
+    return true
+  } catch {
+    return false
+  }
+}

package/src/output.js

@@ -0,0 +1,11 @@
+export function print(text) {
+  process.stdout.write(`${text}\n`)
+}
+
+export function printErr(text) {
+  process.stderr.write(`${text}\n`)
+}
+
+export function isHelpFlag(arg) {
+  return arg === '--help' || arg === '-h'
+}

package/src/runtime.js

@@ -0,0 +1,36 @@
+import { readConfig } from './config.js'
+import { CliError } from './cli-error.js'
+import {
+  DEFAULT_API_BASE_URL,
+  DEFAULT_CLIENT_ID,
+  MESSAGES,
+} from './constants.js'
+
+export function getApiBaseUrl() {
+  return (
+    process.env.CHATLANE_API_URL ||
+    readConfig().apiBaseUrl ||
+    DEFAULT_API_BASE_URL
+  ).replace(/\/+$/, '')
+}
+
+export function getClientId() {
+  return process.env.CHATLANE_CLIENT_ID || DEFAULT_CLIENT_ID
+}
+
+export function getToken() {
+  const envToken = process.env.CHATLANE_TOKEN
+  if (typeof envToken === 'string' && envToken.trim()) return envToken.trim()
+  const fileToken = readConfig().token
+  return typeof fileToken === 'string' && fileToken.trim()
+    ? fileToken.trim()
+    : null
+}
+
+export function requireToken() {
+  const token = getToken()
+  if (!token) {
+    throw new CliError(MESSAGES.notLoggedIn)
+  }
+  return token
+}