nuwaxcode 1.1.34 → 1.1.45

package/src/server/routes/experimental.ts

@@ -1,157 +0,0 @@
-import { Hono } from "hono"
-import { describeRoute, validator, resolver } from "hono-openapi"
-import z from "zod"
-import { ToolRegistry } from "../../tool/registry"
-import { Worktree } from "../../worktree"
-import { Instance } from "../../project/instance"
-import { Project } from "../../project/project"
-import { MCP } from "../../mcp"
-import { zodToJsonSchema } from "zod-to-json-schema"
-import { errors } from "../error"
-import { lazy } from "../../util/lazy"
-
-export const ExperimentalRoutes = lazy(() =>
-  new Hono()
-    .get(
-      "/tool/ids",
-      describeRoute({
-        summary: "List tool IDs",
-        description:
-          "Get a list of all available tool IDs, including both built-in tools and dynamically registered tools.",
-        operationId: "tool.ids",
-        responses: {
-          200: {
-            description: "Tool IDs",
-            content: {
-              "application/json": {
-                schema: resolver(z.array(z.string()).meta({ ref: "ToolIDs" })),
-              },
-            },
-          },
-          ...errors(400),
-        },
-      }),
-      async (c) => {
-        return c.json(await ToolRegistry.ids())
-      },
-    )
-    .get(
-      "/tool",
-      describeRoute({
-        summary: "List tools",
-        description:
-          "Get a list of available tools with their JSON schema parameters for a specific provider and model combination.",
-        operationId: "tool.list",
-        responses: {
-          200: {
-            description: "Tools",
-            content: {
-              "application/json": {
-                schema: resolver(
-                  z
-                    .array(
-                      z
-                        .object({
-                          id: z.string(),
-                          description: z.string(),
-                          parameters: z.any(),
-                        })
-                        .meta({ ref: "ToolListItem" }),
-                    )
-                    .meta({ ref: "ToolList" }),
-                ),
-              },
-            },
-          },
-          ...errors(400),
-        },
-      }),
-      validator(
-        "query",
-        z.object({
-          provider: z.string(),
-          model: z.string(),
-        }),
-      ),
-      async (c) => {
-        const { provider, model } = c.req.valid("query")
-        const tools = await ToolRegistry.tools({ providerID: provider, modelID: model })
-        return c.json(
-          tools.map((t) => ({
-            id: t.id,
-            description: t.description,
-            // Handle both Zod schemas and plain JSON schemas
-            parameters: (t.parameters as any)?._def ? zodToJsonSchema(t.parameters as any) : t.parameters,
-          })),
-        )
-      },
-    )
-    .post(
-      "/worktree",
-      describeRoute({
-        summary: "Create worktree",
-        description: "Create a new git worktree for the current project.",
-        operationId: "worktree.create",
-        responses: {
-          200: {
-            description: "Worktree created",
-            content: {
-              "application/json": {
-                schema: resolver(Worktree.Info),
-              },
-            },
-          },
-          ...errors(400),
-        },
-      }),
-      validator("json", Worktree.create.schema),
-      async (c) => {
-        const body = c.req.valid("json")
-        const worktree = await Worktree.create(body)
-        return c.json(worktree)
-      },
-    )
-    .get(
-      "/worktree",
-      describeRoute({
-        summary: "List worktrees",
-        description: "List all sandbox worktrees for the current project.",
-        operationId: "worktree.list",
-        responses: {
-          200: {
-            description: "List of worktree directories",
-            content: {
-              "application/json": {
-                schema: resolver(z.array(z.string())),
-              },
-            },
-          },
-        },
-      }),
-      async (c) => {
-        const sandboxes = await Project.sandboxes(Instance.project.id)
-        return c.json(sandboxes)
-      },
-    )
-    .get(
-      "/resource",
-      describeRoute({
-        summary: "Get MCP resources",
-        description: "Get all available MCP resources from connected servers. Optionally filter by name.",
-        operationId: "experimental.resource.list",
-        responses: {
-          200: {
-            description: "MCP resources",
-            content: {
-              "application/json": {
-                schema: resolver(z.record(z.string(), MCP.Resource)),
-              },
-            },
-          },
-        },
-      }),
-      async (c) => {
-        return c.json(await MCP.resources())
-      },
-    ),
-)

package/src/server/routes/file.ts

@@ -1,197 +0,0 @@
-import { Hono } from "hono"
-import { describeRoute, validator, resolver } from "hono-openapi"
-import z from "zod"
-import { File } from "../../file"
-import { Ripgrep } from "../../file/ripgrep"
-import { LSP } from "../../lsp"
-import { Instance } from "../../project/instance"
-import { lazy } from "../../util/lazy"
-
-export const FileRoutes = lazy(() =>
-  new Hono()
-    .get(
-      "/find",
-      describeRoute({
-        summary: "Find text",
-        description: "Search for text patterns across files in the project using ripgrep.",
-        operationId: "find.text",
-        responses: {
-          200: {
-            description: "Matches",
-            content: {
-              "application/json": {
-                schema: resolver(Ripgrep.Match.shape.data.array()),
-              },
-            },
-          },
-        },
-      }),
-      validator(
-        "query",
-        z.object({
-          pattern: z.string(),
-        }),
-      ),
-      async (c) => {
-        const pattern = c.req.valid("query").pattern
-        const result = await Ripgrep.search({
-          cwd: Instance.directory,
-          pattern,
-          limit: 10,
-        })
-        return c.json(result)
-      },
-    )
-    .get(
-      "/find/file",
-      describeRoute({
-        summary: "Find files",
-        description: "Search for files or directories by name or pattern in the project directory.",
-        operationId: "find.files",
-        responses: {
-          200: {
-            description: "File paths",
-            content: {
-              "application/json": {
-                schema: resolver(z.string().array()),
-              },
-            },
-          },
-        },
-      }),
-      validator(
-        "query",
-        z.object({
-          query: z.string(),
-          dirs: z.enum(["true", "false"]).optional(),
-          type: z.enum(["file", "directory"]).optional(),
-          limit: z.coerce.number().int().min(1).max(200).optional(),
-        }),
-      ),
-      async (c) => {
-        const query = c.req.valid("query").query
-        const dirs = c.req.valid("query").dirs
-        const type = c.req.valid("query").type
-        const limit = c.req.valid("query").limit
-        const results = await File.search({
-          query,
-          limit: limit ?? 10,
-          dirs: dirs !== "false",
-          type,
-        })
-        return c.json(results)
-      },
-    )
-    .get(
-      "/find/symbol",
-      describeRoute({
-        summary: "Find symbols",
-        description: "Search for workspace symbols like functions, classes, and variables using LSP.",
-        operationId: "find.symbols",
-        responses: {
-          200: {
-            description: "Symbols",
-            content: {
-              "application/json": {
-                schema: resolver(LSP.Symbol.array()),
-              },
-            },
-          },
-        },
-      }),
-      validator(
-        "query",
-        z.object({
-          query: z.string(),
-        }),
-      ),
-      async (c) => {
-        /*
-      const query = c.req.valid("query").query
-      const result = await LSP.workspaceSymbol(query)
-      return c.json(result)
-      */
-        return c.json([])
-      },
-    )
-    .get(
-      "/file",
-      describeRoute({
-        summary: "List files",
-        description: "List files and directories in a specified path.",
-        operationId: "file.list",
-        responses: {
-          200: {
-            description: "Files and directories",
-            content: {
-              "application/json": {
-                schema: resolver(File.Node.array()),
-              },
-            },
-          },
-        },
-      }),
-      validator(
-        "query",
-        z.object({
-          path: z.string(),
-        }),
-      ),
-      async (c) => {
-        const path = c.req.valid("query").path
-        const content = await File.list(path)
-        return c.json(content)
-      },
-    )
-    .get(
-      "/file/content",
-      describeRoute({
-        summary: "Read file",
-        description: "Read the content of a specified file.",
-        operationId: "file.read",
-        responses: {
-          200: {
-            description: "File content",
-            content: {
-              "application/json": {
-                schema: resolver(File.Content),
-              },
-            },
-          },
-        },
-      }),
-      validator(
-        "query",
-        z.object({
-          path: z.string(),
-        }),
-      ),
-      async (c) => {
-        const path = c.req.valid("query").path
-        const content = await File.read(path)
-        return c.json(content)
-      },
-    )
-    .get(
-      "/file/status",
-      describeRoute({
-        summary: "Get file status",
-        description: "Get the git status of all files in the project.",
-        operationId: "file.status",
-        responses: {
-          200: {
-            description: "File status",
-            content: {
-              "application/json": {
-                schema: resolver(File.Info.array()),
-              },
-            },
-          },
-        },
-      }),
-      async (c) => {
-        const content = await File.status()
-        return c.json(content)
-      },
-    ),
-)

package/src/server/routes/global.ts

@@ -1,135 +0,0 @@
-import { Hono } from "hono"
-import { describeRoute, resolver } from "hono-openapi"
-import { streamSSE } from "hono/streaming"
-import z from "zod"
-import { BusEvent } from "@/bus/bus-event"
-import { GlobalBus } from "@/bus/global"
-import { Instance } from "../../project/instance"
-import { Installation } from "@/installation"
-import { Log } from "../../util/log"
-import { lazy } from "../../util/lazy"
-
-const log = Log.create({ service: "server" })
-
-export const GlobalDisposedEvent = BusEvent.define("global.disposed", z.object({}))
-
-export const GlobalRoutes = lazy(() =>
-  new Hono()
-    .get(
-      "/health",
-      describeRoute({
-        summary: "Get health",
-        description: "Get health information about the OpenCode server.",
-        operationId: "global.health",
-        responses: {
-          200: {
-            description: "Health information",
-            content: {
-              "application/json": {
-                schema: resolver(z.object({ healthy: z.literal(true), version: z.string() })),
-              },
-            },
-          },
-        },
-      }),
-      async (c) => {
-        return c.json({ healthy: true, version: Installation.VERSION })
-      },
-    )
-    .get(
-      "/event",
-      describeRoute({
-        summary: "Get global events",
-        description: "Subscribe to global events from the OpenCode system using server-sent events.",
-        operationId: "global.event",
-        responses: {
-          200: {
-            description: "Event stream",
-            content: {
-              "text/event-stream": {
-                schema: resolver(
-                  z
-                    .object({
-                      directory: z.string(),
-                      payload: BusEvent.payloads(),
-                    })
-                    .meta({
-                      ref: "GlobalEvent",
-                    }),
-                ),
-              },
-            },
-          },
-        },
-      }),
-      async (c) => {
-        log.info("global event connected")
-        return streamSSE(c, async (stream) => {
-          stream.writeSSE({
-            data: JSON.stringify({
-              payload: {
-                type: "server.connected",
-                properties: {},
-              },
-            }),
-          })
-          async function handler(event: any) {
-            await stream.writeSSE({
-              data: JSON.stringify(event),
-            })
-          }
-          GlobalBus.on("event", handler)
-
-          // Send heartbeat every 30s to prevent WKWebView timeout (60s default)
-          const heartbeat = setInterval(() => {
-            stream.writeSSE({
-              data: JSON.stringify({
-                payload: {
-                  type: "server.heartbeat",
-                  properties: {},
-                },
-              }),
-            })
-          }, 30000)
-
-          await new Promise<void>((resolve) => {
-            stream.onAbort(() => {
-              clearInterval(heartbeat)
-              GlobalBus.off("event", handler)
-              resolve()
-              log.info("global event disconnected")
-            })
-          })
-        })
-      },
-    )
-    .post(
-      "/dispose",
-      describeRoute({
-        summary: "Dispose instance",
-        description: "Clean up and dispose all OpenCode instances, releasing all resources.",
-        operationId: "global.dispose",
-        responses: {
-          200: {
-            description: "Global disposed",
-            content: {
-              "application/json": {
-                schema: resolver(z.boolean()),
-              },
-            },
-          },
-        },
-      }),
-      async (c) => {
-        await Instance.disposeAll()
-        GlobalBus.emit("event", {
-          directory: "global",
-          payload: {
-            type: GlobalDisposedEvent.type,
-            properties: {},
-          },
-        })
-        return c.json(true)
-      },
-    ),
-)

package/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)
-      },
-    ),
-)