dfcode 1.0.0 → 1.0.2

package/packages/dfcode/src/server/routes/mcp.ts

@@ -1,225 +0,0 @@
-import { Hono } from "hono"
-import { describeRoute, validator, resolver } from "hono-openapi"
-import z from "zod"
-import { MCP } from "../../mcp"
-import { Config } from "../../config/config"
-import { errors } from "../error"
-import { lazy } from "../../util/lazy"
-
-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) => {
-        return c.json(await 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: Config.Mcp,
-        }),
-      ),
-      async (c) => {
-        const { name, config } = c.req.valid("json")
-        const result = await MCP.add(name, config)
-        return c.json(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 supportsOAuth = await MCP.supportsOAuth(name)
-        if (!supportsOAuth) {
-          return c.json({ error: `MCP server ${name} does not support OAuth` }, 400)
-        }
-        const result = await MCP.startAuth(name)
-        return c.json(result)
-      },
-    )
-    .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) => {
-        const name = c.req.param("name")
-        const { code } = c.req.valid("json")
-        const status = await MCP.finishAuth(name, code)
-        return c.json(status)
-      },
-    )
-    .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 supportsOAuth = await MCP.supportsOAuth(name)
-        if (!supportsOAuth) {
-          return c.json({ error: `MCP server ${name} does not support OAuth` }, 400)
-        }
-        const status = await MCP.authenticate(name)
-        return c.json(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) => {
-        const name = c.req.param("name")
-        await MCP.removeAuth(name)
-        return c.json({ 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) => {
-        const { name } = c.req.valid("param")
-        await MCP.connect(name)
-        return c.json(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) => {
-        const { name } = c.req.valid("param")
-        await MCP.disconnect(name)
-        return c.json(true)
-      },
-    ),
-)

package/packages/dfcode/src/server/routes/permission.ts

@@ -1,68 +0,0 @@
-import { Hono } from "hono"
-import { describeRoute, validator, resolver } from "hono-openapi"
-import z from "zod"
-import { PermissionNext } from "@/permission/next"
-import { errors } from "../error"
-import { lazy } from "../../util/lazy"
-
-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: z.string(),
-        }),
-      ),
-      validator("json", z.object({ reply: PermissionNext.Reply, message: z.string().optional() })),
-      async (c) => {
-        const params = c.req.valid("param")
-        const json = c.req.valid("json")
-        await PermissionNext.reply({
-          requestID: params.requestID,
-          reply: json.reply,
-          message: json.message,
-        })
-        return c.json(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(PermissionNext.Request.array()),
-              },
-            },
-          },
-        },
-      }),
-      async (c) => {
-        const permissions = await PermissionNext.list()
-        return c.json(permissions)
-      },
-    ),
-)

package/packages/dfcode/src/server/routes/project.ts

@@ -1,82 +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/project"
-import z from "zod"
-import { errors } from "../error"
-import { lazy } from "../../util/lazy"
-
-export const ProjectRoutes = lazy(() =>
-  new Hono()
-    .get(
-      "/",
-      describeRoute({
-        summary: "List all projects",
-        description: "Get a list of projects that have been opened with DFCode.",
-        operationId: "project.list",
-        responses: {
-          200: {
-            description: "List of projects",
-            content: {
-              "application/json": {
-                schema: resolver(Project.Info.array()),
-              },
-            },
-          },
-        },
-      }),
-      async (c) => {
-        const projects = await Project.list()
-        return c.json(projects)
-      },
-    )
-    .get(
-      "/current",
-      describeRoute({
-        summary: "Get current project",
-        description: "Retrieve the currently active project that DFCode is working with.",
-        operationId: "project.current",
-        responses: {
-          200: {
-            description: "Current project information",
-            content: {
-              "application/json": {
-                schema: resolver(Project.Info),
-              },
-            },
-          },
-        },
-      }),
-      async (c) => {
-        return c.json(Instance.project)
-      },
-    )
-    .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),
-              },
-            },
-          },
-          ...errors(400, 404),
-        },
-      }),
-      validator("param", z.object({ projectID: z.string() })),
-      validator("json", Project.update.schema.omit({ projectID: true })),
-      async (c) => {
-        const projectID = c.req.valid("param").projectID
-        const body = c.req.valid("json")
-        const project = await Project.update({ ...body, projectID })
-        return c.json(project)
-      },
-    ),
-)

package/packages/dfcode/src/server/routes/provider.ts

@@ -1,165 +0,0 @@
-import { Hono } from "hono"
-import { describeRoute, validator, resolver } from "hono-openapi"
-import z from "zod"
-import { Config } from "../../config/config"
-import { Provider } from "../../provider/provider"
-import { ModelsDev } from "../../provider/models"
-import { ProviderAuth } from "../../provider/auth"
-import { mapValues } from "remeda"
-import { errors } from "../error"
-import { lazy } from "../../util/lazy"
-
-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(
-                  z.object({
-                    all: ModelsDev.Provider.array(),
-                    default: z.record(z.string(), z.string()),
-                    connected: z.array(z.string()),
-                  }),
-                ),
-              },
-            },
-          },
-        },
-      }),
-      async (c) => {
-        const config = await Config.get()
-        const disabled = new Set(config.disabled_providers ?? [])
-        const enabled = config.enabled_providers ? new Set(config.enabled_providers) : undefined
-
-        const allProviders = await ModelsDev.get()
-        const filteredProviders: Record<string, (typeof allProviders)[string]> = {}
-        for (const [key, value] of Object.entries(allProviders)) {
-          if ((enabled ? enabled.has(key) : true) && !disabled.has(key)) {
-            filteredProviders[key] = value
-          }
-        }
-
-        const connected = await Provider.list()
-        const providers = Object.assign(
-          mapValues(filteredProviders, (x) => Provider.fromModelsDevProvider(x)),
-          connected,
-        )
-        return c.json({
-          all: Object.values(providers),
-          default: mapValues(providers, (item) => Provider.sort(Object.values(item.models))[0].id),
-          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(z.record(z.string(), z.array(ProviderAuth.Method))),
-              },
-            },
-          },
-        },
-      }),
-      async (c) => {
-        return c.json(await ProviderAuth.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.optional()),
-              },
-            },
-          },
-          ...errors(400),
-        },
-      }),
-      validator(
-        "param",
-        z.object({
-          providerID: z.string().meta({ description: "Provider ID" }),
-        }),
-      ),
-      validator(
-        "json",
-        z.object({
-          method: z.number().meta({ description: "Auth method index" }),
-        }),
-      ),
-      async (c) => {
-        const providerID = c.req.valid("param").providerID
-        const { method } = c.req.valid("json")
-        const result = await ProviderAuth.authorize({
-          providerID,
-          method,
-        })
-        return c.json(result)
-      },
-    )
-    .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: z.string().meta({ description: "Provider ID" }),
-        }),
-      ),
-      validator(
-        "json",
-        z.object({
-          method: z.number().meta({ description: "Auth method index" }),
-          code: z.string().optional().meta({ description: "OAuth authorization code" }),
-        }),
-      ),
-      async (c) => {
-        const providerID = c.req.valid("param").providerID
-        const { method, code } = c.req.valid("json")
-        await ProviderAuth.callback({
-          providerID,
-          method,
-          code,
-        })
-        return c.json(true)
-      },
-    ),
-)

package/packages/dfcode/src/server/routes/pty.ts

@@ -1,169 +0,0 @@
-import { Hono } from "hono"
-import { describeRoute, validator, resolver } from "hono-openapi"
-import { upgradeWebSocket } from "hono/bun"
-import z from "zod"
-import { Pty } from "@/pty"
-import { Storage } from "../../storage/storage"
-import { errors } from "../error"
-import { lazy } from "../../util/lazy"
-
-export const PtyRoutes = lazy(() =>
-  new Hono()
-    .get(
-      "/",
-      describeRoute({
-        summary: "List PTY sessions",
-        description: "Get a list of all active pseudo-terminal (PTY) sessions managed by DFCode.",
-        operationId: "pty.list",
-        responses: {
-          200: {
-            description: "List of sessions",
-            content: {
-              "application/json": {
-                schema: resolver(Pty.Info.array()),
-              },
-            },
-          },
-        },
-      }),
-      async (c) => {
-        return c.json(Pty.list())
-      },
-    )
-    .post(
-      "/",
-      describeRoute({
-        summary: "Create PTY session",
-        description: "Create a new pseudo-terminal (PTY) session for running shell commands and processes.",
-        operationId: "pty.create",
-        responses: {
-          200: {
-            description: "Created session",
-            content: {
-              "application/json": {
-                schema: resolver(Pty.Info),
-              },
-            },
-          },
-          ...errors(400),
-        },
-      }),
-      validator("json", Pty.CreateInput),
-      async (c) => {
-        const info = await Pty.create(c.req.valid("json"))
-        return c.json(info)
-      },
-    )
-    .get(
-      "/:ptyID",
-      describeRoute({
-        summary: "Get PTY session",
-        description: "Retrieve detailed information about a specific pseudo-terminal (PTY) session.",
-        operationId: "pty.get",
-        responses: {
-          200: {
-            description: "Session info",
-            content: {
-              "application/json": {
-                schema: resolver(Pty.Info),
-              },
-            },
-          },
-          ...errors(404),
-        },
-      }),
-      validator("param", z.object({ ptyID: z.string() })),
-      async (c) => {
-        const info = Pty.get(c.req.valid("param").ptyID)
-        if (!info) {
-          throw new Storage.NotFoundError({ message: "Session not found" })
-        }
-        return c.json(info)
-      },
-    )
-    .put(
-      "/:ptyID",
-      describeRoute({
-        summary: "Update PTY session",
-        description: "Update properties of an existing pseudo-terminal (PTY) session.",
-        operationId: "pty.update",
-        responses: {
-          200: {
-            description: "Updated session",
-            content: {
-              "application/json": {
-                schema: resolver(Pty.Info),
-              },
-            },
-          },
-          ...errors(400),
-        },
-      }),
-      validator("param", z.object({ ptyID: z.string() })),
-      validator("json", Pty.UpdateInput),
-      async (c) => {
-        const info = await Pty.update(c.req.valid("param").ptyID, c.req.valid("json"))
-        return c.json(info)
-      },
-    )
-    .delete(
-      "/:ptyID",
-      describeRoute({
-        summary: "Remove PTY session",
-        description: "Remove and terminate a specific pseudo-terminal (PTY) session.",
-        operationId: "pty.remove",
-        responses: {
-          200: {
-            description: "Session removed",
-            content: {
-              "application/json": {
-                schema: resolver(z.boolean()),
-              },
-            },
-          },
-          ...errors(404),
-        },
-      }),
-      validator("param", z.object({ ptyID: z.string() })),
-      async (c) => {
-        await Pty.remove(c.req.valid("param").ptyID)
-        return c.json(true)
-      },
-    )
-    .get(
-      "/:ptyID/connect",
-      describeRoute({
-        summary: "Connect to PTY session",
-        description: "Establish a WebSocket connection to interact with a pseudo-terminal (PTY) session in real-time.",
-        operationId: "pty.connect",
-        responses: {
-          200: {
-            description: "Connected session",
-            content: {
-              "application/json": {
-                schema: resolver(z.boolean()),
-              },
-            },
-          },
-          ...errors(404),
-        },
-      }),
-      validator("param", z.object({ ptyID: z.string() })),
-      upgradeWebSocket((c) => {
-        const id = c.req.param("ptyID")
-        let handler: ReturnType<typeof Pty.connect>
-        if (!Pty.get(id)) throw new Error("Session not found")
-        return {
-          onOpen(_event, ws) {
-            handler = Pty.connect(id, ws)
-          },
-          onMessage(event) {
-            handler?.onMessage(String(event.data))
-          },
-          onClose() {
-            handler?.onClose()
-          },
-        }
-      }),
-    ),
-)