@agent-native/core 0.7.12 → 0.7.14

package/dist/org/handlers.js

@@ -49,7 +49,7 @@ async function exec() {
 }
 function requireAuthEmail(session) {
     const email = session?.email;
-    if (!email || email === "local@localhost") {
+    if (!email) {
         throw createError({ statusCode: 401, message: "Authentication required" });
     }
     return email;
@@ -57,16 +57,6 @@ function requireAuthEmail(session) {
 /** GET /_agent-native/org/me — current user's active org, all orgs, pending invitations */
 export const getMyOrgHandler = defineEventHandler(async (event) => {
     const ctx = await getOrgContext(event);
-    if (ctx.email === "local@localhost") {
-        return {
-            email: ctx.email,
-            orgId: null,
-            orgName: null,
-            role: null,
-            orgs: [],
-            pendingInvitations: [],
-        };
-    }
     const e = await exec();
     const allOrgsRes = await e.execute({
         sql: `SELECT m.org_id AS "orgId", m.role AS role, o.name AS "orgName"
@@ -80,12 +70,54 @@ export const getMyOrgHandler = defineEventHandler(async (event) => {
         role: String(r.role),
         orgName: String(r.orgName ?? r.org_name),
     }));
+    let domainMatches = [];
+    if (!ctx.orgId) {
+        const domain = ctx.email.split("@")[1]?.toLowerCase();
+        if (domain) {
+            try {
+                const dmRes = await e.execute({
+                    sql: `SELECT id, name FROM organizations WHERE LOWER(allowed_domain) = ?`,
+                    args: [domain],
+                });
+                domainMatches = dmRes.rows.map((r) => ({
+                    orgId: String(r.id),
+                    orgName: String(r.name),
+                }));
+            }
+            catch {
+                // allowed_domain column may not exist yet if migration hasn't run
+            }
+        }
+    }
+    let allowedDomain = null;
+    let a2aSecret = null;
+    if (ctx.orgId) {
+        try {
+            const adRes = await e.execute({
+                sql: `SELECT allowed_domain, a2a_secret FROM organizations WHERE id = ? LIMIT 1`,
+                args: [ctx.orgId],
+            });
+            if (adRes.rows[0]) {
+                allowedDomain =
+                    String(adRes.rows[0].allowed_domain ?? "") || null;
+                a2aSecret = String(adRes.rows[0].a2a_secret ?? "") || null;
+            }
+        }
+        catch {
+            // Column may not exist yet
+        }
+    }
+    const isOwnerOrAdmin = ctx.role === "owner" || ctx.role === "admin";
     const invitesRes = await e.execute({
+        // Case-insensitive match: invitations are stored with whatever case
+        // the inviter typed, but the session email may be normalized
+        // differently by the auth provider. LOWER(both sides) keeps these
+        // discoverable and matches getOrgContext.hasPendingInvitation.
         sql: `SELECT i.id AS id, i.org_id AS "orgId", o.name AS "orgName", i.invited_by AS "invitedBy"
           FROM org_invitations i
           INNER JOIN organizations o ON i.org_id = o.id
-          WHERE i.email = ? AND i.status = 'pending'`,
-        args: [ctx.email],
+          WHERE LOWER(i.email) = ? AND i.status = 'pending'`,
+        args: [ctx.email.toLowerCase()],
     });
     const pendingInvitations = invitesRes.rows.map((r) => ({
         id: String(r.id),
@@ -100,6 +132,9 @@ export const getMyOrgHandler = defineEventHandler(async (event) => {
         role: ctx.role,
         orgs,
         pendingInvitations,
+        domainMatches,
+        allowedDomain,
+        a2aSecret: isOwnerOrAdmin ? a2aSecret : undefined,
     };
 });
 /** POST /_agent-native/org — create a new organization */
@@ -117,9 +152,12 @@ export const createOrgHandler = defineEventHandler(async (event) => {
     const orgId = nanoid();
     const now = Date.now();
     const e = await exec();
+    // Auto-generate a per-org A2A secret for cross-app delegation
+    const { randomBytes } = await import("node:crypto");
+    const a2aSecret = randomBytes(32).toString("base64url");
     await e.execute({
-        sql: `INSERT INTO organizations (id, name, created_by, created_at) VALUES (?, ?, ?, ?)`,
-        args: [orgId, name, email, now],
+        sql: `INSERT INTO organizations (id, name, created_by, created_at, a2a_secret) VALUES (?, ?, ?, ?, ?)`,
+        args: [orgId, name, email, now, a2aSecret],
     });
     await e.execute({
         sql: `INSERT INTO org_members (id, org_id, email, role, joined_at) VALUES (?, ?, ?, ?, ?)`,
@@ -166,9 +204,16 @@ export const createInvitationHandler = defineEventHandler(async (event) => {
         throw createError({ statusCode: 400, message: "Email is required" });
     }
     const e = await exec();
+    // Existing rows in org_members / org_invitations may have any case
+    // (writes haven't been normalized historically). Compare with LOWER
+    // on both sides so an "alice@..." invite check correctly recognizes
+    // an existing "Alice@..." membership. `email` is already lowercased
+    // at parse time above, but call .toLowerCase() explicitly here so
+    // the contract at the SQL boundary matches every other handler in
+    // this file.
     const existingMember = await e.execute({
-        sql: `SELECT 1 FROM org_members WHERE org_id = ? AND email = ? LIMIT 1`,
-        args: [ctx.orgId, email],
+        sql: `SELECT 1 FROM org_members WHERE org_id = ? AND LOWER(email) = ? LIMIT 1`,
+        args: [ctx.orgId, email.toLowerCase()],
     });
     if (existingMember.rows.length > 0) {
         throw createError({
@@ -177,8 +222,8 @@ export const createInvitationHandler = defineEventHandler(async (event) => {
         });
     }
     const existingInvite = await e.execute({
-        sql: `SELECT 1 FROM org_invitations WHERE org_id = ? AND email = ? AND status = 'pending' LIMIT 1`,
-        args: [ctx.orgId, email],
+        sql: `SELECT 1 FROM org_invitations WHERE org_id = ? AND LOWER(email) = ? AND status = 'pending' LIMIT 1`,
+        args: [ctx.orgId, email.toLowerCase()],
     });
     if (existingInvite.rows.length > 0) {
         throw createError({
@@ -245,9 +290,11 @@ export const acceptInvitationHandler = defineEventHandler(async (event) => {
     }
     const e = await exec();
     const invRes = await e.execute({
+        // Case-insensitive on email — see comment on the analogous
+        // pending-invitations query in getMyOrgHandler.
         sql: `SELECT id, org_id AS "orgId" FROM org_invitations
-            WHERE id = ? AND email = ? AND status = 'pending' LIMIT 1`,
-        args: [invitationId, email],
+            WHERE id = ? AND LOWER(email) = ? AND status = 'pending' LIMIT 1`,
+        args: [invitationId, email.toLowerCase()],
     });
     if (invRes.rows.length === 0) {
         throw createError({
@@ -258,8 +305,8 @@ export const acceptInvitationHandler = defineEventHandler(async (event) => {
     const inv = invRes.rows[0];
     const invOrgId = String(inv.orgId ?? inv.org_id);
     const existingMembership = await e.execute({
-        sql: `SELECT role FROM org_members WHERE org_id = ? AND email = ? LIMIT 1`,
-        args: [invOrgId, email],
+        sql: `SELECT role FROM org_members WHERE org_id = ? AND LOWER(email) = ? LIMIT 1`,
+        args: [invOrgId, email.toLowerCase()],
     });
     const orgRes = await e.execute({
         sql: `SELECT name FROM organizations WHERE id = ? LIMIT 1`,
@@ -305,29 +352,72 @@ export const removeMemberHandler = defineEventHandler(async (event) => {
     if (!memberEmail) {
         throw createError({ statusCode: 400, message: "Email is required" });
     }
-    if (memberEmail === ctx.email && ctx.role === "owner") {
+    // memberEmail comes from the URL path verbatim; org_members may
+    // hold the row with any case. LOWER both sides for the lookup AND
+    // the DELETE so removal works regardless of how either side cased
+    // it. The self-removal guard ALSO compares case-insensitively —
+    // otherwise an owner whose email was stored as Alice@... could
+    // remove themselves via the lowercase URL alice@..., bypassing the
+    // guard and leaving the org ownerless.
+    const memberEmailLower = memberEmail.toLowerCase();
+    if (memberEmailLower === ctx.email.toLowerCase() && ctx.role === "owner") {
         throw createError({
             statusCode: 400,
             message: "Organization owner cannot remove themselves",
         });
     }
     const e = await exec();
-    const target = await e.execute({
-        sql: `SELECT role FROM org_members WHERE org_id = ? AND email = ? LIMIT 1`,
-        args: [ctx.orgId, memberEmail],
+    // Look specifically for an OWNER row matching this email rather
+    // than just "any matching row". Duplicate-case rows are possible
+    // (e.g. legacy data with both "Alice@..." and "alice@..." in
+    // org_members), and the prior `SELECT role ... LIMIT 1` could
+    // return the non-owner duplicate, pass the role check, and then
+    // the case-insensitive DELETE below would remove BOTH rows —
+    // including the owner — leaving the org ownerless. Querying for
+    // the owner row directly closes that case-mismatch attack.
+    const ownerCheck = await e.execute({
+        sql: `SELECT 1 FROM org_members WHERE org_id = ? AND LOWER(email) = ? AND role = 'owner' LIMIT 1`,
+        args: [ctx.orgId, memberEmailLower],
     });
-    if (target.rows[0]?.role === "owner") {
+    if (ownerCheck.rows.length > 0) {
         throw createError({
             statusCode: 403,
             message: "Cannot remove the organization owner",
         });
     }
     await e.execute({
-        sql: `DELETE FROM org_members WHERE org_id = ? AND email = ?`,
-        args: [ctx.orgId, memberEmail],
+        sql: `DELETE FROM org_members WHERE org_id = ? AND LOWER(email) = ?`,
+        args: [ctx.orgId, memberEmailLower],
     });
     return { success: true };
 });
+/** PATCH /_agent-native/org — rename the current organization (owner/admin only) */
+export const updateOrgHandler = defineEventHandler(async (event) => {
+    const ctx = await getOrgContext(event);
+    if (!ctx.orgId) {
+        throw createError({ statusCode: 400, message: "No organization found" });
+    }
+    if (ctx.role !== "owner" && ctx.role !== "admin") {
+        throw createError({
+            statusCode: 403,
+            message: "Only owners and admins can update the organization",
+        });
+    }
+    const body = await readBody(event);
+    const name = body?.name?.trim();
+    if (!name) {
+        throw createError({
+            statusCode: 400,
+            message: "Organization name is required",
+        });
+    }
+    const e = await exec();
+    await e.execute({
+        sql: `UPDATE organizations SET name = ? WHERE id = ?`,
+        args: [name, ctx.orgId],
+    });
+    return { orgId: ctx.orgId, name };
+});
 /** PUT /_agent-native/org/switch — switch the user's active organization */
 export const switchOrgHandler = defineEventHandler(async (event) => {
     const session = await getSession(event);
@@ -343,8 +433,8 @@ export const switchOrgHandler = defineEventHandler(async (event) => {
         sql: `SELECT m.role AS role, o.name AS "orgName"
           FROM org_members m
           INNER JOIN organizations o ON m.org_id = o.id
-          WHERE m.org_id = ? AND m.email = ? LIMIT 1`,
-        args: [orgId, email],
+          WHERE m.org_id = ? AND LOWER(m.email) = ? LIMIT 1`,
+        args: [orgId, email.toLowerCase()],
     });
     if (membership.rows.length === 0) {
         throw createError({
@@ -360,4 +450,342 @@ export const switchOrgHandler = defineEventHandler(async (event) => {
         role: String(row.role),
     };
 });
+/** POST /_agent-native/org/join-by-domain — join an org whose allowed_domain matches your email */
+export const joinByDomainHandler = defineEventHandler(async (event) => {
+    const session = await getSession(event);
+    const email = requireAuthEmail(session);
+    const body = await readBody(event);
+    const orgId = body?.orgId;
+    if (!orgId) {
+        throw createError({ statusCode: 400, message: "orgId is required" });
+    }
+    const e = await exec();
+    const orgRes = await e.execute({
+        sql: `SELECT id, name, allowed_domain FROM organizations WHERE id = ? LIMIT 1`,
+        args: [orgId],
+    });
+    if (orgRes.rows.length === 0) {
+        throw createError({ statusCode: 404, message: "Organization not found" });
+    }
+    const org = orgRes.rows[0];
+    const allowedDomain = String(org.allowed_domain || "").toLowerCase();
+    const userDomain = email.split("@")[1]?.toLowerCase();
+    if (!allowedDomain || allowedDomain !== userDomain) {
+        throw createError({
+            statusCode: 403,
+            message: "Your email domain does not match this organization's allowed domain",
+        });
+    }
+    const existing = await e.execute({
+        sql: `SELECT 1 FROM org_members WHERE org_id = ? AND LOWER(email) = ? LIMIT 1`,
+        args: [orgId, email.toLowerCase()],
+    });
+    if (existing.rows.length > 0) {
+        throw createError({
+            statusCode: 409,
+            message: "Already a member of this organization",
+        });
+    }
+    await e.execute({
+        sql: `INSERT INTO org_members (id, org_id, email, role, joined_at) VALUES (?, ?, ?, 'member', ?)`,
+        args: [nanoid(), orgId, email, Date.now()],
+    });
+    await putUserSetting(email, "active-org-id", { orgId });
+    return {
+        orgId,
+        orgName: String(org.name),
+        role: "member",
+    };
+});
+/** PUT /_agent-native/org/domain — set or clear the allowed email domain (owner/admin only) */
+export const setDomainHandler = defineEventHandler(async (event) => {
+    const ctx = await getOrgContext(event);
+    if (!ctx.orgId) {
+        throw createError({ statusCode: 400, message: "No active organization" });
+    }
+    if (ctx.role !== "owner" && ctx.role !== "admin") {
+        throw createError({
+            statusCode: 403,
+            message: "Only owners and admins can set the allowed domain",
+        });
+    }
+    const body = await readBody(event);
+    const raw = body?.domain?.trim()?.toLowerCase() || null;
+    if (raw && !/^([a-z0-9]([a-z0-9-]*[a-z0-9])?\.)+[a-z]{2,}$/.test(raw)) {
+        throw createError({
+            statusCode: 400,
+            message: "Invalid domain format",
+        });
+    }
+    const e = await exec();
+    if (raw) {
+        const existing = await e.execute({
+            sql: `SELECT id FROM organizations WHERE LOWER(allowed_domain) = ? AND id != ? LIMIT 1`,
+            args: [raw, ctx.orgId],
+        });
+        if (existing.rows.length > 0) {
+            throw createError({
+                statusCode: 409,
+                message: "Another organization already uses this domain",
+            });
+        }
+    }
+    await e.execute({
+        sql: `UPDATE organizations SET allowed_domain = ? WHERE id = ?`,
+        args: [raw, ctx.orgId],
+    });
+    return { domain: raw };
+});
+/** PUT /_agent-native/org/a2a-secret — regenerate or set the org's A2A secret (owner/admin only) */
+export const setA2ASecretHandler = defineEventHandler(async (event) => {
+    const ctx = await getOrgContext(event);
+    if (!ctx.orgId) {
+        throw createError({
+            statusCode: 400,
+            message: "No active organization",
+        });
+    }
+    if (ctx.role !== "owner" && ctx.role !== "admin") {
+        throw createError({
+            statusCode: 403,
+            message: "Only owners and admins can manage the A2A secret",
+        });
+    }
+    const body = await readBody(event);
+    let secret = body?.secret?.trim() || null;
+    // If no secret provided, auto-generate one
+    if (!secret) {
+        const { randomBytes } = await import("node:crypto");
+        secret = randomBytes(32).toString("base64url");
+    }
+    const e = await exec();
+    // Read the previous secret BEFORE overwriting so the client can chain a
+    // sync call that signs JWTs with the secret peers still hold.
+    const prevRes = await e.execute({
+        sql: `SELECT a2a_secret FROM organizations WHERE id = ? LIMIT 1`,
+        args: [ctx.orgId],
+    });
+    const previousSecret = String(prevRes.rows[0]?.a2a_secret ?? "") || null;
+    await e.execute({
+        sql: `UPDATE organizations SET a2a_secret = ? WHERE id = ?`,
+        args: [secret, ctx.orgId],
+    });
+    return { a2aSecret: secret, previousSecret };
+});
+/**
+ * POST /_agent-native/org/a2a-secret/sync — push the org's A2A secret to all
+ * connected apps so cross-app delegation works without manual copy/paste.
+ *
+ * Auth: standard session — owner/admin only.
+ *
+ * For each discovered agent, signs a JWT with the org's CURRENT a2a_secret
+ * and POSTs to `<app>/_agent-native/org/a2a-secret/receive` with the same
+ * secret + the org's domain. The receiving app verifies the JWT using its
+ * own copy of the secret (peers must already share a secret to be trusted)
+ * — for the first-ever sync this means at least one peer must already hold
+ * the secret, which is the bootstrap. For ongoing rotation, regenerate
+ * locally and call sync immediately; sync signs with the secret that's
+ * currently in DB, which the peers still have.
+ *
+ * Body (optional): { signSecret?: string } — sign the outbound JWTs with
+ * this secret instead of the org's current secret. Used by the regenerate-
+ * then-sync flow: regenerate stores the NEW secret, but sync needs to
+ * authenticate using the OLD one that peers still hold. Owner/admin only,
+ * gated by the session.
+ */
+export const syncA2ASecretHandler = defineEventHandler(async (event) => {
+    const ctx = await getOrgContext(event);
+    if (!ctx.orgId) {
+        throw createError({
+            statusCode: 400,
+            message: "No active organization",
+        });
+    }
+    if (ctx.role !== "owner" && ctx.role !== "admin") {
+        throw createError({
+            statusCode: 403,
+            message: "Only owners and admins can sync the A2A secret",
+        });
+    }
+    const body = await readBody(event).catch(() => null);
+    const overrideSignSecret = typeof body?.signSecret === "string" && body.signSecret.trim()
+        ? body.signSecret.trim()
+        : null;
+    const e = await exec();
+    const orgRes = await e.execute({
+        sql: `SELECT a2a_secret, allowed_domain FROM organizations WHERE id = ? LIMIT 1`,
+        args: [ctx.orgId],
+    });
+    if (orgRes.rows.length === 0) {
+        throw createError({
+            statusCode: 404,
+            message: "Organization not found",
+        });
+    }
+    const orgRow = orgRes.rows[0];
+    const secret = String(orgRow.a2a_secret ?? "") || null;
+    const orgDomain = String(orgRow.allowed_domain ?? "") || null;
+    if (!secret) {
+        throw createError({
+            statusCode: 400,
+            message: "Org has no A2A secret. Generate one first before syncing.",
+        });
+    }
+    if (!orgDomain) {
+        throw createError({
+            statusCode: 400,
+            message: "Org has no allowed domain set. Set the email domain first so connected apps can identify which org to update.",
+        });
+    }
+    const signSecret = overrideSignSecret || secret;
+    const { discoverAgents } = await import("../server/agent-discovery.js");
+    const { signA2AToken } = await import("../a2a/client.js");
+    const agents = await discoverAgents();
+    const results = [];
+    await Promise.all(agents.map(async (agent) => {
+        try {
+            const token = await signA2AToken(ctx.email, orgDomain, signSecret);
+            const target = `${agent.url.replace(/\/$/, "")}/_agent-native/org/a2a-secret/receive`;
+            const res = await fetch(target, {
+                method: "POST",
+                headers: {
+                    "Content-Type": "application/json",
+                    Authorization: `Bearer ${token}`,
+                },
+                body: JSON.stringify({ secret, orgDomain }),
+            });
+            if (!res.ok) {
+                const text = await res.text().catch(() => "");
+                results.push({
+                    id: agent.id,
+                    name: agent.name,
+                    url: agent.url,
+                    ok: false,
+                    status: res.status,
+                    error: text || res.statusText,
+                });
+                return;
+            }
+            results.push({
+                id: agent.id,
+                name: agent.name,
+                url: agent.url,
+                ok: true,
+                status: res.status,
+            });
+        }
+        catch (err) {
+            results.push({
+                id: agent.id,
+                name: agent.name,
+                url: agent.url,
+                ok: false,
+                error: err instanceof Error ? err.message : String(err),
+            });
+        }
+    }));
+    const succeeded = results.filter((r) => r.ok).length;
+    return {
+        total: results.length,
+        succeeded,
+        failed: results.length - succeeded,
+        results,
+    };
+});
+/**
+ * POST /_agent-native/org/a2a-secret/receive — accept a secret push from a
+ * connected agent-native app. Auth-exempt at the route guard; we verify a
+ * JWT signed by the calling app using OUR copy of the org's a2a_secret. If
+ * verification succeeds the calling app is a trusted peer and we overwrite
+ * our local org's secret with the supplied value.
+ *
+ * Body: { secret: string, orgDomain: string }
+ *
+ * Header: Authorization: Bearer <JWT signed with the existing shared
+ * a2a_secret, with `org_domain` matching the body's orgDomain>.
+ */
+export const receiveA2ASecretHandler = defineEventHandler(async (event) => {
+    const { getRequestHeader } = await import("h3");
+    const jose = await import("jose");
+    const authHeader = getRequestHeader(event, "authorization");
+    if (!authHeader || !authHeader.startsWith("Bearer ")) {
+        throw createError({
+            statusCode: 401,
+            message: "Bearer token required",
+        });
+    }
+    const token = authHeader.slice("Bearer ".length);
+    const body = await readBody(event);
+    const newSecret = typeof body?.secret === "string" ? body.secret.trim() : "";
+    const orgDomain = typeof body?.orgDomain === "string"
+        ? body.orgDomain.trim().toLowerCase()
+        : "";
+    if (!newSecret || !orgDomain) {
+        throw createError({
+            statusCode: 400,
+            message: "secret and orgDomain are required",
+        });
+    }
+    // Peek at JWT (unverified) to confirm it claims the same domain we're
+    // updating. Verification still happens below with the trusted secret.
+    let claimedDomain;
+    try {
+        const unverified = jose.decodeJwt(token);
+        claimedDomain =
+            unverified.org_domain || undefined;
+    }
+    catch {
+        throw createError({
+            statusCode: 401,
+            message: "Malformed JWT",
+        });
+    }
+    if (!claimedDomain ||
+        claimedDomain.toLowerCase() !== orgDomain.toLowerCase()) {
+        throw createError({
+            statusCode: 401,
+            message: "JWT org_domain does not match request body",
+        });
+    }
+    // Look up our local org by the domain and grab the existing secret.
+    const e = await exec();
+    const orgRes = await e.execute({
+        sql: `SELECT id, a2a_secret FROM organizations WHERE LOWER(allowed_domain) = ? LIMIT 1`,
+        args: [orgDomain],
+    });
+    if (orgRes.rows.length === 0) {
+        throw createError({
+            statusCode: 404,
+            message: "No local org matches that domain",
+        });
+    }
+    const row = orgRes.rows[0];
+    const localOrgId = String(row.id);
+    const existingSecret = String(row.a2a_secret ?? "") || null;
+    if (!existingSecret) {
+        // Bootstrap requires an existing shared secret to verify the caller.
+        // If we have nothing on file, we can't verify trust — refuse.
+        throw createError({
+            statusCode: 401,
+            message: "Local org has no A2A secret yet — cannot verify caller. Set the secret manually for the first time.",
+        });
+    }
+    // Verify the JWT using OUR existing secret. If the caller is a trusted
+    // peer they signed with the same secret and verification succeeds.
+    try {
+        await jose.jwtVerify(token, new TextEncoder().encode(existingSecret));
+    }
+    catch {
+        throw createError({
+            statusCode: 401,
+            message: "Invalid or expired JWT signature",
+        });
+    }
+    // Trusted — apply the new secret.
+    await e.execute({
+        sql: `UPDATE organizations SET a2a_secret = ? WHERE id = ?`,
+        args: [newSecret, localOrgId],
+    });
+    return { ok: true, orgId: localOrgId };
+});
 //# sourceMappingURL=handlers.js.map