fix: correct stale-dev-branch reset that broke typecheck

Previous cleanup commit (6cdc4d7) reset files against local 'dev'
branch, which was stale at June 2 — a month behind fork/local's
actual merge base. That reset plugin/index.ts, cli/error.ts,
session-data.ts, and session/prompt.ts to pre-LayerNode-refactor
versions, stripping the 'node' export that current tests require.

Fixed by fetching upstream/dev (current as of Jul 10) and re-resetting
against that instead. Also:
- Removed stray duplicate packages/opencode/src/cli/cmd/tui/worker.ts
  (leftover from the bad reset) — real file lives at
  packages/opencode/src/cli/tui/worker.ts (upstream path, unrelated
  to the dead patch-aft-lsp architecture change)
- Restored script/patch-aft-lsp.sh — it IS still referenced by the
  real (upstream-path) worker.ts at startup; my earlier 'dead code'
  classification was wrong, it was only dead in the stale duplicate

Verified: bun run typecheck passes clean (30/30 packages).

Author: rustybret

packages/opencode/script/patch-aft-lsp.sh

@@ -0,0 +1,61 @@
+#!/usr/bin/env bash
+#
+# Patches the @cortexkit/aft-opencode plugin to work around an npm v11+
+# regression where `npm install --no-save` into a bare directory (no
+# package.json) silently installs nothing.
+#
+# The fix: ensure a minimal package.json exists in the LSP cache dir
+# before npm runs.
+#
+# Run this after any opencode version upgrade or plugin update:
+#   ./packages/opencode/script/patch-aft-lsp.sh
+#
+# Safe to re-run (idempotent).
+
+set -euo pipefail
+
+PLUGIN_DIR="${HOME}/.cache/opencode/packages/@cortexkit/aft-opencode@latest"
+DIST_FILE="${PLUGIN_DIR}/node_modules/@cortexkit/aft-opencode/dist/index.js"
+
+if [[ ! -f "${DIST_FILE}" ]]; then
+  echo "[patch-aft-lsp] AFT plugin not found at ${DIST_FILE} — skipping."
+  exit 0
+fi
+
+# Already patched?
+if grep -q 'aft-lsp' "${DIST_FILE}" 2>/dev/null; then
+  echo "[patch-aft-lsp] Already patched — skipping."
+  exit 0
+fi
+
+# Find the runInstall function and inject the package.json stub creation.
+# The patch adds 6 lines after the "installing X to Y" log line.
+PATCHED=$(awk '
+/function runInstall\(spec, version2, cwd, signal\) \{/ {
+  print
+  found = 1
+  next
+}
+found && /log2\(`\[lsp\] installing/ {
+  print
+  # Inject the package.json stub creation
+  print "    try {"
+  print "      const pkgPath = join13(cwd, \"package.json\");"
+  print "      if (!existsSync5(pkgPath)) {"
+  print "        writeFileSync5(pkgPath, JSON.stringify({ name: \"aft-lsp\", private: true }));"
+  print "      }"
+  print "    } catch {}"
+  found = 0
+  next
+}
+{ print }
+' "${DIST_FILE}")
+
+if echo "${PATCHED}" | grep -q 'aft-lsp'; then
+  echo "${PATCHED}" > "${DIST_FILE}"
+  echo "[patch-aft-lsp] Patched ${DIST_FILE} successfully."
+else
+  echo "[patch-aft-lsp] WARNING: Could not locate injection point — patch not applied."
+  echo "  The plugin structure may have changed. Check manually."
+  exit 1
+fi

packages/opencode/src/cli/cmd/tui/worker.ts

@@ -94,6 +94,18 @@ export function FormatError(input: unknown): string | undefined {
     return stringField(configFrontmatter, "message") ?? ""
   }
 
+  // ConfigRemoteAuthError: { url: string, remote: string }
+  const remoteAuth = configData(input, "ConfigRemoteAuthError")
+  if (remoteAuth) {
+    const url = stringField(remoteAuth, "url")
+    const remote = stringField(remoteAuth, "remote")
+    return [
+      `Failed to load remote config${remote ? ` from ${remote}` : ""}: the server returned a login page instead of JSON.`,
+      `Authentication is missing or has expired (the endpoint is likely behind an SSO or identity-aware proxy).`,
+      ...(url ? [`Run \`opencode auth login ${url}\` to re-authenticate.`] : []),
+    ].join("\n")
+  }
+
   // ConfigInvalidError: { path?: string, message?: string, issues?: Array<{ message: string, path: string[] }> }
   const configInvalid = configData(input, "ConfigInvalidError")
   if (configInvalid) {

packages/opencode/src/cli/error.ts

@@ -1,3 +1,4 @@
+import { LayerNode } from "@opencode-ai/core/effect/layer-node"
 import type {
   Hooks,
   PluginInput,
@@ -6,7 +7,6 @@ import type {
   WorkspaceAdapter as PluginWorkspaceAdapter,
 } from "@opencode-ai/plugin"
 import { Config } from "@/config/config"
-import * as Log from "@opencode-ai/core/util/log"
 import { createOpencodeClient } from "@opencode-ai/sdk"
 import { ServerAuth } from "@/server/auth"
 import { CodexAuthPlugin } from "./openai/codex"
@@ -19,6 +19,7 @@ import { CloudflareAIGatewayAuthPlugin, CloudflareWorkersAuthPlugin } from "./cl
 import { AzureAuthPlugin } from "./azure"
 import { DigitalOceanAuthPlugin } from "./digitalocean"
 import { XaiAuthPlugin } from "./xai"
+import { SnowflakeCortexAuthPlugin } from "./snowflake-cortex"
 import { Effect, Layer, Context } from "effect"
 import { EffectBridge } from "@/effect/bridge"
 import { InstanceState } from "@/effect/instance-state"
@@ -31,8 +32,6 @@ import { RuntimeFlags } from "@/effect/runtime-flags"
 import { EventV2Bridge } from "@/event-v2-bridge"
 import { InstallationChannel } from "@opencode-ai/core/installation/version"
 
-const log = Log.create({ service: "plugin" })
-
 type State = {
   hooks: Hooks[]
 }
@@ -77,6 +76,7 @@ function internalPlugins(flags: RuntimeFlags.Info): PluginInstance[] {
     CloudflareAIGatewayAuthPlugin,
     AzureAuthPlugin,
     DigitalOceanAuthPlugin,
+    SnowflakeCortexAuthPlugin,
     XaiAuthPlugin,
   ]
 }
@@ -120,7 +120,7 @@ async function applyPlugin(load: PluginLoader.Loaded, input: PluginInput, hooks:
   }
 }
 
-export const layer = Layer.effect(
+const layer = Layer.effect(
   Service,
   Effect.gen(function* () {
     const events = yield* EventV2Bridge.Service
@@ -138,11 +138,12 @@ export const layer = Layer.effect(
 
         const { Server } = yield* Effect.promise(() => import("../server/server"))
 
+        const serverUrl = Server.url
         const client = createOpencodeClient({
-          baseUrl: "http://localhost:4096",
+          baseUrl: serverUrl?.toString() ?? "http://localhost:4096",
           directory: ctx.directory,
           headers: ServerAuth.headers(),
-          fetch: async (...args) => Server.Default().app.fetch(...args),
+          ...(serverUrl ? {} : { fetch: async (...args) => Server.Default().app.fetch(...args) }),
         })
         const cfg = yield* config.get()
         const input: PluginInput = {
@@ -163,19 +164,18 @@ export const layer = Layer.effect(
         }
 
         for (const plugin of flags.disableDefaultPlugins ? [] : internalPlugins(flags)) {
-          log.info("loading internal plugin", { name: plugin.name })
           const init = yield* Effect.tryPromise({
             try: () => plugin(input),
-            catch: (err) => {
-              log.error("failed to load internal plugin", { name: plugin.name, error: err })
-            },
-          }).pipe(Effect.option)
+            catch: errorMessage,
+          }).pipe(
+            Effect.tapError((error) => Effect.logError("failed to load internal plugin", { name: plugin.name, error })),
+            Effect.option,
+          )
           if (init._tag === "Some") hooks.push(init.value)
         }
 
         const plugins = flags.pure ? [] : (cfg.plugin_origins ?? [])
         if (flags.pure && cfg.plugin_origins?.length) {
-          log.info("skipping external plugins in pure mode", { count: cfg.plugin_origins.length })
         }
         if (plugins.length) yield* config.waitForDependencies()
 
@@ -184,37 +184,29 @@ export const layer = Layer.effect(
             items: plugins,
             kind: "server",
             report: {
-              start(candidate) {
-                log.info("loading plugin", { path: candidate.plan.spec })
-              },
-              missing(candidate, _retry, message) {
-                log.warn("plugin has no server entrypoint", { path: candidate.plan.spec, message })
-              },
+              start(candidate) {},
+              missing(candidate, _retry, message) {},
               error(candidate, _retry, stage, error, resolved) {
                 const spec = candidate.plan.spec
                 const cause = error instanceof Error ? (error.cause ?? error) : error
                 const message = stage === "load" ? errorMessage(error) : errorMessage(cause)
 
                 if (stage === "install") {
                   const parsed = parsePluginSpecifier(spec)
-                  log.error("failed to install plugin", { pkg: parsed.pkg, version: parsed.version, error: message })
                   publishPluginError(`Failed to install plugin ${parsed.pkg}@${parsed.version}: ${message}`)
                   return
                 }
 
                 if (stage === "compatibility") {
-                  log.warn("plugin incompatible", { path: spec, error: message })
                   publishPluginError(`Plugin ${spec} skipped: ${message}`)
                   return
                 }
 
                 if (stage === "entry") {
-                  log.error("failed to resolve plugin server entry", { path: spec, error: message })
                   publishPluginError(`Failed to load plugin ${spec}: ${message}`)
                   return
                 }
 
-                log.error("failed to load plugin", { path: spec, target: resolved?.entry, error: message })
                 publishPluginError(`Failed to load plugin ${spec}: ${message}`)
               },
             },
@@ -229,10 +221,10 @@ export const layer = Layer.effect(
             try: () => applyPlugin(load, input, hooks),
             catch: (err) => {
               const message = errorMessage(err)
-              log.error("failed to load plugin", { path: load.spec, error: message })
               return message
             },
           }).pipe(
+            Effect.tapError((error) => Effect.logError("failed to load plugin", { path: load.spec, error })),
             Effect.catch(() => {
               // TODO: make proper events for this
               // events.publish(Session.Event.Error, {
@@ -249,10 +241,11 @@ export const layer = Layer.effect(
         for (const hook of hooks) {
           yield* Effect.tryPromise({
             try: () => Promise.resolve((hook as any).config?.(cfg)),
-            catch: (err) => {
-              log.error("plugin config hook failed", { error: err })
-            },
-          }).pipe(Effect.ignore)
+            catch: errorMessage,
+          }).pipe(
+            Effect.tapError((error) => Effect.logError("plugin config hook failed", { error })),
+            Effect.ignore,
+          )
         }
 
         const unsubscribe = yield* events.listen((event) => {
@@ -271,10 +264,11 @@ export const layer = Layer.effect(
             (hook) =>
               Effect.tryPromise({
                 try: () => Promise.resolve(hook.dispose?.()),
-                catch: (error) => {
-                  log.error("plugin dispose hook failed", { error })
-                },
-              }).pipe(Effect.ignore),
+                catch: errorMessage,
+              }).pipe(
+                Effect.tapError((error) => Effect.logError("plugin dispose hook failed", { error })),
+                Effect.ignore,
+              ),
             { discard: true },
           ),
         )
@@ -311,10 +305,10 @@ export const layer = Layer.effect(
   }),
 )
 
-export const defaultLayer = layer.pipe(
-  Layer.provide(EventV2Bridge.defaultLayer),
-  Layer.provide(Config.defaultLayer),
-  Layer.provide(RuntimeFlags.defaultLayer),
-)
+export const node = LayerNode.make({
+  service: Service,
+  layer: layer,
+  deps: [EventV2Bridge.node, Config.node, RuntimeFlags.node],
+})
 
 export * as Plugin from "."