@happy-creative/iroder 1.0.0

package/src/cli/commands.ts

@@ -0,0 +1,58 @@
+import { AcpCommand } from "./cmd/acp"
+import { AgentCommand } from "./cmd/agent"
+import { ConsoleCommand } from "./cmd/account"
+import { AttachCommand } from "./cmd/tui/attach"
+import { DbCommand } from "./cmd/db"
+import { DebugCommand } from "./cmd/debug"
+import { ExportCommand } from "./cmd/export"
+import { GenerateCommand } from "./cmd/generate"
+import { GithubCommand } from "./cmd/github"
+import { ImportCommand } from "./cmd/import"
+import { McpCommand } from "./cmd/mcp"
+import { ModelsCommand } from "./cmd/models"
+import { PluginCommand } from "./cmd/plug"
+import { PrCommand } from "./cmd/pr"
+import { ProvidersCommand } from "./cmd/providers"
+import { RunCommand } from "./cmd/run"
+import { ServeCommand } from "./cmd/serve"
+import { SessionCommand } from "./cmd/session"
+import { StatsCommand } from "./cmd/stats"
+import { TuiThreadCommand } from "./cmd/tui/thread"
+import { UninstallCommand } from "./cmd/uninstall"
+import { UpgradeCommand } from "./cmd/upgrade"
+import { WebCommand } from "./cmd/web"
+import { Flag } from "../flag/flag"
+
+const core = [
+  AcpCommand,
+  McpCommand,
+  TuiThreadCommand,
+  AttachCommand,
+  RunCommand,
+  ConsoleCommand,
+  ProvidersCommand,
+  AgentCommand,
+  ServeCommand,
+  WebCommand,
+  ModelsCommand,
+  SessionCommand,
+]
+
+const ext = [
+  GenerateCommand,
+  DebugCommand,
+  UpgradeCommand,
+  UninstallCommand,
+  StatsCommand,
+  ExportCommand,
+  ImportCommand,
+  GithubCommand,
+  PrCommand,
+  PluginCommand,
+  DbCommand,
+]
+
+export function commands() {
+  if (Flag.IRODER_ENABLE_EXT_CMDS) return [...core, ...ext]
+  return core
+}

package/src/cli/effect/prompt.ts

@@ -0,0 +1,25 @@
+import * as prompts from "@clack/prompts"
+import { Effect, Option } from "effect"
+
+export const intro = (msg: string) => Effect.sync(() => prompts.intro(msg))
+export const outro = (msg: string) => Effect.sync(() => prompts.outro(msg))
+
+export const log = {
+  info: (msg: string) => Effect.sync(() => prompts.log.info(msg)),
+}
+
+export const select = <Value>(opts: Parameters<typeof prompts.select<Value>>[0]) =>
+  Effect.tryPromise(() => prompts.select(opts)).pipe(
+    Effect.map((result) => {
+      if (prompts.isCancel(result)) return Option.none<Value>()
+      return Option.some(result)
+    }),
+  )
+
+export const spinner = () => {
+  const s = prompts.spinner()
+  return {
+    start: (msg: string) => Effect.sync(() => s.start(msg)),
+    stop: (msg: string, code?: number) => Effect.sync(() => s.stop(msg, code)),
+  }
+}

package/src/cli/error.ts

@@ -0,0 +1,50 @@
+import { AccountServiceError, AccountTransportError } from "@/account"
+import { ConfigMarkdown } from "@/config/markdown"
+import { errorFormat } from "@/util/error"
+import { Config } from "../config/config"
+import { MCP } from "../mcp"
+import { Provider } from "../provider/provider"
+import { UI } from "./ui"
+
+export function FormatError(input: unknown) {
+  if (MCP.Failed.isInstance(input))
+    return `MCP server "${input.data.name}" failed. Note, iroder does not support MCP authentication yet.`
+  if (input instanceof AccountTransportError || input instanceof AccountServiceError) {
+    return input.message
+  }
+  if (Provider.ModelNotFoundError.isInstance(input)) {
+    const { providerID, modelID, suggestions } = input.data
+    return [
+      `Model not found: ${providerID}/${modelID}`,
+      ...(Array.isArray(suggestions) && suggestions.length ? ["Did you mean: " + suggestions.join(", ")] : []),
+      `Try: \`iroder models\` to list available models`,
+      `Or check your config (iroder.json) provider/model names`,
+    ].join("\n")
+  }
+  if (Provider.InitError.isInstance(input)) {
+    return `Failed to initialize provider "${input.data.providerID}". Check credentials and configuration.`
+  }
+  if (Config.JsonError.isInstance(input)) {
+    return (
+      `Config file at ${input.data.path} is not valid JSON(C)` + (input.data.message ? `: ${input.data.message}` : "")
+    )
+  }
+  if (Config.ConfigDirectoryTypoError.isInstance(input)) {
+    return `Directory "${input.data.dir}" in ${input.data.path} is not valid. Rename the directory to "${input.data.suggestion}" or remove it. This is a common typo.`
+  }
+  if (ConfigMarkdown.FrontmatterError.isInstance(input)) {
+    return input.data.message
+  }
+  if (Config.InvalidError.isInstance(input))
+    return [
+      `Configuration is invalid${input.data.path && input.data.path !== "config" ? ` at ${input.data.path}` : ""}` +
+        (input.data.message ? `: ${input.data.message}` : ""),
+      ...(input.data.issues?.map((issue) => "↳ " + issue.message + " " + issue.path.join(".")) ?? []),
+    ].join("\n")
+
+  if (UI.CancelledError.isInstance(input)) return ""
+}
+
+export function FormatUnknownError(input: unknown): string {
+  return errorFormat(input)
+}

package/src/cli/heap.ts

@@ -0,0 +1,59 @@
+import path from "path"
+import { writeHeapSnapshot } from "node:v8"
+import { Flag } from "@/flag/flag"
+import { Global } from "@/global"
+import { Log } from "@/util/log"
+
+const log = Log.create({ service: "heap" })
+const MINUTE = 60_000
+const LIMIT = 2 * 1024 * 1024 * 1024
+
+export namespace Heap {
+  let timer: Timer | undefined
+  let lock = false
+  let armed = true
+
+  export function start() {
+    if (!Flag.IRODER_AUTO_HEAP_SNAPSHOT) return
+    if (timer) return
+
+    const run = async () => {
+      if (lock) return
+
+      const stat = process.memoryUsage()
+      if (stat.rss <= LIMIT) {
+        armed = true
+        return
+      }
+      if (!armed) return
+
+      lock = true
+      armed = false
+      const file = path.join(
+        Global.Path.log,
+        `heap-${process.pid}-${new Date().toISOString().replace(/[:.]/g, "")}.heapsnapshot`,
+      )
+      log.warn("heap usage exceeded limit", {
+        rss: stat.rss,
+        heap: stat.heapUsed,
+        file,
+      })
+
+      await Promise.resolve()
+        .then(() => writeHeapSnapshot(file))
+        .catch((err) => {
+          log.error("failed to write heap snapshot", {
+            error: err instanceof Error ? err.message : String(err),
+            file,
+          })
+        })
+
+      lock = false
+    }
+
+    timer = setInterval(() => {
+      void run()
+    }, MINUTE)
+    timer.unref?.()
+  }
+}

package/src/cli/llm-ready.ts

@@ -0,0 +1,22 @@
+import type { IroderClient } from "@happy-creative/sdk/v2"
+import { Provider } from "@/provider/provider"
+import { bootstrap } from "./bootstrap"
+
+function msg(env: string[]) {
+  if (env.length > 0) return `no providers found; set at least one key env: ${env.join(", ")}`
+  return "no providers found; configure provider env or auth first"
+}
+
+export async function assertLocalLLMReady(directory: string) {
+  if (process.env.IRODER_E2E_LLM_URL) return
+  return bootstrap(directory, () => Provider.defaultModel()).then(() => undefined)
+}
+
+export async function assertSDKLLMReady(sdk: IroderClient) {
+  const info = await sdk.provider.list().then((res) => res.data)
+  if ((info?.connected ?? []).length > 0) return
+  const env = [...new Set((info?.all ?? []).flatMap((item) => item.env ?? []))]
+    .filter((item) => !item.startsWith("IRODER_"))
+    .sort()
+  throw new Error(msg(env))
+}

package/src/cli/logo.ts

@@ -0,0 +1,8 @@
+export const logo = {
+  // IRO - left half (3 letters)
+  left: ["▀█▀ █▀▀█ █▀▀█", " █  █▀▀▄ █  █", "▀▀▀ ▀  ▀ ▀▀▀▀"],
+  // OTE - right half (3 letters)
+  right: ["█▀▀▄ █▀▀▀ █▀▀█", "█  █ █▀▀  █▀▀▄", "▀▀▀  ▀▀▀▀ ▀  ▀"],
+}
+
+export const marks = "_^~"

package/src/cli/network.ts

@@ -0,0 +1,60 @@
+import type { Argv, InferredOptionTypes } from "yargs"
+import { Config } from "../config/config"
+
+const options = {
+  port: {
+    type: "number" as const,
+    describe: "port to listen on",
+    default: 0,
+  },
+  hostname: {
+    type: "string" as const,
+    describe: "hostname to listen on",
+    default: "127.0.0.1",
+  },
+  mdns: {
+    type: "boolean" as const,
+    describe: "enable mDNS service discovery (defaults hostname to 0.0.0.0)",
+    default: false,
+  },
+  "mdns-domain": {
+    type: "string" as const,
+    describe: "custom domain name for mDNS service (default: iroder.local)",
+    default: "iroder.local",
+  },
+  cors: {
+    type: "string" as const,
+    array: true,
+    describe: "additional domains to allow for CORS",
+    default: [] as string[],
+  },
+}
+
+export type NetworkOptions = InferredOptionTypes<typeof options>
+
+export function withNetworkOptions<T>(yargs: Argv<T>) {
+  return yargs.options(options)
+}
+
+export async function resolveNetworkOptions(args: NetworkOptions) {
+  const config = await Config.getGlobal()
+  const portExplicitlySet = process.argv.includes("--port")
+  const hostnameExplicitlySet = process.argv.includes("--hostname")
+  const mdnsExplicitlySet = process.argv.includes("--mdns")
+  const mdnsDomainExplicitlySet = process.argv.includes("--mdns-domain")
+  const corsExplicitlySet = process.argv.includes("--cors")
+
+  const mdns = mdnsExplicitlySet ? args.mdns : (config?.server?.mdns ?? args.mdns)
+  const mdnsDomain = mdnsDomainExplicitlySet ? args["mdns-domain"] : (config?.server?.mdnsDomain ?? args["mdns-domain"])
+  const port = portExplicitlySet ? args.port : (config?.server?.port ?? args.port)
+  const hostname = hostnameExplicitlySet
+    ? args.hostname
+    : mdns && !config?.server?.hostname
+      ? "0.0.0.0"
+      : (config?.server?.hostname ?? args.hostname)
+  const configCors = config?.server?.cors ?? []
+  const argsCors = Array.isArray(args.cors) ? args.cors : args.cors ? [args.cors] : []
+  const cors = [...configCors, ...argsCors]
+
+  return { hostname, port, mdns, mdnsDomain, cors }
+}

package/src/cli/ui.ts

@@ -0,0 +1,132 @@
+import z from "zod"
+import { EOL } from "os"
+import { NamedError } from "@happy-creative/util/error"
+import { logo as glyphs } from "./logo"
+
+export namespace UI {
+  const wordmark = [
+    `▀█▀ █▀▀█ █▀▀█ █▀▀▄ █▀▀▀ █▀▀█`,
+    ` █  █▀▀▄ █  █ █  █ █▀▀  █▀▀▄`,
+    `▀▀▀ ▀  ▀ ▀▀▀▀ ▀▀▀  ▀▀▀▀ ▀  ▀`,
+  ]
+
+  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)
+    process.stderr.write(EOL)
+  }
+
+  export function print(...message: string[]) {
+    blank = false
+    process.stderr.write(message.join(" "))
+  }
+
+  let blank = false
+  export function empty() {
+    if (blank) return
+    println("" + Style.TEXT_NORMAL)
+    blank = true
+  }
+
+  export function logo(pad?: string) {
+    if (!process.stdout.isTTY && !process.stderr.isTTY) {
+      const result = []
+      for (const row of wordmark) {
+        if (pad) result.push(pad)
+        result.push(row)
+        result.push(EOL)
+      }
+      return result.join("").trimEnd()
+    }
+
+    const result: string[] = []
+    const reset = "\x1b[0m"
+    const left = {
+      fg: "\x1b[90m",
+      shadow: "\x1b[38;5;235m",
+      bg: "\x1b[48;5;235m",
+    }
+    const right = {
+      fg: reset,
+      shadow: "\x1b[38;5;238m",
+      bg: "\x1b[48;5;238m",
+    }
+    const gap = " "
+    const draw = (line: string, fg: string, shadow: string, bg: string) => {
+      const parts: string[] = []
+      for (const char of line) {
+        if (char === "_") {
+          parts.push(bg, " ", reset)
+          continue
+        }
+        if (char === "^") {
+          parts.push(fg, bg, "▀", reset)
+          continue
+        }
+        if (char === "~") {
+          parts.push(shadow, "▀", reset)
+          continue
+        }
+        if (char === " ") {
+          parts.push(" ")
+          continue
+        }
+        parts.push(fg, char, reset)
+      }
+      return parts.join("")
+    }
+    glyphs.left.forEach((row, index) => {
+      if (pad) result.push(pad)
+      result.push(draw(row, left.fg, left.shadow, left.bg))
+      result.push(gap)
+      const other = glyphs.right[index] ?? ""
+      result.push(draw(other, right.fg, right.shadow, right.bg))
+      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) {
+    if (message.startsWith("Error: ")) {
+      message = message.slice("Error: ".length)
+    }
+    println(Style.TEXT_DANGER_BOLD + "Error: " + Style.TEXT_NORMAL + message)
+  }
+
+  export function markdown(text: string): string {
+    return text
+  }
+}

package/src/cli/upgrade.ts

@@ -0,0 +1,31 @@
+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.getGlobal()
+  const method = await Installation.method()
+  const latest = await Installation.latest(method).catch(() => {})
+  if (!latest) return
+
+  if (Flag.IRODER_ALWAYS_NOTIFY_UPDATE) {
+    await Bus.publish(Installation.Event.UpdateAvailable, { version: latest })
+    return
+  }
+
+  if (Installation.VERSION === latest) return
+  if (config.autoupdate === false || Flag.IRODER_DISABLE_AUTOUPDATE) return
+
+  const kind = Installation.getReleaseType(Installation.VERSION, latest)
+
+  if (config.autoupdate === "notify" || kind !== "patch") {
+    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(() => {})
+}

package/src/command/index.ts

@@ -0,0 +1,195 @@
+import { BusEvent } from "@/bus/bus-event"
+import { InstanceState } from "@/effect/instance-state"
+import { makeRuntime } from "@/effect/run-service"
+import { SessionID, MessageID } from "@/session/schema"
+import { Effect, Layer, ServiceMap } from "effect"
+import z from "zod"
+import { Config } from "../config/config"
+import { MCP } from "../mcp"
+import { Skill } from "../skill"
+import { Log } from "../util/log"
+import PROMPT_INITIALIZE from "./template/initialize.txt"
+import PROMPT_REVIEW from "./template/review.txt"
+
+export namespace Command {
+  const log = Log.create({ service: "command" })
+
+  type State = {
+    commands: Record<string, Info>
+  }
+
+  export const Event = {
+    Executed: BusEvent.define(
+      "command.executed",
+      z.object({
+        name: z.string(),
+        sessionID: SessionID.zod,
+        arguments: z.string(),
+        messageID: MessageID.zod,
+      }),
+    ),
+  }
+
+  export const Info = z
+    .object({
+      name: z.string(),
+      description: z.string().optional(),
+      agent: z.string().optional(),
+      model: z.string().optional(),
+      source: z.enum(["command", "mcp", "skill"]).optional(),
+      // workaround for zod not supporting async functions natively so we use getters
+      // https://zod.dev/v4/changelog?id=zfunction
+      template: z.promise(z.string()).or(z.string()),
+      subtask: z.boolean().optional(),
+      hints: z.array(z.string()),
+    })
+    .meta({
+      ref: "Command",
+    })
+
+  // for some reason zod is inferring `string` for z.promise(z.string()).or(z.string()) so we have to manually override it
+  export type Info = Omit<z.infer<typeof Info>, "template"> & { template: Promise<string> | string }
+
+  export function hints(template: string) {
+    const result: string[] = []
+    const numbered = template.match(/\$\d+/g)
+    if (numbered) {
+      for (const match of [...new Set(numbered)].sort()) result.push(match)
+    }
+    if (template.includes("$ARGUMENTS")) result.push("$ARGUMENTS")
+    return result
+  }
+
+  export const Default = {
+    INIT: "init",
+    REVIEW: "review",
+  } as const
+
+  export interface Interface {
+    readonly get: (name: string) => Effect.Effect<Info | undefined>
+    readonly list: () => Effect.Effect<Info[]>
+  }
+
+  export class Service extends ServiceMap.Service<Service, Interface>()("@iroder/Command") {}
+
+  export const layer = Layer.effect(
+    Service,
+    Effect.gen(function* () {
+      const config = yield* Config.Service
+      const mcp = yield* MCP.Service
+      const skill = yield* Skill.Service
+
+      const init = Effect.fn("Command.state")(function* (ctx) {
+        const cfg = yield* config.get()
+        const commands: Record<string, Info> = {}
+
+        commands[Default.INIT] = {
+          name: Default.INIT,
+          description: "guided AGENTS.md setup",
+          source: "command",
+          get template() {
+            return PROMPT_INITIALIZE.replace("${path}", ctx.worktree)
+          },
+          hints: hints(PROMPT_INITIALIZE),
+        }
+        commands[Default.REVIEW] = {
+          name: Default.REVIEW,
+          description: "review changes [commit|branch|pr], defaults to uncommitted",
+          source: "command",
+          get template() {
+            return PROMPT_REVIEW.replace("${path}", ctx.worktree)
+          },
+          subtask: true,
+          hints: hints(PROMPT_REVIEW),
+        }
+
+        for (const [name, command] of Object.entries(cfg.command ?? {})) {
+          commands[name] = {
+            name,
+            agent: command.agent,
+            model: command.model,
+            description: command.description,
+            source: "command",
+            get template() {
+              return command.template
+            },
+            subtask: command.subtask,
+            hints: hints(command.template),
+          }
+        }
+
+        for (const [name, prompt] of Object.entries(yield* mcp.prompts())) {
+          commands[name] = {
+            name,
+            source: "mcp",
+            description: prompt.description,
+            get template() {
+              return Effect.runPromise(
+                mcp
+                  .getPrompt(
+                    prompt.client,
+                    prompt.name,
+                    prompt.arguments
+                      ? Object.fromEntries(prompt.arguments.map((argument, i) => [argument.name, `$${i + 1}`]))
+                      : {},
+                  )
+                  .pipe(
+                    Effect.map(
+                      (template) =>
+                        template?.messages
+                          .map((message) => (message.content.type === "text" ? message.content.text : ""))
+                          .join("\n") || "",
+                    ),
+                  ),
+              )
+            },
+            hints: prompt.arguments?.map((_, i) => `$${i + 1}`) ?? [],
+          }
+        }
+
+        for (const item of yield* skill.all()) {
+          if (commands[item.name]) continue
+          commands[item.name] = {
+            name: item.name,
+            description: item.description,
+            source: "skill",
+            get template() {
+              return item.content
+            },
+            hints: [],
+          }
+        }
+
+        return {
+          commands,
+        }
+      })
+
+      const state = yield* InstanceState.make<State>((ctx) => init(ctx))
+
+      const get = Effect.fn("Command.get")(function* (name: string) {
+        const s = yield* InstanceState.get(state)
+        return s.commands[name]
+      })
+
+      const list = Effect.fn("Command.list")(function* () {
+        const s = yield* InstanceState.get(state)
+        return Object.values(s.commands)
+      })
+
+      return Service.of({ get, list })
+    }),
+  )
+
+  export const defaultLayer = layer.pipe(
+    Layer.provide(Config.defaultLayer),
+    Layer.provide(MCP.defaultLayer),
+    Layer.provide(Skill.defaultLayer),
+  )
+
+  const { runPromise } = makeRuntime(Service, defaultLayer)
+
+  export async function list() {
+    return runPromise((svc) => svc.list())
+  }
+}