@troykelly/openclaw-projects 0.0.1 → 0.0.3

package/README.md

@@ -1,376 +1,321 @@
 # @troykelly/openclaw-projects
 
-An [OpenClaw](https://docs.openclaw.ai/) plugin that connects agents to the openclaw-projects backend for project management, memory, todos, and contacts.
+An [OpenClaw](https://docs.openclaw.ai/) plugin that connects agents to the openclaw-projects backend for project management, memory, todos, contacts, and communications.
 
 > **Note:** This is a third-party plugin — not part of OpenClaw itself. It provides OpenClaw agents with tools to interact with the [openclaw-projects](https://github.com/troykelly/openclaw-projects) backend service.
 
 ## Features
 
-- **Memory Management**: Store, recall, and forget memories with semantic search
+- **Memory Management**: Store, recall, and forget memories with semantic search (pgvector)
 - **Project Management**: List, get, and create projects
 - **Todo Management**: Manage todos with completion tracking
-- **Contact Management**: Search, get, and create contacts
+- **Contact Management**: Search, get, and create contacts with relationship mapping
+- **Communications**: Send SMS (Twilio) and email (Postmark) directly from agents
+- **Message History**: Search and browse message threads across channels
+- **Skill Store**: Persist and query structured data for agent skills
 - **Auto-Recall**: Automatically inject relevant context into conversations
 - **Auto-Capture**: Capture important information from completed conversations
-- **CLI Commands**: Debug and manage the plugin from the command line
-- **Multi-User Support**: Flexible user scoping (agent, session, identity)
+- **Bundled Skills**: 4 ready-to-use skills for common workflows
 
 ## Installation
 
+### Via OpenClaw CLI (recommended)
+
 ```bash
-pnpm add @troykelly/openclaw-projects
+openclaw plugins install @troykelly/openclaw-projects
 ```
 
-## Quick Start
+Then configure the plugin in your OpenClaw config file (`~/.openclaw/config.yaml` or equivalent):
 
-```typescript
-import { register } from '@troykelly/openclaw-projects'
+```yaml
+plugins:
+  entries:
+    openclaw-projects:
+      enabled: true
+      config:
+        apiUrl: https://your-backend.example.com
+        apiKey: your-api-key
+```
 
-const plugin = register({
-  config: {
-    apiUrl: 'https://your-backend.example.com',
-    apiKey: process.env.OPENCLAW_API_KEY,
-  },
-})
+### Via npm (for programmatic use)
 
-// Use tools
-const result = await plugin.tools.memoryRecall.execute({
-  query: 'user preferences',
-})
+```bash
+pnpm add @troykelly/openclaw-projects
 ```
 
-## Configuration
+This method is for integrating the plugin programmatically outside of the OpenClaw runtime. Most users should use the OpenClaw CLI method above.
 
-| Option | Type | Default | Description |
-|--------|------|---------|-------------|
-| `apiUrl` | string | **required** | Backend API URL |
-| `apiKey` | string | **required** | API authentication key |
-| `autoRecall` | boolean | `true` | Enable auto-recall hook |
-| `autoCapture` | boolean | `true` | Enable auto-capture hook |
-| `userScoping` | string | `'agent'` | User scoping mode |
-| `maxRecallMemories` | number | `5` | Max memories to return |
-| `minRecallScore` | number | `0.7` | Minimum similarity score |
-| `timeout` | number | `30000` | API timeout (ms) |
-| `maxRetries` | number | `3` | Max retry attempts |
-| `debug` | boolean | `false` | Enable debug logging |
+## Verification
 
-### User Scoping Modes
+After installation, verify the plugin is loaded:
 
-| Mode | Description | Use Case |
-|------|-------------|----------|
-| `agent` | Scope by agent ID | Single user per agent |
-| `session` | Scope by session key | Maximum isolation |
-| `identity` | Scope by canonical identity | Shared identity across agents |
+```bash
+openclaw plugins info openclaw-projects
+```
 
-### Environment Variables
+Check that the plugin is healthy and can reach the backend:
 
 ```bash
-OPENCLAW_API_URL=https://your-backend.example.com
-OPENCLAW_API_KEY=your-api-key
+openclaw plugins doctor
 ```
 
-## Tools
-
-### Memory Tools
+## Configuration
 
-#### `memory_recall`
-Search memories semantically.
+Configure the plugin in your OpenClaw config file or pass config programmatically.
 
-```typescript
-const result = await plugin.tools.memoryRecall.execute({
-  query: 'user preferences for notifications',
-  limit: 10,           // optional, default: 5
-  category: 'preference', // optional filter
-})
-```
+### Required Settings
 
-#### `memory_store`
-Save information to long-term memory.
+| Option | Type | Description |
+|--------|------|-------------|
+| `apiUrl` | string | Backend API URL (must be HTTPS in production) |
+| `apiKey` | string | API authentication key (direct value) |
 
-```typescript
-const result = await plugin.tools.memoryStore.execute({
-  text: 'User prefers dark mode',
-  category: 'preference', // preference, fact, decision, context, other
-  importance: 0.8,        // optional, 0-1
-})
-```
+You must provide the API key via one of three methods:
 
-#### `memory_forget`
-Delete memories (GDPR data portability).
+| Method | Config Key | Description |
+|--------|-----------|-------------|
+| Direct value | `apiKey` | Plaintext key (for development only) |
+| File reference | `apiKeyFile` | Path to file containing key (e.g., `~/.secrets/api_key`) |
+| Command | `apiKeyCommand` | Shell command to retrieve key (e.g., `op read op://Personal/openclaw/api_key`) |
 
-```typescript
-// By ID
-const result = await plugin.tools.memoryForget.execute({
-  memoryId: '123e4567-e89b-12d3-a456-426614174000',
-})
+### Optional Settings
 
-// By query (bulk delete)
-const result = await plugin.tools.memoryForget.execute({
-  query: 'outdated preferences',
-  confirm: true, // required for bulk delete
-})
+| Option | Type | Default | Description |
+|--------|------|---------|-------------|
+| `autoRecall` | boolean | `true` | Inject relevant memories at conversation start |
+| `autoCapture` | boolean | `true` | Capture important info from completed conversations |
+| `userScoping` | string | `'agent'` | User scoping mode (`agent`, `session`, `identity`) |
+| `maxRecallMemories` | number | `5` | Max memories to inject in auto-recall |
+| `minRecallScore` | number | `0.7` | Minimum similarity score for auto-recall (0-1) |
+| `timeout` | number | `30000` | API request timeout (ms) |
+| `maxRetries` | number | `3` | Max retry attempts for failed requests |
+| `debug` | boolean | `false` | Enable debug logging (never logs secrets) |
+
+### Secret Management
+
+All secret fields (API key, Twilio credentials, Postmark token) support three resolution methods. The plugin resolves secrets in priority order: command > file > direct value.
+
+```yaml
+plugins:
+  entries:
+    openclaw-projects:
+      enabled: true
+      config:
+        apiUrl: https://your-backend.example.com
+        # Option 1: Direct value (development only)
+        apiKey: sk-dev-key-here
+        # Option 2: File reference
+        # apiKeyFile: ~/.secrets/openclaw-api-key
+        # Option 3: Command (e.g., 1Password CLI)
+        # apiKeyCommand: op read op://Personal/openclaw/api_key
 ```
 
-### Project Tools
+### Twilio SMS (optional)
 
-#### `project_list`
-List projects with optional filtering.
+To enable SMS sending, add Twilio credentials using the same direct/file/command pattern:
 
-```typescript
-const result = await plugin.tools.projectList.execute({
-  status: 'active', // optional: active, completed, archived, on_hold
-  limit: 20,        // optional
-})
+```yaml
+        twilioAccountSid: AC...
+        twilioAuthToken: your-auth-token
+        twilioPhoneNumber: "+15551234567"
 ```
 
-#### `project_get`
-Get a specific project by ID.
+### Postmark Email (optional)
+
+To enable email sending, add Postmark credentials:
 
-```typescript
-const result = await plugin.tools.projectGet.execute({
-  id: '123e4567-e89b-12d3-a456-426614174000',
-})
+```yaml
+        postmarkToken: your-postmark-token
+        postmarkFromEmail: noreply@example.com
 ```
 
-#### `project_create`
-Create a new project.
+### User Scoping Modes
 
-```typescript
-const result = await plugin.tools.projectCreate.execute({
-  name: 'Home Renovation',
-  description: 'Kitchen remodel project', // optional
-  status: 'active', // optional
-})
-```
+| Mode | Description | Use Case |
+|------|-------------|----------|
+| `agent` | Scope by agent ID | Single user per agent (default) |
+| `session` | Scope by session key | Maximum isolation between sessions |
+| `identity` | Scope by canonical identity | Shared identity across agents |
 
-### Todo Tools
+## Tools
 
-#### `todo_list`
-List todos with optional filtering.
+The plugin registers 27 tools that agents can use. Tools are automatically available to any agent with the plugin enabled.
 
-```typescript
-const result = await plugin.tools.todoList.execute({
-  projectId: '123e4567-e89b-12d3-a456-426614174000', // optional
-  completed: false, // optional
-  limit: 50,        // optional
-})
-```
+### Memory Tools
 
-#### `todo_create`
-Create a new todo.
+| Tool | Description |
+|------|-------------|
+| `memory_recall` | Search memories semantically by query |
+| `memory_store` | Store a new memory (preference, fact, decision, context) |
+| `memory_forget` | Delete memories by ID or search query |
 
-```typescript
-const result = await plugin.tools.todoCreate.execute({
-  title: 'Buy groceries',
-  projectId: '123e4567-e89b-12d3-a456-426614174000', // optional
-  dueDate: '2024-01-15', // optional, ISO 8601
-})
-```
+### Project Tools
 
-#### `todo_complete`
-Mark a todo as complete.
+| Tool | Description |
+|------|-------------|
+| `project_list` | List projects with optional status filter |
+| `project_get` | Get full details of a specific project |
+| `project_create` | Create a new project |
 
-```typescript
-const result = await plugin.tools.todoComplete.execute({
-  id: '123e4567-e89b-12d3-a456-426614174000',
-})
-```
+### Todo Tools
+
+| Tool | Description |
+|------|-------------|
+| `todo_list` | List todos, optionally filtered by project or status |
+| `todo_create` | Create a new todo item |
+| `todo_complete` | Mark a todo as complete |
 
 ### Contact Tools
 
-#### `contact_search`
-Search contacts.
+| Tool | Description |
+|------|-------------|
+| `contact_search` | Search contacts by name, email, or other fields |
+| `contact_get` | Get full details of a specific contact |
+| `contact_create` | Create a new contact |
 
-```typescript
-const result = await plugin.tools.contactSearch.execute({
-  query: 'Alice',
-  limit: 10, // optional
-})
-```
+### Communication Tools
 
-#### `contact_get`
-Get a specific contact by ID.
+| Tool | Description |
+|------|-------------|
+| `sms_send` | Send an SMS message (requires Twilio config) |
+| `email_send` | Send an email message (requires Postmark config) |
+| `message_search` | Search message history semantically |
+| `thread_list` | List message threads (conversations) |
+| `thread_get` | Get a thread with full message history |
 
-```typescript
-const result = await plugin.tools.contactGet.execute({
-  id: '123e4567-e89b-12d3-a456-426614174000',
-})
-```
+### Relationship Tools
 
-#### `contact_create`
-Create a new contact.
+| Tool | Description |
+|------|-------------|
+| `relationship_set` | Record a relationship between contacts |
+| `relationship_query` | Query a contact's relationships |
 
-```typescript
-const result = await plugin.tools.contactCreate.execute({
-  name: 'Alice Smith',
-  email: 'alice@example.com', // optional
-  phone: '+1-555-123-4567',   // optional
-})
-```
+### Skill Store Tools
 
-## Lifecycle Hooks
+| Tool | Description |
+|------|-------------|
+| `skill_store_put` | Store or update data in the skill store |
+| `skill_store_get` | Retrieve an item by ID or composite key |
+| `skill_store_list` | List items with filtering and pagination |
+| `skill_store_delete` | Delete an item (soft delete) |
+| `skill_store_search` | Search items by text or semantic similarity |
+| `skill_store_collections` | List all collections with item counts |
+| `skill_store_aggregate` | Run aggregations on skill store items |
 
-### `beforeAgentStart` (Auto-Recall)
+### Other Tools
 
-Automatically fetches relevant context before the agent processes a prompt.
+| Tool | Description |
+|------|-------------|
+| `file_share` | Generate a time-limited shareable download link |
 
-```typescript
-const context = await plugin.hooks.beforeAgentStart({
-  prompt: 'What are my notification preferences?',
-})
+## Skills
 
-if (context) {
-  // Prepend context.prependContext to the conversation
-}
-```
+The plugin includes 4 bundled skills that agents can invoke as high-level workflows. Skills combine multiple tools to accomplish common tasks.
 
-### `agentEnd` (Auto-Capture)
+### `contact-lookup`
 
-Automatically captures important information after a conversation ends.
+Look up contact information and recent communications.
 
-```typescript
-await plugin.hooks.agentEnd({
-  messages: [
-    { role: 'user', content: 'Remember I prefer email notifications' },
-    { role: 'assistant', content: 'Noted! I will remember your preference.' },
-  ],
-})
+```
+/contact-lookup name="Alice Smith"
 ```
 
-## CLI Commands
+Searches contacts, retrieves details, shows recent messages, related projects/tasks, and stored memories about the person.
 
-The plugin provides CLI command handlers that can be registered with OpenClaw:
+### `daily-summary`
 
-### `status`
-Check API connectivity.
+Get a summary of today's tasks, messages, and activities.
 
-```typescript
-const result = await plugin.cli.status()
-// { success: true, message: 'API is healthy (latency: 50ms)', data: { ... } }
+```
+/daily-summary
 ```
 
-### `users`
-Show user scoping configuration.
+Shows tasks due today, recent messages, upcoming deadlines, and items requiring attention.
 
-```typescript
-const result = await plugin.cli.users()
-// { success: true, data: { scopingMode: 'agent', description: '...', currentUserId: '...' } }
-```
+### `project-status`
 
-### `recall`
-Search memories from CLI.
+Get a status overview of a specific project.
 
-```typescript
-const result = await plugin.cli.recall({ query: 'preferences', limit: 10 })
-// { success: true, data: { memories: [...], query: '...', limit: 10 } }
+```
+/project-status project="Home Renovation"
 ```
 
-### `stats`
-Show memory statistics.
+Shows project overview, task breakdown with completion percentage, recent activity, blockers, and recommended next steps.
 
-```typescript
-const result = await plugin.cli.stats()
-// { success: true, data: { totalMemories: 42, byCategory: { ... } } }
-```
+### `send-reminder`
 
-### `export`
-Export all memories (GDPR data portability).
+Send a reminder message to a contact via SMS or email.
 
-```typescript
-const result = await plugin.cli.export({ output: '/path/to/export.json' })
-// { success: true, data: { memories: [...], exportedAt: '...', userId: '...' } }
+```
+/send-reminder contact="Alice" message="Don't forget the meeting tomorrow" channel="sms"
 ```
 
-## Health Check
+Looks up the contact, verifies their endpoint, sends the message, and confirms delivery.
 
-```typescript
-const health = await plugin.healthCheck()
-if (!health.healthy) {
-  console.error('Plugin unhealthy:', health.error)
-}
-```
+## Lifecycle Hooks
+
+### `before_agent_start` (Auto-Recall)
+
+When `autoRecall` is enabled (default), the plugin automatically searches for relevant memories before each conversation. It uses the user's prompt for semantic search and injects matching memories as context via `prependContext`.
+
+### `agent_end` (Auto-Capture)
+
+When `autoCapture` is enabled (default), the plugin automatically analyzes completed conversations and stores important information (preferences, facts, decisions) as memories for future recall.
 
 ## Security
 
-### API Key Management
+### Secret Management
 
-- Store API keys in environment variables, never in code
-- Use secrets management in production (Vault, AWS Secrets Manager, etc.)
-- Rotate keys regularly
+- Use file references or command execution for secrets in production
+- Direct values are for development only
+- The plugin supports 1Password CLI, Vault, AWS Secrets Manager, or any command-line tool
+- Secret files are checked for world-readable permissions (warns if `chmod 644`)
 
 ### Data Isolation
 
 - All data is scoped to the configured user scope
 - Cross-user access is prevented at the API level
-- Audit logs track all data access
+
+### HTTPS
+
+- HTTPS is required in production (`NODE_ENV=production`)
+- HTTP is permitted for local development only
 
 ### Sensitive Content
 
-- The plugin filters sensitive content (API keys, passwords, credit cards)
-- PII is not logged at info level
+- Secrets are never logged (config is redacted in logs)
 - Error messages are sanitized to prevent information leakage
 
-### HTTPS
-
-- Use HTTPS in production
-- HTTP is only recommended for local development
+## Troubleshooting
 
-## Error Handling
+### Plugin not loading
 
-All tool executions return a result object:
+Verify the plugin is installed and the manifest is detected:
 
-```typescript
-interface ToolResult {
-  success: boolean
-  content?: string   // Human-readable response
-  data?: unknown     // Structured data
-  error?: string     // Error message if success is false
-}
+```bash
+openclaw plugins info openclaw-projects
 ```
 
-## Troubleshooting
-
-### Connection Issues
+### Connection issues
 
-```typescript
-// Check health
-const health = await plugin.healthCheck()
-console.log('Healthy:', health.healthy, 'Error:', health.error)
+Check that the backend API is reachable:
 
-// Check status via CLI
-const status = await plugin.cli.status()
-console.log('Status:', status.message, 'Latency:', status.data?.latencyMs)
+```bash
+openclaw plugins doctor
 ```
 
-### No Memories Found
+### No memories found
 
 - Verify the user scoping mode matches your setup
 - Check that memories were stored for the same user scope
 - Try broadening your search query
 
-### API Errors
+### API errors
 
-- Verify API URL is correct and accessible
-- Check API key is valid
+- Verify `apiUrl` is correct and accessible
+- Check that the API key is valid
 - Review network connectivity
 
-## API Reference
-
-Full TypeScript types are exported:
-
-```typescript
-import type {
-  PluginConfig,
-  PluginInstance,
-  MemoryRecallParams,
-  MemoryStoreParams,
-  ProjectListParams,
-  TodoCreateParams,
-  ContactSearchParams,
-  // ... and more
-} from '@troykelly/openclaw-projects'
-```
-
 ## Contributing
 
 1. Fork the repository
@@ -385,5 +330,6 @@ MIT
 ## Links
 
 - [OpenClaw Documentation](https://docs.openclaw.ai/)
+- [OpenClaw Plugin Guide](https://docs.openclaw.ai/plugins)
 - [openclaw-projects Backend](https://github.com/troykelly/openclaw-projects)
 - [Report Issues](https://github.com/troykelly/openclaw-projects/issues)

package/dist/config.d.ts

@@ -321,4 +321,16 @@ export declare function redactConfig(config: PluginConfig): PluginConfig;
  * @throws If required secrets cannot be resolved
  */
 export declare function resolveConfigSecrets(rawConfig: RawPluginConfig): Promise<PluginConfig>;
+/**
+ * Resolves all secrets synchronously to produce a resolved config.
+ *
+ * Used during plugin registration where blocking I/O is acceptable.
+ * OpenClaw's loader does not await the register function, so all
+ * config resolution must complete synchronously.
+ *
+ * @param rawConfig - The raw plugin configuration with secret references
+ * @returns The resolved plugin configuration with actual secret values
+ * @throws If required secrets cannot be resolved
+ */
+export declare function resolveConfigSecretsSync(rawConfig: RawPluginConfig): PluginConfig;
 //# sourceMappingURL=config.d.ts.map

package/dist/config.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"config.d.ts","sourceRoot":"","sources":["../src/config.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAGvB,mDAAmD;AACnD,eAAO,MAAM,iBAAiB,6CAA2C,CAAA;AACzE,MAAM,MAAM,WAAW,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,iBAAiB,CAAC,CAAA;AAS3D;;;GAGG;AACH,eAAO,MAAM,qBAAqB;IAE9B,oDAAoD;;IAUpD,4CAA4C;;IAE5C,sCAAsC;;IAEtC,wCAAwC;;IAIxC,wCAAwC;;IAExC,iDAAiD;;IAEjD,wCAAwC;;IAIxC,uCAAuC;;IAEvC,gDAAgD;;IAEhD,uCAAuC;;IAIvC,yCAAyC;;IAEzC,kDAAkD;;IAElD,yCAAyC;;IAIzC,wCAAwC;;IAExC,6CAA6C;;IAE7C,oCAAoC;;IAIpC,iDAAiD;;IAEjD,kDAAkD;;IAElD,yCAAyC;;IAGzC,2DAA2D;;IAS3D,mEAAmE;;IAGnE,8DAA8D;;IAG9D,iCAAiC;;IAGjC,gDAAgD;;IAShD,oDAAoD;;IAQpD,sCAAsC;;IAStC,0CAA0C;;IAS1C,gDAAgD;;IAGhD,oEAAoE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EASrE,CAAA;AAEH,MAAM,MAAM,eAAe,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,qBAAqB,CAAC,CAAA;AAEnE;;;GAGG;AACH,eAAO,MAAM,kBAAkB;IAC7B,sBAAsB;;IAGtB,sCAAsC;;IAGtC,kCAAkC;;IAGlC,iCAAiC;;IAGjC,mCAAmC;;IAGnC,8BAA8B;;IAG9B,mCAAmC;;IAGnC,6BAA6B;;IAG7B,2BAA2B;;IAG3B,4BAA4B;;IAG5B,4BAA4B;;IAG5B,iCAAiC;;IAGjC,8BAA8B;;IAG9B,4BAA4B;;IAG5B,sBAAsB;;IAGtB,2BAA2B;;IAG3B,2BAA2B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAE3B,CAAA;AAEF,MAAM,MAAM,YAAY,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,kBAAkB,CAAC,CAAA;AAE7D;;;;GAIG;AACH,wBAAgB,iBAAiB,CAAC,MAAM,EAAE,OAAO,GAAG,eAAe,CAElE;AAED;;;GAGG;AACH,wBAAgB,qBAAqB,CACnC,MAAM,EAAE,OAAO,GACd;IAAE,OAAO,EAAE,IAAI,CAAC;IAAC,IAAI,EAAE,eAAe,CAAA;CAAE,GAAG;IAAE,OAAO,EAAE,KAAK,CAAC;IAAC,MAAM,EAAE,CAAC,CAAC,QAAQ,EAAE,CAAA;CAAE,CAMrF;AAED;;;GAGG;AACH,wBAAgB,cAAc,CAAC,MAAM,EAAE,OAAO,GAAG,YAAY,CAE5D;AAED;;;;;;GAMG;AACH,wBAAgB,kBAAkB,CAChC,MAAM,EAAE,OAAO,GACd;IAAE,OAAO,EAAE,IAAI,CAAC;IAAC,IAAI,EAAE,eAAe,CAAA;CAAE,GAAG;IAAE,OAAO,EAAE,KAAK,CAAC;IAAC,MAAM,EAAE,CAAC,CAAC,QAAQ,EAAE,CAAA;CAAE,CAErF;AAWD;;GAEG;AACH,wBAAgB,YAAY,CAAC,MAAM,EAAE,YAAY,GAAG,YAAY,CAS/D;AAsBD;;;;;;GAMG;AACH,wBAAsB,oBAAoB,CAAC,SAAS,EAAE,eAAe,GAAG,OAAO,CAAC,YAAY,CAAC,CA6C5F"}
+{"version":3,"file":"config.d.ts","sourceRoot":"","sources":["../src/config.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAGvB,mDAAmD;AACnD,eAAO,MAAM,iBAAiB,6CAA2C,CAAA;AACzE,MAAM,MAAM,WAAW,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,iBAAiB,CAAC,CAAA;AAS3D;;;GAGG;AACH,eAAO,MAAM,qBAAqB;IAE9B,oDAAoD;;IAUpD,4CAA4C;;IAE5C,sCAAsC;;IAEtC,wCAAwC;;IAIxC,wCAAwC;;IAExC,iDAAiD;;IAEjD,wCAAwC;;IAIxC,uCAAuC;;IAEvC,gDAAgD;;IAEhD,uCAAuC;;IAIvC,yCAAyC;;IAEzC,kDAAkD;;IAElD,yCAAyC;;IAIzC,wCAAwC;;IAExC,6CAA6C;;IAE7C,oCAAoC;;IAIpC,iDAAiD;;IAEjD,kDAAkD;;IAElD,yCAAyC;;IAGzC,2DAA2D;;IAS3D,mEAAmE;;IAGnE,8DAA8D;;IAG9D,iCAAiC;;IAGjC,gDAAgD;;IAShD,oDAAoD;;IAQpD,sCAAsC;;IAStC,0CAA0C;;IAS1C,gDAAgD;;IAGhD,oEAAoE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EASrE,CAAA;AAEH,MAAM,MAAM,eAAe,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,qBAAqB,CAAC,CAAA;AAEnE;;;GAGG;AACH,eAAO,MAAM,kBAAkB;IAC7B,sBAAsB;;IAGtB,sCAAsC;;IAGtC,kCAAkC;;IAGlC,iCAAiC;;IAGjC,mCAAmC;;IAGnC,8BAA8B;;IAG9B,mCAAmC;;IAGnC,6BAA6B;;IAG7B,2BAA2B;;IAG3B,4BAA4B;;IAG5B,4BAA4B;;IAG5B,iCAAiC;;IAGjC,8BAA8B;;IAG9B,4BAA4B;;IAG5B,sBAAsB;;IAGtB,2BAA2B;;IAG3B,2BAA2B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAE3B,CAAA;AAEF,MAAM,MAAM,YAAY,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,kBAAkB,CAAC,CAAA;AAE7D;;;;GAIG;AACH,wBAAgB,iBAAiB,CAAC,MAAM,EAAE,OAAO,GAAG,eAAe,CAElE;AAED;;;GAGG;AACH,wBAAgB,qBAAqB,CACnC,MAAM,EAAE,OAAO,GACd;IAAE,OAAO,EAAE,IAAI,CAAC;IAAC,IAAI,EAAE,eAAe,CAAA;CAAE,GAAG;IAAE,OAAO,EAAE,KAAK,CAAC;IAAC,MAAM,EAAE,CAAC,CAAC,QAAQ,EAAE,CAAA;CAAE,CAMrF;AAED;;;GAGG;AACH,wBAAgB,cAAc,CAAC,MAAM,EAAE,OAAO,GAAG,YAAY,CAE5D;AAED;;;;;;GAMG;AACH,wBAAgB,kBAAkB,CAChC,MAAM,EAAE,OAAO,GACd;IAAE,OAAO,EAAE,IAAI,CAAC;IAAC,IAAI,EAAE,eAAe,CAAA;CAAE,GAAG;IAAE,OAAO,EAAE,KAAK,CAAC;IAAC,MAAM,EAAE,CAAC,CAAC,QAAQ,EAAE,CAAA;CAAE,CAErF;AAWD;;GAEG;AACH,wBAAgB,YAAY,CAAC,MAAM,EAAE,YAAY,GAAG,YAAY,CAS/D;AAsBD;;;;;;GAMG;AACH,wBAAsB,oBAAoB,CAAC,SAAS,EAAE,eAAe,GAAG,OAAO,CAAC,YAAY,CAAC,CA6C5F;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,wBAAwB,CAAC,SAAS,EAAE,eAAe,GAAG,YAAY,CAyDjF"}

package/dist/config.js

@@ -8,7 +8,7 @@
  * 3. Command reference (e.g., apiKeyCommand: "op read op://...")
  */
 import { z } from 'zod';
-import { resolveSecret } from './secrets.js';
+import { resolveSecret, resolveSecretSync } from './secrets.js';
 /** User scoping strategies for memory isolation */
 export const UserScopingSchema = z.enum(['agent', 'identity', 'session']);
 /**
@@ -284,4 +284,51 @@ export async function resolveConfigSecrets(rawConfig) {
     // Validate the resolved config
     return validateConfig(resolvedConfig);
 }
+/**
+ * Resolves all secrets synchronously to produce a resolved config.
+ *
+ * Used during plugin registration where blocking I/O is acceptable.
+ * OpenClaw's loader does not await the register function, so all
+ * config resolution must complete synchronously.
+ *
+ * @param rawConfig - The raw plugin configuration with secret references
+ * @returns The resolved plugin configuration with actual secret values
+ * @throws If required secrets cannot be resolved
+ */
+export function resolveConfigSecretsSync(rawConfig) {
+    const timeout = rawConfig.secretCommandTimeout;
+    // Resolve API key (required)
+    const apiKey = resolveSecretSync(buildSecretConfig(rawConfig, 'apiKey', timeout), 'apiKey');
+    if (!apiKey) {
+        throw new Error('Failed to resolve API key from config');
+    }
+    // Resolve optional secrets
+    const twilioAccountSid = resolveSecretSync(buildSecretConfig(rawConfig, 'twilioAccountSid', timeout), 'twilioAccountSid');
+    const twilioAuthToken = resolveSecretSync(buildSecretConfig(rawConfig, 'twilioAuthToken', timeout), 'twilioAuthToken');
+    const twilioPhoneNumber = resolveSecretSync(buildSecretConfig(rawConfig, 'twilioPhoneNumber', timeout), 'twilioPhoneNumber');
+    const postmarkToken = resolveSecretSync(buildSecretConfig(rawConfig, 'postmarkToken', timeout), 'postmarkToken');
+    const postmarkFromEmail = resolveSecretSync(buildSecretConfig(rawConfig, 'postmarkFromEmail', timeout), 'postmarkFromEmail');
+    // Build the resolved config
+    const resolvedConfig = {
+        apiUrl: rawConfig.apiUrl,
+        apiKey,
+        twilioAccountSid,
+        twilioAuthToken,
+        twilioPhoneNumber,
+        postmarkToken,
+        postmarkFromEmail,
+        secretCommandTimeout: timeout,
+        autoRecall: rawConfig.autoRecall,
+        autoCapture: rawConfig.autoCapture,
+        userScoping: rawConfig.userScoping,
+        maxRecallMemories: rawConfig.maxRecallMemories,
+        minRecallScore: rawConfig.minRecallScore,
+        timeout: rawConfig.timeout,
+        maxRetries: rawConfig.maxRetries,
+        debug: rawConfig.debug,
+        baseUrl: rawConfig.baseUrl,
+    };
+    // Validate the resolved config
+    return validateConfig(resolvedConfig);
+}
 //# sourceMappingURL=config.js.map