@aexol/spectral 0.8.2 → 0.8.6

package/dist/server/agent-bridge.js

@@ -1,18 +1,18 @@
 /**
- * Per-connection pi SDK lifecycle.
+ * Per-connection spectral SDK lifecycle.
  *
  * One `AgentBridge` instance per active WebSocket connection. Wraps:
  *  - `createAgentSession` (in-memory session manager — we own persistence in
- *    SQLite; pi doesn't need to write its own JSONL files).
- *  - `subscribe` listener that translates pi `AgentSessionEvent`s into our
+ *    SQLite; spectral doesn't need to write its own JSONL files).
+ *  - `subscribe` listener that translates spectral `AgentSessionEvent`s into our
  *    own `ServerEvent` wire format and pushes them through a caller-supplied
  *    sink.
  *  - `prompt(text)` to send user input.
  *  - `dispose()` for clean teardown on WS close.
  *
- * Event mapping (pi → wire):
+ * Event mapping (agent → wire):
  *  - `message_start` (assistant)        → emit our own `message_start` with a
- *    fresh UUID `messageId`. Pi's AssistantMessage has no stable id field, so
+ *    fresh UUID `messageId`. spectral's AssistantMessage has no stable id field, so
  *    we mint one per turn and use it for all subsequent deltas/tool events
  *    until `message_end`.
  *  - `message_update` w/ inner text_delta / thinking_delta → wire `text_delta`
@@ -29,7 +29,7 @@
  *
  * Persistence shape:
  *  `events_jsonl` is the newline-delimited JSON of the wire-format
- *  `ServerEvent`s we emitted for this message — NOT raw pi
+ *  `ServerEvent`s we emitted for this message — NOT raw spectral
  *  `AgentSessionEvent`s. This guarantees the client's `parseWireEvents`
  *  reducer can rehydrate the turn after a refresh using the exact same
  *  reducer it uses for the live broadcast.
@@ -45,7 +45,7 @@
  *  `createAgentSession` is called, each message is appended to the
  *  in-memory SessionManager so the LLM sees the full conversation
  *  context from the very first prompt. Multi-turn conversations within
- *  a single pi session also work normally (the same AgentSession
+ *  a single spectral session also work normally (the same AgentSession
  *  instance is reused across `prompt()` calls).
  */
 import { createJiti } from "@mariozechner/jiti";
@@ -64,12 +64,12 @@ import { Runtime } from "../memory/runtime.js";
 import { OBSERVATIONAL_MEMORY_CONTEXT_CUSTOM_TYPE, OBSERVATIONAL_MEMORY_SNAPSHOT_CUSTOM_TYPE, } from "../memory/types.js";
 import { fetchAllowedModels as defaultFetchAllowedModels, } from "../relay/models-fetch.js";
 /**
- * Synthetic provider names registered with pi's `ModelRegistry`. They route
+ * Synthetic provider names registered with spectral's `ModelRegistry`. They route
  * 100% of inference traffic through the backend (`${backendUrl}/v1`), which
  * authenticates with the machine JWT and forwards to the upstream provider
  * with centrally-managed API keys.
  *
- * Two providers (rather than one) because pi's `ProviderConfigInput.api`
+ * Two providers (rather than one) because spectral's `ProviderConfigInput.api`
  * picks the request shape per registration. Backend supports both, but a
  * single bag would force all models onto one shape; instead we group by
  * upstream provider type.
@@ -84,7 +84,7 @@ const SPECTRAL_PROXY_USER_MODEL = "spectral-proxy-user-model";
  *
  * Directories are returned in order from the deepest ancestor to `cwd` so
  * project-local skills override ancestor-level ones when there are name
- * collisions (pi's skill loader keeps the first found).
+ * collisions (spectral's skill loader keeps the first found).
  */
 function collectAncestorSkillDirs(cwd, relativePaths) {
     const found = [];
@@ -111,8 +111,8 @@ function collectAncestorSkillDirs(cwd, relativePaths) {
 /**
  * Concatenate text from an `AssistantMessage.content` array. Returns the
  * empty string when no text blocks are present (tool-only turns) or when
- * the input is missing/non-array (defensive — pi's `message_end` always
- * carries an array, but we don't want to crash on a future SDK change).
+ * the input is missing/non-array (defensive — spectral's `message_end` always
+ * carries an array, but we don't want to crash on a future sdk change).
  */
 function extractTextFromContent(content) {
     if (!Array.isArray(content))
@@ -129,7 +129,7 @@ function extractTextFromContent(content) {
     return out;
 }
 /**
- * Resolve the entry point of the pi-mcp-adapter extension.
+ * Resolve the entry point of the spectral-mcp-adapter extension.
  * Uses the bundled copy in dist/mcp/index.js (same directory as this file).
  * Returns the absolute path, or null if the bundled file is missing.
  */
@@ -145,8 +145,8 @@ function resolveMcpAdapterEntry() {
 /**
  * Token pricing per model (USD per 1M tokens). Matches provider list
  * prices as of May 2026. Used to compute token cost server-side when
- * pi's own cost field is unavailable (synthetic proxy models are
- * registered with zero cost to avoid pi-side billing).
+ * spectral's own cost field is unavailable (synthetic proxy models are
+ * registered with zero cost to avoid agent-side billing).
  *
  * Keys are matched as prefix substrings against modelId, so
  * `"claude-sonnet-4"` covers both `claude-sonnet-4-20250514` and any
@@ -386,7 +386,7 @@ export class AgentBridge {
     disposed = false;
     opts;
     /**
-     * Pi's model registry. Built lazily in `start()` so we can resolve a
+     * spectral's model registry. Built lazily in `start()` so we can resolve a
      * `modelId` (envelope-supplied or SQLite-persisted) to a concrete `Model`
      * via `registry.getAll().find(m => m.id === modelId)` before invoking
      * `session.setModel()`. Phase 3 (Available Models whitelist).
@@ -400,9 +400,9 @@ export class AgentBridge {
     allowedModels;
     /**
      * Last `modelId` we successfully applied via `session.setModel()`, or
-     * `undefined` if we never applied one (pi falls back to its own settings
+     * `undefined` if we never applied one (spectral falls back to its own settings
      * file in that case, matching pre-Phase-3 behaviour). Tracked so repeated
-     * envelopes carrying the same modelId don't churn pi's internal state.
+     * envelopes carrying the same modelId don't churn spectral's internal state.
      */
     lastAppliedModelId;
     /** Current model's credit rates (from availableBaseModels), used for token_usage. */
@@ -413,38 +413,38 @@ export class AgentBridge {
         this.opts = opts;
     }
     /**
-     * Create the pi session, wire up subscription, and return.
+     * Create the spectral session, wire up subscription, and return.
      * Throws on creation failure (caller should surface to client).
      */
     async start() {
         if (this.disposed)
             throw new Error("AgentBridge already disposed");
-        const extensionFactories = [aexolMcpExtension, kanbanBridgeExtension, async (pi) => { spectralVisionExtension(pi); }, async (pi) => { subagentExt(pi); }, async (pi) => { designerExtension(pi); }, async (pi) => { observationalMemory(pi); }];
-        // Load pi-mcp-adapter via jiti so tsc never crawls its .ts files in
+        const extensionFactories = [aexolMcpExtension, kanbanBridgeExtension, async (ext) => { spectralVisionExtension(ext); }, async (ext) => { subagentExt(ext); }, async (ext) => { designerExtension(ext); }, async (ext) => { observationalMemory(ext); }];
+        // Load spectral-mcp-adapter via jiti so tsc never crawls its .ts files in
         // node_modules. The static `import` was causing tsc to type-check
-        // pi-mcp-adapter's source and fail the build on its type errors.
-        // jiti is the same loader pi uses internally for all extensions.
+        // spectral-mcp-adapter's source and fail the build on its type errors.
+        // jiti is the same loader spectral uses internally for all extensions.
         const mcpAdapterPath = resolveMcpAdapterEntry();
         if (mcpAdapterPath) {
             try {
                 const jiti = createJiti(import.meta.url, { moduleCache: false });
                 const mcpAdapterFactory = await jiti.import(mcpAdapterPath, { default: true });
                 if (typeof mcpAdapterFactory === "function") {
-                    extensionFactories.push(async (pi) => mcpAdapterFactory(pi));
+                    extensionFactories.push(async (ext) => mcpAdapterFactory(ext));
                 }
             }
             catch {
-                console.info("[AgentBridge] pi-mcp-adapter not found; standard MCP servers disabled.");
+                console.info("[AgentBridge] spectral-mcp-adapter not found; standard MCP servers disabled.");
             }
         }
         else {
-            console.info("[AgentBridge] pi-mcp-adapter not found; standard MCP servers disabled.");
+            console.info("[AgentBridge] spectral-mcp-adapter not found; standard MCP servers disabled.");
         }
         // ResourceLoader with extensions wired in via factories.
-        // Each factory's signature `(pi: ExtensionAPI) => Promise<void>` matches
+        // Each factory's signature `(ext: ExtensionAPI) => Promise<void>` matches
         // the ExtensionFactory type exactly, so we can pass them directly.
         //
-        // Skill discovery: pi's defaults scan ~/.spectral/agent/skills/ (user),
+        // Skill discovery: spectral's defaults scan ~/.spectral/agent/skills/ (user),
         // .spectral/skills/ (project via CONFIG_DIR_NAME), and .agents/skills/
         // (ancestor-walked). We additionally walk ancestors for
         // .opencode/skills and .aexol/skills so OpenCode/Codex/Aexol skills
@@ -581,7 +581,7 @@ export class AgentBridge {
         // provider credentials and the only allowed inference target. We then
         // register synthetic providers (`spectral-proxy-anthropic` /
         // `spectral-proxy-openai`) whose `baseUrl` points at the backend's
-        // `/v1` proxy and whose `apiKey` is the machine JWT. Pi will then
+        // `/v1` proxy and whose `apiKey` is the machine JWT. spectral will then
         // POST `${baseUrl}/messages` (or `/chat/completions`) with
         // `Authorization: Bearer <machineJwt>` for every turn — the backend
         // verifies the JWT, looks up the requested `model` in the BaseModel
@@ -639,7 +639,7 @@ export class AgentBridge {
             }
             catch { /* best-effort */ }
         });
-        // Emit session_start so extensions can initialize (e.g. pi-mcp-adapter
+        // Emit session_start so extensions can initialize (e.g. spectral-mcp-adapter
         // connects to MCP servers, loads configs from ~/.config/mcp/mcp.json etc.).
         // bindExtensions also fires resources_discover for dynamic skill/prompt
         // registration.
@@ -684,7 +684,7 @@ export class AgentBridge {
      * (OpenAI-compatible API). The backend supports both endpoints natively
      * (verified in F1).
      *
-     * Pi will send `Authorization: Bearer ${apiKey}` (because `authHeader: true`)
+     * spectral will send `Authorization: Bearer ${apiKey}` (because `authHeader: true`)
      * which carries the machine JWT — the only credential the backend trusts.
      *
      * The `id` we register is the raw `modelId` (e.g. `claude-3-5-haiku-latest`),
@@ -707,7 +707,7 @@ export class AgentBridge {
                         id: m.modelId,
                         name: m.displayName,
                         api: "anthropic-messages",
-                        // Pin provider/baseUrl explicitly so pi's ModelRegistry doesn't
+                        // Pin provider/baseUrl explicitly so spectral's ModelRegistry doesn't
                         // auto-derive `provider` from a slash-prefixed id (e.g. treating
                         // `deepseek/deepseek-v4-pro` as provider `"deepseek"`), which would
                         // make `hasConfiguredAuth(model)` look up the wrong provider key
@@ -735,7 +735,7 @@ export class AgentBridge {
                         id: m.modelId,
                         name: m.displayName,
                         api: "openai-completions",
-                        // See anthropic batch above for rationale — without these, pi
+                        // See anthropic batch above for rationale — without these, spectral
                         // auto-derives `provider` from slash-prefixed ids like
                         // `deepseek/deepseek-v4-pro` or `meta-llama/llama-3.3-70b-instruct`,
                         // breaking auth lookup against our synthetic proxy provider.
@@ -781,7 +781,7 @@ export class AgentBridge {
         }
     }
     /**
-     * Apply a sticky model selection to the underlying pi session, if it
+     * Apply a sticky model selection to the underlying spectral session, if it
      * differs from what was last applied. No-ops when:
      *  - `modelId` is null/undefined (caller passed nothing to apply)
      *  - the same modelId was already applied to this session
@@ -792,7 +792,7 @@ export class AgentBridge {
      * Returns true when the requested model is now in effect (either because
      * we just applied it or because it was already applied). Returns false
      * on resolution failure so the caller can skip `prompt()` and avoid
-     * driving pi against the wrong model.
+     * driving spectral against the wrong model.
      *
      * Phase 3 (Available Models whitelist).
      */
@@ -809,7 +809,7 @@ export class AgentBridge {
         return this.allowedModels?.[0]?.modelId;
     }
     /**
-     * Return current session context usage from pi's built-in estimator.
+     * Return current session context usage from spectral's built-in estimator.
      * Used after compaction and session start to push updated context-window
      * stats to the frontend without waiting for the next assistant turn.
      */
@@ -850,7 +850,7 @@ export class AgentBridge {
     }
     async setModel(modelId) {
         if (!modelId)
-            return true; // nothing to apply — pi keeps its current model
+            return true; // nothing to apply — spectral keeps its current model
         if (!this.session)
             throw new Error("AgentBridge.start() not called");
         if (this.lastAppliedModelId === modelId)
@@ -858,7 +858,7 @@ export class AgentBridge {
         if (!this.modelRegistry) {
             // Defensive: start() always populates this; if it didn't we can't
             // resolve and must surface to the client rather than silently using
-            // pi's default.
+            // spectral's default.
             this.opts.emit({
                 type: "error",
                 message: `Cannot apply modelId "${modelId}": model registry unavailable`,
@@ -884,7 +884,7 @@ export class AgentBridge {
         if (!model) {
             this.opts.emit({
                 type: "error",
-                message: `Unknown modelId "${modelId}" — not found in pi model registry${refreshError ? ` after refresh: ${refreshError.message}` : ""}`,
+                message: `Unknown modelId "${modelId}" — not found in spectral model registry${refreshError ? ` after refresh: ${refreshError.message}` : ""}`,
             });
             return false;
         }
@@ -914,18 +914,18 @@ export class AgentBridge {
         }
     }
     /**
-     * Map a frontend reasoning-effort string to pi's ThinkingLevel.
+     * Map a frontend reasoning-effort string to spectral's ThinkingLevel.
      * Frontend sends: xhigh | high | medium | low | minimal | none | undefined
-     * Pi expects:   "high" | "medium" | "low" | "minimal" | "off"
+     * spectral expects:   "high" | "medium" | "low" | "minimal" | "off"
      *
      * Mapping:
-     *   xhigh   → high    (pi doesn't have xhigh, default to max)
+     *   xhigh   → high    (spectral doesn't have xhigh, default to max)
      *   high    → high
      *   medium  → medium
      *   low     → low
      *   minimal → minimal
      *   none    → off
-     *   undefined → no-op (pi keeps whatever it has currently)
+     *   undefined → no-op (spectral keeps whatever it has currently)
      */
     mapReasoningEffortToThinkingLevel(effort) {
         if (effort === undefined)
@@ -946,10 +946,10 @@ export class AgentBridge {
     }
     /**
      * Set the reasoning/thinking effort level for the next prompt.
-     * Pass `undefined` to leave pi's current level unchanged.
+     * Pass `undefined` to leave spectral's current level unchanged.
      *
      * The caller (SessionStreamManager) is responsible for persisting the
-     * value to SQLite; this method only applies it to pi's in-memory session.
+     * value to SQLite; this method only applies it to spectral's in-memory session.
      */
     setReasoningEffort(effort) {
         const level = this.mapReasoningEffortToThinkingLevel(effort);
@@ -973,13 +973,13 @@ export class AgentBridge {
         }
     }
     /**
-     * Forward a user message to pi. Resolves when the full turn ends.
+     * Forward a user message to ext. Resolves when the full turn ends.
      * The caller is responsible for persisting the user message to SQLite
-     * BEFORE invoking this — we don't do it here because pi's `prompt` may
+     * BEFORE invoking this — we don't do it here because spectral's `prompt` may
      * fail and we still want the user message recorded.
      *
      * When `images` is non-empty, each base64-encoded attachment is converted
-     * to a pi `ImageContent` block and passed as `options.images` to
+     * to a spectral `ImageContent` block and passed as `options.images` to
      * `session.prompt()`. If the current model does not support image inputs,
      * images are instead converted to text placeholders so the conversation
      * can continue without errors.
@@ -1012,7 +1012,7 @@ export class AgentBridge {
         }
     }
     /**
-     * Manually compact the session context via pi's built-in compaction.
+     * Manually compact the session context via spectral's built-in compaction.
      * Pi generates a summary of older conversation history, preserving the
      * most recent ~20K tokens verbatim. Compaction events are forwarded to
      * the wire through `handleEvent()`.
@@ -1136,8 +1136,8 @@ export class AgentBridge {
     }
     /**
      * Subscriber callback. Public so tests can drive event flow without
-     * spinning up a real pi session — production code never calls this
-     * directly; pi's `subscribe()` does, via the closure registered in
+     * spinning up a real spectral session — production code never calls this
+     * directly; spectral's `subscribe()` does, via the closure registered in
      * `start()`.
      */
     handleEvent(ev) {
@@ -1152,7 +1152,7 @@ export class AgentBridge {
                 // Finalize the previous pending message (if any) before starting a
                 // new one. This captures tool events that arrived after the previous
                 // `message_end` but before this `message_start`. Deferred persistence
-                // is necessary because pi fires tool_execution_* events BETWEEN
+                // is necessary because spectral fires tool_execution_* events BETWEEN
                 // messages — after the previous `message_end` nulled the pending in
                 // the old code, those tool events were lost from history.
                 this.finalizePendingMessage();
@@ -1327,7 +1327,7 @@ export class AgentBridge {
                 if (ev.message.role !== "assistant" || !this.pending)
                     return;
                 const { messageId, text } = this.pending;
-                // Prefer the assembled text from pi's final AssistantMessage
+                // Prefer the assembled text from spectral's final AssistantMessage
                 // (authoritative — providers like deepseek only populate this and
                 // skip per-token `text_delta`s entirely). Fall back to the
                 // accumulator for providers that stream deltas without re-asserting
@@ -1338,7 +1338,7 @@ export class AgentBridge {
                 const endEvent = { type: "message_end", messageId };
                 this.pending.wireEvents.push(endEvent);
                 this.opts.emit(endEvent);
-                // Emit token usage for this assistant message. pi provides token
+                // Emit token usage for this assistant message. spectral provides token
                 // counts via ev.message.usage; credits are computed from the active
                 // model's configured credit rates.
                 //
@@ -1355,7 +1355,7 @@ export class AgentBridge {
                     (usage?.cacheRead ?? 0) +
                     (usage?.cacheWrite ?? 0);
                 if (usage && totalTokens > 0) {
-                    // Resolve current context window usage from pi's built-in
+                    // Resolve current context window usage from spectral's built-in
                     // `getContextUsage()`, which handles post-compaction ambiguity
                     // and estimates total tokens from the full session tree.
                     const ctxUsage = this.session?.getContextUsage();
@@ -1378,7 +1378,7 @@ export class AgentBridge {
                     this.opts.emit(usageEvent);
                 }
                 // Defer persistence: keep `this.pending` alive so tool events that
-                // arrive after `message_end` (pi fires tool_execution_* events
+                // arrive after `message_end` (spectral fires tool_execution_* events
                 // BETWEEN messages) are buffered into `pending.wireEvents`. We store
                 // the final content and persist later — when the next `message_start`
                 // signals a new step, or when `agent_end` closes the turn.
@@ -1415,7 +1415,7 @@ export class AgentBridge {
                 return;
             }
             default:
-                // Other pi-internal events (turn_start, queue_update,
+                // Other spectral-internal events (turn_start, queue_update,
                 // auto_retry_*, tool_execution_update) are intentionally not on
                 // the wire surface for MVP and are NOT persisted — the wire format
                 // is the source of truth for replay.
@@ -1457,7 +1457,7 @@ function detectNotifSystem(message) {
 /**
  * Create a minimal ExtensionUIContext that forwards `notify()` calls as
  * `agent_notification` wire events. All other UI methods are no-ops —
- * only extensions (not pi's TUI) call into the UI context in headless mode,
+ * only extensions (not spectral's TUI) call into the UI context in headless mode,
  * and extensions that call methods other than `notify()` are expected to
  * guard with `ctx.hasUI` first.
  */

package/dist/server/handlers/errors.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Typed errors thrown by REST handlers.
+ *
+ * Each error carries a stable `code` that the relay envelope dispatcher
+ * (Batch 3) maps to a wire-level status. Until then, the handlers throw
+ * and the relay loop just acks — Batch 3 will catch and translate.
+ *
+ * Why typed errors instead of returning `{ ok: false, code }` discriminated
+ * unions? Two reasons:
+ *  - The handlers are also called directly from unit tests; `throw` lets
+ *    tests use `expect(...).rejects.toThrow(NotFoundError)` ergonomically.
+ *  - The Batch 3 dispatcher needs a single `try/catch` boundary; a sum
+ *    type per handler would force every handler to return its own variant.
+ */
+export type HandlerErrorCode = "BAD_REQUEST" | "NOT_FOUND";
+export declare class HandlerError extends Error {
+    readonly code: HandlerErrorCode;
+    constructor(code: HandlerErrorCode, message: string);
+}
+export declare class BadRequestError extends HandlerError {
+    constructor(message: string);
+}
+export declare class NotFoundError extends HandlerError {
+    constructor(message: string);
+}
+//# sourceMappingURL=errors.d.ts.map

package/dist/server/handlers/errors.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"errors.d.ts","sourceRoot":"","sources":["../../../src/server/handlers/errors.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AAEH,MAAM,MAAM,gBAAgB,GAAG,aAAa,GAAG,WAAW,CAAC;AAE3D,qBAAa,YAAa,SAAQ,KAAK;IACrC,QAAQ,CAAC,IAAI,EAAE,gBAAgB,CAAC;gBACpB,IAAI,EAAE,gBAAgB,EAAE,OAAO,EAAE,MAAM;CAKpD;AAED,qBAAa,eAAgB,SAAQ,YAAY;gBACnC,OAAO,EAAE,MAAM;CAI5B;AAED,qBAAa,aAAc,SAAQ,YAAY;gBACjC,OAAO,EAAE,MAAM;CAI5B"}

package/dist/server/handlers/mcp-status.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Handler for `GET /api/mcp-status`.
+ *
+ * Returns a snapshot of the locally connected MCP servers managed by
+ * `spectral serve`. Pure handler pattern — no framework, no side effects.
+ * The caller (the relay dispatcher) injects `McpExtensionState`.
+ *
+ * This module intentionally imports ONLY `McpExtensionState` (a pure-type
+ * import from `state.ts`). It avoids `init.ts` / `config.ts` / etc. so the
+ * dispatcher never pulls in heavy transitive deps.
+ */
+import type { McpExtensionState } from "../../mcp/state.js";
+export interface McpServerStatus {
+    name: string;
+    status: "connected" | "disconnected" | "needs-auth" | "failed" | "cached";
+    toolCount: number;
+    /** Epoch-ms of the most recent connection failure, if the server is in a failed state. */
+    failedAt?: number;
+}
+export declare function handleListMcpStatus(state: McpExtensionState): McpServerStatus[];
+//# sourceMappingURL=mcp-status.d.ts.map

package/dist/server/handlers/mcp-status.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mcp-status.d.ts","sourceRoot":"","sources":["../../../src/server/handlers/mcp-status.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAEH,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,oBAAoB,CAAC;AAK5D,MAAM,WAAW,eAAe;IAC9B,IAAI,EAAE,MAAM,CAAC;IACb,MAAM,EAAE,WAAW,GAAG,cAAc,GAAG,YAAY,GAAG,QAAQ,GAAG,QAAQ,CAAC;IAC1E,SAAS,EAAE,MAAM,CAAC;IAClB,0FAA0F;IAC1F,QAAQ,CAAC,EAAE,MAAM,CAAC;CACnB;AAED,wBAAgB,mBAAmB,CACjC,KAAK,EAAE,iBAAiB,GACvB,eAAe,EAAE,CA0BnB"}

package/dist/server/handlers/mcp-status.js

@@ -0,0 +1,52 @@
+/**
+ * Handler for `GET /api/mcp-status`.
+ *
+ * Returns a snapshot of the locally connected MCP servers managed by
+ * `spectral serve`. Pure handler pattern — no framework, no side effects.
+ * The caller (the relay dispatcher) injects `McpExtensionState`.
+ *
+ * This module intentionally imports ONLY `McpExtensionState` (a pure-type
+ * import from `state.ts`). It avoids `init.ts` / `config.ts` / etc. so the
+ * dispatcher never pulls in heavy transitive deps.
+ */
+/** Maximum age (ms) of a failure entry before we treat it as stale. */
+const FAILURE_BACKOFF_MS = 60_000;
+export function handleListMcpStatus(state) {
+    const result = [];
+    for (const name of Object.keys(state.config.mcpServers)) {
+        const connection = state.manager.getConnection(name);
+        const metadata = state.toolMetadata.get(name);
+        const toolCount = metadata?.length ?? 0;
+        const failedAgo = getFailureAgeSeconds(state, name);
+        let status = "disconnected";
+        let failedAt;
+        if (connection?.status === "connected") {
+            status = "connected";
+        }
+        else if (connection?.status === "needs-auth") {
+            status = "needs-auth";
+        }
+        else if (failedAgo !== null) {
+            status = "failed";
+            failedAt = state.failureTracker.get(name) ?? undefined;
+        }
+        else if (metadata !== undefined) {
+            status = "cached";
+        }
+        result.push({ name, status, toolCount, failedAt });
+    }
+    return result;
+}
+/**
+ * Mirrors `init.ts#getFailureAgeSeconds` without pulling in init.ts's
+ * heavy runtime deps (config, consent manager, UI resource handler, etc.).
+ */
+function getFailureAgeSeconds(state, serverName) {
+    const failedAt = state.failureTracker.get(serverName);
+    if (!failedAt)
+        return null;
+    const ageMs = Date.now() - failedAt;
+    if (ageMs > FAILURE_BACKOFF_MS)
+        return null;
+    return Math.round(ageMs / 1000);
+}

package/dist/server/handlers/paths-autocomplete.d.ts

@@ -0,0 +1,45 @@
+/**
+ * Filesystem autocomplete for project path creation.
+ *
+ * When a user types a partial path in the New Project form, the browser
+ * sends `GET /api/paths/autocomplete?prefix=<partial>`. This handler
+ * expands the prefix (tilde → $HOME, relative → absolute), lists the
+ * containing directory, and returns up to 10 directory suggestions whose
+ * basenames start with the typed partial segment.
+ *
+ * Two strategies:
+ *   1. If the expanded prefix exists on disk as a directory — show its
+ *      immediate children (trailing separator is implicit). This is the
+ *      natural behaviour when the user has already typed a real directory
+ *      and wants to drill deeper.
+ *   2. Otherwise — split into parent + basename prefix and do a
+ *      starts-with match so the user can filter siblings while typing.
+ *
+ * Dotfiles are excluded — they are rarely intentional project roots.
+ * Symlinks to directories ARE included (readdirSync with withFileTypes
+ * returns true for both real dirs and symlink dirs).
+ *
+ * Thread-safety: synchronous, called from the relay-dispatcher hot path.
+ * fs ops block the event loop for microseconds on local SSDs; the form
+ * is typed by a single human, so this is perfectly fine.
+ */
+export interface PathAutocompleteResult {
+    suggestions: string[];
+    expandedPrefix: string;
+}
+/**
+ * List directory suggestions for the given path prefix.
+ *
+ * Examples (assume $HOME=/Users/alice, dirs are `projects`, `proj-old`,
+ * `Documents`, `.config`):
+ *   prefix="~"         → expanded="/Users/alice" (exists as dir)
+ *                        → children of /Users/alice/  ["projects","proj-old","Documents"]
+ *   prefix="~/pro"     → expanded="/Users/alice/pro" (does NOT exist)
+ *                        → starts-with "pro" in /Users/alice/  ["projects","proj-old"]
+ *   prefix="~/projects/" → expanded="/Users/alice/projects/" (exists as dir)
+ *                        → children of /Users/alice/projects/
+ *   prefix="~/projects/sr" → expanded="/Users/alice/projects/sr" (does NOT exist)
+ *                        → starts-with "sr" in /Users/alice/projects/
+ */
+export declare function handlePathAutocomplete(prefix: string): PathAutocompleteResult;
+//# sourceMappingURL=paths-autocomplete.d.ts.map

package/dist/server/handlers/paths-autocomplete.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"paths-autocomplete.d.ts","sourceRoot":"","sources":["../../../src/server/handlers/paths-autocomplete.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AAMH,MAAM,WAAW,sBAAsB;IACrC,WAAW,EAAE,MAAM,EAAE,CAAC;IACtB,cAAc,EAAE,MAAM,CAAC;CACxB;AAgCD;;;;;;;;;;;;;GAaG;AACH,wBAAgB,sBAAsB,CAAC,MAAM,EAAE,MAAM,GAAG,sBAAsB,CA+B7E"}

package/dist/server/handlers/projects.d.ts

@@ -0,0 +1,58 @@
+/**
+ * Pure REST handlers for `/api/projects/*`.
+ *
+ * Extracted from the deleted Hono `routes.ts` so the relay envelope dispatcher
+ * (Batch 3) can call them with a parsed payload instead of a Hono context.
+ *
+ * Contract:
+ *  - Inputs are already-parsed JSON objects (or `unknown` shapes the handler
+ *    validates). The dispatcher upstream parses the relay envelope body.
+ *  - Outputs are the wire shapes the landing client already expects, so the
+ *    Batch 3 dispatcher can JSON-stringify them straight into the response
+ *    envelope without remapping.
+ *  - Errors are thrown as typed `HandlerError` subclasses; the dispatcher
+ *    maps `BAD_REQUEST` → 400-equivalent and `NOT_FOUND` → 404-equivalent.
+ *  - Stream teardown on project delete is the caller's responsibility — the
+ *    handler returns the cascaded session ids so the dispatcher can hand
+ *    them to `SessionStreamManager.disposeProjectStreams` BEFORE the SQL
+ *    cascade has already torn down (in our model the cascade has already
+ *    happened by the time we return; that's intentional and matches the
+ *    old route's ordering — the manager is best-effort cleanup).
+ */
+import type { SessionStore } from "../storage.js";
+import type { WireProject, WireSessionSummary } from "../wire.js";
+export interface CreateProjectInputRaw {
+    name?: unknown;
+    path?: unknown;
+}
+export interface UpdateProjectInputRaw {
+    name?: unknown;
+    path?: unknown;
+}
+export declare function handleListProjects(store: SessionStore): WireProject[];
+export declare function handleCreateProject(store: SessionStore, body: CreateProjectInputRaw): WireProject;
+export declare function handleGetProject(store: SessionStore, id: string): WireProject;
+export declare function handleUpdateProject(store: SessionStore, id: string, body: UpdateProjectInputRaw): WireProject;
+export interface DeleteProjectResult {
+    /** Session ids that belonged to the project (cascade-deleted). */
+    sessionIds: string[];
+}
+export declare function handleDeleteProject(store: SessionStore, id: string): DeleteProjectResult;
+export interface BindStudioInputRaw {
+    studioProjectId?: unknown;
+    studioTeamId?: unknown;
+    studioProjectName?: unknown;
+}
+export interface BindStudioResult {
+    project: WireProject;
+    studioProjectId: string;
+    studioProjectName: string;
+    studioTeamId?: string;
+}
+/**
+ * Bind a local project directory to an Aexol Studio project by writing
+ * `.aexol/aexol.jsonc` into the project's filesystem path.
+ */
+export declare function handleBindStudioProject(store: SessionStore, id: string, body: BindStudioInputRaw): Promise<BindStudioResult>;
+export declare function handleListSessionsByProject(store: SessionStore, id: string): WireSessionSummary[];
+//# sourceMappingURL=projects.d.ts.map

package/dist/server/handlers/projects.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"projects.d.ts","sourceRoot":"","sources":["../../../src/server/handlers/projects.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;GAoBG;AAGH,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,eAAe,CAAC;AAClD,OAAO,KAAK,EAAE,WAAW,EAAE,kBAAkB,EAAE,MAAM,YAAY,CAAC;AAIlE,MAAM,WAAW,qBAAqB;IACpC,IAAI,CAAC,EAAE,OAAO,CAAC;IACf,IAAI,CAAC,EAAE,OAAO,CAAC;CAChB;AAED,MAAM,WAAW,qBAAqB;IACpC,IAAI,CAAC,EAAE,OAAO,CAAC;IACf,IAAI,CAAC,EAAE,OAAO,CAAC;CAChB;AAED,wBAAgB,kBAAkB,CAAC,KAAK,EAAE,YAAY,GAAG,WAAW,EAAE,CAErE;AAED,wBAAgB,mBAAmB,CACjC,KAAK,EAAE,YAAY,EACnB,IAAI,EAAE,qBAAqB,GAC1B,WAAW,CAYb;AAED,wBAAgB,gBAAgB,CAAC,KAAK,EAAE,YAAY,EAAE,EAAE,EAAE,MAAM,GAAG,WAAW,CAI7E;AAED,wBAAgB,mBAAmB,CACjC,KAAK,EAAE,YAAY,EACnB,EAAE,EAAE,MAAM,EACV,IAAI,EAAE,qBAAqB,GAC1B,WAAW,CAwBb;AAED,MAAM,WAAW,mBAAmB;IAClC,kEAAkE;IAClE,UAAU,EAAE,MAAM,EAAE,CAAC;CACtB;AAED,wBAAgB,mBAAmB,CACjC,KAAK,EAAE,YAAY,EACnB,EAAE,EAAE,MAAM,GACT,mBAAmB,CAMrB;AAED,MAAM,WAAW,kBAAkB;IACjC,eAAe,CAAC,EAAE,OAAO,CAAC;IAC1B,YAAY,CAAC,EAAE,OAAO,CAAC;IACvB,iBAAiB,CAAC,EAAE,OAAO,CAAC;CAC7B;AAED,MAAM,WAAW,gBAAgB;IAC/B,OAAO,EAAE,WAAW,CAAC;IACrB,eAAe,EAAE,MAAM,CAAC;IACxB,iBAAiB,EAAE,MAAM,CAAC;IAC1B,YAAY,CAAC,EAAE,MAAM,CAAC;CACvB;AAED;;;GAGG;AACH,wBAAsB,uBAAuB,CAC3C,KAAK,EAAE,YAAY,EACnB,EAAE,EAAE,MAAM,EACV,IAAI,EAAE,kBAAkB,GACvB,OAAO,CAAC,gBAAgB,CAAC,CAoC3B;AAED,wBAAgB,2BAA2B,CACzC,KAAK,EAAE,YAAY,EACnB,EAAE,EAAE,MAAM,GACT,kBAAkB,EAAE,CAItB"}

package/dist/server/handlers/queue.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Pure REST handlers for `/api/sessions/:sessionId/queue/*`.
+ *
+ * Same contract as sessions/projects handlers — pure functions that take
+ * `store` + `manager` dependencies, throw `BadRequestError`/`NotFoundError`
+ * on invalid input, and return typed responses.
+ *
+ * After mutating the queue, each handler calls `manager.pushQueueState()`
+ * to broadcast the updated queue to all subscribers via `queue_changed`.
+ */
+import type { SessionStreamManager } from "../session-stream.js";
+import type { SessionStore } from "../storage.js";
+export interface EnqueuePromptInputRaw {
+    content?: unknown;
+}
+/** Wire shape for a single queue item returned to the frontend. */
+export interface WireQueueItem {
+    id: string;
+    content: string;
+    position: number;
+    createdAt: string;
+}
+export declare function handleEnqueuePrompt(store: SessionStore, manager: SessionStreamManager, sessionId: string, body: EnqueuePromptInputRaw): WireQueueItem;
+export declare function handleGetPromptQueue(store: SessionStore, sessionId: string): WireQueueItem[];
+export declare function handleRemovePrompt(store: SessionStore, manager: SessionStreamManager, sessionId: string, itemId: string): void;
+export declare function handleClearPromptQueue(store: SessionStore, manager: SessionStreamManager, sessionId: string): void;
+//# sourceMappingURL=queue.d.ts.map

package/dist/server/handlers/queue.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"queue.d.ts","sourceRoot":"","sources":["../../../src/server/handlers/queue.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAEH,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,sBAAsB,CAAC;AACjE,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,eAAe,CAAC;AAGlD,MAAM,WAAW,qBAAqB;IACpC,OAAO,CAAC,EAAE,OAAO,CAAC;CACnB;AAED,mEAAmE;AACnE,MAAM,WAAW,aAAa;IAC5B,EAAE,EAAE,MAAM,CAAC;IACX,OAAO,EAAE,MAAM,CAAC;IAChB,QAAQ,EAAE,MAAM,CAAC;IACjB,SAAS,EAAE,MAAM,CAAC;CACnB;AAED,wBAAgB,mBAAmB,CACjC,KAAK,EAAE,YAAY,EACnB,OAAO,EAAE,oBAAoB,EAC7B,SAAS,EAAE,MAAM,EACjB,IAAI,EAAE,qBAAqB,GAC1B,aAAa,CAgBf;AAED,wBAAgB,oBAAoB,CAClC,KAAK,EAAE,YAAY,EACnB,SAAS,EAAE,MAAM,GAChB,aAAa,EAAE,CAUjB;AAED,wBAAgB,kBAAkB,CAChC,KAAK,EAAE,YAAY,EACnB,OAAO,EAAE,oBAAoB,EAC7B,SAAS,EAAE,MAAM,EACjB,MAAM,EAAE,MAAM,GACb,IAAI,CAMN;AAED,wBAAgB,sBAAsB,CACpC,KAAK,EAAE,YAAY,EACnB,OAAO,EAAE,oBAAoB,EAC7B,SAAS,EAAE,MAAM,GAChB,IAAI,CAMN"}