@habemus-papadum/aiui 0.3.0 → 0.5.0

package/dist/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sources":["../src/index.ts"],"sourcesContent":["/**\n * ai ui frontends\n *\n * The `aiui` CLI's library surface. Launch *policy* the CLI applies lives here\n * too, so sibling supervisors can reuse it instead of re-deriving it — the\n * first case is {@link resolveSidecars}, the `aiui claude` logic deciding\n * which session sidecars (e.g. the paint stream) a channel server should host for a\n * project root. The workbench imports it to give its debug channel the same\n * sidecar set a real session would get.\n *\n * @packageDocumentation\n */\n\nexport {\n  type ResolveSidecarsDeps,\n  resolveSidecars,\n  type SidecarDescriptor,\n} from \"./util/sidecars\";\n\n/** The published package name — handy for smoke tests. */\nexport const name = \"@habemus-papadum/aiui\";\n\n/** Greet someone. Replace with your library's real API. */\nexport function greet(who: string): string {\n  return `Hello, ${who}!`;\n}\n"],"names":["name","greet","who"],"mappings":";AAoBO,MAAMA,IAAO;AAGb,SAASC,EAAMC,GAAqB;AACzC,SAAO,UAAUA,CAAG;AACtB;"}
+{"version":3,"file":"index.js","sources":["../src/index.ts"],"sourcesContent":["/**\n * ai ui frontends\n *\n * The `aiui` CLI's library surface. Launch *policy* the CLI applies lives here\n * too, so sibling supervisors can reuse it instead of re-deriving it — e.g. the\n * layered config loader below, so a debug-channel supervisor binds the channel\n * the same way a real `aiui claude` launch would.\n *\n * @packageDocumentation\n */\n\n// The layered config loader (user config ← project config), for supervisors\n// that must obey the same settings a real `aiui claude` launch would — the\n// supervisors read `channel.bind` through this so a debug channel binds the\n// way the user configured the real one.\nexport { type AiuiConfig, loadAiuiConfig } from \"./util/config\";\n\n/** The published package name — handy for smoke tests. */\nexport const name = \"@habemus-papadum/aiui\";\n\n/** Greet someone. Replace with your library's real API. */\nexport function greet(who: string): string {\n  return `Hello, ${who}!`;\n}\n"],"names":["name","greet","who"],"mappings":";AAkBO,MAAMA,IAAO;AAGb,SAASC,EAAMC,GAAqB;AACzC,SAAO,UAAUA,CAAG;AACtB;"}

package/dist/util/aiui-args.d.ts

@@ -55,17 +55,6 @@ export interface AiuiArgs {
      * `chrome.browserUrl` in config for this launch.
      */
     browserUrl?: string;
-    /**
-     * Names collected from repeatable `--aiui-sidecar <name>` flags — session
-     * sidecars to force-enable even when they wouldn't auto-detect for this
-     * project (e.g. `--aiui-sidecar paint`).
-     */
-    sidecar: string[];
-    /**
-     * Names collected from repeatable `--aiui-no-sidecar <name>` flags — session
-     * sidecars to disable for this run. Disable wins over enable.
-     */
-    noSidecar: string[];
     /**
      * The `--aiui-bind <loopback|host>` value, if provided — where the channel's
      * web backend binds for this launch, overriding `channel.bind` in config.
@@ -105,9 +94,6 @@ export declare function infoFlag(passthrough: string[]): "help" | "version" | un
  *    dir instead of a named profile. Mutually exclusive with the above.
  *  - `--aiui-browser-url <url>` — attach the Chrome DevTools MCP to this
  *    endpoint (e.g. a tunneled remote browser) instead of managing one.
- *  - `--aiui-sidecar <name>` / `--aiui-no-sidecar <name>` — force-enable /
- *    disable a session sidecar by name. Both are repeatable and accumulate;
- *    disable wins over enable when the same name appears in both.
  *  - `--aiui-bind <loopback|host>` — where the channel's web backend binds for
  *    this launch (see `channel.bind` in the config guide). Any other value is
  *    an error.

package/dist/util/channel-launch.d.ts

@@ -0,0 +1,67 @@
+/**
+ * How a channel process gets configured, in one place.
+ *
+ * There are two ways the channel server comes up, and they must agree:
+ *
+ *  - **`aiui claude`** builds an argv for the channel's `mcp` subcommand and
+ *    hands it to Claude Code inside `--mcp-config`, which spawns it.
+ *  - **`aiui mcp serve` / `aiui mcp mcp`** run the very same channel CLI
+ *    directly, with no Claude Code anywhere in the loop.
+ *
+ * The one durable setting they must both derive from config is where the web
+ * backend binds (`channel.bind`) — the trusted-LAN posture. The second path
+ * used to forward its arguments verbatim and so never computed it; this module
+ * is what makes both paths resolve the same {@link ChannelLaunch} and emit the
+ * same `--bind` flag, so a standalone channel binds exactly like a session's.
+ *
+ * Which sidecars a channel hosts is NOT decided here anymore. The channel
+ * imports and mounts its own standard set (intent, bar, pencil — see the
+ * channel's standard-sidecars.ts), so there is nothing to pass: every channel
+ * hosts all four, and `channel.bind` alone decides whether a remote device can
+ * reach them.
+ *
+ * What else deliberately does NOT live here: `--launch-info` (a summary of *how
+ * a Claude Code session was assembled* — browser wiring, key preflight — which
+ * a direct launch has nothing to say about, and which `serve` does not even
+ * accept), and `--tag` / `--name` / `--port`, which are per-invocation identity
+ * rather than durable configuration.
+ */
+import type { AiuiConfig, ChannelBind } from "./config";
+/** Everything a launcher knows that can influence the channel's configuration. */
+export interface ChannelLaunchInput {
+    /** Merged user + project config (`util/config`). */
+    config: AiuiConfig;
+    /** An explicit per-launch bind (`--aiui-bind`, or `serve`'s own `--bind`). */
+    bind?: ChannelBind;
+}
+/** The resolved settings, ready to be rendered as channel CLI flags. */
+export interface ChannelLaunch {
+    bind: ChannelBind;
+}
+/**
+ * Resolve the channel's bind for a launch. Follows the three-tier precedence
+ * the docs promise: per-launch flag, then durable config, then the built-in
+ * default (`loopback`).
+ */
+export declare function resolveChannelLaunch(input: ChannelLaunchInput): ChannelLaunch;
+/**
+ * Render a {@link ChannelLaunch} as flags for the channel CLI. Both the `mcp`
+ * and `serve` subcommands accept `--bind` (see the channel's program.ts).
+ */
+export declare function channelLaunchFlags(launch: ChannelLaunch): string[];
+/**
+ * Whether `aiui mcp <args...>` will start a channel process, and so wants the
+ * config-derived settings. Callers use this to leave the subcommands that
+ * merely talk to a channel someone else is running (`quick`, `config`)
+ * untouched.
+ */
+export declare function isChannelLaunch(args: string[]): boolean;
+/**
+ * Apply the config-derived channel settings to a raw `aiui mcp <args...>`
+ * invocation.
+ *
+ * Returns `args` untouched unless its subcommand actually launches a channel.
+ * A setting the caller named explicitly is never overridden — `aiui mcp serve
+ * --bind host` means `host` no matter what config says.
+ */
+export declare function applyChannelLaunchArgs(args: string[], launch: ChannelLaunch): string[];

package/dist/util/channel-target.d.ts

@@ -0,0 +1,33 @@
+/**
+ * channel-target.ts — resolve which running channel a channel-CONNECTING
+ * command should talk to.
+ *
+ * Used by the commands that genuinely reach into a channel: `aiui debug` (the
+ * trace viewer, bound to one channel's port) and, in spirit, the intent
+ * client's standalone `pnpm dev` launcher. Deliberately NOT used by `aiui
+ * vite` any more: an app it serves reaches the channel through the intent
+ * client at `/intent/`, not a build-time port, so there is nothing to resolve.
+ * (This helper lived in `commands/vite.ts` while vite was that connection;
+ * it moved here when vite stopped connecting — owner, 2026-07-17.)
+ */
+import type { RunningServer } from "@habemus-papadum/aiui-claude-channel";
+/** The channel a command should point at, or why it couldn't be resolved. */
+export interface ChannelTarget {
+    /** The server resolved without prompting (by tag). */
+    server?: RunningServer;
+    /** Servers to offer in the interactive selector (no tag given, ≥1 running). */
+    select?: RunningServer[];
+    /** A human-readable reason a requested server couldn't be resolved. */
+    error?: string;
+}
+/**
+ * Decide which running channel server a command should connect to.
+ *
+ * Pure so it can be unit-tested without spawning anything:
+ *  - With a `targetTag`, return the server whose `tag` matches exactly; if none
+ *    matches, return an `error` naming the tag and the tags that *are* running.
+ *  - Without a `targetTag`, don't guess: return `{}` when nothing is running, or
+ *    `{ select }` so the caller runs the same selector as `quick` (which
+ *    auto-picks a lone server and prompts when there are several).
+ */
+export declare function resolveChannelTarget(servers: RunningServer[], targetTag: string | undefined): ChannelTarget;

package/dist/util/chrome.d.ts

@@ -46,7 +46,6 @@ export interface ChromeSettings {
     /** Installed Chrome release channel to launch, if configured. */
     channel?: ChromeChannel;
     headless: boolean;
-    buildExtension: boolean;
 }
 /**
  * Reconcile CLI flags with config into the settings for this launch.
@@ -69,43 +68,61 @@ export declare function chromeUserDataDir(ids: {
     dataDir?: string;
     profile?: string;
 }, base?: string): string;
+/** The intent client's MV3 bundle directory name (see its build-ext.ts: a
+ * THIRD shape of that package — dist/ is the library, dist-ext/ the unpacked
+ * extension). */
+export declare const INTENT_CLIENT_OUT_DIR = "dist-ext";
 /**
- * The built aiui-devtools-extension directory, if available.
+ * What we found when looking for the intent client's extension — the one
+ * launches AUTO-LOAD.
  *
- * The package publishes `extension/` prebuilt, so this resolves both in a dev
- * workspace (where `extension/js` appears once built — see
- * {@link buildDevtoolsExtension}) and installed from npm. Without `js/` the
- * extension is an empty shell, so an unbuilt dev checkout returns undefined.
+ * Deliberately simple: the bundle is a static build with no dev server and no
+ * dev/prod split — the client's hot-iteration surface is the channel-served
+ * plain page, so the extension only ever needs to be BUILT.
  */
-export declare function devtoolsExtensionDir(): string | undefined;
-/**
- * Rebuild the aiui-devtools-extension package so the auto-loaded panel is never stale.
- *
- * A full tsc of the extension (plus the debug-ui esbuild bundle) is well
- * under a second — cheap enough to run on every launch rather than tracking
- * staleness. Best-effort by design: outside a dev
- * checkout (no devtools package, no typescript) it silently does nothing, and
- * a failing compile warns loudly but never blocks the launch — whatever
- * `extension/js` already holds is what gets loaded.
- */
-export declare function buildDevtoolsExtension(): Promise<void>;
+export type IntentClientExtension = {
+    state: "absent";
+} | {
+    state: "unbuilt";
+    root: string;
+} | {
+    state: "ready";
+    dir: string;
+};
+/** Absolute paths for the intent client's bundle, in a checkout. */
+export declare function intentClientExtensionPaths(): {
+    root: string;
+    outDir: string;
+} | undefined;
+/** {@link findIntentClientExtension}'s decision, against explicit paths. */
+export declare function resolveIntentClientExtension(paths: {
+    root: string;
+    outDir: string;
+} | undefined): IntentClientExtension;
+/** The intent client extension, as this checkout can load it. No build-on-
+ * launch (the same rule as the frozen extension's ladder): the bundle is a
+ * deliberate act — `pnpm -C packages/aiui-intent-client build:ext`. */
+export declare function findIntentClientExtension(): IntentClientExtension;
+/** One launch-time note when the client is resolvable but unbuilt — printed
+ * every launch while true (actionable; it disappears once fixed). */
+export declare function warnIntentClientState(intent: IntentClientExtension): void;
 /**
- * One-time tip when the extension exists but the chosen browser won't
- * auto-load it (no `executablePath` means a branded Chrome — installed
+ * One-time tip when extensions exist but the chosen browser won't
+ * auto-load them (no `executablePath` means a branded Chrome — installed
  * stable or a `channel` build — and branded builds ≥ 137 ignore
  * `--load-extension`). Printed once per profile: the marker file lives in the
  * user data dir, so it survives exactly as long as the profile whose manual
  * install it recommends.
  */
-export declare function maybeExtensionAutoloadHint(settings: ChromeSettings, extensionDir: string | undefined): void;
+export declare function maybeExtensionAutoloadHint(settings: ChromeSettings, extensionDirs: string[]): void;
 /**
  * The `mcpServers` entry that launches chrome-devtools-mcp.
  *
  * Uses the documented `npx -y chrome-devtools-mcp@latest` invocation with the
  * user data dir pinned to ours. Puppeteer's default launch args include
- * `--disable-extensions`, which would neuter both the auto-loaded panel and
- * anything installed manually into the profile — so it is always stripped.
- * When an extension dir is given, additionally ask Chrome to load it.
+ * `--disable-extensions`, which would neuter both the auto-loaded extensions
+ * and anything installed manually into the profile — so it is always stripped.
+ * When extension dirs are given, additionally ask Chrome to load them.
  */
 /**
  * The `mcpServers` entry that *attaches* chrome-devtools-mcp to an existing
@@ -117,7 +134,7 @@ export declare function chromeMcpAttachServer(browserUrl: string): {
     command: string;
     args: string[];
 };
-export declare function chromeMcpServer(settings: ChromeSettings, extensionDir?: string): {
+export declare function chromeMcpServer(settings: ChromeSettings, extensionDirs?: string[]): {
     command: string;
     args: string[];
 };

package/dist/util/config.d.ts

@@ -17,10 +17,6 @@ export interface AiuiConfig {
         /** Which interface the channel web server binds: loopback (default) or host (LAN). */
         bind?: ChannelBind;
     };
-    sidecars?: {
-        /** Host the iPad paint sidecar on the channel's port (default: true). */
-        paint?: boolean;
-    };
     chrome?: {
         /** Attach the Chrome DevTools MCP (default: true). */
         enabled?: boolean;
@@ -42,8 +38,12 @@ export interface AiuiConfig {
         forTesting?: ForTestingMode;
         /** Launch Chrome headless (default: false). */
         headless?: boolean;
-        /** Rebuild the aiui-devtools-extension on every launch in a dev checkout. */
+        /** OBSOLETE (the devtools extension is deleted): parsed and ignored so old
+         * configs stay valid. */
         buildExtension?: boolean;
+        /** OBSOLETE (page-side getDisplayMedia capture is gone): parsed and
+         * ignored so old configs stay valid. */
+        autoCapture?: boolean;
     };
 }
 /** The `config.json` paths consulted, user-level first (base: the project dir). */

package/dist/util/gemini-preflight.d.ts

@@ -0,0 +1,56 @@
+/**
+ * Gemini key preflight for `aiui claude` — the GEMINI_API_KEY twin of
+ * {@link ./openai-preflight}.
+ *
+ * The realtime submode's reference engine is Gemini Live, and it runs in the
+ * *channel* process, which inherits the environment `aiui claude` launches in.
+ * Same key story as OpenAI: **`GEMINI_API_KEY` in the environment**, never
+ * config, never a flag. And the same failure this catches: a missing or stale
+ * key that would otherwise surface as an opaque closed WebSocket deep in a
+ * live session ("gemini live session closed") rather than a clear message up
+ * front. Degradation, not refusal — a bad key never blocks the launch; the
+ * realtime tier is simply unavailable until it's fixed.
+ *
+ * We record only a status — never the key or any prefix of it — so the
+ * launch-info summary can explain a degraded pipeline without seeing the
+ * secret.
+ */
+import type { OpenAiKeyStatus } from "@habemus-papadum/aiui-claude-channel";
+export interface GeminiPreflightOptions {
+    /**
+     * Perform the authenticated network check. True only for interactive,
+     * non-CI launches. When false the check is skipped silently and a present
+     * key is reported as "unverified", never contacted.
+     */
+    verify?: boolean;
+    /** Injectable for tests; defaults to the process environment. */
+    env?: NodeJS.ProcessEnv;
+    /** Injectable for tests; defaults to global `fetch`. */
+    fetchImpl?: typeof fetch;
+    /** Network budget for the status check (default {@link DEFAULT_TIMEOUT_MS}). */
+    timeoutMs?: number;
+}
+/**
+ * Determine the status of `GEMINI_API_KEY` for this launch. Same contract as
+ * `preflightOpenAiKey`: never throws, never prints, never returns the key.
+ * The key rides the query string (Gemini's auth shape — no bearer header) and
+ * a rejected key answers 400/401/403 depending on how it's malformed, so all
+ * three read as "invalid".
+ */
+export declare function preflightGeminiKey(opts?: GeminiPreflightOptions): Promise<OpenAiKeyStatus>;
+interface PreflightMessage {
+    level: "warn" | "note";
+    title: string;
+    detail: string;
+}
+/**
+ * The user-facing message for a preflight status, or `null` when there's
+ * nothing to say. Unlike the OpenAI twin, a **missing** Gemini key is a quiet
+ * `note`, not a warning: the default transcription tiers don't need it — only
+ * the realtime (Gemini Live) submode does — so its absence degrades one
+ * opt-in tier, not the pipeline's default path.
+ */
+export declare function geminiPreflightMessage(status: OpenAiKeyStatus): PreflightMessage | null;
+/** Print the preflight message for `status` (nothing, for a valid key). */
+export declare function reportGeminiPreflight(status: OpenAiKeyStatus): void;
+export {};

package/dist/util/openai-preflight.d.ts

@@ -14,7 +14,7 @@
  * blocks the launch; the modality still mounts, but transcription/correction are
  * unavailable until the key is set (the widget says so — `mock` is the explicit
  * offline choice, not a silent fallback). The most valuable case this catches is the one that
- * bit the bench twice (see workbench field-notes, "Keys & config"): a **stale
+ * bit the bench twice (archive/workbench/field-notes.md, "Keys & config"): a **stale
  * shell export** shadowing the real key, which surfaces as a confusing 401 deep
  * in the pipeline rather than a clear message up front.
  *

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@habemus-papadum/aiui",
-  "version": "0.3.0",
+  "version": "0.5.0",
   "description": "ai ui frontends",
   "type": "module",
   "license": "MIT",
@@ -25,8 +25,7 @@
     "aiui": "./dist/cli.js"
   },
   "files": [
-    "dist",
-    "templates"
+    "dist"
   ],
   "publishConfig": {
     "access": "public"
@@ -38,12 +37,13 @@
     "commander": "^15.0.0",
     "execa": "^9.6.1",
     "vite": "^6.4.3",
-    "@habemus-papadum/aiui-claude-plugin": "^0.3.0",
-    "@habemus-papadum/aiui-devtools-extension": "^0.3.0",
-    "@habemus-papadum/aiui-dev-overlay": "^0.3.0",
-    "@habemus-papadum/aiui-paint": "^0.3.0",
-    "@habemus-papadum/aiui-claude-channel": "^0.3.0",
-    "@habemus-papadum/aiui-util": "^0.3.0"
+    "@habemus-papadum/aiui-claude-channel": "^0.5.0",
+    "@habemus-papadum/aiui-trace-ui": "^0.5.0",
+    "@habemus-papadum/aiui-claude-plugin": "^0.5.0",
+    "@habemus-papadum/aiui-util": "^0.5.0"
+  },
+  "devDependencies": {
+    "@habemus-papadum/aiui-lowering-pipeline": "^0.5.0"
   },
   "scripts": {
     "build": "tsc --emitDeclarationOnly -p tsconfig.json && vite build",

package/dist/commands/demo.d.ts

@@ -1,28 +0,0 @@
-export interface DemoOptions {
-    /** Scaffold only — skip `npm install` (used by the packaging test/CI). */
-    skipInstall?: boolean;
-}
-/** What `aiui demo` finds at the target path. */
-export type DemoTargetState = "new" | "existing-demo" | "occupied";
-export declare function runDemo(dir: string | undefined, opts?: DemoOptions): Promise<void>;
-/**
- * Decide what to do with the target: `new` (missing or empty), an
- * `existing-demo` (package.json carries the scaffold marker — continue), or
- * `occupied` (anything else — refuse; never clobber unknown content).
- */
-export declare function classifyDemoTarget(target: string): DemoTargetState;
-/**
- * The dependency range the scaffold pins aiui packages to: this build's exact
- * release line when it has one, `latest` from a dev build (whose `0.0.0+dev`
- * doesn't exist on the registry).
- */
-export declare function demoDependencyRange(version: string): string;
-/** Copy the template, restore dot-paths npm strips, and pin dependency ranges. */
-export declare function scaffoldDemo(template: string, target: string): void;
-/**
- * The template directory shipped with this install. Probed upward from this
- * module because the relative depth differs between layouts: `dist/cli.js`
- * (bundled, installed) sits one level below the package root; the tsx-run
- * `src/commands/demo.ts` sits two below.
- */
-export declare function templateRoot(): string | undefined;

package/dist/commands/paint.d.ts

@@ -1,3 +0,0 @@
-export declare function runPaintUrl(opts?: {
-    json?: boolean;
-}): Promise<void>;

package/dist/sidecars-BKlhUA0V.js

@@ -1,48 +0,0 @@
-import { createRequire as c } from "node:module";
-const l = c(import.meta.url), n = [
-  {
-    // The iPad paint stream. Always on: it rides the channel's own port (no
-    // process, no extra listener), so hosting it costs nothing. Whether an
-    // iPad can actually REACH it is the channel bind's decision (`channel.bind`
-    // / `--aiui-bind`, asked at first run) — the security posture lives there,
-    // not here. `--aiui-no-sidecar paint` / `sidecars.paint: false` turn it off.
-    name: "paint",
-    autoEnable: () => !0,
-    descriptor: (a, o) => ({
-      name: "paint",
-      module: o("@habemus-papadum/aiui-paint/sidecar"),
-      export: "paintSidecar",
-      options: { root: a }
-    })
-  }
-];
-function u(a, o, i = {}) {
-  const d = i.resolveModule ?? ((e) => l.resolve(e)), s = i.log ?? ((e) => process.stderr.write(`[aiui] warning: ${e}
-`)), t = /* @__PURE__ */ new Set();
-  for (const e of n)
-    try {
-      e.autoEnable(a) && t.add(e.name);
-    } catch (r) {
-      s(
-        `sidecar "${e.name}" auto-detect failed: ${r instanceof Error ? r.message : String(r)}`
-      );
-    }
-  for (const e of o.enable)
-    n.some((r) => r.name === e) && t.add(e);
-  for (const e of o.disable)
-    t.delete(e);
-  return n.filter((e) => t.has(e.name)).map((e) => {
-    try {
-      return e.descriptor(a, d);
-    } catch (r) {
-      s(
-        `sidecar "${e.name}" disabled — its module failed to resolve: ${r instanceof Error ? r.message : String(r)}`
-      );
-      return;
-    }
-  }).filter((e) => e !== void 0);
-}
-export {
-  u as r
-};
-//# sourceMappingURL=sidecars-BKlhUA0V.js.map

package/dist/sidecars-BKlhUA0V.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"sidecars-BKlhUA0V.js","sources":["../src/util/sidecars.ts"],"sourcesContent":["/**\n * Deciding which **session sidecars** the channel should host for a launch.\n *\n * A sidecar is an extra backend the channel mounts alongside the intent\n * pipeline — the concrete one today is the iPad paint stream. The channel takes\n * no dependency on any sidecar: `aiui claude` hands it a JSON array of\n * {@link SidecarDescriptor}s on `--sidecars`, and the channel dynamic-imports\n * each `module`, calls `mod[export ?? \"default\"](options)`, and mounts the\n * result (a bad descriptor is logged + skipped there).\n *\n * This module is the CLI's half: a small registry of the sidecars the launcher\n * knows how to construct, plus a pure resolver that decides which are on for a\n * given project root and set of `--aiui-sidecar` / `--aiui-no-sidecar` flags.\n */\n\nimport { createRequire } from \"node:module\";\n\nconst nodeRequire = createRequire(import.meta.url);\n\n/**\n * The contract the channel's `--sidecars` argument expects, mirrored here so\n * the CLI can emit it. The channel imports `module`, calls its `export` (or\n * `default`) with `options`, and mounts the returned sidecar.\n */\nexport interface SidecarDescriptor {\n  /** Stable identifier, used for `--aiui-sidecar`/`--aiui-no-sidecar` and logs. */\n  name: string;\n  /** Importable specifier the channel `import()`s (e.g. a package subpath). */\n  module: string;\n  /** Named export to call as the factory. Defaults to `\"default\"`. */\n  export?: string;\n  /** Passed opaquely to the factory (e.g. `{ root: \"/proj\" }`). */\n  options?: unknown;\n}\n\n/** Resolves a package specifier to an absolute path the channel can `import()`. */\ntype ResolveModule = (specifier: string) => string;\n\n/** Injectable seams, so the resolver is unit-testable without on-disk state. */\nexport interface ResolveSidecarsDeps {\n  /**\n   * Resolves a sidecar's package specifier to an ABSOLUTE path. Defaults to\n   * `createRequire(import.meta.url).resolve`. This matters: the channel\n   * dynamic-imports the descriptor's `module`, but it does NOT depend on any\n   * sidecar package — so a bare specifier resolves from the channel's own\n   * node_modules and fails (pnpm's isolated layout). Resolving here (from the\n   * `aiui` CLI, which DOES depend on the sidecar package) to an absolute path\n   * makes the import work in both the source-first workspace and an install.\n   */\n  resolveModule?: ResolveModule;\n  /** Warning sink for a sidecar that had to be dropped (defaults to stderr). */\n  log?: (message: string) => void;\n}\n\n/** A sidecar the CLI knows how to enable and construct, keyed by name. */\ninterface KnownSidecar {\n  name: string;\n  /** Whether this sidecar auto-enables for the given project root. */\n  autoEnable: (root: string) => boolean;\n  /** Build the descriptor the channel will mount for this root. */\n  descriptor: (root: string, resolveModule: ResolveModule) => SidecarDescriptor;\n}\n\n/**\n * The registry of sidecars the launcher can enable. Emit order follows this\n * list, so the resolver's output is stable regardless of flag order. The paint\n * stream is always on — see its entry.\n */\nconst KNOWN_SIDECARS: KnownSidecar[] = [\n  {\n    // The iPad paint stream. Always on: it rides the channel's own port (no\n    // process, no extra listener), so hosting it costs nothing. Whether an\n    // iPad can actually REACH it is the channel bind's decision (`channel.bind`\n    // / `--aiui-bind`, asked at first run) — the security posture lives there,\n    // not here. `--aiui-no-sidecar paint` / `sidecars.paint: false` turn it off.\n    name: \"paint\",\n    autoEnable: () => true,\n    descriptor: (root, resolveModule) => ({\n      name: \"paint\",\n      module: resolveModule(\"@habemus-papadum/aiui-paint/sidecar\"),\n      export: \"paintSidecar\",\n      options: { root },\n    }),\n  },\n];\n\n/**\n * Decide which session sidecars to host for `root`.\n *\n * Starts from the auto-detected set (each known sidecar whose `autoEnable`\n * predicate is truthy for this root), then applies the flags: `opts.enable`\n * force-adds a known sidecar by name even when it wouldn't auto-detect, and\n * `opts.disable` removes one. Disable wins over enable. Enable names the CLI\n * doesn't know how to construct are ignored (the launcher can only build the\n * sidecars in {@link KNOWN_SIDECARS}). Descriptors come back in the registry's\n * stable order.\n */\nexport function resolveSidecars(\n  root: string,\n  opts: { enable: string[]; disable: string[] },\n  deps: ResolveSidecarsDeps = {},\n): SidecarDescriptor[] {\n  const resolveModule =\n    deps.resolveModule ?? ((specifier: string) => nodeRequire.resolve(specifier));\n  const log =\n    deps.log ?? ((message: string) => process.stderr.write(`[aiui] warning: ${message}\\n`));\n  const enabled = new Set<string>();\n\n  // Auto-detected sidecars. A throwing detector must not kill the launch —\n  // warn and treat as not detected.\n  for (const known of KNOWN_SIDECARS) {\n    try {\n      if (known.autoEnable(root)) {\n        enabled.add(known.name);\n      }\n    } catch (err) {\n      log(\n        `sidecar \"${known.name}\" auto-detect failed: ${\n          err instanceof Error ? err.message : String(err)\n        }`,\n      );\n    }\n  }\n  // Force-enable, but only sidecars the CLI knows how to construct.\n  for (const name of opts.enable) {\n    if (KNOWN_SIDECARS.some((k) => k.name === name)) {\n      enabled.add(name);\n    }\n  }\n  // Disable wins over enable.\n  for (const name of opts.disable) {\n    enabled.delete(name);\n  }\n\n  return KNOWN_SIDECARS.filter((k) => enabled.has(k.name))\n    .map((k) => {\n      try {\n        return k.descriptor(root, resolveModule);\n      } catch (err) {\n        // The sidecar's package isn't resolvable (e.g. not installed) — skip it\n        // rather than failing the whole launch, but say so: silently dropping it\n        // would surface as \"the sidecar is mysteriously absent\".\n        log(\n          `sidecar \"${k.name}\" disabled — its module failed to resolve: ${\n            err instanceof Error ? err.message : String(err)\n          }`,\n        );\n        return undefined;\n      }\n    })\n    .filter((d): d is SidecarDescriptor => d !== undefined);\n}\n"],"names":["nodeRequire","createRequire","KNOWN_SIDECARS","root","resolveModule","resolveSidecars","opts","deps","specifier","log","message","enabled","known","err","name","k","d"],"mappings":";AAiBA,MAAMA,IAAcC,EAAc,YAAY,GAAG,GAmD3CC,IAAiC;AAAA,EACrC;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,IAME,MAAM;AAAA,IACN,YAAY,MAAM;AAAA,IAClB,YAAY,CAACC,GAAMC,OAAmB;AAAA,MACpC,MAAM;AAAA,MACN,QAAQA,EAAc,qCAAqC;AAAA,MAC3D,QAAQ;AAAA,MACR,SAAS,EAAE,MAAAD,EAAA;AAAA,IAAK;AAAA,EAClB;AAEJ;AAaO,SAASE,EACdF,GACAG,GACAC,IAA4B,CAAA,GACP;AACrB,QAAMH,IACJG,EAAK,kBAAkB,CAACC,MAAsBR,EAAY,QAAQQ,CAAS,IACvEC,IACJF,EAAK,QAAQ,CAACG,MAAoB,QAAQ,OAAO,MAAM,mBAAmBA,CAAO;AAAA,CAAI,IACjFC,wBAAc,IAAA;AAIpB,aAAWC,KAASV;AAClB,QAAI;AACF,MAAIU,EAAM,WAAWT,CAAI,KACvBQ,EAAQ,IAAIC,EAAM,IAAI;AAAA,IAE1B,SAASC,GAAK;AACZ,MAAAJ;AAAA,QACE,YAAYG,EAAM,IAAI,yBACpBC,aAAe,QAAQA,EAAI,UAAU,OAAOA,CAAG,CACjD;AAAA,MAAA;AAAA,IAEJ;AAGF,aAAWC,KAAQR,EAAK;AACtB,IAAIJ,EAAe,KAAK,CAACa,MAAMA,EAAE,SAASD,CAAI,KAC5CH,EAAQ,IAAIG,CAAI;AAIpB,aAAWA,KAAQR,EAAK;AACtB,IAAAK,EAAQ,OAAOG,CAAI;AAGrB,SAAOZ,EAAe,OAAO,CAACa,MAAMJ,EAAQ,IAAII,EAAE,IAAI,CAAC,EACpD,IAAI,CAACA,MAAM;AACV,QAAI;AACF,aAAOA,EAAE,WAAWZ,GAAMC,CAAa;AAAA,IACzC,SAASS,GAAK;AAIZ,MAAAJ;AAAA,QACE,YAAYM,EAAE,IAAI,8CAChBF,aAAe,QAAQA,EAAI,UAAU,OAAOA,CAAG,CACjD;AAAA,MAAA;AAEF;AAAA,IACF;AAAA,EACF,CAAC,EACA,OAAO,CAACG,MAA8BA,MAAM,MAAS;AAC1D;"}

package/dist/util/sidecars.d.ts

@@ -1,62 +0,0 @@
-/**
- * Deciding which **session sidecars** the channel should host for a launch.
- *
- * A sidecar is an extra backend the channel mounts alongside the intent
- * pipeline — the concrete one today is the iPad paint stream. The channel takes
- * no dependency on any sidecar: `aiui claude` hands it a JSON array of
- * {@link SidecarDescriptor}s on `--sidecars`, and the channel dynamic-imports
- * each `module`, calls `mod[export ?? "default"](options)`, and mounts the
- * result (a bad descriptor is logged + skipped there).
- *
- * This module is the CLI's half: a small registry of the sidecars the launcher
- * knows how to construct, plus a pure resolver that decides which are on for a
- * given project root and set of `--aiui-sidecar` / `--aiui-no-sidecar` flags.
- */
-/**
- * The contract the channel's `--sidecars` argument expects, mirrored here so
- * the CLI can emit it. The channel imports `module`, calls its `export` (or
- * `default`) with `options`, and mounts the returned sidecar.
- */
-export interface SidecarDescriptor {
-    /** Stable identifier, used for `--aiui-sidecar`/`--aiui-no-sidecar` and logs. */
-    name: string;
-    /** Importable specifier the channel `import()`s (e.g. a package subpath). */
-    module: string;
-    /** Named export to call as the factory. Defaults to `"default"`. */
-    export?: string;
-    /** Passed opaquely to the factory (e.g. `{ root: "/proj" }`). */
-    options?: unknown;
-}
-/** Resolves a package specifier to an absolute path the channel can `import()`. */
-type ResolveModule = (specifier: string) => string;
-/** Injectable seams, so the resolver is unit-testable without on-disk state. */
-export interface ResolveSidecarsDeps {
-    /**
-     * Resolves a sidecar's package specifier to an ABSOLUTE path. Defaults to
-     * `createRequire(import.meta.url).resolve`. This matters: the channel
-     * dynamic-imports the descriptor's `module`, but it does NOT depend on any
-     * sidecar package — so a bare specifier resolves from the channel's own
-     * node_modules and fails (pnpm's isolated layout). Resolving here (from the
-     * `aiui` CLI, which DOES depend on the sidecar package) to an absolute path
-     * makes the import work in both the source-first workspace and an install.
-     */
-    resolveModule?: ResolveModule;
-    /** Warning sink for a sidecar that had to be dropped (defaults to stderr). */
-    log?: (message: string) => void;
-}
-/**
- * Decide which session sidecars to host for `root`.
- *
- * Starts from the auto-detected set (each known sidecar whose `autoEnable`
- * predicate is truthy for this root), then applies the flags: `opts.enable`
- * force-adds a known sidecar by name even when it wouldn't auto-detect, and
- * `opts.disable` removes one. Disable wins over enable. Enable names the CLI
- * doesn't know how to construct are ignored (the launcher can only build the
- * sidecars in {@link KNOWN_SIDECARS}). Descriptors come back in the registry's
- * stable order.
- */
-export declare function resolveSidecars(root: string, opts: {
-    enable: string[];
-    disable: string[];
-}, deps?: ResolveSidecarsDeps): SidecarDescriptor[];
-export {};

package/templates/demo/CLAUDE.md

@@ -1,16 +0,0 @@
-# aiui demo playground
-
-This directory is a scaffolded, disposable aiui demo — a sandbox the user is exploring the aiui
-workflow in. Ground rules for working here:
-
-- **The app is scenery.** `src/main.ts` renders a fake "spectra" viewer purely so there's
-  something to point at and modify. Redesign it, extend it, replace it — that's the point of the
-  demo. Prefer small, visible changes the user can watch land.
-- **Don't remove the integration.** The `aiuiDevOverlay()` plugin in `vite.config.ts` is what
-  mounts the intent tool and connects it to this session's channel. The demo stops working
-  without it.
-- The dev server runs via `npm run dev` (which is `aiui vite dev` — it injects the channel port
-  as `VITE_AIUI_PORT`). Plain `vite` also serves the app, but the intent tool won't find the
-  channel.
-- This is a standalone git repo scaffolded by `aiui demo`; commit freely — history here belongs
-  to the user's sandbox and goes nowhere else.

package/templates/demo/README.md

@@ -1,36 +0,0 @@
-# aiui demo playground
-
-A disposable sandbox for trying [aiui](https://habemus-papadum.github.io/pdum_aiui/): a Claude
-Code session with a custom channel, a shared agent+human browser, and a web intent tool floating
-over a demo app. It's a local git repo of its own — let the agent redesign, break, and rebuild
-the app; nothing flows back anywhere.
-
-> ⚠️ First read *Read before running* in the aiui docs: `aiui claude` can skip permissions and
-> gives the agent a browser. This sandbox assumes you've decided to trust it.
-
-## Run it
-
-```sh
-npm run claude   # terminal 1 — Claude Code with the aiui channel + session browser
-npm run dev      # terminal 2 — the demo app (Vite + the intent tool overlay)
-```
-
-Then open the app **in the session browser** (the window you share with the agent):
-
-```sh
-npx aiui open http://localhost:5173
-```
-
-Click the floating **✳ aiui** button, type an intent — *"make the baseline curve red"* — and
-watch it land in the Claude session as a prompt. The 🔍 button shows how your input was lowered
-into that prompt.
-
-## What's what
-
-- `vite.config.ts` — the **entire** aiui integration: one `aiuiDevOverlay()` plugin. This is the
-  part you'd copy into your own app.
-- `src/main.ts` — throwaway scenery (a fake spectrum viewer). No aiui code in it.
-- Re-running the scaffold command in this directory just picks up where you left off — it never
-  overwrites your (or the agent's) changes.
-
-Docs: <https://habemus-papadum.github.io/pdum_aiui/guide/getting-started>

package/templates/demo/gitignore

@@ -1,4 +0,0 @@
-node_modules/
-dist/
-.aiui-cache/
-*.log

package/templates/demo/index.html

@@ -1,11 +0,0 @@
-<!doctype html>
-<html lang="en">
-  <head>
-    <meta charset="utf-8" />
-    <meta name="viewport" content="width=device-width, initial-scale=1" />
-    <title>spectra — aiui demo playground</title>
-  </head>
-  <body>
-    <script type="module" src="/src/main.ts"></script>
-  </body>
-</html>

package/templates/demo/package.json

@@ -1,23 +0,0 @@
-{
-  "name": "aiui-demo-playground",
-  "private": true,
-  "type": "module",
-  "aiui": {
-    "demo": true
-  },
-  "scripts": {
-    "claude": "aiui claude",
-    "dev": "aiui vite dev",
-    "open": "aiui open"
-  },
-  "dependencies": {
-    "@habemus-papadum/aiui-dev-overlay": "__AIUI_VERSION_RANGE__"
-  },
-  "devDependencies": {
-    "@babel/core": "^7.29.7",
-    "@habemus-papadum/aiui": "__AIUI_VERSION_RANGE__",
-    "typescript": "^5.6.0",
-    "typescript-language-server": "^5.3.0",
-    "vite": "^6.4.1"
-  }
-}