@sleepy-ai/cli 0.1.16 → 0.1.17

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

@@ -1,260 +0,0 @@
-import { Hono } from "hono"
-import { describeRoute, validator, resolver } from "hono-openapi"
-import z from "zod"
-import { MCP } from "@/mcp"
-import { ConfigMCP } from "@/config/mcp"
-import { errors } from "../../error"
-import { lazy } from "@/util/lazy"
-import { Effect } from "effect"
-import { jsonRequest, runRequest } from "./trace"
-
-export const McpRoutes = lazy(() =>
-  new Hono()
-    .get(
-      "/",
-      describeRoute({
-        summary: "Get MCP status",
-        description: "Get the status of all Model Context Protocol (MCP) servers.",
-        operationId: "mcp.status",
-        responses: {
-          200: {
-            description: "MCP server status",
-            content: {
-              "application/json": {
-                schema: resolver(z.record(z.string(), MCP.Status)),
-              },
-            },
-          },
-        },
-      }),
-      async (c) =>
-        jsonRequest("McpRoutes.status", c, function* () {
-          const mcp = yield* MCP.Service
-          return yield* mcp.status()
-        }),
-    )
-    .post(
-      "/",
-      describeRoute({
-        summary: "Add MCP server",
-        description: "Dynamically add a new Model Context Protocol (MCP) server to the system.",
-        operationId: "mcp.add",
-        responses: {
-          200: {
-            description: "MCP server added successfully",
-            content: {
-              "application/json": {
-                schema: resolver(z.record(z.string(), MCP.Status)),
-              },
-            },
-          },
-          ...errors(400),
-        },
-      }),
-      validator(
-        "json",
-        z.object({
-          name: z.string(),
-          config: ConfigMCP.Info.zod,
-        }),
-      ),
-      async (c) =>
-        jsonRequest("McpRoutes.add", c, function* () {
-          const { name, config } = c.req.valid("json")
-          const mcp = yield* MCP.Service
-          const result = yield* mcp.add(name, config)
-          return result.status
-        }),
-    )
-    .post(
-      "/:name/auth",
-      describeRoute({
-        summary: "Start MCP OAuth",
-        description: "Start OAuth authentication flow for a Model Context Protocol (MCP) server.",
-        operationId: "mcp.auth.start",
-        responses: {
-          200: {
-            description: "OAuth flow started",
-            content: {
-              "application/json": {
-                schema: resolver(
-                  z.object({
-                    authorizationUrl: z.string().describe("URL to open in browser for authorization"),
-                  }),
-                ),
-              },
-            },
-          },
-          ...errors(400, 404),
-        },
-      }),
-      async (c) => {
-        const name = c.req.param("name")
-        const result = await runRequest(
-          "McpRoutes.auth.start",
-          c,
-          Effect.gen(function* () {
-            const mcp = yield* MCP.Service
-            const supports = yield* mcp.supportsOAuth(name)
-            if (!supports) return { supports }
-            return {
-              supports,
-              auth: yield* mcp.startAuth(name),
-            }
-          }),
-        )
-        if (!result.supports) {
-          return c.json({ error: `MCP server ${name} does not support OAuth` }, 400)
-        }
-        return c.json(result.auth)
-      },
-    )
-    .post(
-      "/:name/auth/callback",
-      describeRoute({
-        summary: "Complete MCP OAuth",
-        description:
-          "Complete OAuth authentication for a Model Context Protocol (MCP) server using the authorization code.",
-        operationId: "mcp.auth.callback",
-        responses: {
-          200: {
-            description: "OAuth authentication completed",
-            content: {
-              "application/json": {
-                schema: resolver(MCP.Status),
-              },
-            },
-          },
-          ...errors(400, 404),
-        },
-      }),
-      validator(
-        "json",
-        z.object({
-          code: z.string().describe("Authorization code from OAuth callback"),
-        }),
-      ),
-      async (c) =>
-        jsonRequest("McpRoutes.auth.callback", c, function* () {
-          const name = c.req.param("name")
-          const { code } = c.req.valid("json")
-          const mcp = yield* MCP.Service
-          return yield* mcp.finishAuth(name, code)
-        }),
-    )
-    .post(
-      "/:name/auth/authenticate",
-      describeRoute({
-        summary: "Authenticate MCP OAuth",
-        description: "Start OAuth flow and wait for callback (opens browser)",
-        operationId: "mcp.auth.authenticate",
-        responses: {
-          200: {
-            description: "OAuth authentication completed",
-            content: {
-              "application/json": {
-                schema: resolver(MCP.Status),
-              },
-            },
-          },
-          ...errors(400, 404),
-        },
-      }),
-      async (c) => {
-        const name = c.req.param("name")
-        const result = await runRequest(
-          "McpRoutes.auth.authenticate",
-          c,
-          Effect.gen(function* () {
-            const mcp = yield* MCP.Service
-            const supports = yield* mcp.supportsOAuth(name)
-            if (!supports) return { supports }
-            return {
-              supports,
-              status: yield* mcp.authenticate(name),
-            }
-          }),
-        )
-        if (!result.supports) {
-          return c.json({ error: `MCP server ${name} does not support OAuth` }, 400)
-        }
-        return c.json(result.status)
-      },
-    )
-    .delete(
-      "/:name/auth",
-      describeRoute({
-        summary: "Remove MCP OAuth",
-        description: "Remove OAuth credentials for an MCP server",
-        operationId: "mcp.auth.remove",
-        responses: {
-          200: {
-            description: "OAuth credentials removed",
-            content: {
-              "application/json": {
-                schema: resolver(z.object({ success: z.literal(true) })),
-              },
-            },
-          },
-          ...errors(404),
-        },
-      }),
-      async (c) =>
-        jsonRequest("McpRoutes.auth.remove", c, function* () {
-          const name = c.req.param("name")
-          const mcp = yield* MCP.Service
-          yield* mcp.removeAuth(name)
-          return { success: true as const }
-        }),
-    )
-    .post(
-      "/:name/connect",
-      describeRoute({
-        description: "Connect an MCP server",
-        operationId: "mcp.connect",
-        responses: {
-          200: {
-            description: "MCP server connected successfully",
-            content: {
-              "application/json": {
-                schema: resolver(z.boolean()),
-              },
-            },
-          },
-        },
-      }),
-      validator("param", z.object({ name: z.string() })),
-      async (c) =>
-        jsonRequest("McpRoutes.connect", c, function* () {
-          const { name } = c.req.valid("param")
-          const mcp = yield* MCP.Service
-          yield* mcp.connect(name)
-          return true
-        }),
-    )
-    .post(
-      "/:name/disconnect",
-      describeRoute({
-        description: "Disconnect an MCP server",
-        operationId: "mcp.disconnect",
-        responses: {
-          200: {
-            description: "MCP server disconnected successfully",
-            content: {
-              "application/json": {
-                schema: resolver(z.boolean()),
-              },
-            },
-          },
-        },
-      }),
-      validator("param", z.object({ name: z.string() })),
-      async (c) =>
-        jsonRequest("McpRoutes.disconnect", c, function* () {
-          const { name } = c.req.valid("param")
-          const mcp = yield* MCP.Service
-          yield* mcp.disconnect(name)
-          return true
-        }),
-    ),
-)

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

@@ -1,44 +0,0 @@
-import type { MiddlewareHandler } from "hono"
-import { Instance } from "@/project/instance"
-import { InstanceBootstrap } from "@/project/bootstrap"
-import { AppRuntime } from "@/effect/app-runtime"
-import { AppFileSystem } from "@sleepy-ai/shared/filesystem"
-import { WorkspaceContext } from "@/control-plane/workspace-context"
-import { WorkspaceID } from "@/control-plane/schema"
-import { Flag } from "@/flag/flag"
-import { Filesystem } from "@/util"
-
-export function InstanceMiddleware(workspaceID?: WorkspaceID): MiddlewareHandler {
-  return async (c, next) => {
-    const raw = c.req.query("directory") || c.req.header("x-sleepycode-directory") || process.cwd()
-    const directory = AppFileSystem.resolve(
-      (() => {
-        try {
-          return decodeURIComponent(raw)
-        } catch {
-          return raw
-        }
-      })(),
-    )
-
-    if (!Flag.SLEEPYCODE_SERVER_PASSWORD) {
-      const cwd = Filesystem.resolve(process.cwd())
-      if (!Filesystem.contains(cwd, directory)) {
-        return c.json({ error: "Access denied: directory must be within the server's working directory" }, 403)
-      }
-    }
-
-    return WorkspaceContext.provide({
-      workspaceID,
-      async fn() {
-        return Instance.provide({
-          directory,
-          init: () => AppRuntime.runPromise(InstanceBootstrap),
-          async fn() {
-            return next()
-          },
-        })
-      },
-    })
-  }
-}

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

@@ -1,73 +0,0 @@
-import { Hono } from "hono"
-import { describeRoute, validator, resolver } from "hono-openapi"
-import z from "zod"
-import { Permission } from "@/permission"
-import { PermissionID } from "@/permission/schema"
-import { errors } from "../../error"
-import { lazy } from "@/util/lazy"
-import { jsonRequest } from "./trace"
-
-export const PermissionRoutes = lazy(() =>
-  new Hono()
-    .post(
-      "/:requestID/reply",
-      describeRoute({
-        summary: "Respond to permission request",
-        description: "Approve or deny a permission request from the AI assistant.",
-        operationId: "permission.reply",
-        responses: {
-          200: {
-            description: "Permission processed successfully",
-            content: {
-              "application/json": {
-                schema: resolver(z.boolean()),
-              },
-            },
-          },
-          ...errors(400, 404),
-        },
-      }),
-      validator(
-        "param",
-        z.object({
-          requestID: PermissionID.zod,
-        }),
-      ),
-      validator("json", z.object({ reply: Permission.Reply.zod, message: z.string().optional() })),
-      async (c) =>
-        jsonRequest("PermissionRoutes.reply", c, function* () {
-          const params = c.req.valid("param")
-          const json = c.req.valid("json")
-          const svc = yield* Permission.Service
-          yield* svc.reply({
-            requestID: params.requestID,
-            reply: json.reply,
-            message: json.message,
-          })
-          return true
-        }),
-    )
-    .get(
-      "/",
-      describeRoute({
-        summary: "List pending permissions",
-        description: "Get all pending permission requests across all sessions.",
-        operationId: "permission.list",
-        responses: {
-          200: {
-            description: "List of pending permissions",
-            content: {
-              "application/json": {
-                schema: resolver(Permission.Request.zod.array()),
-              },
-            },
-          },
-        },
-      }),
-      async (c) =>
-        jsonRequest("PermissionRoutes.list", c, function* () {
-          const svc = yield* Permission.Service
-          return yield* svc.list()
-        }),
-    ),
-)

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

@@ -1,122 +0,0 @@
-import { Hono } from "hono"
-import { describeRoute, validator } from "hono-openapi"
-import { resolver } from "hono-openapi"
-import { Instance } from "@/project/instance"
-import { Project } from "@/project"
-import z from "zod"
-import { ProjectID } from "@/project/schema"
-import { errors } from "../../error"
-import { lazy } from "@/util/lazy"
-import { InstanceBootstrap } from "@/project/bootstrap"
-import { AppRuntime } from "@/effect/app-runtime"
-import { jsonRequest, runRequest } from "./trace"
-
-export const ProjectRoutes = lazy(() =>
-  new Hono()
-    .get(
-      "/",
-      describeRoute({
-        summary: "List all projects",
-        description: "Get a list of projects that have been opened with OpenCode.",
-        operationId: "project.list",
-        responses: {
-          200: {
-            description: "List of projects",
-            content: {
-              "application/json": {
-                schema: resolver(Project.Info.zod.array()),
-              },
-            },
-          },
-        },
-      }),
-      async (c) => {
-        const projects = Project.list()
-        return c.json(projects)
-      },
-    )
-    .get(
-      "/current",
-      describeRoute({
-        summary: "Get current project",
-        description: "Retrieve the currently active project that OpenCode is working with.",
-        operationId: "project.current",
-        responses: {
-          200: {
-            description: "Current project information",
-            content: {
-              "application/json": {
-                schema: resolver(Project.Info.zod),
-              },
-            },
-          },
-        },
-      }),
-      async (c) => {
-        return c.json(Instance.project)
-      },
-    )
-    .post(
-      "/git/init",
-      describeRoute({
-        summary: "Initialize git repository",
-        description: "Create a git repository for the current project and return the refreshed project info.",
-        operationId: "project.initGit",
-        responses: {
-          200: {
-            description: "Project information after git initialization",
-            content: {
-              "application/json": {
-                schema: resolver(Project.Info.zod),
-              },
-            },
-          },
-        },
-      }),
-      async (c) => {
-        const dir = Instance.directory
-        const prev = Instance.project
-        const next = await runRequest(
-          "ProjectRoutes.initGit",
-          c,
-          Project.Service.use((svc) => svc.initGit({ directory: dir, project: prev })),
-        )
-        if (next.id === prev.id && next.vcs === prev.vcs && next.worktree === prev.worktree) return c.json(next)
-        await Instance.reload({
-          directory: dir,
-          worktree: dir,
-          project: next,
-          init: () => AppRuntime.runPromise(InstanceBootstrap),
-        })
-        return c.json(next)
-      },
-    )
-    .patch(
-      "/:projectID",
-      describeRoute({
-        summary: "Update project",
-        description: "Update project properties such as name, icon, and commands.",
-        operationId: "project.update",
-        responses: {
-          200: {
-            description: "Updated project information",
-            content: {
-              "application/json": {
-                schema: resolver(Project.Info.zod),
-              },
-            },
-          },
-          ...errors(400, 404),
-        },
-      }),
-      validator("param", z.object({ projectID: ProjectID.zod })),
-      validator("json", Project.UpdateInput.omit({ projectID: true })),
-      async (c) =>
-        jsonRequest("ProjectRoutes.update", c, function* () {
-          const projectID = c.req.valid("param").projectID
-          const body = c.req.valid("json")
-          const svc = yield* Project.Service
-          return yield* svc.update({ ...body, projectID })
-        }),
-    ),
-)

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

@@ -1,158 +0,0 @@
-import { Hono } from "hono"
-import { describeRoute, validator, resolver } from "hono-openapi"
-import z from "zod"
-import { Config } from "@/config"
-import { Provider } from "@/provider"
-import { ModelsDev } from "@/provider"
-import { ProviderAuth } from "@/provider"
-import { ProviderID } from "@/provider/schema"
-import { mapValues } from "remeda"
-import { errors } from "../../error"
-import { lazy } from "@/util/lazy"
-import { Effect } from "effect"
-import { jsonRequest } from "./trace"
-
-export const ProviderRoutes = lazy(() =>
-  new Hono()
-    .get(
-      "/",
-      describeRoute({
-        summary: "List providers",
-        description: "Get a list of all available AI providers, including both available and connected ones.",
-        operationId: "provider.list",
-        responses: {
-          200: {
-            description: "List of providers",
-            content: {
-              "application/json": {
-                schema: resolver(Provider.ListResult.zod),
-              },
-            },
-          },
-        },
-      }),
-      async (c) =>
-        jsonRequest("ProviderRoutes.list", c, function* () {
-          const svc = yield* Provider.Service
-          const cfg = yield* Config.Service
-          const config = yield* cfg.get()
-          const all = yield* Effect.promise(() => ModelsDev.get())
-          const disabled = new Set(config.disabled_providers ?? [])
-          const enabled = config.enabled_providers ? new Set(config.enabled_providers) : undefined
-          const filtered: Record<string, (typeof all)[string]> = {}
-          for (const [key, value] of Object.entries(all)) {
-            if ((enabled ? enabled.has(key) : true) && !disabled.has(key)) {
-              filtered[key] = value
-            }
-          }
-          const connected = yield* svc.list()
-          const providers = Object.assign(
-            mapValues(filtered, (x) => Provider.fromModelsDevProvider(x)),
-            connected,
-          )
-          return {
-            all: Object.values(providers),
-            default: Provider.defaultModelIDs(providers),
-            connected: Object.keys(connected),
-          }
-        }),
-    )
-    .get(
-      "/auth",
-      describeRoute({
-        summary: "Get provider auth methods",
-        description: "Retrieve available authentication methods for all AI providers.",
-        operationId: "provider.auth",
-        responses: {
-          200: {
-            description: "Provider auth methods",
-            content: {
-              "application/json": {
-                schema: resolver(ProviderAuth.Methods.zod),
-              },
-            },
-          },
-        },
-      }),
-      async (c) =>
-        jsonRequest("ProviderRoutes.auth", c, function* () {
-          const svc = yield* ProviderAuth.Service
-          return yield* svc.methods()
-        }),
-    )
-    .post(
-      "/:providerID/oauth/authorize",
-      describeRoute({
-        summary: "OAuth authorize",
-        description: "Initiate OAuth authorization for a specific AI provider to get an authorization URL.",
-        operationId: "provider.oauth.authorize",
-        responses: {
-          200: {
-            description: "Authorization URL and method",
-            content: {
-              "application/json": {
-                schema: resolver(ProviderAuth.Authorization.zod.optional()),
-              },
-            },
-          },
-          ...errors(400),
-        },
-      }),
-      validator(
-        "param",
-        z.object({
-          providerID: ProviderID.zod.meta({ description: "Provider ID" }),
-        }),
-      ),
-      validator("json", ProviderAuth.AuthorizeInput.zod),
-      async (c) =>
-        jsonRequest("ProviderRoutes.oauth.authorize", c, function* () {
-          const providerID = c.req.valid("param").providerID
-          const { method, inputs } = c.req.valid("json")
-          const svc = yield* ProviderAuth.Service
-          return yield* svc.authorize({
-            providerID,
-            method,
-            inputs,
-          })
-        }),
-    )
-    .post(
-      "/:providerID/oauth/callback",
-      describeRoute({
-        summary: "OAuth callback",
-        description: "Handle the OAuth callback from a provider after user authorization.",
-        operationId: "provider.oauth.callback",
-        responses: {
-          200: {
-            description: "OAuth callback processed successfully",
-            content: {
-              "application/json": {
-                schema: resolver(z.boolean()),
-              },
-            },
-          },
-          ...errors(400),
-        },
-      }),
-      validator(
-        "param",
-        z.object({
-          providerID: ProviderID.zod.meta({ description: "Provider ID" }),
-        }),
-      ),
-      validator("json", ProviderAuth.CallbackInput.zod),
-      async (c) =>
-        jsonRequest("ProviderRoutes.oauth.callback", c, function* () {
-          const providerID = c.req.valid("param").providerID
-          const { method, code } = c.req.valid("json")
-          const svc = yield* ProviderAuth.Service
-          yield* svc.callback({
-            providerID,
-            method,
-            code,
-          })
-          return true
-        }),
-    ),
-)