Project: jobs, meta-language, build chain

The "Project" node ties description, code, build and deployment into one loop. Commands run at the agent on your machine, the canvas keeps state and history.

The "Project" node

"Components → ⚑ Project" places a card with a name, bundle_name, version, repository, agent, folder and code path, build targets per platform and a deploy command. In the inspector the version is bumped by patch, minor or major and written to pubspec.yaml through the agent. "⚙ Build jobs" creates a "⚙ Job" node per target, commands may use ${version}, ${bundleName}, ${name} and ${metaOut}. "▣ Project frame" groups the card and the jobs, and the code schema and tasks open from there. The "Project" workplace profile sets the palette up for this work.

Jobs at the agent

"Flow → ⚙ Job": the agent as agent:<name>, a command such as docker compose up -d, bash tools/dist/build_linux.sh or ./deploy.sh, and for services a stop command. The ▶ button above the card runs the command at the agent, which checks its allow list in agent.json. The log streams into the node and is visible in the inspector, the state and exit code arrive at the end. ■ stops: the stop command if set, and a signal to the process.

"exec": {
  "allow": ["docker compose *", "bash tools/dist/*", "make *"],
  "cwd": "/srv/app",
  "timeoutSeconds": 120
}

Permissions match the agent-exec action: write access in the room and the cap.shell capability.

Project meta-language

A project has a "meta file" field: text in a language described in f2plw, for example a database schema, an API description or your own language. The path points inside the agent folder or, as node:<key>, to a "Code in a language" node on the canvas. Several files are listed with ; or on separate lines, the language of each is taken from its extension unless set explicitly.

"⚙ Generate" reads the files at the agent, hands them to the language sidecar, and the outputs of the language generation rules are written as a tree into the agent folder named in "outputs to", gen/ by default. A project without an agent takes the meta description from canvas nodes and writes outputs to the workspace sandbox folder on the server. Then the usual build jobs follow, commands may use ${metaOut}.

Build chain

"⚡ Build chain" in the project inspector places a "Start" node, a "Generate" step and a "Build" step per job, connected by exec edges in order. The server runs it: on schedule, by webhook or with "run now". Generation writes outputs to the agent, then jobs run in order, a step waits for the job to finish for up to twenty minutes and stops the chain on a non-zero exit code. Deployment never starts after a failed build. Logs and results arrive in the job nodes exactly as with a manual run. Pressing again rebuilds the chain, dropped steps are removed.

Permissions

Generation needs cap.file, starting jobs needs cap.shell. A manual ▶ on a chain step reports that the step is run by the server.

← Code on the canvas: schema, editor, LSP Tasks and trackers →