Greenhouse relay control

import os
from flask import Flask, jsonify, request
from gpiozero import OutputDevice

API_KEY = os.environ["EDGE_API_KEY"]
# The only outputs that exist, by name; the agent never sends a pin number.
OUTPUTS = {"grow_light": 17, "fan": 18}
relays = {name: OutputDevice(pin, active_high=False, initial_value=False) for name, pin in OUTPUTS.items()}

app = Flask(__name__)


@app.post("/relay")
def set_relay():
    if request.headers.get("X-API-Key") != API_KEY:
        return jsonify({"error": "unauthorized"}), 401
    body = request.get_json(silent=True) or {}
    output, state = body.get("output"), body.get("state")
    if output not in relays or state not in ("on", "off"):
        return jsonify({"error": "unknown output or state"}), 400
    relays[output].on() if state == "on" else relays[output].off()
    return jsonify({"output": output, "state": state})


if __name__ == "__main__":
    app.run(host="0.0.0.0", port=5001)

import { LuaTool, env } from 'lua-cli';
import { z } from 'zod';

export const OUTPUTS = ['grow_light', 'fan'] as const;

export default class SetOutputTool implements LuaTool {
  name = 'set_output';
  description = 'Turn the grow light or the fan on or off';

  inputSchema = z.object({
    output: z.enum(OUTPUTS),
    state: z.enum(['on', 'off']),
  });

  async execute(input: z.infer<typeof this.inputSchema>) {
    const base = env('RELAY_CONTROLLER_URL');
    const key = env('RELAY_CONTROLLER_KEY');
    if (!base || !key) {
      throw new Error('RELAY_CONTROLLER_URL and RELAY_CONTROLLER_KEY must be set');
    }

    const res = await fetch(`${base}/relay`, {
      method: 'POST',
      headers: { 'Content-Type': 'application/json', 'X-API-Key': key },
      body: JSON.stringify(input),
    });
    if (!res.ok) {
      throw new Error(`Relay controller responded ${res.status}`);
    }

    return (await res.json()) as { output: string; state: 'on' | 'off' };
  }
}

import { LuaSkill } from 'lua-cli';
import SetOutputTool from './tools/SetOutputTool';

export default new LuaSkill({
  name: 'greenhouse',
  description: 'Switch the greenhouse grow light and fan',
  context: `set_output switches one output at a time. Confirm which output the user means
when it is ambiguous, and repeat the new state back after the call.
Do not toggle an output more than once per request.`,
  tools: [new SetOutputTool()],
});

import { LuaJob, User, env } from 'lua-cli';
import SetOutputTool from '../skills/tools/SetOutputTool';

export default new LuaJob({
  name: 'lights-out',
  description: 'Turn the grow light off at 22:00 every night and tell the owner',
  schedule: { type: 'cron', expression: '0 22 * * *', timezone: 'Europe/Berlin' },
  timeout: 30,
  retry: { maxAttempts: 3, backoffSeconds: 60 },

  execute: async () => {
    const result = await new SetOutputTool().execute({ output: 'grow_light', state: 'off' });

    // A job runs outside any conversation, so the recipient is configured, not implied.
    const ownerId = env('OWNER_USER_ID');
    const owner = ownerId ? await User.get(ownerId) : null;
    await owner?.send([{ type: 'text', text: 'The grow light is off for the night.' }]);

    return result;
  },
});

import { LuaAgent } from 'lua-cli';
import greenhouseSkill from './skills/greenhouse.skill';
import lightsOut from './jobs/LightsOutJob';

const agent = new LuaAgent({
  name: 'greenhouse-control',
  persona: `You control the outputs in a small greenhouse: a grow light and a fan.
Confirm which output you are switching, switch it once, and report the new state.
If the controller is unreachable, say so and do not retry on your own.`,
  skills: [greenhouseSkill],
  jobs: [lightsOut],
});