@tulip-systems/create-app 0.11.1

package/dist/templates/code/src/server/agents/sales/tools/search_crm_records/tool.server.ts

@@ -0,0 +1,147 @@
+import "server-cli-only";
+
+import { defineTool, resolveAgentTool } from "@tulip-systems/ai/tools/server";
+import { asc, ilike, or } from "drizzle-orm";
+import z from "zod";
+import { contacts } from "@/app/admin/contacts/_lib/schema";
+import { customers } from "@/app/admin/customers/_lib/schema";
+import { prospects } from "@/app/admin/prospects/_lib/schema";
+import { db } from "@/server/db/init";
+
+const crmRecordSchema = z.object({
+  id: z.string(),
+  type: z.enum(["customer", "prospect", "contact"]),
+  name: z.string(),
+  email: z.string().nullable(),
+  phone: z.string().nullable(),
+  website: z.string().nullable(),
+  status: z.string().nullable(),
+});
+
+export const searchCrmRecords = defineTool({
+  name: "search_crm_records",
+  title: "Search CRM Records",
+  description:
+    "Search customers, prospects, and contacts by name, email, phone, or website before answering CRM questions or creating new records.",
+  inputSchema: z.object({
+    query: z
+      .string()
+      .trim()
+      .min(1)
+      .describe("Search text such as a company, person, email, domain, or phone."),
+    limit: z
+      .number()
+      .int()
+      .min(1)
+      .max(10)
+      .default(5)
+      .describe("Maximum records to return per CRM type."),
+  }),
+  outputSchema: z.object({
+    query: z.string(),
+    customers: z.array(crmRecordSchema),
+    prospects: z.array(crmRecordSchema),
+    contacts: z.array(crmRecordSchema),
+    total: z.number(),
+  }),
+  async execute(input) {
+    const query = input.query.trim();
+    const likeQuery = `%${query}%`;
+
+    const [customerRows, prospectRows, contactRows] = await Promise.all([
+      db
+        .select({
+          id: customers.id,
+          name: customers.name,
+          email: customers.email,
+          phone: customers.phone,
+          website: customers.website,
+        })
+        .from(customers)
+        .where(
+          or(
+            ilike(customers.name, likeQuery),
+            ilike(customers.tradeName, likeQuery),
+            ilike(customers.email, likeQuery),
+            ilike(customers.phone, likeQuery),
+            ilike(customers.website, likeQuery),
+            ilike(customers.vat, likeQuery),
+          ),
+        )
+        .orderBy(asc(customers.name))
+        .limit(input.limit),
+      db
+        .select({
+          id: prospects.id,
+          name: prospects.name,
+          email: prospects.email,
+          phone: prospects.phone,
+          website: prospects.website,
+          status: prospects.status,
+        })
+        .from(prospects)
+        .where(
+          or(
+            ilike(prospects.name, likeQuery),
+            ilike(prospects.tradeName, likeQuery),
+            ilike(prospects.email, likeQuery),
+            ilike(prospects.phone, likeQuery),
+            ilike(prospects.website, likeQuery),
+            ilike(prospects.vat, likeQuery),
+          ),
+        )
+        .orderBy(asc(prospects.name))
+        .limit(input.limit),
+      db
+        .select({
+          id: contacts.id,
+          name: contacts.name,
+          email: contacts.email,
+          phone: contacts.phone,
+        })
+        .from(contacts)
+        .where(
+          or(
+            ilike(contacts.name, likeQuery),
+            ilike(contacts.email, likeQuery),
+            ilike(contacts.phone, likeQuery),
+            ilike(contacts.position, likeQuery),
+          ),
+        )
+        .orderBy(asc(contacts.name))
+        .limit(input.limit),
+    ]);
+
+    const customerResults = customerRows.map((record) => ({
+      ...record,
+      type: "customer" as const,
+      status: null,
+    }));
+    const prospectResults = prospectRows.map((record) => ({
+      ...record,
+      type: "prospect" as const,
+    }));
+    const contactResults = contactRows.map((record) => ({
+      ...record,
+      type: "contact" as const,
+      website: null,
+      status: null,
+    }));
+
+    return {
+      query,
+      customers: customerResults,
+      prospects: prospectResults,
+      contacts: contactResults,
+      total: customerResults.length + prospectResults.length + contactResults.length,
+    };
+  },
+});
+
+export const searchCrmRecordsTool = resolveAgentTool(searchCrmRecords, {
+  permissions: ["customer:view", "prospect:view", "contact:view"],
+  ui: {
+    label: "Search CRM records",
+    icon: "search",
+  },
+});

package/dist/templates/code/src/server/agents/tools/web_search/tool.client.tsx

@@ -0,0 +1,24 @@
+"use client";
+
+import { ToolCallCard } from "@tulip-systems/ai/chat/client";
+import { defineToolClient } from "@tulip-systems/ai/tools/client";
+import { Search } from "lucide-react";
+
+type WebSearchTool = {
+  name: "web_search";
+};
+
+export const webSearchToolClient = defineToolClient<WebSearchTool>({
+  toolName: "web_search",
+  render: (part) => (
+    <ToolCallCard
+      part={part}
+      title="Internetzoekopdracht"
+      icon={<Search className="size-3.5" />}
+      labels={{
+        output: "Resultaat",
+        preliminaryOutput: "Tussentijds resultaat",
+      }}
+    />
+  ),
+});

package/dist/templates/code/src/server/agents/tools/web_search/tool.server.ts

@@ -0,0 +1,8 @@
+import { openrouter } from "@/app/admin/assistant/_lib/providers";
+
+export const webSearchTool = openrouter.tools.webSearch({
+  maxResults: 5,
+  engine: "auto",
+  searchPrompt:
+    "Search for current, reliable, factual information. Prefer authoritative and recent sources.",
+});

package/dist/templates/code/src/server/auth/client.server.ts

@@ -0,0 +1,6 @@
+import { oauthProviderResourceClient } from "@better-auth/oauth-provider/resource-client";
+import { createAuthClient } from "better-auth/client";
+
+export const authServerClient = createAuthClient({
+  plugins: [oauthProviderResourceClient()],
+});

package/dist/templates/code/src/server/auth/client.ts

@@ -0,0 +1,22 @@
+"use client";
+
+import { oauthProviderClient } from "@better-auth/oauth-provider/client";
+import { passkeyClient } from "@better-auth/passkey/client";
+import { url } from "@tulip-systems/core";
+import { adminClient, emailOTPClient, inferAdditionalFields } from "better-auth/client/plugins";
+import { createAuthClient } from "better-auth/react";
+import type { AuthServer } from "./init";
+import { ac, roles } from "./permissions";
+
+export const authClient = createAuthClient({
+  baseURL: url(),
+  plugins: [
+    emailOTPClient(),
+    passkeyClient(),
+    oauthProviderClient(),
+    adminClient({ ac, roles }),
+    inferAdditionalFields<AuthServer>(),
+  ],
+});
+
+export type AuthClient = typeof authClient;

package/dist/templates/code/src/server/auth/constants.ts

@@ -0,0 +1,22 @@
+import { url } from "@tulip-systems/core";
+
+/**
+ * This constant defines the OAuth scopes that are required for accessing the protected resource.
+ * These scopes are used to request specific permissions from the authorization server during the OAuth flow.
+ * The scopes should match the permissions required by the resource server for accessing its endpoints.
+ */
+export const OAUTH_SCOPES = ["openid", "profile", "email", "offline_access", "mcp"] as const;
+
+/**
+ * This constant defines the audience URLs for the OAuth protected resource.
+ */
+export const OAUTH_AUDIENCES = [url("/api/mcp")];
+/**
+ * This constant defines the issuer URLs for the OAuth authorization server.
+ */
+export const OAUTH_ISSUER = url("/api/auth");
+
+/**
+ * This constant defines the JWKS URI for the OAuth authorization server, which is used to retrieve the public keys for verifying the access tokens.
+ */
+export const OAUTH_JWKS_URI = url("/api/auth/jwks");

package/dist/templates/code/src/server/auth/init.ts

@@ -0,0 +1,79 @@
+import { oauthProvider } from "@better-auth/oauth-provider";
+import { passkey } from "@better-auth/passkey";
+import { authAdditionalFields, authCookiePrefix } from "@tulip-systems/auth";
+import { ForgetPasswordEmail } from "@tulip-systems/auth/react-email";
+import { url } from "@tulip-systems/core";
+import { drizzleAdapter } from "better-auth/adapters/drizzle";
+import { betterAuth } from "better-auth/minimal";
+import { admin, emailOTP, jwt } from "better-auth/plugins";
+import { config } from "@/lib/config/base";
+import { db } from "../db/init";
+import { email } from "../emails/init";
+import { OAUTH_AUDIENCES, OAUTH_SCOPES } from "./constants";
+import { ac, roles } from "./permissions";
+
+export const auth = betterAuth({
+  advanced: {
+    cookiePrefix: authCookiePrefix,
+    database: { generateId: () => false as const },
+  },
+  baseURL: {
+    allowedHosts: [
+      "*.newcode.be",
+      "*.tulip.systems",
+      "*.vercel.app",
+      "*.localhost:*",
+      "localhost:7459",
+    ],
+  },
+  database: drizzleAdapter(db, {
+    provider: "pg",
+    usePlural: true,
+  }),
+  emailAndPassword: {
+    enabled: true,
+  },
+  user: {
+    additionalFields: authAdditionalFields,
+    changeEmail: {
+      enabled: true,
+    },
+  },
+  plugins: [
+    passkey(),
+    admin({ ac, roles, adminRoles: ["admin", "developer"], defaultRole: "user" }),
+    emailOTP({
+      sendVerificationOTP: async ({ email: recipientEmail, otp, type }) => {
+        if (type !== "forget-password") return;
+
+        const searchParams = new URLSearchParams();
+        searchParams.set("email", recipientEmail);
+        searchParams.set("otp", otp);
+
+        const resetPasswordHref = url(`/auth/reset-password?${searchParams.toString()}`);
+
+        const result = await email.emails.send({
+          from: config.email.defaultFrom,
+          to: recipientEmail,
+          subject: "Wachtwoord herstellen",
+          react: ForgetPasswordEmail({ resetPasswordHref }),
+        });
+
+        if (result.error) throw new Error(result.error.message);
+      },
+    }),
+    jwt(),
+    oauthProvider({
+      loginPage: "/auth/login",
+      consentPage: "/auth/consent",
+      scopes: [...OAUTH_SCOPES],
+      validAudiences: [...OAUTH_AUDIENCES],
+      allowDynamicClientRegistration: true,
+      allowUnauthenticatedClientRegistration: true,
+      clientRegistrationDefaultScopes: [...OAUTH_SCOPES],
+    }),
+  ],
+});
+
+export type AuthServer = typeof auth;
+export type AuthServerOptions = typeof auth.options;

package/dist/templates/code/src/server/auth/permissions.ts

@@ -0,0 +1,81 @@
+import { adminAc, createAccessControl, createStatements } from "@tulip-systems/auth/permissions";
+
+/**
+ * Statements
+ */
+const statement = createStatements({
+  developer: ["debug"],
+  dashboard: ["view.budget"],
+  drive: ["view", "create", "update", "archive", "delete"],
+  prospect: ["view", "create", "update", "archive", "delete"],
+  customer: ["view", "create", "update", "archive", "delete"],
+  task: ["view", "create", "update", "delete"],
+  project: ["view", "view.budget", "view.drive", "create", "update", "archive", "delete"],
+  initiative: ["view", "view.budget", "view.stats", "create", "update", "delete"],
+  domain: ["view", "create", "update", "delete"],
+  time: ["view", "create", "update", "delete"],
+  employee: ["view", "view.avatar", "create", "update", "ban", "archive", "delete"],
+} as const);
+
+/**
+ * Access control
+ */
+export const ac = createAccessControl(statement);
+
+/**
+ * Admin role
+ */
+const developer = ac.newRole({
+  developer: ["debug"],
+  dashboard: ["view.budget"],
+  drive: ["view", "create", "update", "archive", "delete"],
+  prospect: ["view", "create", "update", "archive", "delete"],
+  customer: ["view", "create", "update", "archive", "delete"],
+  task: ["view", "create", "update", "delete"],
+  project: ["view", "view.budget", "view.drive", "create", "update", "archive", "delete"],
+  initiative: ["view", "view.budget", "view.stats", "create", "update", "delete"],
+  domain: ["view", "create", "update", "delete"],
+  time: ["view", "create", "update", "delete"],
+  employee: ["view", "view.avatar", "create", "update", "ban", "archive", "delete"],
+  ...adminAc.statements,
+});
+
+/**
+ * Owner role
+ */
+const admin = ac.newRole({
+  dashboard: ["view.budget"],
+  drive: ["view", "create", "update", "archive", "delete"],
+  prospect: ["view", "create", "update", "archive", "delete"],
+  customer: ["view", "create", "update", "archive", "delete"],
+  task: ["view", "create", "update", "delete"],
+  project: ["view", "view.budget", "view.drive", "create", "update", "archive", "delete"],
+  initiative: ["view", "view.budget", "view.stats", "create", "update", "delete"],
+  domain: ["view", "create", "update", "delete"],
+  time: ["view", "create", "update", "delete"],
+  employee: ["view", "view.avatar", "create", "update", "ban", "archive", "delete"],
+  ...adminAc.statements,
+});
+
+/**
+ * Worker role
+ */
+const worker = ac.newRole({
+  drive: ["create", "update", "archive"],
+  customer: ["view"],
+  task: ["view", "create", "update", "delete"],
+  project: ["view", "view.drive", "create", "update"],
+  initiative: ["view", "view.stats", "update"],
+  domain: ["view", "create", "update", "delete"],
+  time: ["view", "create", "update", "delete"],
+});
+
+/**
+ * Roles config
+ */
+export const roles = { admin, developer, worker };
+
+export type AccessControl = typeof ac;
+export type Roles = typeof roles;
+
+export type Role = keyof typeof roles;