clawvault 2.3.0 → 2.3.1

package/dist/index.js

@@ -2,6 +2,39 @@ import {
   registerSyncBdCommand,
   syncBdCommand
 } from "./chunk-MGDEINGP.js";
+import {
+  registerTailscaleCommands,
+  registerTailscaleDiscoverCommand,
+  registerTailscaleServeCommand,
+  registerTailscaleStatusCommand,
+  registerTailscaleSyncCommand,
+  tailscaleDiscoverCommand,
+  tailscaleServeCommand,
+  tailscaleStatusCommand,
+  tailscaleSyncCommand
+} from "./chunk-NZ4ZZNSR.js";
+import {
+  CLAWVAULT_SERVE_PATH,
+  DEFAULT_SERVE_PORT,
+  checkPeerClawVault,
+  compareManifests,
+  configureTailscaleServe,
+  discoverClawVaultPeers,
+  fetchRemoteFile,
+  fetchRemoteManifest,
+  findPeer,
+  generateVaultManifest,
+  getOnlinePeers,
+  getTailscaleStatus,
+  getTailscaleVersion,
+  hasTailscale,
+  pushFileToRemote,
+  resolvePeerIP,
+  serveVault,
+  stopTailscaleServe,
+  syncWithPeer
+} from "./chunk-4GBPTBFJ.js";
+import "./chunk-CLE2HHNT.js";
 import {
   buildTemplateVariables,
   renderTemplate
@@ -9,11 +42,11 @@ import {
 import {
   reflectCommand,
   registerReflectCommand
-} from "./chunk-GJEGPO7U.js";
+} from "./chunk-TT3FXYCN.js";
 import {
   registerReplayCommand,
   replayCommand
-} from "./chunk-6BBTI7NV.js";
+} from "./chunk-RARDNTUP.js";
 import {
   buildSessionRecap,
   formatSessionRecapMarkdown,
@@ -24,7 +57,7 @@ import {
 } from "./chunk-W463YRED.js";
 import {
   runReflection
-} from "./chunk-GQVYQCY5.js";
+} from "./chunk-JVAWKNIZ.js";
 import {
   graphCommand,
   graphSummary
@@ -33,12 +66,12 @@ import {
   migrateObservations,
   migrateObservationsCommand,
   registerMigrateObservationsCommand
-} from "./chunk-5WR6RRPX.js";
+} from "./chunk-VBVEXNI5.js";
 import {
   SessionWatcher,
   observeCommand,
   registerObserveCommand
-} from "./chunk-PTSEIWXZ.js";
+} from "./chunk-6AQZIPLV.js";
 import "./chunk-HRLWZGMA.js";
 import {
   parseSessionFile
@@ -46,19 +79,19 @@ import {
 import {
   rebuildCommand,
   registerRebuildCommand
-} from "./chunk-DPS7NYIU.js";
+} from "./chunk-USZU5CBB.js";
 import {
   Compressor,
   Observer,
   Reflector
-} from "./chunk-2HM7ZI4X.js";
+} from "./chunk-2AYPFUGX.js";
 import {
   archiveCommand,
   registerArchiveCommand
-} from "./chunk-VR5NE7PZ.js";
+} from "./chunk-HVTTYDCJ.js";
 import {
   archiveObservations
-} from "./chunk-MQUJNOHK.js";
+} from "./chunk-QALB2V3E.js";
 import {
   findNearestVaultPath,
   getVaultPath,
@@ -77,7 +110,7 @@ import {
   normalizeContextProfileInput,
   registerContextCommand,
   resolveContextProfile
-} from "./chunk-SOTWYGH7.js";
+} from "./chunk-TB3BM2PQ.js";
 import {
   ClawVault,
   createVault,
@@ -105,7 +138,7 @@ import {
   getMemoryGraph,
   loadMemoryGraphIndex
 } from "./chunk-ZZA73MFY.js";
-import "./chunk-Z2XBWN7A.js";
+import "./chunk-NAMFB7ZA.js";
 
 // src/index.ts
 import * as fs from "fs";
@@ -123,13 +156,16 @@ function registerCommanderCommands(program) {
   registerContextCommand(program);
   registerObserveCommand(program);
   registerReflectCommand(program);
+  registerTailscaleCommands(program);
   return program;
 }
 export {
+  CLAWVAULT_SERVE_PATH,
   ClawVault,
   Compressor,
   DEFAULT_CATEGORIES,
   DEFAULT_CONFIG,
+  DEFAULT_SERVE_PORT,
   MEMORY_GRAPH_SCHEMA_VERSION,
   MEMORY_TYPES,
   Observer,
@@ -148,21 +184,33 @@ export {
   buildSessionRecap,
   buildTemplateVariables,
   checkOpenClawCompatibility,
+  checkPeerClawVault,
+  compareManifests,
   compatCommand,
   compatibilityExitCode,
+  configureTailscaleServe,
   contextCommand,
   createVault,
+  discoverClawVaultPeers,
   extractTags,
   extractWikiLinks,
+  fetchRemoteFile,
+  fetchRemoteManifest,
   findNearestVaultPath,
+  findPeer,
   findVault,
   formatContextMarkdown,
   formatSessionRecapMarkdown,
+  generateVaultManifest,
   getMemoryGraph,
+  getOnlinePeers,
+  getTailscaleStatus,
+  getTailscaleVersion,
   getVaultPath,
   graphCommand,
   graphSummary,
   hasQmd,
+  hasTailscale,
   inferContextProfile,
   loadMemoryGraphIndex,
   migrateObservations,
@@ -170,6 +218,7 @@ export {
   normalizeContextProfileInput,
   observeCommand,
   parseSessionFile,
+  pushFileToRemote,
   qmdEmbed,
   qmdUpdate,
   rebuildCommand,
@@ -183,12 +232,25 @@ export {
   registerReflectCommand,
   registerReplayCommand,
   registerSyncBdCommand,
+  registerTailscaleCommands,
+  registerTailscaleDiscoverCommand,
+  registerTailscaleServeCommand,
+  registerTailscaleStatusCommand,
+  registerTailscaleSyncCommand,
   renderTemplate,
   replayCommand,
   resolveContextProfile,
+  resolvePeerIP,
   resolveVaultPath,
   runReflection,
+  serveVault,
   sessionRecapCommand,
   setupCommand,
-  syncBdCommand
+  stopTailscaleServe,
+  syncBdCommand,
+  syncWithPeer,
+  tailscaleDiscoverCommand,
+  tailscaleServeCommand,
+  tailscaleStatusCommand,
+  tailscaleSyncCommand
 };

package/dist/lib/tailscale.d.ts

@@ -0,0 +1,225 @@
+import { ChildProcess } from 'child_process';
+import * as http from 'http';
+
+/**
+ * Tailscale Integration for ClawVault
+ *
+ * Provides native Tailscale networking capabilities for vault synchronization
+ * across devices on a Tailscale network (tailnet).
+ *
+ * Features:
+ * - Tailscale status detection and peer discovery
+ * - MagicDNS hostname resolution
+ * - Secure peer-to-peer vault sync
+ * - Tailscale Funnel/Serve integration for vault sharing
+ */
+
+interface TailscaleStatus {
+    /** Whether Tailscale is installed */
+    installed: boolean;
+    /** Whether Tailscale daemon is running */
+    running: boolean;
+    /** Whether connected to tailnet */
+    connected: boolean;
+    /** Current device's Tailscale IP */
+    selfIP?: string;
+    /** Current device's MagicDNS hostname */
+    selfHostname?: string;
+    /** Current device's full domain name */
+    selfDNSName?: string;
+    /** Tailnet name */
+    tailnetName?: string;
+    /** Backend state (Running, Stopped, etc.) */
+    backendState?: string;
+    /** List of peers on the tailnet */
+    peers: TailscalePeer[];
+    /** Error message if any */
+    error?: string;
+}
+interface TailscalePeer {
+    /** Peer's hostname */
+    hostname: string;
+    /** Peer's MagicDNS name */
+    dnsName: string;
+    /** Peer's Tailscale IP addresses */
+    tailscaleIPs: string[];
+    /** Whether peer is currently online */
+    online: boolean;
+    /** Operating system */
+    os?: string;
+    /** Whether this peer is the exit node */
+    exitNode?: boolean;
+    /** Whether this peer is a tagged device */
+    tags?: string[];
+    /** Last seen timestamp */
+    lastSeen?: string;
+    /** Whether peer is running ClawVault serve */
+    clawvaultServing?: boolean;
+    /** ClawVault serve port if detected */
+    clawvaultPort?: number;
+}
+interface TailscaleServeConfig {
+    /** Port to serve on (default: 8384) */
+    port?: number;
+    /** Whether to use HTTPS (via Tailscale) */
+    https?: boolean;
+    /** Whether to expose via Tailscale Funnel (public internet) */
+    funnel?: boolean;
+    /** Path prefix for the serve endpoint */
+    pathPrefix?: string;
+    /** Optional WebDAV Basic Auth credentials */
+    webdavAuth?: {
+        username: string;
+        password: string;
+    };
+}
+interface TailscaleSyncOptions {
+    /** Target peer hostname or IP */
+    peer: string;
+    /** Port on the peer (default: 8384) */
+    port?: number;
+    /** Direction: push, pull, or bidirectional */
+    direction?: 'push' | 'pull' | 'bidirectional';
+    /** Dry run - don't actually sync */
+    dryRun?: boolean;
+    /** Delete files on target that don't exist on source */
+    deleteOrphans?: boolean;
+    /** Categories to sync (default: all) */
+    categories?: string[];
+    /** Use HTTPS for connection */
+    https?: boolean;
+}
+interface TailscaleSyncResult {
+    /** Files pushed to peer */
+    pushed: string[];
+    /** Files pulled from peer */
+    pulled: string[];
+    /** Files deleted */
+    deleted: string[];
+    /** Files unchanged */
+    unchanged: string[];
+    /** Errors encountered */
+    errors: string[];
+    /** Sync statistics */
+    stats: {
+        bytesTransferred: number;
+        filesProcessed: number;
+        duration: number;
+    };
+}
+interface VaultManifest {
+    /** Vault name */
+    name: string;
+    /** Vault version */
+    version: string;
+    /** Last updated timestamp */
+    lastUpdated: string;
+    /** File manifest with checksums */
+    files: VaultFileEntry[];
+}
+interface VaultFileEntry {
+    /** Relative path */
+    path: string;
+    /** File size in bytes */
+    size: number;
+    /** Last modified timestamp */
+    modified: string;
+    /** SHA-256 checksum */
+    checksum: string;
+    /** Category */
+    category: string;
+}
+declare const DEFAULT_SERVE_PORT = 8384;
+declare const CLAWVAULT_SERVE_PATH = "/.clawvault";
+declare const MANIFEST_ENDPOINT = "/.clawvault/manifest";
+declare const SYNC_ENDPOINT = "/.clawvault/sync";
+declare const FILE_ENDPOINT = "/.clawvault/files";
+/**
+ * Check if Tailscale CLI is installed
+ */
+declare function hasTailscale(): boolean;
+/**
+ * Get Tailscale version
+ */
+declare function getTailscaleVersion(): string | null;
+/**
+ * Get comprehensive Tailscale status
+ */
+declare function getTailscaleStatus(): TailscaleStatus;
+/**
+ * Find a peer by hostname (partial match supported)
+ */
+declare function findPeer(hostname: string): TailscalePeer | null;
+/**
+ * Get online peers only
+ */
+declare function getOnlinePeers(): TailscalePeer[];
+/**
+ * Resolve a peer hostname to its Tailscale IP
+ */
+declare function resolvePeerIP(hostname: string): string | null;
+/**
+ * Generate vault manifest for synchronization
+ */
+declare function generateVaultManifest(vaultPath: string): VaultManifest;
+/**
+ * Compare two manifests and return differences
+ */
+declare function compareManifests(local: VaultManifest, remote: VaultManifest): {
+    toPush: VaultFileEntry[];
+    toPull: VaultFileEntry[];
+    conflicts: Array<{
+        path: string;
+        local: VaultFileEntry;
+        remote: VaultFileEntry;
+    }>;
+    unchanged: string[];
+};
+interface ServeInstance {
+    server: http.Server;
+    port: number;
+    stop: () => Promise<void>;
+}
+/**
+ * Start serving a vault over HTTP for Tailscale sync
+ * Includes WebDAV support at /webdav/ for Obsidian mobile sync
+ */
+declare function serveVault(vaultPath: string, options?: TailscaleServeConfig): ServeInstance;
+/**
+ * Fetch remote vault manifest
+ */
+declare function fetchRemoteManifest(host: string, port?: number, useHttps?: boolean): Promise<VaultManifest>;
+/**
+ * Fetch a file from remote vault
+ */
+declare function fetchRemoteFile(host: string, filePath: string, port?: number, useHttps?: boolean): Promise<string>;
+/**
+ * Push a file to remote vault
+ */
+declare function pushFileToRemote(host: string, filePath: string, content: string, port?: number, useHttps?: boolean): Promise<void>;
+/**
+ * Sync vault with a remote peer
+ */
+declare function syncWithPeer(vaultPath: string, options: TailscaleSyncOptions): Promise<TailscaleSyncResult>;
+/**
+ * Configure Tailscale serve for the vault
+ * This uses `tailscale serve` to expose the vault server via Tailscale's HTTPS
+ */
+declare function configureTailscaleServe(localPort: number, options?: {
+    funnel?: boolean;
+    background?: boolean;
+}): ChildProcess | null;
+/**
+ * Stop Tailscale serve
+ */
+declare function stopTailscaleServe(): boolean;
+/**
+ * Check if a peer is serving ClawVault
+ */
+declare function checkPeerClawVault(host: string, port?: number): Promise<boolean>;
+/**
+ * Discover ClawVault peers on the tailnet
+ */
+declare function discoverClawVaultPeers(port?: number): Promise<TailscalePeer[]>;
+
+export { CLAWVAULT_SERVE_PATH, DEFAULT_SERVE_PORT, FILE_ENDPOINT, MANIFEST_ENDPOINT, SYNC_ENDPOINT, type ServeInstance, type TailscalePeer, type TailscaleServeConfig, type TailscaleStatus, type TailscaleSyncOptions, type TailscaleSyncResult, type VaultFileEntry, type VaultManifest, checkPeerClawVault, compareManifests, configureTailscaleServe, discoverClawVaultPeers, fetchRemoteFile, fetchRemoteManifest, findPeer, generateVaultManifest, getOnlinePeers, getTailscaleStatus, getTailscaleVersion, hasTailscale, pushFileToRemote, resolvePeerIP, serveVault, stopTailscaleServe, syncWithPeer };

package/dist/lib/tailscale.js

@@ -0,0 +1,49 @@
+import {
+  CLAWVAULT_SERVE_PATH,
+  DEFAULT_SERVE_PORT,
+  FILE_ENDPOINT,
+  MANIFEST_ENDPOINT,
+  SYNC_ENDPOINT,
+  checkPeerClawVault,
+  compareManifests,
+  configureTailscaleServe,
+  discoverClawVaultPeers,
+  fetchRemoteFile,
+  fetchRemoteManifest,
+  findPeer,
+  generateVaultManifest,
+  getOnlinePeers,
+  getTailscaleStatus,
+  getTailscaleVersion,
+  hasTailscale,
+  pushFileToRemote,
+  resolvePeerIP,
+  serveVault,
+  stopTailscaleServe,
+  syncWithPeer
+} from "../chunk-4GBPTBFJ.js";
+import "../chunk-CLE2HHNT.js";
+export {
+  CLAWVAULT_SERVE_PATH,
+  DEFAULT_SERVE_PORT,
+  FILE_ENDPOINT,
+  MANIFEST_ENDPOINT,
+  SYNC_ENDPOINT,
+  checkPeerClawVault,
+  compareManifests,
+  configureTailscaleServe,
+  discoverClawVaultPeers,
+  fetchRemoteFile,
+  fetchRemoteManifest,
+  findPeer,
+  generateVaultManifest,
+  getOnlinePeers,
+  getTailscaleStatus,
+  getTailscaleVersion,
+  hasTailscale,
+  pushFileToRemote,
+  resolvePeerIP,
+  serveVault,
+  stopTailscaleServe,
+  syncWithPeer
+};

package/dist/lib/webdav.d.ts

@@ -0,0 +1,109 @@
+import * as fs from 'fs';
+import { IncomingMessage, ServerResponse } from 'http';
+
+/**
+ * WebDAV Handler for ClawVault
+ *
+ * Implements WebDAV protocol support for Obsidian mobile sync via Remotely Save plugin.
+ * Uses only Node built-in modules (http, fs, path) - zero external dependencies.
+ *
+ * Supported methods:
+ * - GET: Serve file contents
+ * - PUT: Write/create file (creates parent dirs if needed)
+ * - DELETE: Delete file or directory
+ * - MKCOL: Create directory
+ * - PROPFIND: List directory contents or file properties (XML response)
+ * - OPTIONS: Return allowed methods + DAV header
+ * - HEAD: File metadata without body
+ * - MOVE: Rename/move file (uses Destination header)
+ * - COPY: Copy file
+ */
+
+interface WebDAVConfig {
+    /** Root path for WebDAV files (vault path) */
+    rootPath: string;
+    /** URL prefix for WebDAV routes (default: /webdav) */
+    prefix?: string;
+    /** Optional Basic Auth credentials */
+    auth?: {
+        username: string;
+        password: string;
+    };
+}
+interface WebDAVRequest {
+    method: string;
+    path: string;
+    headers: Record<string, string | string[] | undefined>;
+    body?: string;
+}
+interface WebDAVResponse {
+    status: number;
+    headers: Record<string, string>;
+    body?: string;
+}
+declare const WEBDAV_PREFIX = "/webdav";
+/**
+ * Check if a path is safe (no traversal attacks, not blocked)
+ */
+declare function isPathSafe(requestPath: string, rootPath: string): boolean;
+/**
+ * Resolve a WebDAV path to filesystem path
+ */
+declare function resolveWebDAVPath(requestPath: string, rootPath: string): string | null;
+/**
+ * Check Basic Auth credentials
+ */
+declare function checkAuth(req: IncomingMessage, auth?: {
+    username: string;
+    password: string;
+}): boolean;
+/**
+ * Generate full PROPFIND response XML
+ */
+declare function generatePropfindResponse(entries: Array<{
+    href: string;
+    stats: fs.Stats | null;
+    isCollection: boolean;
+}>): string;
+/**
+ * Handle OPTIONS request
+ */
+declare function handleOptions(res: ServerResponse, prefix: string): void;
+/**
+ * Handle HEAD request
+ */
+declare function handleHead(res: ServerResponse, filePath: string): void;
+/**
+ * Handle GET request
+ */
+declare function handleGet(res: ServerResponse, filePath: string): void;
+/**
+ * Handle PUT request
+ */
+declare function handlePut(res: ServerResponse, filePath: string, body: Buffer): void;
+/**
+ * Handle DELETE request
+ */
+declare function handleDelete(res: ServerResponse, filePath: string): void;
+/**
+ * Handle MKCOL request (create directory)
+ */
+declare function handleMkcol(res: ServerResponse, filePath: string): void;
+/**
+ * Handle PROPFIND request
+ */
+declare function handlePropfind(res: ServerResponse, filePath: string, webdavPath: string, prefix: string, depth: string): void;
+/**
+ * Handle MOVE request
+ */
+declare function handleMove(res: ServerResponse, sourcePath: string, destinationPath: string | null, overwrite: boolean): void;
+/**
+ * Handle COPY request
+ */
+declare function handleCopy(res: ServerResponse, sourcePath: string, destinationPath: string | null, overwrite: boolean): void;
+/**
+ * Create WebDAV request handler
+ */
+declare function createWebDAVHandler(config: WebDAVConfig): (req: IncomingMessage, res: ServerResponse) => Promise<boolean>;
+
+export { WEBDAV_PREFIX, type WebDAVConfig, type WebDAVRequest, type WebDAVResponse, checkAuth, createWebDAVHandler, generatePropfindResponse, handleCopy, handleDelete, handleGet, handleHead, handleMkcol, handleMove, handleOptions, handlePropfind, handlePut, isPathSafe, resolveWebDAVPath };

package/dist/lib/webdav.js

@@ -0,0 +1,34 @@
+import {
+  WEBDAV_PREFIX,
+  checkAuth,
+  createWebDAVHandler,
+  generatePropfindResponse,
+  handleCopy,
+  handleDelete,
+  handleGet,
+  handleHead,
+  handleMkcol,
+  handleMove,
+  handleOptions,
+  handlePropfind,
+  handlePut,
+  isPathSafe,
+  resolveWebDAVPath
+} from "../chunk-CLE2HHNT.js";
+export {
+  WEBDAV_PREFIX,
+  checkAuth,
+  createWebDAVHandler,
+  generatePropfindResponse,
+  handleCopy,
+  handleDelete,
+  handleGet,
+  handleHead,
+  handleMkcol,
+  handleMove,
+  handleOptions,
+  handlePropfind,
+  handlePut,
+  isPathSafe,
+  resolveWebDAVPath
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "clawvault",
-  "version": "2.3.0",
+  "version": "2.3.1",
   "description": "ClawVault™ - 🐘 An elephant never forgets. Structured memory for OpenClaw agents. Context death resilience, Obsidian-compatible markdown, local semantic search.",
   "type": "module",
   "main": "dist/index.cjs",
@@ -29,7 +29,7 @@
     ]
   },
   "scripts": {
-    "build": "tsup src/index.ts src/commands/entities.ts src/commands/link.ts src/commands/checkpoint.ts src/commands/recover.ts src/commands/status.ts src/commands/template.ts src/commands/setup.ts src/commands/context.ts src/commands/observe.ts src/commands/reflect.ts src/commands/archive.ts src/commands/rebuild.ts src/commands/replay.ts src/commands/migrate-observations.ts src/commands/sync-bd.ts src/commands/session-recap.ts src/commands/wake.ts src/commands/sleep.ts src/commands/doctor.ts src/commands/compat.ts src/commands/graph.ts src/commands/shell-init.ts src/commands/repair-session.ts src/commands/task.ts src/commands/backlog.ts src/commands/blocked.ts src/commands/canvas.ts src/lib/entity-index.ts src/lib/auto-linker.ts src/lib/config.ts src/lib/template-engine.ts src/lib/session-utils.ts src/lib/session-repair.ts src/lib/task-utils.ts src/lib/canvas-layout.ts --format esm --dts --clean",
+    "build": "tsup src/commands/archive.ts src/commands/backlog.ts src/commands/blocked.ts src/commands/canvas.ts src/commands/checkpoint.ts src/commands/compat.ts src/commands/context.ts src/commands/doctor.ts src/commands/entities.ts src/commands/graph.ts src/commands/link.ts src/commands/migrate-observations.ts src/commands/observe.ts src/commands/rebuild.ts src/commands/recover.ts src/commands/reflect.ts src/commands/repair-session.ts src/commands/replay.ts src/commands/session-recap.ts src/commands/setup.ts src/commands/shell-init.ts src/commands/sleep.ts src/commands/status.ts src/commands/sync-bd.ts src/commands/tailscale.ts src/commands/task.ts src/commands/template.ts src/commands/wake.ts src/index.ts src/lib/auto-linker.ts src/lib/canvas-layout.ts src/lib/config.ts src/lib/entity-index.ts src/lib/session-repair.ts src/lib/session-utils.ts src/lib/tailscale.ts src/lib/task-utils.ts src/lib/template-engine.ts src/lib/webdav.ts --format esm --dts --clean",
     "dev": "tsup src/index.ts src/commands/*.ts src/lib/*.ts --format esm --dts --watch",
     "lint": "eslint src",
     "typecheck": "tsc --noEmit",