fix(handoff): require the Kiro IDE bundle instead of falling back to the ambiguous shim

Keeping `command: kiro` left a live path to the bug this entry exists to prevent: with Kiro.app absent but the shim present — the June QA machine, which had Kiro CLI and no IDE — resolveEntry reported the editor tile as available and open-in launched the router, which can be the CLI.

Drop the shim entirely. The catalogue already expresses darwin-only + bundle-only by omitting `command`; xcode, terminal and warp all do it. Availability now requires Kiro.app, so the tile can only ever reach the IDE through LaunchServices.

That makes preferMacOpenBundle unused, so revert it along with the resolveEntry split: CatalogueEntry and resolveEntry return byte-identical to main and the source diff is now purely additive — one catalogue entry and its comment.

Tests: assert available:false when the bundle is missing even with the shim on PATH, and pin the route-level platform gate (POST open-in with editorId=kiro from linux/win32 is refused 400 BAD_REQUEST, distinguishable from the 409 the probe would return without the gate).

Author: gmarchand

apps/daemon/src/routes/host-tools.ts

@@ -42,16 +42,9 @@ export interface CatalogueEntry {
   // macOS-only fallback: when the CLI shim is missing, look for an app
   // bundle by name and launch it via `open -a "<name>"`. Lets us list
   // Xcode / Qoder / Antigravity / Warp / IntelliJ without forcing users
-  // to also install their CLI shim. `preferMacOpenBundle` flips it from
-  // fallback to first choice.
+  // to also install their CLI shim.
   macOpenBundle?: string | readonly string[];
   macOpenArgs?: (bundleName: string, resolvedDir: string) => string[];
-  // On darwin, try `macOpenBundle` before the `$PATH` shim. For tools whose
-  // bare shim is not a deterministic entry point, the app bundle is: it goes
-  // through LaunchServices and lands on exactly one app. `command` stays as
-  // the fallback so the entry still reports available when the bundle is
-  // missing, and win32/linux resolution order is untouched.
-  preferMacOpenBundle?: boolean;
   platforms?: RealPlatform[];
   excludedPlatforms?: RealPlatform[];
 }
@@ -65,18 +58,17 @@ export const CATALOGUE: ReadonlyArray<CatalogueEntry> = [
   { id: 'cursor', label: 'Cursor', icon: 'sparkles', command: 'cursor', macOpenBundle: 'Cursor' },
   { id: 'vscode', label: 'VS Code', icon: 'file-code', command: 'code', macOpenBundle: 'Visual Studio Code' },
   { id: 'windsurf', label: 'Windsurf', icon: 'sparkles', command: 'windsurf', macOpenBundle: 'Windsurf' },
-  // darwin-only: bare `kiro` is not a deterministic IDE entry point. Once the
-  // opt-in command router is installed (v1.26.0+) `kiro` routes to whatever
-  // the user set as their default, so `kiro set-default cli` would make this
-  // tile open the terminal agent — see "Kiro Command Router" in
+  // darwin-only: bare `kiro` is not a deterministic IDE entry point. The
+  // opt-in command router (v1.26.0+) makes `kiro` follow whatever the user set
+  // as their default, so `kiro set-default cli` would point this editor tile at
+  // the terminal agent — see "Kiro Command Router" in
   // https://kiro.dev/docs/cli/reference/cli-commands/. `kiro ide <dir>` is not
-  // the fix: with the router absent, `kiro` is a Code-OSS-style launcher that
-  // treats `ide` as a path and opens a spurious `ide` entry. darwin is
-  // deterministic because it resolves /Applications/Kiro.app first, which
-  // reaches the IDE through LaunchServices in every router state; `command`
-  // stays as the fallback when that bundle is missing. win32/linux stay
+  // an alternative: with the router absent, `kiro` treats `ide` as a path and
+  // opens a spurious `ide` entry. So this entry deliberately carries no
+  // `command` shim — availability requires Kiro.app, which reaches the IDE
+  // through LaunchServices in every router state. win32/linux stay
   // unadvertised until they have a verified deterministic launch path. (#6313)
-  { id: 'kiro', label: 'Kiro', icon: 'sparkles', command: 'kiro', macOpenBundle: 'Kiro', preferMacOpenBundle: true, platforms: ['darwin'] },
+  { id: 'kiro', label: 'Kiro', icon: 'sparkles', macOpenBundle: 'Kiro', platforms: ['darwin'] },
   { id: 'zed', label: 'Zed', icon: 'edit', command: 'zed', macOpenBundle: 'Zed' },
   { id: 'qoder', label: 'Qoder', icon: 'sparkles', command: 'qoder', macOpenBundle: ['Qoder', 'QoderWork'] },
   { id: 'antigravity', label: 'Antigravity', icon: 'orbit', command: 'antigravity', macOpenBundle: ['Antigravity', 'Google Antigravity'] },
@@ -180,47 +172,35 @@ async function probeMacBundle(name: string | readonly string[]): Promise<{ name:
   return null;
 }
 
-interface ResolvedEntry {
+async function resolveEntry(entry: CatalogueEntry): Promise<{
   available: boolean;
   resolvedPath?: string;
   launch?: { command: string; argsForDir: (resolvedDir: string) => string[] };
-}
-
-async function resolveViaPathShim(entry: CatalogueEntry): Promise<ResolvedEntry | null> {
-  if (!entry.command) return null;
-  const resolved = await probeCommandOnPath(entry.command);
-  if (!resolved) return null;
-  return {
-    available: true,
-    resolvedPath: resolved,
-    launch: { command: resolved, argsForDir: entry.commandArgs ?? ((resolvedDir) => [resolvedDir]) },
-  };
-}
-
-async function resolveViaMacBundle(entry: CatalogueEntry): Promise<ResolvedEntry | null> {
-  if (!entry.macOpenBundle || process.platform !== 'darwin') return null;
-  const bundle = await probeMacBundle(entry.macOpenBundle);
-  if (!bundle) return null;
-  return {
-    available: true,
-    resolvedPath: bundle.path,
-    launch: {
-      command: await resolveMacOpenCommand(),
-      argsForDir: entry.macOpenArgs
-        ? ((resolvedDir) => entry.macOpenArgs?.(bundle.name, resolvedDir) ?? ['-a', bundle.name, resolvedDir])
-        : ((resolvedDir) => ['-a', bundle.name, resolvedDir]),
-    },
-  };
-}
-
-async function resolveEntry(entry: CatalogueEntry): Promise<ResolvedEntry> {
-  const order =
-    entry.preferMacOpenBundle === true && process.platform === 'darwin'
-      ? [resolveViaMacBundle, resolveViaPathShim]
-      : [resolveViaPathShim, resolveViaMacBundle];
-  for (const resolve of order) {
-    const resolved = await resolve(entry);
-    if (resolved) return resolved;
+}> {
+  if (entry.command) {
+    const resolved = await probeCommandOnPath(entry.command);
+    if (resolved) {
+      return {
+        available: true,
+        resolvedPath: resolved,
+        launch: { command: resolved, argsForDir: entry.commandArgs ?? ((resolvedDir) => [resolvedDir]) },
+      };
+    }
+  }
+  if (entry.macOpenBundle && process.platform === 'darwin') {
+    const bundle = await probeMacBundle(entry.macOpenBundle);
+    if (bundle) {
+      return {
+        available: true,
+        resolvedPath: bundle.path,
+        launch: {
+          command: await resolveMacOpenCommand(),
+          argsForDir: entry.macOpenArgs
+            ? ((resolvedDir) => entry.macOpenArgs?.(bundle.name, resolvedDir) ?? ['-a', bundle.name, resolvedDir])
+            : ((resolvedDir) => ['-a', bundle.name, resolvedDir]),
+        },
+      };
+    }
   }
   return { available: false };
 }

apps/daemon/tests/host-tools-open-in-route.test.ts

@@ -14,7 +14,7 @@ import path from 'node:path';
 import { tmpdir } from 'node:os';
 import express from 'express';
 import type { Response } from 'express';
-import { afterAll, beforeAll, describe, expect, it, vi } from 'vitest';
+import { afterAll, afterEach, beforeAll, describe, expect, it, vi } from 'vitest';
 
 import { registerHostToolsRoutes } from '../src/routes/host-tools.js';
 import type { RegisterHostToolsRoutesDeps } from '../src/routes/host-tools.js';
@@ -79,11 +79,11 @@ afterAll(async () => {
   await new Promise<void>((resolve) => server.close(() => resolve()));
 });
 
-function postOpenIn(projectId: string) {
+function postOpenIn(projectId: string, editorId = 'cursor') {
   return fetch(`${baseUrl}/api/projects/${projectId}/open-in`, {
     method: 'POST',
     headers: { 'content-type': 'application/json' },
-    body: JSON.stringify({ editorId: 'cursor' }),
+    body: JSON.stringify({ editorId }),
   });
 }
 
@@ -109,3 +109,36 @@ describe('POST /api/projects/:id/open-in launch reporting (#3871)', () => {
     expect(await resp.json()).toEqual({ ok: true, editorId: 'cursor', path: PROJECT_DIR });
   });
 });
+
+// The darwin gate on the Kiro entry has to be enforced on the *launch* path,
+// not just filtered out of `GET /api/editors`. A client can POST any
+// `editorId` — it does not have to be one the list offered — so if the route
+// stopped consulting applicableForPlatform, a non-macOS POST for `kiro` would
+// fall through to the probe. That is the exact "editor tile launches the
+// terminal agent" hazard the bundle-only entry exists to prevent (#6313), so
+// the refusal is pinned here at the HTTP boundary.
+//
+// The 400/BAD_REQUEST pair matters: with the gate removed the request is still
+// refused, but as 409 EDITOR_NOT_AVAILABLE from the probe. Asserting the code
+// (not just a non-2xx status) keeps the two failure modes distinguishable.
+describe('POST /api/projects/:id/open-in platform gate — kiro is darwin-only (#6313)', () => {
+  const ORIGINAL_PLATFORM = process.platform;
+
+  afterEach(() => {
+    Object.defineProperty(process, 'platform', { value: ORIGINAL_PLATFORM, configurable: true });
+  });
+
+  it.each(['linux', 'win32'] as const)(
+    'refuses editorId=kiro with 400 BAD_REQUEST on %s',
+    async (platform) => {
+      Object.defineProperty(process, 'platform', { value: platform, configurable: true });
+
+      const resp = await postOpenIn('p1', 'kiro');
+
+      expect(resp.status).toBe(400);
+      const body = (await resp.json()) as { error: { code: string; message: string } };
+      expect(body.error.code).toBe('BAD_REQUEST');
+      expect(body.error.message).toBe(`Kiro is not available on ${platform}`);
+    },
+  );
+});

apps/daemon/tests/host-tools-routes.test.ts

@@ -48,13 +48,13 @@ describe('host tools open-in launch plans', () => {
   });
 });
 
-// Resolution-order coverage for the launch *arguments*, not just platform
-// applicability. `kiro` carries preferMacOpenBundle so darwin resolves
-// /Applications/Kiro.app ahead of the `$PATH` shim — bare `kiro` routes to the
-// user's default once the Kiro command router is installed, and `kiro ide
-// <dir>` is not a usable substitute (it adds a spurious `ide` entry when the
-// router is absent). These cases pin both halves so neither can regress.
-describe('host tools resolution order — preferMacOpenBundle', () => {
+// Resolution coverage for the launch *arguments*, not just platform
+// applicability. `kiro` is bundle-only: it declares no `command`, so the tile
+// can only ever reach Kiro.app and never the `kiro` shim, which routes to the
+// user's default once the Kiro command router is installed. These cases pin
+// both halves of that — the bundle launch, and the refusal to fall back to a
+// shim that may be the terminal agent. (#6313)
+describe('host tools resolution — kiro resolves through the IDE bundle only', () => {
   const DIR = '/tmp/open-design-project';
   const ORIGINAL_PLATFORM = process.platform;
 
@@ -83,17 +83,17 @@ describe('host tools resolution order — preferMacOpenBundle', () => {
     expect(plan.args).not.toContain('ide');
   });
 
-  it('darwin: kiro still falls back to the $PATH shim when the app bundle is missing', async () => {
+  it('darwin: kiro is unavailable when Kiro.app is missing, even with the $PATH shim installed', async () => {
     stubPlatform('darwin', ['/fake/bin/kiro', '/usr/bin/open']);
 
     const plan = await resolveHostToolLaunchPlan('kiro', DIR);
 
-    expect(plan.available).toBe(true);
-    expect(plan.command).toBe('/fake/bin/kiro');
-    expect(plan.args).toEqual([DIR]);
+    expect(plan.available).toBe(false);
+    expect(plan.command).toBeUndefined();
+    expect(plan.args).toBeUndefined();
   });
 
-  it('darwin: an unflagged entry still prefers the $PATH shim over its app bundle', async () => {
+  it('darwin: an entry that declares a shim still prefers it over its app bundle', async () => {
     stubPlatform('darwin', ['/fake/bin/cursor', '/Applications/Cursor.app', '/usr/bin/open']);
 
     const plan = await resolveHostToolLaunchPlan('cursor', DIR);
@@ -103,11 +103,6 @@ describe('host tools resolution order — preferMacOpenBundle', () => {
     expect(plan.command).toBe('/fake/bin/cursor');
     expect(plan.args).toEqual([DIR]);
   });
-
-  it('only kiro opts into bundle-first resolution', () => {
-    const flagged = CATALOGUE.filter((e: CatalogueEntry) => e.preferMacOpenBundle === true);
-    expect(flagged.map((e: CatalogueEntry) => e.id)).toEqual(['kiro']);
-  });
 });
 
 describe('platform gate — Warp and Kiro are darwin-only, cross-platform tools stay available everywhere', () => {