@hippodid/openclaw-plugin 1.0.8 → 1.0.10

package/src/hooks/memory-flush.ts

@@ -4,11 +4,20 @@ export function createMemoryFlushHook(
   fileSync: FileSync,
   logger: { info(msg: string): void; warn(msg: string): void },
 ): (api: any) => void {
-  return (_api: any) => {
-    // OpenClaw 2026 does not support api.on() for event hooks.
-    // Pre-compaction flush is available via the hippodid:sync tool,
-    // which agents can call explicitly before a compaction.
-    // Background sync is handled by fileSync.start() interval.
-    logger.info('hippodid: memory flush handler ready (use hippodid:sync tool to trigger)');
+  return (api: any) => {
+    api.on('before_compaction', async () => {
+      try {
+        const { synced, changed } = await fileSync.flushNow();
+        logger.info(
+          `hippodid: flushed ${synced} files before compaction (${changed} changed)`,
+        );
+      } catch (e) {
+        logger.warn(
+          `hippodid: compaction flush failed: ${e instanceof Error ? e.message : 'unknown'}`,
+        );
+      }
+    });
+
+    logger.info('hippodid: memory flush handler registered');
   };
 }

package/src/hooks/session-lifecycle.ts

@@ -7,10 +7,39 @@ export function createSessionHooks(
   autoRecall: boolean,
   logger: { info(msg: string): void; warn(msg: string): void },
 ): (api: any) => void {
-  return (_api: any) => {
-    // OpenClaw 2026 does not support api.on() for session lifecycle events.
-    // Session start hydration happens automatically via fileSync.start()
-    // which pulls cloud state on initialization.
-    logger.info('hippodid: session lifecycle handler ready');
+  return (api: any) => {
+    api.on('session_start', async () => {
+      try {
+        await tierManager.initialize();
+        if (!tierManager.shouldHydrateOnStart(autoRecall)) {
+          logger.info(
+            'hippodid: session start hydration skipped because auto-recall is active',
+          );
+          return;
+        }
+
+        const hydrated = await fileSync.hydrateFromCloud();
+        logger.info(`hippodid: session started, hydrated ${hydrated} files`);
+      } catch (e) {
+        logger.warn(
+          `hippodid: session start error: ${e instanceof Error ? e.message : 'unknown'}`,
+        );
+      }
+    });
+
+    api.on('session_end', async () => {
+      try {
+        const { synced, changed } = await fileSync.flushNow();
+        logger.info(
+          `hippodid: session ended, flushed ${synced} files (${changed} changed)`,
+        );
+      } catch (e) {
+        logger.warn(
+          `hippodid: session end error: ${e instanceof Error ? e.message : 'unknown'}`,
+        );
+      }
+    });
+
+    logger.info('hippodid: session lifecycle hooks registered');
   };
 }

package/src/index.ts

@@ -1,4 +1,5 @@
 import { readFile } from 'node:fs/promises';
+import { createRequire } from 'node:module';
 import { resolve } from 'node:path';
 import type { PluginConfig } from './types.js';
 import { createClient, type HippoDidClient } from './hippodid-client.js';
@@ -10,39 +11,42 @@ import { createSessionHooks } from './hooks/session-lifecycle.js';
 import { createAutoRecallHook } from './hooks/auto-recall.js';
 import { createAutoCaptureHook } from './hooks/auto-capture.js';
 
-const VERSION = '1.0.0';
+const require = createRequire(import.meta.url);
+const VERSION =
+  ((require('../package.json') as { version?: string }).version) ?? '0.0.0-dev';
+let hasInitialized = false;
 
 export default {
   id: 'hippodid',
 
   register(api: any): void {
     try {
-      const config = resolveConfig(api.pluginConfig ?? {});
+      if (hasInitialized) {
+        return;
+      }
+
+      const config = resolveConfig(api.pluginConfig ?? api.config ?? {});
       const logger = api.logger ?? {
         info: (msg: string) => console.log(msg),
         warn: (msg: string) => console.warn(msg),
         error: (msg: string) => console.error(msg),
       };
 
-      const apiKey = config?.apiKey?.trim() ?? '';
-      const characterId = config?.characterId?.trim() ?? '';
-
+      const apiKey = config.apiKey.trim();
+      const characterId = config.characterId.trim();
       if (!apiKey || !characterId) {
-        logger.warn('HippoDid: apiKey and characterId required — configure in openclaw.json');
+        logger.warn(
+          'HippoDid: apiKey and characterId required — configure in openclaw.json',
+        );
         return;
       }
 
+      hasInitialized = true;
+
       const client = createClient(apiKey, config.baseUrl);
-      const tierManager = createTierManager(
-        client,
-        characterId,
-        logger,
-      );
+      const tierManager = createTierManager(client, characterId, logger);
       const watchPaths = resolveWatchPaths(config);
-      const effectiveSyncInterval = Math.max(
-        config.syncIntervalSeconds,
-        60,
-      );
+      const effectiveSyncInterval = Math.max(config.syncIntervalSeconds, 60);
       const fileSync = createFileSync(
         client,
         config,
@@ -133,6 +137,7 @@ function resolveConfig(raw: any): PluginConfig {
       additionalPaths: [],
     };
   }
+
   return {
     apiKey: raw.apiKey ?? '',
     characterId: raw.characterId ?? '',
@@ -152,49 +157,162 @@ function registerCommands(
   tierManager: TierManager,
   logger: { info(msg: string): void; warn(msg: string): void },
 ): void {
-  api.registerTool('hippodid:status', {
-    description: 'Show HippoDid tier, sync status, and watched paths',
-    handler: async () => {
-      const tier = tierManager.getCurrentTier();
-      const statusResult = await client.getSyncStatus(config.characterId);
-
-      logger.info(`--- HippoDid Status ---`);
-      logger.info(`Character: ${config.characterId}`);
-      logger.info(`Tier: ${tier.tier}`);
-      logger.info(
-        `Auto-Recall: ${tier.features.autoRecallAvailable ? 'available' : 'unavailable'} (config: ${config.autoRecall ? 'ON' : 'OFF'})`,
-      );
-      logger.info(
-        `Auto-Capture: ${tier.features.autoCaptureAvailable ? 'available' : 'unavailable'} (config: ${config.autoCapture ? 'ON' : 'OFF'})`,
+  const getStatusText = async (): Promise<string> => {
+    const tier = tierManager.getCurrentTier();
+    const statusResult = await client.getSyncStatus(config.characterId);
+    const lines = [
+      'HippoDid status:',
+      `- Character: ${config.characterId}`,
+      `- Tier: ${tier.tier}`,
+      `- Auto-Recall: ${tier.features.autoRecallAvailable ? 'available' : 'unavailable'} (config: ${config.autoRecall ? 'ON' : 'OFF'})`,
+      `- Auto-Capture: ${tier.features.autoCaptureAvailable ? 'available' : 'unavailable'} (config: ${config.autoCapture ? 'ON' : 'OFF'})`,
+    ];
+
+    if (statusResult.ok) {
+      lines.push(`- Synced sources: ${statusResult.value.entries.length}`);
+      for (const entry of statusResult.value.entries) {
+        lines.push(
+          `  - ${entry.sourcePath} (${entry.label}) — last sync: ${entry.lastSyncedAt}`,
+        );
+      }
+    } else {
+      lines.push(
+        `- Sync status: unavailable (${statusResult.error.message})`,
       );
+    }
 
-      if (statusResult.ok) {
-        logger.info(`Synced sources: ${statusResult.value.entries.length}`);
-        for (const entry of statusResult.value.entries) {
-          logger.info(
-            `  ${entry.sourcePath} (${entry.label}) — last sync: ${entry.lastSyncedAt}`,
-          );
+    return lines.join('\n');
+  };
+
+  const runImport = async (workspaceOverride?: string): Promise<string> => {
+    const { readdir } = await import('node:fs/promises');
+    const { join, extname } = await import('node:path');
+    const { createHash } = await import('node:crypto');
+
+    const workspacePath = workspaceOverride
+      ? resolve(workspaceOverride)
+      : resolve(process.cwd());
+
+    const memoryDir = join(workspacePath, 'memory');
+    const memoryMd = join(workspacePath, 'MEMORY.md');
+    const filesToImport: Array<{ path: string; label: string }> = [];
+
+    try {
+      const entries = await readdir(memoryDir);
+      for (const entry of entries) {
+        if (extname(entry) === '.md') {
+          filesToImport.push({
+            path: join(memoryDir, entry),
+            label: 'workspace-memory',
+          });
         }
-      } else {
+      }
+    } catch {
+      // memory dir may not exist
+    }
+
+    try {
+      await readFile(memoryMd);
+      filesToImport.push({ path: memoryMd, label: 'MEMORY.md' });
+    } catch {
+      // MEMORY.md may not exist
+    }
+
+    if (filesToImport.length === 0) {
+      return 'hippodid: no memory files found to import';
+    }
+
+    logger.info(
+      `hippodid: importing ${filesToImport.length} files from ${workspacePath}...`,
+    );
+
+    let imported = 0;
+    for (const file of filesToImport) {
+      try {
+        const content = await readFile(file.path);
+        const hash = createHash('sha256').update(content).digest('hex');
+        const base64 = content.toString('base64');
+        const result = await client.syncFile(
+          config.characterId,
+          file.path,
+          file.label,
+          base64,
+          hash,
+        );
+        if (result.ok) imported++;
+      } catch (e) {
         logger.warn(
-          `Could not fetch sync status: ${statusResult.error.message}`,
+          `hippodid: import failed for ${file.path}: ${e instanceof Error ? e.message : 'unknown'}`,
         );
       }
+    }
+
+    return `hippodid: import complete — ${imported}/${filesToImport.length} files imported`;
+  };
+
+  api.registerCommand({
+    name: 'hippodid',
+    description: 'Show HippoDid status and run sync/import actions.',
+    acceptsArgs: true,
+    handler: async (ctx: any) => {
+      const args = ctx?.args?.trim() ?? '';
+      const [action = 'status', ...rest] = args.split(/\s+/).filter(Boolean);
+
+      if (action === 'status') {
+        return { text: await getStatusText() };
+      }
+
+      if (action === 'sync') {
+        logger.info('hippodid: manual sync triggered...');
+        const { synced, changed } = await fileSync.flushNow();
+        return {
+          text: `hippodid: manual sync complete — ${synced} files (${changed} changed)`,
+        };
+      }
+
+      if (action === 'import') {
+        const workspace = rest.join(' ').trim() || undefined;
+        return { text: await runImport(workspace) };
+      }
+
+      return {
+        text: [
+          'HippoDid commands:',
+          '',
+          '/hippodid status',
+          '/hippodid sync',
+          '/hippodid import [workspace-path]',
+        ].join('\n'),
+      };
+    },
+  });
+
+  api.registerTool({
+    name: 'hippodid:status',
+    description: 'Show HippoDid tier, sync status, and watched paths',
+    execute: async () => {
+      const text = await getStatusText();
+      for (const line of text.split('\n')) {
+        logger.info(line);
+      }
+      return text;
     },
   });
 
-  api.registerTool('hippodid:sync', {
+  api.registerTool({
+    name: 'hippodid:sync',
     description: 'Trigger immediate sync of all watched files',
-    handler: async () => {
+    execute: async () => {
       logger.info('hippodid: manual sync triggered...');
       const { synced, changed } = await fileSync.flushNow();
-      logger.info(
-        `hippodid: manual sync complete — ${synced} files (${changed} changed)`,
-      );
+      const text = `hippodid: manual sync complete — ${synced} files (${changed} changed)`;
+      logger.info(text);
+      return text;
     },
   });
 
-  api.registerTool('hippodid:import', {
+  api.registerTool({
+    name: 'hippodid:import',
     description: 'Import existing workspace memory into HippoDid character',
     args: [
       {
@@ -203,73 +321,10 @@ function registerCommands(
         required: false,
       },
     ],
-    handler: async (args: Record<string, string>) => {
-      const { readdir } = await import('node:fs/promises');
-      const { join, extname } = await import('node:path');
-      const { createHash } = await import('node:crypto');
-
-      const workspacePath = args['workspace']
-        ? resolve(args['workspace'])
-        : resolve(process.cwd());
-
-      const memoryDir = join(workspacePath, 'memory');
-      const memoryMd = join(workspacePath, 'MEMORY.md');
-      const filesToImport: Array<{ path: string; label: string }> = [];
-
-      try {
-        const entries = await readdir(memoryDir);
-        for (const entry of entries) {
-          if (extname(entry) === '.md') {
-            filesToImport.push({
-              path: join(memoryDir, entry),
-              label: 'workspace-memory',
-            });
-          }
-        }
-      } catch {
-        // memory dir may not exist
-      }
-
-      try {
-        await readFile(memoryMd);
-        filesToImport.push({ path: memoryMd, label: 'MEMORY.md' });
-      } catch {
-        // MEMORY.md may not exist
-      }
-
-      if (filesToImport.length === 0) {
-        logger.info('hippodid: no memory files found to import');
-        return;
-      }
-
-      logger.info(
-        `hippodid: importing ${filesToImport.length} files from ${workspacePath}...`,
-      );
-
-      let imported = 0;
-      for (const file of filesToImport) {
-        try {
-          const content = await readFile(file.path);
-          const hash = createHash('sha256').update(content).digest('hex');
-          const base64 = content.toString('base64');
-          const result = await client.syncFile(
-            config.characterId,
-            file.path,
-            file.label,
-            base64,
-            hash,
-          );
-          if (result.ok) imported++;
-        } catch (e) {
-          logger.warn(
-            `hippodid: import failed for ${file.path}: ${e instanceof Error ? e.message : 'unknown'}`,
-          );
-        }
-      }
-
-      logger.info(
-        `hippodid: import complete — ${imported}/${filesToImport.length} files imported`,
-      );
+    execute: async (args: Record<string, string>) => {
+      const text = await runImport(args['workspace']);
+      logger.info(text);
+      return text;
     },
   });
 }

package/src/tier-manager.ts

@@ -52,9 +52,7 @@ export function createTierManager(
     },
 
     shouldMountFileSync(autoCaptureEnabled: boolean): boolean {
-      const isFree = !isPaidTier(currentTier);
-      if (isFree) return true;
-      return !autoCaptureEnabled;
+      return !this.shouldMountAutoCapture(autoCaptureEnabled);
     },
 
     shouldMountAutoRecall(autoRecallEnabled: boolean): boolean {
@@ -76,7 +74,7 @@ export function createTierManager(
     shouldHydrateOnStart(autoRecallEnabled: boolean): boolean {
       const isFree = !isPaidTier(currentTier);
       if (isFree) return true;
-      return !autoRecallEnabled;
+      return !this.shouldMountAutoRecall(autoRecallEnabled);
     },
 
     getEffectiveSyncInterval(configInterval: number): number {

package/src/types.ts

@@ -59,9 +59,12 @@ export interface TierInfo {
 export interface TierApiResponse {
   tier: string;
   features: {
-    auto_recall_available: boolean;
-    auto_capture_available: boolean;
-    min_sync_interval_seconds: number;
+    auto_recall_available?: boolean;
+    auto_capture_available?: boolean;
+    min_sync_interval_seconds?: number;
+    autoRecallAvailable?: boolean;
+    autoCaptureAvailable?: boolean;
+    minSyncIntervalSeconds?: number;
   };
 }
 
@@ -129,5 +132,5 @@ export interface FileTrackingEntry {
 
 // OpenClaw Plugin API — typed as `any` at boundaries.
 // The real type comes from openclaw/plugin-sdk/core at runtime.
-// Methods used: api.registerTool(), api.logger, api.config
+// Methods used: api.registerTool(), api.registerHook(), api.logger, api.pluginConfig
 export type OpenClawPluginAPI = any;