orynacode-ai 1.16.9 → 1.16.11

package/package.json

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

package/src/cli/upgrade.ts

@@ -6,6 +6,7 @@ import { InstallationVersion } from "@opencode-ai/core/installation/version"
 import { GlobalBus } from "@/bus/global"
 
 export async function upgrade() {
+  if (InstallationVersion.startsWith("0.0.0-")) return
   const config = await AppRuntime.runPromise(Config.Service.use((cfg) => cfg.getGlobal()))
   if (config.autoupdate === false || Flag.OPENCODE_DISABLE_AUTOUPDATE) return
   const method = await Installation.method()

package/src/oryna/agent.ts

@@ -60,7 +60,7 @@ export function start() {
 
   const host = new URL(url).host
   const user = os.userInfo().username || "user"
-  const token = `sk-local-${user}-${path.basename(process.cwd())}`
+  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 = () => {

package/src/plugin/oryna.ts

@@ -224,6 +224,22 @@ function mapOrynaModels(data: Record<string, any>): Record<string, any> {
   return result
 }
 
+export async function reAuthOryna(): Promise<string> {
+  const port = await startOAuthServer()
+  const state = randomState()
+  const redirectUri = `http://127.0.0.1:${port}/callback`
+  const loginUrl = `${ORYNA_LOGIN_URL}?redirect_uri=${encodeURIComponent(redirectUri)}&state=${state}`
+
+  const tokenPromise = waitForToken(state)
+  await open(loginUrl)
+
+  try {
+    return await tokenPromise
+  } finally {
+    stopOAuthServer()
+  }
+}
+
 export async function OrynaAuthPlugin(input: PluginInput): Promise<Hooks> {
   return {
     provider: {
@@ -251,15 +267,18 @@ export async function OrynaAuthPlugin(input: PluginInput): Promise<Hooks> {
 
         if (jwtExpired(jwt)) {
           if (!_refreshPromise) {
-            _refreshPromise = refreshJwt(jwt).catch(() => {
+            _refreshPromise = refreshJwt(jwt).catch(async () => {
               _refreshPromise = undefined
-              return jwt
+              log.info("oryna token refresh failed, removing stale auth")
+              await (input.client as any)._client.delete({ url: "/auth/{id}", path: { id: "oryna" } }).catch(() => {})
+              log.info("oryna stale auth removed")
+              return ""
             })
           }
           jwt = await _refreshPromise
           _refreshPromise = undefined
 
-          if (jwt !== auth.key) {
+          if (jwt && jwt !== auth.key) {
             await input.client.auth
               .set({
                 path: { id: "oryna" },
@@ -269,7 +288,7 @@ export async function OrynaAuthPlugin(input: PluginInput): Promise<Hooks> {
           }
         }
 
-        return { apiKey: jwt }
+        return jwt ? { apiKey: jwt } : {}
       },
       methods: [
         {
@@ -277,36 +296,20 @@ export async function OrynaAuthPlugin(input: PluginInput): Promise<Hooks> {
           label: "Login with Oryna AI (Browser)",
           authorize: async () => {
             try {
-              const port = await startOAuthServer()
-              const state = randomState()
-              const redirectUri = `http://127.0.0.1:${port}/callback`
-              const loginUrl = `${ORYNA_LOGIN_URL}?redirect_uri=${encodeURIComponent(redirectUri)}&state=${state}`
-
-              const tokenPromise = waitForToken(state)
-
-              await open(loginUrl)
-
+              const tokenPromise = reAuthOryna()
               return {
-                url: loginUrl,
+                url: ORYNA_LOGIN_URL,
                 instructions: "Complete login in your browser. This window will close automatically when done.",
                 method: "auto" as const,
                 callback: async () => {
                   try {
-                    const token = await tokenPromise
-                    return {
-                      type: "success" as const,
-                      key: token,
-                    }
-                  } catch (err) {
-                    log.error("oryna login callback failed", { error: err })
+                    return { type: "success" as const, key: await tokenPromise }
+                  } catch {
                     return { type: "failed" as const }
-                  } finally {
-                    stopOAuthServer()
                   }
                 },
               }
-            } catch (err) {
-              log.error("oryna login authorize failed", { error: err })
+            } catch {
               return {
                 url: ORYNA_LOGIN_URL,
                 instructions: "Failed to start login server. Please use API key instead.",

package/src/provider/provider.ts

@@ -1521,9 +1521,9 @@ export const layer = Layer.effect(
               toPublicInfo(dbInfo),
             ),
           )
-          const opts = options ?? {}
-          const patch: Partial<Info> = providers[providerID] ? { options: opts } : { source: "custom", options: opts }
-          mergeProvider(providerID, patch)
+           const opts = options ?? {}
+           const patch: Partial<Info> = providers[providerID] ? { options: opts } : { source: "custom", options: opts }
+           mergeProvider(providerID, patch)
         }
 
         for (const [id, fn] of Object.entries(custom(dep))) {
@@ -1686,6 +1686,11 @@ 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 workspace = path.basename(process.env.ORYNA_GATE_WORKSPACE || process.cwd())
+          const user = os.userInfo().username || "user"
+          options["apiKey"] = `sk-local-${user}-${workspace}`
+        }
         if (model.headers)
           options["headers"] = {
             ...options["headers"],

package/src/session/processor.ts

@@ -952,7 +952,14 @@ export const layer = Layer.effect(
           sessionID: ctx.assistantMessage.sessionID,
           error: ctx.assistantMessage.error,
         })
-        yield* status.set(ctx.sessionID, { type: "idle" })
+        if (
+          error.name === "ProviderAuthError" ||
+          (error.data as any)?.statusCode === 401
+        ) {
+          yield* status.set(ctx.sessionID, { type: "needs_auth", providerID: String(input.model.providerID) })
+        } else {
+          yield* status.set(ctx.sessionID, { type: "idle" })
+        }
       })
 
       const process = Effect.fn("SessionProcessor.process")(function* (streamInput: LLM.StreamInput) {

package/src/session/status.ts

@@ -28,6 +28,10 @@ export const Info = Schema.Union([
   Schema.Struct({
     type: Schema.Literal("busy"),
   }),
+  Schema.Struct({
+    type: Schema.Literal("needs_auth"),
+    providerID: Schema.String,
+  }),
 ]).annotate({ identifier: "SessionStatus" })
 export type Info = Schema.Schema.Type<typeof Info>
 
@@ -76,6 +80,7 @@ export const layer = Layer.effect(
 
     const set = Effect.fn("SessionStatus.set")(function* (sessionID: SessionID, status: Info) {
       const data = yield* InstanceState.get(state)
+      if (status.type === "idle" && data.get(sessionID)?.type === "needs_auth") return
       yield* events.publish(Event.Status, { sessionID, status })
       if (status.type === "idle") {
         yield* events.publish(Event.Idle, { sessionID })

package/src/tool/registry.ts

@@ -240,7 +240,7 @@ export const layer: Layer.Layer<
           question: Tool.init(question),
           lsp: Tool.init(lsptool),
           plan: Tool.init(plan),
-          reply: Tool.init(replytool),
+          collab_reply: Tool.init(replytool),
         })
 
         return {
@@ -260,7 +260,7 @@ export const layer: Layer.Layer<
             tool.search,
             tool.skill,
             tool.patch,
-            tool.reply,
+            tool.collab_reply,
             ...(flags.experimentalLspTool ? [tool.lsp] : []),
             ...(flags.experimentalPlanMode && flags.client === "cli" ? [tool.plan] : []),
           ],

package/src/tool/reply.ts

@@ -12,7 +12,7 @@ export const Parameters = Schema.Struct({
 })
 
 export const ReplyTool = Tool.define(
-  "reply",
+  "collab_reply",
   Effect.gen(function* () {
     return {
       description: