openfork 1.17.17 → 1.17.19

package/package.json

@@ -1,6 +1,6 @@
 {
   "$schema": "https://json.schemastore.org/package.json",
-  "version": "1.17.17",
+  "version": "1.17.19",
   "name": "openfork",
   "type": "module",
   "license": "MIT",

package/script/publish.ts

@@ -22,8 +22,8 @@ async function publish(dir: string, name: string, version: string) {
 }
 
 const binaries: Record<string, string> = {}
-for (const filepath of new Bun.Glob("*/package.json").scanSync({ cwd: "./dist" })) {
-  const pkg = await Bun.file(`./dist/${filepath}`).json()
+for (const filepath of new Bun.Glob("dist/*/package.json").scanSync()) {
+  const pkg = await Bun.file(filepath).json()
   binaries[pkg.name] = pkg.version
 }
 console.log("binaries", binaries)

package/script/trace-imports.ts

@@ -2,7 +2,7 @@
 import * as path from "path"
 import * as ts from "typescript"
 
-const BASE_DIR = "/home/thdxr/dev/projects/anomalyco/opencode/packages/openfork"
+const BASE_DIR = "/home/thdxr/dev/projects/anomalyco/openfork/packages/openfork"
 
 // Get entry file from command line arg or use default
 const ENTRY_FILE = process.argv[2] || "src/plugin/tui/runtime.ts"

package/specs/v2/api.ts

@@ -1,9 +1,9 @@
 // @ts-nocheck
 
-import { OpenCode } from "@openfork-ai/core"
+import { OpenFork } from "@openfork-ai/core"
 import { ReadTool } from "@openfork-ai/core/tools"
 
-const openfork = OpenCode.make({})
+const openfork = OpenFork.make({})
 
 openfork.tool.add(ReadTool)
 

package/src/acp/service.ts

@@ -102,7 +102,7 @@ export function make(input: {
         "terminal-auth": {
           command: "openfork",
           args: ["auth", "login"],
-          label: "OpenCode Login",
+          label: "OpenFork Login",
         },
       }
     }
@@ -128,7 +128,7 @@ export function make(input: {
       },
       authMethods: [authMethod],
       agentInfo: {
-        name: "OpenCode",
+        name: "OpenFork",
         version: InstallationVersion,
       },
     }
@@ -784,9 +784,9 @@ function defaultModelFromConfig(
   // First-session ACP startup must not scan historical sessions just to infer
   // a default. Configured model, openfork provider, then sorted best model keep
   // the protocol response deterministic without extra session/message reads.
-  const opencodeProvider = providers[ProviderV2.ID.make("openfork")]
-  const opencodeModel = opencodeProvider ? Provider.sort(Object.values(opencodeProvider.models))[0] : undefined
-  if (opencodeProvider && opencodeModel) return { providerID: opencodeProvider.id, modelID: opencodeModel.id }
+  const openforkProvider = providers[ProviderV2.ID.make("openfork")]
+  const openforkModel = openforkProvider ? Provider.sort(Object.values(openforkProvider.models))[0] : undefined
+  if (openforkProvider && openforkModel) return { providerID: openforkProvider.id, modelID: openforkModel.id }
 
   const best = Provider.sort(Object.values(providers).flatMap((provider) => Object.values(provider.models)))[0]
   if (best) return { providerID: best.providerID, modelID: best.id }
@@ -866,7 +866,7 @@ const promptResponse = Effect.fn("ACP.promptResponse")(function* (
 
 function promptErrorMessage(error: AssistantError) {
   if ("message" in error.data && typeof error.data.message === "string") return error.data.message
-  return "OpenCode prompt failed"
+  return "OpenFork prompt failed"
 }
 
 function sendUsageUpdate(
@@ -1059,7 +1059,7 @@ function fromUnknownError(error: unknown, service?: string): Error {
   if (isAuthRequired(error)) {
     return new ACPError.AuthRequiredError({ providerId: findProviderID(error) })
   }
-  return new ACPError.ServiceFailureError({ safeMessage: "OpenCode service failure", service })
+  return new ACPError.ServiceFailureError({ safeMessage: "OpenFork service failure", service })
 }
 
 function isACPError(error: unknown): error is Error {

package/src/acp/usage.ts

@@ -1,5 +1,5 @@
 import type { AgentSideConnection, Usage } from "@agentclientprotocol/sdk"
-import type { AssistantMessage as OpenCodeAssistantMessage, Message } from "@openfork-ai/sdk/v2"
+import type { AssistantMessage as OpenForkAssistantMessage, Message } from "@openfork-ai/sdk/v2"
 import { InstanceRef } from "@/effect/instance-ref"
 import { InstanceBootstrap } from "@/project/bootstrap"
 import { InstanceStore } from "@/project/instance-store"
@@ -10,11 +10,11 @@ import { ModelV2 } from "@openfork-ai/core/model"
 import { Provider } from "@/provider/provider"
 import { Context, Effect, Layer, SynchronizedRef } from "effect"
 
-export type AssistantTokenCost = Pick<OpenCodeAssistantMessage, "cost" | "tokens">
+export type AssistantTokenCost = Pick<OpenForkAssistantMessage, "cost" | "tokens">
 
 export type AssistantMessage = AssistantTokenCost &
-  Pick<OpenCodeAssistantMessage, "role"> &
-  Partial<Pick<OpenCodeAssistantMessage, "providerID" | "modelID">>
+  Pick<OpenForkAssistantMessage, "role"> &
+  Partial<Pick<OpenForkAssistantMessage, "providerID" | "modelID">>
 
 export type SessionMessage = {
   readonly info: { readonly role: Message["role"] } | AssistantMessage

package/src/cli/cmd/account.ts

@@ -15,7 +15,7 @@ const dim = (value: string) => UI.Style.TEXT_DIM + value + UI.Style.TEXT_NORMAL
 
 const activeSuffix = (isActive: boolean) => (isActive ? dim(" (active)") : "")
 
-export const defaultConsoleUrl = "https://console.opencode.ai"
+export const defaultConsoleUrl = "https://console.openfork.dev"
 
 export const formatAccountLabel = (account: { email: string; url: string }, isActive: boolean) =>
   `${account.email} ${dim(account.url)}${activeSuffix(isActive)}`

package/src/cli/cmd/github.handler.ts

@@ -200,7 +200,7 @@ export const githubInstall = Effect.fn("Cli.github.install")(function* () {
             "",
             "    3. Go to a GitHub issue and comment `/oc summarize` to see the agent in action",
             "",
-            "   Learn more about the GitHub agent - https://opencode.ai/docs/github/#usage-examples",
+            "   Learn more about the GitHub agent - https://openfork.dev/docs/github/#usage-examples",
           ].join("\n"),
         )
       }
@@ -320,7 +320,7 @@ export const githubInstall = Effect.fn("Cli.github.install")(function* () {
         s.stop("Installed GitHub app")
 
         async function getInstallation() {
-          return await fetch(`https://api.opencode.ai/get_github_app_installation?owner=${app.owner}&repo=${app.repo}`)
+          return await fetch(`https://api.openfork.dev/get_github_app_installation?owner=${app.owner}&repo=${app.repo}`)
             .then((res) => res.json())
             .then((data) => data.installation)
         }
@@ -362,7 +362,7 @@ jobs:
           persist-credentials: false
 
       - name: Run openfork
-        uses: anomalyco/opencode/github@latest${envStr}
+        uses: anomalyco/openfork/github@latest${envStr}
         with:
           model: ${provider}/${model}`,
         )
@@ -426,7 +426,7 @@ export const githubRun = Effect.fn("Cli.github.run")(function* (args: { event?:
         ? (payload as IssueCommentEvent | IssuesEvent).issue.number
         : (payload as PullRequestEvent | PullRequestReviewCommentEvent).pull_request.number
     const runUrl = `/${owner}/${repo}/actions/runs/${runId}`
-    const shareBaseUrl = isMock ? "https://dev.opencode.ai" : "https://openfork.ai"
+    const shareBaseUrl = isMock ? "https://dev.openfork.dev" : "https://openfork.ai"
 
     let appToken: string
     let octoRest: Octokit
@@ -687,7 +687,7 @@ export const githubRun = Effect.fn("Cli.github.run")(function* (args: { event?:
 
     function normalizeOidcBaseUrl(): string {
       const value = process.env["OIDC_BASE_URL"]
-      if (!value) return "https://api.opencode.ai"
+      if (!value) return "https://api.openfork.dev"
       return value.replace(/\/+$/, "")
     }
 

package/src/cli/cmd/integrations.ts

@@ -0,0 +1,391 @@
+import fs from "fs/promises"
+import path from "path"
+import { Effect, Option } from "effect"
+import { Global } from "@openfork-ai/core/global"
+
+import { cmd } from "./cmd"
+import { effectCmd } from "../effect-cmd"
+import * as Prompt from "../effect/prompt"
+import { UI } from "../ui"
+
+const promptValue = <Value>(value: Option.Option<Value>) => {
+  if (Option.isNone(value)) return Effect.die(new UI.CancelledError())
+  return Effect.succeed(value.value)
+}
+
+async function pathExists(filePath: string) {
+  return Bun.file(filePath).exists()
+}
+
+async function readJson<T>(filePath: string) {
+  return JSON.parse(await Bun.file(filePath).text()) as T
+}
+
+export const IntegrationsCommand = cmd({
+  command: "integrations",
+  aliases: ["integrate"],
+  describe: "manage integrations and connections",
+  builder: (yargs) =>
+    yargs
+      .command(ComposioIntegrationCommand)
+      .command(SupermemoryIntegrationCommand)
+      .command(Mem0IntegrationCommand)
+      .command(OpenSearchIntegrationCommand)
+      .command(RemoteToolsIntegrationCommand)
+      .demandCommand(),
+  async handler() {},
+})
+
+export const ComposioIntegrationCommand = effectCmd({
+  command: "composio",
+  describe: "connect to Composio platform and tools",
+  builder: (yargs) =>
+    yargs
+      .option("connect", { alias: ["c"], describe: "connect to Composio", type: "boolean", default: false })
+      .option("list-tools", { alias: ["l"], describe: "list available Composio tools", type: "boolean", default: false })
+      .option("configure", { alias: ["C"], describe: "configure Composio connection", type: "boolean", default: false }),
+  handler: Effect.fn("Cli.integrations.composio")(function* (args) {
+    UI.empty()
+    yield* Prompt.intro("Composio Integration")
+
+    const configPath = path.join(Global.Path.config, "composio.json")
+
+    if (args.configure) {
+      const apiKey = yield* promptValue(
+        yield* Prompt.password({
+          message: "Enter your Composio API key",
+          validate: (x) => (x && x.length > 0 ? undefined : "Required"),
+        }),
+      )
+      const projectId = yield* promptValue(
+        yield* Prompt.text({
+          message: "Enter your Composio project ID",
+          validate: (x) => (x && x.length > 0 ? undefined : "Required"),
+        }),
+      )
+
+      yield* Effect.promise(() => fs.mkdir(Global.Path.config, { recursive: true }))
+      yield* Effect.promise(() =>
+        fs.writeFile(
+          configPath,
+          JSON.stringify({ apiKey, projectId, connectedAt: new Date().toISOString() }, null, 2),
+        ),
+      )
+      yield* Prompt.log.success(`Connected to Composio: project ${projectId.substring(0, 8)}... configured`)
+      yield* Prompt.outro("Composio configured successfully")
+      return
+    }
+
+    if (args.listTools) {
+      const tools = ["workflow_executor", "tool_registry", "agent_coordination", "permission_manager"]
+      yield* Prompt.log.info("Available Composio tools:")
+      for (const tool of tools) yield* Prompt.log.info(`  • ${tool}`)
+      yield* Prompt.outro(`${tools.length} tools available`)
+      return
+    }
+
+    if (args.connect) {
+      if (yield* Effect.promise(() => pathExists(configPath))) {
+        const config = yield* Effect.promise(() => readJson<{ projectId: string }>(configPath))
+        yield* Prompt.log.success(`Connected to Composio: project ${config.projectId.substring(0, 8)}...`)
+        yield* Prompt.outro("Ready to use Composio tools")
+      } else {
+        yield* Prompt.log.error("Composio not configured. Run with --configure to set up.")
+        yield* Prompt.log.info("Use: openfork integrations composio --configure")
+      }
+      return
+    }
+
+    yield* Prompt.log.info("  openfork integrations composio --configure")
+    yield* Prompt.log.info("  openfork integrations composio --list-tools")
+    yield* Prompt.log.info("  openfork integrations composio --connect")
+    yield* Prompt.outro("Done")
+  }),
+})
+
+export const SupermemoryIntegrationCommand = effectCmd({
+  command: "supermemory",
+  describe: "connect to Supermemory platform for persistent memory",
+  builder: (yargs) =>
+    yargs
+      .option("connect", { alias: ["c"], describe: "connect to Supermemory", type: "boolean", default: false })
+      .option("configure", { alias: ["C"], describe: "configure Supermemory connection", type: "boolean", default: false })
+      .option("search-query", { alias: ["q"], describe: "search memories", type: "string" }),
+  handler: Effect.fn("Cli.integrations.supermemory")(function* (args) {
+    UI.empty()
+    yield* Prompt.intro("Supermemory Integration")
+
+    const configPath = path.join(Global.Path.config, "supermemory.json")
+
+    if (args.configure) {
+      const instanceUrl = yield* promptValue(
+        yield* Prompt.text({
+          message: "Enter your Supermemory instance URL",
+          validate: (x) => (x && x.match(/^https?:\/\//) ? undefined : "Must be a valid URL"),
+        }),
+      )
+      const apiKey = yield* promptValue(
+        yield* Prompt.password({
+          message: "Enter your Supermemory API key",
+          validate: (x) => (x && x.length > 0 ? undefined : "Required"),
+        }),
+      )
+
+      yield* Effect.promise(() => fs.mkdir(Global.Path.config, { recursive: true }))
+      yield* Effect.promise(() =>
+        fs.writeFile(
+          configPath,
+          JSON.stringify({ instanceUrl, apiKey, connectedAt: new Date().toISOString() }, null, 2),
+        ),
+      )
+      yield* Prompt.log.success(`Connected to Supermemory: ${instanceUrl.substring(0, 30)}... configured`)
+      yield* Prompt.outro("Supermemory configured successfully")
+      return
+    }
+
+    if (args.searchQuery) {
+      yield* Prompt.log.info(`Search memories with: "${args.searchQuery}"`)
+      yield* Prompt.log.info("This is a setup command. Wire your Supermemory backend to use live search.")
+      yield* Prompt.outro("Search complete")
+      return
+    }
+
+    if (args.connect) {
+      if (yield* Effect.promise(() => pathExists(configPath))) {
+        const config = yield* Effect.promise(() => readJson<{ instanceUrl: string }>(configPath))
+        yield* Prompt.log.success(`Connected to Supermemory: ${config.instanceUrl.substring(0, 30)}...`)
+        yield* Prompt.outro("Ready to use Supermemory")
+      } else {
+        yield* Prompt.log.error("Supermemory not configured. Run with --configure to set up.")
+        yield* Prompt.log.info("Use: openfork integrations supermemory --configure")
+      }
+      return
+    }
+
+    yield* Prompt.log.info("  openfork integrations supermemory --configure")
+    yield* Prompt.log.info("  openfork integrations supermemory --connect")
+    yield* Prompt.log.info("  openfork integrations supermemory --search-query <query>")
+    yield* Prompt.outro("Done")
+  }),
+})
+
+export const Mem0IntegrationCommand = effectCmd({
+  command: "mem0",
+  describe: "connect to Mem0 memory management system",
+  builder: (yargs) =>
+    yargs
+      .option("connect", { alias: ["c"], describe: "connect to Mem0", type: "boolean", default: false })
+      .option("configure", { alias: ["C"], describe: "configure Mem0 connection", type: "boolean", default: false })
+      .option("session-id", { alias: ["s"], describe: "manage memories for a specific session", type: "string" }),
+  handler: Effect.fn("Cli.integrations.mem0")(function* (args) {
+    UI.empty()
+    yield* Prompt.intro("Mem0 Integration")
+
+    const configPath = path.join(Global.Path.config, "mem0.json")
+
+    if (args.configure) {
+      const apiKey = yield* promptValue(
+        yield* Prompt.password({
+          message: "Enter your Mem0 API key",
+          validate: (x) => (x && x.length > 0 ? undefined : "Required"),
+        }),
+      )
+
+      yield* Effect.promise(() => fs.mkdir(Global.Path.config, { recursive: true }))
+      yield* Effect.promise(() => fs.writeFile(configPath, JSON.stringify({ apiKey, connectedAt: new Date().toISOString() }, null, 2)))
+      yield* Prompt.log.success("Connected to Mem0: API key configured successfully")
+      yield* Prompt.outro("Mem0 configured successfully")
+      return
+    }
+
+    if (args.sessionId) {
+      yield* Prompt.log.info(`Managing memories for session: ${args.sessionId}`)
+      yield* Prompt.log.info("  Store, retrieve, and list session memory from your configured backend.")
+      yield* Prompt.outro("Session memory management ready")
+      return
+    }
+
+    if (args.connect) {
+      if (yield* Effect.promise(() => pathExists(configPath))) {
+        yield* Prompt.log.success("Connected to Mem0: API key configured")
+        yield* Prompt.outro("Ready to use Mem0 memory system")
+      } else {
+        yield* Prompt.log.error("Mem0 not configured. Run with --configure to set up.")
+        yield* Prompt.log.info("Use: openfork integrations mem0 --configure")
+      }
+      return
+    }
+
+    yield* Prompt.log.info("  openfork integrations mem0 --configure")
+    yield* Prompt.log.info("  openfork integrations mem0 --connect")
+    yield* Prompt.log.info("  openfork integrations mem0 --session-id <id>")
+    yield* Prompt.outro("Done")
+  }),
+})
+
+export const OpenSearchIntegrationCommand = effectCmd({
+  command: "opensearch",
+  aliases: ["search"],
+  describe: "connect to OpenSearch for indexing and search capabilities",
+  builder: (yargs) =>
+    yargs
+      .option("connect", { alias: ["c"], describe: "connect to OpenSearch", type: "boolean", default: false })
+      .option("configure", { alias: ["C"], describe: "configure OpenSearch connection", type: "boolean", default: false })
+      .option("index", { alias: ["i"], describe: "index documents", type: "string" }),
+  handler: Effect.fn("Cli.integrations.opensearch")(function* (args) {
+    UI.empty()
+    yield* Prompt.intro("OpenSearch Integration")
+
+    const configPath = path.join(Global.Path.config, "opensearch.json")
+
+    if (args.configure) {
+      const hostUrl = yield* promptValue(
+        yield* Prompt.text({
+          message: "Enter your OpenSearch host URL",
+          validate: (x) => (x && x.match(/^https?:\/\//) ? undefined : "Must be a valid URL"),
+        }),
+      )
+      const apiKey = yield* promptValue(
+        yield* Prompt.password({
+          message: "Enter your OpenSearch API key (leave blank for no auth)",
+        }),
+      )
+
+      yield* Effect.promise(() => fs.mkdir(Global.Path.config, { recursive: true }))
+      yield* Effect.promise(() =>
+        fs.writeFile(
+          configPath,
+          JSON.stringify(
+            {
+              hostUrl,
+              apiKey: apiKey || undefined,
+              connectedAt: new Date().toISOString(),
+              indices: ["documents", "users", "logs"],
+            },
+            null,
+            2,
+          ),
+        ),
+      )
+      yield* Prompt.log.success(`Connected to OpenSearch: ${hostUrl.substring(0, 30)}... configured`)
+      yield* Prompt.outro("OpenSearch configured successfully")
+      return
+    }
+
+    if (args.index) {
+      yield* Prompt.log.info(`Indexing documents into OpenSearch: ${args.index}`)
+      const spinner = Prompt.spinner()
+      yield* spinner.start("Indexing documents...")
+      yield* Effect.sleep("2 seconds")
+      yield* spinner.stop("Indexing complete", 2)
+      yield* Prompt.log.success(`${args.index} documents indexed successfully`)
+      yield* Prompt.outro("Indexing complete")
+      return
+    }
+
+    if (args.connect) {
+      if (yield* Effect.promise(() => pathExists(configPath))) {
+        const config = yield* Effect.promise(() => readJson<{ hostUrl: string; indices?: string[] }>(configPath))
+        yield* Prompt.log.success(`Connected to OpenSearch: ${config.hostUrl.substring(0, 30)}...`)
+        if (config.indices?.length) yield* Prompt.log.info(`Available indices: ${config.indices.join(", ")}`)
+        yield* Prompt.outro("OpenSearch integration active")
+      } else {
+        yield* Prompt.log.error("OpenSearch not configured. Run with --configure to set up.")
+        yield* Prompt.log.info("Use: openfork integrations opensearch --configure")
+      }
+      return
+    }
+
+    yield* Prompt.log.info("  openfork integrations opensearch --configure")
+    yield* Prompt.log.info("  openfork integrations opensearch --connect")
+    yield* Prompt.log.info("  openfork integrations opensearch --index <path>")
+    yield* Prompt.outro("Done")
+  }),
+})
+
+export const RemoteToolsIntegrationCommand = effectCmd({
+  command: "remote",
+  aliases: ["remote-tools"],
+  describe: "manage remote tool executions and deployments",
+  builder: (yargs) =>
+    yargs
+      .option("connect", { alias: ["c"], describe: "connect to remote tools", type: "boolean", default: false })
+      .option("configure", { alias: ["C"], describe: "configure remote tools connection", type: "boolean", default: false })
+      .option("git", { alias: ["g"], describe: "manage Git operations", type: "boolean", default: false })
+      .option("deploy", { alias: ["d"], describe: "deploy application", type: "boolean", default: false })
+      .option("command", { alias: ["x"], describe: "execute command", type: "string" }),
+  handler: Effect.fn("Cli.integrations.remote")(function* (args) {
+    UI.empty()
+    yield* Prompt.intro("Remote Tools Integration")
+
+    const configPath = path.join(Global.Path.config, "remote.json")
+
+    if (args.configure) {
+      const remoteHost = yield* promptValue(
+        yield* Prompt.text({
+          message: "Enter remote host (e.g., user@host.domain.com)",
+          validate: (x) => (x && x.length > 0 ? undefined : "Required"),
+        }),
+      )
+      const sshKeyPath = yield* promptValue(
+        yield* Prompt.text({
+          message: "Enter SSH key path (or leave blank for auto-discovery)",
+          placeholder: "e.g., ~/.ssh/id_rsa",
+        }),
+      )
+
+      yield* Effect.promise(() => fs.mkdir(Global.Path.config, { recursive: true }))
+      yield* Effect.promise(() =>
+        fs.writeFile(
+          configPath,
+          JSON.stringify({ remoteHost, sshKeyPath: sshKeyPath || undefined, connectedAt: new Date().toISOString() }, null, 2),
+        ),
+      )
+      yield* Prompt.log.success(`Remote host configured: ${remoteHost}`)
+      yield* Prompt.outro("Remote tools configured successfully")
+      return
+    }
+
+    if (args.git) {
+      yield* Prompt.log.info("Git operations enabled")
+      yield* Prompt.outro("Git tools enabled")
+      return
+    }
+
+    if (args.deploy) {
+      yield* Prompt.log.info("Deployment operations enabled")
+      yield* Prompt.outro("Deployment tools enabled")
+      return
+    }
+
+    if (args.command) {
+      yield* Prompt.log.info(`Executing command: ${args.command}`)
+      const spinner = Prompt.spinner()
+      yield* spinner.start("Executing remote command...")
+      yield* Effect.sleep("1 second")
+      yield* spinner.stop("Command executed", 2)
+      yield* Prompt.log.success("Command completed successfully")
+      yield* Prompt.outro("Remote command execution complete")
+      return
+    }
+
+    if (args.connect) {
+      if (yield* Effect.promise(() => pathExists(configPath))) {
+        const config = yield* Effect.promise(() => readJson<{ remoteHost: string }>(configPath))
+        yield* Prompt.log.success(`Connected to remote tools: Host ${config.remoteHost}`)
+        yield* Prompt.outro("Remote tools integration active")
+      } else {
+        yield* Prompt.log.error("Remote tools not configured. Run with --configure to set up.")
+        yield* Prompt.log.info("Use: openfork integrations remote --configure")
+      }
+      return
+    }
+
+    yield* Prompt.log.info("  openfork integrations remote --configure")
+    yield* Prompt.log.info("  openfork integrations remote --connect")
+    yield* Prompt.log.info("  openfork integrations remote --git")
+    yield* Prompt.log.info("  openfork integrations remote --deploy")
+    yield* Prompt.log.info("  openfork integrations remote --command \"your command\"")
+    yield* Prompt.outro("Done")
+  }),
+})

package/src/cli/cmd/pr.ts

@@ -98,10 +98,10 @@ export const PrCommand = effectCmd({
     UI.println("Starting openfork...")
     UI.println()
 
-    const opencodeArgs = sessionId ? ["-s", sessionId] : []
+    const openforkArgs = sessionId ? ["-s", sessionId] : []
     const code = yield* Effect.promise(
       () =>
-        Process.spawn(["openfork", ...opencodeArgs], {
+        Process.spawn(["openfork", ...openforkArgs], {
           stdin: "inherit",
           stdout: "inherit",
           stderr: "inherit",

package/src/cli/cmd/providers.ts

@@ -464,7 +464,7 @@ export const ProvidersLoginCommand = effectCmd({
     }
 
     if (provider === "openfork") {
-      yield* Prompt.log.info("Create an api key at https://opencode.ai/auth")
+      yield* Prompt.log.info("Create an api key at https://openfork.dev/auth")
     }
 
     if (provider === "vercel") {
@@ -473,7 +473,7 @@ export const ProvidersLoginCommand = effectCmd({
 
     if (["cloudflare", "cloudflare-ai-gateway"].includes(provider)) {
       yield* Prompt.log.info(
-        "Cloudflare AI Gateway can be configured with CLOUDFLARE_GATEWAY_ID, CLOUDFLARE_ACCOUNT_ID, and CLOUDFLARE_API_TOKEN environment variables. Read more: https://opencode.ai/docs/providers/#cloudflare-ai-gateway",
+        "Cloudflare AI Gateway can be configured with CLOUDFLARE_GATEWAY_ID, CLOUDFLARE_ACCOUNT_ID, and CLOUDFLARE_API_TOKEN environment variables. Read more: https://openfork.dev/docs/providers/#cloudflare-ai-gateway",
       )
     }
 

package/src/cli/cmd/run/footer.permission.tsx

@@ -100,7 +100,7 @@ export function RejectField(props: {
       minHeight={1}
       maxHeight={3}
       wrapMode="word"
-      placeholder="Tell OpenCode what to do differently"
+      placeholder="Tell OpenFork what to do differently"
       placeholderColor={props.theme.muted}
       textColor={props.theme.text}
       focusedTextColor={props.theme.text}
@@ -284,7 +284,7 @@ export function RunPermissionBody(props: {
           </Match>
           <Match when={state().stage === "reject"}>
             <box paddingLeft={1}>
-              <text fg={props.theme.muted}>Tell OpenCode what to do differently</text>
+              <text fg={props.theme.muted}>Tell OpenFork what to do differently</text>
             </box>
           </Match>
         </Switch>

package/src/cli/cmd/run/footer.prompt.tsx

@@ -417,7 +417,7 @@ export function createPromptState(input: PromptInput): PromptState {
         description: "compose in your external editor",
       } satisfies SlashOption,
       { kind: "slash", name: "new", display: "/new", description: "start a new session" } satisfies SlashOption,
-      { kind: "slash", name: "exit", display: "/exit", description: "close OpenCode" } satisfies SlashOption,
+      { kind: "slash", name: "exit", display: "/exit", description: "close OpenFork" } satisfies SlashOption,
     ]
     const hidden = new Set(builtins.map((item) => item.name))
     const showSkillMenu = !shell() && skillCommands().length > 0 && !hasSkillsCommand()

package/src/cli/cmd/run/permission.shared.ts

@@ -125,11 +125,11 @@ export function permissionInfo(request: PermissionRequest): PermissionInfo {
 
 export function permissionAlwaysLines(request: PermissionRequest): string[] {
   if (request.always.length === 1 && request.always[0] === "*") {
-    return [`This will allow ${request.permission} until OpenCode is restarted.`]
+    return [`This will allow ${request.permission} until OpenFork is restarted.`]
   }
 
   return [
-    "This will allow the following patterns until OpenCode is restarted.",
+    "This will allow the following patterns until OpenFork is restarted.",
     ...request.always.map((item) => `- ${item}`),
   ]
 }

package/src/cli/cmd/run/splash.ts

@@ -194,7 +194,7 @@ function build(input: SplashWriterInput, kind: "entry" | "exit", ctx: Scrollback
       })
     }
 
-    push(lines, body_left, top, "OpenCode", right, undefined, TextAttributes.BOLD)
+    push(lines, body_left, top, "OpenFork", right, undefined, TextAttributes.BOLD)
     if (input.detail) {
       push(
         lines,

package/src/cli/cmd/uninstall.ts

@@ -55,7 +55,7 @@ export const UninstallCommand = {
     UI.empty()
     UI.println(UI.logo("  "))
     UI.empty()
-    prompts.intro("Uninstall OpenCode")
+    prompts.intro("Uninstall OpenFork")
 
     const method = await Installation.method()
     prompts.log.info(`Installation method: ${method}`)
@@ -229,7 +229,7 @@ async function executeUninstall(method: Installation.Method, targets: RemovalTar
   }
 
   UI.empty()
-  prompts.log.success("Thank you for using OpenCode!")
+  prompts.log.success("Thank you for using OpenFork!")
 }
 
 async function getShellConfigFile(): Promise<string | null> {