opencode-kiro 0.4.0 → 0.5.0-beta.2

package/dist/server.js

@@ -1,258 +1,422 @@
-// src/server.ts
-import { readFileSync } from "fs";
-import { homedir } from "os";
-import { dirname, join } from "path";
-var KIRO_PLUGIN_NAME = "opencode-kiro";
-var server = async (input) => {
-  const prompts = [
-    {
-      type: "select",
-      key: "sidebar",
-      message: "Enable the Kiro credits sidebar?",
-      options: [
-        { label: "Yes", value: "yes", hint: "writes tui.json; restart to apply" },
-        { label: "No", value: "no" }
-      ]
-    }
-  ];
+// src/server/auth.ts
+var KIRO_INTEGRATION_ID = "kiro";
+var KIRO_INTEGRATION_NAME = "Kiro";
+var KIRO_OAUTH_METHOD_ID = "kiro-cli-login";
+var KIRO_OAUTH_METHOD_LABEL = "Kiro CLI Login";
+var KIRO_DOCS_URL = "https://kiro.dev/docs/cli/";
+var POLL_INTERVAL_MS = 2e3;
+var MAX_WAIT_MS = 12e4;
+var NOT_INSTALLED_MESSAGE = "kiro-cli is not installed. Install it from https://kiro.dev/docs/cli/";
+var TIMEOUT_MESSAGE = "Kiro authentication timed out. Run `kiro-cli login` manually, then re-run `opencode auth login`.";
+var LOGIN_INSTRUCTIONS = "Complete Kiro authentication in the browser window that just opened. Waiting for login...";
+var ALREADY_AUTHENTICATED_INSTRUCTIONS = "Already authenticated with Kiro CLI.";
+function createAuthResources() {
   return {
-    auth: {
-      provider: "kiro",
-      // options forwarded into createKiroAcp(). maps each model's limit.context into contextWindows by api.id; zero/missing skipped (SDK falls back to 1M).
-      loader: async (_getAuth, provider) => {
-        void notifyIfTokenExpired(input.client);
-        return {
-          cwd: input.directory ?? input.worktree,
-          agent: "opencode",
-          trustAllTools: true,
-          mcpTimeout: 45,
-          contextWindows: Object.fromEntries(
-            Object.values(provider?.models ?? {}).filter((m) => m.api?.id && (m.limit?.context ?? 0) > 0).map((m) => [m.api.id, m.limit.context])
-          )
-        };
-      },
-      methods: [
-        {
-          type: "oauth",
-          label: "Kiro CLI Login",
-          prompts,
-          async authorize(inputs) {
-            const { verifyAuth } = await import("kiro-acp-ai-provider");
-            const status = verifyAuth();
-            if (!status.installed)
-              throw new Error(
-                "kiro-cli is not installed. Install it from https://kiro.dev/docs/cli/"
-              );
-            if (inputs?.sidebar === "yes") await enableSidebarConfig(tuiConfigPath(), input);
-            if (status.authenticated) {
-              return {
-                url: "",
-                instructions: "",
-                method: "auto",
-                async callback() {
-                  return readToken(status.tokenPath);
-                }
-              };
-            }
-            const { execFile } = await import("child_process");
-            const child = execFile("kiro-cli", ["login"], {
-              shell: process.platform === "win32"
-            });
-            return {
-              url: "",
-              instructions: "Complete Kiro authentication in the browser window that just opened. Waiting for login...",
-              method: "auto",
-              async callback() {
-                const maxWait = 12e4;
-                const start = Date.now();
-                while (Date.now() - start < maxWait) {
-                  await new Promise((r) => setTimeout(r, 2e3));
-                  const check = verifyAuth();
-                  if (check.authenticated) {
-                    child.kill();
-                    return readToken(check.tokenPath);
-                  }
-                }
-                child.kill();
-                throw new Error(
-                  "Kiro authentication timed out. Run `kiro-cli login` manually."
-                );
-              }
-            };
-          }
-        }
-      ]
-    },
-    // crash guard: core derefs an undefined kiro provider during auth init when a cred exists but the catalog lacks kiro.
-    // only inject when authed; ??= is idempotent and won't clobber a real catalog entry.
-    config: async (input2) => {
-      if (!hasStoredKiroCredential()) return;
-      input2.provider ??= {};
-      input2.provider.kiro ??= {};
-    },
-    provider: {
-      id: "kiro",
-      // expose the exact runtime/models.dev intersection with catalog metadata intact
-      async models(provider, ctx) {
-        if (!ctx.auth) return provider.models;
-        try {
-          const { listModels } = await import("kiro-acp-ai-provider");
-          const discoveredModels = await listModels({
-            cwd: input.directory ?? input.worktree
-          });
-          const runtimeModels = new Map(discoveredModels.map((model) => [model.modelId, model]));
-          if (runtimeModels.size !== discoveredModels.length) return provider.models;
-          const models = {};
-          for (const [catalogKey, catalogModel] of Object.entries(provider.models)) {
-            const apiId = catalogModel.api?.id;
-            if (typeof apiId !== "string") continue;
-            const runtimeModel = runtimeModels.get(apiId);
-            if (!runtimeModel) continue;
-            if (runtimeModel.runtimeEfforts.length === 0) {
-              models[catalogKey] = catalogModel;
-              continue;
-            }
-            models[catalogKey] = {
-              ...catalogModel,
-              ...runtimeModel.baselineEffort === void 0 ? {} : {
-                options: {
-                  ...catalogModel.options,
-                  reasoningEffort: runtimeModel.baselineEffort
-                }
-              },
-              variants: {
-                ...catalogModel.variants,
-                ...Object.fromEntries(
-                  runtimeModel.runtimeEfforts.map((effort) => [
-                    effort,
-                    {
-                      ...catalogModel.variants?.[effort],
-                      reasoningEffort: effort
-                    }
-                  ])
-                )
-              }
-            };
-          }
-          return models;
-        } catch {
-          return provider.models;
-        }
-      }
-    }
+    child: void 0,
+    pollTimer: void 0,
+    cancelPoll: void 0,
+    disposeRegistration: void 0
   };
-};
-function kiroTokenPath() {
-  return join(homedir(), ".aws", "sso", "cache", "kiro-auth-token.json");
 }
-async function readKiroTokenFile(tokenPath) {
-  try {
-    const { readFile } = await import("fs/promises");
-    const parsed = JSON.parse(await readFile(tokenPath, "utf8"));
-    return typeof parsed === "object" && parsed !== null && !Array.isArray(parsed) ? parsed : void 0;
-  } catch {
-    return void 0;
+function releaseLoginResources(resources) {
+  if (resources.pollTimer !== void 0) {
+    clearTimeout(resources.pollTimer);
+    resources.pollTimer = void 0;
+  }
+  if (resources.child !== void 0) {
+    resources.child.kill();
+    resources.child = void 0;
+  }
+  if (resources.cancelPoll !== void 0) {
+    const cancel = resources.cancelPoll;
+    resources.cancelPoll = void 0;
+    cancel();
   }
 }
-async function readToken(tokenPath) {
+function kiroCredential() {
+  return {
+    type: "oauth",
+    methodID: KIRO_OAUTH_METHOD_ID,
+    refresh: "",
+    access: "kiro-cli",
+    expires: 0
+  };
+}
+function pollForLogin(verifyAuth, resources) {
+  return new Promise((resolve, reject) => {
+    const start = Date.now();
+    resources.cancelPoll = () => {
+      reject(new Error("Kiro authentication was cancelled."));
+    };
+    const tick = () => {
+      resources.pollTimer = void 0;
+      if (verifyAuth().authenticated) {
+        resources.cancelPoll = void 0;
+        releaseLoginResources(resources);
+        resolve(kiroCredential());
+        return;
+      }
+      if (Date.now() - start >= MAX_WAIT_MS) {
+        resources.cancelPoll = void 0;
+        releaseLoginResources(resources);
+        reject(new Error(TIMEOUT_MESSAGE));
+        return;
+      }
+      resources.pollTimer = setTimeout(tick, POLL_INTERVAL_MS);
+    };
+    resources.pollTimer = setTimeout(tick, POLL_INTERVAL_MS);
+  });
+}
+async function authorize(resources) {
   const { verifyAuth } = await import("kiro-acp-ai-provider");
-  if (!verifyAuth().authenticated) return { type: "failed" };
-  const token = tokenPath ? await readKiroTokenFile(tokenPath) : void 0;
-  const access = typeof token?.accessToken === "string" ? token.accessToken : "";
-  const refresh = typeof token?.refreshToken === "string" ? token.refreshToken : "";
+  const status = verifyAuth();
+  if (!status.installed) throw new Error(NOT_INSTALLED_MESSAGE);
+  if (status.authenticated) {
+    return {
+      url: KIRO_DOCS_URL,
+      instructions: ALREADY_AUTHENTICATED_INSTRUCTIONS,
+      mode: "auto",
+      callback: Promise.resolve(kiroCredential())
+    };
+  }
+  const { execFile } = await import("child_process");
+  resources.child = execFile("kiro-cli", ["login"], {
+    shell: process.platform === "win32"
+  });
   return {
-    type: "success",
-    refresh,
-    // real refresh when present, else ""
-    access: access || "authenticated",
-    // cosmetic; opencode-core only needs presence
-    // future expiry, refreshed each startup (server() re-runs per session) so core doesn't flag a logged-in user as expired. not the file value.
-    expires: Date.now() + 8 * 60 * 60 * 1e3
+    url: KIRO_DOCS_URL,
+    instructions: LOGIN_INSTRUCTIONS,
+    mode: "auto",
+    callback: pollForLogin(verifyAuth, resources)
   };
 }
-async function notifyIfTokenExpired(client) {
-  try {
-    const { verifyAuth } = await import("kiro-acp-ai-provider");
-    if (verifyAuth().authenticated) return;
-    const message = "Kiro is not logged in. Run 'kiro-cli login' to authenticate.";
-    console.warn(message);
-    void client?.tui?.showToast?.({ body: { message, variant: "warning" } })?.catch(() => {
+async function registerAuth(context, resources) {
+  const registration = await context.integration.transform((draft) => {
+    draft.update(KIRO_INTEGRATION_ID, (integration) => {
+      integration.name = KIRO_INTEGRATION_NAME;
     });
-  } catch {
+    draft.method.update({
+      integrationID: KIRO_INTEGRATION_ID,
+      method: {
+        id: KIRO_OAUTH_METHOD_ID,
+        type: "oauth",
+        label: KIRO_OAUTH_METHOD_LABEL
+      },
+      authorize: async (_answer) => authorize(resources)
+      // no refresh callback: kiro-cli owns credential storage and refresh
+    });
+  });
+  resources.disposeRegistration = registration.dispose;
+  return async () => {
+    releaseLoginResources(resources);
+    resources.disposeRegistration = void 0;
+    await registration.dispose();
+  };
+}
+
+// src/server/discovery.ts
+var KIRO_PROVIDER_ID = "kiro";
+var KIRO_PROVIDER_PACKAGE = "aisdk:kiro-acp-ai-provider";
+function asString(value) {
+  return value;
+}
+function createDiscoveryResources() {
+  return {
+    state: void 0,
+    disposeTransform: void 0,
+    eventIterator: void 0,
+    eventTask: void 0
+  };
+}
+function effortSettings(effort) {
+  return { effort };
+}
+function applyEfforts(model, runtimeModel) {
+  if (runtimeModel.runtimeEfforts.length === 0) return;
+  if (runtimeModel.baselineEffort !== void 0) {
+    model.settings = { ...model.settings, ...effortSettings(runtimeModel.baselineEffort) };
+  }
+  for (const effort of runtimeModel.runtimeEfforts) {
+    const existing = model.variants.find((variant) => asString(variant.id) === effort);
+    if (existing !== void 0) {
+      existing.settings = { ...existing.settings, ...effortSettings(effort) };
+    } else {
+      model.variants.push({
+        id: effort,
+        settings: effortSettings(effort)
+      });
+    }
   }
 }
-function hasStoredKiroCredential() {
-  return authJsonPaths().some((path) => {
+function applyCatalogSnapshot(draft, state) {
+  const snapshot = state.snapshot;
+  if (snapshot === void 0 || snapshot.length === 0) return;
+  const runtime = new Map(snapshot.map((model) => [model.modelId, model]));
+  const record = draft.provider.get(KIRO_PROVIDER_ID);
+  const rich = record !== void 0 && record.models.size > 0;
+  const contextWindows = {};
+  if (rich) {
+    for (const [catalogKey, catalogModel] of Array.from(record.models.entries())) {
+      const runtimeModel = runtime.get(asString(catalogModel.modelID));
+      if (runtimeModel === void 0) {
+        draft.model.remove(KIRO_PROVIDER_ID, catalogKey);
+        continue;
+      }
+      draft.model.update(KIRO_PROVIDER_ID, catalogKey, (model) => {
+        applyEfforts(model, runtimeModel);
+        if (model.limit.context > 0) contextWindows[asString(model.modelID)] = model.limit.context;
+      });
+    }
+  } else {
+    for (const runtimeModel of snapshot) {
+      draft.model.update(KIRO_PROVIDER_ID, runtimeModel.modelId, (model) => {
+        model.name = runtimeModel.name || runtimeModel.modelId;
+        model.modelID = runtimeModel.modelId;
+        applyEfforts(model, runtimeModel);
+        if (model.limit.context > 0) contextWindows[asString(model.modelID)] = model.limit.context;
+      });
+    }
+  }
+  draft.provider.update(KIRO_PROVIDER_ID, (provider) => {
+    provider.name = KIRO_INTEGRATION_NAME;
+    provider.integrationID = KIRO_INTEGRATION_ID;
+    provider.package = KIRO_PROVIDER_PACKAGE;
+    provider.settings = {
+      ...provider.settings,
+      cwd: state.cwd,
+      agent: "opencode",
+      trustAllTools: true,
+      mcpTimeout: 45,
+      contextWindows
+    };
+  });
+}
+function createDiscover(context, state) {
+  async function runDiscovery(gen) {
     try {
-      const parsed = JSON.parse(readFileSync(path, "utf8"));
-      return typeof parsed === "object" && parsed !== null && !Array.isArray(parsed) && "kiro" in parsed;
+      const { listModels } = await import("kiro-acp-ai-provider");
+      const discovered = await listModels({ cwd: state.cwd });
+      if (gen !== state.generation) return;
+      const uniqueIds = new Set(discovered.map((model) => model.modelId));
+      if (uniqueIds.size !== discovered.length) return;
+      state.snapshot = discovered;
+      await context.catalog.reload();
     } catch {
-      return false;
     }
-  });
+  }
+  return async function discover(_reason) {
+    const active = await context.integration.connection.active(KIRO_INTEGRATION_ID);
+    if (!active) {
+      state.generation += 1;
+      state.snapshot = void 0;
+      await context.catalog.reload();
+      return;
+    }
+    if (state.inflight !== void 0) return state.inflight;
+    const gen = ++state.generation;
+    const run = runDiscovery(gen).finally(() => {
+      if (state.inflight === run) state.inflight = void 0;
+    });
+    state.inflight = run;
+    return run;
+  };
+}
+async function consumeEvents(iterator, discover) {
+  try {
+    while (true) {
+      const result = await iterator.next();
+      if (result.done) return;
+      const event = result.value;
+      if (event.type === "integration.connection.updated" && event.data.integrationID === KIRO_INTEGRATION_ID) {
+        try {
+          await discover("connection-updated");
+        } catch {
+        }
+      }
+    }
+  } catch {
+  }
 }
-function authJsonPaths() {
-  if (process.env.XDG_DATA_HOME) return [join(process.env.XDG_DATA_HOME, "opencode", "auth.json")];
-  const current = join(homedir(), ".local", "share", "opencode", "auth.json");
-  if (process.platform !== "win32") return [current];
-  return [current, join(homedir(), ".opencode", "auth.json")];
+async function registerDiscovery(context, resources) {
+  const { location } = await context.integration.list();
+  const state = {
+    cwd: location.directory,
+    snapshot: void 0,
+    generation: 0,
+    inflight: void 0
+  };
+  resources.state = state;
+  const discover = createDiscover(context, state);
+  const registration = await context.catalog.transform(
+    (draft) => applyCatalogSnapshot(draft, state)
+  );
+  resources.disposeTransform = registration.dispose;
+  const iterator = context.event.subscribe()[Symbol.asyncIterator]();
+  resources.eventIterator = iterator;
+  resources.eventTask = consumeEvents(iterator, discover);
+  if (await context.integration.connection.active(KIRO_INTEGRATION_ID)) {
+    void discover("setup").catch(() => {
+    });
+  }
+  return async () => {
+    state.generation += 1;
+    const errors = [];
+    const eventIterator = resources.eventIterator;
+    resources.eventIterator = void 0;
+    if (eventIterator?.return !== void 0) {
+      try {
+        await eventIterator.return();
+      } catch (error) {
+        errors.push(error);
+      }
+    }
+    const eventTask = resources.eventTask;
+    resources.eventTask = void 0;
+    if (eventTask !== void 0) await eventTask;
+    const disposeTransform = resources.disposeTransform;
+    resources.disposeTransform = void 0;
+    if (disposeTransform !== void 0) {
+      try {
+        await disposeTransform();
+      } catch (error) {
+        errors.push(error);
+      }
+    }
+    if (errors.length > 0) throw new AggregateError(errors, "kiro discovery cleanup failures");
+  };
 }
-function tuiConfigPath() {
-  const base = process.env.XDG_CONFIG_HOME || join(homedir(), ".config");
-  return join(base, "opencode", "tui.json");
+
+// src/server/aisdk.ts
+var KIRO_SDK_PACKAGE = "kiro-acp-ai-provider";
+function createAisdkResources() {
+  return {
+    ownedSdks: /* @__PURE__ */ new Set(),
+    cache: /* @__PURE__ */ new Map(),
+    disposeHook: void 0
+  };
 }
-function isSidebarConfigured(config) {
-  if (!config) return false;
-  const plugin = config.plugin;
-  return Array.isArray(plugin) && plugin.includes(KIRO_PLUGIN_NAME);
+function isKiroPackage(pkg) {
+  return pkg === KIRO_SDK_PACKAGE || pkg === `aisdk:${KIRO_SDK_PACKAGE}`;
 }
-async function enableSidebarConfig(path, input) {
-  try {
-    const { readFile, writeFile, mkdir } = await import("fs/promises");
-    let raw;
+function isJsonSafe(value) {
+  if (value === null) return true;
+  const kind = typeof value;
+  if (kind === "string" || kind === "number" || kind === "boolean") return true;
+  if (Array.isArray(value)) return value.every(isJsonSafe);
+  if (kind === "object") {
+    const proto = Object.getPrototypeOf(value);
+    if (proto !== Object.prototype && proto !== null) return false;
+    return Object.values(value).every(isJsonSafe);
+  }
+  return false;
+}
+function stableStringify(value) {
+  if (Array.isArray(value)) return `[${value.map(stableStringify).join(",")}]`;
+  if (typeof value === "object" && value !== null) {
+    const entries = Object.entries(value).sort(([a], [b]) => a < b ? -1 : a > b ? 1 : 0).map(([key, entry]) => `${JSON.stringify(key)}:${stableStringify(entry)}`);
+    return `{${entries.join(",")}}`;
+  }
+  return JSON.stringify(value);
+}
+function stableOptionsKey(options) {
+  return isJsonSafe(options) ? stableStringify(options) : void 0;
+}
+async function registerAisdkHook(context, resources) {
+  const registration = await context.aisdk.hook(
+    "sdk",
+    async (event) => {
+      if (!isKiroPackage(event.package)) return;
+      const { createKiroAcp } = await import("kiro-acp-ai-provider");
+      const key = stableOptionsKey(event.options);
+      let sdk = key === void 0 ? void 0 : resources.cache.get(key);
+      if (sdk === void 0) {
+        sdk = createKiroAcp(event.options);
+        resources.ownedSdks.add(sdk);
+        if (key !== void 0) resources.cache.set(key, sdk);
+      }
+      event.sdk = sdk;
+    },
+    { providerID: KIRO_PROVIDER_ID }
+  );
+  resources.disposeHook = registration.dispose;
+  return async () => {
+    const errors = [];
+    resources.disposeHook = void 0;
     try {
-      raw = await readFile(path, "utf8");
-    } catch {
-      raw = void 0;
+      await registration.dispose();
+    } catch (error) {
+      errors.push(error);
     }
-    let config;
-    if (raw === void 0) {
-      config = {};
-    } else {
+    const owned = Array.from(resources.ownedSdks);
+    resources.ownedSdks.clear();
+    resources.cache.clear();
+    for (const sdk of owned) {
       try {
-        const parsed = JSON.parse(raw);
-        if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) return;
-        config = parsed;
-      } catch {
-        return;
+        await sdk.shutdown();
+      } catch (error) {
+        errors.push(error);
       }
     }
-    if (isSidebarConfigured(config)) return;
-    const plugin = Array.isArray(config.plugin) ? [...config.plugin] : [];
-    if (!plugin.includes(KIRO_PLUGIN_NAME)) plugin.push(KIRO_PLUGIN_NAME);
-    config.plugin = plugin;
-    await mkdir(dirname(path), { recursive: true });
-    await writeFile(path, JSON.stringify(config, null, 2) + "\n", "utf8");
+    if (errors.length > 0) throw new AggregateError(errors, "kiro aisdk cleanup failures");
+  };
+}
+
+// src/server/lifecycle.ts
+function createServerState() {
+  return {
+    auth: createAuthResources(),
+    discovery: createDiscoveryResources(),
+    aisdk: createAisdkResources(),
+    disposers: [],
+    disposed: false,
+    cleanup: void 0
+  };
+}
+async function disposeAll(disposers) {
+  const errors = [];
+  for (const dispose of [...disposers].reverse()) {
+    try {
+      await dispose();
+    } catch (error) {
+      if (error instanceof AggregateError) errors.push(...error.errors);
+      else errors.push(error);
+    }
+  }
+  if (errors.length > 0) throw new AggregateError(errors, "kiro server cleanup failures");
+}
+function buildCleanup(state) {
+  return () => {
+    if (state.cleanup !== void 0) return state.cleanup;
+    state.disposed = true;
+    state.cleanup = disposeAll(state.disposers);
+    return state.cleanup;
+  };
+}
+
+// src/server.ts
+var plugin = {
+  id: "kiro",
+  // tui: true (dist/promise/plugin.d.ts:40) — the host auto-loads this
+  // package's `./tui` entrypoint for npm-channel installs (single config entry)
+  tui: true,
+  async setup(context) {
+    const state = createServerState();
+    const cleanup = buildCleanup(state);
     try {
-      await input.client.tui.showToast({
-        body: {
-          message: "Kiro credits sidebar enabled. Restart opencode to see it.",
-          variant: "success"
-        }
+      state.disposers.push(await registerAuth(context, state.auth));
+      state.disposers.push(await registerDiscovery(context, state.discovery));
+      state.disposers.push(await registerAisdkHook(context, state.aisdk));
+    } catch (error) {
+      await Promise.resolve(cleanup()).catch(() => {
       });
-    } catch {
+      throw error;
     }
-  } catch (err) {
-    console.error("opencode-kiro: failed to enable the Kiro credits sidebar in tui.json:", err);
+    return cleanup;
   }
-}
-var KiroAuthPlugin = server;
-var server_default = { id: "kiro", server };
+};
+var server_default = plugin;
+var KiroAuthPlugin = plugin;
 export {
   KiroAuthPlugin,
-  server_default as default,
-  enableSidebarConfig,
-  kiroTokenPath,
-  notifyIfTokenExpired,
-  readToken
+  server_default as default
 };