@capybara-hq/kernel 0.1.0-rc.2 → 0.1.0-rc.21

package/dist/ui/views.js

@@ -7,20 +7,27 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
 var __param = (this && this.__param) || function (paramIndex, decorator) {
     return function (target, key) { decorator(target, key, paramIndex); }
 };
-import { normalizePlace, validateUiView, } from "@capybara-hq/plugin-sdk";
+import { UI_ARRANGEABLE_SLOTS, validateUiView, } from "@capybara-hq/plugin-sdk";
 import { Inject, Injectable } from "@nestjs/common";
 import { sql } from "kysely";
+import { isAgentVisibleIn } from "../agents/agent-lookup.js";
 import { ConversationsService } from "../conversations/conversations.service.js";
 import { ApiError } from "../errors.js";
+import { EffectiveConfigs, NEEDS_CONFIG_REASON } from "../extensions/effective-config.js";
 import { ExtensionHost } from "../extensions/host.js";
 import { PreviewerRegistry } from "../files/previewers.js";
+import { readUiArrangement } from "../identity/settings.js";
 import { KernelDb } from "../infra/database/kernel-db.js";
 import { KERNEL_LOGGER } from "../infra/tokens.js";
+import { readOrgSettings } from "../orgs/settings.service.js";
+import { arrange, arrangeBySlot, effectiveEntry, isSingle, keyOf, ORG_ARRANGEABLE, orderItems, resolveSingleSlot, storedUse, } from "./arrangement.js";
 import { callExtension } from "./call-extension.js";
-import { canUsePlace, isConversationPlace, UUID_RE } from "./registry.js";
+import { canUseSlot, UUID_RE } from "./registry.js";
 export { callExtension } from "./call-extension.js";
 /** 插件 render / action 的时限（spec §4.2：慢的插件只让那个标签失败）。 */
 export const UI_CALL_TIMEOUT_MS = 5_000;
+/** The log field naming where a target is: its org, or the platform scope. */
+const whereOf = (t) => t.scope === "platform" ? { scope: "platform" } : { orgId: t.orgId };
 /**
  * The card a `tool_result` of the conversation recorded for `callId`, or null (the inline-card
  * attestation of {@link UiViewsDeps.recordedCard}). Scans one conversation's tool results.
@@ -65,16 +72,54 @@ export function dropForeignOpens(view, panels) {
     const { open, ...rest } = view;
     return { ...rest, ...(open !== undefined && ok(open) && { open }), blocks };
 }
+/**
+ * Lists contributions for a listing route: no alias, a view's render registered (an embed or a
+ * component is listed without one: a component's server view is optional); base order (spec §5):
+ * extension name, then manifest order (stable).
+ */
+function listed(entries) {
+    return entries
+        .filter((c) => c.contribution.aliasOf === undefined &&
+        (c.contribution.kind === "embed" || c.contribution.kind === "component" || c.render))
+        .map((c, i) => ({ c, i }))
+        .sort((x, y) => (x.c.plugin === y.c.plugin ? x.i - y.i : x.c.plugin < y.c.plugin ? -1 : 1))
+        .map(({ c: { plugin, contribution: c, slot: s, after } }) => ({
+        plugin,
+        id: c.id,
+        title: c.title,
+        slot: s.id,
+        ...(after !== undefined && { after }),
+        kind: c.kind,
+        ...(c.kind === "embed" && c.path !== undefined && { path: c.path }),
+        icon: c.icon ?? "puzzle",
+    }));
+}
+/** The candidates of a single slot in an arrangement listing. */
+const candidatesOf = (items) => items.map((i) => ({ key: keyOf(i), title: i.title }));
+/** The items in effective order, each marked hidden or not (hidden ones stay in place). */
+function withHidden(items, entry) {
+    const hidden = new Set(entry.hidden);
+    return orderItems(items, entry).map((i) => ({ ...i, hidden: hidden.has(`${i.plugin}/${i.id}`) }));
+}
+/** A platform route's contribution: found, and in `platform.page`; else 404. */
+function platformEntry(entry) {
+    if (entry === undefined || entry.slot.id !== "platform.page")
+        throw notFound();
+    return entry;
+}
 const TOAST_MAX = 500;
 const MAX_LOGGED_PROBLEMS = 10;
 const notFound = () => new ApiError("ui.not_found", "UI contribution not found");
 const isObj = (v) => typeof v === "object" && v !== null && !Array.isArray(v);
-/** 校验动作结果，返回问题列表（空 = 合法）。 */
-function actionResultProblems(r) {
+/**
+ * 校验动作结果，返回问题列表（空 = 合法）。A new `view` may carry `data` only for a component
+ * (`component`).
+ */
+function actionResultProblems(r, component) {
     if (!isObj(r))
         return ["action result must be an object"];
     if (r.view !== undefined)
-        return validateUiView(r.view).map((p) => `view: ${p}`);
+        return validateUiView(r.view, { component }).map((p) => `view: ${p}`);
     if (r.toast === undefined)
         return [];
     if (!isObj(r.toast))
@@ -90,9 +135,13 @@ function actionResultProblems(r) {
 /**
  * 插件视图（第一档：渲染 schema）：列出贡献、调用插件 `render` / `action`。
  * - 只认在该组织已启用、且已在本副本加载的插件（启用状态每次查库）；
- * - 对话视图要求调用者能访问这个对话（与 SSE 流一致），访问不了与不存在一样返回 404 `ui.not_found`；
- * - 组织页面（`place: "page"`，视图与嵌入）只给 member 以上：guest 列表里看不到、取视图 / 动作 / 令牌一律 404；
- * - 组织页面视图不接受 `conversationId`（带了 400，与对话视图缺它一致）；
+ * - every request goes through one gate (`resolve`): the slot's `minRole` (never `platform.page`),
+ *   then its scope rule (conversation: readable, like the SSE stream; agent: readable and in this
+ *   org; org: the role alone); refused is 404 `ui.not_found`, the same as not existing;
+ * - a view takes only the context id of its scope (`conversationId` / `agentId`): a missing one or
+ *   one of another scope is 400 `validation_failed`;
+ * - a component's server view (`ctx.ui.view(<component id>)`) is served like a view of its slot;
+ *   only its views carry `data` (a plain view's `data` is 502 `ui.invalid_view`);
  * - 调用带 5 秒时限与中止信号：render 抛错 502 `ui.render_failed`、action 抛错 502 `ui.action_failed`、
  *   超时 504 `ui.timeout`、返回非法视图 502
  *   `ui.invalid_view`，都记告警日志、不写对话日志（这些不是模型可见的内容）。
@@ -100,63 +149,150 @@ function actionResultProblems(r) {
  */
 let UiViews = class UiViews {
     d;
-    constructor(host, conversations, previewers, db, log) {
+    constructor(host, conversations, previewers, db, log, effective) {
         this.d = {
             host,
+            effective,
             // org config rows plus the required bootstrap plugins
             enabledPlugins: (orgId) => host.enabledPlugins(orgId),
             canAccessConversation: (orgId, id, accountId) => conversations.isAccessible(orgId, id, accountId),
+            canReadAgent: (orgId, agentId, accountId) => isAgentVisibleIn(db.db, orgId, agentId, accountId),
             checkWritable: async (orgId, id, accountId) => {
                 await conversations.writable(orgId, id, accountId);
             },
             previewEmbedAllowed: (t) => previewers.embedAllowed(t),
             recordedCard: (conversationId, callId) => recordedCard(db.db, conversationId, callId),
+            orgArrangement: async (orgId) => (await readOrgSettings(db.db, orgId)).uiArrangement,
+            platformArrangement: () => readUiArrangement(db.db),
             log,
         };
     }
-    /** 该组织、该角色可见的界面贡献：插件已启用且已加载；kind view 的要求插件注册了 render；组织页面要 member 以上。 */
-    async contributions(orgId, role) {
+    /**
+     * The contributions the role may use in the org, of one slot or of every org-reachable slot:
+     * the extension enabled and loaded, a view's render registered (a component is listed with or
+     * without a server view), the slot's `minRole` ({@link canUseSlot}, so never `platform.page`);
+     * no alias, no `file.preview` contribution (the file previewers list those). Base order (spec
+     * §5): extension name, then manifest order. A single slot lists at most its winner
+     * ({@link resolveSingleSlot} over what this role may use: none until one is chosen, and the web
+     * renders the built-in); display only, the routes that serve a contribution never read it. The
+     * winner is listed whether or not its client code may load (kill switch, per-plugin disable,
+     * client API support): the web renders the built-in when the org's client set has no such
+     * component, and any other consumer must do the same.
+     */
+    async contributions(orgId, role, slot) {
+        const items = await this.orgBase(orgId, role, slot);
+        if (items.length === 0)
+            return items;
+        const [org, platform] = await Promise.all([
+            this.d.orgArrangement(orgId),
+            this.d.platformArrangement(),
+        ]);
+        const winners = new Map();
+        const winnerOf = (s) => {
+            if (!winners.has(s)) {
+                const available = new Set(items.filter((i) => i.slot === s).map(keyOf));
+                winners.set(s, resolveSingleSlot(s, org?.[s], platform[s], available));
+            }
+            return winners.get(s) ?? null;
+        };
+        const shown = items.filter((i) => !isSingle(i.slot) || keyOf(i) === winnerOf(i.slot));
+        return arrangeBySlot(shown, (s) => effectiveEntry(org, platform, s).entry);
+    }
+    /** {@link contributions} before the arrangement: what the role may use, in base order. */
+    async orgBase(orgId, role, slot) {
         const all = this.d.host.uiContributions();
         if (all.length === 0)
             return [];
         const enabled = await this.d.enabledPlugins(orgId);
-        return all
-            .filter((c) => enabled.has(c.plugin) &&
-            c.contribution.aliasOf === undefined &&
-            c.contribution.place !== "file-preview" &&
-            (c.contribution.kind === "embed" || c.render) &&
-            canUsePlace(c.contribution.place, role))
-            .map(({ plugin, contribution: c }) => ({
-            plugin,
-            id: c.id,
-            title: c.title,
-            place: normalizePlace(c.place),
-            ...(c.place === "conversation" && { legacyPlace: "conversation" }),
-            kind: c.kind,
-            ...(c.kind === "embed" && c.path !== undefined && { path: c.path }),
-            icon: c.icon ?? "puzzle",
-        }));
+        return listed(all.filter((c) => enabled.has(c.plugin) &&
+            c.slot.id !== "file.preview" &&
+            (slot === undefined || c.slot.id === slot) &&
+            canUseSlot(c.slot, role)));
+    }
+    /**
+     * The arrangement page of an org: every org-arrangeable slot with the contributions the role may
+     * use: a list slot in effective order with the hidden ones in place, and where the entry comes
+     * from; a single slot with its candidates, the stored `use` and whether it follows the platform.
+     */
+    async arrangementView(orgId, role) {
+        // the page is for people who arrange or at least see the org's UI, not for a guest
+        if (role === "guest")
+            throw notFound();
+        const [base, org, platform] = await Promise.all([
+            this.orgBase(orgId, role, undefined),
+            this.d.orgArrangement(orgId),
+            this.d.platformArrangement(),
+        ]);
+        return ORG_ARRANGEABLE.map((slot) => {
+            const items = base.filter((i) => i.slot === slot);
+            if (isSingle(slot)) {
+                return { slot, candidates: candidatesOf(items), ...storedUse(org, platform, slot) };
+            }
+            const { entry, source } = effectiveEntry(org, platform, slot);
+            return { slot, source, items: withHidden(items, entry) };
+        });
+    }
+    /**
+     * The platform's arrangement page: every arrangeable slot with the contributions of every running
+     * extension (whatever its org enablement): a list slot ordered by the platform entry, hidden ones
+     * in place; a single slot with its candidates and the platform's `use`.
+     */
+    async platformArrangementView() {
+        const [base, platform] = await Promise.all([
+            listed(this.d.host.uiContributions().filter((c) => c.slot.id !== "file.preview")),
+            this.d.platformArrangement(),
+        ]);
+        return UI_ARRANGEABLE_SLOTS.map((slot) => {
+            const items = base.filter((i) => i.slot === slot);
+            if (isSingle(slot)) {
+                const { use } = storedUse(undefined, platform, slot);
+                return { slot, candidates: candidatesOf(items), use, followsPlatform: false };
+            }
+            const { entry, source } = effectiveEntry(undefined, platform, slot);
+            return { slot, source, items: withHidden(items, entry) };
+        });
+    }
+    /**
+     * The `platform.page` contributions of the running extensions, for the admin console (super
+     * admins; no org enablement applies): no alias, a view's render registered (a component is
+     * listed with or without a server view). Base order like {@link contributions}.
+     */
+    async platformContributions() {
+        const items = listed(this.d.host.uiContributions().filter((c) => c.slot.id === "platform.page"));
+        const { entry } = effectiveEntry(undefined, await this.d.platformArrangement(), "platform.page");
+        return arrange(items, entry);
     }
     /**
      * 嵌入应用：核对贡献是 embed、插件在该组织启用；对话嵌入要求调用者能访问该对话（否则 404，与视图一致），
      * 组织页面不收 `conversationId`。返回签发令牌所需的目标（令牌由调用方签）。
      */
     async embed(t) {
-        const { fileId, ...target } = t;
-        const { entry, args } = await this.resolve({ ...target, locale: "en" }, "embed");
+        let fileId;
+        let target;
+        if (t.scope === "platform")
+            target = { ...t, locale: "en" };
+        else {
+            const { fileId: f, ...org } = t;
+            fileId = f;
+            target = { ...org, locale: "en" };
+        }
+        const { entry, args } = await this.resolve(target, "embed");
         const path = entry.contribution.path;
         if (path === undefined)
             throw notFound();
-        const preview = entry.contribution.place === "file-preview";
+        const preview = entry.slot.id === "file.preview";
         if (preview !== (fileId !== undefined)) {
             throw new ApiError("validation_failed", preview
                 ? "fileId is required for a file-preview embed"
                 : "fileId is only allowed for a file-preview embed");
         }
         if (fileId !== undefined) {
+            // a file-preview embed is an org's (a platform target never carries a fileId)
+            if (args.orgId === undefined)
+                throw notFound();
             const allowed = this.d.previewEmbedAllowed !== undefined &&
                 (await this.d.previewEmbedAllowed({
-                    orgId: t.orgId,
+                    orgId: args.orgId,
                     accountId: t.accountId,
                     conversationId: args.conversationId,
                     fileId,
@@ -171,6 +307,7 @@ let UiViews = class UiViews {
             contribution: t.id,
             path,
             ...(args.conversationId !== undefined && { conversationId: args.conversationId }),
+            ...(args.agentId !== undefined && { agentId: args.agentId }),
             ...(fileId !== undefined && { fileId }),
         };
     }
@@ -179,7 +316,8 @@ let UiViews = class UiViews {
         const { entry, args } = await this.resolve(t, "render");
         const render = entry.render;
         const view = await this.call(t, "render", (signal) => render({ ...args, signal }));
-        this.check(t, "render", validateUiView(view));
+        // `data` only from a component's view (client extensions spec §5.2)
+        this.check(t, "render", validateUiView(view, { component: entry.contribution.kind === "component" }));
         return dropForeignOpens(view, this.panels(t.plugin));
     }
     /** 执行动作：调用插件 `action`（视图里的按钮 / 表单提交），校验返回的提示或新视图。 */
@@ -193,7 +331,7 @@ let UiViews = class UiViews {
             ...(input.payload !== undefined && { payload: input.payload }),
             ...(input.answer !== undefined && { answer: input.answer }),
         }));
-        this.check(t, "action", actionResultProblems(r));
+        this.check(t, "action", actionResultProblems(r, entry.contribution.kind === "component"));
         const res = r;
         if (res.view !== undefined)
             return { view: dropForeignOpens(res.view, this.panels(t.plugin)) };
@@ -203,10 +341,20 @@ let UiViews = class UiViews {
     panels(plugin) {
         return new Set(this.d.host
             .uiContributions()
-            .filter((c) => c.plugin === plugin && normalizePlace(c.contribution.place) === "panel")
+            .filter((c) => c.plugin === plugin && c.slot.id === "conversation.panel")
             .map((c) => c.contribution.id));
     }
-    /** 找贡献、核对组织启用与对话访问；返回传给插件的参数（不含 signal）。 */
+    /**
+     * The single access gate of the org UI routes (UI slots spec §7): finds the contribution (a
+     * retired alias answers with the one it names), then checks, in order, that its slot is reachable
+     * from an org (not `platform`), the role meets the slot's `minRole`, the extension is enabled in
+     * the org, its effective config is valid, and the slot's scope rule (conversation: readable;
+     * agent: readable and in this org; org: the role alone; file: a conversation the caller reads,
+     * the previewer's grant is checked by `embed`). A platform target (the admin routes) takes the
+     * platform gate instead ({@link platformArgs}): only a `platform.page` contribution. Returns the
+     * args passed to the extension (no signal). Anything refused for a contribution that exists is
+     * 404 `ui.not_found`.
+     */
     async resolve(t, need) {
         const loaded = this.d.host.uiContributions();
         const named = loaded.find((c) => c.plugin === t.plugin && c.contribution.id === t.id);
@@ -218,24 +366,63 @@ let UiViews = class UiViews {
             c.contribution.aliasOf === undefined &&
             (need === "embed"
                 ? c.contribution.kind === "embed"
-                : c.contribution.kind === "view" && c[need] !== undefined));
-        if (!entry || !canUsePlace(entry.contribution.place, t.role))
+                : // a view, or a component's server view (served like a view of its slot)
+                    (c.contribution.kind === "view" || c.contribution.kind === "component") &&
+                        c[need] !== undefined));
+        if (t.scope === "platform") {
+            const found = platformEntry(entry);
+            return { entry: found, args: this.platformArgs(t, found) };
+        }
+        if (!entry || entry.slot.scope === "platform" || !canUseSlot(entry.slot, t.role)) {
             throw notFound();
+        }
         if (!(await this.d.enabledPlugins(t.orgId)).has(t.plugin))
             throw notFound();
-        const base = { orgId: t.orgId, accountId: t.accountId, role: t.role, locale: t.locale };
-        if (!isConversationPlace(entry.contribution.place)) {
-            if (t.item !== undefined || t.card !== undefined) {
-                throw new ApiError("validation_failed", "item and callId are for conversation views");
+        // spec A §6: the extension is not called for an org whose effective config is not valid
+        const effective = await this.d.effective.get(t.orgId, t.plugin);
+        if (!effective.ok) {
+            throw new ApiError("extension.needs_config", `Extension ${t.plugin} ${NEEDS_CONFIG_REASON}`);
+        }
+        const scope = entry.slot.scope;
+        const base = {
+            orgId: t.orgId,
+            accountId: t.accountId,
+            role: t.role,
+            slot: entry.slot.id,
+            scope,
+            locale: t.locale,
+            config: effective.config,
+        };
+        const what = need === "embed" ? "embed" : "view";
+        const conversational = scope === "conversation" || scope === "file";
+        if (!conversational && (t.item !== undefined || t.card !== undefined)) {
+            throw new ApiError("validation_failed", "item and callId are for conversation views");
+        }
+        if (scope !== "agent" && t.agentId !== undefined) {
+            throw new ApiError("validation_failed", `agentId is only allowed for an agent ${what}`);
+        }
+        if (scope === "agent") {
+            if (t.conversationId !== undefined) {
+                throw new ApiError("validation_failed", `conversationId is not allowed for an agent ${what}`);
+            }
+            const agentId = t.agentId;
+            if (agentId === undefined) {
+                throw new ApiError("validation_failed", `agentId is required for an agent ${what}`);
+            }
+            if (!UUID_RE.test(agentId) || !(await this.d.canReadAgent(t.orgId, agentId, t.accountId))) {
+                throw notFound();
             }
+            return { entry, args: { ...base, agentId } };
+        }
+        if (!conversational) {
             if (t.conversationId !== undefined) {
-                throw new ApiError("validation_failed", `conversationId is not allowed for an organization page ${need === "embed" ? "embed" : "view"}`);
+                throw new ApiError("validation_failed", `conversationId is not allowed for an organization page ${what}`);
             }
             return { entry, args: base };
         }
         const conversationId = t.conversationId;
         if (conversationId === undefined) {
-            throw new ApiError("validation_failed", `conversationId is required for a conversation ${need === "embed" ? "embed" : "view"}`);
+            throw new ApiError("validation_failed", `conversationId is required for a conversation ${what}`);
         }
         if (!UUID_RE.test(conversationId) ||
             !(await this.d.canAccessConversation(t.orgId, conversationId, t.accountId))) {
@@ -247,7 +434,7 @@ let UiViews = class UiViews {
         if (t.card !== undefined) {
             // args.card is attested: an inline view, and a tool_result of this conversation recorded this
             // very card (plugin, the requested id or its alias target, key); else it is not found
-            const recorded = normalizePlace(entry.contribution.place) === "inline" && this.d.recordedCard !== undefined
+            const recorded = entry.slot.id === "conversation.tool-result.card" && this.d.recordedCard !== undefined
                 ? await this.d.recordedCard(conversationId, t.card.callId)
                 : null;
             if (recorded === null ||
@@ -267,13 +454,32 @@ let UiViews = class UiViews {
             },
         };
     }
+    /**
+     * The platform gate (UI slots spec §7): the contribution is a `platform.page` of a running
+     * extension (no org enablement applies), given the platform's deployment config. The caller is a
+     * super admin (`@SuperAdmin` on the admin routes); anything else is 404 `ui.not_found`.
+     */
+    platformArgs(t, entry) {
+        const effective = this.d.effective.platform(t.plugin);
+        // `platform()` fails only when the extension is not running here: not found
+        if (!effective.ok)
+            throw notFound();
+        return {
+            scope: "platform",
+            accountId: t.accountId,
+            role: "superAdmin",
+            slot: entry.slot.id,
+            locale: t.locale,
+            config: effective.config,
+        };
+    }
     /** 带时限调用插件：超时中止信号并 504；抛错 502（render / action 各一个码，不回显插件的异常信息）。 */
     call(t, what, fn) {
         return callExtension({
             log: this.d.log,
             plugin: t.plugin,
             what,
-            fields: { plugin: t.plugin, contribution: t.id, orgId: t.orgId },
+            fields: { plugin: t.plugin, contribution: t.id, ...whereOf(t) },
             timeoutMs: UI_CALL_TIMEOUT_MS,
             failCode: what === "render" ? "ui.render_failed" : "ui.action_failed",
             failMessage: `Plugin ${t.plugin} failed to ${what} ${t.id}`,
@@ -287,7 +493,7 @@ let UiViews = class UiViews {
         this.d.log.warn(`plugin ui ${what} returned an invalid view`, {
             plugin: t.plugin,
             contribution: t.id,
-            orgId: t.orgId,
+            ...whereOf(t),
             problems: problems.slice(0, MAX_LOGGED_PROBLEMS),
         });
         throw new ApiError("ui.invalid_view", `Plugin ${t.plugin} returned an invalid view`);
@@ -299,6 +505,7 @@ UiViews = __decorate([
     __param(1, Inject(ConversationsService)),
     __param(2, Inject(PreviewerRegistry)),
     __param(3, Inject(KernelDb)),
-    __param(4, Inject(KERNEL_LOGGER))
+    __param(4, Inject(KERNEL_LOGGER)),
+    __param(5, Inject(EffectiveConfigs))
 ], UiViews);
 export { UiViews };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@capybara-hq/kernel",
-  "version": "0.1.0-rc.2",
+  "version": "0.1.0-rc.21",
   "description": "Capybara kernel: config, database, plugin host and HTTP API of the Capybara agent platform",
   "license": "Apache-2.0",
   "repository": {
@@ -32,6 +32,7 @@
   "dependencies": {
     "@fastify/cookie": "^11.1.3",
     "@fastify/static": "^9.3.0",
+    "@fastify/websocket": "^11.3.7",
     "@langchain/core": "^1.2.18",
     "@langchain/langgraph": "^1.5.1",
     "@langchain/langgraph-checkpoint": "^1.2.0",
@@ -64,14 +65,16 @@
     "yaml": "^2.9.1",
     "yauzl": "3.4.0",
     "zod": "^4.6.7",
-    "@capybara-hq/plugin-sdk": "^0.1.0-rc.0"
+    "@capybara-hq/plugin-sdk": "^0.1.0-rc.15"
   },
   "devDependencies": {
     "@langchain/langgraph-checkpoint-validation": "^1.2.0",
     "@types/pg": "^8.23.1",
     "@types/semver": "^7.8.0",
+    "@types/ws": "^8.18.2",
     "@types/yauzl": "3.4.0",
-    "@capybara-hq/testing": "0.1.0-rc.3"
+    "ws": "^8.22.0",
+    "@capybara-hq/testing": "0.1.0-rc.15"
   },
   "scripts": {
     "build": "tsc -b"