mop-agent 0.1.0

package/apps/web/lib/link/store.ts

@@ -0,0 +1,89 @@
+/**
+ * Link registry — DB-backed (Drizzle + SQLite). Same surface the gateway/routes
+ * already use. The link token is hashed (sha256) at rest; the plaintext is shown
+ * to FLOW exactly once at pairing.
+ */
+import { createHash, randomBytes } from "node:crypto";
+import { eq } from "drizzle-orm";
+import type { Capabilities, ProjectManifest } from "@mop/link-protocol";
+import { getDb } from "../db/client";
+import { project, pairingCode } from "../db/schema";
+
+export type ProjectRecord = {
+  id: string;
+  name: string;
+  mopFlowVersion: string | null;
+  capabilities: Capabilities;
+  status: "online" | "offline";
+  lastSeenAt: number | null;
+};
+
+export function sha256(s: string): string {
+  return createHash("sha256").update(s).digest("hex");
+}
+
+export function createPairingCode(ttlMs = 10 * 60_000): { code: string; expiresAt: number } {
+  const code = `${rand4()}-${rand4()}`;
+  const expiresAt = Date.now() + ttlMs;
+  getDb().insert(pairingCode).values({ code, expiresAt, usedAt: null, createdAt: Date.now() }).run();
+  return { code, expiresAt };
+}
+
+export function consumePairingCode(code: string): boolean {
+  const db = getDb();
+  const [row] = db.select().from(pairingCode).where(eq(pairingCode.code, code)).all();
+  if (!row || row.usedAt || row.expiresAt < Date.now()) return false;
+  db.update(pairingCode).set({ usedAt: Date.now() }).where(eq(pairingCode.code, code)).run();
+  return true;
+}
+
+export function registerProject(manifest: ProjectManifest): { linkToken: string } {
+  const linkToken = randomBytes(32).toString("hex");
+  const linkTokenHash = sha256(linkToken);
+  getDb()
+    .insert(project)
+    .values({
+      id: manifest.projectId,
+      name: manifest.name,
+      mopFlowVersion: manifest.mopFlowVersion,
+      linkTokenHash,
+      capabilities: manifest.capabilities,
+      status: "offline",
+      lastSeenAt: null,
+      createdAt: Date.now(),
+    })
+    .onConflictDoUpdate({
+      target: project.id,
+      set: { name: manifest.name, mopFlowVersion: manifest.mopFlowVersion, linkTokenHash, capabilities: manifest.capabilities },
+    })
+    .run();
+  return { linkToken };
+}
+
+export function findProjectByToken(token: string): ProjectRecord | undefined {
+  const [row] = getDb().select().from(project).where(eq(project.linkTokenHash, sha256(token))).all();
+  return row ? toRecord(row) : undefined;
+}
+
+export function setProjectStatus(id: string, status: ProjectRecord["status"]): void {
+  getDb().update(project).set({ status, lastSeenAt: Date.now() }).where(eq(project.id, id)).run();
+}
+
+export function listProjects(): ProjectRecord[] {
+  return getDb().select().from(project).all().map(toRecord);
+}
+
+function toRecord(row: typeof project.$inferSelect): ProjectRecord {
+  return {
+    id: row.id,
+    name: row.name,
+    mopFlowVersion: row.mopFlowVersion,
+    capabilities: row.capabilities,
+    status: row.status as "online" | "offline",
+    lastSeenAt: row.lastSeenAt,
+  };
+}
+
+function rand4(): string {
+  return randomBytes(2).toString("hex").toUpperCase();
+}

package/apps/web/lib/memory/embed.ts

@@ -0,0 +1,111 @@
+/**
+ * Embeddings + sqlite-vec index/search.
+ *
+ * Embedder is pluggable (PRD open decision #6). The default `dummyEmbedder` is a
+ * deterministic hashed bag-of-words — no network, no API key — so the whole loop
+ * runs offline. Text sharing words lands near in cosine space, which is enough to
+ * demonstrate recall plumbing. Swap in a provider/local model later via setEmbedder.
+ */
+import { getSqlite, getDb } from "../db/client";
+import { vecMap } from "../db/schema";
+
+export const EMBED_DIM = 384;
+
+export interface Embedder {
+  embed(text: string): Promise<number[]>;
+}
+
+export function dummyEmbedder(): Embedder {
+  return {
+    async embed(text: string): Promise<number[]> {
+      const v = new Array<number>(EMBED_DIM).fill(0);
+      for (const tok of text.toLowerCase().split(/\W+/).filter(Boolean)) {
+        let h = 2166136261;
+        for (let i = 0; i < tok.length; i += 1) {
+          h ^= tok.charCodeAt(i);
+          h = Math.imul(h, 16777619);
+        }
+        const idx = Math.abs(h) % EMBED_DIM;
+        v[idx] = (v[idx] ?? 0) + 1;
+      }
+      const norm = Math.sqrt(v.reduce((s, x) => s + x * x, 0)) || 1;
+      return v.map((x) => x / norm);
+    },
+  };
+}
+
+/**
+ * Default embedder: real local MiniLM (semantic), falling back to the dummy
+ * keyword-hash if the model can't load (offline / native issue) or when
+ * MOP_AGENT_EMBEDDER=dummy. Both produce EMBED_DIM (384) vectors, so the vec
+ * table is unaffected either way. The choice is made + cached on first embed.
+ */
+function autoEmbedder(): Embedder {
+  let impl: Embedder | null = null;
+  return {
+    async embed(text: string): Promise<number[]> {
+      if (!impl) {
+        if (process.env.MOP_AGENT_EMBEDDER === "dummy") {
+          impl = dummyEmbedder();
+        } else {
+          try {
+            const { localEmbedder } = await import("./local-embedder");
+            const le = localEmbedder();
+            await le.embed("warmup"); // force model load now so failures fall back cleanly
+            impl = le;
+            console.log("[embed] local MiniLM embedder active");
+          } catch (e) {
+            console.warn(`[embed] local embedder unavailable, using dummy: ${e instanceof Error ? e.message : e}`);
+            impl = dummyEmbedder();
+          }
+        }
+      }
+      return impl.embed(text);
+    },
+  };
+}
+
+let _embedder: Embedder = autoEmbedder();
+export function setEmbedder(e: Embedder): void {
+  _embedder = e;
+}
+export function embedText(text: string): Promise<number[]> {
+  return _embedder.embed(text);
+}
+
+export type RefType = "episodic" | "semantic" | "skill";
+
+export async function embedAndIndex(refType: RefType, refId: string, text: string): Promise<void> {
+  const sqlite = getSqlite();
+  const vec = await embedText(text);
+  // Replace any existing vector for this ref (idempotent re-ingest).
+  const existing = sqlite
+    .prepare("SELECT rowid FROM vec_map WHERE ref_type = ? AND ref_id = ?")
+    .get(refType, refId) as { rowid: number } | undefined;
+  if (existing) {
+    sqlite.prepare("DELETE FROM vec_memory WHERE rowid = ?").run(existing.rowid);
+    sqlite.prepare("DELETE FROM vec_map WHERE rowid = ?").run(existing.rowid);
+  }
+  const info = sqlite
+    .prepare("INSERT INTO vec_memory(embedding) VALUES (vec_f32(?))")
+    .run(JSON.stringify(vec));
+  getDb().insert(vecMap).values({ rowid: Number(info.lastInsertRowid), refType, refId }).run();
+}
+
+export type SearchHit = { refType: RefType; refId: string; distance: number };
+
+export async function semanticSearch(query: string, k = 8): Promise<SearchHit[]> {
+  const sqlite = getSqlite();
+  const qvec = await embedText(query);
+  // sqlite-vec KNN requires a `k = ?` constraint (LIMIT alone isn't honored with a JOIN).
+  const rows = sqlite
+    .prepare(
+      `SELECT m.ref_type AS refType, m.ref_id AS refId, v.distance AS distance
+       FROM vec_memory v
+       JOIN vec_map m ON m.rowid = v.rowid
+       WHERE v.embedding MATCH vec_f32(?) AND k = ?
+       ORDER BY v.distance`,
+    )
+    .all(JSON.stringify(qvec), k) as SearchHit[];
+  return rows;
+}

package/apps/web/lib/memory/local-embedder.ts

@@ -0,0 +1,26 @@
+/**
+ * Local embedder — all-MiniLM-L6-v2 (384d) via transformers.js. No API key, runs
+ * on CPU. Model weights download once (~25MB) then cache. Lazy-loaded so it costs
+ * nothing until first use.
+ */
+import type { Embedder } from "./embed";
+
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+let _extractor: Promise<any> | null = null;
+
+export function localEmbedder(model = "Xenova/all-MiniLM-L6-v2"): Embedder {
+  return {
+    async embed(text: string): Promise<number[]> {
+      if (!_extractor) {
+        _extractor = (async () => {
+          const t = await import("@xenova/transformers");
+          t.env.allowLocalModels = false;
+          return t.pipeline("feature-extraction", model);
+        })();
+      }
+      const extractor = await _extractor;
+      const out = await extractor(text && text.trim() ? text : " ", { pooling: "mean", normalize: true });
+      return Array.from(out.data as Float32Array);
+    },
+  };
+}

package/apps/web/lib/providers/anthropic.ts

@@ -0,0 +1,23 @@
+import Anthropic from "@anthropic-ai/sdk";
+import type { ChatProvider, ChatOptions } from "./types";
+
+export function anthropicProvider(apiKey: string, model = "claude-sonnet-4-6"): ChatProvider {
+  const client = new Anthropic({ apiKey });
+  return {
+    id: "anthropic",
+    model,
+    async *chat({ system, messages }: ChatOptions) {
+      const stream = client.messages.stream({
+        model,
+        max_tokens: 4096,
+        system,
+        messages: messages.map((m) => ({ role: m.role, content: m.content })),
+      });
+      for await (const ev of stream) {
+        if (ev.type === "content_block_delta" && ev.delta.type === "text_delta") {
+          yield ev.delta.text;
+        }
+      }
+    },
+  };
+}

package/apps/web/lib/providers/config.ts

@@ -0,0 +1,55 @@
+/** Provider config store — encrypted API keys (AES-GCM) per owner. */
+import { eq } from "drizzle-orm";
+import { getDb } from "../db/client";
+import { providerConfig } from "../db/schema";
+import { decryptSecret, encryptSecret, keyHint } from "../crypto";
+
+export type ProviderId = "anthropic" | "openrouter";
+
+export function setProviderConfig(ownerId: string, input: { provider: ProviderId; apiKey: string; model?: string }): void {
+  const apiKeyEnc = encryptSecret(input.apiKey);
+  getDb()
+    .insert(providerConfig)
+    .values({ ownerId, provider: input.provider, apiKeyEnc, model: input.model ?? null, updatedAt: Date.now() })
+    .onConflictDoUpdate({
+      target: providerConfig.ownerId,
+      set: { provider: input.provider, apiKeyEnc, model: input.model ?? null, updatedAt: Date.now() },
+    })
+    .run();
+}
+
+/** Raw row (with encrypted key) for a given owner, or the first configured owner. */
+export function getProviderConfigRow(ownerId?: string) {
+  const db = getDb();
+  if (ownerId) {
+    const [row] = db.select().from(providerConfig).where(eq(providerConfig.ownerId, ownerId)).all();
+    if (row) return row;
+  }
+  return db.select().from(providerConfig).all()[0];
+}
+
+export function getDecryptedKey(row: { apiKeyEnc: string }): string {
+  return decryptSecret(row.apiKeyEnc);
+}
+
+/** Safe view for the UI — never returns the key itself. */
+export function getProviderConfigMasked(ownerId?: string): {
+  configured: boolean;
+  provider?: ProviderId;
+  model?: string | null;
+  keyHint?: string;
+} {
+  const row = getProviderConfigRow(ownerId);
+  if (!row) return { configured: false };
+  let hint = "••••";
+  try {
+    hint = keyHint(decryptSecret(row.apiKeyEnc));
+  } catch {
+    /* secret rotated — can't decrypt */
+  }
+  return { configured: true, provider: row.provider as ProviderId, model: row.model, keyHint: hint };
+}
+
+export function clearProviderConfig(ownerId: string): void {
+  getDb().delete(providerConfig).where(eq(providerConfig.ownerId, ownerId)).run();
+}

package/apps/web/lib/providers/echo.ts

@@ -0,0 +1,26 @@
+import type { ChatProvider, ChatOptions } from "./types";
+
+/**
+ * Offline provider — no API key. Echoes a deterministic answer that proves the
+ * grounding pipeline (it reflects the injected context + question). Used as the
+ * default fallback and in smoke tests.
+ */
+export function echoProvider(): ChatProvider {
+  return {
+    id: "echo",
+    model: "echo-1",
+    async *chat({ system, messages }: ChatOptions) {
+      const lastUser = [...messages].reverse().find((m) => m.role === "user")?.content ?? "";
+      const ctxLines = (system ?? "")
+        .split("\n")
+        .filter((l) => l.trim().startsWith("- "))
+        .slice(0, 5);
+      yield `🧠 (echo) You asked: "${lastUser}".\n\n`;
+      if (ctxLines.length) {
+        yield `Based on project memory I can see:\n${ctxLines.join("\n")}\n`;
+      } else {
+        yield `No project context was retrieved for this query.\n`;
+      }
+    },
+  };
+}

package/apps/web/lib/providers/index.ts

@@ -0,0 +1,41 @@
+/**
+ * Provider resolution. Fasa 3: env-driven (ANTHROPIC_API_KEY / OPENROUTER_API_KEY),
+ * falls back to the offline echo provider so chat works with no keys.
+ * TODO Fasa 3b: per-owner encrypted provider_config (AES-GCM via MOP_AGENT_SECRET).
+ */
+import type { ChatProvider } from "./types";
+import { anthropicProvider } from "./anthropic";
+import { openRouterProvider } from "./openrouter";
+import { echoProvider } from "./echo";
+import { getDecryptedKey, getProviderConfigRow } from "./config";
+
+export type { ChatProvider, ChatOptions, Msg } from "./types";
+export { anthropicProvider, openRouterProvider, echoProvider };
+
+export function resolveProvider(ownerId?: string): ChatProvider {
+  // 1) DB config (encrypted key set via /settings) wins.
+  try {
+    const row = getProviderConfigRow(ownerId);
+    if (row) {
+      const apiKey = getDecryptedKey(row);
+      if (row.provider === "anthropic") return anthropicProvider(apiKey, row.model ?? undefined);
+      if (row.provider === "openrouter") return openRouterProvider(apiKey, row.model ?? undefined);
+    }
+  } catch {
+    /* DB not ready or secret rotated — fall through to env */
+  }
+
+  // 2) env fallback
+  const pref = process.env.MOP_AGENT_PROVIDER; // "anthropic" | "openrouter" | "echo"
+  if (pref === "anthropic" || (!pref && process.env.ANTHROPIC_API_KEY)) {
+    if (process.env.ANTHROPIC_API_KEY) {
+      return anthropicProvider(process.env.ANTHROPIC_API_KEY, process.env.MOP_AGENT_MODEL);
+    }
+  }
+  if (pref === "openrouter" || (!pref && process.env.OPENROUTER_API_KEY)) {
+    if (process.env.OPENROUTER_API_KEY) {
+      return openRouterProvider(process.env.OPENROUTER_API_KEY, process.env.MOP_AGENT_MODEL);
+    }
+  }
+  return echoProvider();
+}

package/apps/web/lib/providers/openrouter.ts

@@ -0,0 +1,24 @@
+import OpenAI from "openai";
+import type { ChatProvider, ChatOptions } from "./types";
+
+/** OpenRouter is OpenAI-compatible — unlocks most other models in one adapter. */
+export function openRouterProvider(apiKey: string, model = "anthropic/claude-sonnet-4.6"): ChatProvider {
+  const client = new OpenAI({ apiKey, baseURL: "https://openrouter.ai/api/v1" });
+  return {
+    id: "openrouter",
+    model,
+    async *chat({ system, messages }: ChatOptions) {
+      const stream = await client.chat.completions.create({
+        model,
+        stream: true,
+        messages: [
+          ...(system ? ([{ role: "system" as const, content: system }]) : []),
+          ...messages.map((m) => ({ role: m.role, content: m.content })),
+        ],
+      });
+      for await (const chunk of stream) {
+        yield chunk.choices[0]?.delta?.content ?? "";
+      }
+    },
+  };
+}

package/apps/web/lib/providers/types.ts

@@ -0,0 +1,14 @@
+/** Provider-neutral chat interface. Adapters stream text deltas. */
+export type Msg = { role: "user" | "assistant"; content: string };
+
+export type ChatOptions = {
+  system?: string;
+  messages: Msg[];
+};
+
+export interface ChatProvider {
+  id: string;
+  model: string;
+  chat(opts: ChatOptions): AsyncIterable<string>;
+  embed?(text: string): Promise<number[]>;
+}

package/apps/web/lib/ws/gateway.ts

@@ -0,0 +1,113 @@
+/**
+ * Reverse WSS gateway — accepts inbound connections FROM FLOW nodes.
+ *
+ * FLOW dials out (Authorization: Bearer <linkToken>); the AGENT authenticates the
+ * token, then uses the persistent socket to push snapshots up and send tool
+ * requests down. Lives on the custom Node server (see server.ts).
+ */
+import type { Server } from "node:http";
+import { WebSocketServer, type WebSocket } from "ws";
+import { randomUUID } from "node:crypto";
+import {
+  LINK_PROTOCOL_VERSION,
+  LINK_WS_PATH,
+  parseLinkMessage,
+  type LinkMessage,
+  type McpToolName,
+} from "@mop/link-protocol";
+import { findProjectByToken, setProjectStatus } from "../link/store";
+import { ingestSnapshot } from "../brain/mirror";
+
+type Pending = { resolve: (v: unknown) => void; reject: (e: Error) => void };
+
+// Shared across the custom server (server.ts via tsx) and Next route bundles —
+// without globalThis these would be separate module instances and callFlow()
+// from an API route would never see the socket the gateway registered.
+const g = globalThis as unknown as {
+  __mopLiveLinks?: Map<string, WebSocket>;
+  __mopPending?: Map<string, Pending>;
+};
+const liveLinks = (g.__mopLiveLinks ??= new Map<string, WebSocket>()); // projectId -> socket
+const pending = (g.__mopPending ??= new Map<string, Pending>()); // req id -> resolver
+
+export function attachGateway(server: Server): WebSocketServer {
+  const wss = new WebSocketServer({ server, path: LINK_WS_PATH });
+
+  wss.on("connection", (ws, req) => {
+    const token = (req.headers["authorization"] ?? "").toString().replace(/^Bearer\s+/i, "");
+    const proj = findProjectByToken(token);
+    if (!proj) {
+      ws.close(4001, "unauthorized");
+      return;
+    }
+
+    liveLinks.set(proj.id, ws);
+    setProjectStatus(proj.id, "online");
+    console.log(`[gateway] ${proj.id} online`);
+
+    ws.send(
+      JSON.stringify({
+        t: "hello",
+        capabilities: proj.capabilities,
+        serverTime: Date.now(),
+        protocolVersion: LINK_PROTOCOL_VERSION,
+      }),
+    );
+
+    ws.on("message", async (raw) => {
+      let msg: LinkMessage;
+      try {
+        msg = parseLinkMessage(raw.toString());
+      } catch {
+        return;
+      }
+      if (msg.t === "snapshot.push") {
+        try {
+          await ingestSnapshot(msg);
+          console.log(`[gateway] ${proj.id} snapshot: ${msg.memory.length} memories`);
+        } catch (e) {
+          console.error(`[gateway] ${proj.id} ingest failed:`, e);
+        }
+      } else if (msg.t === "res") {
+        const p = pending.get(msg.id);
+        if (p) {
+          pending.delete(msg.id);
+          msg.ok ? p.resolve(msg.data) : p.reject(new Error(msg.error ?? "flow_error"));
+        }
+      } else if (msg.t === "ping") {
+        ws.send(JSON.stringify({ t: "pong" }));
+      }
+    });
+
+    ws.on("close", () => {
+      liveLinks.delete(proj.id);
+      setProjectStatus(proj.id, "offline");
+      console.log(`[gateway] ${proj.id} offline`);
+    });
+  });
+
+  return wss;
+}
+
+/** AGENT -> FLOW: call a tool over the live link. Rejects if the project is offline. */
+export function callFlow(
+  projectId: string,
+  tool: McpToolName,
+  args: Record<string, unknown>,
+  timeoutMs = 15_000,
+): Promise<unknown> {
+  const ws = liveLinks.get(projectId);
+  if (!ws) return Promise.reject(new Error("project_offline"));
+  const id = randomUUID();
+  return new Promise((resolve, reject) => {
+    pending.set(id, { resolve, reject });
+    ws.send(JSON.stringify({ t: "req", id, tool, args }));
+    setTimeout(() => {
+      if (pending.delete(id)) reject(new Error("flow_timeout"));
+    }, timeoutMs);
+  });
+}
+
+export function isOnline(projectId: string): boolean {
+  return liveLinks.has(projectId);
+}

package/apps/web/next-env.d.ts

@@ -0,0 +1,6 @@
+/// <reference types="next" />
+/// <reference types="next/image-types/global" />
+/// <reference path="./.next/types/routes.d.ts" />
+
+// NOTE: This file should not be edited
+// see https://nextjs.org/docs/app/api-reference/config/typescript for more information.

package/apps/web/next.config.mjs

@@ -0,0 +1,9 @@
+/** @type {import('next').NextConfig} */
+const nextConfig = {
+  // The shared protocol package ships raw TS — let Next transpile it.
+  transpilePackages: ["@mop/link-protocol"],
+  // Native modules must not be bundled — require them at runtime instead.
+  serverExternalPackages: ["better-sqlite3", "sqlite-vec", "@xenova/transformers", "onnxruntime-node"],
+};
+
+export default nextConfig;

package/apps/web/package.json

@@ -0,0 +1,44 @@
+{
+  "name": "@mop/web",
+  "version": "0.0.1",
+  "description": "MOP-AGENT web app — control plane, Brain, WS gateway, central agent.",
+  "private": true,
+  "type": "module",
+  "scripts": {
+    "dev": "tsx server.ts",
+    "build": "next build",
+    "start": "cross-env NODE_ENV=production tsx server.ts",
+    "db:migrate": "tsx scripts/migrate.ts",
+    "cli": "tsx bin/mop-agent.mjs",
+    "typecheck": "tsc --noEmit"
+  },
+  "dependencies": {
+    "@anthropic-ai/sdk": "^0.105.0",
+    "@mop/link-protocol": "*",
+    "@xenova/transformers": "^2.17.2",
+    "better-auth": "^1.6.20",
+    "better-sqlite3": "^12.11.1",
+    "croner": "^10.0.1",
+    "discord.js": "^14.26.4",
+    "drizzle-orm": "^0.45.2",
+    "grammy": "^1.44.0",
+    "next": "^15.1.0",
+    "openai": "^6.44.0",
+    "react": "^19.0.0",
+    "react-dom": "^19.0.0",
+    "reactflow": "^11.11.4",
+    "sqlite-vec": "^0.1.9",
+    "ws": "^8.18.0"
+  },
+  "devDependencies": {
+    "@types/better-sqlite3": "^7.6.13",
+    "@types/node": "^22.0.0",
+    "@types/react": "^19.0.0",
+    "@types/react-dom": "^19.0.0",
+    "@types/ws": "^8.5.12",
+    "cross-env": "^7.0.3",
+    "drizzle-kit": "^0.31.10",
+    "tsx": "^4.19.0",
+    "typescript": "^5.5.0"
+  }
+}

package/apps/web/scripts/migrate.ts

@@ -0,0 +1,12 @@
+/** Run all migrations (app tables + sqlite-vec + Better Auth). `npm run db:migrate`. */
+import { runAllMigrations } from "../lib/db/migrate.js";
+
+runAllMigrations()
+  .then(() => {
+    console.log("✅ migrations applied");
+    process.exit(0);
+  })
+  .catch((e) => {
+    console.error("❌ migration failed:", e);
+    process.exit(1);
+  });

package/apps/web/server.ts

@@ -0,0 +1,27 @@
+/**
+ * Custom Node server: Next.js request handler + the reverse WSS gateway on one port.
+ * Cross-platform (Windows + Linux). Run via `tsx server.ts`.
+ */
+import { createServer } from "node:http";
+import next from "next";
+import { attachGateway } from "./lib/ws/gateway.js";
+import { startChannels } from "./lib/channels/index.js";
+import { startScheduler } from "./lib/brain/scheduler.js";
+
+const dev = process.env.NODE_ENV !== "production";
+const port = Number(process.env.PORT ?? 3000);
+
+const app = next({ dev });
+const handle = app.getRequestHandler();
+
+app.prepare().then(() => {
+  const server = createServer((req, res) => handle(req, res));
+  attachGateway(server);
+  server.listen(port, async () => {
+    console.log(`MOP-AGENT → http://localhost:${port}  (link ws: /link)`);
+    const channels = await startChannels();
+    if (channels.length) console.log(`channels started: ${channels.join(", ")}`);
+    const jobs = startScheduler();
+    if (jobs.length) console.log(`scheduler: ${jobs.join(", ")}`);
+  });
+});

package/apps/web/tsconfig.json

@@ -0,0 +1,31 @@
+{
+  "extends": "../../tsconfig.base.json",
+  "compilerOptions": {
+    "jsx": "preserve",
+    "noEmit": true,
+    "plugins": [
+      {
+        "name": "next"
+      }
+    ],
+    "types": [
+      "node"
+    ],
+    "paths": {
+      "@/*": [
+        "./*"
+      ]
+    },
+    "allowJs": true,
+    "incremental": true
+  },
+  "include": [
+    "next-env.d.ts",
+    "**/*.ts",
+    "**/*.tsx",
+    ".next/types/**/*.ts"
+  ],
+  "exclude": [
+    "node_modules"
+  ]
+}