base44/skills

sync-sdk-skill

Synchronize the base44-sdk skill with the latest SDK source code from the Base44 SDK repository

View source

How to use

  1. Copy the installation command and review the source package before installing it in your own agent environment.
  2. Check the source document for required tools, credentials and supported hosts.
  3. Describe your input and desired deliverable; review the output against the source material.
npx skills add https://github.com/base44/skills --skill sync-sdk-skill

Before you start

  • Installation does not include a model subscription, API allowance or permission to access your files.
  • Repository stars and installation counts describe activity, not an independent quality or security test.
Original skill document

Rendered from the source repository. Headings, examples, code, tables, links, and referenced images are preserved.

Sync SDK Skill

Synchronize the skills/base44-sdk/ skill with the latest SDK source code from the Base44 SDK repository.

Usage

When activated, this command will ask for:

  1. SDK source folder path (required) - The local path to the Base44 SDK source code
  2. Documentation URL (optional) - URL to fetch additional documentation

Steps

Step 1: Gather Input

Ask the user for the required inputs using the AskQuestion tool if available, otherwise ask conversationally:

Required:

  • SDK source folder path (e.g., ~/projects/base44-sdk or /Users/me/base44-sdk)

Optional:

  • Documentation URL (e.g., https://docs.base44.com/sdk)

If the user provided these in the initial prompt, use those values.

Step 2: Validate Source Folder

  1. Check that the provided path exists and contains SDK source code
  2. Look for these key indicators:
  • package.json with @base44/sdk or similar SDK-related content
  • src/ directory with module implementations
  • TypeScript/JavaScript files with SDK module exports (e.g., entities.ts, auth.ts, client.ts)

If validation fails, ask the user to verify the path.

Step 3: Discover SDK Modules

Scan the SDK source folder to find all available modules. Look for:

  1. Module files in directories like:
  • src/
  • src/modules/
  • lib/
  1. For each module, extract:
  • Module name and exports
  • Available methods and their signatures
  • Method parameters and types
  • Return types
  • Usage examples (if present in source or JSDoc)
  • Submodules (e.g., integrations.Core, integrations.custom)
  1. Parse module definitions from:
  • TypeScript interfaces and types
  • Class definitions and methods
  • JSDoc comments and annotations
  • Export statements
  1. Key modules to look for:
  • entities - CRUD operations on data models
  • auth - Login, register, user management
  • agents - AI conversations and messages
  • functions - Backend function invocation
  • integrations - AI, email, file uploads, custom APIs
  • connectors - OAuth tokens (service role only)
  • analytics - Track custom events
  • appLogs - Log user activity
  • users - User invitations
  • client - Client creation and configuration

Step 4: Read Existing Skill

Read the current skill files to understand what needs updating:

skills/base44-sdk/
├── SKILL.md
└── references/
    ├── analytics.md
    ├── app-logs.md
    ├── auth.md
    ├── base44-agents.md
    ├── client.md
    ├── connectors.md
    ├── entities.md
    ├── functions.md
    ├── integrations.md
    └── users.md

Step 5: Compare and Identify Changes

Compare discovered SDK modules with existing skill documentation:

  1. New modules: Modules in source but not in skill references
  2. New methods: Methods added to existing modules
  3. Updated methods: Methods with changed signatures, parameters, or return types
  4. Deprecated methods: Methods marked as deprecated
  5. Removed methods: Methods in skill but not in source (verify before removing)
  6. New parameters: New options added to existing methods

Create a summary of changes to show the user before applying.

Step 6: Fetch External Documentation (Optional)

If a documentation URL was provided:

  1. Fetch the documentation page
  2. Extract relevant module and method documentation
  3. Use this to supplement information from source code
  4. Cross-reference for accuracy

Step 7: Update Skill Files

For each change identified:

Update Reference Files

For each module, update or create references/{module-name}.md:

markdown
# {ModuleName} Module

{Description from source}

## Overview

{Brief explanation of what the module does}

## Methods

### `{methodName}(params)`

{Method description}

**Parameters:**

| Parameter | Type | Description | Required |
|-----------|------|-------------|----------|
| `param1` | `string` | {description} | Yes |
| `options` | `object` | {description} | No |

**Returns:** `Promise<{ReturnType}>`

**Example:**

const result = await base44.{module}.{methodName}({ param1: "value" });


## Notes

{Any important behavioral notes, frontend/backend availability, etc.}

Update SKILL.md

  1. Update the SDK Modules table if modules changed
  2. Update Quick Start if core patterns changed
  3. Update Module Selection section with new capabilities
  4. Update Common Patterns with new usage examples
  5. Update Frontend vs Backend table if availability changed
  6. Keep the existing structure and formatting
  7. Do NOT change the frontmatter description unless explicitly asked

Step 8: Present Summary

After updates, present a summary to the user:

## Sync Summary

### Files Updated
- references/new-module.md (created)
- references/entities.md (updated methods)
- SKILL.md (updated module table)

### Changes Made
- Added new module: `newModule`
- Updated `entities` module: added `bulkCreate()` method
- Added new parameter `options.cache` to `auth.me()`
- Deprecated `integrations.legacyMethod()`

### Manual Review Recommended
- [List any changes that need verification]

Important Notes

  • Preserve existing content: Don't remove detailed explanations, examples, or warnings unless they're outdated
  • Keep formatting consistent: Match the existing style of SKILL.md and reference files
  • Maintain progressive disclosure: Keep detailed docs in references, summaries in SKILL.md
  • Flag uncertainties: If source code is unclear, flag it for manual review
  • Document frontend/backend availability: Always note if a method is backend-only (e.g., connectors, asServiceRole)
  • Preserve type information: Include TypeScript types in method signatures
  • Keep examples practical: Examples should reflect real-world usage patterns

Module-Specific Guidelines

entities.md

  • Document CRUD methods: create, get, list, filter, update, delete
  • Include query filter syntax and operators
  • Document subscribe() for real-time updates
  • Note RLS/FLS security implications if applicable

auth.md

  • Cover all authentication methods (email/password, OAuth, etc.)
  • Document me(), updateMe(), logout()
  • Include redirect flow examples
  • Note token handling

integrations.md

  • Document Core submodule methods (InvokeLLM, SendEmail, UploadFile, GenerateImage)
  • Document custom.call() for custom integrations
  • Include AI prompt examples

connectors.md

  • Note this is service role / backend only
  • Document getAccessToken() for OAuth providers

functions.md

  • Show both frontend invocation and backend implementation
  • Include createClientFromRequest() usage
  • Document asServiceRole access patterns

Troubleshooting

IssueSolution
Can't find module filesTry searching for export class or export function patterns
Types not detectedLook for .d.ts files or inline TypeScript annotations
Missing method descriptionsCheck for JSDoc comments (/** ... */) above methods
Submodule structureModules like integrations.Core may be in nested files
Return types unclearCheck TypeScript generics and Promise wrappers

Related by task

from this repository

More skills

All skills
base44
Community

base44-cli

The base44 CLI is used for EVERYTHING related to base44 projects: resource configuration (entities, backend functions, realtime actors, ai agents), initialization and actions (resource creation, deployment), and any other operation on an existing app or workspace through the Base44 public API (settings, domains, users, members, source export). This skill is the place for learning about how to configure resources, including actors — the realtime/WebSocket primitive behind multiplayer, collaborati

1h installs
9
GitHub stars
94
Updated
Nov 15
base44
Community

base44-platform-actors

Base44 realtime actors: stateful server rooms over WebSockets (Durable Objects) under base44/actors/ /entry.ts for multiplayer, collaborative boards, presence, live cursors, chat rooms and auctions, with the actor contract, rules and the React client. Use when users interact live in one shared session.

1h installs
9
GitHub stars
94
Updated
Nov 15
base44
Community

base44-platform-agents

Base44 in-app AI agents: JSON agent configs under base44/agents/ with entity, backend-function or server-route tools, WhatsApp and Telegram channels, the agents SDK for conversation UIs, and code agents (an agent loop the app runs on the AI gateway). Use when the app needs a conversational assistant or programmable AI.

1h installs
9
GitHub stars
94
Updated
Nov 15
base44
Community

base44-platform-connectors

Base44 app connectors: OAuth integrations with external services (Google, Slack, GitHub and more) in shared, app-user and BYO-shared modes, how to connect one from an external agent, and how server code reads the token with getConnection. Use when the app must act on a user's or the builder's account at a third-party service.

1h installs
9
GitHub stars
94
Updated
Nov 15