@cursor/july 0.1.1

package/src/channels/slack/socket-mode.ts

@@ -0,0 +1,154 @@
+/**
+ * Slack Socket Mode via `@slack/socket-mode`.
+ *
+ * Thin wrapper: ACK envelopes immediately, then forward Events API
+ * payloads to the channel pack. Reconnect is handled by the SDK.
+ */
+
+import { type Logger, LogLevel, SocketModeClient } from "@slack/socket-mode";
+
+export interface SlackSocketModeOptions {
+  appToken: string;
+  /** Events API payloads (`type: events_api` envelope body). */
+  onEvent: (payload: unknown) => void | Promise<void>;
+  /**
+   * Interactive payloads (`type: interactive` — Block Kit actions).
+   * When omitted, interactive envelopes are ACKed and ignored.
+   */
+  onInteractive?: (payload: unknown) => void | Promise<void>;
+  logger?: (line: string) => void;
+}
+
+export interface SlackSocketModeHandle {
+  stop(): void | Promise<void>;
+}
+
+function createBridgeLogger(write: (line: string) => void): Logger {
+  let level: LogLevel = LogLevel.INFO;
+  const rank: Record<LogLevel, number> = {
+    [LogLevel.ERROR]: 0,
+    [LogLevel.WARN]: 1,
+    [LogLevel.INFO]: 2,
+    [LogLevel.DEBUG]: 3,
+  };
+  const emit = (msgLevel: LogLevel, msgs: unknown[]): void => {
+    if (rank[msgLevel] > rank[level]) {
+      return;
+    }
+    const text = msgs
+      .map((m) => (typeof m === "string" ? m : JSON.stringify(m)))
+      .join(" ");
+    write(`[agent-serve/slack] Socket Mode ${text}`);
+  };
+  return {
+    debug: (...msgs) => emit(LogLevel.DEBUG, msgs),
+    info: (...msgs) => emit(LogLevel.INFO, msgs),
+    warn: (...msgs) => emit(LogLevel.WARN, msgs),
+    error: (...msgs) => emit(LogLevel.ERROR, msgs),
+    setLevel(next) {
+      level = next;
+    },
+    getLevel: () => level,
+    setName() {
+      // Name is unused; agent-serve prefixes lines itself.
+    },
+  };
+}
+
+function invokeHandler(
+  log: (line: string) => void,
+  label: string,
+  handler: (payload: unknown) => void | Promise<void>,
+  payload: unknown
+): void {
+  try {
+    const result = handler(payload);
+    if (
+      result !== undefined &&
+      typeof (result as Promise<void>).then === "function"
+    ) {
+      void Promise.resolve(result).catch((error) => {
+        log(
+          `[agent-serve/slack] Socket Mode ${label} failed: ${errorMessage(error)}`
+        );
+      });
+    }
+  } catch (error) {
+    log(
+      `[agent-serve/slack] Socket Mode ${label} failed: ${errorMessage(error)}`
+    );
+  }
+}
+
+function errorMessage(error: unknown): string {
+  return error instanceof Error ? error.message : String(error);
+}
+
+/**
+ * Start a Socket Mode connection. Call `stop()` to tear down.
+ * Resolves once the first WebSocket session is connected.
+ */
+export async function startSlackSocketMode(
+  options: SlackSocketModeOptions
+): Promise<SlackSocketModeHandle> {
+  const write = options.logger ?? ((line: string) => console.log(line));
+  const client = new SocketModeClient({
+    appToken: options.appToken,
+    logger: createBridgeLogger(write),
+    logLevel: LogLevel.INFO,
+    autoReconnectEnabled: true,
+  });
+
+  client.on("connected", () => {
+    write("[agent-serve/slack] Socket Mode connected");
+  });
+  client.on("reconnecting", () => {
+    write("[agent-serve/slack] Socket Mode reconnecting");
+  });
+  client.on("disconnected", () => {
+    write("[agent-serve/slack] Socket Mode disconnected");
+  });
+
+  client.on(
+    "slack_event",
+    (evt: {
+      type?: string;
+      body?: unknown;
+      ack: (response?: Record<string, unknown>) => Promise<void>;
+    }) => {
+      // ACK immediately (3s envelope budget); then dispatch off-path.
+      void Promise.resolve(evt.ack()).catch((error: unknown) => {
+        write(
+          `[agent-serve/slack] Socket Mode ACK failed: ${errorMessage(error)}`
+        );
+      });
+
+      if (evt.type === "events_api") {
+        if (evt.body !== undefined) {
+          invokeHandler(write, "onEvent", options.onEvent, evt.body);
+        }
+        return;
+      }
+      if (evt.type === "interactive") {
+        if (evt.body !== undefined && options.onInteractive !== undefined) {
+          invokeHandler(
+            write,
+            "onInteractive",
+            options.onInteractive,
+            evt.body
+          );
+        }
+        return;
+      }
+    }
+  );
+
+  await client.start();
+
+  return {
+    async stop() {
+      await client.disconnect();
+      write("[agent-serve/slack] Socket Mode stopped");
+    },
+  };
+}

package/src/channels/slack/stream.ts

@@ -0,0 +1,63 @@
+/**
+ * Chat streaming helpers for Slack AI / agent features.
+ */
+
+export type StreamTaskStatus = "pending" | "in_progress" | "complete" | "error";
+
+export interface StreamTaskChunk {
+  type: "task_update";
+  id: string;
+  title: string;
+  status: StreamTaskStatus;
+}
+
+/**
+ * Given previously sent cumulative text and the new cumulative text, return
+ * the suffix to append. Empty string when there is nothing new to send.
+ */
+export function computeStreamAppend(
+  lastPostedText: string | null | undefined,
+  cumulative: string
+): string {
+  if (cumulative === "") {
+    return "";
+  }
+  if (
+    lastPostedText === null ||
+    lastPostedText === undefined ||
+    lastPostedText === ""
+  ) {
+    return cumulative;
+  }
+  if (cumulative.startsWith(lastPostedText)) {
+    return cumulative.slice(lastPostedText.length);
+  }
+  // Text rewound / rewritten — cannot unsend; skip append.
+  return "";
+}
+
+/** Build task_update chunks for tool calls. */
+export function buildTaskChunksForCalls(
+  calls: Array<{ callId: string; toolName: string }>,
+  status: StreamTaskStatus
+): StreamTaskChunk[] {
+  return calls.map((call) => ({
+    type: "task_update" as const,
+    id: call.callId,
+    title: call.toolName,
+    status,
+  }));
+}
+
+export function buildTaskChunkForResult(args: {
+  callId: string;
+  toolName: string;
+  isError: boolean;
+}): StreamTaskChunk {
+  return {
+    type: "task_update",
+    id: args.callId,
+    title: args.toolName,
+    status: args.isError ? "error" : "complete",
+  };
+}

package/src/channels/slack/tool-approval-events.ts

@@ -0,0 +1,136 @@
+/**
+ * Slack surface for human-in-the-loop tool approvals.
+ *
+ * Or compose with {@link buildDefaultEvents} (or your own handlers). When
+ * composing by hand, also set `slackChannel({ interactivity: true })` (or
+ * `toolApprovals: true`) so Socket Mode routes Approve/Deny clicks —
+ * otherwise cards post but button presses are ACKed and ignored:
+ *
+ * ```ts
+ * events: {
+ *   ...buildDefaultEvents({ credentials }),
+ *   ...buildToolApprovalEvents({ credentials }),
+ * }
+ * ```
+ *
+ * Or opt in via `slackChannel({ toolApprovals: true })`.
+ * Park/resume itself is the framework HITL primitive (`needsApproval`);
+ * this pack only delivers Approve/Deny in Slack.
+ */
+
+import type { ChannelEventHandlers } from "../../types.js";
+import { postMessage, setThreadStatus, updateMessage } from "./api.js";
+import {
+  buildApprovalBlocks,
+  buildResolvedApprovalBlocks,
+} from "./approvals.js";
+import { SLACK_DEFAULT_LOADING_MESSAGES } from "./constants.js";
+import { defaultSlackLog, type SlackLog } from "./log.js";
+import type { SlackChannelState, SlackCredentials } from "./types.js";
+
+export interface BuildToolApprovalEventsOptions {
+  credentials?: SlackCredentials;
+  /** Resolved per-call so channel onStart can rebind the server logger. */
+  getLog?: () => SlackLog;
+}
+
+/**
+ * Stream-event handlers that post Block Kit Approve/Deny cards and
+ * update them when approval is resolved (HTTP, playground, or Slack).
+ */
+export function buildToolApprovalEvents(
+  options: BuildToolApprovalEventsOptions = {}
+): ChannelEventHandlers<SlackChannelState> {
+  const botToken = options.credentials?.botToken;
+  const getLog = options.getLog ?? (() => defaultSlackLog);
+
+  return {
+    async "action.approval_requested"(event, channel, ctx) {
+      const log = getLog();
+      const state = channel.state;
+      if (state.channelId === null || state.threadTs === null) {
+        return;
+      }
+      const blocks = buildApprovalBlocks({
+        sessionId: ctx.session.id,
+        callId: event.data.callId,
+        toolName: event.data.toolName,
+        args: event.data.args,
+      });
+      try {
+        const posted = await postMessage({
+          botToken,
+          channel: state.channelId,
+          threadTs: state.threadTs,
+          text: `Approval required for \`${event.data.toolName}\``,
+          blocks,
+        });
+        channel.state.approvalMessageByCallId = {
+          ...(state.approvalMessageByCallId ?? {}),
+          [event.data.callId]: posted.ts,
+        };
+        await setThreadStatus({
+          botToken,
+          channelId: state.channelId,
+          threadTs: state.threadTs,
+          status: "Awaiting approval…",
+          loadingMessages: [
+            "Awaiting approval…",
+            ...SLACK_DEFAULT_LOADING_MESSAGES,
+          ],
+        });
+        log.info("approval card posted", {
+          call_id: event.data.callId,
+          tool: event.data.toolName,
+          message_ts: posted.ts,
+        });
+      } catch (error) {
+        log.warn("approval card post failed", {
+          call_id: event.data.callId,
+          error: error instanceof Error ? error.message : String(error),
+        });
+      }
+    },
+
+    async "action.approval_resolved"(event, channel) {
+      const log = getLog();
+      const state = channel.state;
+      const messageTs = state.approvalMessageByCallId?.[event.data.callId];
+      if (
+        state.channelId !== null &&
+        messageTs !== undefined &&
+        messageTs !== ""
+      ) {
+        const blocks = buildResolvedApprovalBlocks({
+          toolName: event.data.toolName,
+          decision: event.data.decision,
+          ...(event.data.by === undefined ? {} : { byUserId: event.data.by }),
+        });
+        const verb = event.data.decision === "approve" ? "Approved" : "Denied";
+        await updateMessage({
+          botToken,
+          channel: state.channelId,
+          ts: messageTs,
+          text: `${verb} — ${event.data.toolName}`,
+          blocks,
+        });
+        const next = { ...(state.approvalMessageByCallId ?? {}) };
+        delete next[event.data.callId];
+        channel.state.approvalMessageByCallId = next;
+      }
+      if (state.channelId !== null && state.threadTs !== null) {
+        await setThreadStatus({
+          botToken,
+          channelId: state.channelId,
+          threadTs: state.threadTs,
+          status: "Working…",
+          loadingMessages: [...SLACK_DEFAULT_LOADING_MESSAGES],
+        });
+      }
+      log.info("approval resolved in slack", {
+        call_id: event.data.callId,
+        decision: event.data.decision,
+      });
+    },
+  };
+}

package/src/channels/slack/types.ts

@@ -0,0 +1,349 @@
+/**
+ * Types for the Slack platform channel pack.
+ */
+
+import type {
+  AgentCloudOptions,
+  AuthContext,
+  ChannelEventHandlers,
+  HostContext,
+} from "../../types.js";
+
+/**
+ * Pluggable Slack Web API caller. Instead of holding a raw `xoxb-…` token,
+ * calls are executed by `call` — e.g. proxied through the Cursor backend
+ * with the signed-in account's Slack connection (`cursorAccount: true`).
+ * Implementations return the Slack response body (including `ok: false`
+ * platform errors) and only throw on programmer error.
+ */
+export interface SlackApiTransport {
+  kind: "api-transport";
+  /** Human-readable transport label for logs (e.g. `cursor-account`). */
+  label: string;
+  call(
+    method: string,
+    args: Record<string, unknown>
+  ): Promise<Record<string, unknown>>;
+}
+
+/** Bot token as a string, a (possibly async) resolver, or an API transport. */
+export type SlackBotToken =
+  | string
+  | (() => string | Promise<string>)
+  | SlackApiTransport;
+
+export interface SlackCredentials {
+  /**
+   * Bot user OAuth token (`xoxb-…`), or a {@link SlackApiTransport} that
+   * executes Web API calls without a local token. When omitted, falls back
+   * to `SLACK_BOT_TOKEN` (or `{envPrefix}_SLACK_BOT_TOKEN` via
+   * {@link SlackChannelOptions.envPrefix}).
+   */
+  botToken?: SlackBotToken;
+  /**
+   * App-level token (`xapp-…`) for Socket Mode. Requires scope
+   * `connections:write`. Same fallback rules as `botToken`.
+   */
+  appToken?: string | (() => string | Promise<string>);
+}
+
+/** Per-session Slack adapter state. */
+export interface SlackChannelState {
+  channelId: string | null;
+  threadTs: string | null;
+  teamId: string | null;
+  triggeringUserId: string | null;
+  pendingToolCallMessage: string | null;
+  lastReasoningTypingAtMs: number | null;
+  lastReasoningTypingStatus: string | null;
+  /** Active chat stream message ts (`chat.startStream`). */
+  streamTs: string | null;
+  /** Channel id used when the stream was started. */
+  streamChannelId?: string | null;
+  /** Last cumulative text sent via appendStream (for incremental append). */
+  lastPostedText?: string | null;
+  /**
+   * When true, stream APIs failed for this session — use postMessage
+   * for the rest of the turn.
+   */
+  streamingUnavailable?: boolean;
+  /**
+   * Message ts of approval cards keyed by tool call id (for
+   * replacing Approve/Deny buttons after a decision).
+   */
+  approvalMessageByCallId?: Record<string, string>;
+}
+
+export interface SlackAuthor {
+  userId: string;
+  userName?: string;
+  isBot: boolean;
+}
+
+export interface SlackMessage {
+  text: string;
+  /** Text roughly suitable for the model (mention markers cleaned). */
+  markdown: string;
+  ts: string;
+  threadTs: string;
+  channelId: string;
+  teamId?: string;
+  author?: SlackAuthor;
+}
+
+export interface SlackDispatchDecision {
+  auth: AuthContext | null;
+  /** Extra context blocks injected alongside the default Slack context. */
+  context?: string[];
+  /**
+   * Override the user prompt sent to the model. When omitted, uses the Slack
+   * message markdown (plus context blocks). Host-prepared reviews can pass
+   * a short "read pr.txt" prompt here.
+   */
+  message?: string;
+  /**
+   * Absolute directory used as the local harness `cwd` for this session
+   * (new sessions only).
+   */
+  workspaceDir?: string;
+  /**
+   * Relative path → contents written into the session workspace before the
+   * first turn (new sessions only). Prefer this for host-prepared files like
+   * `pr.txt` so default skill materialization stays on the session cwd.
+   */
+  workspaceFiles?: Record<string, string>;
+  /** Session display title (new sessions only). */
+  title?: string;
+  /**
+   * Per-session cloud options (new sessions only). Use this to attach a PR to
+   * a cloud agent from an inbound Slack mention.
+   */
+  cloud?: AgentCloudOptions;
+  /**
+   * Seed the Cursor SDK agent id for a new session (ignored when the thread
+   * already has one). Lets a handler reattach a Slack thread to an existing
+   * cloud conversation (e.g. per-PR `bc-…` affinity).
+   */
+  sdkAgentId?: string;
+}
+
+export interface SlackSuggestedPrompt {
+  title: string;
+  message: string;
+}
+
+export interface SlackThreadHandle {
+  post(text: string, options?: { blocks?: unknown[] }): Promise<{ ts: string }>;
+  startTyping(status: string, loadingMessages?: string[]): Promise<void>;
+  setTitle(title: string): Promise<void>;
+  setSuggestedPrompts(
+    prompts: SlackSuggestedPrompt[],
+    title?: string
+  ): Promise<void>;
+}
+
+export interface SlackBinding {
+  thread: SlackThreadHandle;
+  slack: {
+    channelId: string;
+    threadTs: string;
+    teamId?: string;
+  };
+  /** Shared host services (MCP / GitHub / Slack). */
+  host: HostContext;
+}
+
+export type SlackMessageHandler = (
+  ctx: SlackBinding,
+  message: SlackMessage
+) =>
+  | SlackDispatchDecision
+  | null
+  | undefined
+  | Promise<SlackDispatchDecision | null | undefined>;
+
+/**
+ * Opt-in channel watch: dispatch on posts in explicitly allowlisted
+ * channels without requiring an @mention. There is deliberately no
+ * "every channel the bot is in" wildcard — watching a channel is a
+ * per-channel decision.
+ */
+export interface SlackChannelPostsOptions {
+  /**
+   * Channels to watch: ids (`C…` / `G…`) or `#names`. Must be non-empty
+   * (empty is a definition error). `#names` are resolved to ids via
+   * `conversations.list` when the channel starts; the bot must be a member
+   * of each watched channel to receive its messages. Socket Mode only —
+   * `cursorAccount: true` rejects `engagement.channelPosts`.
+   */
+  allow: string[];
+  /**
+   * Which posts dispatch. `"top-level"` (default) fires only on new
+   * channel posts — never on replies inside other people's threads, so the
+   * agent can take fresh intake but cannot barge into conversations.
+   * `"all"` also dispatches thread replies (Socket Mode only).
+   */
+  posts?: "top-level" | "all";
+  /**
+   * Delay dispatch by this many milliseconds so rapid edits settle first.
+   * Edits during the window update the dispatched text; deleting the post
+   * cancels the dispatch. Defaults to `0` (immediate). Socket Mode only —
+   * the Cursor relay does not deliver edits/deletes.
+   */
+  debounceMs?: number;
+}
+
+/**
+ * How the agent engages over Slack. Omitted entirely = mentions + DMs,
+ * which is also the default for each flag — summoned, never proactive.
+ */
+export interface SlackEngagementOptions {
+  /** Dispatch on `app_mention`. Defaults to `true`. */
+  mentions?: boolean;
+  /** Dispatch on direct messages (`message.im`). Defaults to `true`. */
+  directMessages?: boolean;
+  /**
+   * Opt-in channel watch (see {@link SlackChannelPostsOptions}). Requires
+   * the Slack app to subscribe to `message.channels` / `message.groups`
+   * (`slack init --channel-posts`, or add the events to an existing app).
+   */
+  channelPosts?: SlackChannelPostsOptions;
+}
+
+export interface SlackChannelOptions {
+  credentials?: SlackCredentials;
+  /**
+   * Per-agent env prefix for tokens. `envPrefix: "MY_AGENT"` reads
+   * `MY_AGENT_SLACK_BOT_TOKEN` + `MY_AGENT_SLACK_APP_TOKEN`. Prefer this over
+   * shared `SLACK_*` vars when serving multiple agents in one process.
+   * Ignored when `credentials` is set explicitly.
+   */
+  envPrefix?: string;
+  /**
+   * Use the signed-in Cursor account's Slack connection instead of a
+   * dedicated Slack app: no bot/app tokens, no extra install. Inbound
+   * traffic (`@Cursor <agent name> …` mentions, replies in threads the
+   * agent owns, and DMs) is relayed from the Cursor backend
+   * (`/v0/slack-events`), and outbound Web API calls are proxied through it
+   * — the agent posts as the Cursor Slack app with this agent's name and
+   * icon.
+   *
+   * Both paths stay first-class: omit this (default) for the classic
+   * Socket-Mode channel with your own Slack app and tokens. Requires a
+   * signed-in host (`agent-serve login` / `CURSOR_API_KEY`) and a Slack
+   * account linked to the Cursor account. Mutually exclusive with
+   * `credentials` / `envPrefix`. `engagement.mentions: false` and
+   * `engagement.directMessages: false` are rejected (the relay always
+   * carries that traffic). Channel watching (`engagement.channelPosts`) and
+   * tool approvals / interactivity (`toolApprovals` / `interactivity`) are
+   * Socket Mode only — not supported on cursorAccount; agents must be
+   * explicitly addressed, and Approve/Deny buttons need a dedicated Slack
+   * app.
+   */
+  cursorAccount?: boolean;
+  /**
+   * Display name registered with the Cursor backend when
+   * {@link cursorAccount} is on: `@Cursor <agentName> …` routes here, and
+   * replies post under this username. Defaults to a name derived from the
+   * agent's mount slug (or project name).
+   */
+  agentName?: string;
+  /** Avatar for posts when {@link cursorAccount} is on. */
+  agentIcon?: { url?: string; emoji?: string };
+  /**
+   * Optional log sink. When omitted, uses `console.log` until the server
+   * mounts the channel and rebinds to {@link ServeOptions.logger}.
+   */
+  logger?: (line: string) => void;
+  /**
+   * Engagement surface. Defaults to mentions + DMs only; channel watch is
+   * opt-in via {@link SlackEngagementOptions.channelPosts}.
+   */
+  engagement?: SlackEngagementOptions;
+  onAppMention?: SlackMessageHandler;
+  onDirectMessage?: SlackMessageHandler;
+  /**
+   * Handler for watched channel posts (same contract as `onAppMention`:
+   * return `null` to skip, or a {@link SlackDispatchDecision} to dispatch).
+   * Only consulted when `engagement.channelPosts` is configured.
+   */
+  onChannelPost?: SlackMessageHandler;
+  /**
+   * Override / extend the default stream-event handlers (typing, replies).
+   * Handlers you provide replace the matching default handlers.
+   */
+  events?: ChannelEventHandlers<SlackChannelState>;
+  /**
+   * When true (default), reply on final `message.completed` and show typing
+   * via `assistant.threads.setStatus` (and streaming when enabled).
+   */
+  deliverDefaults?: boolean;
+  /**
+   * Stream assistant text while the turn runs via `chat.startStream` /
+   * `appendStream` / `stopStream` (defaults to `true` for Socket Mode).
+   * Ignored when {@link cursorAccount} is on — that path never edits posts
+   * (`setStatus` + one final `chat.postMessage` only).
+   */
+  streaming?: boolean;
+  /**
+   * Show task-style thinking steps for tool calls (stream chunks or status).
+   * Defaults to `true`.
+   */
+  thinkingSteps?: boolean;
+  /**
+   * Opt in to Slack delivery for human-in-the-loop tool approvals.
+   *
+   * Framework park/resume is enabled by `needsApproval` on server tools.
+   * Set this to `true` to also post Block Kit Approve/Deny cards and route
+   * the Socket Mode `interactive` clicks to `resolveApproval`. Socket Mode
+   * only — rejected on `cursorAccount: true` (the Cursor Slack connection
+   * does not relay Block Kit clicks).
+   *
+   * Defaults to `false`. For custom composition, spread
+   * `buildToolApprovalEvents({ credentials })` into `events`.
+   */
+  toolApprovals?: boolean;
+  /**
+   * Route interactive payloads to approval resolution without opting into
+   * the full {@link buildToolApprovalEvents} handler pack. Use when
+   * composing `buildToolApprovalEvents` into `events` manually. Socket Mode
+   * only — rejected on `cursorAccount: true`.
+   */
+  interactivity?: boolean;
+  /**
+   * Suggested prompts shown when an assistant thread starts (and optionally
+   * after a turn completes).
+   */
+  suggestedPrompts?: SlackSuggestedPrompt[];
+  suggestedPromptsTitle?: string;
+}
+
+export interface SlackManifestOptions {
+  /** Display name for the Slack app. */
+  name: string;
+  /** Bot display name (handle without @). Defaults from `name`. */
+  botDisplayName?: string;
+  /** Env profile. Affects display name suffix. */
+  env: "dev" | "prod";
+  /** Optional short description shown in the Slack app. */
+  description?: string;
+  /** Include `assistant_view` + `assistant:write` for typing status. */
+  assistant?: boolean;
+  /**
+   * Enable Slack interactivity (needed for Approve/Deny cards).
+   * Defaults to `false` — enable when using `toolApprovals: true`.
+   */
+  interactivity?: boolean;
+  /**
+   * Subscribe to `message.channels` + `message.groups` for the opt-in
+   * channel watch (`engagement.channelPosts`). Defaults to `false`.
+   */
+  channelPosts?: boolean;
+  /** Seed suggested prompts into the manifest `assistant_view`. */
+  suggestedPrompts?: Array<{ title: string; message: string }>;
+}
+
+/** Soft-fail result for optional Slack API features. */
+export type SoftSlackResult<
+  T extends Record<string, unknown> = Record<string, unknown>,
+> = ({ ok: true } & T) | { ok: false; error: string; unsupported?: boolean };