orynacode-ai 1.16.8 → 1.16.10

package/package.json

@@ -1,6 +1,6 @@
 {
   "$schema": "https://json.schemastore.org/package.json",
-  "version": "1.16.8",
+  "version": "1.16.10",
   "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/installation/index.ts

@@ -136,11 +136,9 @@ export const layer: Layer.Layer<Service, never, HttpClient.HttpClient | AppProce
     )
 
     const getBrewFormula = Effect.fnUntraced(function* () {
-      const tapFormula = yield* text(["brew", "list", "--formula", "anomalyco/tap/opencode"])
-      if (tapFormula.includes("opencode")) return "anomalyco/tap/opencode"
-      const coreFormula = yield* text(["brew", "list", "--formula", "opencode"])
-      if (coreFormula.includes("opencode")) return "opencode"
-      return "opencode"
+      const tapFormula = yield* text(["brew", "list", "--formula", "oryna-ai/tap/orynacode"])
+      if (tapFormula.includes("orynacode")) return "oryna-ai/tap/orynacode"
+      return "oryna-ai/tap/orynacode"
     })
 
     const upgradeFailure = (method: Method, result?: { code: number; stdout: string; stderr: string }) => {
@@ -194,9 +192,7 @@ export const layer: Layer.Layer<Service, never, HttpClient.HttpClient | AppProce
           { name: "yarn", command: () => text(["yarn", "global", "list"]) },
           { name: "pnpm", command: () => text(["pnpm", "list", "-g", "--depth=0"]) },
           { name: "bun", command: () => text(["bun", "pm", "ls", "-g"]) },
-          { name: "brew", command: () => text(["brew", "list", "--formula", "opencode"]) },
-          { name: "scoop", command: () => text(["scoop", "list", "opencode"]) },
-          { name: "choco", command: () => text(["choco", "list", "--limit-output", "opencode"]) },
+          { name: "brew", command: () => text(["brew", "list", "--formula", "orynacode"]) },
         ]
 
         checks.sort((a, b) => {
@@ -209,8 +205,7 @@ export const layer: Layer.Layer<Service, never, HttpClient.HttpClient | AppProce
 
         for (const check of checks) {
           const output = yield* check.command()
-          const installedName =
-            check.name === "brew" || check.name === "choco" || check.name === "scoop" ? "opencode" : "opencode-ai"
+          const installedName = check.name === "brew" ? "orynacode" : "orynacode-ai"
           if (output.includes(installedName)) {
             return check.name
           }
@@ -228,45 +223,18 @@ export const layer: Layer.Layer<Service, never, HttpClient.HttpClient | AppProce
             const info = yield* Schema.decodeUnknownEffect(Schema.fromJsonString(BrewInfoV2))(infoJson)
             return info.formulae[0].versions.stable
           }
-          const response = yield* httpOk.execute(
-            HttpClientRequest.get("https://formulae.brew.sh/api/formula/opencode.json").pipe(
-              HttpClientRequest.acceptJson,
-            ),
-          )
-          const data = yield* HttpClientResponse.schemaBodyJson(BrewFormula)(response)
-          return data.versions.stable
         }
 
         if (detectedMethod === "npm" || detectedMethod === "bun" || detectedMethod === "pnpm") {
           const response = yield* httpOk.execute(
             HttpClientRequest.get(
-              `${yield* NpmConfig.registry(process.cwd())}/opencode-ai/${InstallationChannel}`,
+              `${yield* NpmConfig.registry(process.cwd())}/orynacode-ai/${InstallationChannel}`,
             ).pipe(HttpClientRequest.acceptJson),
           )
           const data = yield* HttpClientResponse.schemaBodyJson(NpmPackage)(response)
           return data.version
         }
 
-        if (detectedMethod === "choco") {
-          const response = yield* httpOk.execute(
-            HttpClientRequest.get(
-              "https://community.chocolatey.org/api/v2/Packages?$filter=Id%20eq%20%27opencode%27%20and%20IsLatestVersion&$select=Version",
-            ).pipe(HttpClientRequest.setHeaders({ Accept: "application/json;odata=verbose" })),
-          )
-          const data = yield* HttpClientResponse.schemaBodyJson(ChocoPackage)(response)
-          return data.d.results[0].Version
-        }
-
-        if (detectedMethod === "scoop") {
-          const response = yield* httpOk.execute(
-            HttpClientRequest.get(
-              "https://raw.githubusercontent.com/ScoopInstaller/Main/master/bucket/opencode.json",
-            ).pipe(HttpClientRequest.setHeaders({ Accept: "application/json" })),
-          )
-          const data = yield* HttpClientResponse.schemaBodyJson(ScoopManifest)(response)
-          return data.version
-        }
-
         const response = yield* httpOk.execute(
           HttpClientRequest.get("https://api.github.com/repos/oryna-ai/orynacode/releases/latest").pipe(
             HttpClientRequest.acceptJson,
@@ -282,24 +250,24 @@ export const layer: Layer.Layer<Service, never, HttpClient.HttpClient | AppProce
             upgradeResult = yield* upgradeCurl(target)
             break
           case "npm":
-            upgradeResult = yield* run(["npm", "install", "-g", `opencode-ai@${target}`])
+            upgradeResult = yield* run(["npm", "install", "-g", `orynacode-ai@${target}`])
             break
           case "pnpm":
-            upgradeResult = yield* run(["pnpm", "install", "-g", `opencode-ai@${target}`])
+            upgradeResult = yield* run(["pnpm", "install", "-g", `orynacode-ai@${target}`])
             break
           case "bun":
-            upgradeResult = yield* run(["bun", "install", "-g", `opencode-ai@${target}`])
+            upgradeResult = yield* run(["bun", "install", "-g", `orynacode-ai@${target}`])
             break
           case "brew": {
             const formula = yield* getBrewFormula()
             const env = { HOMEBREW_NO_AUTO_UPDATE: "1" }
             if (formula.includes("/")) {
-              const tap = yield* run(["brew", "tap", "anomalyco/tap"], { env })
+              const tap = yield* run(["brew", "tap", "oryna-ai/tap"], { env })
               if (tap.code !== 0) {
                 upgradeResult = tap
                 break
               }
-              const repo = yield* text(["brew", "--repo", "anomalyco/tap"])
+              const repo = yield* text(["brew", "--repo", "oryna-ai/tap"])
               const dir = repo.trim()
               if (dir) {
                 const pull = yield* run(["git", "pull", "--ff-only"], { cwd: dir, env })
@@ -312,12 +280,6 @@ export const layer: Layer.Layer<Service, never, HttpClient.HttpClient | AppProce
             upgradeResult = yield* run(["brew", "upgrade", formula], { env })
             break
           }
-          case "choco":
-            upgradeResult = yield* run(["choco", "upgrade", "opencode", `--version=${target}`, "-y"])
-            break
-          case "scoop":
-            upgradeResult = yield* run(["scoop", "install", `opencode@${target}`])
-            break
           default:
             return yield* new UpgradeFailedError({ stderr: `Unknown installation method: ${m}` })
         }

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/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: