clawvault 2.3.0 → 2.4.0

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/task-utils.d.ts

@@ -6,6 +6,7 @@ type TaskStatus = 'open' | 'in-progress' | 'blocked' | 'done';
 type TaskPriority = 'critical' | 'high' | 'medium' | 'low';
 interface TaskFrontmatter {
     status: TaskStatus;
+    source?: string;
     owner?: string;
     project?: string;
     priority?: TaskPriority;
@@ -27,6 +28,7 @@ interface BacklogFrontmatter {
     source?: string;
     project?: string;
     created: string;
+    lastSeen?: string;
     tags?: string[];
 }
 interface BacklogItem {
@@ -95,6 +97,7 @@ declare function listBacklogItems(vaultPath: string, filters?: BacklogFilterOpti
  * Create a new task
  */
 declare function createTask(vaultPath: string, title: string, options?: {
+    source?: string;
     owner?: string;
     project?: string;
     priority?: TaskPriority;
@@ -127,6 +130,15 @@ declare function createBacklogItem(vaultPath: string, title: string, options?: {
     content?: string;
     tags?: string[];
 }): BacklogItem;
+/**
+ * Update an existing backlog item frontmatter.
+ */
+declare function updateBacklogItem(vaultPath: string, slug: string, updates: {
+    source?: string;
+    project?: string;
+    tags?: string[];
+    lastSeen?: string;
+}): BacklogItem;
 /**
  * Promote a backlog item to a task
  */
@@ -156,4 +168,4 @@ declare function getStatusIcon(status: TaskStatus): string;
  */
 declare function getStatusDisplay(status: TaskStatus): string;
 
-export { type BacklogFilterOptions, type BacklogFrontmatter, type BacklogItem, type Task, type TaskFilterOptions, type TaskFrontmatter, type TaskPriority, type TaskStatus, completeTask, createBacklogItem, createTask, ensureBacklogDir, ensureTasksDir, getActiveTasks, getBacklogDir, getBacklogPath, getBlockedTasks, getRecentlyCompletedTasks, getStatusDisplay, getStatusIcon, getTaskPath, getTasksDir, listBacklogItems, listTasks, promoteBacklogItem, readBacklogItem, readTask, slugify, updateTask };
+export { type BacklogFilterOptions, type BacklogFrontmatter, type BacklogItem, type Task, type TaskFilterOptions, type TaskFrontmatter, type TaskPriority, type TaskStatus, completeTask, createBacklogItem, createTask, ensureBacklogDir, ensureTasksDir, getActiveTasks, getBacklogDir, getBacklogPath, getBlockedTasks, getRecentlyCompletedTasks, getStatusDisplay, getStatusIcon, getTaskPath, getTasksDir, listBacklogItems, listTasks, promoteBacklogItem, readBacklogItem, readTask, slugify, updateBacklogItem, updateTask };

package/dist/lib/task-utils.js

@@ -19,8 +19,9 @@ import {
   readBacklogItem,
   readTask,
   slugify,
+  updateBacklogItem,
   updateTask
-} from "../chunk-NGVAEFT2.js";
+} from "../chunk-DEFBIVQ3.js";
 export {
   completeTask,
   createBacklogItem,
@@ -42,5 +43,6 @@ export {
   readBacklogItem,
   readTask,
   slugify,
+  updateBacklogItem,
   updateTask
 };

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.4.0",
   "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",

package/dist/chunk-W463YRED.js

@@ -1,97 +0,0 @@
-import {
-  DEFAULT_CATEGORIES,
-  hasQmd
-} from "./chunk-FDJIZKCW.js";
-
-// src/commands/setup.ts
-import * as fs from "fs";
-import * as os from "os";
-import * as path from "path";
-import { execFileSync } from "child_process";
-var CONFIG_FILE = ".clawvault.json";
-function resolveVaultTarget() {
-  const envPath = process.env.CLAWVAULT_PATH?.trim();
-  const home = os.homedir();
-  if (envPath) {
-    const vaultPath = path.resolve(envPath);
-    return { vaultPath, source: "CLAWVAULT_PATH", existed: fs.existsSync(vaultPath) };
-  }
-  const candidates = [
-    { vaultPath: path.join(home, ".openclaw", "workspace", "memory"), source: "OpenClaw default" },
-    { vaultPath: path.resolve(process.cwd(), "memory"), source: "./memory" },
-    { vaultPath: path.join(home, "memory"), source: "~/memory" }
-  ];
-  for (const candidate of candidates) {
-    if (fs.existsSync(candidate.vaultPath)) {
-      return { ...candidate, existed: true };
-    }
-  }
-  const fallback = candidates[0];
-  return { ...fallback, existed: false };
-}
-function ensureVaultStructure(vaultPath) {
-  fs.mkdirSync(vaultPath, { recursive: true });
-  for (const category of DEFAULT_CATEGORIES) {
-    fs.mkdirSync(path.join(vaultPath, category), { recursive: true });
-  }
-  const configPath = path.join(vaultPath, CONFIG_FILE);
-  if (fs.existsSync(configPath)) return false;
-  const now = (/* @__PURE__ */ new Date()).toISOString();
-  const name = path.basename(vaultPath);
-  const meta = {
-    name,
-    version: "1.0.0",
-    created: now,
-    lastUpdated: now,
-    categories: DEFAULT_CATEGORIES,
-    documentCount: 0,
-    qmdCollection: name,
-    qmdRoot: vaultPath
-  };
-  fs.writeFileSync(configPath, JSON.stringify(meta, null, 2));
-  return true;
-}
-function getQmdConfig(vaultPath) {
-  const configPath = path.join(vaultPath, CONFIG_FILE);
-  if (fs.existsSync(configPath)) {
-    try {
-      const meta = JSON.parse(fs.readFileSync(configPath, "utf-8"));
-      return {
-        collection: meta.qmdCollection || meta.name || path.basename(vaultPath),
-        root: meta.qmdRoot || vaultPath
-      };
-    } catch {
-      return { collection: path.basename(vaultPath), root: vaultPath };
-    }
-  }
-  return { collection: path.basename(vaultPath), root: vaultPath };
-}
-async function setupCommand() {
-  const target = resolveVaultTarget();
-  if (target.existed && !fs.statSync(target.vaultPath).isDirectory()) {
-    throw new Error(`Vault path is not a directory: ${target.vaultPath}`);
-  }
-  if (!target.existed) fs.mkdirSync(target.vaultPath, { recursive: true });
-  console.log(`${target.existed ? "Found" : "Created"} vault path (${target.source}): ${target.vaultPath}`);
-  const initialized = ensureVaultStructure(target.vaultPath);
-  console.log(initialized ? "Initialized vault structure." : "Vault structure already present.");
-  console.log("\nTip: add this to your shell config:");
-  console.log(`  export CLAWVAULT_PATH="${target.vaultPath}"`);
-  if (hasQmd()) {
-    const { collection, root } = getQmdConfig(target.vaultPath);
-    try {
-      execFileSync("qmd", ["collection", "add", root, "--name", collection, "--mask", "**/*.md"], {
-        stdio: "ignore"
-      });
-      console.log(`qmd collection ready: ${collection}`);
-    } catch {
-      console.log("qmd collection already exists or could not be created.");
-    }
-  } else {
-    console.log("qmd not found; skipping collection setup.");
-  }
-}
-
-export {
-  setupCommand
-};