nikcli 0.0.6

package/src/server/ssh.ts

@@ -0,0 +1,207 @@
+import type { ConnectConfig } from "ssh2"
+import { Server as SshServer } from "ssh2"
+import { Flag } from "@/flag/flag"
+import { Log } from "@/util/log"
+import { createServer, Server as NetServer } from "net"
+import { join, dirname } from "path"
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "fs"
+
+export namespace Ssh {
+  const log = Log.create({ service: "ssh" })
+
+  let server: NetServer | undefined
+  let sshServer: SshServer | undefined
+  let connectedClient: any
+
+  export function start(): NetServer | undefined {
+    if (!Flag.NIKCLI_SERVER_SSH_ENABLED) {
+      return undefined
+    }
+
+    const port = Flag.NIKCLI_SERVER_SSH_PORT
+    const host = Flag.NIKCLI_SERVER_SSH_HOST
+
+    log.info("starting SSH server", { host, port })
+
+    sshServer = new SshServer({
+      hostKeys: [getOrGenerateHostKey()],
+    })
+
+    sshServer.on("connection", (client) => {
+      log.info("new SSH connection")
+      connectedClient = client
+
+      let authenticated = false
+      let username: string | undefined
+
+      client.on("authentication", (ctx) => {
+        username = ctx.username
+
+        if (ctx.method === "password") {
+          const password = Flag.NIKCLI_SERVER_PASSWORD
+          if (password && ctx.password === password) {
+            authenticated = true
+            ctx.accept()
+          } else {
+            log.warn("SSH auth failed: invalid password", { username })
+            ctx.reject()
+          }
+        } else if (ctx.method === "publickey") {
+          log.warn("SSH auth attempt: publickey not implemented", { username })
+          ctx.reject()
+        } else {
+          ctx.reject()
+        }
+      })
+
+      client.on("ready", () => {
+        log.info("SSH client ready", { username })
+      })
+
+      client.on("session", (accept, reject) => {
+        if (!authenticated) {
+          reject()
+          return
+        }
+
+        const session = accept()
+        session.once("pty", (accept, reject, info) => {
+          log.info("SSH pty request", { username, info })
+          accept()
+        })
+
+        session.once("shell", (accept, reject) => {
+          const stream = accept()
+
+          stream.write("Welcome to nikcli SSH shell\r\n")
+          stream.write(`Session: ${Date.now()}\r\n\r\n`)
+          stream.write("$ ")
+
+          let buffer = ""
+
+          stream.on("data", (data: Buffer) => {
+            const str = data.toString()
+
+            for (const char of str) {
+              if (char === "\r" || char === "\n") {
+                stream.write("\r\n")
+                if (buffer.trim()) {
+                  handleCommand(buffer.trim(), stream, username)
+                }
+                buffer = ""
+                stream.write("$ ")
+              } else if (char === "\x03") {
+                buffer = ""
+                stream.write("^C\r\n$ ")
+              } else if (char === "\x7f") {
+                if (buffer.length > 0) {
+                  buffer = buffer.slice(0, -1)
+                  stream.write("\b \b")
+                }
+              } else {
+                buffer += char
+                stream.write(char)
+              }
+            }
+          })
+
+          stream.on("close", () => {
+            log.info("SSH session closed", { username })
+            client.end()
+          })
+        })
+      })
+
+      client.on("error", (err: Error) => {
+        log.error("SSH client error", { error: err, username })
+      })
+
+      client.on("close", () => {
+        log.info("SSH client disconnected", { username })
+      })
+    })
+
+    sshServer.on("error", (err: Error) => {
+      log.error("SSH server error", { error: err })
+    })
+
+    server = createServer((socket) => {
+      sshServer!.emit("connection", socket)
+    })
+
+    server.listen(port, host, () => {
+      log.info("SSH server listening", { host, port })
+    })
+
+    return server
+  }
+
+  export function stop(): Promise<void> {
+    return new Promise((resolve) => {
+      if (server) {
+        server.close(() => {
+          log.info("SSH server stopped")
+          resolve()
+        })
+      } else {
+        resolve()
+      }
+    })
+  }
+
+  async function handleCommand(cmd: string, stream: any, username?: string): Promise<void> {
+    const command = cmd.split(" ")[0]
+
+    switch (command) {
+      case "help":
+        stream.write("Available commands:\r\n")
+        stream.write("  help     - Show this help\r\n")
+        stream.write("  whoami   - Show current user\r\n")
+        stream.write("  version  - Show nikcli version\r\n")
+        stream.write("  exit     - Close SSH connection\r\n")
+        break
+
+      case "whoami":
+        stream.write(`${username || "unknown"}\r\n`)
+        break
+
+      case "version":
+        stream.write("nikcli SSH shell\r\n")
+        break
+
+      case "exit":
+        stream.write("Goodbye!\r\n")
+        connectedClient?.end()
+        break
+
+      default:
+        stream.write(`Unknown command: ${command}\r\n`)
+        stream.write("Type 'help' for available commands\r\n")
+    }
+  }
+
+  function getOrGenerateHostKey(): string {
+    const dir = join(import.meta.dir, "../../../.ssh")
+    const path = join(dir, "host_rsa_key")
+
+    if (existsSync(path)) {
+      return readFileSync(path, "utf-8")
+    }
+
+    if (!existsSync(dir)) {
+      mkdirSync(dir, { recursive: true })
+    }
+
+    log.info("generating SSH host key", { path })
+
+    const { spawnSync } = Bun
+    const result = spawnSync(["ssh-keygen", "-t", "rsa", "-b", "2048", "-f", path, "-N", "", "-q"])
+
+    if (result.exitCode !== 0) {
+      const errMsg = result.stderr?.toString() || "unknown error"
+      throw new Error(`Failed to generate SSH host key: ${errMsg}`)
+    }
+
+    return readFileSync(path, "utf-8")
+  }
+}

package/src/session/auth.ts

@@ -0,0 +1,402 @@
+import { Auth } from "../auth"
+
+import * as prompts from "@clack/prompts"
+
+import { ModelsDev } from "../provider/models"
+import { map, pipe, sortBy, values } from "remeda"
+import path from "path"
+import os from "os"
+import { Config } from "../config/config"
+import { Global } from "../global"
+import { Plugin } from "../plugin"
+import { Instance } from "../project/instance"
+import type { Hooks } from "@nikcli-ai/plugin"
+import { cmd } from "@/cli/cmd/cmd"
+import { UI } from "@/cli/ui"
+
+type PluginAuth = NonNullable<Hooks["auth"]>
+
+/**
+ * Handle plugin-based authentication flow.
+ * Returns true if auth was handled, false if it should fall through to default handling.
+ */
+async function handlePluginAuth(plugin: { auth: PluginAuth }, provider: string): Promise<boolean> {
+  let index = 0
+  if (plugin.auth.methods.length > 1) {
+    const method = await prompts.select({
+      message: "Login method",
+      options: [
+        ...plugin.auth.methods.map((x, index) => ({
+          label: x.label,
+          value: index.toString(),
+        })),
+      ],
+    })
+    if (prompts.isCancel(method)) throw new UI.CancelledError()
+    index = parseInt(method)
+  }
+  const method = plugin.auth.methods[index]
+
+  // Handle prompts for all auth types
+  await Bun.sleep(10)
+  const inputs: Record<string, string> = {}
+  if (method.prompts) {
+    for (const prompt of method.prompts) {
+      if (prompt.condition && !prompt.condition(inputs)) {
+        continue
+      }
+      if (prompt.type === "select") {
+        const value = await prompts.select({
+          message: prompt.message,
+          options: prompt.options,
+        })
+        if (prompts.isCancel(value)) throw new UI.CancelledError()
+        inputs[prompt.key] = value
+      } else {
+        const value = await prompts.text({
+          message: prompt.message,
+          placeholder: prompt.placeholder,
+          validate: prompt.validate ? (v) => prompt.validate!(v ?? "") : undefined,
+        })
+        if (prompts.isCancel(value)) throw new UI.CancelledError()
+        inputs[prompt.key] = value
+      }
+    }
+  }
+
+  if (method.type === "oauth") {
+    const authorize = await method.authorize(inputs)
+
+    if (authorize.url) {
+      prompts.log.info("Go to: " + authorize.url)
+    }
+
+    if (authorize.method === "auto") {
+      if (authorize.instructions) {
+        prompts.log.info(authorize.instructions)
+      }
+      const spinner = prompts.spinner()
+      spinner.start("Waiting for authorization...")
+      const result = await authorize.callback()
+      if (result.type === "failed") {
+        spinner.stop("Failed to authorize", 1)
+      }
+      if (result.type === "success") {
+        const saveProvider = result.provider ?? provider
+        if ("refresh" in result) {
+          const { type: _, provider: __, refresh, access, expires, ...extraFields } = result
+          await Auth.set(saveProvider, {
+            type: "oauth",
+            refresh,
+            access,
+            expires,
+            ...extraFields,
+          })
+        }
+        if ("key" in result) {
+          await Auth.set(saveProvider, {
+            type: "api",
+            key: result.key,
+          })
+        }
+        spinner.stop("Login successful")
+      }
+    }
+
+    if (authorize.method === "code") {
+      const code = await prompts.text({
+        message: "Paste the authorization code here: ",
+        validate: (x) => (x && x.length > 0 ? undefined : "Required"),
+      })
+      if (prompts.isCancel(code)) throw new UI.CancelledError()
+      const result = await authorize.callback(code)
+      if (result.type === "failed") {
+        prompts.log.error("Failed to authorize")
+      }
+      if (result.type === "success") {
+        const saveProvider = result.provider ?? provider
+        if ("refresh" in result) {
+          const { type: _, provider: __, refresh, access, expires, ...extraFields } = result
+          await Auth.set(saveProvider, {
+            type: "oauth",
+            refresh,
+            access,
+            expires,
+            ...extraFields,
+          })
+        }
+        if ("key" in result) {
+          await Auth.set(saveProvider, {
+            type: "api",
+            key: result.key,
+          })
+        }
+        prompts.log.success("Login successful")
+      }
+    }
+
+    prompts.outro("Done")
+    return true
+  }
+
+  if (method.type === "api") {
+    if (method.authorize) {
+      const result = await method.authorize(inputs)
+      if (result.type === "failed") {
+        prompts.log.error("Failed to authorize")
+      }
+      if (result.type === "success") {
+        const saveProvider = result.provider ?? provider
+        await Auth.set(saveProvider, {
+          type: "api",
+          key: result.key,
+        })
+        prompts.log.success("Login successful")
+      }
+      prompts.outro("Done")
+      return true
+    }
+  }
+
+  return false
+}
+
+export const AuthCommand = cmd({
+  command: "auth",
+  describe: "manage credentials",
+  builder: (yargs) =>
+    yargs.command(AuthLoginCommand).command(AuthLogoutCommand).command(AuthListCommand).demandCommand(),
+  async handler() { },
+})
+
+export const AuthListCommand = cmd({
+  command: "list",
+  aliases: ["ls"],
+  describe: "list providers",
+  async handler() {
+    UI.empty()
+    const authPath = path.join(Global.Path.data, "auth.json")
+    const homedir = os.homedir()
+    const displayPath = authPath.startsWith(homedir) ? authPath.replace(homedir, "~") : authPath
+    prompts.intro(`Credentials ${UI.Style.TEXT_DIM}${displayPath}`)
+    const results = Object.entries(await Auth.all())
+    const database = await ModelsDev.get()
+
+    for (const [providerID, result] of results) {
+      const name = database[providerID]?.name || providerID
+      prompts.log.info(`${name} ${UI.Style.TEXT_DIM}${result.type}`)
+    }
+
+    prompts.outro(`${results.length} credentials`)
+
+    // Environment variables section
+    const activeEnvVars: Array<{ provider: string; envVar: string }> = []
+
+    for (const [providerID, provider] of Object.entries(database)) {
+      for (const envVar of provider.env) {
+        if (process.env[envVar]) {
+          activeEnvVars.push({
+            provider: provider.name || providerID,
+            envVar,
+          })
+        }
+      }
+    }
+
+    if (activeEnvVars.length > 0) {
+      UI.empty()
+      prompts.intro("Environment")
+
+      for (const { provider, envVar } of activeEnvVars) {
+        prompts.log.info(`${provider} ${UI.Style.TEXT_DIM}${envVar}`)
+      }
+
+      prompts.outro(`${activeEnvVars.length} environment variable` + (activeEnvVars.length === 1 ? "" : "s"))
+    }
+  },
+})
+
+export const AuthLoginCommand = cmd({
+  command: "login [url]",
+  describe: "log in to a provider",
+  builder: (yargs) =>
+    yargs.positional("url", {
+      describe: "nikcli auth provider",
+      type: "string",
+    }),
+  async handler(args) {
+    await Instance.provide({
+      directory: process.cwd(),
+      async fn() {
+        UI.empty()
+        prompts.intro("Add credential")
+        if (args.url) {
+          const wellknown = await fetch(`${args.url}/.well-known/nikcli`).then((x) => x.json() as any)
+          prompts.log.info(`Running \`${wellknown.auth.command.join(" ")}\``)
+          const proc = Bun.spawn({
+            cmd: wellknown.auth.command,
+            stdout: "pipe",
+          })
+          const exit = await proc.exited
+          if (exit !== 0) {
+            prompts.log.error("Failed")
+            prompts.outro("Done")
+            return
+          }
+          const token = await new Response(proc.stdout).text()
+          await Auth.set(args.url, {
+            type: "wellknown",
+            key: wellknown.auth.env,
+            token: token.trim(),
+          })
+          prompts.log.success("Logged into " + args.url)
+          prompts.outro("Done")
+          return
+        }
+        await ModelsDev.refresh().catch(() => { })
+
+        const config = await Config.get()
+
+        const disabled = new Set(config.disabled_providers ?? [])
+        const enabled = config.enabled_providers ? new Set(config.enabled_providers) : undefined
+
+        const providers = await ModelsDev.get().then((x) => {
+          const filtered: Record<string, (typeof x)[string]> = {}
+          for (const [key, value] of Object.entries(x)) {
+            if ((enabled ? enabled.has(key) : true) && !disabled.has(key)) {
+              filtered[key] = value
+            }
+          }
+          return filtered
+        })
+
+        const priority: Record<string, number> = {
+          nikcli: 0,
+          anthropic: 1,
+          "github-copilot": 2,
+          openai: 3,
+          google: 4,
+          openrouter: 5,
+          vercel: 6,
+        }
+        let provider = await prompts.autocomplete({
+          message: "Select provider",
+          maxItems: 8,
+          options: [
+            ...pipe(
+              providers,
+              values(),
+              sortBy(
+                (x) => priority[x.id] ?? 99,
+                (x) => x.name ?? x.id,
+              ),
+              map((x) => ({
+                label: x.name,
+                value: x.id,
+                hint: {
+                  nikcli: "recommended",
+                  anthropic: "Claude Max or API key",
+                  openai: "ChatGPT Plus/Pro or API key",
+                }[x.id],
+              })),
+            ),
+            {
+              value: "other",
+              label: "Other",
+            },
+          ],
+        })
+
+        if (prompts.isCancel(provider)) throw new UI.CancelledError()
+
+        const plugin = await Plugin.list().then((x) => x.find((x) => x.auth?.provider === provider))
+        if (plugin && plugin.auth) {
+          const handled = await handlePluginAuth({ auth: plugin.auth }, provider)
+          if (handled) return
+        }
+
+        if (provider === "other") {
+          provider = await prompts.text({
+            message: "Enter provider id",
+            validate: (x) => (x && x.match(/^[0-9a-z-]+$/) ? undefined : "a-z, 0-9 and hyphens only"),
+          })
+          if (prompts.isCancel(provider)) throw new UI.CancelledError()
+          provider = provider.replace(/^@ai-sdk\//, "")
+          if (prompts.isCancel(provider)) throw new UI.CancelledError()
+
+          // Check if a plugin provides auth for this custom provider
+          const customPlugin = await Plugin.list().then((x) => x.find((x) => x.auth?.provider === provider))
+          if (customPlugin && customPlugin.auth) {
+            const handled = await handlePluginAuth({ auth: customPlugin.auth }, provider)
+            if (handled) return
+          }
+
+          prompts.log.warn(
+            `This only stores a credential for ${provider} - you will need configure it in nikcli.json, check the docs for examples.`,
+          )
+        }
+
+        if (provider === "amazon-bedrock") {
+          prompts.log.info(
+            "Amazon Bedrock authentication priority:\n" +
+            "  1. Bearer token (AWS_BEARER_TOKEN_BEDROCK or /connect)\n" +
+            "  2. AWS credential chain (profile, access keys, IAM roles, EKS IRSA)\n\n" +
+            "Configure via nikcli.json options (profile, region, endpoint) or\n" +
+            "AWS environment variables (AWS_PROFILE, AWS_REGION, AWS_ACCESS_KEY_ID, AWS_WEB_IDENTITY_TOKEN_FILE).",
+          )
+        }
+
+        if (provider === "nikcli") {
+          prompts.log.info("Create an api key at https://nikcli.store/auth")
+        }
+
+        if (provider === "vercel") {
+          prompts.log.info("You can create an api key at https://vercel.link/ai-gateway-token")
+        }
+
+        if (["cloudflare", "cloudflare-ai-gateway"].includes(provider)) {
+          prompts.log.info(
+            "Cloudflare AI Gateway can be configured with CLOUDFLARE_GATEWAY_ID, CLOUDFLARE_ACCOUNT_ID, and CLOUDFLARE_API_TOKEN environment variables. Read more: https://nikcli.store/docs/providers/#cloudflare-ai-gateway",
+          )
+        }
+
+        const key = await prompts.password({
+          message: "Enter your API key",
+          validate: (x) => (x && x.length > 0 ? undefined : "Required"),
+        })
+        if (prompts.isCancel(key)) throw new UI.CancelledError()
+        await Auth.set(provider, {
+          type: "api",
+          key,
+        })
+
+        prompts.outro("Done")
+      },
+    })
+  },
+})
+
+export const AuthLogoutCommand = cmd({
+  command: "logout",
+  describe: "log out from a configured provider",
+  async handler() {
+    UI.empty()
+    const credentials = await Auth.all().then((x) => Object.entries(x))
+    prompts.intro("Remove credential")
+    if (credentials.length === 0) {
+      prompts.log.error("No credentials found")
+      return
+    }
+    const database = await ModelsDev.get()
+    const providerID = await prompts.select({
+      message: "Select provider",
+      options: credentials.map(([key, value]) => ({
+        label: (database[key]?.name || key) + UI.Style.TEXT_DIM + " (" + value.type + ")",
+        value: key,
+      })),
+    })
+    if (prompts.isCancel(providerID)) throw new UI.CancelledError()
+    await Auth.remove(providerID)
+    prompts.outro("Logout successful")
+  },
+})