clawvault 3.1.0 → 3.2.0

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,35 @@
+import {
+  WEBDAV_PREFIX,
+  checkAuth,
+  createWebDAVHandler,
+  generatePropfindResponse,
+  handleCopy,
+  handleDelete,
+  handleGet,
+  handleHead,
+  handleMkcol,
+  handleMove,
+  handleOptions,
+  handlePropfind,
+  handlePut,
+  isPathSafe,
+  resolveWebDAVPath
+} from "../chunk-IVRIKYFE.js";
+import "../chunk-2ZDO52B4.js";
+export {
+  WEBDAV_PREFIX,
+  checkAuth,
+  createWebDAVHandler,
+  generatePropfindResponse,
+  handleCopy,
+  handleDelete,
+  handleGet,
+  handleHead,
+  handleMkcol,
+  handleMove,
+  handleOptions,
+  handlePropfind,
+  handlePut,
+  isPathSafe,
+  resolveWebDAVPath
+};

package/dist/openclaw-plugin.d.ts

@@ -0,0 +1,8 @@
+declare const clawvaultPlugin: {
+    id: string;
+    name: string;
+    description: string;
+    register(): void;
+};
+
+export { clawvaultPlugin as default };

package/dist/openclaw-plugin.js

@@ -0,0 +1,14 @@
+import "./chunk-2ZDO52B4.js";
+
+// src/openclaw-plugin.ts
+var clawvaultPlugin = {
+  id: "clawvault",
+  name: "ClawVault",
+  description: "Structured memory system for AI agents with context death resilience",
+  register() {
+  }
+};
+var openclaw_plugin_default = clawvaultPlugin;
+export {
+  openclaw_plugin_default as default
+};

package/dist/registry-BR4326o0.d.ts

@@ -0,0 +1,30 @@
+import { FieldDefinition, PrimitiveTypeDefinition, Registry } from './workgraph/types.js';
+
+/**
+ * Dynamic primitive type registry.
+ *
+ * Agents can define new primitive types at runtime. The registry is stored
+ * as `.clawvault/registry.json` in the vault. Built-in types are seeded on
+ * first access and cannot be deleted (but CAN be extended with new fields).
+ */
+
+declare function registryPath(vaultPath: string): string;
+declare function loadRegistry(vaultPath: string): Registry;
+declare function saveRegistry(vaultPath: string, registry: Registry): void;
+declare function defineType(vaultPath: string, name: string, description: string, fields: Record<string, FieldDefinition>, actor: string, directory?: string): PrimitiveTypeDefinition;
+declare function getType(vaultPath: string, name: string): PrimitiveTypeDefinition | undefined;
+declare function listTypes(vaultPath: string): PrimitiveTypeDefinition[];
+declare function extendType(vaultPath: string, name: string, newFields: Record<string, FieldDefinition>, actor: string): PrimitiveTypeDefinition;
+
+declare const registry_defineType: typeof defineType;
+declare const registry_extendType: typeof extendType;
+declare const registry_getType: typeof getType;
+declare const registry_listTypes: typeof listTypes;
+declare const registry_loadRegistry: typeof loadRegistry;
+declare const registry_registryPath: typeof registryPath;
+declare const registry_saveRegistry: typeof saveRegistry;
+declare namespace registry {
+  export { registry_defineType as defineType, registry_extendType as extendType, registry_getType as getType, registry_listTypes as listTypes, registry_loadRegistry as loadRegistry, registry_registryPath as registryPath, registry_saveRegistry as saveRegistry };
+}
+
+export { loadRegistry as a, registryPath as b, defineType as d, extendType as e, getType as g, listTypes as l, registry as r, saveRegistry as s };

package/dist/store-CA-6sKCJ.d.ts

@@ -0,0 +1,34 @@
+import { PrimitiveInstance } from './workgraph/types.js';
+
+/**
+ * Workgraph store — CRUD for primitive instances.
+ *
+ * Primitives are markdown files with YAML frontmatter. The store reads/writes
+ * them and logs every mutation to the ledger. Schemas are soft: unknown fields
+ * are preserved, missing optional fields get defaults.
+ */
+
+declare function create(vaultPath: string, typeName: string, fields: Record<string, unknown>, body: string, actor: string): PrimitiveInstance;
+declare function read(vaultPath: string, relPath: string): PrimitiveInstance | null;
+declare function list(vaultPath: string, typeName: string): PrimitiveInstance[];
+declare function update(vaultPath: string, relPath: string, fieldUpdates: Record<string, unknown>, bodyUpdate: string | undefined, actor: string): PrimitiveInstance;
+declare function remove(vaultPath: string, relPath: string, actor: string): void;
+declare function findByField(vaultPath: string, typeName: string, field: string, value: unknown): PrimitiveInstance[];
+declare function openThreads(vaultPath: string): PrimitiveInstance[];
+declare function activeThreads(vaultPath: string): PrimitiveInstance[];
+declare function blockedThreads(vaultPath: string): PrimitiveInstance[];
+
+declare const store_activeThreads: typeof activeThreads;
+declare const store_blockedThreads: typeof blockedThreads;
+declare const store_create: typeof create;
+declare const store_findByField: typeof findByField;
+declare const store_list: typeof list;
+declare const store_openThreads: typeof openThreads;
+declare const store_read: typeof read;
+declare const store_remove: typeof remove;
+declare const store_update: typeof update;
+declare namespace store {
+  export { store_activeThreads as activeThreads, store_blockedThreads as blockedThreads, store_create as create, store_findByField as findByField, store_list as list, store_openThreads as openThreads, store_read as read, store_remove as remove, store_update as update };
+}
+
+export { activeThreads as a, blockedThreads as b, create as c, remove as d, findByField as f, list as l, openThreads as o, read as r, store as s, update as u };

package/dist/thread-B9LhXNU0.d.ts

@@ -0,0 +1,41 @@
+import { PrimitiveInstance } from './workgraph/types.js';
+
+/**
+ * Thread lifecycle operations.
+ *
+ * Threads are the core coordination primitive. This module handles the
+ * claim/release/block/done lifecycle with ledger-backed exclusivity.
+ */
+
+declare function createThread(vaultPath: string, title: string, goal: string, actor: string, opts?: {
+    priority?: string;
+    deps?: string[];
+    parent?: string;
+    context_refs?: string[];
+    tags?: string[];
+}): PrimitiveInstance;
+declare function claim(vaultPath: string, threadPath: string, actor: string): PrimitiveInstance;
+declare function release(vaultPath: string, threadPath: string, actor: string, reason?: string): PrimitiveInstance;
+declare function block(vaultPath: string, threadPath: string, actor: string, blockedBy: string, reason?: string): PrimitiveInstance;
+declare function unblock(vaultPath: string, threadPath: string, actor: string): PrimitiveInstance;
+declare function done(vaultPath: string, threadPath: string, actor: string, output?: string): PrimitiveInstance;
+declare function cancel(vaultPath: string, threadPath: string, actor: string, reason?: string): PrimitiveInstance;
+declare function decompose(vaultPath: string, parentPath: string, subthreads: Array<{
+    title: string;
+    goal: string;
+    deps?: string[];
+}>, actor: string): PrimitiveInstance[];
+
+declare const thread_block: typeof block;
+declare const thread_cancel: typeof cancel;
+declare const thread_claim: typeof claim;
+declare const thread_createThread: typeof createThread;
+declare const thread_decompose: typeof decompose;
+declare const thread_done: typeof done;
+declare const thread_release: typeof release;
+declare const thread_unblock: typeof unblock;
+declare namespace thread {
+  export { thread_block as block, thread_cancel as cancel, thread_claim as claim, thread_createThread as createThread, thread_decompose as decompose, thread_done as done, thread_release as release, thread_unblock as unblock };
+}
+
+export { claim as a, block as b, cancel as c, createThread as d, decompose as e, done as f, release as r, thread as t, unblock as u };