nikcli 0.0.6

package/src/connectors/auth.ts

@@ -0,0 +1,68 @@
+import path from "path"
+import fs from "fs/promises"
+import z from "zod"
+import { Global } from "../global"
+
+export namespace ConnectorAuth {
+  export const Entry = z.object({
+    token: z.string().optional(),
+    botToken: z.string().optional(),
+    apiKey: z.string().optional(),
+    teamId: z.string().optional(),
+    expiresAt: z.number().optional(),
+  })
+  export type Entry = z.infer<typeof Entry>
+
+  const filepath = path.join(Global.Path.data, "connectors-auth.json")
+
+  export async function get(connectorName: string): Promise<Entry | undefined> {
+    const data = await all()
+    return data[connectorName]
+  }
+
+  export async function all(): Promise<Record<string, Entry>> {
+    const file = Bun.file(filepath)
+    return file.json().catch(() => ({}))
+  }
+
+  export async function set(connectorName: string, entry: Entry): Promise<void> {
+    const file = Bun.file(filepath)
+    const data = await all()
+    await Bun.write(file, JSON.stringify({ ...data, [connectorName]: entry }, null, 2))
+    await fs.chmod(file.name!, 0o600)
+  }
+
+  export async function remove(connectorName: string): Promise<void> {
+    const file = Bun.file(filepath)
+    const data = await all()
+    delete data[connectorName]
+    await Bun.write(file, JSON.stringify(data, null, 2))
+    await fs.chmod(file.name!, 0o600)
+  }
+
+  export async function updateToken(connectorName: string, token: string, expiresAt?: number): Promise<void> {
+    const entry = (await get(connectorName)) ?? {}
+    entry.token = token
+    if (expiresAt) entry.expiresAt = expiresAt
+    await set(connectorName, entry)
+  }
+
+  export async function updateBotToken(connectorName: string, botToken: string, teamId?: string): Promise<void> {
+    const entry = (await get(connectorName)) ?? {}
+    entry.botToken = botToken
+    if (teamId) entry.teamId = teamId
+    await set(connectorName, entry)
+  }
+
+  export async function updateApiKey(connectorName: string, apiKey: string): Promise<void> {
+    const entry = (await get(connectorName)) ?? {}
+    entry.apiKey = apiKey
+    await set(connectorName, entry)
+  }
+
+  export async function isTokenExpired(connectorName: string): Promise<boolean | null> {
+    const entry = await get(connectorName)
+    if (!entry?.expiresAt) return null
+    return entry.expiresAt < Date.now() / 1000
+  }
+}

package/src/connectors/cache.ts

@@ -0,0 +1,119 @@
+export interface CacheEntry<T> {
+  value: T
+  expiresAt: number
+}
+
+const STATUS_CACHE_TTL = 5 * 60 * 1000
+const TOOLS_CACHE_TTL = 2 * 60 * 1000
+
+class Cache<T> {
+  private cache: Map<string, CacheEntry<T>> = new Map()
+
+  set(key: string, value: T, ttl: number): void {
+    this.cache.set(key, {
+      value,
+      expiresAt: Date.now() + ttl,
+    })
+  }
+
+  get(key: string): T | null {
+    const entry = this.cache.get(key)
+    if (!entry) return null
+
+    if (Date.now() > entry.expiresAt) {
+      this.cache.delete(key)
+      return null
+    }
+
+    return entry.value
+  }
+
+  invalidate(key: string): void {
+    this.cache.delete(key)
+  }
+
+  clear(): void {
+    this.cache.clear()
+  }
+}
+
+const statusCache = new Cache<Record<string, any>>()
+const toolsCache = new Cache<Record<string, any>>()
+const configHashCache = new Cache<string>()
+
+function normalize(value: unknown): unknown {
+  if (Array.isArray(value)) {
+    return value.map((item) => normalize(item))
+  }
+
+  if (value && typeof value === "object") {
+    const entries = Object.entries(value as Record<string, unknown>).sort(([a], [b]) => a.localeCompare(b))
+    return Object.fromEntries(entries.map(([key, entry]) => [key, normalize(entry)]))
+  }
+
+  return value
+}
+
+function getConfigHash(config: any): string {
+  return JSON.stringify(normalize(config?.connectors ?? {}))
+}
+
+async function getCachedOrCompute<T>(
+  cache: Cache<T>,
+  key: string,
+  compute: () => Promise<T>,
+  ttl: number,
+  config?: any,
+): Promise<T> {
+  const currentHash = config ? getConfigHash(config) : null
+
+  if (currentHash) {
+    const cachedHash = configHashCache.get(key)
+
+    if (cachedHash && cachedHash !== currentHash) {
+      cache.invalidate(key)
+      configHashCache.invalidate(key)
+    }
+  }
+
+  const cached = cache.get(key)
+  if (cached !== null) return cached
+
+  const result = await compute()
+  cache.set(key, result, ttl)
+
+  if (currentHash) {
+    configHashCache.set(key, currentHash, ttl)
+  }
+
+  return result
+}
+
+export function invalidateStatusCache(): void {
+  statusCache.clear()
+}
+
+export function invalidateToolsCache(): void {
+  toolsCache.clear()
+}
+
+export function invalidateConnectorCache(_connectorName: string): void {
+  statusCache.invalidate("connectors_status")
+  toolsCache.invalidate("connectors_tools")
+}
+
+export function getCachedStatus(
+  key: string,
+  compute: () => Promise<Record<string, any>>,
+  config?: any,
+): Promise<Record<string, any>> {
+  return getCachedOrCompute(statusCache, key, compute, STATUS_CACHE_TTL, config)
+}
+
+export function getCachedTools(
+  key: string,
+  compute: () => Promise<Record<string, any>>,
+  config?: any,
+): Promise<Record<string, any>> {
+  return getCachedOrCompute(toolsCache, key, compute, TOOLS_CACHE_TTL, config)
+}

package/src/connectors/credentials.ts

@@ -0,0 +1,81 @@
+import { Config } from "../config/config"
+import { Flag } from "../flag/flag"
+import { getToken as getFigmaToken } from "./api/figma"
+import { getToken as getGithubToken } from "./api/github"
+import { getBotToken as getSlackBotToken } from "./api/slack"
+import { getToken as getLovableToken } from "./api/lovable"
+
+type CredentialType = "token" | "botToken" | "apiKey"
+
+const credentialTypeMap: Record<string, CredentialType> = {
+  figma: "token",
+  github: "token",
+  slack: "botToken",
+  lovable: "token",
+}
+
+function getCredentialType(type: string): CredentialType | null {
+  return credentialTypeMap[type] ?? null
+}
+
+function getCredentialFlag(type: string): string | null {
+  switch (type) {
+    case "figma":
+      return Flag.NIKCLI_FIGMA_TOKEN ?? null
+    case "github":
+      return Flag.NIKCLI_GITHUB_TOKEN ?? null
+    case "slack":
+      return Flag.NIKCLI_SLACK_BOT_TOKEN ?? null
+    case "lovable":
+      return Flag.NIKCLI_LOVABLE_TOKEN ?? null
+    default:
+      return null
+  }
+}
+
+function getCredentialFromAuth(name: string, type: string): Promise<string | null> {
+  switch (type) {
+    case "figma":
+      return getFigmaToken(name)
+    case "github":
+      return getGithubToken(name)
+    case "slack":
+      return getSlackBotToken(name)
+    case "lovable":
+      return getLovableToken(name)
+    default:
+      return Promise.resolve(null)
+  }
+}
+
+function getCredentialFromConfig(connector: Config.Connector): string | null {
+  switch (connector.type) {
+    case "figma":
+      return connector.token ?? null
+    case "github":
+      return connector.token ?? null
+    case "slack":
+      return connector.botToken ?? null
+    case "lovable":
+      return connector.token ?? connector.apiKey ?? null
+    default:
+      return null
+  }
+}
+
+export async function resolveCredential(name: string, connector: Config.Connector): Promise<string | null> {
+  const flag = getCredentialFlag(connector.type)
+  if (flag) return flag
+
+  const configCredential = getCredentialFromConfig(connector)
+  if (configCredential) return configCredential
+
+  const authCredential = await getCredentialFromAuth(name, connector.type)
+  if (authCredential) return authCredential
+
+  return null
+}
+
+export function resolveCredentialType(type: string): CredentialType | null {
+  return getCredentialType(type)
+}

package/src/connectors/index.ts

@@ -0,0 +1,202 @@
+import { type Tool } from "ai"
+import z from "zod"
+import { Config } from "../config/config"
+import { Log } from "../util/log"
+import { ConnectorAuth } from "./auth"
+import { createTools, getHealthCheck, getPrompts } from "./registry"
+import { resolveCredential, resolveCredentialType } from "./credentials"
+import {
+  getCachedStatus,
+  getCachedTools,
+  invalidateConnectorCache,
+  invalidateToolsCache,
+  invalidateStatusCache,
+} from "./cache"
+
+export namespace Connectors {
+  const log = Log.create({ service: "connectors" })
+
+  export const StatusSchema = z
+    .discriminatedUnion("status", [
+      z
+        .object({
+          status: z.literal("connected"),
+        })
+        .meta({ ref: "ConnectorStatusConnected" }),
+      z
+        .object({
+          status: z.literal("disabled"),
+        })
+        .meta({ ref: "ConnectorStatusDisabled" }),
+      z
+        .object({
+          status: z.literal("failed"),
+          error: z.string(),
+        })
+        .meta({ ref: "ConnectorStatusFailed" }),
+      z
+        .object({
+          status: z.literal("needs_auth"),
+        })
+        .meta({ ref: "ConnectorStatusNeedsAuth" }),
+    ])
+    .meta({ ref: "ConnectorStatus" })
+  export type Status = z.infer<typeof StatusSchema>
+
+  type ConnectorEntry = NonNullable<Config.Info["connectors"]>[string]
+  export function isConnectorConfigured(entry: ConnectorEntry): entry is Config.Connector {
+    return typeof entry === "object" && entry !== null && "type" in entry && typeof entry.type === "string"
+  }
+
+  function getRequiredCredentialType(type: string): "token" | "botToken" | "apiKey" | null {
+    return resolveCredentialType(type)
+  }
+
+  async function checkConnector(name: string, config: Config.Connector): Promise<Status> {
+    try {
+      const credential = await resolveCredential(name, config)
+      if (!credential) return { status: "needs_auth" }
+
+      const healthCheck = getHealthCheck(config.type)
+      if (!healthCheck) return { status: "failed", error: "Unknown connector type" }
+
+      await healthCheck(credential)
+      return { status: "connected" }
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error)
+      return { status: "failed", error: message }
+    }
+  }
+
+  async function resolveStatuses(): Promise<Record<string, Status>> {
+    const cfg = await Config.get()
+    const config = cfg.connectors ?? {}
+    const statuses: Record<string, Status> = {}
+
+    await Promise.all(
+      Object.entries(config).map(async ([key, connector]) => {
+        if (!isConnectorConfigured(connector)) {
+          log.error("Ignoring connector config entry without type", { key })
+          return
+        }
+
+        if (connector.enabled === false) {
+          statuses[key] = { status: "disabled" }
+          return
+        }
+
+        const result = await checkConnector(key, connector).catch(() => undefined)
+        if (!result) return
+
+        statuses[key] = result
+      }),
+    )
+
+    return statuses
+  }
+
+  export async function status(): Promise<Record<string, Status>> {
+    const cfg = await Config.get()
+    const cacheKey = "connectors_status"
+
+    return getCachedStatus(cacheKey, resolveStatuses, cfg)
+  }
+
+  export function invalidateStatus(): void {
+    invalidateStatusCache()
+  }
+
+  export function invalidateTools(): void {
+    invalidateToolsCache()
+  }
+
+  export function invalidateConnector(name: string): void {
+    invalidateConnectorCache(name)
+  }
+
+  export async function hasStoredCredentials(name: string, type?: string): Promise<boolean> {
+    const auth = await ConnectorAuth.get(name)
+    if (!auth) return false
+    if (!type) {
+      return !!auth.token || !!auth.botToken || !!auth.apiKey
+    }
+    const requiredType = getRequiredCredentialType(type)
+    if (!requiredType) return false
+    switch (requiredType) {
+      case "token":
+        if (auth.token) return true
+        if (type === "lovable") return !!auth.apiKey
+        return false
+      case "botToken":
+        return !!auth.botToken
+      case "apiKey":
+        return !!auth.apiKey
+    }
+    return false
+  }
+
+  export async function tools(): Promise<Record<string, Tool>> {
+    const cfg = await Config.get()
+    const cacheKey = "connectors_tools"
+
+    const compute = async (): Promise<Record<string, Tool>> => {
+      const config = cfg.connectors ?? {}
+      const tools: Record<string, Tool> = {}
+
+      await Promise.all(
+        Object.entries(config).map(async ([name, connector]) => {
+          if (!isConnectorConfigured(connector)) return
+          if (connector.enabled === false) return
+
+          try {
+            const connectorTools = await createTools(name, connector)
+            Object.assign(tools, connectorTools)
+          } catch (error) {
+            log.error("Failed to load connector tools", { name, connector: connector.type, error })
+          }
+        }),
+      )
+
+      return tools
+    }
+
+    return getCachedTools(cacheKey, compute, cfg)
+  }
+
+  type ConnectorPrompt = {
+    name: string
+    description: string
+    type: string
+    arguments?: Array<{ name: string; description: string }>
+  }
+
+  export async function prompts(): Promise<Record<string, ConnectorPrompt & { client: string }>> {
+    const cfg = await Config.get()
+    const config = cfg.connectors ?? {}
+    const connectorStatuses = await status()
+
+    const prompts: Record<string, ConnectorPrompt & { client: string }> = {}
+
+    for (const [connectorName, connector] of Object.entries(config)) {
+      if (!isConnectorConfigured(connector)) continue
+      if (connector.enabled === false) continue
+
+      const connStatus = connectorStatuses[connectorName]
+      if (connStatus?.status !== "connected") continue
+
+      const operationPrompts = getPrompts(connector.type)
+
+      for (const op of operationPrompts) {
+        prompts[`${connectorName}_${op.name}`] = {
+          name: `${connectorName}_${op.name}`,
+          description: op.description,
+          type: connector.type,
+          arguments: op.args.map((arg) => ({ name: arg.name, description: arg.description })),
+          client: connectorName,
+        }
+      }
+    }
+
+    return prompts
+  }
+}