Door access over WhatsApp

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

API_KEY = os.environ["EDGE_API_KEY"]
# The only doors that exist, by name; the agent never sends a pin number.
DOORS = {"front": 17, "garage": 27}
MAX_UNLOCK_MS = 10000

app = Flask(__name__)
last_unlock = 0.0


@app.get("/health")
def health():
    return jsonify({"ok": True})


@app.post("/door/unlock")
def unlock():
    global last_unlock
    if request.headers.get("X-API-Key") != API_KEY:
        return jsonify({"error": "unauthorized"}), 401
    body = request.get_json(silent=True) or {}
    door = body.get("door")
    if door not in DOORS:
        return jsonify({"error": "unknown door"}), 400
    if time.time() - last_unlock < 2:
        return jsonify({"error": "rate limited"}), 429
    ms = min(int(body.get("ms", 3000)), MAX_UNLOCK_MS)

    relay = OutputDevice(DOORS[door], active_high=False, initial_value=False)
    try:
        relay.on()
        time.sleep(ms / 1000)
        relay.off()
    finally:
        relay.close()
    last_unlock = time.time()
    return jsonify({"ok": True, "door": door, "ms": ms})


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

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

export const DOORS = ['front', 'garage'] as const;

export default class UnlockDoorTool implements LuaTool {
  name = 'unlock_door';
  description =
    'Unlock a door for the guest in this conversation. Refuses when they have no active booking for that door.';

  inputSchema = z.object({
    door: z.enum(DOORS).describe('Which door to unlock'),
  });

  async execute(input: z.infer<typeof this.inputSchema>) {
    // Identity comes from the channel's verified phone number, never from the model.
    const user = await User.get();
    const phones = user?._luaProfile.mobileNumbers ?? [];
    if (!user || phones.length === 0) {
      return { unlocked: false, reason: 'This channel has no verified phone number' };
    }

    const now = Date.now();
    const bookings = await Data.get(
      'guests',
      { phone: { $in: phones }, status: 'active', startAt: { $lte: now }, endAt: { $gte: now } },
      1,
      10,
    );
    const booking = bookings.data.find(
      (b) => Array.isArray(b.data.doors) && b.data.doors.includes(input.door),
    );
    if (!booking) {
      return { unlocked: false, reason: 'No active booking for this door; suggest the front desk' };
    }

    // Three unlocks per minute per guest, on top of the throttle on the controller.
    const recent = await Data.get(
      'door_logs',
      { userId: user._luaProfile.userId, at: { $gte: now - 60_000 } },
      1,
      3,
    );
    if (recent.data.length >= 3) {
      return { unlocked: false, reason: 'Too many unlock requests in the last minute' };
    }

    const base = env('DOOR_CONTROLLER_URL');
    const key = env('DOOR_CONTROLLER_KEY');
    if (!base || !key) {
      throw new Error('DOOR_CONTROLLER_URL and DOOR_CONTROLLER_KEY must be set');
    }
    const ms = Number(env('UNLOCK_MS') ?? 3000);
    const res = await fetch(`${base}/door/unlock`, {
      method: 'POST',
      headers: { 'Content-Type': 'application/json', 'X-API-Key': key },
      body: JSON.stringify({ door: input.door, ms }),
    });
    if (!res.ok) {
      throw new Error(`Door controller responded ${res.status}`);
    }

    await Data.create(
      'door_logs',
      { userId: user._luaProfile.userId, door: input.door, bookingId: booking.id, at: now },
      `unlock ${input.door} ${user._luaProfile.userId}`,
    );

    return { unlocked: true, door: input.door, relocksInSeconds: Math.round(ms / 1000) };
  }
}

import { LuaTool, Data, User } from 'lua-cli';
import { z } from 'zod';
import { DOORS } from './UnlockDoorTool';

export default class RegisterGuestTool implements LuaTool {
  name = 'register_guest';
  description = 'Staff only: give a guest phone number access to doors between check-in and check-out';

  inputSchema = z.object({
    phone: z.string().regex(/^\+[1-9]\d{6,14}$/).describe('Guest WhatsApp number in E.164 form'),
    name: z.string(),
    doors: z.array(z.enum(DOORS)).min(1),
    startAt: z.string().datetime().describe('Check-in, ISO 8601'),
    endAt: z.string().datetime().describe('Check-out, ISO 8601'),
  });

  // Hidden from the model unless the person in the conversation is staff.
  async condition() {
    const user = await User.get();
    return user?.data.role === 'staff';
  }

  async execute(input: z.infer<typeof this.inputSchema>) {
    const startAt = Date.parse(input.startAt);
    const endAt = Date.parse(input.endAt);
    if (startAt >= endAt) {
      return { registered: false, reason: 'Check-out must be after check-in' };
    }

    const entry = await Data.create(
      'guests',
      { phone: input.phone, name: input.name, doors: input.doors, startAt, endAt, status: 'active' },
      `${input.name} ${input.phone} ${input.doors.join(' ')}`,
    );

    return { registered: true, bookingId: entry.id, doors: input.doors, validUntil: input.endAt };
  }
}

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

export default new LuaSkill({
  name: 'door-access',
  description: 'Unlock building doors for guests with an active booking',
  context: `Guests message on WhatsApp to open a door. Ask which door if it is unclear (front or
garage), then call unlock_door; it checks the booking itself, so never argue with a refusal.
Report how long the door stays open. Staff use register_guest at check-in.`,
  tools: [new UnlockDoorTool(), new RegisterGuestTool()],
});

import { LuaAgent } from 'lua-cli';
import doorAccessSkill from './skills/door-access.skill';

const agent = new LuaAgent({
  name: 'harbor-house-doors',
  persona: `You are the door assistant for Harbor House.
Be brief. Unlock only through the tool, confirm the door name before unlocking, and when
access is refused, say why in one sentence and point the guest to the front desk.
Never mention pins, wiring, or the controller.`,
  skills: [doorAccessSkill],
});

✅ Compiled 4 primitives (1 agent, 1 skill, 2 tools) in 520ms
✅ Selected tool: unlock_door
Input: {
  "door": "front"
}
🚀 Executing tool...
✅ Tool execution successful!

Tool returned: Object — fields: unlocked, reason
Output:
{ unlocked: false, reason: 'This channel has no verified phone number' }