soraacode 0.2.0 → 0.2.2

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

@@ -1,19 +0,0 @@
-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/control-plane/dev/debug-workspace-plugin.ts

@@ -1,73 +0,0 @@
-import type { Plugin } from "@soraacode/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/control-plane/types.ts

@@ -1,59 +0,0 @@
-import { Schema, Struct } from "effect"
-import { ProjectV2 } from "@soraacode/core/project"
-import type { InstanceContext } from "@/project/instance-context"
-import { WorkspaceV2 } from "@soraacode/core/workspace"
-import type { DeepMutable } from "@soraacode/core/schema"
-
-export const WorkspaceInfo = Schema.Struct({
-  id: WorkspaceV2.ID,
-  type: Schema.String,
-  name: Schema.String,
-  branch: Schema.optional(Schema.NullOr(Schema.String)),
-  directory: Schema.optional(Schema.NullOr(Schema.String)),
-  extra: Schema.optional(Schema.NullOr(Schema.Unknown)),
-  projectID: ProjectV2.ID,
-}).annotate({ identifier: "Workspace" })
-export type WorkspaceInfo = DeepMutable<Schema.Schema.Type<typeof WorkspaceInfo>>
-
-export const WorkspaceListedInfo = Schema.Struct(Struct.omit(WorkspaceInfo.fields, ["id"])).annotate({
-  identifier: "WorkspaceListedInfo",
-})
-export type WorkspaceListedInfo = DeepMutable<Schema.Schema.Type<typeof WorkspaceListedInfo>>
-
-export const WorkspaceAdapterEntry = Schema.Struct({
-  type: Schema.String,
-  name: Schema.String,
-  description: Schema.String,
-})
-export type WorkspaceAdapterEntry = Schema.Schema.Type<typeof WorkspaceAdapterEntry>
-
-export type Target =
-  | {
-      type: "local"
-      directory: string
-    }
-  | {
-      type: "remote"
-      url: string | URL
-      headers?: HeadersInit
-    }
-
-export type WorkspaceAdapterContext = {
-  readonly instance?: InstanceContext
-  readonly workspaceID?: WorkspaceV2.ID
-}
-
-export type WorkspaceAdapter = {
-  name: string
-  description: string
-  configure(info: WorkspaceInfo, context?: WorkspaceAdapterContext): WorkspaceInfo | Promise<WorkspaceInfo>
-  create(
-    info: WorkspaceInfo,
-    env: Record<string, string | undefined>,
-    from?: WorkspaceInfo,
-    context?: WorkspaceAdapterContext,
-  ): Promise<void>
-  list?(context?: WorkspaceAdapterContext): WorkspaceListedInfo[] | Promise<WorkspaceListedInfo[]>
-  remove(info: WorkspaceInfo, context?: WorkspaceAdapterContext): Promise<void>
-  target(info: WorkspaceInfo, context?: WorkspaceAdapterContext): Target | Promise<Target>
-}

package/src/control-plane/util.ts

@@ -1,39 +0,0 @@
-import { GlobalBus, type GlobalEvent } from "@/bus/global"
-import { Effect } from "effect"
-
-export function waitEvent(input: { timeout: number; signal?: AbortSignal; fn: (event: GlobalEvent) => boolean }) {
-  if (input.signal?.aborted) return Effect.fail(input.signal.reason ?? new Error("Request aborted"))
-
-  return Effect.callback<void, unknown>((resume) => {
-    const abort = () => {
-      cleanup()
-      resume(Effect.fail(input.signal?.reason ?? new Error("Request aborted")))
-    }
-
-    const handler = (event: GlobalEvent) => {
-      try {
-        if (!input.fn(event)) return
-        cleanup()
-        resume(Effect.void)
-      } catch (error) {
-        cleanup()
-        resume(Effect.fail(error))
-      }
-    }
-
-    const cleanup = () => {
-      clearTimeout(timeout)
-      GlobalBus.off("event", handler)
-      input.signal?.removeEventListener("abort", abort)
-    }
-
-    const timeout = setTimeout(() => {
-      cleanup()
-      resume(Effect.fail(new Error("Timed out waiting for global event")))
-    }, input.timeout)
-
-    GlobalBus.on("event", handler)
-    input.signal?.addEventListener("abort", abort, { once: true })
-    return Effect.sync(cleanup)
-  })
-}

package/src/control-plane/workspace-adapter-runtime.ts

@@ -1,51 +0,0 @@
-import { Effect } from "effect"
-import { EffectBridge } from "@/effect/bridge"
-import { InstanceRef, WorkspaceRef } from "@/effect/instance-ref"
-import { getAdapter } from "./adapters"
-import type { WorkspaceAdapter, WorkspaceInfo } from "./types"
-
-const context = Effect.gen(function* () {
-  return {
-    instance: yield* InstanceRef,
-    workspaceID: yield* WorkspaceRef,
-  }
-})
-
-export const target = (info: WorkspaceInfo) =>
-  Effect.gen(function* () {
-    const adapter = getAdapter(info.projectID, info.type)
-    const ctx = yield* context
-    return yield* EffectBridge.fromPromise(() => adapter.target(info, ctx))
-  })
-
-export const configure = (adapter: WorkspaceAdapter, info: WorkspaceInfo) =>
-  Effect.gen(function* () {
-    const ctx = yield* context
-    return yield* EffectBridge.fromPromise(() => adapter.configure(info, ctx))
-  })
-
-export const create = (
-  adapter: WorkspaceAdapter,
-  info: WorkspaceInfo,
-  env: Record<string, string | undefined>,
-  from?: WorkspaceInfo,
-) =>
-  Effect.gen(function* () {
-    const ctx = yield* context
-    return yield* EffectBridge.fromPromise(() => adapter.create(info, env, from, ctx))
-  })
-
-export const list = (adapter: WorkspaceAdapter) =>
-  Effect.gen(function* () {
-    const ctx = yield* context
-    return yield* EffectBridge.fromPromise(() => Promise.resolve(adapter.list?.(ctx) ?? []))
-  })
-
-export const remove = (info: WorkspaceInfo) =>
-  Effect.gen(function* () {
-    const adapter = getAdapter(info.projectID, info.type)
-    const ctx = yield* context
-    return yield* EffectBridge.fromPromise(() => adapter.remove(info, ctx))
-  })
-
-export * as WorkspaceAdapterRuntime from "./workspace-adapter-runtime"

package/src/control-plane/workspace-context.ts

@@ -1,26 +0,0 @@
-import { LocalContext } from "@/util/local-context"
-import type { WorkspaceV2 } from "@soraacode/core/workspace"
-
-export interface WorkspaceContext {
-  workspaceID: WorkspaceV2.ID | undefined
-}
-
-const context = LocalContext.create<WorkspaceContext>("instance")
-
-export const WorkspaceContext = {
-  async provide<R>(input: { workspaceID?: WorkspaceV2.ID; fn: () => R }): Promise<R> {
-    return context.provide({ workspaceID: input.workspaceID }, () => input.fn())
-  },
-
-  restore<R>(workspaceID: WorkspaceV2.ID, fn: () => R): R {
-    return context.provide({ workspaceID }, fn)
-  },
-
-  get workspaceID() {
-    try {
-      return context.use().workspaceID
-    } catch {
-      return undefined
-    }
-  },
-}