@aussieljk/forkbook 0.0.0-stage → 0.0.1-2

package/dist/cli/skills/content/index.d.ts

@@ -0,0 +1,72 @@
+import { i as ToolsetCtx } from "../../../chunk-BCoJQE-f.js";
+
+//#region .dts-emit/code/core/src/cli/skills/content/skills.d.ts
+/**
+ * The Forkbook skills: agent-facing instruction documents served by `forkbook skills <id>`
+ * and, on the MCP side, by addon-mcp (server instructions and the story-instructions tool). The
+ * ids are public CLI vocabulary — plugin stubs (M7) will reference them — so treat renames as
+ * breaking.
+ */
+declare const SKILL_IDS: readonly ['stories', 'write-story', 'setup'];
+type SkillId = (typeof SKILL_IDS)[number];
+declare const SKILLS: Record<SkillId, {
+  blurb: string;
+}>;
+declare function isSkillId(value: string): value is SkillId;
+//#endregion
+//#region .dts-emit/code/core/src/cli/skills/content/skill-refs.d.ts
+type SkillTransport = ToolsetCtx['transport'];
+/**
+ * Renders a cross-reference to a skill in the transport's own vocabulary, mirroring `getToolName` for
+ * toolset methods: the MCP tool name where one exists, the `forkbook skills` command otherwise.
+ */
+declare function getSkillRef(transport: SkillTransport): (id: SkillId) => string;
+//#endregion
+//#region .dts-emit/code/core/src/cli/skills/content/build-server-instructions.d.ts
+type ServerInstructionsInputs = {
+  transport: SkillTransport;
+  devEnabled: boolean;
+  testSupported: boolean;
+  docsEnabled: boolean; /** `stories-find-by-component` is registered, so the workflow can point at it. */
+  moduleGraphSupported: boolean;
+};
+/**
+ * The full rule for how the agent should present links in its final
+ * user-facing response, delivered through the
+ * `get-storybook-story-instructions` output. The server instructions only
+ * carry a terse pointer to the same rule: MCP clients truncate server
+ * instructions (Claude Code cuts them at 2,048 chars), so anything beyond
+ * the workflow trigger must live in tool descriptions and tool results.
+ *
+ * The guidance covers both paths: ending with a review section after
+ * publishing, or falling back to preview URLs when no review was published
+ * (e.g. non-visual refactors).
+ */
+declare function getFinalLinksGuidance(transport: SkillTransport): string;
+declare function buildServerInstructions({
+  transport,
+  ...options
+}: ServerInstructionsInputs): string;
+//#endregion
+//#region .dts-emit/code/core/src/cli/skills/content/build-story-instructions.d.ts
+type StoryInstructionsInputs = {
+  transport: SkillTransport;
+  framework: string; /** Renderer package name; defaults to `framework` when unmapped (today's behavior). */
+  renderer?: string;
+  testSupported: boolean;
+  a11yEnabled: boolean;
+  docsEnabled: boolean;
+};
+declare function buildStoryInstructions({
+  transport,
+  framework,
+  renderer,
+  testSupported,
+  a11yEnabled,
+  docsEnabled
+}: StoryInstructionsInputs): string;
+//#endregion
+//#region .dts-emit/code/core/src/cli/skills/content/framework-renderer.d.ts
+declare const frameworkToRendererMap: Record<string, string>;
+//#endregion
+export { SKILLS, SKILL_IDS, type ServerInstructionsInputs, type SkillId, type SkillTransport, type StoryInstructionsInputs, buildServerInstructions, buildStoryInstructions, frameworkToRendererMap, getFinalLinksGuidance, getSkillRef, isSkillId };

package/dist/cli/skills/content/index.js

@@ -0,0 +1,335 @@
+import {
+  getToolName
+} from "../../../_browser-chunks/chunk-LEVSOOLQ.js";
+import "../../../_browser-chunks/chunk-IE4ULIOQ.js";
+import "../../../_browser-chunks/chunk-IMSF75WX.js";
+
+// src/cli/skills/content/skills.ts
+var SKILL_IDS = ["stories", "write-story", "setup"], SKILLS = {
+  stories: {
+    blurb: "The workflow for UI changes, with every command it needs: look up components, write stories, test, and publish a review."
+  },
+  "write-story": {
+    blurb: "How to write, update, and test Forkbook stories for this project: imports, patterns, and conventions."
+  },
+  setup: {
+    blurb: "Setup instructions to write stories for the real components in this project."
+  }
+};
+function isSkillId(value) {
+  return SKILL_IDS.includes(value);
+}
+
+// src/cli/skills/content/skill-refs.ts
+var MCP_SKILL_TOOL_NAMES = {
+  "write-story": "get-storybook-story-instructions"
+};
+function getSkillRef(transport) {
+  return (id) => transport === "mcp" && MCP_SKILL_TOOL_NAMES[id] || `npx forkbook skills ${id}`;
+}
+
+// src/cli/skills/content/instructions/dev-instructions.md
+var dev_instructions_default = `## UI Building and Story Writing Workflow
+
+- {{STORY_INSTRUCTIONS_STEP}}
+- {{PREVIEW_STORIES_STEP}}
+- {{FINAL_LINKS_STEP}}{{DISPLAY_REVIEW_STEP}}
+- Only use story IDs returned by tools \u2014 never derive them from file names or memory.{{FIND_BY_COMPONENT_STEP}}
+`;
+
+// src/cli/skills/content/instructions/docs-instructions.md
+var docs_instructions_default = `## Documentation Workflow
+
+**CRITICAL: Never hallucinate component properties!** Undocumented props do not exist \u2014 never assume them from naming or other libraries; verify every prop via these tools, not source or types in node_modules.
+
+1. Call **{{DOCS_LIST}}** once at task start for component and docs IDs.
+2. Call **{{DOCS_SHOW}}** with an \`id\` from that list for props and usage examples.
+
+Only reference IDs returned by these tools \u2014 never guess; scope multi-source requests with \`storybookId\`.
+`;
+
+// src/cli/skills/content/instructions/test-instructions.md
+var test_instructions_default = `## Validation Workflow
+
+- After editing anything that changes how the UI looks, run **{{RUN_STORY_TESTS}}** \u2014 never a package.json test script.
+- Never report completion while story tests are failing.
+`;
+
+// src/cli/skills/content/build-server-instructions.ts
+function getFinalLinksGuidance(transport) {
+  let ref = getToolName({ transport });
+  return `In your final user-facing response, show one set of links \u2014 never both. If you published a review with **${ref("review.create")}**, finish your reply with a dedicated review section as the very last thing in the output: its own top-level heading on a line by itself (for example \`## \u{1F440} Review your changes\`), then a one-line explanation that the review shows the handful of stories most relevant to this change and that, because it is AI-curated, results may be inaccurate or incomplete, then on the next line the review page as a markdown link prefixed with a \u{1F449} so it is easy to spot, using the returned \`reviewUrl\` (for example \`\u{1F449} [Open the Forkbook review page](<reviewUrl>)\`). Nothing should come after this section. Never also list the individual story or preview URLs. Avoid internal jargon like "collection" or "trigger" in anything the user reads \u2014 those are terms from this tooling, not words that mean anything to them; use plain language unless the user used the term first. A visually observable change is not finished until its review is published \u2014 never substitute preview URLs for the review. If **${ref("review.create")}** keeps failing, end with the **${ref("stories.preview")}** URLs instead and say the review could not be published. Only when there is no review because the change has no visually observable impact, say so plainly; include preview URLs only if the user asked to see specific stories.`;
+}
+function buildServerInstructions({
+  transport,
+  ...options
+}) {
+  let ref = getToolName({ transport }), skillRef = getSkillRef(transport), sections = [
+    options.docsEnabled ? "Follow these workflows when working with UI and/or Forkbook. Answer questions about component props, API, or usage with the documentation tools \u2014 never from source or type definitions." : "Follow these workflows when working with UI and/or Forkbook."
+  ];
+  if (options.devEnabled) {
+    let previewStoriesStep = `After editing anything that changes how the UI looks \u2014 components, stories, styles, themes, tokens \u2014 call **${ref("stories.changed")}** to discover the affected stories.`, finalLinksStep = `End your final response with the review section from **${ref("review.create")}**'s result \u2014 never substitute preview URLs. **${ref("stories.preview")}** is only for mid-loop iteration or a requested direct link. If nothing visually changed, say so.`;
+    sections.push(
+      dev_instructions_default.replace(
+        "{{STORY_INSTRUCTIONS_STEP}}",
+        `Before creating or editing components or stories, call **${skillRef("write-story")}**; its output is the source of truth for imports, story patterns, and testing conventions.`
+      ).replace("{{PREVIEW_STORIES_STEP}}", previewStoriesStep).replace("{{FINAL_LINKS_STEP}}", finalLinksStep).replace(
+        "{{DISPLAY_REVIEW_STEP}}",
+        `
+- After a visually observable UI change, or when the user asks to see or browse stories/components, call **${ref("review.create")}** (again on each iteration) and follow its description and result. Visual work is not done until the review is published; any newly created story MUST be included.`
+      ).replace(
+        "{{FIND_BY_COMPONENT_STEP}}",
+        options.moduleGraphSupported ? ` **${ref("stories.findByComponent")}** maps any input to stories; its description covers the workflow. No matches means no stories exist yet \u2014 say so.` : ""
+      ).trim()
+    );
+  }
+  return options.testSupported && sections.push(test_instructions_default.replaceAll("{{RUN_STORY_TESTS}}", ref("test.run")).trim()), options.docsEnabled && sections.push(
+    docs_instructions_default.replaceAll("{{DOCS_LIST}}", ref("docs.list")).replaceAll("{{DOCS_SHOW}}", ref("docs.show")).trim()
+  ), sections.length === 1 ? "" : sections.join(`
+
+`);
+}
+
+// src/cli/skills/content/framework-renderer.ts
+var frameworkToRendererMap = {
+  "@aussieljk/forkbook/react-vite": "@aussieljk/forkbook/react",
+  "@aussieljk/forkbook/nextjs-vite": "@aussieljk/forkbook/react"
+};
+
+// src/cli/skills/content/instructions/a11y-instructions.md
+var a11y_instructions_default = `### Accessibility Violations
+
+**Fix automatically** (semantic/structural, no visual change):
+
+- ARIA attributes, roles, labels, alt text
+- Heading hierarchy, landmarks, table structure
+- Keyboard access (tabindex, focus, handlers)
+- Document-level: lang attr, frame titles, duplicate IDs
+
+**Confirm with user first** (visual/design changes):
+
+- Color contrast ratios
+- Font sizes, spacing, layout
+- Focus indicator styling
+
+Describe the issue, ask how the user wants to proceed, and provide 2-3 concrete options.
+Do not auto-apply visual changes before user confirmation, and do not claim visual issues are fixed until they approve an option.
+`;
+
+// src/cli/skills/content/instructions/story-testing-instructions.md
+var story_testing_instructions_default = `## Story Testing Requirements
+
+**Run \`{{RUN_STORY_TESTS_TOOL_NAME}}\` after EVERY component or story change.** This includes creating, modifying, or refactoring components, stories, or their dependencies. It is the only way to run story tests \u2014 never run package.json test scripts (like \`npm run test:stories\`) instead.
+
+### Workflow
+
+1. Make your change
+2. Run \`{{RUN_STORY_TESTS_TOOL_NAME}}\` with related stories for focused feedback (faster while iterating)
+3. If tests fail: analyze, fix{{A11Y_FIX_SUFFIX}}, re-run
+4. Repeat until all tests pass
+
+Do not skip tests, ignore failures, or move on with failing tests. If stuck after multiple attempts, report to user.
+
+### Focused vs. full-suite test runs
+
+- Prefer focused runs (\`stories\` input) during development to validate the parts you changed quickly.
+- Run all tests (omit \`stories\`) before final handoff, after broad/refactor changes, or when impact is unclear and you need project-wide verification.
+`;
+
+// src/cli/skills/content/instructions/storybook-story-instructions.md
+var storybook_story_instructions_default = `# Writing User Interfaces
+
+Use the configured framework (\`{{FRAMEWORK}}\`) and renderer (\`{{RENDERER}}\`). Follow the project\u2019s component syntax, story format, imports, and setup conventions. Use examples for this framework when consulting documentation.
+
+When writing UI, prefer breaking larger components up into smaller parts.
+
+ALWAYS write a Forkbook story for any component written. If editing a component, ensure appropriate changes have been made to stories for that component.
+{{DOCS_WORKFLOW_GUIDANCE}}
+
+## How to write good stories
+
+Goal: Cover every distinct piece of business logic and state the component can reach (happy paths, error/edge states, loading, permissions/roles, empty states, variations from props/context). Avoid redundant stories that show the same logic.
+
+Interactivity: If the component is interactive, add Interaction tests using play functions that drive the UI with @aussieljk/forkbook/test utilities (e.g., fn, userEvent, expect). Simulate key user flows: clicking buttons/links, typing, focus/blur, keyboard nav, form submit, async responses, toggle/selection changes, pagination/filters, etc. When passing \`fn\` functions as \`args\` for callback functions, make sure to add a play function which interacts with the component and assert whether the callback function was actually called.
+
+Data/setup: Provide realistic props, state, and mocked data. Include meaningful labels/text to make behaviors observable. Stub network/services with deterministic fixtures; keep stories reliable.
+
+Assertions: In play functions, assert the visible outcome of the interaction (text, aria state, enabled/disabled, class/state changes, emitted events). Prefer role/label-based queries.
+
+Variants to consider (pick only those that change behavior): default vs. alternate themes; loading vs. loaded vs. empty vs. error; validated vs. invalid input; permissions/roles/capabilities; feature flags; size/density/layout variants that alter logic.
+
+Accessibility: Use semantic roles/labels; ensure focusable/keyboard interactions are test-covered where relevant.
+
+Naming/structure: Use clear story names that describe the scenario (\u201CError state after failed submit\u201D). Group related variants logically; don\u2019t duplicate.
+
+Imports/format: Import Meta/StoryObj from the framework package; import test helpers from @aussieljk/forkbook/test (not @storybook/test). Keep stories minimal\u2014only what's needed to demonstrate behavior.
+
+## Forkbook 9 Essential Changes for Story Writing
+
+### Package Consolidation
+
+#### \`Meta\` and \`StoryObj\` imports
+
+Update story imports to use the framework package:
+
+\`\`\`diff
+- import { Meta, StoryObj } from '{{RENDERER}}';
++ import { Meta, StoryObj } from '{{FRAMEWORK}}';
+\`\`\`
+
+#### Test utility imports
+
+Update test imports to use \`@aussieljk/forkbook/test\` instead of \`@storybook/test\`
+
+\`\`\`diff
+- import { fn } from '@storybook/test';
++ import { fn } from '@aussieljk/forkbook/test';
+\`\`\`
+
+### Global State Changes
+
+The \`globals\` annotation has be renamed to \`initialGlobals\`:
+
+\`\`\`diff
+// .forkbook/preview.js
+export default {
+- globals: { theme: 'light' }
++ initialGlobals: { theme: 'light' }
+};
+\`\`\`
+
+### Autodocs Configuration
+
+Instead of \`parameters.docs.autodocs\` in main.js, use tags:
+
+\`\`\`js
+// .forkbook/preview.js or in individual stories
+export default {
+	tags: ['autodocs'], // generates autodocs for all stories
+};
+\`\`\`
+
+### Mocking imports in Forkbook
+
+To mock imports in Forkbook, use Forkbook's mocking features. ALWAYS mock external dependencies to ensure stories render consistently.
+
+1. **Register in the mock in Forkbook's preview file**:
+   To mock dependendencies, you MUST register a module mock in \`.forkbook/preview.ts\` (or equivalent):
+
+\`\`\`js
+import { sb } from '@aussieljk/forkbook/test';
+
+// Prefer spy mocks (keeps functions, but allows to override them and spy on them)
+sb.mock(import('some-library'), { spy: true });
+\`\`\`
+
+**Important: Use file extensions when referring to relative files!**
+
+\`\`\`js
+sb.mock(import('./relative/module.ts'), { spy: true });
+\`\`\`
+
+2. **Specify mock values in stories**:
+   You can override the behaviour of the mocks per-story using \`beforeEach\` and the \`mocked()\` type function:
+
+\`\`\`js
+import { expect, mocked, fn } from '@aussieljk/forkbook/test';
+import { library } from 'some-library';
+
+const meta = {
+  component: AuthButton,
+  beforeEach: async () => {
+    mocked(library).mockResolvedValue({  user: 'data' });
+  },
+};
+
+export const LoggedIn: Story = {
+  play: async ({ canvas }) => {
+    await expect(library).toHaveBeenCalled();
+  },
+};
+\`\`\`
+
+Before doing this ensure you have mocked the import in the preview file.
+
+### Play Function Parameters
+
+- The play function has a \`canvas\` parameter that can be used directly with testing-library-like query methods.
+- It also has a \`canvasElement\` which is the actual DOM element.
+- The \`within\`-function imported from \`@aussieljk/forkbook/test\` transforms a DOM element to an object with query methods, similar to \`canvas\`.
+
+**DO NOT** use \`within(canvas)\` - it is redundant because \`canvas\` already has the query methods, \`canvas\` is not a DOM element.
+
+\`\`\`ts
+// \u2705 Correct: Use canvas directly
+play: async ({ canvas }) => {
+	await canvas.getByLabelText('Submit').click();
+};
+
+// \u26A0\uFE0F Also acceptable: Use \`canvasElement\` with \`within\`
+import { within } from '@aussieljk/forkbook/test';
+
+play: async ({ canvasElement }) => {
+	const canvas = within(canvasElement);
+	await canvas.getByLabelText('Submit').click();
+};
+
+// \u274C Wrong: Do NOT use within(canvas)
+play: async ({ canvas }) => {
+	const screen = within(canvas); // Error!
+};
+\`\`\`
+
+### Key Requirements
+
+- **Node.js 22.12+**
+- For TypeScript projects, use a version supported by the configured Forkbook framework and application framework.
+{{RENDERER_REQUIREMENTS}}
+
+## Story Linking Agent Behavior
+
+- ALWAYS provide story links after any changes to stories files, including changes to existing stories.
+- {{STORY_LINKING_WORKFLOW}}
+- {{FINAL_LINKS_GUIDANCE}}
+- When you will share preview/story links (i.e. when you are not collapsing everything into a single review section), pass only the most relevant story IDs into **{{PREVIEW_STORIES}}** (generally no more than 5) so the returned URL list stays manageable. Include every URL returned by that call in your final response \u2014 do not drop links there.
+- {{CHANGED_STORY_FALLBACK_LINK_GUIDANCE}}
+- After changing any UI components, ALWAYS search for related stories that might cover the changes you've made. If you find any, provide the story links to the user. THIS IS VERY IMPORTANT, as it allows the user to visually inspect the changes you've made. Even later in a session when changing UI components or stories that have already been linked to previously, YOU MUST PROVIDE THE LINKS AGAIN.
+`;
+
+// src/cli/skills/content/build-story-instructions.ts
+function buildStoryInstructions({
+  transport,
+  framework,
+  renderer,
+  testSupported,
+  a11yEnabled,
+  docsEnabled
+}) {
+  let ref = getToolName({ transport }), resolvedRenderer = renderer ?? frameworkToRendererMap[framework] ?? framework, storyLinkingWorkflow = `After changing any component or story, call \`${ref("stories.changed")}\` to discover the new, modified, and related stories affected by your change. Story IDs must come from that call (or a fallback discovery tool such as ${ref("stories.findByComponent")} for shared-infrastructure changes) \u2014 never construct them from file names, export names, or memory. Feed the discovered IDs into **${ref("review.create")}** when the change is visually observable; use \`${ref("stories.preview")}\` only while iterating on a specific story.`, changedStoryFallbackLinkGuidance = `When sharing preview/story links (not when ending with a review section): if you did not pass every changed story into \`${ref("stories.preview")}\`, include this Forkbook fallback link so the user can view the complete changed list: \`/?statuses=affected;modified;new\`.`, docsWorkflowGuidance = `
+
+## Using library components
+
+This Forkbook exposes component documentation tools. Before creating or changing any UI, call **${ref("docs.list")}** once to see what the design system already provides \u2014 build on existing components instead of hand-rolling duplicates \u2014 then call **${ref("docs.show")}** with the \`id\` of each component you build on or get asked about, for its real props and usage examples. When multiple Forkbook sources are configured, pass the \`storybookId\` from **${ref("docs.list")}** on follow-up calls. Do this instead of reading the library's source or type definitions out of \`node_modules\` \u2014 stories show intended usage, raw types don't \u2014 and answer props/usage questions from these tools too. Never assume or invent props.`, uiInstructions = storybook_story_instructions_default.replaceAll("{{FRAMEWORK}}", framework).replaceAll("{{RENDERER}}", resolvedRenderer).replace(
+    "{{RENDERER_REQUIREMENTS}}",
+    resolvedRenderer === "@storybook/react-native" ? "- React Native uses `.rnstorybook` directory" : ""
+  ).replace(`
+{{DOCS_WORKFLOW_GUIDANCE}}`, docsEnabled ? docsWorkflowGuidance : "").replace("{{STORY_LINKING_WORKFLOW}}", storyLinkingWorkflow).replace("{{FINAL_LINKS_GUIDANCE}}", getFinalLinksGuidance(transport)).replace("{{PREVIEW_STORIES}}", ref("stories.preview")).replace("{{CHANGED_STORY_FALLBACK_LINK_GUIDANCE}}", changedStoryFallbackLinkGuidance);
+  if (testSupported) {
+    let a11yFixSuffix = a11yEnabled ? " (see a11y guidelines below)" : "", storyTestingInstructions = story_testing_instructions_default.replaceAll("{{RUN_STORY_TESTS_TOOL_NAME}}", ref("test.run")).replace("{{A11Y_FIX_SUFFIX}}", a11yFixSuffix);
+    uiInstructions += `
+
+${storyTestingInstructions}`, a11yEnabled && (uiInstructions += `
+${a11y_instructions_default}`);
+  }
+  return uiInstructions;
+}
+export {
+  SKILLS,
+  SKILL_IDS,
+  buildServerInstructions,
+  buildStoryInstructions,
+  frameworkToRendererMap,
+  getFinalLinksGuidance,
+  getSkillRef,
+  isSkillId
+};

package/dist/cli/tools/sdk/child-host.d.ts

@@ -0,0 +1,61 @@
+import { d as ToolsStorybookInfo, o as ToolsClientInfo } from "../../../chunk-DEVFdzxR.js";
+
+//#region .dts-emit/code/core/src/shared/open-service/service-error-serialization.d.ts
+/**
+ * Error (de)serialization for remote command execution.
+ *
+ * A command invoked from a runtime that has no local handler runs on a peer; when it throws, the
+ * thrown value has to cross the channel and be rethrown on the requester. `Error` instances are not
+ * structured-cloneable in a way that survives a websocket (JSON) or postMessage transport with their
+ * `name`, `stack`, `cause`, and Forkbook-specific fields (`code`, `fromStorybook`, …) intact, so we
+ * convert to and from a plain, transport-safe shape here.
+ *
+ * The conversion is recursive: an error's `cause` (and any nested arrays/objects, e.g. the
+ * `cause.aggregated` array used by the `.loaded()` drain) is walked so a multi-cause failure arrives
+ * on the requester with its chain reconstructed rather than flattened to a single message.
+ */
+/** Marks a serialized object as a reconstructable `Error` rather than a plain payload object. */
+declare const ERROR_MARKER: '__openServiceError__';
+/** Transport-safe representation of a thrown `Error`, including its recursive `cause` chain. */
+interface SerializedError {
+  [ERROR_MARKER]: true;
+  name: string;
+  message: string;
+  stack?: string;
+  /** The error's `cause`, itself serialized (another error, a plain object, an array, …). */
+  cause?: unknown;
+  /** Extra own enumerable fields (e.g. Forkbook's `code`, `fromStorybook`), serialized. */
+  properties?: Record<string, unknown>;
+}
+//#endregion
+//#region .dts-emit/code/core/src/cli/tools/sdk/child-protocol.d.ts
+type ChildHelloMessage = {
+  type: 'hello';
+  version: number;
+  storybook: ToolsStorybookInfo;
+  clientInfo: Required<ToolsClientInfo>;
+};
+type ChildResultMessage = {
+  type: 'result';
+  id: string;
+  value: unknown;
+};
+type ChildErrorMessage = {
+  type: 'error';
+  id: string;
+  error: SerializedError;
+};
+type ChildMessage = ChildHelloMessage | ChildResultMessage | ChildErrorMessage;
+//#endregion
+//#region .dts-emit/code/core/src/cli/tools/sdk/child-host.d.ts
+declare function runChildHost({
+  send,
+  subscribe,
+  cwd
+}?: {
+  send?: (message: ChildMessage) => void;
+  subscribe?: (handler: (message: unknown) => void) => void;
+  cwd?: () => string;
+}): Promise<void>;
+//#endregion
+export { runChildHost };

package/dist/cli/tools/sdk/child-host.js

@@ -0,0 +1,131 @@
+import CJS_COMPAT_NODE_URL_ro17f80mg6k from 'node:url';
+import CJS_COMPAT_NODE_PATH_ro17f80mg6k from 'node:path';
+import CJS_COMPAT_NODE_MODULE_ro17f80mg6k from "node:module";
+
+var __filename = CJS_COMPAT_NODE_URL_ro17f80mg6k.fileURLToPath(import.meta.url);
+var __dirname = CJS_COMPAT_NODE_PATH_ro17f80mg6k.dirname(__filename);
+var require = CJS_COMPAT_NODE_MODULE_ro17f80mg6k.createRequire(import.meta.url);
+
+// ------------------------------------------------------------
+// end of CJS compatibility banner, injected by Forkbook's esbuild configuration
+// ------------------------------------------------------------
+import {
+  createTools
+} from "../../../_node-chunks/chunk-6KEHV53S.js";
+import "../../../_node-chunks/chunk-LXBD4UL4.js";
+import {
+  ToolsRuntimeError
+} from "../../../_node-chunks/chunk-3SDUYDXH.js";
+import "../../../_node-chunks/chunk-BSKFCWQD.js";
+import "../../../_node-chunks/chunk-ICPBH3E7.js";
+import "../../../_node-chunks/chunk-EWOX7HPJ.js";
+import {
+  serializeError
+} from "../../../_node-chunks/chunk-3W7F2B7P.js";
+import "../../../_node-chunks/chunk-OUW6R7C3.js";
+import "../../../_node-chunks/chunk-U5W53R2J.js";
+import "../../../_node-chunks/chunk-2BUPBPFB.js";
+import "../../../_node-chunks/chunk-CXRU72ET.js";
+
+// src/cli/tools/sdk/child-host.ts
+import { pathToFileURL } from "node:url";
+async function runChildHost({
+  send = (message) => {
+    process.send?.(message);
+  },
+  subscribe = (handler) => {
+    process.on("message", handler);
+  },
+  cwd = () => process.cwd()
+} = {}) {
+  process.on("disconnect", () => {
+    process.exit(0);
+  }), process.env.FORKBOOK_TOOLS_CHILD_HOST = "true";
+  let tools, controllers = /* @__PURE__ */ new Map(), handle = async (raw) => {
+    let message = raw;
+    switch (message.type) {
+      case "init": {
+        tools = await createTools({
+          ...message.options,
+          cwd: cwd(),
+          mode: message.options.mode ?? "attached",
+          autoSpawn: !1
+        }), send({
+          type: "hello",
+          version: 1,
+          storybook: tools.storybook,
+          clientInfo: tools.clientInfo
+        });
+        return;
+      }
+      case "describe": {
+        await reply(message.id, tools, () => tools.describe(message.options));
+        return;
+      }
+      case "call": {
+        let controller = new AbortController();
+        controllers.set(message.id, controller);
+        try {
+          await reply(
+            message.id,
+            tools,
+            () => tools.call(message.ref, message.input, { signal: controller.signal })
+          );
+        } finally {
+          controllers.delete(message.id);
+        }
+        return;
+      }
+      case "cancel": {
+        controllers.get(message.id)?.abort();
+        return;
+      }
+      case "close": {
+        await tools?.close(), process.exit(0);
+        return;
+      }
+      default:
+        throw message;
+    }
+  };
+  async function reply(id, host, run) {
+    if (!host) {
+      send({
+        type: "error",
+        id,
+        error: serializeError(
+          new ToolsRuntimeError({
+            reason: "command-unhandled",
+            message: "The child host has not been initialized."
+          })
+        )
+      });
+      return;
+    }
+    try {
+      send({ type: "result", id, value: await run() });
+    } catch (error) {
+      send({ type: "error", id, error: serializeError(error) });
+    }
+  }
+  subscribe((message) => {
+    handle(message).catch((error) => {
+      let fallbackId = typeof message == "object" && message !== null && "id" in message && typeof message.id == "string" ? message.id : "init";
+      send({ type: "error", id: fallbackId, error: serializeError(error) });
+    });
+  });
+}
+function isExecutedAsEntry() {
+  let entry = process.argv[1];
+  if (!entry)
+    return !1;
+  try {
+    return import.meta.url === pathToFileURL(entry).href;
+  } catch {
+    return !1;
+  }
+}
+isExecutedAsEntry() && runChildHost();
+export {
+  runChildHost
+};