bonecode 1.0.0 → 1.2.0

package/src/engine/config/variable.ts

@@ -1,90 +1,90 @@
-export * as ConfigVariable from "./variable"
-
-import path from "path"
-import os from "os"
-import { Filesystem } from "@/util/filesystem"
-import { InvalidError } from "./error"
-
-type ParseSource =
-  | {
-      type: "path"
-      path: string
-    }
-  | {
-      type: "virtual"
-      source: string
-      dir: string
-    }
-
-type SubstituteInput = ParseSource & {
-  text: string
-  missing?: "error" | "empty"
-}
-
-function source(input: ParseSource) {
-  return input.type === "path" ? input.path : input.source
-}
-
-function dir(input: ParseSource) {
-  return input.type === "path" ? path.dirname(input.path) : input.dir
-}
-
-/** Apply {env:VAR} and {file:path} substitutions to config text. */
-export async function substitute(input: SubstituteInput) {
-  const missing = input.missing ?? "error"
-  let text = input.text.replace(/\{env:([^}]+)\}/g, (_, varName) => {
-    return process.env[varName] || ""
-  })
-
-  const fileMatches = Array.from(text.matchAll(/\{file:[^}]+\}/g))
-  if (!fileMatches.length) return text
-
-  const configDir = dir(input)
-  const configSource = source(input)
-  let out = ""
-  let cursor = 0
-
-  for (const match of fileMatches) {
-    const token = match[0]
-    const index = match.index!
-    out += text.slice(cursor, index)
-
-    const lineStart = text.lastIndexOf("\n", index - 1) + 1
-    const prefix = text.slice(lineStart, index).trimStart()
-    if (prefix.startsWith("//")) {
-      out += token
-      cursor = index + token.length
-      continue
-    }
-
-    let filePath = token.replace(/^\{file:/, "").replace(/\}$/, "")
-    if (filePath.startsWith("~/")) {
-      filePath = path.join(os.homedir(), filePath.slice(2))
-    }
-
-    const resolvedPath = path.isAbsolute(filePath) ? filePath : path.resolve(configDir, filePath)
-    const fileContent = (
-      await Filesystem.readText(resolvedPath).catch((error: NodeJS.ErrnoException) => {
-        if (missing === "empty") return ""
-
-        const errMsg = `bad file reference: "${token}"`
-        if (error.code === "ENOENT") {
-          throw new InvalidError(
-            {
-              path: configSource,
-              message: errMsg + ` ${resolvedPath} does not exist`,
-            },
-            { cause: error },
-          )
-        }
-        throw new InvalidError({ path: configSource, message: errMsg }, { cause: error })
-      })
-    ).trim()
-
-    out += JSON.stringify(fileContent).slice(1, -1)
-    cursor = index + token.length
-  }
-
-  out += text.slice(cursor)
-  return out
-}
+export * as ConfigVariable from "./variable"
+
+import path from "path"
+import os from "os"
+import { Filesystem } from "@/util/filesystem"
+import { InvalidError } from "./error"
+
+type ParseSource =
+  | {
+      type: "path"
+      path: string
+    }
+  | {
+      type: "virtual"
+      source: string
+      dir: string
+    }
+
+type SubstituteInput = ParseSource & {
+  text: string
+  missing?: "error" | "empty"
+}
+
+function source(input: ParseSource) {
+  return input.type === "path" ? input.path : input.source
+}
+
+function dir(input: ParseSource) {
+  return input.type === "path" ? path.dirname(input.path) : input.dir
+}
+
+/** Apply {env:VAR} and {file:path} substitutions to config text. */
+export async function substitute(input: SubstituteInput) {
+  const missing = input.missing ?? "error"
+  let text = input.text.replace(/\{env:([^}]+)\}/g, (_, varName) => {
+    return process.env[varName] || ""
+  })
+
+  const fileMatches = Array.from(text.matchAll(/\{file:[^}]+\}/g))
+  if (!fileMatches.length) return text
+
+  const configDir = dir(input)
+  const configSource = source(input)
+  let out = ""
+  let cursor = 0
+
+  for (const match of fileMatches) {
+    const token = match[0]
+    const index = match.index!
+    out += text.slice(cursor, index)
+
+    const lineStart = text.lastIndexOf("\n", index - 1) + 1
+    const prefix = text.slice(lineStart, index).trimStart()
+    if (prefix.startsWith("//")) {
+      out += token
+      cursor = index + token.length
+      continue
+    }
+
+    let filePath = token.replace(/^\{file:/, "").replace(/\}$/, "")
+    if (filePath.startsWith("~/")) {
+      filePath = path.join(os.homedir(), filePath.slice(2))
+    }
+
+    const resolvedPath = path.isAbsolute(filePath) ? filePath : path.resolve(configDir, filePath)
+    const fileContent = (
+      await Filesystem.readText(resolvedPath).catch((error: NodeJS.ErrnoException) => {
+        if (missing === "empty") return ""
+
+        const errMsg = `bad file reference: "${token}"`
+        if (error.code === "ENOENT") {
+          throw new InvalidError(
+            {
+              path: configSource,
+              message: errMsg + ` ${resolvedPath} does not exist`,
+            },
+            { cause: error },
+          )
+        }
+        throw new InvalidError({ path: configSource, message: errMsg }, { cause: error })
+      })
+    ).trim()
+
+    out += JSON.stringify(fileContent).slice(1, -1)
+    cursor = index + token.length
+  }
+
+  out += text.slice(cursor)
+  return out
+}

package/src/engine/control-plane/adapters/index.ts

@@ -1,41 +1,41 @@
-import type { ProjectID } from "@/project/schema"
-import type { WorkspaceAdapter, WorkspaceAdapterEntry } from "../types"
-import { WorktreeAdapter } from "./worktree"
-
-const BUILTIN: Record<string, WorkspaceAdapter> = {
-  worktree: WorktreeAdapter,
-}
-
-const state = new Map<ProjectID, Map<string, WorkspaceAdapter>>()
-
-export function getAdapter(projectID: ProjectID, type: string): WorkspaceAdapter {
-  const custom = state.get(projectID)?.get(type)
-  if (custom) return custom
-
-  const builtin = BUILTIN[type]
-  if (builtin) return builtin
-
-  throw new Error(`Unknown workspace adapter: ${type}`)
-}
-
-export function listAdapters(projectID: ProjectID): WorkspaceAdapterEntry[] {
-  return registeredAdapters(projectID).map(([type, adapter]) => ({
-    type,
-    name: adapter.name,
-    description: adapter.description,
-  }))
-}
-
-export function registeredAdapters(projectID: ProjectID): [string, WorkspaceAdapter][] {
-  const adapters = new Map(Object.entries(BUILTIN))
-  for (const [type, adapter] of state.get(projectID)?.entries() ?? []) adapters.set(type, adapter)
-  return [...adapters.entries()]
-}
-
-// Plugins can be loaded per-project so we need to scope them. If you
-// want to install a global one pass `ProjectID.global`
-export function registerAdapter(projectID: ProjectID, type: string, adapter: WorkspaceAdapter) {
-  const adapters = state.get(projectID) ?? new Map<string, WorkspaceAdapter>()
-  adapters.set(type, adapter)
-  state.set(projectID, adapters)
-}
+import type { ProjectID } from "@/project/schema"
+import type { WorkspaceAdapter, WorkspaceAdapterEntry } from "../types"
+import { WorktreeAdapter } from "./worktree"
+
+const BUILTIN: Record<string, WorkspaceAdapter> = {
+  worktree: WorktreeAdapter,
+}
+
+const state = new Map<ProjectID, Map<string, WorkspaceAdapter>>()
+
+export function getAdapter(projectID: ProjectID, type: string): WorkspaceAdapter {
+  const custom = state.get(projectID)?.get(type)
+  if (custom) return custom
+
+  const builtin = BUILTIN[type]
+  if (builtin) return builtin
+
+  throw new Error(`Unknown workspace adapter: ${type}`)
+}
+
+export function listAdapters(projectID: ProjectID): WorkspaceAdapterEntry[] {
+  return registeredAdapters(projectID).map(([type, adapter]) => ({
+    type,
+    name: adapter.name,
+    description: adapter.description,
+  }))
+}
+
+export function registeredAdapters(projectID: ProjectID): [string, WorkspaceAdapter][] {
+  const adapters = new Map(Object.entries(BUILTIN))
+  for (const [type, adapter] of state.get(projectID)?.entries() ?? []) adapters.set(type, adapter)
+  return [...adapters.entries()]
+}
+
+// Plugins can be loaded per-project so we need to scope them. If you
+// want to install a global one pass `ProjectID.global`
+export function registerAdapter(projectID: ProjectID, type: string, adapter: WorkspaceAdapter) {
+  const adapters = state.get(projectID) ?? new Map<string, WorkspaceAdapter>()
+  adapters.set(type, adapter)
+  state.set(projectID, adapters)
+}

package/src/engine/control-plane/adapters/worktree.ts

@@ -1,96 +1,96 @@
-import { Effect, Schema } from "effect"
-import { InstanceRef, WorkspaceRef } from "@/effect/instance-ref"
-import { type WorkspaceAdapter, type WorkspaceAdapterContext, WorkspaceInfo } from "../types"
-
-const WorktreeConfig = Schema.Struct({
-  name: WorkspaceInfo.fields.name,
-  branch: Schema.optional(Schema.NullOr(Schema.String)),
-  directory: Schema.String,
-})
-const decodeWorktreeConfig = Schema.decodeUnknownSync(WorktreeConfig)
-
-async function loadWorktree() {
-  const [{ AppRuntime }, { Worktree }] = await Promise.all([import("@/effect/app-runtime"), import("@/worktree")])
-  return { AppRuntime, Worktree }
-}
-
-function requireInstance(context: WorkspaceAdapterContext | undefined) {
-  if (!context?.instance) throw new Error("Worktree adapter requires an instance context")
-  return context.instance
-}
-
-const provideContext = <A, E, R>(effect: Effect.Effect<A, E, R>, context: WorkspaceAdapterContext | undefined) =>
-  effect.pipe(
-    Effect.provideService(InstanceRef, requireInstance(context)),
-    Effect.provideService(WorkspaceRef, context?.workspaceID),
-  )
-
-export const WorktreeAdapter: WorkspaceAdapter = {
-  name: "Worktree",
-  description: "Create a git worktree",
-  async configure(info, context) {
-    const { AppRuntime, Worktree } = await loadWorktree()
-    const next = await AppRuntime.runPromise(
-      provideContext(
-        Worktree.Service.use((svc) => svc.makeWorktreeInfo({ detached: true })),
-        context,
-      ),
-    )
-    return {
-      ...info,
-      name: next.name,
-      directory: next.directory,
-    }
-  },
-  async create(info, _env, _from, context) {
-    const { AppRuntime, Worktree } = await loadWorktree()
-    const config = decodeWorktreeConfig(info)
-    await AppRuntime.runPromise(
-      provideContext(
-        Worktree.Service.use((svc) =>
-          svc.createFromInfo({
-            name: config.name,
-            directory: config.directory,
-            ...(config.branch ? { branch: config.branch } : {}),
-          }),
-        ),
-        context,
-      ),
-    )
-  },
-  async list(context) {
-    const { AppRuntime, Worktree } = await loadWorktree()
-    const ctx = requireInstance(context)
-    return (
-      await AppRuntime.runPromise(
-        provideContext(
-          Worktree.Service.use((svc) => svc.list()),
-          context,
-        ),
-      )
-    ).map((info) => ({
-      type: "worktree",
-      name: info.name,
-      branch: info.branch,
-      directory: info.directory,
-      projectID: ctx.project.id,
-    }))
-  },
-  async remove(info, context) {
-    const { AppRuntime, Worktree } = await loadWorktree()
-    const config = decodeWorktreeConfig(info)
-    await AppRuntime.runPromise(
-      provideContext(
-        Worktree.Service.use((svc) => svc.remove({ directory: config.directory })),
-        context,
-      ),
-    )
-  },
-  target(info) {
-    const config = decodeWorktreeConfig(info)
-    return {
-      type: "local",
-      directory: config.directory,
-    }
-  },
-}
+import { Effect, Schema } from "effect"
+import { InstanceRef, WorkspaceRef } from "@/effect/instance-ref"
+import { type WorkspaceAdapter, type WorkspaceAdapterContext, WorkspaceInfo } from "../types"
+
+const WorktreeConfig = Schema.Struct({
+  name: WorkspaceInfo.fields.name,
+  branch: Schema.optional(Schema.NullOr(Schema.String)),
+  directory: Schema.String,
+})
+const decodeWorktreeConfig = Schema.decodeUnknownSync(WorktreeConfig)
+
+async function loadWorktree() {
+  const [{ AppRuntime }, { Worktree }] = await Promise.all([import("@/effect/app-runtime"), import("@/worktree")])
+  return { AppRuntime, Worktree }
+}
+
+function requireInstance(context: WorkspaceAdapterContext | undefined) {
+  if (!context?.instance) throw new Error("Worktree adapter requires an instance context")
+  return context.instance
+}
+
+const provideContext = <A, E, R>(effect: Effect.Effect<A, E, R>, context: WorkspaceAdapterContext | undefined) =>
+  effect.pipe(
+    Effect.provideService(InstanceRef, requireInstance(context)),
+    Effect.provideService(WorkspaceRef, context?.workspaceID),
+  )
+
+export const WorktreeAdapter: WorkspaceAdapter = {
+  name: "Worktree",
+  description: "Create a git worktree",
+  async configure(info, context) {
+    const { AppRuntime, Worktree } = await loadWorktree()
+    const next = await AppRuntime.runPromise(
+      provideContext(
+        Worktree.Service.use((svc) => svc.makeWorktreeInfo({ detached: true })),
+        context,
+      ),
+    )
+    return {
+      ...info,
+      name: next.name,
+      directory: next.directory,
+    }
+  },
+  async create(info, _env, _from, context) {
+    const { AppRuntime, Worktree } = await loadWorktree()
+    const config = decodeWorktreeConfig(info)
+    await AppRuntime.runPromise(
+      provideContext(
+        Worktree.Service.use((svc) =>
+          svc.createFromInfo({
+            name: config.name,
+            directory: config.directory,
+            ...(config.branch ? { branch: config.branch } : {}),
+          }),
+        ),
+        context,
+      ),
+    )
+  },
+  async list(context) {
+    const { AppRuntime, Worktree } = await loadWorktree()
+    const ctx = requireInstance(context)
+    return (
+      await AppRuntime.runPromise(
+        provideContext(
+          Worktree.Service.use((svc) => svc.list()),
+          context,
+        ),
+      )
+    ).map((info) => ({
+      type: "worktree",
+      name: info.name,
+      branch: info.branch,
+      directory: info.directory,
+      projectID: ctx.project.id,
+    }))
+  },
+  async remove(info, context) {
+    const { AppRuntime, Worktree } = await loadWorktree()
+    const config = decodeWorktreeConfig(info)
+    await AppRuntime.runPromise(
+      provideContext(
+        Worktree.Service.use((svc) => svc.remove({ directory: config.directory })),
+        context,
+      ),
+    )
+  },
+  target(info) {
+    const config = decodeWorktreeConfig(info)
+    return {
+      type: "local",
+      directory: config.directory,
+    }
+  },
+}

package/src/engine/control-plane/dev/README.md

@@ -1,19 +1,19 @@
-This is a plugin to simulate a remote environment locally. Add this to `.opencode/opencode.jsonc`:
-
-```json
-  "plugin": ["../packages/opencode/src/control-plane/dev/debug-workspace-plugin.ts"],
-```
-
-In a separate terminal, run a separate OpenCode server. This will act like a remote server and the local instance will proxy all requests to it:
-
-```
-./packages/opencode/script/run-workspace-server
-```
-
-With the plugin install, you can now run OpenCode and create a `debug` workspace type. This will create a "remote" workspace which talks to the second workspace server started above.
-
-How this works:
-
-- The workspace server needs to know the workspace id and port to run. It waits for this information to be written to a file and starts the server when the data is written.
-- The debug plugin writes this information in the `create` call to the workspace. So create a `debug` workspace will always kick off a new external server.
-- The server script watches for file changes, so whenver you create a new `debug` workspace it will restart with the new information. This means that there is only ever one working `debug` workspace at a time; when you create a new one all previous sessions will show that it can't connect because previous debug workspaces do not exist.
+This is a plugin to simulate a remote environment locally. Add this to `.opencode/opencode.jsonc`:
+
+```json
+  "plugin": ["../packages/opencode/src/control-plane/dev/debug-workspace-plugin.ts"],
+```
+
+In a separate terminal, run a separate OpenCode server. This will act like a remote server and the local instance will proxy all requests to it:
+
+```
+./packages/opencode/script/run-workspace-server
+```
+
+With the plugin install, you can now run OpenCode and create a `debug` workspace type. This will create a "remote" workspace which talks to the second workspace server started above.
+
+How this works:
+
+- The workspace server needs to know the workspace id and port to run. It waits for this information to be written to a file and starts the server when the data is written.
+- The debug plugin writes this information in the `create` call to the workspace. So create a `debug` workspace will always kick off a new external server.
+- The server script watches for file changes, so whenver you create a new `debug` workspace it will restart with the new information. This means that there is only ever one working `debug` workspace at a time; when you create a new one all previous sessions will show that it can't connect because previous debug workspaces do not exist.

package/src/engine/control-plane/dev/debug-workspace-plugin.ts

@@ -1,73 +1,73 @@
-import type { Plugin } from "@opencode-ai/plugin"
-import { rename, writeFile } from "node:fs/promises"
-import { randomInt } from "node:crypto"
-import { setTimeout as sleep } from "node:timers/promises"
-
-const DEV_DATA_FILE = "/tmp/opencode-workspace-dev-data.json"
-const DEV_DATA_TEMP_FILE = `${DEV_DATA_FILE}.tmp`
-
-async function waitForHealth(port: number) {
-  const url = `http://127.0.0.1:${port}/global/health`
-  const started = Date.now()
-
-  while (Date.now() - started < 30_000) {
-    try {
-      const response = await fetch(url)
-      if (response.ok) {
-        return
-      }
-    } catch {}
-
-    await sleep(250)
-  }
-
-  throw new Error(`Timed out waiting for debug server health check at ${url}`)
-}
-
-let PORT: number | undefined
-
-async function writeDebugData(port: number, id: string, env: Record<string, string | undefined>) {
-  await writeFile(
-    DEV_DATA_TEMP_FILE,
-    JSON.stringify(
-      {
-        port,
-        id,
-        env,
-      },
-      null,
-      2,
-    ),
-  )
-
-  await rename(DEV_DATA_TEMP_FILE, DEV_DATA_FILE)
-}
-
-export const DebugWorkspacePlugin: Plugin = async ({ experimental_workspace }) => {
-  experimental_workspace.register("debug", {
-    name: "Debug",
-    description: "Create a debugging server",
-    configure(config) {
-      return config
-    },
-    async create(config, env) {
-      const port = randomInt(5000, 9001)
-      PORT = port
-
-      await writeDebugData(port, config.id, env)
-
-      await waitForHealth(port)
-    },
-    async remove(_config) {},
-    target(_config) {
-      return {
-        type: "remote",
-        url: `http://localhost:${PORT!}/`,
-      }
-    },
-  })
-
-  return {}
-}
-
-export default DebugWorkspacePlugin
+import type { Plugin } from "@opencode-ai/plugin"
+import { rename, writeFile } from "node:fs/promises"
+import { randomInt } from "node:crypto"
+import { setTimeout as sleep } from "node:timers/promises"
+
+const DEV_DATA_FILE = "/tmp/opencode-workspace-dev-data.json"
+const DEV_DATA_TEMP_FILE = `${DEV_DATA_FILE}.tmp`
+
+async function waitForHealth(port: number) {
+  const url = `http://127.0.0.1:${port}/global/health`
+  const started = Date.now()
+
+  while (Date.now() - started < 30_000) {
+    try {
+      const response = await fetch(url)
+      if (response.ok) {
+        return
+      }
+    } catch {}
+
+    await sleep(250)
+  }
+
+  throw new Error(`Timed out waiting for debug server health check at ${url}`)
+}
+
+let PORT: number | undefined
+
+async function writeDebugData(port: number, id: string, env: Record<string, string | undefined>) {
+  await writeFile(
+    DEV_DATA_TEMP_FILE,
+    JSON.stringify(
+      {
+        port,
+        id,
+        env,
+      },
+      null,
+      2,
+    ),
+  )
+
+  await rename(DEV_DATA_TEMP_FILE, DEV_DATA_FILE)
+}
+
+export const DebugWorkspacePlugin: Plugin = async ({ experimental_workspace }) => {
+  experimental_workspace.register("debug", {
+    name: "Debug",
+    description: "Create a debugging server",
+    configure(config) {
+      return config
+    },
+    async create(config, env) {
+      const port = randomInt(5000, 9001)
+      PORT = port
+
+      await writeDebugData(port, config.id, env)
+
+      await waitForHealth(port)
+    },
+    async remove(_config) {},
+    target(_config) {
+      return {
+        type: "remote",
+        url: `http://localhost:${PORT!}/`,
+      }
+    },
+  })
+
+  return {}
+}
+
+export default DebugWorkspacePlugin

package/src/engine/control-plane/schema.ts

@@ -1,14 +1,14 @@
-import { Schema } from "effect"
-
-import { Identifier } from "@/id/id"
-import { withStatics } from "@opencode-ai/core/schema"
-
-const workspaceIdSchema = Schema.String.check(Schema.isStartsWith("wrk")).pipe(Schema.brand("WorkspaceID"))
-
-export type WorkspaceID = typeof workspaceIdSchema.Type
-
-export const WorkspaceID = workspaceIdSchema.pipe(
-  withStatics((schema: typeof workspaceIdSchema) => ({
-    ascending: (id?: string) => schema.make(Identifier.ascending("workspace", id)),
-  })),
-)
+import { Schema } from "effect"
+
+import { Identifier } from "@/id/id"
+import { withStatics } from "@opencode-ai/core/schema"
+
+const workspaceIdSchema = Schema.String.check(Schema.isStartsWith("wrk")).pipe(Schema.brand("WorkspaceID"))
+
+export type WorkspaceID = typeof workspaceIdSchema.Type
+
+export const WorkspaceID = workspaceIdSchema.pipe(
+  withStatics((schema: typeof workspaceIdSchema) => ({
+    ascending: (id?: string) => schema.make(Identifier.ascending("workspace", id)),
+  })),
+)