zidane 6.6.4 → 7.0.0

package/dist/login-CB23LyI1.js

@@ -1,707 +0,0 @@
-import { t as defineSkill } from "./skills-BMGH_KK1.js";
-import { h as McpOAuthProvider, m as sseToJsonFetchIfNeeded, o as expandMcpConfigEnv, p as createTolerantClient, v as isOAuthTokenRejectionError } from "./mcp-CVtSQTWg.js";
-import { createRequire } from "node:module";
-import { basename, dirname, join, resolve } from "node:path";
-import { existsSync } from "node:fs";
-import { fileURLToPath } from "node:url";
-import { createServer } from "node:http";
-//#region src/extension-authoring.ts
-/**
-* Session-metadata key marking an "edit / create extension" session. The value
-* is an {@link ExtensionEditMarker}. Both hosts stamp it at session creation so
-* the agent build can scope the docs skill to exactly these sessions (and it
-* survives reload because metadata is persisted).
-*/
-const EXTENSION_EDIT_METADATA_KEY = "zidane.extensionEdit";
-/** Name of the inline docs skill auto-activated in extension edit sessions. */
-const ZIDANE_EXTENSION_SKILL_NAME = "zidane-extension";
-/**
-* Session-metadata key marking an "edit skill" session — the skill-editing
-* counterpart of {@link EXTENSION_EDIT_METADATA_KEY}. The value is a
-* {@link SkillEditMarker}. Stamped at session creation by both hosts (via
-* {@link editSessionMetadata}); persisted metadata means it survives reload.
-*/
-const SKILL_EDIT_METADATA_KEY = "zidane.skillEdit";
-/** Name of the inline preset skill auto-activated in skill edit sessions. */
-const ZIDANE_SKILL_EDIT_SKILL_NAME = "zidane-skill";
-/**
-* THE canonical seed for "open an editing session with preset context" —
-* the session metadata both hosts stamp at creation time. The engines read
-* the marker back and inject + auto-activate the matching inline preset
-* skill ({@link buildZidaneExtensionSkill} / {@link buildZidaneSkillEditSkill}),
-* so the preset rides as real conversation context from turn one.
-*/
-function editSessionMetadata(target) {
-	return target.kind === "extension" ? { [EXTENSION_EDIT_METADATA_KEY]: { dir: target.dir } } : { [SKILL_EDIT_METADATA_KEY]: {
-		dir: target.dir,
-		name: target.name
-	} };
-}
-/**
-* Parse a persisted {@link SkillEditMarker} back out of session metadata.
-* Tolerant: anything that isn't `{ dir: string, name: string }` → `null`
-* (older sessions, manual metadata edits, type drift).
-*/
-function readSkillEditMarker(raw) {
-	if (typeof raw !== "object" || raw === null) return null;
-	const { dir, name } = raw;
-	if (typeof dir !== "string" || dir.length === 0 || typeof name !== "string" || name.length === 0) return null;
-	return {
-		dir,
-		name
-	};
-}
-/**
-* Minimal valid extension module for a freshly-created extension. `name` MUST
-* equal the folder name or the loader rejects it (see `src/extensions/discovery`).
-* Does nothing by default — the author registers contributions via `ctx.*`
-* inside `setup`; the auto-activated docs skill guides them from there.
-*/
-function extensionScaffold(name) {
-	return `import { defineExtension } from 'zidane'
-
-/**
- * ${name} — a zidane extension.
- *
- * Register tools / hooks / skills / MCP servers / subagents / config / themes /
- * agents / keybindings via the \`ctx\` surface inside \`setup\`.
- *
- * Authoring reference: activate the \`${ZIDANE_EXTENSION_SKILL_NAME}\` skill — it carries
- * the full \`ctx\` API + invariants and is available whenever you open this
- * folder in zidane (or run \`zidane\` from inside it).
- */
-export default defineExtension({
-  name: '${name}',
-  setup(ctx) {
-    // e.g. ctx.registerTool('${name}_hello', {
-    //   spec: { name: '${name}_hello', description: 'say hi', inputSchema: { type: 'object', properties: {} } },
-    //   isConcurrencySafe: true,
-    //   async execute() { return 'hello from ${name}' },
-    // })
-  },
-})
-`;
-}
-/**
-* Locate the shipped `docs/` directory (`docs/EXTENSIONS.md` + siblings).
-*
-* The docs ship via `package.json` `files`, so an installed consumer has
-* `<root>/node_modules/zidane/docs` and the repo itself has `<repo>/docs`.
-* Returns the first existing candidate, or `null` (the skill then falls back to
-* the literal `node_modules/zidane/docs` hint, which the model's file tools can
-* still attempt from cwd).
-*/
-function resolveExtensionDocsDir(cwd = process.cwd()) {
-	const candidates = [];
-	try {
-		const req = createRequire(import.meta.url);
-		candidates.push(join(dirname(req.resolve("zidane/package.json")), "docs"));
-	} catch {}
-	try {
-		let dir = dirname(fileURLToPath(import.meta.url));
-		for (let i = 0; i < 6; i++) {
-			if (existsSync(join(dir, "docs", "EXTENSIONS.md"))) {
-				candidates.push(join(dir, "docs"));
-				break;
-			}
-			dir = dirname(dir);
-		}
-	} catch {}
-	candidates.push(join(cwd, "node_modules", "zidane", "docs"));
-	for (const candidate of candidates) if (existsSync(join(candidate, "EXTENSIONS.md"))) return candidate;
-	return null;
-}
-/** Entry-file probe order for an extension dir (mirrors the loader's discovery). */
-const EXTENSION_ENTRY_FILES = [
-	"index.ts",
-	"index.tsx",
-	"index.mjs",
-	"index.js"
-];
-/**
-* If `cwd` sits inside a zidane extension, return that extension's root dir,
-* else `null`. Mirrors the discovery layout
-* `<scope>/.{agents,zidane}/extensions/<name>/` — the root is the `<name>` dir
-* (parent `extensions`, grandparent `.agents` / `.zidane`) holding an entry
-* file. Walks up from `cwd`, so the nearest enclosing extension wins. Lets the
-* hosts surface the authoring skill for a plain `zidane` launched from an
-* extension folder, not just sessions opened through the edit/create flow.
-*/
-function extensionDirForCwd(cwd = process.cwd()) {
-	let dir = resolve(cwd);
-	for (let i = 0; i < 64; i++) {
-		const parent = dirname(dir);
-		if (basename(parent) === "extensions" && (basename(dirname(parent)) === ".agents" || basename(dirname(parent)) === ".zidane") && EXTENSION_ENTRY_FILES.some((f) => existsSync(join(dir, f)))) return dir;
-		if (parent === dir) break;
-		dir = parent;
-	}
-	return null;
-}
-/**
-* The authoring reference embedded into the skill body. Kept INLINE (not a
-* filesystem path) on purpose: a `bun build --compile` TUI binary has no
-* resolvable `node_modules/zidane/docs`, no real `import.meta.url`, and the
-* edited extension's own cwd has no `node_modules` — so a path reference dead-
-* ends there. The model gets the API verbatim on activation regardless of host.
-*
-* Mirrors `ExtensionContext` (src/extensions/types.ts) — keep in sync when the
-* `ctx.*` surface changes.
-*/
-const EXTENSION_AUTHORING_CHEATSHEET = `## defineExtension
-
-A zidane extension is a module at \`<scope>/.{agents,zidane}/extensions/<name>/index.{ts,tsx,mjs,js}\`
-that default-exports \`defineExtension({ ... })\`. It runs in-process in the host (TUI / GUI / SDK).
-
-\`\`\`ts
-import { defineExtension } from 'zidane'
-
-export default defineExtension({
-  name: 'my-ext',          // MUST equal the folder name
-  apiVersion: 1,           // optional; omitted means v1
-  version: '0.1.0',        // optional — shown in Settings → Extensions
-  displayName: 'My Ext',   // optional UI label
-  description: 'what it does',
-  capabilities: ['tools'], // optional descriptive manifest labels
-  permissions: [],         // optional descriptive labels; not a sandbox
-  setup(ctx) { /* register everything here; may be async */ },
-  teardown() {},           // optional, reserved (no hot-reload yet)
-})
-\`\`\`
-
-Zero-import form — required INSIDE compiled binaries, which can't \`import 'zidane'\` at runtime:
-\`\`\`ts
-import type { ExtensionContext } from 'zidane' // type-only: erased at runtime
-export default {
-  name: 'my-ext',
-  setup(ctx: ExtensionContext) { /* ... */ },
-}
-\`\`\`
-
-## ctx surface (call everything inside setup)
-
-Identity / utilities:
-- ctx.name / ctx.version / ctx.dir / ctx.scope ('project' | 'user' | 'inline' | 'builtin')
-- ctx.logger          — Logger namespaced \`extension:<name>\`
-- ctx.config          — read THIS extension's config, default-first: \`ctx.config.get(key)\`
-- ctx.paths           — cwd/projectRoot/dataDir/cacheDir/configDir/stateDir
-- ctx.storage.path(scope, ...segments) — extension-scoped storage path
-- ctx.session         — JSON-only per-session state: get / set / delete
-
-Renderer-agnostic registration:
-- ctx.registerTool(name, toolDef)
-- ctx.registerHook(event, handler)             — an AgentHooks event; fires on the PARENT agent (use child:* for subagents)
-- ctx.registerMcpServer(config)
-- ctx.registerSkill(skillConfig)               — a defineSkill() shape
-- ctx.registerCompletionProvider(provider)     — single-char '/' '@' '!' trigger
-- ctx.tui.notify(text, { tone? })              — one-shot transcript line (info/warn/error); buffered pre-mount
-- ctx.tui.setStatus(text | null, { loader?, timeout? }) — single dim status line (transcript-tail slot); loader glyph, auto-clear ms
-- ctx.tui.setBanner(lines | null, { timeout? }) — short block above the prompt (stacked with the todo indicator); auto-clear ms
-- ctx.submitPrompt(text, { delivery? })        — submit as the user: 'auto' (run-or-queue), 'steer', 'followUp'; false when detached
-- ctx.registerToolPolicy({ tools?, decide })   — gate tool calls: allow / { block } / { patch } (patches re-validated by the loop)
-- ctx.registerToolResultTransform(fn)          — middleware over finished tool results (chained)
-- ctx.registerContextTransform(fn)             — rewrite wire messages before each provider call
-- ctx.registerPromptTransform(fn)              — transform or consume submitted prompts (after / commands, before skills)
-- ctx.runtime / ctx.sessions                   — late-bound host controls: model()/thinking()/setThinking(), sessions list/switch/create
-- ctx.appendNote(blocks)                       — durable display-only transcript note (command-output block vocabulary)
-- ctx.workspace.exec/readFile/writeFile/listFiles/fileSize — shell + files through the SESSION'S execution context (sandbox-correct; host child_process silently targets the wrong filesystem under docker/e2b). Detached ⇒ rejects; guard with \`await ctx.workspace.available()\`.
-- ctx.tui.registerToolRenderer({ tools?, render }) — custom view for tool-result rows; return null to fall through to the default. View-layer only: never persisted, error-bounded per row, TUI-scoped.
-- ctx.tui.registerRenderer(id, render) + emit/appendNote \`custom: { renderer, data }\` blocks — custom components in the transcript. \`data\` must be JSON-safe (it persists); the block's \`text\` is the MANDATORY markdown fallback (disabled extension, headless host, GUI, renderer throw). appendNote auto-prefixes bare ids; command emit needs \`<ext>/<id>\`.
-- Renderer components: import \`react\` / \`@opentui/react\` BARE (never as your own dependency) — the host maps them to its live instances at load time, so hooks work. Async data: render() stays sync; return a component that fetches with useState/useEffect.
-- Renderer async caching: \`useSessionState(id, initial)\` (per-row, session-persisted — rehydrates on reload) + \`useRowVisible()\` (latched viewport gate) from \`zidane/tui\` — fetch once, only when scrolled in.
-- ctx.registerCommand(command)                 — a '/<name>' workflow (handler or steps[]); step ctx: emit (local output),
-                                                 runAgent (interactive sub-run), generateData (silent zod/JSON-Schema JSON),
-                                                 session? (read-only turns/runs view), interaction? (confirm / askUser forms /
-                                                 presentPlan approval — both optional; guard for bare hosts)
-- ctx.registerTheme(theme)
-- ctx.registerAgent(profile)                   — extra agent profile in the picker
-- ctx.registerSubagent(def)                    — spawnable subagent (the spawn tool's subagent_type)
-- ctx.registerSubagentOverride(name, fn)       — edit/delete an existing subagent
-- ctx.registerProvider(descriptor)
-- ctx.registerSystemPromptFragment(text)
-- ctx.registerContextBreakdownSection(fn)      — render extension-owned rows in the context panel
-- ctx.registerContextPanelSection(section)     — richer context panel section with rows/load
-- ctx.registerToolResultMetadata(registration) — project namespaced tool-result metadata into context
-- ctx.registerRunTransform(fn)                 — sync rewrite of agent.run options
-- ctx.registerBehaviorTransform(fn)            — sync rewrite of resolved behavior
-- ctx.registerProviderMiddleware(fn)           — wrap provider instances
-- ctx.registerToolCatalogTransform(fn)         — shape/hide/rename tools before disclosure/execution
-- ctx.registerMcpConfigTransform(fn)           — rewrite MCP server configs before connect
-- ctx.registerSkillPolicy(policy)              — auto-activate skills by run context
-- ctx.registerConfigCategory(category)
-- ctx.registerConfigItem([categoryId,] item)   — typed setting; supports scope/onChange metadata
-
-TUI-only (ctx.tui.* — silently ignored on non-TUI hosts):
-- ctx.tui.registerKeybinding(binding)
-- ctx.tui.registerFooterHint(hint)
-- ctx.tui.registerModal(modal)                 — keep UI lazy: \`node: () => import('./panel')\`
-
-GUI-only:
-- ctx.gui.registerPanel(panel)                  — collected, not rendered yet
-
-Completion providers may also implement submit hooks:
-- resolveReferences(refs, ctx, signal)
-- onSubmit({ text, cursor, references }, signal)
-Both TUI and GUI call these before dispatching a submitted prompt.
-
-## ToolDef shape
-\`\`\`ts
-ctx.registerTool('my_tool', {
-  spec: { name: 'my_tool', description: '...', inputSchema: { type: 'object', properties: {} } },
-  isConcurrencySafe: true,   // default false (barrier/write); true = read-only, fans out in parallel
-  async execute(args) { return 'result' },
-})
-\`\`\`
-
-## Invariants
-- The folder name MUST equal \`name\`, or the loader rejects the extension.
-- Optional metadata lives in \`extension.json\` or \`package.json#zidane\`; unsupported \`apiVersion\` is rejected.
-- Export as \`default\` (or a named \`extension\` export).
-- Register ONLY inside \`setup\` — calls after it resolves are dropped (logger.warn).
-- A throw in \`setup\` is caught and shown on the extension's Settings row; the rest of boot continues.
-- Discovery order, first per name wins: project \`.agents\` → project \`.zidane\` → \`~/.agents\` → \`~/.zidane\`.
-- \`/reload\` is a TRUE hot-reload: re-discover + re-run setup, and each extension's module graph is re-imported fresh — code edits (deep imports included) apply live. Module-level state resets; clean up external resources in \`teardown\`.
-
-## Distribution
-- Users install via Settings → Extensions → \`ctrl+g\` (source input + scope picker) — GitHub (\`owner/repo[#ref][:sub/dir]\`, tree URLs) or npm (\`pkg[@version]\`, exact versions / dist-tags).
-- Update / remove: Settings → Extensions, \`ctrl+u\` / \`ctrl+x\` on the focused row (update replays the recorded \`.install.json\` provenance in place, skipping when the recorded commit/version still matches the remote).
-- Shape your repo/package as a root \`index.ts\` (single extension) or \`extensions/<name>/index.*\` dirs (collection).
-- Reference packages to copy: \`extensions/git-flow\` in the zidane repo (zero-dep \`/commit\` command) and \`extensions/headroom\` (hooks + tool + config).
-- Declare runtime deps in \`package.json#dependencies\` — installed with bun/npm/… WITHOUT lifecycle scripts; don't rely on postinstall.
-- The installed folder is named from your exported \`definition.name\` — pick it to be folder-safe ([A-Za-z0-9_.-]).`;
-/** Preset preamble for "edit / create extension" sessions. */
-const EXTENSION_EDIT_PRESET = "You are authoring / editing a zidane extension. Authoritative API reference:";
-/** Preset preamble for "edit skill" sessions — same spirit, skill-flavored. */
-function skillEditPreset(marker) {
-	return `We are going to work on ${marker.name}, in ${marker.dir} directory, next messages will be requests at modifying and improving the skill or understanding how it works better.`;
-}
-/**
-* The inline `zidane-extension` skill. Carries the authoring reference IN its
-* body ({@link EXTENSION_AUTHORING_CHEATSHEET}) so it works in every host —
-* incl. compiled binaries where the on-disk docs aren't resolvable. The shipped
-* `EXTENSIONS.md` (prose long-form) is appended as a "see also" only when found
-* on disk. `source: 'inline'` (the `defineSkill` default) survives the
-* project-trust gate.
-*/
-function buildZidaneExtensionSkill(opts = {}) {
-	const docsDir = resolveExtensionDocsDir(opts.cwd);
-	const seeAlso = docsDir ? `\n\n---\nFull prose reference on disk: ${join(docsDir, "EXTENSIONS.md")}\nSibling docs cover related surfaces (ARCHITECTURE.md, CHAT.md, TUI.md, SKILL.md, HEADLESS.md, …).` : "\n\n---\nFuller prose reference, when present: node_modules/zidane/docs/EXTENSIONS.md (often absent in compiled binaries — the API above is authoritative).";
-	return defineSkill({
-		name: ZIDANE_EXTENSION_SKILL_NAME,
-		description: "Authoring or editing a zidane extension (a module calling defineExtension, under .zidane/extensions/** or .agents/extensions/**). Carries the extension authoring reference.",
-		instructions: `${EXTENSION_EDIT_PRESET}\n\n${EXTENSION_AUTHORING_CHEATSHEET}${seeAlso}`
-	});
-}
-/**
-* Inject the `zidane-extension` skill into an already-merged {@link SkillsConfig}.
-*
-* Call this on the FINAL merged skills object (after folding extension / preset
-* skills): `composePresets` is last-wins on `catalog`, so injecting earlier
-* would be silently dropped whenever an extension also contributes skills.
-*
-* Adds the skill to the catalog and, when an `enabled` allowlist is in force,
-* force-includes the name so the allowlist filter can't hide it (mirrors how
-* extension-contributed skill names are force-included). When skills are fully
-* disabled (`enabled === false`), the edit session still gets just this skill.
-*/
-function withZidaneExtensionSkill(skills, opts = {}) {
-	return injectInlineSkill(skills, buildZidaneExtensionSkill(opts));
-}
-/**
-* Compact skill-authoring reference embedded into the skill-edit skill body.
-* Inline for the same reason as {@link EXTENSION_AUTHORING_CHEATSHEET}: works
-* in compiled binaries where on-disk docs don't resolve.
-*/
-const SKILL_AUTHORING_CHEATSHEET = `## SKILL.md anatomy
-
-A skill is a directory holding a \`SKILL.md\` (YAML frontmatter + markdown body)
-per the Agent Skills standard (agentskills.io/specification):
-
-\`\`\`md
----
-name: my-skill            # 1-64 chars, lowercase alphanumeric + hyphens; SHOULD match the directory name
-description: what it does AND when to use it (drives activation — 1-1024 chars)
-license: MIT              # optional
-compatibility: …          # optional environment requirements
-allowed-tools:            # optional — restricts the agent to these tools while active
-  - read_file
-metadata:                 # optional flat string map; zidane-specific keys use the \`zidane.\` prefix
-  some-key: value
----
-The body is the skill's instructions — injected into context when the skill
-is activated. Keep it token-lean: move depth into references/.
-\`\`\`
-
-## Bundled resources (all optional, discovered automatically)
-- \`references/\` — docs loaded on demand via \`skills_read\`
-- \`scripts/\`    — executables run via \`skills_run_script\` (honor shebangs)
-- \`assets/\`     — templates / static files
-
-## Guidance
-- The description is the activation trigger — write it for the ROUTER ("use when …"), the body for the ACTIVATED agent.
-- Prefer small bodies + lazy references over one giant SKILL.md.
-- Shell interpolation (exclamation mark + backtick-quoted command) in the body runs at activation — use sparingly; hosts may gate or disable it.
-- Validate names: mismatched frontmatter name vs directory loads with a warning diagnostic.`;
-/**
-* The inline skill auto-activated in "edit skill" sessions. Body = the
-* session preset (which skill, which directory, what the next messages will
-* be about) + a compact SKILL.md authoring reference — the skill-editing
-* counterpart of {@link buildZidaneExtensionSkill}.
-*/
-function buildZidaneSkillEditSkill(marker, opts = {}) {
-	const docsDir = resolveExtensionDocsDir(opts.cwd);
-	const seeAlso = docsDir && existsSync(join(docsDir, "SKILL.md")) ? `\n\n---\nFull prose reference on disk: ${join(docsDir, "SKILL.md")}` : "";
-	return defineSkill({
-		name: ZIDANE_SKILL_EDIT_SKILL_NAME,
-		description: `Editing or improving the "${marker.name}" agent skill (its SKILL.md, references, scripts, and assets). Carries the skill-authoring reference for this edit session.`,
-		instructions: `${skillEditPreset(marker)}\n\n${SKILL_AUTHORING_CHEATSHEET}${seeAlso}`
-	});
-}
-/**
-* Inject the skill-edit preset skill into an already-merged {@link SkillsConfig}.
-* Same contract as {@link withZidaneExtensionSkill} — call on the FINAL merged
-* skills object.
-*/
-function withZidaneSkillEditSkill(skills, marker, opts = {}) {
-	return injectInlineSkill(skills, buildZidaneSkillEditSkill(marker, opts));
-}
-/**
-* Shared injector: add `skill` to the catalog and, when an `enabled`
-* allowlist is in force, force-include its name so the filter can't hide it
-* (mirrors how extension-contributed skill names are force-included). When
-* skills are fully disabled (`enabled === false`), the edit session still
-* gets just this skill.
-*/
-function injectInlineSkill(skills, skill) {
-	const catalog = [...skills.catalog ?? [], skill];
-	const enabled = skills.enabled;
-	const nextEnabled = enabled === void 0 ? void 0 : Array.isArray(enabled) ? enabled.includes(skill.name) ? enabled : [...enabled, skill.name] : [skill.name];
-	return {
-		...skills,
-		catalog,
-		...nextEnabled !== void 0 ? { enabled: nextEnabled } : {}
-	};
-}
-//#endregion
-//#region src/mcp/oauth-callback.ts
-const DEFAULT_PATH = "/callback";
-const DEFAULT_HOST = "127.0.0.1";
-/**
-* Fallback renderer for hosts that don't inject one (bare SDK use) —
-* deliberately minimal, no framework, no branding. All interpolations are
-* escaped: a malicious authorization server could craft an
-* `error_description` containing markup, and even a one-shot loopback
-* page must not XSS.
-*/
-const renderMinimalPage = (page) => {
-	const escaped = (value) => value.replaceAll("&", "&amp;").replaceAll("<", "&lt;").replaceAll(">", "&gt;");
-	const ok = page.kind === "success";
-	return `<!doctype html>
-<html><head><meta charset="utf-8"><title>${ok ? "Logged in" : "Login failed"}</title>
-<style>body{font:14px/1.5 -apple-system,system-ui,sans-serif;margin:6rem auto;max-width:28rem;text-align:center;color:#1d1d1f}.ok{color:#1f8a4c;font-weight:600}.err{color:#c43c2c;font-weight:600}</style>
-</head><body>
-<p class="${ok ? "ok" : "err"}">${ok ? "Logged in." : "Login failed."}</p>
-${page.details ? `<p>${escaped(page.details)}</p>` : ""}
-<p>${escaped(page.message)}</p>
-</body></html>`;
-};
-const CLOSE_TAB_MESSAGE = "You can close this tab and return to the terminal.";
-/**
-* Start a one-shot OAuth callback server. The returned handle's `redirectUri`
-* should be passed to the authorization server as the `redirect_uri` query
-* parameter; `promise` resolves once the user finishes the browser flow.
-*
-* Always `await handle.close()` in a `finally` block — even on success, the
-* server stays open until told to shut down (so it can serve the
-* "you can close this tab" page).
-*/
-async function startOAuthCallback(opts = {}) {
-	const path = opts.path ?? DEFAULT_PATH;
-	const host = opts.host ?? DEFAULT_HOST;
-	const port = opts.port ?? 0;
-	const renderPage = opts.renderPage ?? renderMinimalPage;
-	const provider = opts.provider ?? "MCP server";
-	if (!path.startsWith("/")) throw new Error(`OAuth callback path must start with "/" (got: ${JSON.stringify(path)})`);
-	if (opts.signal?.aborted) throw new Error("OAuth callback aborted");
-	let resolveResult;
-	let rejectResult;
-	const promise = new Promise((resolve, reject) => {
-		resolveResult = resolve;
-		rejectResult = reject;
-	});
-	promise.catch(() => {});
-	let settled = false;
-	const resolveOnce = (value) => {
-		if (settled) return;
-		settled = true;
-		resolveResult(value);
-	};
-	const rejectOnce = (error) => {
-		if (settled) return;
-		settled = true;
-		rejectResult(error);
-	};
-	const server = createServer((req, res) => {
-		const url = new URL(req.url ?? "/", `http://${host}`);
-		if (url.pathname !== path) {
-			res.writeHead(404, { "content-type": "text/plain" });
-			res.end("Not Found");
-			return;
-		}
-		const htmlHeaders = {
-			"content-type": "text/html; charset=utf-8",
-			"cache-control": "no-store"
-		};
-		const error = url.searchParams.get("error");
-		if (error) {
-			const desc = url.searchParams.get("error_description") ?? error;
-			res.writeHead(400, htmlHeaders);
-			res.end(renderPage({
-				kind: "error",
-				message: CLOSE_TAB_MESSAGE,
-				details: desc,
-				provider
-			}));
-			rejectOnce(/* @__PURE__ */ new Error(`OAuth authorization failed: ${desc}`));
-			return;
-		}
-		const code = url.searchParams.get("code");
-		if (!code) {
-			res.writeHead(400, { "content-type": "text/plain" });
-			res.end("Missing \"code\" query parameter.");
-			return;
-		}
-		const state = url.searchParams.get("state") ?? void 0;
-		res.writeHead(200, htmlHeaders);
-		res.end(renderPage({
-			kind: "success",
-			message: CLOSE_TAB_MESSAGE,
-			provider
-		}));
-		resolveOnce({
-			code,
-			state
-		});
-	});
-	server.on("error", (err) => {
-		rejectOnce(err instanceof Error ? err : new Error(String(err)));
-	});
-	await new Promise((resolve, reject) => {
-		server.once("error", reject);
-		server.listen(port, host, () => {
-			server.off("error", reject);
-			resolve();
-		});
-	});
-	const addr = server.address();
-	if (!addr || typeof addr === "string") {
-		server.close();
-		throw new Error("OAuth callback server did not bind to a TCP port");
-	}
-	let closing;
-	let closeServer;
-	const onAbort = () => {
-		rejectOnce(/* @__PURE__ */ new Error("OAuth callback aborted"));
-		closeServer();
-	};
-	closeServer = () => {
-		if (closing) return closing;
-		closing = new Promise((resolve) => {
-			server.closeAllConnections?.();
-			server.close(() => {
-				opts.signal?.removeEventListener("abort", onAbort);
-				if (opts.signal?.aborted) rejectOnce(/* @__PURE__ */ new Error("OAuth callback aborted"));
-				else rejectOnce(/* @__PURE__ */ new Error("OAuth callback server closed"));
-				resolve();
-			});
-		});
-		return closing;
-	};
-	opts.signal?.addEventListener("abort", onAbort, { once: true });
-	return {
-		redirectUri: `http://${host}:${addr.port}${path}`,
-		promise,
-		close: closeServer
-	};
-}
-//#endregion
-//#region src/mcp/login.ts
-const DEFAULT_LOGIN_TIMEOUT_MS = 5 * 6e4;
-const DEFAULT_CONNECT_TIMEOUT_MS = 3e4;
-/**
-* Run the full interactive OAuth flow for `config`. Only supports `sse` and
-* `streamable-http` transports — `stdio` MCP servers don't speak OAuth.
-*
-* Throws on:
-*   - Wrong transport.
-*   - Abort signal.
-*   - Browser-side error (user denied, server rejected, etc.).
-*   - Code exchange failure.
-*   - Post-exchange connect failure.
-*
-* Always closes the loopback callback server before returning, success or
-* failure.
-*/
-async function loginMcpServer(config, options) {
-	if (config.transport !== "sse" && config.transport !== "streamable-http") throw new Error(`MCP OAuth: cannot login for transport "${config.transport}" — only sse / streamable-http are supported`);
-	if (!config.url) throw new Error(`MCP OAuth: server "${config.name}" is missing a url`);
-	const hooks = options.hooks;
-	let settled = false;
-	let callback;
-	try {
-		callback = await startOAuthCallback({
-			signal: options.signal,
-			path: options.callbackPath,
-			...options.renderCallbackPage ? { renderPage: options.renderCallbackPage } : {},
-			provider: config.name
-		});
-		const handle = callback;
-		const provider = new McpOAuthProvider({
-			name: config.name,
-			store: options.store,
-			redirectUri: handle.redirectUri,
-			clientName: options.clientName,
-			scope: options.scope,
-			onAuthorizationUrl: async (url) => {
-				if (settled || options.signal?.aborted) return;
-				await hooks?.callHook("mcp:auth:url", {
-					name: config.name,
-					url: url.toString()
-				});
-				await options.onAuthorizationUrl?.(url);
-			}
-		});
-		let transport = await createInteractiveTransport(config, provider);
-		const client = await createTolerantClient({
-			name: "zidane",
-			version: "1.0.0"
-		});
-		let needsAuth = false;
-		const connectTimeoutMs = options.connectTimeoutMs ?? DEFAULT_CONNECT_TIMEOUT_MS;
-		for (let attempt = 0;; attempt++) try {
-			await raceAbort(client.connect(transport), options.signal, connectTimeoutMs, `MCP OAuth: "${config.name}" did not respond within ${connectTimeoutMs}ms — the server may be unreachable`);
-			break;
-		} catch (err) {
-			if (isUnauthorizedError(err)) {
-				needsAuth = true;
-				break;
-			}
-			if (attempt === 0 && isOAuthTokenRejectionError(err)) {
-				await provider.invalidateCredentials("tokens");
-				await transport.close().catch(() => {});
-				transport = await createInteractiveTransport(config, provider);
-				continue;
-			}
-			await client.close().catch(() => {});
-			throw err;
-		}
-		if (needsAuth) {
-			const { code } = await raceLoginCallback(handle, options.timeoutMs ?? DEFAULT_LOGIN_TIMEOUT_MS, options.signal);
-			await transport.finishAuth(code);
-			await transport.close().catch(() => {});
-			const freshTransport = await createInteractiveTransport(config, provider);
-			await raceAbort(client.connect(freshTransport), options.signal, connectTimeoutMs, `MCP OAuth: "${config.name}" did not respond after the token exchange (within ${connectTimeoutMs}ms)`);
-		}
-		const { tools } = await raceAbort(client.listTools(), options.signal, connectTimeoutMs, `MCP OAuth: "${config.name}" did not return its tool list within ${connectTimeoutMs}ms`);
-		await client.close();
-		const tokens = provider.tokens();
-		if (!tokens) throw new Error(`MCP OAuth: login for "${config.name}" returned no tokens (server may have rejected the exchange silently)`);
-		await hooks?.callHook("mcp:auth:success", { name: config.name });
-		return {
-			tokens,
-			tools
-		};
-	} catch (err) {
-		const error = err instanceof Error ? err : new Error(String(err));
-		await hooks?.callHook("mcp:auth:error", {
-			name: config.name,
-			error
-		});
-		throw error;
-	} finally {
-		settled = true;
-		await callback?.close();
-	}
-}
-/**
-* Build an `sse` / `streamable-http` transport pre-wired with `authProvider`.
-* Mirrors the bootstrap-side `createTransport` shape but inlined here so the
-* login flow doesn't depend on the bootstrap module's private export.
-*/
-async function createInteractiveTransport(rawConfig, authProvider) {
-	const config = expandMcpConfigEnv(rawConfig);
-	if (config.transport === "sse") {
-		const { SSEClientTransport } = await import("@modelcontextprotocol/sdk/client/sse.js");
-		return new SSEClientTransport(new URL(config.url), {
-			requestInit: config.headers ? { headers: config.headers } : void 0,
-			authProvider
-		});
-	}
-	const { StreamableHTTPClientTransport } = await import("@modelcontextprotocol/sdk/client/streamableHttp.js");
-	return new StreamableHTTPClientTransport(new URL(config.url), {
-		requestInit: config.headers ? { headers: config.headers } : void 0,
-		fetch: sseToJsonFetchIfNeeded(),
-		authProvider
-	});
-}
-function isUnauthorizedError(err) {
-	if (!err || typeof err !== "object") return false;
-	const e = err;
-	if (e.name === "UnauthorizedError" || e.constructor?.name === "UnauthorizedError") return true;
-	return typeof e.message === "string" && e.message.toLowerCase().startsWith("unauthorized");
-}
-/**
-* Race `promise` against the external abort signal and a hard timeout.
-*
-* Used for phases we can't cancel from the inside (the SDK's `connect()`
-* accepts no signal). The underlying work isn't stopped — it's abandoned —
-* so callers must treat a rejection as "this attempt is over" and close
-* whatever they own. Rejects with `'OAuth login aborted'` on abort so the
-* host can tell a user cancel apart from a genuine failure.
-*/
-async function raceAbort(promise, signal, timeoutMs, timeoutMessage) {
-	if (signal?.aborted) throw new Error("OAuth login aborted");
-	promise.catch(() => {});
-	let timer;
-	let onAbort;
-	try {
-		return await new Promise((resolve, reject) => {
-			timer = setTimeout(() => reject(new Error(timeoutMessage)), timeoutMs);
-			if (signal) {
-				onAbort = () => reject(/* @__PURE__ */ new Error("OAuth login aborted"));
-				signal.addEventListener("abort", onAbort, { once: true });
-			}
-			promise.then(resolve, reject);
-		});
-	} finally {
-		if (timer) clearTimeout(timer);
-		if (signal && onAbort) signal.removeEventListener("abort", onAbort);
-	}
-}
-/**
-* Wait on the callback handle, with a hard timeout AND honor the external
-* abort signal. Unlike `callback.promise` alone, this provides a deterministic
-* failure mode for "user opened the browser then walked away" — the modal
-* doesn't hang forever waiting for a redirect that may never come.
-*/
-async function raceLoginCallback(handle, timeoutMs, signal) {
-	if (signal?.aborted) throw new Error("OAuth login aborted");
-	let timer;
-	let onAbort;
-	try {
-		return await new Promise((resolve, reject) => {
-			timer = setTimeout(() => reject(/* @__PURE__ */ new Error(`OAuth login timed out after ${timeoutMs}ms`)), timeoutMs);
-			if (signal) {
-				onAbort = () => reject(/* @__PURE__ */ new Error("OAuth login aborted"));
-				signal.addEventListener("abort", onAbort, { once: true });
-			}
-			handle.promise.then(resolve, reject);
-		});
-	} finally {
-		if (timer) clearTimeout(timer);
-		if (signal && onAbort) signal.removeEventListener("abort", onAbort);
-	}
-}
-//#endregion
-export { ZIDANE_EXTENSION_SKILL_NAME as a, buildZidaneSkillEditSkill as c, extensionScaffold as d, readSkillEditMarker as f, withZidaneSkillEditSkill as h, SKILL_EDIT_METADATA_KEY as i, editSessionMetadata as l, withZidaneExtensionSkill as m, startOAuthCallback as n, ZIDANE_SKILL_EDIT_SKILL_NAME as o, resolveExtensionDocsDir as p, EXTENSION_EDIT_METADATA_KEY as r, buildZidaneExtensionSkill as s, loginMcpServer as t, extensionDirForCwd as u };
-
-//# sourceMappingURL=login-CB23LyI1.js.map