nikcli 0.0.6

package/src/cli/remote/session-manager.ts

@@ -0,0 +1,284 @@
+import { EventEmitter } from "node:events"
+import type {
+  BroadcastMessage,
+  DeviceInfo,
+  RemoteNotification,
+  RemoteServiceConfig,
+  RemoteSession,
+  SessionOptions,
+  SessionStatus,
+} from "./types"
+
+type RemoteServer = import("@nikcli-ai/remote").RemoteServer
+type NativeSession = import("@nikcli-ai/remote").RemoteSession
+type CloudAgent = import("@nikcli-ai/remote/cloud-agent").CloudAgent
+
+interface RelayTerminalMessage {
+  from?: {
+    userID?: string
+    deviceID?: string
+  }
+  sessionID?: string
+  body?: {
+    type?: string
+    payload?: {
+      data?: string
+      cols?: number
+      rows?: number
+    }
+  }
+}
+
+export class SessionManager extends EventEmitter {
+  private server: RemoteServer | null = null
+  private cloudAgent: CloudAgent | null = null
+  private session: RemoteSession | null = null
+  private config: RemoteServiceConfig
+  private stopEmitted = false
+
+  constructor(config: RemoteServiceConfig) {
+    super()
+    this.config = config
+  }
+
+  async start(options?: SessionOptions): Promise<RemoteSession> {
+    const { RemoteServer } = await import("@nikcli-ai/remote")
+    this.stopEmitted = false
+
+    this.server = new RemoteServer({
+      port: 0,
+      enableTunnel: true,
+      tunnelProvider: "localtunnel",
+      maxConnections: options?.maxDevices ?? this.config.maxDevices,
+      sessionTimeout: this.config.sessionExpiry * 1000,
+      enableTerminal: false,
+    })
+
+    this.server.on("client:connected", (device: DeviceInfo) => {
+      if (!this.session) return
+      this.session.connectedDevices.push(device)
+      this.session.status = "connected"
+      this.session.lastActivity = new Date()
+      this.emit("status:change", this.session)
+      this.emit("device:connected", this.session, device)
+    })
+
+    this.server.on("client:disconnected", (device: DeviceInfo) => {
+      if (!this.session) return
+      this.session.connectedDevices = this.session.connectedDevices.filter((d) => d.id !== device.id)
+      if (this.session.connectedDevices.length === 0) {
+        this.session.status = "waiting"
+      }
+      this.emit("status:change", this.session)
+      this.emit("device:disconnected", this.session, device)
+    })
+
+    this.server.on("tunnel:connected", (url: string) => {
+      if (this.session) {
+        this.session.qrUrl = url
+        this.emit("tunnel:connected", url)
+      }
+    })
+
+    this.server.on("tunnel:error", (error: Error) => {
+      this.emit("tunnel:error", error)
+    })
+
+    this.server.on("error", (error: Error) => {
+      this.emit("error", error)
+    })
+
+    this.server.on("stopped", () => {
+      if (this.stopEmitted) return
+      this.stopEmitted = true
+      if (this.session) {
+        this.session.status = "stopped"
+        this.session.lastActivity = new Date()
+      }
+      this.emit("stopped", this.session)
+    })
+
+    this.server.on("terminal:resize", (cols: number, rows: number) => {
+      this.emit("terminal:resize", cols, rows)
+    })
+
+    this.server.on("terminal:output", (data: string | Buffer) => {
+      const output = typeof data === "string" ? data : data.toString("utf8")
+      // Server already broadcasts to WebSocket clients
+      // Just emit for other listeners, don't re-broadcast
+      this.emit("terminal:output", output)
+      if (this.cloudAgent?.isRelayConnected()) {
+        try {
+          this.cloudAgent.sendRelayMessage({
+            type: "terminal:output",
+            payload: { data: output },
+            timestamp: Date.now(),
+          })
+        } catch {
+          // relay may disconnect while terminal output is in-flight
+        }
+      }
+    })
+
+    const nativeSession: NativeSession = await this.server.start({
+      name: options?.name,
+      processForStreaming: {
+        stdout: process.stdout,
+        stdin: process.stdin,
+        input: (data: Buffer) => {
+          process.stdin.emit("data", data)
+        },
+      },
+    })
+
+    this.session = {
+      id: nativeSession.id,
+      name: nativeSession.name,
+      qrCode: "",
+      qrUrl: nativeSession.qrUrl,
+      localUrl: nativeSession.localUrl,
+      tunnelUrl: nativeSession.tunnelUrl,
+      status: nativeSession.status as SessionStatus,
+      connectedDevices: [],
+      startedAt: nativeSession.startedAt,
+      lastActivity: nativeSession.lastActivity,
+      port: nativeSession.port,
+    }
+
+    try {
+      await this.startCloudAgent(options)
+    } catch (error) {
+      await this.server.stop().catch(() => {})
+      this.server = null
+      this.session.status = "error"
+      throw error
+    }
+
+    return this.session
+  }
+
+  async stop(): Promise<void> {
+    if (this.cloudAgent) {
+      await this.cloudAgent.disconnectRelay().catch(() => {})
+      this.cloudAgent.removeAllListeners()
+      this.cloudAgent = null
+    }
+
+    if (this.server) {
+      await this.server.stop()
+      this.server = null
+    }
+
+    if (this.session) {
+      this.session.status = "stopped"
+    }
+
+    if (!this.stopEmitted) {
+      this.stopEmitted = true
+      this.emit("stopped", this.session)
+    }
+  }
+
+  isActive(): boolean {
+    return this.server?.isActive() ?? false
+  }
+
+  getSession(): RemoteSession | null {
+    return this.session
+  }
+
+  broadcast(message: BroadcastMessage): void {
+    this.server?.broadcast(message)
+  }
+
+  notify(notification: RemoteNotification): void {
+    this.server?.notify({
+      type:
+        notification.type === "task_complete"
+          ? "success"
+          : notification.type === "error"
+            ? "error"
+            : notification.type === "action_required"
+              ? "warning"
+              : "info",
+      title: notification.title,
+      body: notification.body,
+      data: notification.data,
+    })
+  }
+
+  writeToTerminal(data: string): void {
+    this.server?.writeToTerminal(data)
+  }
+
+  resizeTerminal(cols: number, rows: number): void {
+    this.server?.resizeTerminal(cols, rows)
+  }
+
+  getConnectedCount(): number {
+    return this.server?.getConnectedCount() ?? 0
+  }
+
+  private async startCloudAgent(options?: SessionOptions): Promise<void> {
+    if (!options?.cloud?.enabled || !this.session) return
+
+    const { CloudAgent } = await import("@nikcli-ai/remote/cloud-agent")
+    const sessionID = options.cloud.sessionID || this.session.id
+
+    const agent = new CloudAgent({
+      cloudUrl: options.cloud.url,
+      token: options.cloud.token,
+      deviceID: options.cloud.deviceID,
+    })
+
+    agent.on("connected", () => {
+      this.emit("cloud:connected", {
+        sessionID,
+        cloudUrl: options.cloud?.url,
+      })
+    })
+
+    agent.on("disconnected", (info: unknown) => {
+      this.emit("cloud:disconnected", info)
+    })
+
+    agent.on("message", (payload: unknown) => {
+      this.emit("cloud:message", payload)
+      if (this.server && payload && typeof payload === "object") {
+        const body = payload as RelayTerminalMessage
+        if (body.sessionID && body.sessionID !== sessionID) return
+
+        const messageType = body.body?.type
+        if (messageType === "terminal:input" || messageType === "terminal.input") {
+          const input = body.body?.payload?.data
+          if (typeof input === "string") {
+            this.server.sendInputToTerminal(input)
+          }
+        }
+
+        if (messageType === "terminal:resize" || messageType === "terminal.resize") {
+          const cols = body.body?.payload?.cols
+          const rows = body.body?.payload?.rows
+          if (typeof cols === "number" && typeof rows === "number") {
+            this.server.resizeTerminal(cols, rows)
+          }
+        }
+      }
+    })
+
+    agent.on("error", (error: unknown) => {
+      this.emit("cloud:error", error)
+    })
+
+    if (options.cloud.publicKey) {
+      await agent.registerDevice({
+        name: "nikcli-desktop",
+        platform: "desktop",
+        publicKey: options.cloud.publicKey,
+      })
+    }
+
+    this.cloudAgent = agent
+    await agent.connectRelay(sessionID)
+  }
+}

package/src/cli/remote/subagent-hooks.ts

@@ -0,0 +1,151 @@
+import { remoteService } from "./remote-service"
+import type { InputPrompt, SubagentResult, TaskInfo } from "./types"
+
+export interface SubagentRemoteHooks {
+  onStart(agentName: string, task: string): void
+  onProgress(agentName: string, progress: number, message: string): void
+  onComplete(agentName: string, result: SubagentResult): void
+  onError(agentName: string, error: Error): void
+  onRequiresInput(agentName: string, prompt: InputPrompt): void
+}
+
+export function createSubagentRemoteHooks(): SubagentRemoteHooks {
+  return {
+    onStart(agentName: string, task: string) {
+      if (!remoteService.hasActiveSession()) return
+      remoteService.broadcast({
+        type: "subagent:start",
+        payload: {
+          agentName,
+          task,
+          timestamp: Date.now(),
+        },
+      })
+    },
+
+    onProgress(agentName: string, progress: number, message: string) {
+      if (!remoteService.hasActiveSession()) return
+      remoteService.broadcast({
+        type: "subagent:progress",
+        payload: {
+          agentName,
+          progress,
+          message,
+          timestamp: Date.now(),
+        },
+      })
+    },
+
+    onComplete(agentName: string, result: SubagentResult) {
+      if (!remoteService.hasActiveSession()) return
+      remoteService.broadcast({
+        type: "subagent:complete",
+        payload: {
+          agentName,
+          result,
+          timestamp: Date.now(),
+        },
+      })
+
+      remoteService.notifyTaskComplete({
+        name: agentName,
+        summary: result.summary,
+        success: result.success,
+        duration: result.duration,
+        agentName,
+      })
+    },
+
+    onError(agentName: string, error: Error) {
+      if (!remoteService.hasActiveSession()) return
+      remoteService.broadcast({
+        type: "subagent:error",
+        payload: {
+          agentName,
+          error: error.message,
+          timestamp: Date.now(),
+        },
+      })
+      remoteService.notifyError(agentName, error.message)
+    },
+
+    onRequiresInput(agentName: string, prompt: InputPrompt) {
+      if (!remoteService.hasActiveSession()) return
+      remoteService.broadcast({
+        type: "subagent:input_required",
+        payload: {
+          agentName,
+          prompt,
+          timestamp: Date.now(),
+        },
+      })
+      remoteService.notifyInputRequired(agentName, prompt.message)
+    },
+  }
+}
+
+let _hooks: SubagentRemoteHooks | null = null
+
+export function getSubagentRemoteHooks(): SubagentRemoteHooks {
+  if (!_hooks) {
+    _hooks = createSubagentRemoteHooks()
+  }
+  return _hooks
+}
+
+export function attachRemoteHooksToAgentService(agentService: any): void {
+  const hooks = getSubagentRemoteHooks()
+  if (!agentService?.on) return
+
+  agentService.on("task_start", (task: any) => {
+    hooks.onStart(task.agentType ?? "agent", task.task ?? task.description ?? "Task")
+  })
+
+  agentService.on("task_progress", (task: any, update: any) => {
+    hooks.onProgress(
+      task.agentType ?? "agent",
+      update.progress ?? 0,
+      update.description ?? update.message ?? "",
+    )
+  })
+
+  agentService.on("task_complete", (task: any, result: any) => {
+    hooks.onComplete(task.agentType ?? "agent", {
+      success: result?.success ?? true,
+      summary: result?.summary ?? "Task completed",
+      duration: result?.duration ?? 0,
+      output: result?.output,
+    })
+  })
+
+  agentService.on("task_error", (task: any, error: any) => {
+    hooks.onError(task.agentType ?? "agent", error instanceof Error ? error : new Error(String(error)))
+  })
+
+  agentService.on("input_required", (task: any, prompt: any) => {
+    hooks.onRequiresInput(task.agentType ?? "agent", {
+      message: prompt?.message ?? "Input required",
+      type: prompt?.type ?? "text",
+      options: prompt?.options,
+      required: prompt?.required,
+    })
+  })
+}
+
+export function createTaskInfo(
+  name: string,
+  summary: string,
+  options?: {
+    success?: boolean
+    duration?: number
+    agentName?: string
+  },
+): TaskInfo {
+  return {
+    name,
+    summary,
+    success: options?.success ?? true,
+    duration: options?.duration,
+    agentName: options?.agentName ?? name,
+  }
+}

package/src/cli/remote/types.ts

@@ -0,0 +1,121 @@
+export type SessionStatus = "starting" | "waiting" | "connected" | "stopped" | "error"
+
+export interface DeviceInfo {
+  id: string
+  userAgent?: string
+  connectedAt: Date
+  lastActivity: Date
+}
+
+export interface RemoteSession {
+  id: string
+  name: string
+  qrCode: string
+  qrUrl: string
+  localUrl?: string
+  tunnelUrl?: string
+  tunnelPassword?: string
+  status: SessionStatus
+  connectedDevices: DeviceInfo[]
+  startedAt: Date
+  lastActivity: Date
+  error?: string
+  port?: number
+}
+
+export interface SessionOptions {
+  name?: string
+  timeout?: number
+  maxDevices?: number
+  cloud?: {
+    enabled: boolean
+    url: string
+    token: string
+    deviceID: string
+    sessionID?: string
+    publicKey?: string
+  }
+}
+
+export interface RemoteServiceConfig {
+  notificationsEnabled: boolean
+  sessionExpiry: number
+  maxDevices: number
+  autoRecoverSession: boolean
+}
+
+export interface BroadcastMessage {
+  type: string
+  payload: unknown
+  timestamp?: number
+}
+
+export interface RemoteNotification {
+  type: "task_complete" | "error" | "action_required" | "info"
+  title: string
+  body: string
+  data?: unknown
+}
+
+export interface TaskInfo {
+  name: string
+  summary: string
+  success?: boolean
+  duration?: number
+  agentName?: string
+}
+
+export interface SubagentResult {
+  success: boolean
+  summary: string
+  duration: number
+  output?: string
+  error?: string
+}
+
+export interface InputPrompt {
+  message: string
+  type: "text" | "confirm" | "select"
+  options?: string[]
+  required?: boolean
+}
+
+export interface RemoteSessionPersistence {
+  sessionId: string
+  name: string
+  qrUrl: string
+  localUrl?: string
+  tunnelUrl?: string
+  tunnelPassword?: string
+  port?: number
+  startedAt: string
+  lastActivity: string
+  status: SessionStatus
+}
+
+export interface ResolvedRemoteSession {
+  source: "memory" | "persisted"
+  session: RemoteSession
+  persisted?: RemoteSessionPersistence
+}
+
+export interface SubagentRemoteEvent {
+  type: "subagent:start" | "subagent:progress" | "subagent:complete" | "subagent:error" | "subagent:input_required"
+  payload: {
+    agentName: string
+    task?: string
+    progress?: number
+    message?: string
+    result?: SubagentResult
+    error?: string
+    prompt?: InputPrompt
+    timestamp: number
+  }
+}
+
+export const DEFAULT_REMOTE_CONFIG: RemoteServiceConfig = {
+  notificationsEnabled: true,
+  sessionExpiry: 86400,
+  maxDevices: 5,
+  autoRecoverSession: true,
+}

package/src/cli/ui.ts

@@ -0,0 +1,96 @@
+import z from "zod"
+import { EOL } from "os"
+import { NamedError } from "@nikcli-ai/util/error"
+import { remoteService } from "./remote"
+
+export namespace UI {
+  const LOGO = [
+    `
+    ███╗   ██╗██╗██╗  ██╗ ██████╗██╗     ██╗
+    ████╗  ██║██║██║ ██╔╝██╔════╝██║     ██║
+    ██╔██╗ ██║██║█████╔╝ ██║     ██║     ██║
+    ██║╚██╗██║██║██╔═██╗ ██║     ██║     ██║
+    ██║ ╚████║██║██║  ██╗╚██████╗███████╗██║`
+  ]
+
+  export const CancelledError = NamedError.create("UICancelledError", z.void())
+
+  export const Style = {
+    TEXT_HIGHLIGHT: "\x1b[96m",
+    TEXT_HIGHLIGHT_BOLD: "\x1b[96m\x1b[1m",
+    TEXT_DIM: "\x1b[90m",
+    TEXT_DIM_BOLD: "\x1b[90m\x1b[1m",
+    TEXT_NORMAL: "\x1b[0m",
+    TEXT_NORMAL_BOLD: "\x1b[1m",
+    TEXT_WARNING: "\x1b[93m",
+    TEXT_WARNING_BOLD: "\x1b[93m\x1b[1m",
+    TEXT_DANGER: "\x1b[91m",
+    TEXT_DANGER_BOLD: "\x1b[91m\x1b[1m",
+    TEXT_SUCCESS: "\x1b[92m",
+    TEXT_SUCCESS_BOLD: "\x1b[92m\x1b[1m",
+    TEXT_INFO: "\x1b[94m",
+    TEXT_INFO_BOLD: "\x1b[94m\x1b[1m",
+  }
+
+  export function println(...message: string[]) {
+    print(...message)
+    Bun.stderr.write(EOL)
+    forwardToRemote(EOL)
+  }
+
+  export function print(...message: string[]) {
+    blank = false
+    const text = message.join(" ")
+    Bun.stderr.write(text)
+    forwardToRemote(text)
+  }
+
+  let blank = false
+  export function empty() {
+    if (blank) return
+    println("" + Style.TEXT_NORMAL)
+    blank = true
+  }
+
+  export function logo(pad?: string) {
+    const result = []
+    for (const row of LOGO) {
+      if (pad) result.push(pad)
+      result.push(Bun.color("gray", "ansi"))
+      result.push(row[0])
+      result.push("\x1b[0m")
+      result.push(row[1])
+      result.push(EOL)
+    }
+    return result.join("").trimEnd()
+  }
+
+  export async function input(prompt: string): Promise<string> {
+    const readline = require("readline")
+    const rl = readline.createInterface({
+      input: process.stdin,
+      output: process.stdout,
+    })
+
+    return new Promise((resolve) => {
+      rl.question(prompt, (answer: string) => {
+        rl.close()
+        resolve(answer.trim())
+      })
+    })
+  }
+
+  export function error(message: string) {
+    println(Style.TEXT_DANGER_BOLD + "Error: " + Style.TEXT_NORMAL + message)
+  }
+
+  export function markdown(text: string): string {
+    return text
+  }
+
+  function forwardToRemote(text: string) {
+    if (!text) return
+    if (!remoteService.hasActiveSession()) return
+    remoteService.writeToTerminal(text)
+  }
+}

package/src/cli/upgrade.ts

@@ -0,0 +1,25 @@
+import { Bus } from "@/bus"
+import { Config } from "@/config/config"
+import { Flag } from "@/flag/flag"
+import { Installation } from "@/installation"
+
+export async function upgrade() {
+  const config = await Config.global()
+  const method = await Installation.method()
+  const latest = await Installation.latest(method).catch(() => {})
+  if (!latest) return
+  if (Installation.VERSION === latest) return
+
+  if (config.autoupdate === false || Flag.NIKCLI_DISABLE_AUTOUPDATE) {
+    return
+  }
+  if (config.autoupdate === "notify") {
+    await Bus.publish(Installation.Event.UpdateAvailable, { version: latest })
+    return
+  }
+
+  if (method === "unknown") return
+  await Installation.upgrade(method, latest)
+    .then(() => Bus.publish(Installation.Event.Updated, { version: latest }))
+    .catch(() => {})
+}