@sleepy-ai/cli 0.0.0-main-202607032053 → 0.1.4

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

@@ -0,0 +1,153 @@
+import { Effect, Layer, Redacted, Schema } from "effect"
+import { HttpApiBuilder, HttpApiMiddleware, HttpApiSecurity } from "effect/unstable/httpapi"
+import { HttpRouter, HttpServer, HttpServerRequest } from "effect/unstable/http"
+import { AppRuntime } from "@/effect/app-runtime"
+import { InstanceRef, WorkspaceRef } from "@/effect/instance-ref"
+import { Observability } from "@/effect"
+import { Flag } from "@/flag/flag"
+import { InstanceBootstrap } from "@/project/bootstrap"
+import { Instance } from "@/project/instance"
+import { lazy } from "@/util/lazy"
+import { Filesystem } from "@/util"
+import { ConfigApi, configHandlers } from "./config"
+import { PermissionApi, permissionHandlers } from "./permission"
+import { ProjectApi, projectHandlers } from "./project"
+import { ProviderApi, providerHandlers } from "./provider"
+import { QuestionApi, questionHandlers } from "./question"
+import { memoMap } from "@/effect/memo-map"
+
+const Query = Schema.Struct({
+  directory: Schema.optional(Schema.String),
+  workspace: Schema.optional(Schema.String),
+  auth_token: Schema.optional(Schema.String),
+})
+
+const Headers = Schema.Struct({
+  authorization: Schema.optional(Schema.String),
+  "x-sleepycode-directory": Schema.optional(Schema.String),
+})
+
+function decode(input: string) {
+  try {
+    return decodeURIComponent(input)
+  } catch {
+    return input
+  }
+}
+
+class Unauthorized extends Schema.TaggedErrorClass<Unauthorized>()(
+  "Unauthorized",
+  { message: Schema.String },
+  { httpApiStatus: 401 },
+) {}
+
+class Authorization extends HttpApiMiddleware.Service<Authorization>()("@opencode/ExperimentalHttpApiAuthorization", {
+  error: Unauthorized,
+  security: {
+    basic: HttpApiSecurity.basic,
+  },
+}) {}
+
+const normalize = HttpRouter.middleware()(
+  Effect.gen(function* () {
+    return (effect) =>
+      Effect.gen(function* () {
+        const query = yield* HttpServerRequest.schemaSearchParams(Query)
+        if (!query.auth_token) return yield* effect
+        const req = yield* HttpServerRequest.HttpServerRequest
+        const next = req.modify({
+          headers: {
+            ...req.headers,
+            authorization: `Basic ${query.auth_token}`,
+          },
+        })
+        return yield* effect.pipe(Effect.provideService(HttpServerRequest.HttpServerRequest, next))
+      })
+  }),
+).layer
+
+const auth = Layer.succeed(
+  Authorization,
+  Authorization.of({
+    basic: (effect, { credential }) =>
+      Effect.gen(function* () {
+        if (!Flag.SLEEPYCODE_SERVER_PASSWORD) return yield* effect
+
+        const user = Flag.SLEEPYCODE_SERVER_USERNAME ?? "sleepycode"
+        if (credential.username !== user) {
+          return yield* new Unauthorized({ message: "Unauthorized" })
+        }
+        if (Redacted.value(credential.password) !== Flag.SLEEPYCODE_SERVER_PASSWORD) {
+          return yield* new Unauthorized({ message: "Unauthorized" })
+        }
+        return yield* effect
+      }),
+  }),
+)
+
+class DirectoryAccessDenied extends Schema.TaggedErrorClass<DirectoryAccessDenied>()(
+  "DirectoryAccessDenied",
+  { message: Schema.String },
+  { httpApiStatus: 403 },
+) {}
+
+const instance = HttpRouter.middleware()(
+  Effect.gen(function* () {
+    return (effect) =>
+      Effect.gen(function* () {
+        const query = yield* HttpServerRequest.schemaSearchParams(Query)
+        const headers = yield* HttpServerRequest.schemaHeaders(Headers)
+        const raw = query.directory || headers["x-sleepycode-directory"] || process.cwd()
+        const workspace = query.workspace || undefined
+        const directory = Filesystem.resolve(decode(raw))
+
+        if (!Flag.SLEEPYCODE_SERVER_PASSWORD) {
+          const cwd = Filesystem.resolve(process.cwd())
+          if (!Filesystem.contains(cwd, directory)) {
+            return yield* new DirectoryAccessDenied({
+              message: "Access denied: directory must be within the server's working directory",
+            })
+          }
+        }
+
+        const ctx = yield* Effect.promise(() =>
+          Instance.provide({
+            directory,
+            init: () => AppRuntime.runPromise(InstanceBootstrap),
+            fn: () => Instance.current,
+          }),
+        )
+
+        const next = workspace ? effect.pipe(Effect.provideService(WorkspaceRef, workspace)) : effect
+        return yield* next.pipe(Effect.provideService(InstanceRef, ctx))
+      })
+  }),
+).layer
+
+const QuestionSecured = QuestionApi.middleware(Authorization)
+const PermissionSecured = PermissionApi.middleware(Authorization)
+const ProjectSecured = ProjectApi.middleware(Authorization)
+const ProviderSecured = ProviderApi.middleware(Authorization)
+const ConfigSecured = ConfigApi.middleware(Authorization)
+
+export const routes = Layer.mergeAll(
+  HttpApiBuilder.layer(ConfigSecured).pipe(Layer.provide(configHandlers)),
+  HttpApiBuilder.layer(ProjectSecured).pipe(Layer.provide(projectHandlers)),
+  HttpApiBuilder.layer(QuestionSecured).pipe(Layer.provide(questionHandlers)),
+  HttpApiBuilder.layer(PermissionSecured).pipe(Layer.provide(permissionHandlers)),
+  HttpApiBuilder.layer(ProviderSecured).pipe(Layer.provide(providerHandlers)),
+).pipe(
+  Layer.provide(auth),
+  Layer.provide(normalize),
+  Layer.provide(instance),
+  Layer.provide(HttpServer.layerServices),
+  Layer.provideMerge(Observability.layer),
+)
+
+export const webHandler = lazy(() =>
+  HttpRouter.toWebHandler(routes, {
+    memoMap,
+  }),
+)
+
+export * as ExperimentalHttpApiServer from "./server"

package/src/server/routes/instance/index.ts

@@ -0,0 +1,301 @@
+import { describeRoute, resolver, validator } from "hono-openapi"
+import { Hono } from "hono"
+import type { UpgradeWebSocket } from "hono/ws"
+import { Context, Effect } from "effect"
+import z from "zod"
+import { Format } from "@/format"
+import { TuiRoutes } from "./tui"
+import { Instance } from "@/project/instance"
+import { Vcs } from "@/project"
+import { Agent } from "@/agent/agent"
+import { Skill } from "@/skill"
+import { Global } from "@/global"
+import { LSP } from "@/lsp"
+import { Command } from "@/command"
+import { QuestionRoutes } from "./question"
+import { PermissionRoutes } from "./permission"
+import { WorkflowRoutes } from "./workflows"
+import { BashInteractiveRoutes } from "./bash-interactive"
+import { Flag } from "@/flag/flag"
+import { ExperimentalHttpApiServer } from "./httpapi/server"
+import { ProjectRoutes } from "./project"
+import { SessionRoutes } from "./session"
+import { PtyRoutes } from "./pty"
+import { McpRoutes } from "./mcp"
+import { FileRoutes } from "./file"
+import { ConfigRoutes } from "./config"
+import { ExperimentalRoutes } from "./experimental"
+import { ProviderRoutes } from "./provider"
+import { EventRoutes } from "./event"
+import { SyncRoutes } from "./sync"
+import { InstanceMiddleware } from "./middleware"
+import { jsonRequest } from "./trace"
+
+export const InstanceRoutes = (upgrade: UpgradeWebSocket): Hono => {
+  const app = new Hono()
+
+  if (Flag.SLEEPYCODE_EXPERIMENTAL_HTTPAPI) {
+    const handler = ExperimentalHttpApiServer.webHandler().handler
+    const context = Context.empty() as Context.Context<unknown>
+    app.get("/question", (c) => handler(c.req.raw, context))
+    app.post("/question/:requestID/reply", (c) => handler(c.req.raw, context))
+    app.post("/question/:requestID/reject", (c) => handler(c.req.raw, context))
+    app.get("/permission", (c) => handler(c.req.raw, context))
+    app.post("/permission/:requestID/reply", (c) => handler(c.req.raw, context))
+    app.get("/config/providers", (c) => handler(c.req.raw, context))
+    app.get("/provider", (c) => handler(c.req.raw, context))
+    app.get("/provider/auth", (c) => handler(c.req.raw, context))
+    app.post("/provider/:providerID/oauth/authorize", (c) => handler(c.req.raw, context))
+    app.post("/provider/:providerID/oauth/callback", (c) => handler(c.req.raw, context))
+    app.get("/project", (c) => handler(c.req.raw, context))
+    app.get("/project/current", (c) => handler(c.req.raw, context))
+  }
+
+  return app
+    .route("/project", ProjectRoutes())
+    .route("/pty", PtyRoutes(upgrade))
+    .route("/config", ConfigRoutes())
+    .route("/experimental", ExperimentalRoutes())
+    .route("/session", SessionRoutes())
+    .route("/permission", PermissionRoutes())
+    .route("/workflows", WorkflowRoutes())
+    .route("/question", QuestionRoutes())
+    .route("/bash-interactive", BashInteractiveRoutes())
+    .route("/provider", ProviderRoutes())
+    .route("/sync", SyncRoutes())
+    .route("/", FileRoutes())
+    .route("/", EventRoutes())
+    .route("/mcp", McpRoutes())
+    .route("/tui", TuiRoutes())
+    .post(
+      "/instance/dispose",
+      describeRoute({
+        summary: "Dispose instance",
+        description: "Clean up and dispose the current OpenCode instance, releasing all resources.",
+        operationId: "instance.dispose",
+        responses: {
+          200: {
+            description: "Instance disposed",
+            content: {
+              "application/json": {
+                schema: resolver(z.boolean()),
+              },
+            },
+          },
+        },
+      }),
+      async (c) => {
+        await Instance.dispose()
+        return c.json(true)
+      },
+    )
+    .get(
+      "/path",
+      describeRoute({
+        summary: "Get paths",
+        description: "Retrieve the current working directory and related path information for the OpenCode instance.",
+        operationId: "path.get",
+        responses: {
+          200: {
+            description: "Path",
+            content: {
+              "application/json": {
+                schema: resolver(
+                  z
+                    .object({
+                      home: z.string(),
+                      state: z.string(),
+                      config: z.string(),
+                      worktree: z.string(),
+                      directory: z.string(),
+                    })
+                    .meta({
+                      ref: "Path",
+                    }),
+                ),
+              },
+            },
+          },
+        },
+      }),
+      async (c) => {
+        return c.json({
+          home: Global.Path.home,
+          state: Global.Path.state,
+          config: Global.Path.config,
+          worktree: Instance.worktree,
+          directory: Instance.directory,
+        })
+      },
+    )
+    .get(
+      "/vcs",
+      describeRoute({
+        summary: "Get VCS info",
+        description: "Retrieve version control system (VCS) information for the current project, such as git branch.",
+        operationId: "vcs.get",
+        responses: {
+          200: {
+            description: "VCS info",
+            content: {
+              "application/json": {
+                schema: resolver(Vcs.Info),
+              },
+            },
+          },
+        },
+      }),
+      async (c) =>
+        jsonRequest("InstanceRoutes.vcs.get", c, function* () {
+          const vcs = yield* Vcs.Service
+          const [branch, default_branch] = yield* Effect.all([vcs.branch(), vcs.defaultBranch()], {
+            concurrency: 2,
+          })
+          return { branch, default_branch }
+        }),
+    )
+    .get(
+      "/vcs/diff",
+      describeRoute({
+        summary: "Get VCS diff",
+        description: "Retrieve the current git diff for the working tree or against the default branch.",
+        operationId: "vcs.diff",
+        responses: {
+          200: {
+            description: "VCS diff",
+            content: {
+              "application/json": {
+                schema: resolver(Vcs.FileDiff.array()),
+              },
+            },
+          },
+        },
+      }),
+      validator(
+        "query",
+        z.object({
+          mode: Vcs.Mode,
+        }),
+      ),
+      async (c) =>
+        jsonRequest("InstanceRoutes.vcs.diff", c, function* () {
+          const vcs = yield* Vcs.Service
+          return yield* vcs.diff(c.req.valid("query").mode)
+        }),
+    )
+    .get(
+      "/command",
+      describeRoute({
+        summary: "List commands",
+        description: "Get a list of all available commands in the OpenCode system.",
+        operationId: "command.list",
+        responses: {
+          200: {
+            description: "List of commands",
+            content: {
+              "application/json": {
+                schema: resolver(Command.Info.array()),
+              },
+            },
+          },
+        },
+      }),
+      async (c) =>
+        jsonRequest("InstanceRoutes.command.list", c, function* () {
+          const svc = yield* Command.Service
+          return yield* svc.list()
+        }),
+    )
+    .get(
+      "/agent",
+      describeRoute({
+        summary: "List agents",
+        description: "Get a list of all available AI agents in the OpenCode system.",
+        operationId: "app.agents",
+        responses: {
+          200: {
+            description: "List of agents",
+            content: {
+              "application/json": {
+                schema: resolver(Agent.Info.array()),
+              },
+            },
+          },
+        },
+      }),
+      async (c) =>
+        jsonRequest("InstanceRoutes.agent.list", c, function* () {
+          const svc = yield* Agent.Service
+          return yield* svc.list()
+        }),
+    )
+    .get(
+      "/skill",
+      describeRoute({
+        summary: "List skills",
+        description: "Get a list of all available skills in the OpenCode system.",
+        operationId: "app.skills",
+        responses: {
+          200: {
+            description: "List of skills",
+            content: {
+              "application/json": {
+                schema: resolver(Skill.Info.array()),
+              },
+            },
+          },
+        },
+      }),
+      async (c) =>
+        jsonRequest("InstanceRoutes.skill.list", c, function* () {
+          const skill = yield* Skill.Service
+          return yield* skill.all()
+        }),
+    )
+    .get(
+      "/lsp",
+      describeRoute({
+        summary: "Get LSP status",
+        description: "Get LSP server status",
+        operationId: "lsp.status",
+        responses: {
+          200: {
+            description: "LSP server status",
+            content: {
+              "application/json": {
+                schema: resolver(LSP.Status.array()),
+              },
+            },
+          },
+        },
+      }),
+      async (c) =>
+        jsonRequest("InstanceRoutes.lsp.status", c, function* () {
+          const lsp = yield* LSP.Service
+          return yield* lsp.status()
+        }),
+    )
+    .get(
+      "/formatter",
+      describeRoute({
+        summary: "Get formatter status",
+        description: "Get formatter status",
+        operationId: "formatter.status",
+        responses: {
+          200: {
+            description: "Formatter status",
+            content: {
+              "application/json": {
+                schema: resolver(Format.Status.array()),
+              },
+            },
+          },
+        },
+      }),
+      async (c) =>
+        jsonRequest("InstanceRoutes.formatter.status", c, function* () {
+          const svc = yield* Format.Service
+          return yield* svc.status()
+        }),
+    )
+}