@hover-dev/core 0.16.0 → 0.18.0

package/dist/service/cdpHandlers.js

@@ -1,85 +0,0 @@
-/**
- * CDP-related WebSocket message handlers.
- *
- *   check-cdp     → checkCdpStatus → emit cdp-status
- *   launch-chrome → emit "launching" placeholder → launchDebugChrome →
- *                   re-check status → emit cdp-status
- *   focus-debug   → focusDebugTab → no message on success (the widget the
- *                   user is about to focus runs its own check-cdp anyway)
- *
- * Extracted from service.ts during the v0.2.x refactor pass so the main
- * file can be a thin orchestrator.
- */
-import { checkCdpStatus, focusDebugTab } from '../playwright/cdpStatus.js';
-import { launchDebugChrome } from '../playwright/launchChrome.js';
-import { send } from './types.js';
-/**
- * "Is this widget running inside the debug Chrome?" The widget asks this on
- * connect (and after every status-changing event) so it can render itself as
- * either:
- *   - same-window  → normal, drives the page
- *   - wrong-window → disabled, with a "use the other window" notice
- *   - no-cdp       → enabled but click triggers launch-chrome instead
- */
-export async function handleCheckCdp(ws, msg, cdpUrl, extras) {
-    const pageUrl = msg.payload?.pageUrl;
-    if (typeof pageUrl !== 'string' || !pageUrl) {
-        send(ws, { type: 'error', payload: { message: 'check-cdp: pageUrl is required' } });
-        return;
-    }
-    const status = await checkCdpStatus(cdpUrl, pageUrl);
-    send(ws, { type: 'cdp-status', payload: status });
-}
-/**
- * Launch a debug Chrome navigated to `pageUrl`, then re-check status. The
- * re-check usually returns 'wrong-window' (because the widget asking is in
- * the user's regular Chrome, not the freshly-launched one) — the widget then
- * displays the "use the other window" state.
- */
-export async function handleLaunchChrome(ws, msg, cdpUrl, extras) {
-    const pageUrl = msg.payload?.pageUrl;
-    if (typeof pageUrl !== 'string' || !pageUrl) {
-        send(ws, { type: 'error', payload: { message: 'launch-chrome: pageUrl is required' } });
-        return;
-    }
-    // Tell the widget we're launching so it can render a spinner immediately —
-    // findChromeBinary + spawn + ready-poll can take a few seconds.
-    send(ws, { type: 'cdp-status', payload: { state: 'no-cdp', launching: true } });
-    const port = (() => {
-        try {
-            return Number(new URL(cdpUrl).port) || 9222;
-        }
-        catch {
-            return 9222;
-        }
-    })();
-    const result = await launchDebugChrome({
-        url: pageUrl,
-        port,
-        proxy: extras?.proxy,
-    });
-    if (!result.ok) {
-        send(ws, { type: 'cdp-status', payload: { state: 'no-cdp', reason: result.reason } });
-        return;
-    }
-    const status = await checkCdpStatus(cdpUrl, pageUrl);
-    send(ws, { type: 'cdp-status', payload: status });
-}
-/**
- * bringToFront the debug-Chrome tab matching `pageUrl`'s origin (or open one
- * if none exists). Used by the wrong-window UI's "switch to debug Chrome"
- * button. Doesn't return cdp-status — bringToFront doesn't change anything
- * the widget cares about, and the widget the user is about to focus is a
- * different page (and will run its own check-cdp on its own ws connection).
- */
-export async function handleFocusDebug(ws, msg, cdpUrl, extras) {
-    const pageUrl = msg.payload?.pageUrl;
-    if (typeof pageUrl !== 'string' || !pageUrl) {
-        send(ws, { type: 'error', payload: { message: 'focus-debug: pageUrl is required' } });
-        return;
-    }
-    const result = await focusDebugTab(cdpUrl, pageUrl);
-    if (!result.ok) {
-        send(ws, { type: 'error', payload: { message: `focus-debug: ${result.reason}` } });
-    }
-}

package/dist/service/cdpHint.d.ts

@@ -1,48 +0,0 @@
-/**
- * System-prompt addendum sent to the agent on every command.
- *
- * Two roles:
- *   1. Navigation rules — the most failure-prone agent behaviours are
- *      `browser_navigate` to same-origin paths (kills the widget) and
- *      reading the JS bundle for credentials. We tell the agent both
- *      mistakes by name, including the actual origin to forbid.
- *   2. Narration format — how the widget renders the run depends on the
- *      agent emitting short imperative one-liners before each logical
- *      step. The good/bad examples are present-tense and 3–8 words.
- *
- * Lives in its own file because this string is the most-tuned text in the
- * repo and the easiest to break with a typo. Tests can import directly.
- *
- * Two-tier split (since v0.4.x perf pass):
- *   - `buildCdpHint(tabs)` returns the full rules + narration block.
- *     Used on the *first* turn of a session (no `--resume`).
- *   - `buildCdpHintResume(tabs)` returns ONLY the volatile tab list +
- *     active-origin guard. Used on subsequent turns once `--resume`
- *     re-anchors the agent to the prior turn's full system prompt —
- *     the stable rules are already in context, so re-sending them
- *     fragments Anthropic's prompt cache and bills ~500 extra input
- *     tokens per turn for zero behavioural change.
- */
-interface Tab {
-    url: string;
-    title?: string;
-}
-export declare function buildCdpHint(tabs: Tab[]): string;
-/**
- * Volatile-only hint for `--resume` turns: just the tab list snapshot.
- * Empty string when the tab list is empty (nothing to refresh).
- *
- * The rules and narration format from `buildCdpHint` are already
- * established in the prior turn's context; re-sending them here would
- * fragment Anthropic's prompt-cache fingerprint (cache hits require the
- * system prompt to match byte-for-byte across turns) and bill ~500
- * extra input tokens per follow-up turn for no behaviour change.
- *
- * We DO re-send the tab list because it can drift between turns (user
- * opens a second tab, switches focus). The active-origin nav-guard is
- * not repeated — the agent has it from turn 1 and the tab-list update
- * keeps it grounded in the current URL.
- */
-export declare function buildCdpHintResume(tabs: Tab[]): string;
-export {};
-//# sourceMappingURL=cdpHint.d.ts.map

package/dist/service/cdpHint.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"cdpHint.d.ts","sourceRoot":"","sources":["../../src/service/cdpHint.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AAEH,UAAU,GAAG;IAAG,GAAG,EAAE,MAAM,CAAC;IAAC,KAAK,CAAC,EAAE,MAAM,CAAA;CAAE;AAa7C,wBAAgB,YAAY,CAAC,IAAI,EAAE,GAAG,EAAE,GAAG,MAAM,CAmJhD;AAED;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,GAAG,EAAE,GAAG,MAAM,CAYtD"}

package/dist/service/cdpHint.js

@@ -1,216 +0,0 @@
-/**
- * System-prompt addendum sent to the agent on every command.
- *
- * Two roles:
- *   1. Navigation rules — the most failure-prone agent behaviours are
- *      `browser_navigate` to same-origin paths (kills the widget) and
- *      reading the JS bundle for credentials. We tell the agent both
- *      mistakes by name, including the actual origin to forbid.
- *   2. Narration format — how the widget renders the run depends on the
- *      agent emitting short imperative one-liners before each logical
- *      step. The good/bad examples are present-tense and 3–8 words.
- *
- * Lives in its own file because this string is the most-tuned text in the
- * repo and the easiest to break with a typo. Tests can import directly.
- *
- * Two-tier split (since v0.4.x perf pass):
- *   - `buildCdpHint(tabs)` returns the full rules + narration block.
- *     Used on the *first* turn of a session (no `--resume`).
- *   - `buildCdpHintResume(tabs)` returns ONLY the volatile tab list +
- *     active-origin guard. Used on subsequent turns once `--resume`
- *     re-anchors the agent to the prior turn's full system prompt —
- *     the stable rules are already in context, so re-sending them
- *     fragments Anthropic's prompt cache and bills ~500 extra input
- *     tokens per turn for zero behavioural change.
- */
-function resolveActiveOrigin(tabs) {
-    if (tabs.length === 0)
-        return null;
-    // Prefer the localhost tab if we have multiple — that's almost always the
-    // dev server the user is testing against.
-    const localhost = tabs.find(t => /localhost|127\.0\.0\.1/.test(t.url));
-    const active = localhost ?? tabs[0];
-    let activeOrigin = '';
-    try {
-        activeOrigin = new URL(active.url).origin;
-    }
-    catch { /* malformed url — fall back to no-origin guard */ }
-    return { active, activeOrigin };
-}
-export function buildCdpHint(tabs) {
-    const resolved = resolveActiveOrigin(tabs);
-    if (!resolved)
-        return '';
-    const { active, activeOrigin } = resolved;
-    return [
-        `Your job — read this first:`,
-        ``,
-        `  You are an end-to-end testing agent. Match the scope of your run to how`,
-        `  specific the user's prompt is — do NOT over-test.`,
-        ``,
-        `  SPECIFIC prompt — it names a flow or action ("log in as alice and add a`,
-        `  todo", "test the login flow", "只测试登录"): do EXACTLY that flow and`,
-        `  verify its outcome, then STOP. Stay inside the named scope. Do NOT wander`,
-        `  into adjacent flows, extra edge cases (empty/invalid input, boundary`,
-        `  values), logout, or bug-hunting unless the prompt explicitly asks. A`,
-        `  focused run that does what was asked and asserts the result is the goal,`,
-        `  not breadth — one clean verified flow is a complete, successful result.`,
-        `  But if you DO hit a real problem while doing the asked flow — a broken`,
-        `  button, a wrong message, a console error, a failed verification — still`,
-        `  report it under ## Findings. Don't go hunting for more; just don't swallow`,
-        `  what you ran into.`,
-        ``,
-        `  VAGUE or short prompt ("test", "check", "see if it works", "find bugs",`,
-        `  or a single word): DO NOT ask for clarification and DO NOT just take a`,
-        `  snapshot and call it done. Run a real exploratory test pass:`,
-        ``,
-        `    1. browser_snapshot to learn the app's structure.`,
-        `    2. Identify the main interactive surfaces (forms, buttons, links,`,
-        `       inputs, navigation). Plan 2–5 distinct user flows to exercise.`,
-        `    3. Drive each flow end-to-end. Submit forms with real-ish input,`,
-        `       click through navigation, exercise lists / counters / toggles.`,
-        `       Try a couple of edge cases — empty submissions, invalid input,`,
-        `       boundary values — and observe the response.`,
-        `    4. Note anything that looks broken, inconsistent, slow, or`,
-        `       confusing in the final summary's "## Findings" section.`,
-        ``,
-        `  A short "App is running fine" reply after one snapshot is NOT an`,
-        `  acceptable result for a vague prompt — either the app works and you ran`,
-        `  several flows to confirm it, or you found something interesting.`,
-        ``,
-        `The user's Chrome currently has these tabs open:`,
-        ...tabs.map(t => `  - ${t.url}${t.title ? `  (${t.title})` : ''}`),
-        ``,
-        `The likely active dev tab is: ${active.url}`,
-        ``,
-        `Navigation rules — read carefully, these mistakes are the #1 cause of failed`,
-        `runs:`,
-        ``,
-        `  1. Do NOT call browser_navigate to a URL that is already the active tab.`,
-        `     The widget that hosts this session lives inside the page; reloading the`,
-        `     page kills the WebSocket connection and your run gets aborted mid-flight.`,
-        ``,
-        activeOrigin
-            ? `  2. Do NOT call browser_navigate to ANY path on origin ${activeOrigin}`
-            : `  2. Do NOT call browser_navigate to source-file paths on the dev server`,
-        `     just to "read source code for hints" — paths like /src/Login.tsx,`,
-        `     /@vite/client, /node_modules/* are served by Vite as JS modules and`,
-        `     loading them triggers the same widget-killing reload. To inspect the`,
-        `     page, use browser_snapshot — the accessibility tree already exposes`,
-        `     labels, placeholders, and roles.`,
-        ``,
-        `  3. Do NOT read the JS bundle, evaluate page source, or scrape DOM for`,
-        `     hardcoded credentials, API keys, or secrets. If the task needs login,`,
-        `     the user must provide credentials in their prompt; if they didn't,`,
-        `     report "no credentials provided" and stop — do not guess.`,
-        ``,
-        `  4. To see the current page state, call browser_snapshot first. Only`,
-        `     navigate if you actually need a different URL.`,
-        ``,
-        `Multi-tab + cross-origin flows (Stripe Checkout, OAuth login, "Pay with X" popups):`,
-        ``,
-        `  5. When you click something that may open a new tab (target=_blank, a`,
-        `     window.open trigger, a "Pay with …" / "Sign in with …" button), the`,
-        `     popup tab is where the next user-visible step happens — but your tools`,
-        `     stay anchored to the prior tab until you switch. After such a click:`,
-        ``,
-        `       a) Call browser_tabs(action='list') to see if a new tab appeared.`,
-        `          A new entry at a different origin is the popup.`,
-        `       b) Call browser_tabs(action='select', idx=<popup idx>) to focus it,`,
-        `          then browser_snapshot the new tab and proceed.`,
-        `       c) When the popup closes (it usually does so on success/cancel —`,
-        `          window.close() or after a redirect chain), browser_tabs(list)`,
-        `          will no longer show it. The current page may be invalid; call`,
-        `          browser_tabs(action='select', idx=0) to refocus the original tab,`,
-        `          then browser_snapshot it. The original tab's DOM may have updated`,
-        `          via a postMessage handler (e.g. it should now show a "Success" or`,
-        `          "Payment complete" state).`,
-        `       d) If the original tab's snapshot looks unchanged (still showing the`,
-        `          checkout form / login button), the postMessage handler may not`,
-        `          have fired yet or may not exist. Wait once with`,
-        `          browser_wait_for_text("<expected success copy>", timeout=3000)`,
-        `          before concluding the flow is broken.`,
-        ``,
-        `  6. OAuth-style redirect chains: when a tab redirects through several`,
-        `     origins (myapp → identity provider → /callback?code=… → myapp), watch`,
-        `     browser_tabs after each browser_snapshot — the same tab idx can switch`,
-        `     origin underneath you. The URL in browser_tabs(list) is authoritative.`,
-        ``,
-        `  7. Cross-origin cookie/session updates: after the popup closes and you're`,
-        `     back on the original tab, the server-set session cookie may be present`,
-        `     in the browser but the React state hasn't yet picked it up. The most`,
-        `     likely cause is a missing or slow postMessage handler — NOT a real`,
-        `     bug yet. Try browser_wait_for_text once for the expected logged-in`,
-        `     copy with a 3s timeout. If nothing shows, report it as a Finding`,
-        `     ("Original tab did not update after popup closed — likely missing`,
-        `     postMessage listener or auth refresh"); do NOT browser_navigate to`,
-        `     same-origin to force a refresh (rule #2 still applies).`,
-        ``,
-        `Tool usage — operate and verify through the structured Playwright tools:`,
-        ``,
-        `  8. Drive the page only with click / fill / select / snapshot / wait. Do`,
-        `     NOT use browser_run_code_unsafe or browser_evaluate to run JavaScript`,
-        `     — they are disabled, and any action taken in raw JS cannot be`,
-        `     crystallized into a deterministic Playwright spec (it is dropped as a`,
-        `     TODO). To VERIFY an outcome, assert on what browser_snapshot shows —`,
-        `     a heading, an error message, a counter value; the accessibility tree`,
-        `     already exposes the text and roles you need.`,
-        ``,
-        `Narration format — affects how the widget renders your run for the user:`,
-        ``,
-        `  Before each LOGICAL STEP (a coherent unit of work like "Open the login`,
-        `  form", "Fill credentials", "Verify the welcome message"), emit ONE short`,
-        `  imperative sentence describing what you're about to do — present tense,`,
-        `  3–8 words, no markdown. The widget uses that sentence as the step's title.`,
-        ``,
-        `  Good examples:`,
-        `    "Open the login form."`,
-        `    "Fill credentials and submit."`,
-        `    "Verify the welcome message."`,
-        `    "Now testing the Counter section."`,
-        ``,
-        `  Bad examples (too verbose / too vague):`,
-        `    "Let me check the current state of the app and then drive the login flow."`,
-        `    "First, I'll take a snapshot, then I'll look at the page structure, and..."`,
-        ``,
-        `  After the run, if you discovered bugs or unexpected behavior, summarize`,
-        `  them in the FINAL message using these markers so the widget can extract`,
-        `  them into a Findings card:`,
-        ``,
-        `    ## Findings`,
-        `    - **Bug** — <one-line summary>`,
-        `    - **Minor** — <one-line summary>`,
-        ``,
-        `  Do NOT spread bug discoveries across mid-run narration — keep them in the`,
-        `  final summary so they group cleanly. Mid-run, just narrate the next step.`,
-    ].join('\n');
-}
-/**
- * Volatile-only hint for `--resume` turns: just the tab list snapshot.
- * Empty string when the tab list is empty (nothing to refresh).
- *
- * The rules and narration format from `buildCdpHint` are already
- * established in the prior turn's context; re-sending them here would
- * fragment Anthropic's prompt-cache fingerprint (cache hits require the
- * system prompt to match byte-for-byte across turns) and bill ~500
- * extra input tokens per follow-up turn for no behaviour change.
- *
- * We DO re-send the tab list because it can drift between turns (user
- * opens a second tab, switches focus). The active-origin nav-guard is
- * not repeated — the agent has it from turn 1 and the tab-list update
- * keeps it grounded in the current URL.
- */
-export function buildCdpHintResume(tabs) {
-    const resolved = resolveActiveOrigin(tabs);
-    if (!resolved)
-        return '';
-    const { active } = resolved;
-    return [
-        `(Resumed session — full nav + narration rules already in context.)`,
-        ``,
-        `Current Chrome tabs:`,
-        ...tabs.map(t => `  - ${t.url}${t.title ? `  (${t.title})` : ''}`),
-        ``,
-        `Likely active dev tab: ${active.url}`,
-    ].join('\n');
-}

package/dist/service/conventions.d.ts

@@ -1,8 +0,0 @@
-/** Max characters of the conventions file folded into the prompt. */
-export declare const CONVENTIONS_MAX_CHARS = 4000;
-/**
- * Read `<projectRoot>/.hover/conventions.md` and return it wrapped as a
- * system-prompt block, or null when the file is absent or empty.
- */
-export declare function readConventions(projectRoot: string, maxChars?: number): Promise<string | null>;
-//# sourceMappingURL=conventions.d.ts.map

package/dist/service/conventions.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"conventions.d.ts","sourceRoot":"","sources":["../../src/service/conventions.ts"],"names":[],"mappings":"AAgBA,qEAAqE;AACrE,eAAO,MAAM,qBAAqB,OAAO,CAAC;AAE1C;;;GAGG;AACH,wBAAsB,eAAe,CACnC,WAAW,EAAE,MAAM,EACnB,QAAQ,SAAwB,GAC/B,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC,CAqBxB"}

package/dist/service/conventions.js

@@ -1,42 +0,0 @@
-/**
- * Knowledge layer (F5): the project's testing conventions, injected into the
- * agent's system prompt so the developer can steer *how it explores* — which
- * flows matter, where login lives, the preferred selector attribute.
- *
- * Read by the SERVICE (not the agent) from `<projectRoot>/.hover/conventions.md`
- * and folded into the system prompt — the agent never gains a file-read tool
- * (D2). This shapes exploration only; it does NOT change how the saved spec is
- * generated (that's the translator's job — D9).
- *
- * Capped to avoid prompt bloat, and injected on the FIRST turn only (it's
- * static, like cdpHint's rules) so it doesn't fragment the prompt cache.
- */
-import { readFile } from 'node:fs/promises';
-import { join } from 'node:path';
-/** Max characters of the conventions file folded into the prompt. */
-export const CONVENTIONS_MAX_CHARS = 4000;
-/**
- * Read `<projectRoot>/.hover/conventions.md` and return it wrapped as a
- * system-prompt block, or null when the file is absent or empty.
- */
-export async function readConventions(projectRoot, maxChars = CONVENTIONS_MAX_CHARS) {
-    let raw;
-    try {
-        raw = await readFile(join(projectRoot, '.hover', 'conventions.md'), 'utf-8');
-    }
-    catch {
-        return null; // no conventions file — nothing to inject
-    }
-    const trimmed = raw.trim();
-    if (!trimmed)
-        return null;
-    const body = trimmed.length > maxChars ? `${trimmed.slice(0, maxChars)}\n…(truncated)` : trimmed;
-    return [
-        `Project testing conventions — the developer's house rules for this app,`,
-        `from .hover/conventions.md. Use them while EXPLORING (which flows matter,`,
-        `where login lives, preferred selectors, test data). They guide exploration`,
-        `only — they do not change how the saved spec is generated.`,
-        ``,
-        body,
-    ].join('\n');
-}

package/dist/service/saveHandlers.d.ts

@@ -1,52 +0,0 @@
-/**
- * Save-artifact WebSocket handlers (spec / Jira CSV).
- *
- * Both save-* messages share the same shape: validate `name + steps`, call a
- * per-kind writer, fork on Exists-error vs. success. The differences (which
- * writer, which message names, which fields to pluck) are captured in the
- * `SaveArtifactConfig` descriptor table below. (Save-as-Skill was retired; the
- * generic `onSaved` hook it used is kept for any future artifact that needs a
- * post-write tail.)
- */
-import type { WebSocket } from 'ws';
-import { type SkillStep } from '../skills/writeSkill.js';
-import { writeSpec, type SpecAssertion } from '../specs/writeSpec.js';
-import { writeCaseCsv } from '../specs/writeCaseCsv.js';
-import { type ClientMessage } from './types.js';
-interface SaveArtifactConfig<TWriteResult extends {
-    slug: string;
-    path: string;
-}> {
-    /** Used in error messages. Mirrors the WS `type` the client sent. */
-    requestName: string;
-    /** Emitted on success. */
-    savedType: string;
-    /** Emitted when the writer threw an Exists-error. */
-    existsType: string;
-    /** Optional — fires after a successful write (e.g. to push a refreshed list
-     *  to the widget). Currently unused; kept generic for future artifacts. */
-    onSaved?: (ws: WebSocket, devRoot: string) => Promise<void>;
-    /** Class used in `err instanceof …` to detect "already exists" errors. */
-    ExistsError: new (...args: never[]) => {
-        slug: string;
-        path: string;
-    } & Error;
-    /** Pluck the payload fields this artifact needs and call its writer. */
-    write: (args: {
-        devRoot: string;
-        name: string;
-        description: string;
-        steps: SkillStep[];
-        assertions: SpecAssertion[];
-        payload: NonNullable<ClientMessage['payload']>;
-        overwrite: boolean;
-    }) => Promise<TWriteResult>;
-}
-export declare function handleSaveArtifact<TWriteResult extends {
-    slug: string;
-    path: string;
-}>(ws: WebSocket, msg: ClientMessage, devRoot: string, cfg: SaveArtifactConfig<TWriteResult>): Promise<void>;
-export declare const SPEC_CONFIG: SaveArtifactConfig<Awaited<ReturnType<typeof writeSpec>>>;
-export declare const CASE_CSV_CONFIG: SaveArtifactConfig<Awaited<ReturnType<typeof writeCaseCsv>>>;
-export {};
-//# sourceMappingURL=saveHandlers.d.ts.map

package/dist/service/saveHandlers.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"saveHandlers.d.ts","sourceRoot":"","sources":["../../src/service/saveHandlers.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAEH,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,IAAI,CAAC;AACpC,OAAO,EAAE,KAAK,SAAS,EAAE,MAAM,yBAAyB,CAAC;AACzD,OAAO,EAAE,SAAS,EAAmB,KAAK,aAAa,EAAE,MAAM,uBAAuB,CAAC;AACvF,OAAO,EAAE,YAAY,EAAsB,MAAM,0BAA0B,CAAC;AAC5E,OAAO,EAAQ,KAAK,aAAa,EAAE,MAAM,YAAY,CAAC;AAEtD,UAAU,kBAAkB,CAAC,YAAY,SAAS;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAA;CAAE;IAC9E,qEAAqE;IACrE,WAAW,EAAE,MAAM,CAAC;IACpB,0BAA0B;IAC1B,SAAS,EAAE,MAAM,CAAC;IAClB,qDAAqD;IACrD,UAAU,EAAE,MAAM,CAAC;IACnB;+EAC2E;IAC3E,OAAO,CAAC,EAAE,CAAC,EAAE,EAAE,SAAS,EAAE,OAAO,EAAE,MAAM,KAAK,OAAO,CAAC,IAAI,CAAC,CAAC;IAC5D,0EAA0E;IAC1E,WAAW,EAAE,KAAK,GAAG,IAAI,EAAE,KAAK,EAAE,KAAK;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,CAAA;KAAE,GAAG,KAAK,CAAC;IAC9E,wEAAwE;IACxE,KAAK,EAAE,CAAC,IAAI,EAAE;QACZ,OAAO,EAAE,MAAM,CAAC;QAChB,IAAI,EAAE,MAAM,CAAC;QACb,WAAW,EAAE,MAAM,CAAC;QACpB,KAAK,EAAE,SAAS,EAAE,CAAC;QACnB,UAAU,EAAE,aAAa,EAAE,CAAC;QAC5B,OAAO,EAAE,WAAW,CAAC,aAAa,CAAC,SAAS,CAAC,CAAC,CAAC;QAC/C,SAAS,EAAE,OAAO,CAAC;KACpB,KAAK,OAAO,CAAC,YAAY,CAAC,CAAC;CAC7B;AAED,wBAAsB,kBAAkB,CAAC,YAAY,SAAS;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAA;CAAE,EAC1F,EAAE,EAAE,SAAS,EACb,GAAG,EAAE,aAAa,EAClB,OAAO,EAAE,MAAM,EACf,GAAG,EAAE,kBAAkB,CAAC,YAAY,CAAC,GACpC,OAAO,CAAC,IAAI,CAAC,CA0Cf;AAED,eAAO,MAAM,WAAW,EAAE,kBAAkB,CAAC,OAAO,CAAC,UAAU,CAAC,OAAO,SAAS,CAAC,CAAC,CAOjF,CAAC;AAEF,eAAO,MAAM,eAAe,EAAE,kBAAkB,CAAC,OAAO,CAAC,UAAU,CAAC,OAAO,YAAY,CAAC,CAAC,CAYxF,CAAC"}

package/dist/service/saveHandlers.js

@@ -1,75 +0,0 @@
-/**
- * Save-artifact WebSocket handlers (spec / Jira CSV).
- *
- * Both save-* messages share the same shape: validate `name + steps`, call a
- * per-kind writer, fork on Exists-error vs. success. The differences (which
- * writer, which message names, which fields to pluck) are captured in the
- * `SaveArtifactConfig` descriptor table below. (Save-as-Skill was retired; the
- * generic `onSaved` hook it used is kept for any future artifact that needs a
- * post-write tail.)
- */
-import { writeSpec, SpecExistsError } from '../specs/writeSpec.js';
-import { writeCaseCsv, CaseCsvExistsError } from '../specs/writeCaseCsv.js';
-import { send } from './types.js';
-export async function handleSaveArtifact(ws, msg, devRoot, cfg) {
-    const name = msg.payload?.name;
-    const description = msg.payload?.description ?? '';
-    const steps = msg.payload?.steps;
-    const assertions = msg.payload?.assertions ?? [];
-    const overwrite = msg.payload?.overwrite === true;
-    if (typeof name !== 'string' || !name.trim()) {
-        send(ws, { type: 'error', payload: { message: `${cfg.requestName}: name is required` } });
-        return;
-    }
-    if (!Array.isArray(steps) || steps.length === 0) {
-        send(ws, { type: 'error', payload: { message: `${cfg.requestName}: no steps to save` } });
-        return;
-    }
-    let result;
-    try {
-        result = await cfg.write({
-            devRoot, name, description, steps, assertions,
-            payload: msg.payload, overwrite,
-        });
-    }
-    catch (err) {
-        if (err instanceof cfg.ExistsError) {
-            send(ws, { type: cfg.existsType, payload: { slug: err.slug, existingPath: err.path } });
-            return;
-        }
-        const message = err instanceof Error ? err.message : String(err);
-        send(ws, { type: 'error', payload: { message: `${cfg.requestName} failed: ${message}` } });
-        return;
-    }
-    send(ws, { type: cfg.savedType, payload: { name: result.slug, path: result.path } });
-    // The artifact is already on disk; an onSaved failure (e.g. a follow-up
-    // list re-scan) shouldn't surface as if the save itself failed — log on.
-    if (cfg.onSaved) {
-        try {
-            await cfg.onSaved(ws, devRoot);
-        }
-        catch (err) {
-            const message = err instanceof Error ? err.message : String(err);
-            console.warn(`[hover] ${cfg.requestName} onSaved failed: ${message}`);
-        }
-    }
-}
-export const SPEC_CONFIG = {
-    requestName: 'save-spec',
-    savedType: 'spec-saved',
-    existsType: 'spec-exists',
-    ExistsError: SpecExistsError,
-    write: ({ devRoot, name, description, steps, assertions, overwrite }) => writeSpec({ devRoot, name, description, steps, assertions, overwrite }),
-};
-export const CASE_CSV_CONFIG = {
-    requestName: 'save-case-csv',
-    savedType: 'case-csv-saved',
-    existsType: 'case-csv-exists',
-    ExistsError: CaseCsvExistsError,
-    write: ({ devRoot, name, description, steps, assertions, payload, overwrite }) => writeCaseCsv({
-        devRoot, name, description, steps, assertions,
-        jiraProjectKey: payload.jiraProjectKey,
-        labels: payload.labels,
-        overwrite,
-    }),
-};

package/dist/service/types.d.ts

@@ -1,58 +0,0 @@
-/**
- * Shared types for the service/ handler modules.
- *
- * `ClientMessage` describes the wire-protocol envelope every message from
- * the widget arrives in. Lives here (not in service.ts) so individual
- * handlers can type their `msg` argument without circular imports.
- *
- * `send` is the one-liner used by every handler to emit a typed message
- * back to the widget. Centralised so the JSON.stringify happens in exactly
- * one place.
- */
-import { WebSocket } from 'ws';
-import type { SkillStep } from '../skills/writeSkill.js';
-import type { SpecAssertion } from '../specs/writeSpec.js';
-export interface ClientMessage {
-    type: string;
-    payload?: {
-        text?: string;
-        sessionId?: string;
-        name?: string;
-        description?: string;
-        steps?: SkillStep[];
-        assertions?: SpecAssertion[];
-        overwrite?: boolean;
-        /** save-case-csv only — passed through to writeCaseCsv as extra
-         *  fields on the test case's Labels column. */
-        jiraProjectKey?: string;
-        labels?: string;
-        /** check-cdp / launch-chrome / focus-debug — the widget's
-         *  window.location.href so service can compare origins or navigate the
-         *  newly-launched debug Chrome to the same URL. */
-        pageUrl?: string;
-        /** switch-agent only — id of the agent to switch the service to. */
-        agentId?: string;
-        /** set-mode only — id of the plugin-contributed mode to activate,
-         *  or null to return to normal (unmoded) operation. */
-        modeId?: string | null;
-        /** optimize-spec / promote-optimized / discard-optimized — the spec slug. */
-        slug?: string;
-        /** set-api-key only — the model API key to inject into the spawned CLI's
-         *  env (or empty/missing to clear it). Held in memory only, never logged. */
-        key?: string;
-    };
-}
-export declare function send(ws: WebSocket, message: {
-    type: string;
-    payload?: unknown;
-}): void;
-/** Send a message only if the socket is still open. Use this from delayed
- *  callbacks (promise `.then`, timers) where the client may have disconnected
- *  between scheduling and firing — calling `ws.send` on a closed socket
- *  is a silent no-op for some states and throws for others, so a single
- *  guarded helper makes the intent obvious and prevents surprises. */
-export declare function sendIfOpen(ws: WebSocket, message: {
-    type: string;
-    payload?: unknown;
-}): boolean;
-//# sourceMappingURL=types.d.ts.map

package/dist/service/types.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/service/types.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAEH,OAAO,EAAE,SAAS,EAAE,MAAM,IAAI,CAAC;AAC/B,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,yBAAyB,CAAC;AACzD,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,uBAAuB,CAAC;AAE3D,MAAM,WAAW,aAAa;IAC5B,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,CAAC,EAAE;QACR,IAAI,CAAC,EAAE,MAAM,CAAC;QACd,SAAS,CAAC,EAAE,MAAM,CAAC;QACnB,IAAI,CAAC,EAAE,MAAM,CAAC;QACd,WAAW,CAAC,EAAE,MAAM,CAAC;QACrB,KAAK,CAAC,EAAE,SAAS,EAAE,CAAC;QACpB,UAAU,CAAC,EAAE,aAAa,EAAE,CAAC;QAC7B,SAAS,CAAC,EAAE,OAAO,CAAC;QACpB;uDAC+C;QAC/C,cAAc,CAAC,EAAE,MAAM,CAAC;QACxB,MAAM,CAAC,EAAE,MAAM,CAAC;QAChB;;2DAEmD;QACnD,OAAO,CAAC,EAAE,MAAM,CAAC;QACjB,oEAAoE;QACpE,OAAO,CAAC,EAAE,MAAM,CAAC;QACjB;+DACuD;QACvD,MAAM,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;QACvB,6EAA6E;QAC7E,IAAI,CAAC,EAAE,MAAM,CAAC;QACd;qFAC6E;QAC7E,GAAG,CAAC,EAAE,MAAM,CAAC;KACd,CAAC;CACH;AAED,wBAAgB,IAAI,CAAC,EAAE,EAAE,SAAS,EAAE,OAAO,EAAE;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,OAAO,CAAC,EAAE,OAAO,CAAA;CAAE,GAAG,IAAI,CAEtF;AAED;;;;sEAIsE;AACtE,wBAAgB,UAAU,CACxB,EAAE,EAAE,SAAS,EACb,OAAO,EAAE;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,OAAO,CAAC,EAAE,OAAO,CAAA;CAAE,GAC3C,OAAO,CAIT"}

package/dist/service/types.js

@@ -1,26 +0,0 @@
-/**
- * Shared types for the service/ handler modules.
- *
- * `ClientMessage` describes the wire-protocol envelope every message from
- * the widget arrives in. Lives here (not in service.ts) so individual
- * handlers can type their `msg` argument without circular imports.
- *
- * `send` is the one-liner used by every handler to emit a typed message
- * back to the widget. Centralised so the JSON.stringify happens in exactly
- * one place.
- */
-import { WebSocket } from 'ws';
-export function send(ws, message) {
-    ws.send(JSON.stringify(message));
-}
-/** Send a message only if the socket is still open. Use this from delayed
- *  callbacks (promise `.then`, timers) where the client may have disconnected
- *  between scheduling and firing — calling `ws.send` on a closed socket
- *  is a silent no-op for some states and throws for others, so a single
- *  guarded helper makes the intent obvious and prevents surprises. */
-export function sendIfOpen(ws, message) {
-    if (ws.readyState !== WebSocket.OPEN)
-        return false;
-    ws.send(JSON.stringify(message));
-    return true;
-}