orynacode-ai 1.16.19 → 1.16.21

package/package.json

@@ -1,6 +1,6 @@
 {
   "$schema": "https://json.schemastore.org/package.json",
-  "version": "1.16.19",
+  "version": "1.16.21",
   "name": "orynacode-ai",
   "type": "module",
   "license": "MIT",

package/src/cli/cmd/tui.ts

@@ -217,9 +217,11 @@ export const TuiThreadCommand = cmd({
         return
       }
 
-      setTimeout(() => {
-        client.call("checkUpgrade", { directory: cwd }).catch(() => {})
-      }, 1000).unref?.()
+      if (process.env.OPENCODE_CLIENT !== "desktop") {
+        setTimeout(() => {
+          client.call("checkUpgrade", { directory: cwd }).catch(() => {})
+        }, 1000).unref?.()
+      }
 
       try {
         const { Effect } = await import("effect")

package/src/oryna/agent-signal.ts

@@ -7,6 +7,6 @@ export type AgentState = {
   url: string
 }
 
-export const [agentStatus, setAgentStatus] = createRoot(() =>
-  createSignal<AgentState>({ connected: false, processing: false, ready: false, url: "" }),
+export const agentStatus = createRoot(() =>
+  createSignal<AgentState>({ connected: false, processing: false, ready: false, url: "" })[0],
 )

package/src/oryna/agent.ts

@@ -1,136 +1,22 @@
 import { readFileSync } from "fs"
-import { setAgentStatus, agentStatus } from "./agent-signal"
 import os from "os"
 import path from "path"
 
 export function getOrynaGateId(dir: string): string {
   try {
     const config = JSON.parse(readFileSync(path.join(dir, ".orynagate"), "utf-8"))
+    if (config.ticket) return config.ticket
     if (config.id && typeof config.id === "string") return config.id
   } catch {}
   return path.basename(dir)
 }
 
-export function setReady(ready: boolean) {
-  const s = agentStatus()
-  setAgentStatus({ ...s, ready })
-}
-
-const REPLY_FILE = `/tmp/oryna-reply-${process.pid}`
-let ws: WebSocket | null = null
-let reconnectTimer: ReturnType<typeof setTimeout> | null = null
-let heartbeatTimer: ReturnType<typeof setInterval> | null = null
-let replyWatchTimer: ReturnType<typeof setInterval> | null = null
-let stopped = false
-let connecting = false
-let onMessage: ((content: string, from: string) => Promise<void>) | null = null
-
-export function setMessageHandler(fn: (content: string, from: string) => Promise<void>) {
-  onMessage = fn
-}
-
-function readAuthUrl(): string | undefined {
+export function getOrynaGateKey(dir: string): string {
+  const user = os.userInfo().username || "user"
   try {
-    const dataDir = process.env.XDG_DATA_HOME || path.join(os.homedir(), ".local", "share")
-    const authPath = path.join(dataDir, "orynacode", "auth.json")
-    const auth = JSON.parse(readFileSync(authPath, "utf-8"))
-    const local = auth?.["orynagate"]
-    if (local?.metadata?.url) return local.metadata.url
+    const config = JSON.parse(readFileSync(path.join(dir, ".orynagate"), "utf-8"))
+    if (config.ticket) return `sk-ticket-${user}-${config.ticket}`
+    if (config.id && typeof config.id === "string") return `sk-local-${user}-${config.id}`
   } catch {}
-  return undefined
-}
-
-function startReplyWatch() {
-  if (replyWatchTimer) return
-  let offset = 0
-  replyWatchTimer = setInterval(() => {
-    try {
-      const raw = readFileSync(REPLY_FILE, "utf-8")
-      const lines = raw.split("\n")
-      let sent = 0
-      for (let i = offset; i < lines.length; i++) {
-        const line = lines[i].trim()
-        if (!line) continue
-        if (ws?.readyState === WebSocket.OPEN) {
-          ws.send(line)
-          sent++
-        }
-      }
-      offset += sent
-    } catch {}
-  }, 300)
-}
-
-export function start() {
-  stopped = false
-  const url = process.env.ORYNA_GATE_URL || readAuthUrl()
-  if (!url) return
-
-  const host = new URL(url).host
-  const user = os.userInfo().username || "user"
-  const token = `sk-local-${user}-${path.basename(process.env.ORYNA_GATE_WORKSPACE || process.cwd())}`
-  const wsUrl = `ws://${host}/ws?token=${token}&name=orynacode`
-
-  const connect = () => {
-    if (connecting) return
-    connecting = true
-    const socket = new WebSocket(wsUrl)
-    ws = socket
-
-    socket.addEventListener("open", () => {
-      startReplyWatch()
-      const s = agentStatus()
-      setAgentStatus({ connected: true, processing: false, ready: s.ready, url: host })
-      heartbeatTimer = setInterval(() => {
-        if (socket.readyState === WebSocket.OPEN) socket.send("__PING__")
-      }, 30000)
-    })
-
-    socket.addEventListener("message", async (event) => {
-      try {
-        const msg = JSON.parse(event.data.toString())
-        if (!msg.success) return
-        if (msg.recv === "hello") return
-        if (msg.recv === "error") return
-        if (msg.recv !== "message") return
-
-        const content = msg.data?.content
-        const from = msg.data?.from || "unknown"
-        if (!content) return
-
-        setTimeout(() => {
-          const s = agentStatus()
-          setAgentStatus({ connected: true, processing: true, ready: s.ready, url: host })
-        }, 0)
-        if (onMessage) await onMessage(content, from)
-        setTimeout(() => {
-          const s = agentStatus()
-          setAgentStatus({ connected: true, processing: false, ready: s.ready, url: host })
-        }, 0)
-      } catch {}
-    })
-
-    socket.addEventListener("close", () => {
-      connecting = false
-      const s = agentStatus()
-      setAgentStatus({ connected: false, processing: false, ready: s.ready, url: host })
-      if (!stopped) reconnectTimer = setTimeout(connect, 3000)
-    })
-
-    socket.addEventListener("error", () => {
-      socket.close()
-    })
-  }
-
-  connect()
-}
-
-export function stop() {
-  connecting = false
-  stopped = true
-  if (reconnectTimer) { clearTimeout(reconnectTimer); reconnectTimer = null }
-  if (heartbeatTimer) { clearInterval(heartbeatTimer); heartbeatTimer = null }
-  if (replyWatchTimer) { clearInterval(replyWatchTimer); replyWatchTimer = null }
-  if (ws) { ws.close(); ws = null }
-  setAgentStatus({ connected: false, processing: false, ready: false, url: "" })
+  return `sk-local-${user}-${path.basename(dir)}`
 }

package/src/oryna/reply-service.ts

@@ -1,12 +1,13 @@
-import { appendFileSync } from "fs"
+const REPLY_URL = process.env.ORYNA_GATE_REPLY_URL + "/reply"
 
-const FILE = `/tmp/oryna-reply-${process.pid}`
+export async function sendReply(content: string, to?: string) {
+  if (!content) return
 
-export function sendReply(content: string, to?: string) {
-  const args: Record<string, string> = { content }
-  if (to) args.to = to
-  appendFileSync(
-    FILE,
-    JSON.stringify({ cmd: "reply", args: JSON.stringify(args) }) + "\n",
-  )
+  if (REPLY_URL) {
+    fetch(REPLY_URL, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ content, to: to ?? "" }),
+    }).catch(() => {})
+  }
 }

package/src/plugin/oryna.ts

@@ -291,34 +291,38 @@ export async function OrynaAuthPlugin(input: PluginInput): Promise<Hooks> {
         return jwt ? { apiKey: jwt } : {}
       },
       methods: [
-        {
-          type: "oauth",
-          label: "Login with Oryna AI (Browser)",
-          authorize: async () => {
-            try {
-              const tokenPromise = reAuthOryna()
-              return {
-                url: ORYNA_LOGIN_URL,
-                instructions: "Complete login in your browser. This window will close automatically when done.",
-                method: "auto" as const,
-                callback: async () => {
+        ...(process.env.OPENCODE_CLIENT !== "desktop"
+          ? [
+              {
+                type: "oauth",
+                label: "Login with Oryna AI (Browser)",
+                authorize: async () => {
                   try {
-                    return { type: "success" as const, key: await tokenPromise }
+                    const tokenPromise = reAuthOryna()
+                    return {
+                      url: ORYNA_LOGIN_URL,
+                      instructions: "Complete login in your browser. This window will close automatically when done.",
+                      method: "auto" as const,
+                      callback: async () => {
+                        try {
+                          return { type: "success" as const, key: await tokenPromise }
+                        } catch {
+                          return { type: "failed" as const }
+                        }
+                      },
+                    }
                   } catch {
-                    return { type: "failed" as const }
+                    return {
+                      url: ORYNA_LOGIN_URL,
+                      instructions: "Failed to start login server. Please use API key instead.",
+                      method: "code" as const,
+                      callback: async () => ({ type: "failed" as const }),
+                    }
                   }
                 },
-              }
-            } catch {
-              return {
-                url: ORYNA_LOGIN_URL,
-                instructions: "Failed to start login server. Please use API key instead.",
-                method: "code" as const,
-                callback: async () => ({ type: "failed" as const }),
-              }
-            }
-          },
-        },
+              } as const,
+            ]
+          : []),
         {
           type: "api",
           label: "API key",

package/src/provider/provider.ts

@@ -7,7 +7,7 @@ import { NoSuchModelError, type Provider as SDK } from "ai"
 import { Log } from "@opencode-ai/core/util/log"
 import { Npm } from "@opencode-ai/core/npm"
 import { Hash } from "@opencode-ai/core/util/hash"
-import { getOrynaGateId } from "../oryna/agent"
+import { getOrynaGateKey } from "../oryna/agent"
 import { Plugin } from "../plugin"
 import { serviceUse } from "@opencode-ai/core/effect/service-use"
 import { type LanguageModelV3 } from "@ai-sdk/provider"
@@ -1688,9 +1688,7 @@ export const layer = Layer.effect(
         if (baseURL !== undefined) options["baseURL"] = baseURL
         if (options["apiKey"] === undefined && provider.key) options["apiKey"] = provider.key
         if (model.providerID === "orynagate") {
-          const id = getOrynaGateId(process.cwd())
-          const user = os.userInfo().username || "user"
-          options["apiKey"] = `sk-local-${user}-${id}`
+          options["apiKey"] = getOrynaGateKey(process.env.ORYNA_GATE_WORKSPACE || process.cwd())
         }
         if (model.headers)
           options["headers"] = {

package/src/server/routes/instance/httpapi/groups/session.ts

@@ -88,6 +88,7 @@ export const SessionPaths = {
   remove: `${root}/:sessionID`,
   update: `${root}/:sessionID`,
   fork: `${root}/:sessionID/fork`,
+  focus: `${root}/:sessionID/focus`,
   abort: `${root}/:sessionID/abort`,
   share: `${root}/:sessionID/share`,
   init: `${root}/:sessionID/init`,
@@ -250,6 +251,18 @@ export const SessionApi = HttpApi.make("session")
             description: "Create a new session by forking an existing session at a specific message point.",
           }),
         ),
+        HttpApiEndpoint.post("focus", SessionPaths.focus, {
+          params: { sessionID: SessionID },
+          query: WorkspaceRoutingQuery,
+          success: described(Schema.Boolean, "Session focused"),
+          error: [HttpApiError.BadRequest, ApiNotFoundError],
+        }).annotateMerge(
+          OpenApi.annotations({
+            identifier: "session.focus",
+            summary: "Focus session",
+            description: "Navigate the TUI to the specified session via SSE event.",
+          }),
+        ),
         HttpApiEndpoint.post("abort", SessionPaths.abort, {
           params: { sessionID: SessionID },
           query: WorkspaceRoutingQuery,

package/src/server/routes/instance/httpapi/handlers/session.ts

@@ -1,5 +1,6 @@
 import { PermissionV1 } from "@opencode-ai/core/v1/permission"
 import { Agent } from "@/agent/agent"
+import { GlobalBus } from "@/bus/global"
 import { SessionV1 } from "@opencode-ai/core/v1/session"
 import { EventV2Bridge } from "@/event-v2-bridge"
 import { Command } from "@/command"
@@ -410,6 +411,22 @@ export const sessionHandlers = HttpApiBuilder.group(InstanceHttpApi, "session",
       return yield* session.updatePart(payload)
     })
 
+    const focus = Effect.fn("SessionHttpApi.focus")(function* (ctx: {
+      params: { sessionID: SessionID }
+    }) {
+      const info = yield* requireSession(ctx.params.sessionID)
+      yield* Effect.sync(() => {
+        GlobalBus.emit("event", {
+          directory: info.directory,
+          payload: {
+            type: "tui.session.select",
+            properties: { sessionID: ctx.params.sessionID },
+          },
+        })
+      })
+      return true
+    })
+
     return handlers
       .handle("list", list)
       .handle("status", status)
@@ -423,6 +440,7 @@ export const sessionHandlers = HttpApiBuilder.group(InstanceHttpApi, "session",
       .handle("remove", remove)
       .handle("update", update)
       .handleRaw("fork", forkRaw)
+      .handle("focus", focus)
       .handle("abort", abort)
       .handle("init", init)
       .handle("share", share)

package/src/session/processor.ts

@@ -917,7 +917,7 @@ export const layer = Layer.effect(
 
         const msgs = yield* session.messages({ sessionID: ctx.sessionID }).pipe(Effect.orDie)
         const lastUser = msgs.findLast((m) => m.info.role === "user")
-        const collabMatch = (lastUser?.info as any)?.system?.match(/orynagate:from=(\S+)/)
+        const collabMatch = (lastUser?.info as any)?.system?.match(/collab:from=(\S+)/)
         if (collabMatch) {
           const userParts = lastUser?.parts ?? []
           const alreadyReplied = userParts.some((p) => p.type === "text" && (p as any).text?.includes("✓ Replied"))