---

What OpenYida Provides

OpenYida is a bridge between AI coding tools and Yida. It gives agents a stable command-line interface for the full application lifecycle:

Area	What you can do
Application delivery	Create, update, export, and import Yida applications
Form modeling	Create forms, update fields, inspect schemas, and manage permissions
Custom pages	Generate React-based pages, lint Yida runtime rules, compile, and publish
Workflow automation	Create process forms, configure approval flows, preview process instances
Data operations	Query form/process/task/subform data and run anomaly checks
Integrations	Manage HTTP connectors, connector actions, auth accounts, and automation flows
Operations	Diagnose environment issues, manage login state, configure sharing, upload CDN assets

The result remains a native Yida application: teams can continue editing it in Yida, use existing enterprise security controls, and deploy through the Yida platform.

Quick Start

1. Install

npm install -g openyida

OpenYida requires Node.js 18 or later. The package exposes both openyida and yida commands.

If Codex is already installed, OpenYida also imports a local Codex plugin during postinstall. Restart Codex after installation, then type @宜搭 or @openyida in the composer to attach the OpenYida context.

2. Check Your Environment

Run this from the AI coding workspace where you want OpenYida to operate:

openyida env
openyida env --json
openyida commands --json

OpenYida detects the active agent environment, workspace path, login state, and organization context. Use --json when an agent needs a stable machine-readable snapshot. openyida commands --json emits the command manifest used by the CLI help, so agents can inspect available routes without scraping terminal output.

3. Log In

openyida login

In Codex, OpenYida returns a browser handoff when no valid cached login exists. The Codex agent should open login_url in the in-app browser, let DingTalk/Yida handle QR scan and organization selection in the real login page, then re-run openyida login --check-only --json to verify whether a CLI Cookie bridge has written credentials. If the current Browser Use runtime cannot navigate directly to an external URL, open a temporary local redirect page in the in-app browser and let that page redirect to login_url.

The older Codex QR polling flow remains available as an explicit fallback:

openyida login --codex-qr

For terminal QR login, use:

openyida login --qr
openyida login --qr --corp-id dingxxxxxxxx
openyida login --check-only --json

Qoder and Wukong keep using the built-in browser handoff. OpenYida does not install Playwright by default.

4. Build With an AI Agent

Ask your coding agent for a concrete Yida application or workflow:

Create a CRM application in Yida with customer, contact, opportunity, and follow-up forms.
Build an IPD workflow for chip production, including approval nodes and dashboard pages.
Generate a public landing page and publish it to my Yida app.

The agent can then call OpenYida commands to create the application, generate source files, publish pages, and return the final Yida URLs. In Codex, Qoder, and Wukong environments, successful creation and publish commands also include a browser handoff so the agent can open the resulting Yida page in the in-app browser. Use --open to force this handoff or --no-open to suppress it.

Wukong Installation

Wukong uses manual skill package installation instead of npm:

1. Download the latest .zip skill package from GitHub Releases.
2. Open Wukong.
3. Go to Skill Center > Upload Skill and select the downloaded package.

For Wukong terminal work, make sure its bundled Node.js path is active before running node, npm, or npx commands:

export PATH="$HOME/.real/.bin/node/bin:$PATH"

Supported AI Coding Tools

Tool	Support
Codex	Full support
Claude Code	Full support
Aone Copilot	Full support
OpenCode	Full support
Cursor	Full support
Visual Studio Code	Full support
Qoder	Full support
Wukong	Full support

How It Works

flowchart LR
  A["AI coding agent"] --> B["OpenYida CLI"]
  B --> C["Environment detection"]
  B --> D["Login and organization context"]
  B --> E["Yida API operations"]
  B --> F["Local page generation and compile"]
  E --> G["Native Yida app"]
  F --> G

OpenYida keeps platform-specific behavior inside the CLI, while agents interact with predictable commands and project files.

Project Layout

openyida/
├── bin/yida.js                 # CLI entry and command routing
├── lib/
│   ├── app/                    # Application, form, page, import/export commands
│   ├── auth/                   # Login, QR login, browser handoff, organization switch
│   ├── connector/              # HTTP connector lifecycle and smart creation
│   ├── core/                   # Environment detection, i18n, diagnostics, data commands
│   ├── process/                # Process form creation, configuration, preview
│   ├── report/                 # Yida report and chart generation
│   └── samples/                # Templates emitted by openyida sample
├── project/                    # Default workspace template for generated Yida projects
├── yida-skills/                # Agent skills and Yida API references
└── scripts/                    # CI, packaging, and installation helpers

Capabilities

Application and Form Management

openyida create-app "CRM"
openyida create-app --name "CRM" --desc "Customer management" --theme deepBlue
openyida app-list --size 20
openyida create-form create APP_XXX "Customer" fields.json
openyida create-form update APP_XXX FORM_XXX changes.json
openyida get-schema APP_XXX FORM_XXX
openyida get-schema APP_XXX --all --output-dir .cache/schemas

Custom Page Development

openyida create-page APP_XXX "Dashboard"
openyida generate-page product-homepage --spec page.json --output pages/src/home.jsx --compile
openyida check-page pages/src/home.jsx
openyida compile pages/src/home.jsx
openyida publish pages/src/home.jsx APP_XXX FORM_XXX

generate-page turns a structured spec into a Page IR, renders a curated React 16-compatible template, writes a .openyida-page.json manifest, and optionally compiles the result. The manifest makes follow-up AI edits safer because agents can update known blocks instead of rewriting a large JSX file by hand.

Workflow, Data, and Permissions

openyida create-process APP_XXX "Purchase Request" fields.json process.json
openyida configure-process APP_XXX FORM_XXX process.json
openyida process preview APP_XXX PROC_INST_XXX --output process.html
openyida data query form APP_XXX FORM_XXX --page 1 --size 20
openyida get-permission APP_XXX FORM_XXX

When creating or updating test data with openyida data, Yida date fields must use 13-digit millisecond timestamps, for example "dateField_xxx": 1719705600000. Do not submit YYYY-MM-DD strings for DateField or CascadeDateField values.

Connectors, Integrations, and Reports

openyida connector smart-create --curl "curl https://api.example.com/users"
openyida connector list
openyida integration create APP_XXX FORM_XXX "Sync customer data"
openyida create-report APP_XXX "Sales Dashboard" charts.json
openyida append-chart APP_XXX REPORT_XXX chart.json

CLI Reference

Run openyida --help or openyida <command> --help for detailed usage.

Environment and Authentication

Command	Description
openyida env [--json]	Detect the active AI tool environment and login state
openyida env <list|show|switch|add|remove>	Manage public/private Yida environment profiles
openyida commands [--json]	Emit the machine-readable command manifest
openyida login [--qr|--codex|--codex-qr|--browser] [--corp-id <corpId>]	Log in to Yida
openyida logout	Log out or switch account
openyida auth <status|login|refresh|logout>	Manage login status
openyida org list	List accessible organizations
openyida org switch --corp-id <corpId>	Switch organization without logging in again

Applications

Command	Description
openyida app-list [--size N]	List Yida applications
openyida create-app "<name>"|--name <name> [options] [--open|--no-open]	Create an application and output appType
openyida update-app <appType> --name "..."	Update application metadata
openyida export <appType> [output]	Export an application migration package
openyida import <file> [name]	Import a migration package into a target environment

Forms and Pages

Command	Description
openyida create-form create <appType> "<name>" <fields.json> [--open|--no-open]	Create a form page
openyida create-form update <appType> <formUuid> <changes.json> [--open|--no-open]	Update a form page
openyida list-forms <appType> [--keyword <text>]	List forms in an application
openyida get-schema <appType> <formUuid|--all>	Fetch one form schema or batch export all schemas
openyida create-page <appType> "<name>" [--open|--no-open]	Create a custom display page
openyida generate-page <template> [--spec file]	Generate custom page source from templates
openyida check-page <sourceFile> [--json]	Check page compatibility with Yida runtime rules
openyida compile <sourceFile>	Compile a custom page locally
openyida publish <sourceFile> <appType> <formUuid> [--open|--no-open]	Compile and publish a custom page
openyida update-form-config <appType> <formUuid> <isRenderNav> <title>	Update page/form display configuration

Data, Permissions, and Sharing

Command	Description
openyida data <action> <resource> [args]	Unified data management for forms, processes, tasks, and subforms
openyida data check <appType> <formUuid> <rules.json>	Detect anomalous process-form records
openyida task-center <type> [options]	Query todo, created, processed, CC, or proxy-submitted tasks
openyida get-permission <appType> <formUuid>	Query form permission configuration
openyida save-permission <appType> <formUuid> [options]	Save form permission configuration
openyida verify-short-url <appType> <formUuid> <url>	Verify a short URL
openyida save-share-config <appType> <formUuid> <url> <isOpen> [openAuth]	Save public access or sharing configuration
openyida get-page-config <appType> <formUuid>	Query public access or sharing configuration

Workflow, Reports, and Integrations

Command	Description
openyida create-process <appType> ...	Create a process form and configure workflow
openyida configure-process <appType> ...	Configure and publish process rules
openyida process preview <appType> <processInstanceId> [--output <path>]	Generate a visual process preview
openyida create-report <appType> "<name>" <charts.json> [--open|--no-open]	Create a Yida report
openyida append-chart <appType> <reportId> <charts.json> [--open|--no-open]	Append a chart to an existing report
openyida connector <sub-command>	Manage HTTP connectors, actions, tests, and auth accounts
openyida integration create <appType> <formUuid> <flowName> [options]	Create an integration automation flow
openyida dws <command> [args]	Access DingTalk CLI capabilities such as contacts, calendar, todo, and approval

Utilities

Command	Description
openyida copy [--force]	Initialize the local project/ workspace
openyida sample [--list]	Emit sample templates
openyida doctor [--fix]	Diagnose and repair environment issues
openyida formula evaluate <formula|file> [--schema file]	Static-check formula syntax and field references
openyida update	Update OpenYida through npm
openyida export-conversation [options]	Export AI conversation history
openyida flash-to-prd --file <path> --name "<project>"	Convert flash notes or meeting notes into a PRD prompt
openyida cdn-config	Configure image upload to Aliyun OSS/CDN
openyida cdn-upload <image-path>	Upload an image to CDN
openyida cdn-refresh [options]	Refresh CDN cache

Agent Skills

The yida-skills/ directory contains agent-facing instructions and references for common Yida workflows. It is organized as a small skill library:

Path	Purpose
yida-skills/SKILL.md	Entry point and skill index
yida-skills/skills/	Self-contained sub-skills for app, form, process, page, data, and integration work
yida-skills/references/	Shared Yida API, model API, and query-condition references

When OpenYida is used inside a supported AI coding environment, these skills help the agent choose the right command sequence and file conventions.

For Codex, npm install -g openyida additionally creates a local plugin marketplace under ~/.openyida/codex-plugin and enables openyida@openyida in ~/.codex/config.toml when Codex is detected. This makes OpenYida show up in Codex's @ plugin menu as 宜搭 after Codex reloads.

Examples

Business Systems: IPD and CRM

Describe your requirements in one sentence; the agent can create a complete multi-form Yida application.

Custom Pages and Utilities

Interactive Campaigns

Common Prompts

Build a Yida application for [business scenario].
Generate an app from this requirements document.
Create a [name] form page with these fields.
Add a required [field type] field named [field name] to [form name].
Publish this custom page to the Yida app.
Make this page publicly accessible.
Export the application as a migration package.

OpenClaw Integration

Use OpenYida through yida-app in OpenClaw:

npx clawhub@latest install nicky1108/yida-app

Development

git clone https://github.com/openyida/openyida.git
cd openyida
npm install
npm run check:ci

Useful checks:

Command	Purpose
npm test	Run Jest tests
npm run lint	Run ESLint
npm run check:syntax	Validate JavaScript syntax
npm run check:structure	Validate project structure
npm run check:package	Validate npm package contents

When adding new CLI commands, register the route in bin/yida.js, add it to lib/core/command-manifest.js, update user-facing documentation here, and keep agent skills in yida-skills/ aligned when the workflow changes.

Security and Configuration

• Login cookies are cached locally and should never be hard-coded into source files.
• Private deployment environments are managed through lib/core/env-manager.js.
• Yida API requests should use the active environment base URL and authenticated cookies.
• For multi-organization accounts, prefer explicit --corp-id values in non-interactive automation.

Community

Scan the QR code to join the OpenYida DingTalk user group for updates and support.

Contributors

Thanks to everyone who has contributed to OpenYida. Read the Contributing Guide to get involved.

License

MIT © 2026 Alibaba Group Holding Limited