rimuru-ai 1.19.0 → 1.19.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "$schema": "https://json.schemastore.org/package.json",
-  "version": "1.19.0",
+  "version": "1.19.1",
   "name": "rimuru-ai",
   "description": "The open source AI coding agent — powered by Veldora",
   "keywords": [

package/src/cli/cmd/tui.ts

@@ -126,22 +126,6 @@ export const TuiThreadCommand = cmd({
       }
       const cwd = Filesystem.resolve(process.cwd())
 
-      const worker = new Worker(file)
-      const client = Rpc.client<typeof rpc>(worker)
-      const reload = () => {
-        client.call("reload", undefined).catch(() => {})
-      }
-      process.on("SIGUSR2", reload)
-
-      let stopped = false
-      const stop = async () => {
-        if (stopped) return
-        stopped = true
-        process.off("SIGUSR2", reload)
-        await withTimeout(client.call("shutdown", undefined), 5000).catch(() => {})
-        worker.terminate()
-      }
-
       const prompt = await input(args.prompt)
       const config = await TuiConfig.get()
 
@@ -154,17 +138,62 @@ export const TuiThreadCommand = cmd({
         network.port !== 0 ||
         network.hostname !== "127.0.0.1"
 
-      const transport = external
-        ? {
-            url: (await client.call("server", network)).url,
-            fetch: undefined,
-            events: undefined,
-          }
-        : {
-            url: "http://rimuru-ai.internal",
-            fetch: createWorkerFetch(client),
-            events: createEventSource(client),
-          }
+      let transport: { url: string; fetch?: typeof fetch; events?: EventSource }
+      let stop: () => Promise<void>
+      let onSnapshot: (() => Promise<string[]>) | undefined
+
+      try {
+        const worker = new Worker(file)
+        const client = Rpc.client<typeof rpc>(worker)
+
+        const reload = () => {
+          client.call("reload", undefined).catch(() => {})
+        }
+        process.on("SIGUSR2", reload)
+
+        let stopped = false
+        stop = async () => {
+          if (stopped) return
+          stopped = true
+          process.off("SIGUSR2", reload)
+          await withTimeout(client.call("shutdown", undefined), 5000).catch(() => {})
+          worker.terminate()
+        }
+
+        transport = external
+          ? {
+              url: (await client.call("server", network)).url,
+              fetch: undefined,
+              events: undefined,
+            }
+          : {
+              url: "http://rimuru-ai.internal",
+              fetch: createWorkerFetch(client),
+              events: createEventSource(client),
+            }
+
+        onSnapshot = async () => {
+          const tui = writeHeapSnapshot("tui.heapsnapshot")
+          const server = await client.call("snapshot", undefined)
+          return [tui, server]
+        }
+
+        setTimeout(() => {
+          client.call("checkUpgrade", { directory: cwd }).catch(() => {})
+        }, 1000).unref?.()
+      } catch {
+        UI.error("Worker unavailable, running in single-process mode")
+        const { Server } = await import("@/server/server")
+        const server = await Server.listen(network)
+        transport = {
+          url: server.url.toString(),
+          fetch: undefined,
+          events: undefined,
+        }
+        stop = async () => {
+          await server.stop(true).catch(() => {})
+        }
+      }
 
       try {
         await validateSession({
@@ -179,10 +208,6 @@ export const TuiThreadCommand = cmd({
         return
       }
 
-      setTimeout(() => {
-        client.call("checkUpgrade", { directory: cwd }).catch(() => {})
-      }, 1000).unref?.()
-
       try {
         const { Effect } = await import("effect")
         const { run } = await import("../tui/layer")
@@ -190,11 +215,7 @@ export const TuiThreadCommand = cmd({
         await Effect.runPromise(
           run({
             url: transport.url,
-            async onSnapshot() {
-              const tui = writeHeapSnapshot("tui.heapsnapshot")
-              const server = await client.call("snapshot", undefined)
-              return [tui, server]
-            },
+            onSnapshot,
             config,
             pluginHost: createLegacyTuiPluginHost(),
             directory: cwd,

package/src/config/config.ts

@@ -418,6 +418,47 @@ export const layer = Layer.effect(
           yield* Effect.logDebug("loading config from RIMURU_CONFIG_DIR", { path: Flag.RIMURU_CONFIG_DIR })
         }
 
+        // @ts-ignore - virtual module, only exists in compiled binary (see script/build.ts createEmbeddedPluginBundle)
+        const loadPluginBundle = (): Promise<string | null> => import("plugin-bundle.gen.ts").then((m) => (m.default as any)?.text?.() ?? null).catch(() => null)
+
+        const writePluginFallback = (dir: string): Effect.Effect<void> =>
+          Effect.gen(function* () {
+            yield* Effect.logWarning("background dependency install failed, using embedded plugin fallback", { dir })
+            const pluginDir = path.join(dir, "node_modules", "@rimurucode-ai", "plugin")
+            const distDir = path.join(pluginDir, "dist")
+
+            const content = yield* Effect.promise(() => loadPluginBundle())
+            if (!content) {
+              yield* Effect.logInfo("plugin-bundle.gen.ts not available (dev mode?), cannot write fallback")
+              return
+            }
+
+            yield* Effect.promise(() => fsNode.mkdir(distDir, { recursive: true }))
+
+            yield* fs.writeFileString(
+              path.join(pluginDir, "package.json"),
+              JSON.stringify({
+                name: "@rimurucode-ai/plugin",
+                version: InstallationLocal ? "0.0.0" : InstallationVersion,
+                type: "module",
+                main: "./dist/index.js",
+                exports: {
+                  ".": { default: "./dist/index.js" },
+                  "./tool": { default: "./dist/tool.js" },
+                },
+              }),
+            ).pipe(Effect.orDie)
+
+            yield* fs.writeFileString(
+              path.join(distDir, "index.js"),
+              `export * from "./tool.js";\n`,
+            ).pipe(Effect.orDie)
+
+            yield* fs.writeFileString(path.join(distDir, "tool.js"), content).pipe(Effect.orDie)
+
+            yield* Effect.logInfo("embedded plugin fallback written to disk", { dir: pluginDir })
+          })
+
         const deps: Fiber.Fiber<void>[] = []
 
         for (const dir of directories) {
@@ -447,7 +488,7 @@ export const layer = Layer.effect(
               Effect.exit,
               Effect.tap((exit) =>
                 Exit.isFailure(exit)
-                  ? Effect.logWarning("background dependency install failed", { dir, error: String(exit.cause) })
+                  ? writePluginFallback(dir)
                   : Effect.void,
               ),
               Effect.asVoid,

package/src/session/retry.ts

@@ -9,7 +9,7 @@ export type Err = ReturnType<NamedError["toObject"]>
 
 export const GO_UPSELL_MESSAGE = "Free usage exceeded, subscribe to Go"
 export const GO_UPSELL_URL = "https://github.com/gowdaman-dev/rimuru-ai/go"
-export type RetryReason = "free_tier_limit" | "account_rate_limit" | (string & {})
+export type RetryReason = "account_rate_limit" | (string & {})
 
 export type Retryable = {
   message: string
@@ -73,19 +73,6 @@ export function retryable(error: Err, provider: string) {
     // 5xx errors are transient server failures and should always be retried,
     // even when the provider SDK doesn't explicitly mark them as retryable.
     if (!error.data.isRetryable && !(status !== undefined && status >= 500)) return undefined
-    if (error.data.responseBody?.includes("FreeUsageLimitError")) {
-      return {
-        message: GO_UPSELL_MESSAGE,
-        action: {
-          reason: "free_tier_limit",
-          provider,
-          title: "Free limit reached",
-          message: "Subscribe to Rimuru Go for reliable access to the best open-source models, starting at $5/month.",
-          label: "subscribe",
-          link: GO_UPSELL_URL,
-        },
-      }
-    }
     if (error.data.responseBody?.includes("GoUsageLimitError")) {
       const body = parseJSON(error.data.responseBody)
       const workspace = str(body?.metadata?.workspace)