@revealui/harnesses 0.1.0 → 0.1.3

package/dist/content/index.d.ts

@@ -0,0 +1,231 @@
+import { z } from 'zod';
+
+interface ResolverContext {
+    projectRoot: string;
+    projectName?: string;
+    phase?: string;
+    packageManager?: string;
+    nodeVersion?: string;
+}
+type ResolverFn = (ctx: ResolverContext) => string;
+
+declare const AgentSchema: z.ZodObject<{
+    id: z.ZodString;
+    name: z.ZodString;
+    description: z.ZodString;
+    tier: z.ZodDefault<z.ZodEnum<{
+        oss: "oss";
+        pro: "pro";
+    }>>;
+    isolation: z.ZodDefault<z.ZodEnum<{
+        worktree: "worktree";
+        none: "none";
+    }>>;
+    tools: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    content: z.ZodString;
+}, z.core.$strip>;
+type Agent = z.infer<typeof AgentSchema>;
+
+declare const CommandSchema: z.ZodObject<{
+    id: z.ZodString;
+    name: z.ZodString;
+    description: z.ZodString;
+    tier: z.ZodDefault<z.ZodEnum<{
+        oss: "oss";
+        pro: "pro";
+    }>>;
+    disableModelInvocation: z.ZodDefault<z.ZodBoolean>;
+    argumentHint: z.ZodOptional<z.ZodString>;
+    content: z.ZodString;
+}, z.core.$strip>;
+type Command = z.infer<typeof CommandSchema>;
+
+declare const ManifestSchema: z.ZodObject<{
+    version: z.ZodLiteral<1>;
+    generatedAt: z.ZodString;
+    rules: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        name: z.ZodString;
+        description: z.ZodString;
+        scope: z.ZodEnum<{
+            global: "global";
+            project: "project";
+        }>;
+        preambleTier: z.ZodDefault<z.ZodNumber>;
+        tier: z.ZodDefault<z.ZodEnum<{
+            oss: "oss";
+            pro: "pro";
+        }>>;
+        tags: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        content: z.ZodString;
+    }, z.core.$strip>>;
+    commands: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        name: z.ZodString;
+        description: z.ZodString;
+        tier: z.ZodDefault<z.ZodEnum<{
+            oss: "oss";
+            pro: "pro";
+        }>>;
+        disableModelInvocation: z.ZodDefault<z.ZodBoolean>;
+        argumentHint: z.ZodOptional<z.ZodString>;
+        content: z.ZodString;
+    }, z.core.$strip>>;
+    agents: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        name: z.ZodString;
+        description: z.ZodString;
+        tier: z.ZodDefault<z.ZodEnum<{
+            oss: "oss";
+            pro: "pro";
+        }>>;
+        isolation: z.ZodDefault<z.ZodEnum<{
+            worktree: "worktree";
+            none: "none";
+        }>>;
+        tools: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        content: z.ZodString;
+    }, z.core.$strip>>;
+    skills: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        name: z.ZodString;
+        description: z.ZodString;
+        tier: z.ZodDefault<z.ZodEnum<{
+            oss: "oss";
+            pro: "pro";
+        }>>;
+        disableModelInvocation: z.ZodDefault<z.ZodBoolean>;
+        skipFrontmatter: z.ZodDefault<z.ZodBoolean>;
+        filePatterns: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        bashPatterns: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        references: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodString>>;
+        content: z.ZodString;
+    }, z.core.$strip>>;
+    preambles: z.ZodArray<z.ZodObject<{
+        tier: z.ZodNumber;
+        name: z.ZodString;
+        description: z.ZodString;
+        ruleIds: z.ZodArray<z.ZodString>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+type Manifest = z.infer<typeof ManifestSchema>;
+
+declare const PreambleTierSchema: z.ZodObject<{
+    tier: z.ZodNumber;
+    name: z.ZodString;
+    description: z.ZodString;
+    ruleIds: z.ZodArray<z.ZodString>;
+}, z.core.$strip>;
+type PreambleTier = z.infer<typeof PreambleTierSchema>;
+
+declare const RuleSchema: z.ZodObject<{
+    id: z.ZodString;
+    name: z.ZodString;
+    description: z.ZodString;
+    scope: z.ZodEnum<{
+        global: "global";
+        project: "project";
+    }>;
+    preambleTier: z.ZodDefault<z.ZodNumber>;
+    tier: z.ZodDefault<z.ZodEnum<{
+        oss: "oss";
+        pro: "pro";
+    }>>;
+    tags: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    content: z.ZodString;
+}, z.core.$strip>;
+type Rule = z.infer<typeof RuleSchema>;
+
+declare const SkillSchema: z.ZodObject<{
+    id: z.ZodString;
+    name: z.ZodString;
+    description: z.ZodString;
+    tier: z.ZodDefault<z.ZodEnum<{
+        oss: "oss";
+        pro: "pro";
+    }>>;
+    disableModelInvocation: z.ZodDefault<z.ZodBoolean>;
+    skipFrontmatter: z.ZodDefault<z.ZodBoolean>;
+    filePatterns: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    bashPatterns: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    references: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodString>>;
+    content: z.ZodString;
+}, z.core.$strip>;
+type Skill = z.infer<typeof SkillSchema>;
+
+interface GeneratedFile {
+    /** Relative path from project root (e.g. '.claude/rules/biome.md') */
+    relativePath: string;
+    content: string;
+}
+interface DiffEntry {
+    relativePath: string;
+    status: 'added' | 'modified' | 'deleted' | 'unchanged';
+    expected?: string;
+    actual?: string;
+}
+interface ContentGenerator {
+    readonly id: string;
+    readonly outputDir: string;
+    generateRule(rule: Rule, ctx: ResolverContext): GeneratedFile[];
+    generateCommand(cmd: Command, ctx: ResolverContext): GeneratedFile[];
+    generateAgent(agent: Agent, ctx: ResolverContext): GeneratedFile[];
+    generateSkill(skill: Skill, ctx: ResolverContext): GeneratedFile[];
+    generateAll(manifest: Manifest, ctx: ResolverContext): GeneratedFile[];
+}
+
+/** Build a complete manifest from all canonical definitions. */
+declare function buildManifest(): Manifest;
+
+/** Get a generator by ID. */
+declare function getGenerator(id: string): ContentGenerator | undefined;
+/** Register a custom generator. */
+declare function registerGenerator(generator: ContentGenerator): void;
+/** List all registered generator IDs. */
+declare function listGenerators(): string[];
+
+/** Register a custom resolver. Overwrites existing entries with the same key. */
+declare function registerResolver(key: string, fn: ResolverFn): void;
+/** Resolve all `{{PLACEHOLDER}}` markers in a string using the resolver registry. */
+declare function resolveTemplate(template: string, ctx: ResolverContext): string;
+/** List all registered resolver keys. */
+declare function listResolvers(): string[];
+
+/**
+ * @revealui/harnesses/content — Canonical Content Layer
+ *
+ * Tool-agnostic definitions for AI guidance content (rules, commands, agents, skills).
+ * Generators produce tool-specific output (Claude Code, Cursor, etc.) from canonical definitions.
+ *
+ * @example
+ * ```ts
+ * import { buildManifest, validateManifest, generateContent, diffContent } from '@revealui/harnesses/content';
+ *
+ * const manifest = buildManifest();
+ * const validation = validateManifest(manifest);
+ * const files = generateContent('claude-code', manifest, { projectRoot: '/path/to/project' });
+ * ```
+ */
+
+interface ValidationResult {
+    valid: boolean;
+    errors: string[];
+}
+interface ContentSummary {
+    rules: number;
+    commands: number;
+    agents: number;
+    skills: number;
+    preambles: number;
+    total: number;
+}
+/** Validate a manifest object against the Zod schema. */
+declare function validateManifest(manifest: unknown): ValidationResult;
+/** Generate content files for a specific generator. */
+declare function generateContent(generatorId: string, manifest: Manifest, ctx: ResolverContext): GeneratedFile[];
+/** Compare generated content against existing files on disk. */
+declare function diffContent(generatorId: string, manifest: Manifest, ctx: ResolverContext, projectRoot: string): DiffEntry[];
+/** Get a summary of all content in the manifest. */
+declare function listContent(manifest?: Manifest): ContentSummary;
+
+export { type Agent, AgentSchema, type Command, CommandSchema, type ContentGenerator, type ContentSummary, type DiffEntry, type GeneratedFile, type Manifest, ManifestSchema, type PreambleTier, PreambleTierSchema, type ResolverContext, type ResolverFn, type Rule, RuleSchema, type Skill, SkillSchema, type ValidationResult, buildManifest, diffContent, generateContent, getGenerator, listContent, listGenerators, listResolvers, registerGenerator, registerResolver, resolveTemplate, validateManifest };

package/dist/content/index.js

@@ -0,0 +1,40 @@
+import {
+  AgentSchema,
+  CommandSchema,
+  ManifestSchema,
+  PreambleTierSchema,
+  RuleSchema,
+  SkillSchema,
+  buildManifest,
+  diffContent,
+  generateContent,
+  getGenerator,
+  listContent,
+  listGenerators,
+  listResolvers,
+  registerGenerator,
+  registerResolver,
+  resolveTemplate,
+  validateManifest
+} from "../chunk-JDI6B2IB.js";
+import "../chunk-DGUM43GV.js";
+export {
+  AgentSchema,
+  CommandSchema,
+  ManifestSchema,
+  PreambleTierSchema,
+  RuleSchema,
+  SkillSchema,
+  buildManifest,
+  diffContent,
+  generateContent,
+  getGenerator,
+  listContent,
+  listGenerators,
+  listResolvers,
+  registerGenerator,
+  registerResolver,
+  resolveTemplate,
+  validateManifest
+};
+//# sourceMappingURL=index.js.map

package/dist/content/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}

package/dist/index.d.ts

@@ -1,132 +1,8 @@
+import { HarnessAdapter, HarnessCapabilities, HarnessInfo, HarnessCommand, HarnessCommandResult, HarnessEvent, ConfigDiffEntry, ConfigSyncDirection, ConfigSyncResult, HealthCheckResult, HarnessProcessInfo } from './types/index.js';
+export { Agent, Command, ContentGenerator, ContentSummary, DiffEntry, GeneratedFile, Manifest, PreambleTier, ResolverContext, Rule, Skill, ValidationResult, buildManifest, diffContent, generateContent, listContent, validateManifest } from './content/index.js';
 import { WorkboardManager } from './workboard/index.js';
-export { ConflictResult, SessionType, WorkboardEntry, WorkboardSession, WorkboardState, deriveSessionId, detectSessionType } from './workboard/index.js';
-
-/**
- * Core types for the AI harness integration system.
- * Mirrors packages/editors/src/types/core.ts for the harness domain.
- */
-interface HarnessCapabilities {
-    /** Can generate code from a prompt */
-    generateCode: boolean;
-    /** Can analyze/explain existing code */
-    analyzeCode: boolean;
-    /** Can apply inline code edits */
-    applyEdit: boolean;
-    /** Can sync configuration files */
-    applyConfig: boolean;
-    /** Can query workboard state */
-    readWorkboard: boolean;
-    /** Can write workboard state */
-    writeWorkboard: boolean;
-}
-type ConfigSyncDirection = 'push' | 'pull';
-type HarnessCommand = {
-    type: 'generate-code';
-    prompt: string;
-    context?: string;
-    language?: string;
-} | {
-    type: 'analyze-code';
-    filePath: string;
-    question?: string;
-} | {
-    type: 'apply-edit';
-    filePath: string;
-    diff: string;
-} | {
-    type: 'apply-config';
-    configPath: string;
-    content: string;
-} | {
-    type: 'get-status';
-} | {
-    type: 'get-running-instances';
-} | {
-    type: 'sync-config';
-    direction: ConfigSyncDirection;
-} | {
-    type: 'diff-config';
-} | {
-    type: 'read-workboard';
-} | {
-    type: 'update-workboard';
-    sessionId: string;
-    task?: string;
-    files?: string[];
-};
-interface HarnessCommandResult {
-    success: boolean;
-    command: HarnessCommand['type'];
-    message?: string;
-    data?: unknown;
-}
-type HarnessEvent = {
-    type: 'harness-connected';
-    harnessId: string;
-} | {
-    type: 'harness-disconnected';
-    harnessId: string;
-} | {
-    type: 'generation-started';
-    taskId: string;
-} | {
-    type: 'generation-completed';
-    taskId: string;
-    output: string;
-} | {
-    type: 'error';
-    harnessId: string;
-    message: string;
-};
-interface HarnessInfo {
-    id: string;
-    name: string;
-    version?: string;
-    capabilities: HarnessCapabilities;
-}
-interface HarnessProcessInfo {
-    pid: number;
-    command: string;
-    harnessId: string;
-}
-interface ConfigSyncResult {
-    success: boolean;
-    harnessId: string;
-    direction: ConfigSyncDirection;
-    message?: string;
-}
-interface ConfigDiffEntry {
-    harnessId: string;
-    localExists: boolean;
-    ssdExists: boolean;
-    identical: boolean;
-}
-
-/**
- * Contract every AI harness adapter must satisfy.
- * Mirrors EditorAdapter from packages/editors.
- *
- * AI tools are external executables — never linked libraries.
- * Communication is data-only: commands in, results out.
- */
-interface HarnessAdapter {
-    /** Unique stable identifier, e.g. "claude-code", "cursor", "copilot" */
-    readonly id: string;
-    /** Human-readable display name */
-    readonly name: string;
-    /** Returns the static capability set for this harness */
-    getCapabilities(): HarnessCapabilities;
-    /** Returns live info (version, etc.) — may shell out */
-    getInfo(): Promise<HarnessInfo>;
-    /** True if the harness executable is on PATH and accessible */
-    isAvailable(): Promise<boolean>;
-    /** Execute a typed command against this harness */
-    execute(command: HarnessCommand): Promise<HarnessCommandResult>;
-    /** Subscribe to harness events; returns an unsubscribe function */
-    onEvent(handler: (event: HarnessEvent) => void): () => void;
-    /** Release all resources held by this adapter */
-    dispose(): Promise<void>;
-}
+export { ConflictResult, SessionType, WorkboardEntry, WorkboardSession, WorkboardState, acquireLock, atomicWriteSync, deriveSessionId, detectSessionType, lockPathFor, releaseLock, withLock, withLockAsync } from './workboard/index.js';
+import 'zod';
 
 /**
  * Adapter for Anthropic Claude Code (CLI: `claude`).
@@ -147,42 +23,67 @@ declare class ClaudeCodeAdapter implements HarnessAdapter {
     getCapabilities(): HarnessCapabilities;
     getInfo(): Promise<HarnessInfo>;
     isAvailable(): Promise<boolean>;
+    notifyRegistered(): void;
+    notifyUnregistering(): void;
     execute(command: HarnessCommand): Promise<HarnessCommandResult>;
+    private executeInner;
     onEvent(handler: (event: HarnessEvent) => void): () => void;
     dispose(): Promise<void>;
+    private emit;
 }
 
 /**
- * Stub adapter for GitHub Copilot.
+ * Adapter for Cursor IDE.
  *
- * Copilot has no standalone CLI — it runs as a VS Code extension.
- * This adapter is a stub for future integration once Copilot exposes
- * a programmatic interface.
+ * Cursor is a VS Code fork with built-in AI capabilities.
+ * This adapter detects Cursor via `cursor --version` and provides
+ * workboard read/write when REVEALUI_WORKBOARD_PATH is set.
  */
-declare class CopilotAdapter implements HarnessAdapter {
-    readonly id = "copilot";
-    readonly name = "GitHub Copilot";
+declare class CursorAdapter implements HarnessAdapter {
+    readonly id = "cursor";
+    readonly name = "Cursor";
     private readonly eventHandlers;
+    private readonly workboardPath;
+    constructor(workboardPath?: string);
     getCapabilities(): HarnessCapabilities;
     getInfo(): Promise<HarnessInfo>;
     isAvailable(): Promise<boolean>;
+    notifyRegistered(): void;
+    notifyUnregistering(): void;
     execute(command: HarnessCommand): Promise<HarnessCommandResult>;
+    private executeInner;
     onEvent(handler: (event: HarnessEvent) => void): () => void;
     dispose(): Promise<void>;
+    private emit;
 }
 
 /**
- * Syncs harness config between local filesystem and SSD backup.
+ * Syncs harness config between local filesystem and root backup.
  * Mirrors config-sync.ts from packages/editors.
  */
-declare function syncConfig(harnessId: string, direction: ConfigSyncDirection, ssdBase?: string): ConfigSyncResult;
-/** Compares local vs SSD config for a harness. */
-declare function diffConfig(harnessId: string, ssdBase?: string): ConfigDiffEntry;
+declare function syncConfig(harnessId: string, direction: ConfigSyncDirection, root?: string): ConfigSyncResult;
+/** Compares local vs root config for a harness. */
+declare function diffConfig(harnessId: string, root?: string): ConfigDiffEntry;
+/**
+ * Sync all known harness configs in a given direction.
+ * Returns results for each harness.
+ */
+declare function syncAllConfigs(direction: ConfigSyncDirection, root?: string): ConfigSyncResult[];
+/**
+ * Diff all known harness configs.
+ * Returns diff entries for each harness.
+ */
+declare function diffAllConfigs(root?: string): ConfigDiffEntry[];
+/**
+ * Validate that a config file contains parseable JSON.
+ * Returns null if valid, or an error message if invalid.
+ */
+declare function validateConfigJson(harnessId: string): string | null;
 
 /** Returns the local config file path for a given harness id, or undefined if unknown. */
 declare function getLocalConfigPath(harnessId: string): string | undefined;
-/** Returns the SSD config file path for a given harness id, or undefined if unknown. */
-declare function getSsdConfigPath(harnessId: string, ssdBase?: string): string | undefined;
+/** Returns the root config file path for a given harness id, or undefined if unknown. */
+declare function getRootConfigPath(harnessId: string, root?: string): string | undefined;
 /** Returns ids of all harnesses with known config paths. */
 declare function getConfigurableHarnesses(): string[];
 
@@ -242,6 +143,8 @@ declare class HarnessCoordinator {
     getWorkboard(): WorkboardManager;
     /** Register a custom adapter (must be called before start()). */
     registerAdapter(adapter: HarnessAdapter): void;
+    /** Run a health check across all registered harnesses and the workboard. */
+    healthCheck(): Promise<HealthCheckResult>;
 }
 
 /**
@@ -276,14 +179,18 @@ declare function findClaudeCodeSockets(): Promise<string[]>;
  *   harness.listRunning       → HarnessProcessInfo[]
  *   harness.syncConfig        → ConfigSyncResult
  *   harness.diffConfig        → ConfigDiffEntry
+ *   harness.health            → HealthCheckResult
  */
 declare class RpcServer {
     private readonly registry;
     private readonly socketPath;
     private server;
+    private healthCheckFn;
     constructor(registry: HarnessRegistry, socketPath: string);
     private handleLine;
     private dispatch;
+    /** Set the health check function (called by coordinator after construction). */
+    setHealthCheck(fn: () => Promise<unknown>): void;
     start(): Promise<void>;
     stop(): Promise<void>;
 }
@@ -292,14 +199,14 @@ declare class RpcServer {
  * @revealui/harnesses — AI Harness Integration System (Server-side)
  *
  * Adapters, registry, workboard coordination, and JSON-RPC server for
- * integrating AI coding tools (Claude Code, Cursor, Copilot) into the
+ * integrating AI coding tools (Claude Code, Cursor) into the
  * RevealUI development workflow.
  *
- * Pro tier feature: gated behind isFeatureEnabled("harnesses").
+ * Pro tier feature: gated behind isFeatureEnabled("ai").
  *
  * @packageDocumentation
  */
 /** Check whether the harnesses feature is licensed for this installation. */
 declare function checkHarnessesLicense(): Promise<boolean>;
 
-export { ClaudeCodeAdapter, type ConfigDiffEntry, type ConfigSyncDirection, type ConfigSyncResult, type CoordinatorOptions, CopilotAdapter, type HarnessAdapter, type HarnessCapabilities, type HarnessCommand, type HarnessCommandResult, HarnessCoordinator, type HarnessEvent, type HarnessInfo, type HarnessProcessInfo, HarnessRegistry, RpcServer, WorkboardManager, autoDetectHarnesses, checkHarnessesLicense, diffConfig, findAllHarnessProcesses, findClaudeCodeSockets, findHarnessProcesses, findProcesses, getConfigurableHarnesses, getLocalConfigPath, getSsdConfigPath, syncConfig };
+export { ClaudeCodeAdapter, ConfigDiffEntry, ConfigSyncDirection, ConfigSyncResult, type CoordinatorOptions, CursorAdapter, HarnessAdapter, HarnessCapabilities, HarnessCommand, HarnessCommandResult, HarnessCoordinator, HarnessEvent, HarnessInfo, HarnessProcessInfo, HarnessRegistry, HealthCheckResult, RpcServer, WorkboardManager, autoDetectHarnesses, checkHarnessesLicense, diffAllConfigs, diffConfig, findAllHarnessProcesses, findClaudeCodeSockets, findHarnessProcesses, findProcesses, getConfigurableHarnesses, getLocalConfigPath, getRootConfigPath, syncAllConfigs, syncConfig, validateConfigJson };

package/dist/index.js

@@ -1,10 +1,12 @@
 import {
   ClaudeCodeAdapter,
-  CopilotAdapter,
+  CursorAdapter,
   HarnessCoordinator,
   HarnessRegistry,
   RpcServer,
   autoDetectHarnesses,
+  checkHarnessesLicense,
+  diffAllConfigs,
   diffConfig,
   findAllHarnessProcesses,
   findClaudeCodeSockets,
@@ -12,50 +14,63 @@ import {
   findProcesses,
   getConfigurableHarnesses,
   getLocalConfigPath,
-  getSsdConfigPath,
-  syncConfig
-} from "./chunk-BDA7D725.js";
-import "./chunk-JUNNIQS3.js";
+  getRootConfigPath,
+  syncAllConfigs,
+  syncConfig,
+  validateConfigJson
+} from "./chunk-HH2PJYQN.js";
+import {
+  buildManifest,
+  diffContent,
+  generateContent,
+  listContent,
+  validateManifest
+} from "./chunk-JDI6B2IB.js";
 import {
   WorkboardManager,
+  acquireLock,
+  atomicWriteSync,
   deriveSessionId,
-  detectSessionType
-} from "./chunk-PG4RAOWS.js";
-
-// src/index.ts
-import { isFeatureEnabled } from "@revealui/core/features";
-import { initializeLicense } from "@revealui/core/license";
-import { logger } from "@revealui/core/observability/logger";
-async function checkHarnessesLicense() {
-  await initializeLicense();
-  if (!isFeatureEnabled("harnesses")) {
-    logger.warn(
-      "[@revealui/harnesses] AI harness integration requires a Pro or Enterprise license. Visit https://revealui.com/pricing for details.",
-      { feature: "harnesses" }
-    );
-    return false;
-  }
-  return true;
-}
+  detectSessionType,
+  lockPathFor,
+  releaseLock,
+  withLock,
+  withLockAsync
+} from "./chunk-FJGN6DTH.js";
+import "./chunk-DGUM43GV.js";
 export {
   ClaudeCodeAdapter,
-  CopilotAdapter,
+  CursorAdapter,
   HarnessCoordinator,
   HarnessRegistry,
   RpcServer,
   WorkboardManager,
+  acquireLock,
+  atomicWriteSync,
   autoDetectHarnesses,
+  buildManifest,
   checkHarnessesLicense,
   deriveSessionId,
   detectSessionType,
+  diffAllConfigs,
   diffConfig,
+  diffContent,
   findAllHarnessProcesses,
   findClaudeCodeSockets,
   findHarnessProcesses,
   findProcesses,
+  generateContent,
   getConfigurableHarnesses,
   getLocalConfigPath,
-  getSsdConfigPath,
-  syncConfig
+  getRootConfigPath,
+  listContent,
+  lockPathFor,
+  releaseLock,
+  syncAllConfigs,
+  syncConfig,
+  validateConfigJson,
+  validateManifest,
+  withLock,
+  withLockAsync
 };
 //# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../src/index.ts"],"sourcesContent":["/**\n * @revealui/harnesses — AI Harness Integration System (Server-side)\n *\n * Adapters, registry, workboard coordination, and JSON-RPC server for\n * integrating AI coding tools (Claude Code, Cursor, Copilot) into the\n * RevealUI development workflow.\n *\n * Pro tier feature: gated behind isFeatureEnabled(\"harnesses\").\n *\n * @packageDocumentation\n */\n\nimport { isFeatureEnabled } from '@revealui/core/features'\nimport { initializeLicense } from '@revealui/core/license'\nimport { logger } from '@revealui/core/observability/logger'\n\n/** Check whether the harnesses feature is licensed for this installation. */\nexport async function checkHarnessesLicense(): Promise<boolean> {\n  await initializeLicense()\n  if (!isFeatureEnabled('harnesses')) {\n    logger.warn(\n      '[@revealui/harnesses] AI harness integration requires a Pro or Enterprise license. ' +\n        'Visit https://revealui.com/pricing for details.',\n      { feature: 'harnesses' },\n    )\n    return false\n  }\n  return true\n}\n\n// Adapters\nexport { ClaudeCodeAdapter } from './adapters/claude-code-adapter.js'\nexport { CopilotAdapter } from './adapters/copilot-adapter.js'\n\n// Config\nexport { diffConfig, syncConfig } from './config/config-sync.js'\nexport {\n  getConfigurableHarnesses,\n  getLocalConfigPath,\n  getSsdConfigPath,\n} from './config/harness-config-paths.js'\nexport type { CoordinatorOptions } from './coordinator.js'\n// Coordinator\nexport { HarnessCoordinator } from './coordinator.js'\n\n// Detection\nexport { autoDetectHarnesses } from './detection/auto-detector.js'\nexport {\n  findAllHarnessProcesses,\n  findClaudeCodeSockets,\n  findHarnessProcesses,\n  findProcesses,\n} from './detection/process-detector.js'\n\n// Registry\nexport { HarnessRegistry } from './registry/harness-registry.js'\n\n// Server\nexport { RpcServer } from './server/rpc-server.js'\nexport type { HarnessAdapter } from './types/adapter.js'\n\n// Types — harness core\nexport type {\n  ConfigDiffEntry,\n  ConfigSyncDirection,\n  ConfigSyncResult,\n  HarnessCapabilities,\n  HarnessCommand,\n  HarnessCommandResult,\n  HarnessEvent,\n  HarnessInfo,\n  HarnessProcessInfo,\n} from './types/core.js'\n// Workboard\nexport {\n  deriveSessionId,\n  detectSessionType,\n  WorkboardManager,\n} from './workboard/index.js'\n// Types — session identity\nexport type { SessionType } from './workboard/session-identity.js'\n// Types — workboard protocol\nexport type {\n  ConflictResult,\n  WorkboardEntry,\n  WorkboardSession,\n  WorkboardState,\n} from './workboard/workboard-protocol.js'\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;AAYA,SAAS,wBAAwB;AACjC,SAAS,yBAAyB;AAClC,SAAS,cAAc;AAGvB,eAAsB,wBAA0C;AAC9D,QAAM,kBAAkB;AACxB,MAAI,CAAC,iBAAiB,WAAW,GAAG;AAClC,WAAO;AAAA,MACL;AAAA,MAEA,EAAE,SAAS,YAAY;AAAA,IACzB;AACA,WAAO;AAAA,EACT;AACA,SAAO;AACT;","names":[]}
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}