nikcli 0.0.6

package/src/cli/cmd/mobile.ts

@@ -0,0 +1,223 @@
+import { cmd } from "./cmd"
+import { withNetworkOptions, resolveNetworkOptions } from "../network"
+import { Server } from "@/server/server"
+import { Flag } from "@/flag/flag"
+import { MobileAuth } from "@/mobile/auth"
+import { generateQR } from "@nikcli-ai/remote"
+import { Installation } from "@/installation"
+import { Ssh } from "@/server/ssh"
+import { networkInterfaces } from "os"
+
+function normalizePublicUrl(input?: string) {
+  if (!input) return
+  const url = new URL(input)
+  return url.toString().replace(/\/$/, "")
+}
+
+function getLocalIPs(): string[] {
+  const ips: string[] = []
+  for (const iface of Object.values(networkInterfaces())) {
+    if (!iface) continue
+    for (const addr of iface) {
+      if (addr.family === "IPv4" && !addr.internal) ips.push(addr.address)
+    }
+  }
+  return ips
+}
+
+function isLoopbackHostname(hostname: string) {
+  return hostname === "127.0.0.1" || hostname === "::1" || hostname === "localhost"
+}
+
+function resolveServerUrl(input: { publicUrl?: string; hostname: string; port: number }) {
+  if (input.publicUrl) {
+    const value = normalizePublicUrl(input.publicUrl)
+    if (!value) throw new Error("Invalid public URL")
+    return value
+  }
+  const isAllInterfaces = input.hostname === "0.0.0.0" || input.hostname === "::"
+  const host = isAllInterfaces ? (getLocalIPs()[0] ?? input.hostname) : input.hostname
+  return `http://${host}:${input.port}`
+}
+
+function printPairing(info: { serverUrl: string; token: string; directory?: string }) {
+  const deepLink = new URL("nikcli://connect")
+  deepLink.searchParams.set("server", info.serverUrl)
+  deepLink.searchParams.set("token", info.token)
+  if (info.directory) deepLink.searchParams.set("directory", info.directory)
+
+  console.log("")
+  console.log("Nikcli Mobile Pairing")
+  console.log(`Server URL: ${info.serverUrl}`)
+  console.log(`Token:      ${info.token}`)
+  console.log(`Deep Link:  ${deepLink.toString()}`)
+  console.log("")
+
+  return generateQR(deepLink.toString())
+}
+
+export const MobileCommand = cmd({
+  command: "mobile",
+  describe: "mobile app host and pairing tools",
+  builder: (yargs) =>
+    yargs
+      .command({
+        command: "serve",
+        describe: "start nikcli with mobile-friendly defaults",
+        builder: (yargs) =>
+          withNetworkOptions(yargs)
+            .default("hostname", "0.0.0.0")
+            .option("public-url", {
+              type: "string",
+              describe: "public HTTPS URL used by the mobile app outside your tailnet",
+            })
+            .option("pair", {
+              type: "boolean",
+              default: false,
+              describe: "create and print a new mobile pairing token at startup",
+            })
+            .option("pair-name", {
+              type: "string",
+              default: "iphone",
+              describe: "name for the generated pairing token",
+            })
+            .option("pair-expiry-days", {
+              type: "number",
+              describe: "optional token expiry in days",
+            }),
+        handler: async (args) => {
+          const opts = await resolveNetworkOptions(args)
+          const loopback = isLoopbackHostname(opts.hostname)
+          const tailscaleAuthActive = Flag.NIKCLI_SERVER_TAILSCALE_AUTH && loopback
+          const publicExposure = Boolean(args.publicUrl) || !loopback
+
+          if (!Flag.NIKCLI_SERVER_PASSWORD && !tailscaleAuthActive) {
+            if (publicExposure) {
+              throw new Error(
+                "Public mobile hosting requires NIKCLI_SERVER_PASSWORD. Set a server password before binding to a non-loopback address or using --public-url.",
+              )
+            }
+
+            console.log(
+              "Mobile mode without a server password is only safe on loopback. Set NIKCLI_SERVER_PASSWORD for LAN or public access.",
+            )
+          }
+
+          const server = Server.listen(opts)
+          const hostname = server.hostname || opts.hostname
+          const port = server.port || opts.port || 4096
+          const serverUrl = resolveServerUrl({
+            publicUrl: args.publicUrl as string | undefined,
+            hostname,
+            port,
+          })
+
+          console.log(`nikcli mobile host listening on http://${hostname}:${port}`)
+          if (serverUrl !== `http://${hostname}:${port}`) {
+            console.log(`public mobile URL: ${serverUrl}`)
+          }
+
+          if (args.pair) {
+            const created = await MobileAuth.create({
+              name: String(args.pairName || "iphone"),
+              expiresInDays: args.pairExpiryDays ? Number(args.pairExpiryDays) : undefined,
+            })
+
+            const localIPs = getLocalIPs()
+            const isAllInterfaces = opts.hostname === "0.0.0.0" || opts.hostname === "::"
+            const pairingIPs = args.publicUrl
+              ? [serverUrl]
+              : isAllInterfaces && localIPs.length > 0
+                ? localIPs.map((ip) => `http://${ip}:${port}`)
+                : [serverUrl]
+
+            for (let i = 0; i < pairingIPs.length; i++) {
+              const url = pairingIPs[i]
+              if (pairingIPs.length > 1) console.log(`--- Interface ${i + 1}/${pairingIPs.length}: ${url} ---`)
+              const qr = await printPairing({ serverUrl: url, token: created.token, directory: process.cwd() })
+              console.log(qr)
+            }
+          }
+
+          const sshServer = Ssh.start()
+          if (sshServer) {
+            console.log(
+              `nikcli SSH server listening on ssh://${Flag.NIKCLI_SERVER_SSH_HOST}:${Flag.NIKCLI_SERVER_SSH_PORT}`,
+            )
+          }
+
+          await new Promise(() => {})
+
+          await server.stop()
+          if (sshServer) await Ssh.stop()
+        },
+      })
+      .command({
+        command: "pair",
+        describe: "generate a mobile pairing token and QR code",
+        builder: (yargs) =>
+          yargs
+            .option("public-url", {
+              type: "string",
+              demandOption: true,
+              describe: "public server URL the mobile app should connect to",
+            })
+            .option("name", {
+              type: "string",
+              default: "iphone",
+              describe: "token label",
+            })
+            .option("expiry-days", {
+              type: "number",
+              describe: "optional token expiry in days",
+            })
+            .option("directory", {
+              type: "string",
+              describe: "default directory or repo path for the paired app",
+            }),
+        handler: async (args) => {
+          const created = await MobileAuth.create({
+            name: String(args.name || "iphone"),
+            expiresInDays: args.expiryDays ? Number(args.expiryDays) : undefined,
+          })
+          const serverUrl = normalizePublicUrl(String(args.publicUrl))
+          if (!serverUrl) throw new Error("Invalid --public-url")
+          const qr = await printPairing({
+            serverUrl,
+            token: created.token,
+            directory: args.directory ? String(args.directory) : process.cwd(),
+          })
+          console.log(qr)
+        },
+      })
+      .command({
+        command: "token list",
+        describe: "list mobile pairing tokens",
+        handler: async () => {
+          const tokens = await MobileAuth.list()
+          if (!tokens.length) {
+            console.log("No mobile tokens found")
+            return
+          }
+          for (const token of tokens) {
+            console.log(`${token.id}  ${token.name}  created=${new Date(token.createdAt).toISOString()}`)
+          }
+        },
+      })
+      .command({
+        command: "token revoke <id>",
+        describe: "revoke a mobile pairing token",
+        builder: (yargs) =>
+          yargs.positional("id", {
+            type: "string",
+            describe: "token id to revoke",
+          }),
+        handler: async (args) => {
+          const ok = await MobileAuth.remove(String(args.id))
+          if (!ok) throw new Error(`Token not found: ${args.id}`)
+          console.log(`Revoked mobile token ${args.id}`)
+        },
+      })
+      .demandCommand(),
+  async handler() {},
+})

package/src/cli/cmd/models.ts

@@ -0,0 +1,77 @@
+import type { Argv } from "yargs"
+import { Instance } from "../../project/instance"
+import { Provider } from "../../provider/provider"
+import { ModelsDev } from "../../provider/models"
+import { cmd } from "./cmd"
+import { UI } from "../ui"
+import { EOL } from "os"
+
+export const ModelsCommand = cmd({
+  command: "models [provider]",
+  describe: "list all available models",
+  builder: (yargs: Argv) => {
+    return yargs
+      .positional("provider", {
+        describe: "provider ID to filter models by",
+        type: "string",
+        array: false,
+      })
+      .option("verbose", {
+        describe: "use more verbose model output (includes metadata like costs)",
+        type: "boolean",
+      })
+      .option("refresh", {
+        describe: "refresh the models cache from models.dev",
+        type: "boolean",
+      })
+  },
+  handler: async (args) => {
+    if (args.refresh) {
+      await ModelsDev.refresh()
+      UI.println(UI.Style.TEXT_SUCCESS_BOLD + "Models cache refreshed" + UI.Style.TEXT_NORMAL)
+    }
+
+    await Instance.provide({
+      directory: process.cwd(),
+      async fn() {
+        const providers = await Provider.list()
+
+        function printModels(providerID: string, verbose?: boolean) {
+          const provider = providers[providerID]
+          const sortedModels = Object.entries(provider.models).sort(([a], [b]) => a.localeCompare(b))
+          for (const [modelID, model] of sortedModels) {
+            process.stdout.write(`${providerID}/${modelID}`)
+            process.stdout.write(EOL)
+            if (verbose) {
+              process.stdout.write(JSON.stringify(model, null, 2))
+              process.stdout.write(EOL)
+            }
+          }
+        }
+
+        if (args.provider) {
+          const provider = providers[args.provider]
+          if (!provider) {
+            UI.error(`Provider not found: ${args.provider}`)
+            return
+          }
+
+          printModels(args.provider, args.verbose)
+          return
+        }
+
+        const providerIDs = Object.keys(providers).sort((a, b) => {
+          const aIsNikcli = a.startsWith("nikcli")
+          const bIsNikcli = b.startsWith("nikcli")
+          if (aIsNikcli && !bIsNikcli) return -1
+          if (!aIsNikcli && bIsNikcli) return 1
+          return a.localeCompare(b)
+        })
+
+        for (const providerID of providerIDs) {
+          printModels(providerID, args.verbose)
+        }
+      },
+    })
+  },
+})

package/src/cli/cmd/plug.ts

@@ -0,0 +1,231 @@
+import { intro, log, outro, spinner } from "@clack/prompts"
+import type { Argv } from "yargs"
+
+import { ConfigPaths } from "../../config/paths"
+import { Global } from "../../global"
+import { installPlugin, patchPluginConfig, readPluginManifest } from "../../plugin/install"
+import { resolvePluginTarget } from "../../plugin/shared"
+import { Instance } from "../../project/instance"
+import { errorMessage } from "../../util/error"
+import { Filesystem } from "../../util/filesystem"
+import { Process } from "../../util/process"
+import { UI } from "../ui"
+import { cmd } from "./cmd"
+
+type Spin = {
+  start: (msg: string) => void
+  stop: (msg: string, code?: number) => void
+}
+
+export type PlugDeps = {
+  spinner: () => Spin
+  log: {
+    error: (msg: string) => void
+    info: (msg: string) => void
+    success: (msg: string) => void
+  }
+  resolve: (spec: string) => Promise<string>
+  readText: (file: string) => Promise<string>
+  write: (file: string, text: string) => Promise<void>
+  exists: (file: string) => Promise<boolean>
+  files: (dir: string, name: "nikcli" | "tui") => string[]
+  global: string
+}
+
+export type PlugInput = {
+  mod: string
+  global?: boolean
+  force?: boolean
+}
+
+export type PlugCtx = {
+  vcs?: string
+  worktree: string
+  directory: string
+}
+
+const defaultPlugDeps: PlugDeps = {
+  spinner: () => spinner(),
+  log: {
+    error: (msg) => log.error(msg),
+    info: (msg) => log.info(msg),
+    success: (msg) => log.success(msg),
+  },
+  resolve: (spec) => resolvePluginTarget(spec),
+  readText: (file) => Filesystem.readText(file),
+  write: async (file, text) => {
+    await Filesystem.write(file, text)
+  },
+  exists: (file) => Filesystem.exists(file),
+  files: (dir, name) => ConfigPaths.fileInDirectory(dir, name),
+  global: Global.Path.config,
+}
+
+function cause(err: unknown) {
+  if (!err || typeof err !== "object") return
+  if (!("cause" in err)) return
+  return (err as { cause?: unknown }).cause
+}
+
+export function createPlugTask(input: PlugInput, dep: PlugDeps = defaultPlugDeps) {
+  const mod = input.mod
+  const force = Boolean(input.force)
+  const global = Boolean(input.global)
+
+  return async (ctx: PlugCtx) => {
+    const install = dep.spinner()
+    install.start("Installing plugin package...")
+    const target = await installPlugin(mod, dep)
+    if (!target.ok) {
+      install.stop("Install failed", 1)
+      dep.log.error(`Could not install "${mod}"`)
+      const hit = cause(target.error) ?? target.error
+      if (hit instanceof Process.RunFailedError) {
+        const lines = hit.stderr
+          .toString()
+          .split(/\r?\n/)
+          .map((line) => line.trim())
+          .filter(Boolean)
+        const errs = lines.filter((line) => line.startsWith("error:")).map((line) => line.replace(/^error:\s*/, ""))
+        const detail = errs[0] ?? lines.at(-1)
+        if (detail) dep.log.error(detail)
+        if (lines.some((line) => line.includes("No version matching"))) {
+          dep.log.info("This package depends on a version that is not available in your npm registry.")
+          dep.log.info("Check npm registry/auth settings and try again.")
+        }
+      }
+      if (!(hit instanceof Process.RunFailedError)) {
+        dep.log.error(errorMessage(hit))
+      }
+      return false
+    }
+    install.stop("Plugin package ready")
+
+    const inspect = dep.spinner()
+    inspect.start("Reading plugin manifest...")
+    const manifest = await readPluginManifest(target.target)
+    if (!manifest.ok) {
+      if (manifest.code === "manifest_read_failed") {
+        inspect.stop("Manifest read failed", 1)
+        dep.log.error(`Installed "${mod}" but failed to read ${manifest.file}`)
+        dep.log.error(errorMessage(cause(manifest.error) ?? manifest.error))
+        return false
+      }
+
+      if (manifest.code === "manifest_no_targets") {
+        inspect.stop("No plugin targets found", 1)
+        dep.log.error(`"${mod}" does not declare supported targets in package.json`)
+        dep.log.info('Expected: "oc-plugin": ["server", "tui"] or tuples like [["tui", { ... }]].')
+        return false
+      }
+
+      inspect.stop("Manifest read failed", 1)
+      return false
+    }
+
+    inspect.stop(
+      `Detected ${manifest.targets.map((item) => item.kind).join(" + ")} target${manifest.targets.length === 1 ? "" : "s"}`,
+    )
+
+    const patch = dep.spinner()
+    patch.start("Updating plugin config...")
+    const out = await patchPluginConfig(
+      {
+        spec: mod,
+        targets: manifest.targets,
+        force,
+        global,
+        vcs: ctx.vcs,
+        worktree: ctx.worktree,
+        directory: ctx.directory,
+        config: dep.global,
+      },
+      dep,
+    )
+    if (!out.ok) {
+      if (out.code === "invalid_json") {
+        patch.stop(`Failed updating ${out.kind} config`, 1)
+        dep.log.error(`Invalid JSON in ${out.file} (${out.parse} at line ${out.line}, column ${out.col})`)
+        dep.log.info("Fix the config file and run the command again.")
+        return false
+      }
+
+      patch.stop("Failed updating plugin config", 1)
+      dep.log.error(errorMessage(out.error))
+      return false
+    }
+    patch.stop("Plugin config updated")
+    for (const item of out.items) {
+      if (item.mode === "noop") {
+        dep.log.info(`Already configured in ${item.file}`)
+        continue
+      }
+      if (item.mode === "replace") {
+        dep.log.info(`Replaced in ${item.file}`)
+        continue
+      }
+      dep.log.info(`Added to ${item.file}`)
+    }
+
+    dep.log.success(`Installed ${mod}`)
+    dep.log.info(global ? `Scope: global (${out.dir})` : `Scope: local (${out.dir})`)
+    return true
+  }
+}
+
+export const PluginCommand = cmd({
+  command: "plugin <module>",
+  aliases: ["plug"],
+  describe: "install plugin and update config",
+  builder: (yargs: Argv) => {
+    return yargs
+      .positional("module", {
+        type: "string",
+        describe: "npm module name",
+      })
+      .option("global", {
+        alias: ["g"],
+        type: "boolean",
+        default: false,
+        describe: "install in global config",
+      })
+      .option("force", {
+        alias: ["f"],
+        type: "boolean",
+        default: false,
+        describe: "replace existing plugin version",
+      })
+  },
+  handler: async (args) => {
+    const mod = String(args.module ?? "").trim()
+    if (!mod) {
+      UI.error("module is required")
+      process.exitCode = 1
+      return
+    }
+
+    UI.empty()
+    intro(`Install plugin ${mod}`)
+
+    const run = createPlugTask({
+      mod,
+      global: Boolean(args.global),
+      force: Boolean(args.force),
+    })
+    let ok = true
+
+    await Instance.provide({
+      directory: process.cwd(),
+      fn: async () => {
+        ok = await run({
+          vcs: Instance.project.vcs,
+          worktree: Instance.worktree,
+          directory: Instance.directory,
+        })
+      },
+    })
+
+    outro("Done")
+    if (!ok) process.exitCode = 1
+  },
+})

package/src/cli/cmd/pr.ts

@@ -0,0 +1,104 @@
+import { UI } from "../ui"
+import { cmd } from "./cmd"
+import { Instance } from "@/project/instance"
+import { $ } from "bun"
+
+export const PrCommand = cmd({
+  command: "pr <number>",
+  describe: "fetch and checkout a GitHub PR branch, then run nikcli",
+  builder: (yargs) =>
+    yargs.positional("number", {
+      type: "number",
+      describe: "PR number to checkout",
+      demandOption: true,
+    }),
+  async handler(args) {
+    await Instance.provide({
+      directory: process.cwd(),
+      async fn() {
+        const project = Instance.project
+        if (project.vcs !== "git") {
+          UI.error("Could not find git repository. Please run this command from a git repository.")
+          process.exit(1)
+        }
+
+        const prNumber = args.number
+        const localBranchName = `pr/${prNumber}`
+        UI.println(`Fetching and checking out PR #${prNumber}...`)
+
+        const result = await $`gh pr checkout ${prNumber} --branch ${localBranchName} --force`.nothrow()
+
+        if (result.exitCode !== 0) {
+          UI.error(`Failed to checkout PR #${prNumber}. Make sure you have gh CLI installed and authenticated.`)
+          process.exit(1)
+        }
+
+        const prInfoResult =
+          await $`gh pr view ${prNumber} --json headRepository,headRepositoryOwner,isCrossRepository,headRefName,body`.nothrow()
+
+        let sessionId: string | undefined
+
+        if (prInfoResult.exitCode === 0) {
+          const prInfoText = prInfoResult.text()
+          if (prInfoText.trim()) {
+            const prInfo = JSON.parse(prInfoText)
+
+            if (prInfo && prInfo.isCrossRepository && prInfo.headRepository && prInfo.headRepositoryOwner) {
+              const forkOwner = prInfo.headRepositoryOwner.login
+              const forkName = prInfo.headRepository.name
+              const remoteName = forkOwner
+
+              const remotes = (await $`git remote`.nothrow().text()).trim()
+              if (!remotes.split("\n").includes(remoteName)) {
+                await $`git remote add ${remoteName} https://github.com/${forkOwner}/${forkName}.git`.nothrow()
+                UI.println(`Added fork remote: ${remoteName}`)
+              }
+
+              const headRefName = prInfo.headRefName
+              await $`git branch --set-upstream-to=${remoteName}/${headRefName} ${localBranchName}`.nothrow()
+            }
+
+            if (prInfo && prInfo.body) {
+              const sessionMatch = prInfo.body.match(/https:\/\/nikcli\.ai\/s\/([a-zA-Z0-9_-]+)/)
+              if (sessionMatch) {
+                const sessionUrl = sessionMatch[0]
+                UI.println(`Found nikcli session: ${sessionUrl}`)
+                UI.println(`Importing session...`)
+
+                const importResult = await $`nikcli import ${sessionUrl}`.nothrow()
+                if (importResult.exitCode === 0) {
+                  const importOutput = importResult.text().trim()
+                  const sessionIdMatch = importOutput.match(/Imported session: ([a-zA-Z0-9_-]+)/)
+                  if (sessionIdMatch) {
+                    sessionId = sessionIdMatch[1]
+                    UI.println(`Session imported: ${sessionId}`)
+                  }
+                }
+              }
+            }
+          }
+        }
+
+        UI.println(`Successfully checked out PR #${prNumber} as branch '${localBranchName}'`)
+        UI.println()
+        UI.println("Starting nikcli...")
+        UI.println()
+
+        const { spawn } = await import("child_process")
+        const nikcliArgs = sessionId ? ["-s", sessionId] : []
+        const nikcliProcess = spawn("nikcli", nikcliArgs, {
+          stdio: "inherit",
+          cwd: process.cwd(),
+        })
+
+        await new Promise<void>((resolve, reject) => {
+          nikcliProcess.on("exit", (code) => {
+            if (code === 0) resolve()
+            else reject(new Error(`nikcli exited with code ${code}`))
+          })
+          nikcliProcess.on("error", reject)
+        })
+      },
+    })
+  },
+})