@takara-ai/miru-code 1.10.0 → 1.11.0

package/README.md

@@ -48,6 +48,7 @@ Plugin installs don't carry full CLI parity — what each one gives you depends
 | `miru` / Caveman / STE skills | ✅ | ✅ | ✅ |
 | Dedicated sub-agent (`miru:miru-code`) | ✅ | — | — |
 | Benchmark mode toggle (`/plugin configure`) | ✅ | — | — |
+| Self-hosted SageMaker embeddings (`/plugin configure`) | ✅ | — | — |
 | Credentials | own plugin-scoped dir | own plugin-scoped dir | n/a |
 
 `—` means the IDE's plugin schema has no equivalent mechanism to port these to (not a packaging gap we can close): Codex's and Cursor's plugin manifests have no `agents` or `userConfig` fields, so the dedicated sub-agent and the benchmark toggle are Claude-Code-only.
@@ -323,7 +324,7 @@ Miru sends **file contents** to the [Takara inference API](https://takara.ai) wh
 
 If you index proprietary code, make sure that sending snippets to Takara's endpoint fits your security and compliance requirements. `MIRU_WORKSPACE_ROOT` is an opt-in boundary for MCP local `repo` paths only, and restricts indexing to a single workspace directory when set.
 
-Enterprise self-hosted embeddings (no Takara egress): see [docs/self-hosted-sagemaker.md](docs/self-hosted-sagemaker.md).
+Enterprise self-hosted embeddings (no Takara egress): see [docs/self-hosted-sagemaker.md](docs/self-hosted-sagemaker.md), including the [Claude Code plugin settings](docs/self-hosted-sagemaker.md#claude-code-plugin).
 
 ## Benchmark mode
 

package/docs/self-hosted-sagemaker.md

@@ -174,6 +174,28 @@ After that, indexing and search embed via SageMaker — no egress to `infer.taka
 
 If `TAKARA_API_KEY` is still set in your shell or `.env.local`, remove it there too so it cannot conflict later.
 
+### Claude Code plugin
+
+The plugin has no terminal step. Do steps 1–3 first, then set the plugin settings. Run `/plugin`, open **miru**, and set:
+
+| Setting                  | Value                                                                                  |
+| ------------------------ | ---------------------------------------------------------------------------------------- |
+| `SageMaker endpoint ARN` | The `EndpointArn` output from step 2                                                     |
+| `AWS profile`            | The profile from step 3. It must already exist in `~/.aws`; Miru never creates one.       |
+
+Or from a shell, then restart Claude Code:
+
+```bash
+echo '{"sagemaker_endpoint_arn":"arn:aws:sagemaker:<region>:<account-id>:endpoint/<name>","aws_profile":"miru"}' \
+  | claude plugin configure miru@miru --values-stdin
+```
+
+When the ARN is set, it **takes priority over any stored Takara sign-in** and Miru does not contact `infer.takara.ai`. Nothing is deleted, so clearing the ARN returns you to Takara. Leaving the ARN blank means Takara is used. The profile is only read when an ARN is set.
+
+If the profile uses SSO, run `aws sso login --profile <name>` again whenever the token expires.
+
+The plugin's `auth` tool only handles Takara sign-in; SageMaker is configured through these settings only.
+
 ## Switch back to Takara
 
 ```bash
@@ -184,6 +206,8 @@ Enter your Takara API key. Setup validates it, saves it, and **deletes any store
 
 Also unset any `MIRU_SAGEMAKER_*` variables if you set them in the environment or `.env.local`.
 
+In the Claude Code plugin, clear the **SageMaker endpoint ARN** setting and restart.
+
 ## Environment alternatives
 
 Prefer `miru setup --sagemaker` so auth is checked automatically. You can also set:

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@takara-ai/miru-code",
-  "version": "1.10.0",
+  "version": "1.11.0",
   "mcpName": "ai.takara/miru",
   "description": "Miru (見る) — hybrid code search for agents. Bun, TypeScript, Takara embeddings.",
   "type": "module",

package/src/credentials.ts

@@ -116,6 +116,32 @@ function clearTakaraEnv(): void {
   delete process.env.TAKARA_API_KEY;
 }
 
+/** A plugin `userConfig` value, or undefined when blank or left as an unsubstituted `${...}`. */
+function pluginConfigValue(name: string): string | undefined {
+  const value = process.env[name]?.trim();
+  return value && !isUnsubstitutedPlaceholder(value) ? value : undefined;
+}
+
+/**
+ * Plugin settings (`sagemaker_endpoint_arn` / `aws_profile` in plugin.json) arrive as
+ * MIRU_PLUGIN_* env vars. When an endpoint is configured there it is an explicit choice, so it
+ * wins over any stored credentials; Takara env is dropped because the modes are exclusive.
+ */
+function applyPluginSageMakerConfig(): boolean {
+  const arn = pluginConfigValue("MIRU_PLUGIN_SAGEMAKER_ENDPOINT_ARN");
+  if (!arn) {
+    return false;
+  }
+  process.env.MIRU_SAGEMAKER_ENDPOINT_ARN = arn;
+  const profile = pluginConfigValue("MIRU_PLUGIN_AWS_PROFILE");
+  if (profile) {
+    process.env.AWS_PROFILE = profile;
+  }
+  clearTakaraEnv();
+  activeStoredToken = null;
+  return true;
+}
+
 function hydrateSageMakerEnv(sagemaker: StoredSageMakerCredentials): void {
   process.env.MIRU_SAGEMAKER_ENDPOINT_ARN = sagemaker.endpoint_arn;
   if (sagemaker.profile && !process.env.AWS_PROFILE) {
@@ -144,6 +170,9 @@ function markLoadedToken(token: string): void {
 /** Hydrate TAKARA_API_KEY / SageMaker env vars from the credentials file when env is unset. */
 export async function loadStoredCredentials(): Promise<boolean> {
   normalizeTakaraApiKeyEnv();
+  if (applyPluginSageMakerConfig()) {
+    return true;
+  }
   const stored = await readStoredCredentials();
   if (!stored) {
     return false;

package/src/mcp/auth-tool.ts

@@ -2,6 +2,7 @@ import * as z from "zod";
 import {
   checkDeviceAuthorizationOnce,
   type DeviceAuthConfig,
+  type DeviceAuthorizationCheck,
   type DeviceAuthorizationStart,
   openBrowserForDeviceLogin,
   resolveDeviceAuthConfig,
@@ -15,24 +16,37 @@ import type { MiruMcpServer } from "./runtime.ts";
 type ToolResult = ReturnType<typeof toolText>;
 
 const CHECK_HINT =
-  'Once the user approves, call `auth` again with action "check" to finish signing in.';
+  "If the user has not approved yet, call `auth` again to keep waiting; it will not open a second tab.";
+
+/**
+ * How long one `auth` call waits for the user to approve in the browser. Kept well under
+ * typical MCP client tool timeouts; a slower login just takes another call.
+ */
+const DEFAULT_WAIT_MS = 45_000;
+const SLOW_DOWN_STEP_MS = 5_000;
+/** The server may advertise `interval: 0`; never poll the token endpoint faster than this. */
+const MIN_POLL_INTERVAL_MS = 1_000;
 
 /** Appended to credentials failures so an agent knows Miru's own recovery step. */
 const RECOVERY_HINT =
-  'Miru could not authorize its current credentials. Call the `auth` tool with action "start" ' +
-  'to open the Takara device-login page, then action "check" once the user approves. If access ' +
-  "is still denied after signing in, check the account token balance.";
+  "Miru could not authorize its current credentials. Call the `auth` tool to open the Takara " +
+  "device-login page; it waits for the user to approve. If access is still denied after " +
+  "signing in, check the account token balance.";
 
 const AUTH_TOOL_DESCRIPTION =
   "Sign in with Takara credentials via device-code login — no terminal required. " +
   "Only call this in direct response to a tool error mentioning missing, expired, rejected, or " +
   "invalid credentials — never speculatively, since it starts a real sign-in prompt for the " +
-  'user. Call with no arguments (or action "start") to begin: it opens the device-login ' +
-  `page in the user's browser and returns that URL plus a short code. ${CHECK_HINT}`;
+  "user. Call with no arguments: it opens the device-login page in the user's browser, then " +
+  "waits (up to about 45 seconds) for them to approve and returns once they have. If it " +
+  'returns "still waiting", tell the user the URL and code and call `auth` again.';
 
 /** Browser opener seam; the real one spawns a detached `open`/`xdg-open`/`start`. */
 export type BrowserOpener = (url: string) => boolean;
 
+/** Sleep seam so tests can drive the wait loop without real delays. */
+export type Sleeper = (ms: number) => Promise<void>;
+
 /** Opening is on unless MIRU_OPEN_BROWSER is set to something other than "1" (matches `miru setup`). */
 function openIfAllowed(open: BrowserOpener, url: string): boolean {
   const raw = process.env.MIRU_OPEN_BROWSER;
@@ -42,8 +56,14 @@ function openIfAllowed(open: BrowserOpener, url: string): boolean {
   return open(url);
 }
 
-function approvalText(link: string, userCode: string, opened: boolean): string {
-  const lead = opened ? `A browser tab is open at ${link}` : `Ask the user to open ${link}`;
+/** `opened` is null when resuming an existing login (no new tab was opened). */
+function approvalText(link: string, userCode: string, opened: boolean | null): string {
+  const lead =
+    opened === null
+      ? `Still waiting for approval at ${link}`
+      : opened
+        ? `A browser tab is open at ${link}`
+        : `Ask the user to open ${link}`;
   return `${lead}. Code: ${userCode}. ${CHECK_HINT}`;
 }
 
@@ -71,11 +91,17 @@ function isExpired(entry: PendingDeviceAuth): boolean {
 class AuthToolState {
   private pending: PendingDeviceAuth | null = null;
 
-  constructor(private readonly openBrowser: BrowserOpener) {}
+  constructor(
+    private readonly openBrowser: BrowserOpener,
+    private readonly waitMs: number,
+    private readonly sleep: Sleeper,
+  ) {}
 
   async start(): Promise<ToolResult> {
     let pending = this.pending;
+    let fresh = false;
     if (!pending || isExpired(pending)) {
+      fresh = true;
       const config = resolveDeviceAuthConfig();
       const start = await startDeviceAuthorization({ config });
       pending = { start, config, startedAtMs: Date.now() };
@@ -84,21 +110,33 @@ class AuthToolState {
 
     const { verificationUriComplete, verificationUri, userCode } = pending.start;
     const link = verificationUriComplete ?? verificationUri;
-    // Reopening on a repeat call is deliberate: the user may have closed the first tab.
-    return toolText(approvalText(link, userCode, openIfAllowed(this.openBrowser, link)));
+    // Only a new login opens a tab; a repeat call just resumes the wait.
+    const opened = fresh ? openIfAllowed(this.openBrowser, link) : null;
+
+    const settled = await this.waitForApproval(pending);
+    return settled ?? toolText(approvalText(link, userCode, opened));
   }
 
-  async check(): Promise<ToolResult> {
-    if (!this.pending) {
-      return toolText('No device login is pending. Call `auth` with action "start" first.');
+  /** Poll until approved, denied or expired, or the wait budget runs out (then null). */
+  private async waitForApproval(entry: PendingDeviceAuth): Promise<ToolResult | null> {
+    const deadline = Date.now() + this.waitMs;
+    let intervalMs = Math.max(entry.start.interval * 1000, MIN_POLL_INTERVAL_MS);
+    while (Date.now() + intervalMs <= deadline) {
+      await this.sleep(intervalMs);
+      const result = await checkDeviceAuthorizationOnce(entry.start, { config: entry.config });
+      const settled = await this.settle(result);
+      if (settled) {
+        return settled;
+      }
+      if (result.status === "slow_down") {
+        intervalMs += SLOW_DOWN_STEP_MS;
+      }
     }
+    return null;
+  }
 
-    const { start, config } = this.pending;
-    // Errors (network failure, unrecognized OAuth error code) intentionally leave
-    // `pending` intact — a transient failure shouldn't force the user to restart
-    // the whole login, just retry the check.
-    const result = await checkDeviceAuthorizationOnce(start, { config });
-
+  /** Handle a final poll result; null means the login is still pending. */
+  private async settle(result: DeviceAuthorizationCheck): Promise<ToolResult | null> {
     switch (result.status) {
       case "success": {
         this.pending = null;
@@ -114,31 +152,51 @@ class AuthToolState {
         setStoredCredentialsEnvToken(tokens.accessToken);
         return toolText("Signed in successfully. Miru tools are now ready to use.");
       }
-      case "pending":
-        return toolText(
-          'Still waiting for approval. Ask the user to confirm they clicked and approved, then call `auth` again with action "check".',
-        );
-      case "slow_down":
-        return toolText(
-          'Checking too soon — wait a bit before calling `auth` again with action "check".',
-        );
       case "denied":
         this.pending = null;
-        return toolText('Sign-in was denied. Call `auth` with action "start" to try again.');
+        return toolText("Sign-in was denied. Call `auth` again to try again.");
       case "expired":
         this.pending = null;
         return toolText(
-          'The device code expired before it was approved. Call `auth` with action "start" to try again.',
+          "The device code expired before it was approved. Call `auth` again to get a new one.",
         );
+      default:
+        return null;
+    }
+  }
+
+  async check(): Promise<ToolResult> {
+    if (!this.pending) {
+      return toolText('No device login is pending. Call `auth` with action "start" first.');
     }
+
+    const { start, config } = this.pending;
+    // Errors (network failure, unrecognized OAuth error code) intentionally leave
+    // `pending` intact — a transient failure shouldn't force the user to restart
+    // the whole login, just retry the check.
+    const result = await checkDeviceAuthorizationOnce(start, { config });
+
+    const settled = await this.settle(result);
+    if (settled) {
+      return settled;
+    }
+    return toolText(
+      result.status === "slow_down"
+        ? "Checking too soon — wait a bit before calling `auth` again."
+        : "Still waiting for approval. Ask the user to confirm they clicked and approved, then call `auth` again.",
+    );
   }
 }
 
 export function registerAuthTool(
   server: MiruMcpServer,
-  options?: { openBrowser?: BrowserOpener },
+  options?: { openBrowser?: BrowserOpener; waitMs?: number; sleep?: Sleeper },
 ): void {
-  const state = new AuthToolState(options?.openBrowser ?? openBrowserForDeviceLogin);
+  const state = new AuthToolState(
+    options?.openBrowser ?? openBrowserForDeviceLogin,
+    options?.waitMs ?? DEFAULT_WAIT_MS,
+    options?.sleep ?? ((ms) => new Promise((resolve) => setTimeout(resolve, ms))),
+  );
 
   server.registerTool(
     "auth",
@@ -148,7 +206,9 @@ export function registerAuthTool(
         action: z
           .enum(["start", "check"])
           .optional()
-          .describe('"start" begins a device-code login (default); "check" completes it.'),
+          .describe(
+            '"start" begins or resumes a device-code login and waits for approval (default); "check" is a single non-blocking poll.',
+          ),
       },
     },
     async ({ action }) => {