rimuru-ai 1.19.0

package/src/server/routes/instance/httpapi/handlers/experimental.ts

@@ -0,0 +1,187 @@
+import { Account } from "@/account/account"
+import { Agent } from "@/agent/agent"
+import { BackgroundJob } from "@/background/job"
+import { Config } from "@/config/config"
+import { InstanceState } from "@/effect/instance-state"
+import { RuntimeFlags } from "@/effect/runtime-flags"
+import { MCP } from "@/mcp"
+import { Project } from "@/project/project"
+import { Session } from "@/session/session"
+import type { SessionID } from "@/session/schema"
+import { ToolJsonSchema } from "@/tool/json-schema"
+import { ToolRegistry } from "@/tool/registry"
+import { Worktree } from "@/worktree"
+import { Effect, Option } from "effect"
+import * as HttpServerResponse from "effect/unstable/http/HttpServerResponse"
+import { HttpApiBuilder, HttpApiError } from "effect/unstable/httpapi"
+import { InstanceHttpApi } from "../api"
+import { ConsoleSwitchPayload, SessionListQuery, ToolListQuery, WorktreeApiError } from "../groups/experimental"
+
+function mapWorktreeError<A, R>(self: Effect.Effect<A, Worktree.Error, R>) {
+  return self.pipe(
+    Effect.mapError((error) => new WorktreeApiError({ name: error._tag, data: { message: error.message } })),
+  )
+}
+
+export const experimentalHandlers = HttpApiBuilder.group(InstanceHttpApi, "experimental", (handlers) =>
+  Effect.gen(function* () {
+    const account = yield* Account.Service
+    const agents = yield* Agent.Service
+    const config = yield* Config.Service
+    const mcp = yield* MCP.Service
+    const project = yield* Project.Service
+    const registry = yield* ToolRegistry.Service
+    const worktreeSvc = yield* Worktree.Service
+    const sessions = yield* Session.Service
+    const background = yield* BackgroundJob.Service
+    const flags = yield* RuntimeFlags.Service
+
+    const getConsole = Effect.fn("ExperimentalHttpApi.console")(function* () {
+      const [state, groups] = yield* Effect.all(
+        [
+          config.getConsoleState(),
+          account.orgsByAccount().pipe(Effect.catch(() => Effect.fail(new HttpApiError.InternalServerError({})))),
+        ],
+        {
+          concurrency: "unbounded",
+        },
+      )
+      return {
+        consoleManagedProviders: state.consoleManagedProviders,
+        ...(state.activeOrgName ? { activeOrgName: state.activeOrgName } : {}),
+        switchableOrgCount: groups.reduce((count, group) => count + group.orgs.length, 0),
+      }
+    })
+
+    const listConsoleOrgs = Effect.fn("ExperimentalHttpApi.consoleOrgs")(function* () {
+      const [groups, active] = yield* Effect.all(
+        [
+          account.orgsByAccount().pipe(Effect.catch(() => Effect.fail(new HttpApiError.InternalServerError({})))),
+          account.active().pipe(Effect.catch(() => Effect.fail(new HttpApiError.InternalServerError({})))),
+        ],
+        {
+          concurrency: "unbounded",
+        },
+      )
+      const info = Option.getOrUndefined(active)
+      return {
+        orgs: groups.flatMap((group) =>
+          group.orgs.map((org) => ({
+            accountID: group.account.id,
+            accountEmail: group.account.email,
+            accountUrl: group.account.url,
+            orgID: org.id,
+            orgName: org.name,
+            active: !!info && info.id === group.account.id && info.active_org_id === org.id,
+          })),
+        ),
+      }
+    })
+
+    const switchConsole = Effect.fn("ExperimentalHttpApi.consoleSwitch")(function* (ctx: {
+      payload: typeof ConsoleSwitchPayload.Type
+    }) {
+      yield* account
+        .use(ctx.payload.accountID, Option.some(ctx.payload.orgID))
+        .pipe(Effect.catch(() => Effect.fail(new HttpApiError.BadRequest({}))))
+      return true
+    })
+
+    const tool = Effect.fn("ExperimentalHttpApi.tool")(function* (ctx: { query: typeof ToolListQuery.Type }) {
+      const list = yield* registry.tools({
+        providerID: ctx.query.provider,
+        modelID: ctx.query.model,
+        agent: yield* agents.defaultInfo(),
+      })
+      return list.map((item) => ({
+        id: item.id,
+        description: item.description,
+        parameters: ToolJsonSchema.fromTool(item),
+      }))
+    })
+
+    const toolIDs = Effect.fn("ExperimentalHttpApi.toolIDs")(function* () {
+      return yield* registry.ids()
+    })
+
+    const worktree = Effect.fn("ExperimentalHttpApi.worktree")(function* () {
+      const ctx = yield* InstanceState.context
+      return yield* project.sandboxes(ctx.project.id)
+    })
+
+    const worktreeCreate = Effect.fn("ExperimentalHttpApi.worktreeCreate")(function* (ctx: {
+      payload: typeof Worktree.CreateInput.Type | void
+    }) {
+      return yield* mapWorktreeError(worktreeSvc.create(ctx.payload ?? undefined))
+    })
+
+    const worktreeRemove = Effect.fn("ExperimentalHttpApi.worktreeRemove")(function* (input: {
+      payload: Worktree.RemoveInput
+    }) {
+      const ctx = yield* InstanceState.context
+      yield* mapWorktreeError(worktreeSvc.remove(input.payload))
+      yield* project.removeSandbox(ctx.project.id, input.payload.directory)
+      return true
+    })
+
+    const worktreeReset = Effect.fn("ExperimentalHttpApi.worktreeReset")(function* (ctx: {
+      payload: Worktree.ResetInput
+    }) {
+      yield* mapWorktreeError(worktreeSvc.reset(ctx.payload))
+      return true
+    })
+
+    const session = Effect.fn("ExperimentalHttpApi.session")(function* (ctx: { query: typeof SessionListQuery.Type }) {
+      const limit = ctx.query.limit ?? 100
+      const all = yield* sessions.listGlobal({
+        directory: ctx.query.directory,
+        roots: ctx.query.roots,
+        start: ctx.query.start,
+        cursor: ctx.query.cursor,
+        search: ctx.query.search,
+        limit: limit + 1,
+        archived: ctx.query.archived,
+      })
+      const list = all.length > limit ? all.slice(0, limit) : all
+      return HttpServerResponse.jsonUnsafe(list, {
+        headers:
+          all.length > limit && list.length > 0
+            ? { "x-next-cursor": String(list[list.length - 1].time.updated) }
+            : undefined,
+      })
+    })
+
+    const sessionBackground = Effect.fn("ExperimentalHttpApi.sessionBackground")(function* (ctx: {
+      params: { sessionID: SessionID }
+    }) {
+      if (!flags.experimentalBackgroundSubagents) return false
+      const jobs = (yield* background.list()).filter(
+        (job) =>
+          job.type === "task" &&
+          job.status === "running" &&
+          job.metadata?.parentSessionId === ctx.params.sessionID &&
+          job.metadata.background !== true,
+      )
+      const promoted = yield* Effect.forEach(jobs, (job) => background.promote(job.id), { concurrency: "unbounded" })
+      return promoted.some((job) => job !== undefined)
+    })
+
+    const resource = Effect.fn("ExperimentalHttpApi.resource")(function* () {
+      return yield* mcp.resources()
+    })
+
+    return handlers
+      .handle("console", getConsole)
+      .handle("consoleOrgs", listConsoleOrgs)
+      .handle("consoleSwitch", switchConsole)
+      .handle("tool", tool)
+      .handle("toolIDs", toolIDs)
+      .handle("worktree", worktree)
+      .handle("worktreeCreate", worktreeCreate)
+      .handle("worktreeRemove", worktreeRemove)
+      .handle("worktreeReset", worktreeReset)
+      .handle("session", session)
+      .handle("sessionBackground", sessionBackground)
+      .handle("resource", resource)
+  }),
+)

package/src/server/routes/instance/httpapi/handlers/file.ts

@@ -0,0 +1,139 @@
+import * as InstanceState from "@/effect/instance-state"
+import { FileSystem } from "@rimurucode-ai/core/filesystem"
+import { LocationServiceMap } from "@rimurucode-ai/core/location-layer"
+import { Ripgrep } from "@rimurucode-ai/core/ripgrep"
+import { FSUtil } from "@rimurucode-ai/core/fs-util"
+import { Location } from "@rimurucode-ai/core/location"
+import { AbsolutePath, RelativePath } from "@rimurucode-ai/core/schema"
+import { Effect, Layer, Option } from "effect"
+import ignore from "ignore"
+import path from "path"
+import { HttpApiBuilder } from "effect/unstable/httpapi"
+import { InstanceHttpApi } from "../api"
+
+export const fileHandlers = HttpApiBuilder.group(InstanceHttpApi, "file", (handlers) =>
+  Effect.gen(function* () {
+    const ripgrep = yield* Ripgrep.Service
+    const locations = yield* LocationServiceMap
+
+    const filesystem = Effect.fnUntraced(function* <A, E, R>(effect: Effect.Effect<A, E, R>) {
+      return yield* effect.pipe(
+        Effect.provide(
+          locations.get(Location.Ref.make({ directory: AbsolutePath.make((yield* InstanceState.context).directory) })),
+        ),
+      )
+    })
+
+    const findText = Effect.fn("FileHttpApi.findText")(function* (ctx: { query: { pattern: string } }) {
+      return (yield* ripgrep
+        .grep({ cwd: (yield* InstanceState.context).directory, pattern: ctx.query.pattern, limit: 10 })
+        .pipe(Effect.orDie)).map((match) => ({
+        path: { text: match.entry.path },
+        lines: { text: match.text },
+        line_number: match.line,
+        absolute_offset: match.offset,
+        submatches: match.submatches.map((submatch) => ({
+          match: { text: submatch.text },
+          start: submatch.start,
+          end: submatch.end,
+        })),
+      }))
+    })
+
+    const findFile = Effect.fn("FileHttpApi.findFile")(function* (ctx: {
+      query: { query: string; dirs?: "true" | "false"; type?: "file" | "directory"; limit?: number }
+    }) {
+      const directory = (yield* InstanceState.context).directory
+      const limit = ctx.query.limit ?? 10
+      const type = ctx.query.type ?? (ctx.query.dirs === "false" ? "file" : undefined)
+      const started = performance.now()
+      const found = yield* filesystem(FileSystem.Service.use((fs) => fs.find({ query: ctx.query.query, limit, type })))
+      yield* Effect.logInfo("find file", {
+        query: ctx.query.query,
+        type,
+        directory,
+        limit,
+        results: found.length,
+        duration: Math.round(performance.now() - started),
+      })
+      return found.map((item) => item.path)
+    })
+
+    const findSymbol = Effect.fn("FileHttpApi.findSymbol")(function* () {
+      return []
+    })
+
+    const list = Effect.fn("FileHttpApi.list")(function* (ctx: { query: { path: string } }) {
+      const directory = (yield* InstanceState.context).directory
+      return yield* filesystem(
+        Effect.gen(function* () {
+          const fs = yield* FileSystem.Service
+          const raw = yield* FSUtil.Service
+          const location = yield* Location.Service
+          const ignored = ignore()
+          const gitignore = yield* raw
+            .readFileString(path.join(location.project.directory, ".gitignore"))
+            .pipe(Effect.catch(() => Effect.succeed("")))
+          if (gitignore) ignored.add(gitignore)
+          const ignorefile = yield* raw
+            .readFileString(path.join(location.project.directory, ".ignore"))
+            .pipe(Effect.catch(() => Effect.succeed("")))
+          if (ignorefile) ignored.add(ignorefile)
+          return (yield* fs.list({ path: RelativePath.make(ctx.query.path) })).map((item) => ({
+            name: path.basename(item.path),
+            path: item.path,
+            absolute: path.resolve(location.directory, item.path),
+            type: item.type,
+            ignored: ignored.ignores(
+              path.relative(location.project.directory, path.resolve(location.directory, item.path)) +
+                (item.type === "directory" ? "/" : ""),
+            ),
+          }))
+        }),
+      )
+    })
+
+    const content = Effect.fn("FileHttpApi.content")(function* (ctx: { query: { path: string } }) {
+      const directory = (yield* InstanceState.context).directory
+      const file = path.resolve(directory, ctx.query.path)
+      if (!FSUtil.contains(directory, file)) return yield* Effect.die(new Error("Path escapes the location"))
+      if (!(yield* FSUtil.Service.use((fs) => fs.existsSafe(file)))) return { type: "text" as const, content: "" }
+      return yield* filesystem(
+        FileSystem.Service.use((fs) => fs.read({ path: RelativePath.make(ctx.query.path) })),
+      ).pipe(
+        Effect.flatMap((item) =>
+          Effect.gen(function* () {
+            const text = item.content.includes(0)
+              ? Option.none<string>()
+              : yield* Effect.sync(() => new TextDecoder("utf-8", { fatal: true }).decode(item.content)).pipe(
+                  Effect.option,
+                )
+            return { item, text }
+          }),
+        ),
+        Effect.map(({ item, text }) =>
+          Option.isSome(text)
+            ? { type: "text" as const, content: text.value.trim() }
+            : {
+                type: "binary" as const,
+                content: Buffer.from(item.content).toString("base64"),
+                encoding: "base64" as const,
+                mimeType: item.mime,
+              },
+        ),
+      )
+    })
+
+    const status = Effect.fn("FileHttpApi.status")(function* () {
+      return []
+    })
+
+    return handlers
+      .handle("findText", findText)
+      .handle("findFile", findFile)
+      .handle("findSymbol", findSymbol)
+      .handle("list", list)
+      .handle("content", content)
+      .handle("status", status)
+  }),
+).pipe(Layer.provide(LocationServiceMap.layer))

package/src/server/routes/instance/httpapi/handlers/global.ts

@@ -0,0 +1,156 @@
+import { Config } from "@/config/config"
+import { GlobalBus, type GlobalEvent as GlobalBusEvent } from "@/bus/global"
+import { EffectBridge } from "@/effect/bridge"
+import { EventV2 } from "@rimurucode-ai/core/event"
+import { Installation } from "@/installation"
+import { disposeAllInstancesAndEmitGlobalDisposed } from "@/server/global-lifecycle"
+import { InstallationVersion } from "@rimurucode-ai/core/installation/version"
+import { Effect, Queue, Schema } from "effect"
+import * as Stream from "effect/Stream"
+import { HttpServerRequest, HttpServerResponse } from "effect/unstable/http"
+import { HttpApiBuilder } from "effect/unstable/httpapi"
+import * as Sse from "effect/unstable/encoding/Sse"
+import { RootHttpApi } from "../api"
+import { GlobalUpgradeInput } from "../groups/global"
+
+function eventData(data: unknown): Sse.Event {
+  return {
+    _tag: "Event",
+    event: "message",
+    id: undefined,
+    data: JSON.stringify(data),
+  }
+}
+
+function parseBody(body: string) {
+  try {
+    return JSON.parse(body || "{}") as unknown
+  } catch {
+    return undefined
+  }
+}
+
+function eventResponse() {
+  return Effect.gen(function* () {
+    yield* Effect.logInfo("global event connected")
+    const events = Stream.callback<GlobalBusEvent>((queue) => {
+      const handler = (event: GlobalBusEvent) => Queue.offerUnsafe(queue, event)
+      return Effect.acquireRelease(
+        Effect.sync(() => GlobalBus.on("event", handler)),
+        () => Effect.sync(() => GlobalBus.off("event", handler)),
+      )
+    })
+    const heartbeat = Stream.tick("10 seconds").pipe(
+      Stream.drop(1),
+      Stream.map(() => ({ payload: { id: EventV2.ID.create(), type: "server.heartbeat", properties: {} } })),
+    )
+
+    return HttpServerResponse.stream(
+      Stream.make({ payload: { id: EventV2.ID.create(), type: "server.connected", properties: {} } }).pipe(
+        Stream.concat(events.pipe(Stream.merge(heartbeat, { haltStrategy: "left" }))),
+        Stream.map(eventData),
+        Stream.pipeThroughChannel(Sse.encode()),
+        Stream.encodeText,
+        Stream.ensuring(Effect.logInfo("global event disconnected")),
+      ),
+      {
+        contentType: "text/event-stream",
+        headers: {
+          "Cache-Control": "no-cache, no-transform",
+          "X-Accel-Buffering": "no",
+          "X-Content-Type-Options": "nosniff",
+        },
+      },
+    )
+  })
+}
+
+export const globalHandlers = HttpApiBuilder.group(RootHttpApi, "global", (handlers) =>
+  Effect.gen(function* () {
+    const config = yield* Config.Service
+    const installation = yield* Installation.Service
+    const bridge = yield* EffectBridge.make()
+
+    const health = Effect.fn("GlobalHttpApi.health")(function* () {
+      return { healthy: true as const, version: InstallationVersion }
+    })
+
+    const event = Effect.fn("GlobalHttpApi.event")(function* () {
+      return yield* eventResponse()
+    })
+
+    const configGet = Effect.fn("GlobalHttpApi.configGet")(function* () {
+      return yield* config.getGlobal()
+    })
+
+    const configUpdate = Effect.fn("GlobalHttpApi.configUpdate")(function* (ctx) {
+      const result = yield* config.updateGlobal(ctx.payload)
+      if (result.changed) bridge.fork(disposeAllInstancesAndEmitGlobalDisposed({ swallowErrors: true }))
+      return result.info
+    })
+
+    const dispose = Effect.fn("GlobalHttpApi.dispose")(function* () {
+      yield* disposeAllInstancesAndEmitGlobalDisposed()
+      return true
+    })
+
+    const upgrade = Effect.fn("GlobalHttpApi.upgrade")(function* (ctx: { payload: typeof GlobalUpgradeInput.Type }) {
+      const method = yield* installation.method()
+      if (method === "unknown") {
+        return {
+          status: 400,
+          body: { success: false as const, error: "Unknown installation method" },
+        }
+      }
+      const target = ctx.payload.target || (yield* installation.latest(method))
+      const result = yield* installation.upgrade(method, target).pipe(
+        Effect.as({ status: 200, body: { success: true as const, version: target } }),
+        Effect.catch((err) =>
+          Effect.succeed({
+            status: 500,
+            body: {
+              success: false as const,
+              error: err instanceof Error ? err.message : String(err),
+            },
+          }),
+        ),
+      )
+      if (!result.body.success) return result
+      GlobalBus.emit("event", {
+        directory: "global",
+        payload: {
+          type: Installation.Event.Updated.type,
+          properties: { version: target },
+        },
+      })
+      return result
+    })
+
+    const upgradeRaw = Effect.fn("GlobalHttpApi.upgradeRaw")(function* (ctx: {
+      request: HttpServerRequest.HttpServerRequest
+    }) {
+      const body = yield* Effect.orDie(ctx.request.text)
+      const json = parseBody(body)
+      if (json === undefined) {
+        return HttpServerResponse.jsonUnsafe({ success: false, error: "Invalid request body" }, { status: 400 })
+      }
+      const payload = yield* Schema.decodeUnknownEffect(GlobalUpgradeInput)(json).pipe(
+        Effect.map((payload) => ({ valid: true as const, payload })),
+        Effect.catch(() => Effect.succeed({ valid: false as const })),
+      )
+      if (!payload.valid) {
+        return HttpServerResponse.jsonUnsafe({ success: false, error: "Invalid request body" }, { status: 400 })
+      }
+      const result = yield* upgrade({ payload: payload.payload })
+      return HttpServerResponse.jsonUnsafe(result.body, { status: result.status })
+    })
+
+    return handlers
+      .handle("health", health)
+      .handleRaw("event", event)
+      .handle("configGet", configGet)
+      .handle("configUpdate", configUpdate)
+      .handle("dispose", dispose)
+      .handleRaw("upgrade", upgradeRaw)
+  }),
+)

package/src/server/routes/instance/httpapi/handlers/instance.ts

@@ -0,0 +1,110 @@
+import { Agent } from "@/agent/agent"
+import { Command } from "@/command"
+import * as InstanceState from "@/effect/instance-state"
+import { Format } from "@/format"
+import { Global } from "@rimurucode-ai/core/global"
+import { LSP } from "@/lsp/lsp"
+import { Vcs } from "@/project/vcs"
+import { Skill } from "@/skill"
+import { Effect } from "effect"
+import { HttpApiBuilder } from "effect/unstable/httpapi"
+import { InstanceHttpApi } from "../api"
+import { ApiVcsApplyError } from "../groups/instance"
+import { markInstanceForDisposal } from "../lifecycle"
+
+export const instanceHandlers = HttpApiBuilder.group(InstanceHttpApi, "instance", (handlers) =>
+  Effect.gen(function* () {
+    const agent = yield* Agent.Service
+    const command = yield* Command.Service
+    const format = yield* Format.Service
+    const lsp = yield* LSP.Service
+    const skill = yield* Skill.Service
+    const vcs = yield* Vcs.Service
+
+    const dispose = Effect.fn("InstanceHttpApi.dispose")(function* () {
+      yield* markInstanceForDisposal(yield* InstanceState.context)
+      return true
+    })
+
+    const getPath = Effect.fn("InstanceHttpApi.path")(function* () {
+      const ctx = yield* InstanceState.context
+      return {
+        home: Global.Path.home,
+        state: Global.Path.state,
+        config: Global.Path.config,
+        worktree: ctx.worktree,
+        directory: ctx.directory,
+      }
+    })
+
+    const getVcs = Effect.fn("InstanceHttpApi.vcs")(function* () {
+      const [branch, default_branch] = yield* Effect.all([vcs.branch(), vcs.defaultBranch()], {
+        concurrency: "unbounded",
+      })
+      return { branch, default_branch }
+    })
+
+    const getVcsStatus = Effect.fn("InstanceHttpApi.vcsStatus")(function* () {
+      return yield* vcs.status()
+    })
+
+    const getVcsDiff = Effect.fn("InstanceHttpApi.vcsDiff")(function* (ctx: {
+      query: { mode: Vcs.Mode; context?: number }
+    }) {
+      return yield* vcs.diff(ctx.query.mode, { context: ctx.query.context })
+    })
+
+    const getVcsDiffRaw = Effect.fn("InstanceHttpApi.vcsDiffRaw")(function* () {
+      return yield* vcs.diffRaw()
+    })
+
+    const applyVcs = Effect.fn("InstanceHttpApi.vcsApply")(function* (ctx: { payload: Vcs.ApplyInput }) {
+      return yield* vcs.apply(ctx.payload).pipe(
+        Effect.mapError(
+          (error) =>
+            new ApiVcsApplyError({
+              name: "VcsApplyError",
+              data: {
+                message: error.message,
+                reason: error.reason,
+              },
+            }),
+        ),
+      )
+    })
+
+    const getCommand = Effect.fn("InstanceHttpApi.command")(function* () {
+      return yield* command.list()
+    })
+
+    const getAgent = Effect.fn("InstanceHttpApi.agent")(function* () {
+      return yield* agent.list()
+    })
+
+    const getSkill = Effect.fn("InstanceHttpApi.skill")(function* () {
+      return yield* skill.all()
+    })
+
+    const getLsp = Effect.fn("InstanceHttpApi.lsp")(function* () {
+      return yield* lsp.status()
+    })
+
+    const getFormatter = Effect.fn("InstanceHttpApi.formatter")(function* () {
+      return yield* format.status()
+    })
+
+    return handlers
+      .handle("dispose", dispose)
+      .handle("path", getPath)
+      .handle("vcs", getVcs)
+      .handle("vcsStatus", getVcsStatus)
+      .handle("vcsDiff", getVcsDiff)
+      .handle("vcsDiffRaw", getVcsDiffRaw)
+      .handle("vcsApply", applyVcs)
+      .handle("command", getCommand)
+      .handle("agent", getAgent)
+      .handle("skill", getSkill)
+      .handle("lsp", getLsp)
+      .handle("formatter", getFormatter)
+  }),
+)