@theaiplatform/miniapp-sdk 0.0.0

package/dist/config.d.ts

@@ -0,0 +1,35 @@
+export declare type AppConfig = {
+    ui?: readonly UIEntrypoint[];
+    tools?: Record<string, ToolDefinition>;
+};
+
+export declare function defineApp<const TConfig extends AppConfig>(config: TConfig): TConfig;
+
+export declare type JsonSchema = {
+    readonly [key: string]: unknown;
+};
+
+export declare type ToolDefinition<TArguments = unknown, TResult = unknown> = {
+    displayName?: string;
+    description: string;
+    parametersSchema: JsonSchema;
+    timeoutMs?: number;
+    actionMessageTemplate?: string;
+    execute(arguments_: TArguments): TResult;
+};
+
+export declare type UIEntrypoint = {
+    type: UIEntrypointType;
+    id: string;
+    name: string;
+    entryPoint: string;
+    icon?: string;
+    persistWhenClosed?: boolean;
+};
+
+/**
+ * @capability integrations-and-marketplace
+ */
+export declare type UIEntrypointType = 'workspace-left-sidebar' | 'workspace-left-sidebar-item' | 'chat-right-sidebar' | 'chat-right-sidebar-item';
+
+export { }

package/dist/config.js

@@ -0,0 +1,4 @@
+function defineApp(config) {
+    return config;
+}
+export { defineApp };

package/dist/index.d.ts

@@ -0,0 +1,475 @@
+export declare type AppConfig = {
+    ui?: readonly UIEntrypoint[];
+    tools?: Record<string, ToolDefinition>;
+};
+
+export declare type CreateChannelOptions = {
+    workspaceId?: string;
+    name: string;
+    description?: string;
+    projectId?: string | null;
+    visibility?: string;
+};
+
+export declare type CreateChannelResult = {
+    roomId: string;
+};
+
+export declare type CreateProjectOptions = {
+    workspaceId?: string;
+    id?: string;
+    name: string;
+    discoverable?: boolean;
+};
+
+export declare type CreateProjectResult = {
+    projectId: string;
+};
+
+export declare function defineApp<const TConfig extends AppConfig>(config: TConfig): TConfig;
+
+export declare type GetChannelAccessOptions = {
+    workspaceId?: string;
+    channelId: string;
+};
+
+export declare type GetChannelAccessResult = {
+    archived: boolean;
+    capabilities: string[];
+    isParticipant: boolean;
+    /**
+     * Last timeline sequence retained for a former participant. When present,
+     * the channel remains readable through this sequence even though
+     * `isParticipant` is false.
+     */
+    visibleUntilSequence?: number | null;
+};
+
+export declare type GetChannelTimelineOptions = {
+    workspaceId?: string;
+    channelId: string;
+};
+
+export declare type GetChannelTimelineResult = {
+    timeline: {
+        messages: MiniAppChannelMessage[];
+        sequence: number;
+    };
+};
+
+export declare type GetProjectOptions = {
+    workspaceId?: string;
+    projectId: string;
+};
+
+export declare type GetProjectResult = {
+    project: MiniAppProject | null;
+};
+
+export declare type InvokeSavedWorkflowOptions<TPayload = unknown> = {
+    workflowId: string;
+    payload?: TPayload;
+};
+
+export declare type InvokeWorkflowOptions<TPayload = unknown> = {
+    workflowJson: string;
+    payload?: TPayload;
+};
+
+export declare type InvokeWorkflowResult = {
+    success: boolean;
+    status: string;
+    message: string;
+    runId?: string | null;
+    error?: string | null;
+};
+
+export declare type JsonSchema = {
+    readonly [key: string]: unknown;
+};
+
+export declare type ListChannelsOptions = {
+    workspaceId?: string;
+};
+
+export declare type ListChannelsResult = {
+    rooms: MiniAppChannel[];
+    readMode: string;
+};
+
+export declare type ListWorkflowsOptions = {
+    workspaceId?: string;
+};
+
+export declare type ListWorkflowsResult = {
+    workflows: MiniAppWorkflow[];
+};
+
+export declare type MiniAppAuthApi = {
+    getUserProfile(): MiniAppMaybePromise<MiniAppUserProfile | null>;
+};
+
+/**
+ * @capability integrations-and-marketplace
+ */
+export declare type MiniAppChannel = {
+    roomId: string;
+    title?: string;
+    kind?: string;
+    description?: string;
+    visibility: string;
+    archived: boolean;
+    createdAt: number;
+    updatedAt: number;
+};
+
+/**
+ * One bounded JSON timeline row. The row schema is host-versioned, so callers
+ * must narrow it before reading fields.
+ */
+export declare type MiniAppChannelMessage = MiniAppJsonValue;
+
+export declare type MiniAppChatApi = {
+    /**
+     * Select the miniapp's active conversation, reveal the shared chat panel,
+     * and place text in its composer without unmounting the miniapp surface.
+     */
+    sendTextToChat(text: string): MiniAppMaybePromise<void>;
+    joinChannelSpecialist?(channelId: string, specialistId: string): MiniAppMaybePromise<null>;
+    archiveConversation?(workspaceId: string, userId: string, conversationId: string, projectId: string): MiniAppMaybePromise<null>;
+};
+
+export declare type MiniAppCreateSpecialistOptions = {
+    name: string;
+    domain: string;
+    description: string | null;
+    configuration: MiniAppJsonValue;
+};
+
+export declare type MiniAppCreateSpecialistResult = {
+    id: string;
+    name: string;
+    domain: string;
+    description: string | null;
+    isActive: boolean;
+};
+
+/** JSON-compatible values accepted by public miniapp operations. */
+export declare type MiniAppJsonValue = null | boolean | number | string | MiniAppJsonValue[] | {
+    [key: string]: MiniAppJsonValue;
+};
+
+/**
+ * Author-controlled manifest accepted by the host-managed specialist
+ * persistence operation. Ownership, visibility, installation, and verification
+ * metadata are derived by the host and cannot be supplied by a miniapp.
+ */
+export declare type MiniAppManagedSpecialist = {
+    id: string;
+    slug: string;
+    name: string;
+    publisher: string;
+    description: string;
+    icon: string;
+    category?: string;
+    categoryDisplayName?: string;
+    version?: string;
+    schemaVersion?: string;
+    displayName?: string;
+    maintainers?: Array<{
+        name: string;
+        email: string;
+        url?: string;
+    }>;
+    license?: string;
+    lastUpdated?: string;
+    fullDescription?: string;
+    knowledgeSources?: MiniAppJsonValue[];
+    ownedKnowledgePlotId?: string;
+    links?: {
+        terms?: string;
+        privacy?: string;
+        website?: string;
+    };
+    systemPrompt?: string;
+    prompts?: MiniAppJsonValue;
+    skills?: string[];
+    tooling?: MiniAppJsonValue;
+    orchestration?: MiniAppJsonValue;
+    taskModels?: Record<string, string>;
+    knowledgeTargeting?: MiniAppJsonValue;
+    tasks?: MiniAppJsonValue[];
+    identity?: MiniAppJsonValue;
+    audience?: MiniAppJsonValue;
+    constraints?: MiniAppJsonValue;
+    domainContext?: MiniAppJsonValue;
+    purpose?: string;
+    values?: MiniAppJsonValue[];
+    attributes?: string[];
+    techStack?: string[];
+    writingStyle?: MiniAppJsonValue;
+    tags?: string[];
+    preferredModel?: string;
+    supportsLocal?: boolean;
+    requiresNetwork?: boolean;
+    knowledgeGardens?: string[];
+};
+
+export declare type MiniAppManagedSpecialistResult = {
+    specialistId: string;
+};
+
+export declare type MiniAppMaybePromise<T> = T | Promise<T>;
+
+export declare type MiniAppPlatformApi = {
+    channels: {
+        create(options: CreateChannelOptions): CreateChannelResult | Promise<CreateChannelResult>;
+        list(options?: ListChannelsOptions): ListChannelsResult | Promise<ListChannelsResult>;
+        sendMessage(options: SendChannelMessageOptions): SendChannelMessageResult | Promise<SendChannelMessageResult>;
+        /** Persist one deterministic completed row under a joined specialist. */
+        sendSpecialistMessage(options: SendChannelSpecialistMessageOptions): SendChannelSpecialistMessageResult | Promise<SendChannelSpecialistMessageResult>;
+        getAccess(options: GetChannelAccessOptions): GetChannelAccessResult | Promise<GetChannelAccessResult>;
+        getTimeline(options: GetChannelTimelineOptions): GetChannelTimelineResult | Promise<GetChannelTimelineResult>;
+    };
+    projects: {
+        create(options: CreateProjectOptions): CreateProjectResult | Promise<CreateProjectResult>;
+        get(options: GetProjectOptions): GetProjectResult | Promise<GetProjectResult>;
+        update(options: UpdateProjectOptions): UpdateProjectResult | Promise<UpdateProjectResult>;
+    };
+    workflows: {
+        list(options?: ListWorkflowsOptions): ListWorkflowsResult | Promise<ListWorkflowsResult>;
+        invokeSaved<TPayload = unknown>(options: InvokeSavedWorkflowOptions<TPayload>): InvokeWorkflowResult | Promise<InvokeWorkflowResult>;
+        invoke?<TPayload = unknown>(options: InvokeWorkflowOptions<TPayload>): InvokeWorkflowResult | Promise<InvokeWorkflowResult>;
+    };
+    navigation: {
+        open(options: OpenNavigationOptions): void | Promise<void>;
+    };
+    chat: MiniAppChatApi;
+    /** Browser capabilities appear only when the selected target supports them. */
+    auth?: MiniAppAuthApi;
+    vfs?: MiniAppVfsApi;
+    specialist?: MiniAppSpecialistApi;
+    hasEditorView?: boolean;
+    hasHostHttpRequest?: boolean;
+};
+
+export declare type MiniAppProject = {
+    id: string;
+    name: string;
+    workspaceId: string;
+    discoverable: boolean;
+    channelIds: string[];
+    archivedChannelIds: string[];
+};
+
+export declare type MiniAppProvisionProjectChatOptions = {
+    conversationId: string;
+    projectId: string;
+    referenceBranch?: string | null;
+};
+
+export declare type MiniAppProvisionProjectChatResult = {
+    mountedRoots: string[];
+    worktreeBranch?: string | null;
+    worktreeBaseCommit?: string | null;
+};
+
+export declare type MiniAppSpecialistApi = {
+    joinToChannel(channelId: string, specialistId: string): MiniAppMaybePromise<string>;
+    listWorkspace(workspaceId: string): MiniAppMaybePromise<MiniAppSpecialistSummary[]>;
+    create(options: MiniAppCreateSpecialistOptions): MiniAppMaybePromise<MiniAppCreateSpecialistResult>;
+    upsertManaged?(specialist: MiniAppManagedSpecialist): MiniAppMaybePromise<MiniAppManagedSpecialistResult>;
+    runTurnWithTools?(options: MiniAppSpecialistTurnOptions): MiniAppMaybePromise<MiniAppSpecialistTurnResult>;
+};
+
+export declare type MiniAppSpecialistConversationPart = {
+    type: 'text';
+    content: string;
+} | {
+    type: 'tool';
+    toolCallId: string;
+    toolName: string;
+    arguments: MiniAppJsonValue;
+    toolIntent: string | null;
+    success: boolean;
+    content: MiniAppJsonValue;
+    mediaCost?: MiniAppJsonValue | null;
+    error?: string | null;
+    executionTimeMs: number;
+} | {
+    type: 'stepEnd';
+    iteration: number;
+};
+
+export declare type MiniAppSpecialistInteractionMode = 'conversational' | 'agentic' | 'planning' | 'background' | 'longRunning' | 'inlineEdit' | 'focus';
+
+export declare type MiniAppSpecialistSummary = {
+    id: string;
+    slug: string;
+    displayName: string;
+    description: string;
+    tags: string[];
+    version: string;
+    availability: 'public' | 'internal' | 'private' | 'restricted';
+    canRunLocally: boolean;
+    category: string;
+    categoryDisplayName: string;
+    requiredCapabilities: {
+        inputModalities: string[];
+        toolUse?: boolean | null;
+        reasoning?: boolean | null;
+    } | null;
+    omnipresence?: {
+        autoJoinChannels: boolean;
+        includeDms: boolean;
+        pinSidebar: boolean;
+    } | null;
+    displayIcon?: {
+        type: 'bundled';
+        path: string;
+    } | {
+        type: 'remote';
+        url: string;
+    } | null;
+};
+
+export declare type MiniAppSpecialistTurnOptions = {
+    workspaceId: string;
+    channelId: string;
+    specialistId: string;
+    content: string;
+    modelOverride: string;
+    messageId: null;
+    interactionMode: MiniAppSpecialistInteractionMode;
+    timeoutMs: number;
+};
+
+export declare type MiniAppSpecialistTurnResult = {
+    completionEvent: {
+        parts: MiniAppSpecialistConversationPart[];
+        finishReason?: string;
+        modelUsed?: string;
+    };
+};
+
+export declare type MiniAppUserProfile = {
+    sub: string;
+    name?: string | null;
+    givenName?: string | null;
+    familyName?: string | null;
+    middleName?: string | null;
+    nickname?: string | null;
+    preferredUsername?: string | null;
+    profile?: string | null;
+    picture?: string | null;
+    website?: string | null;
+    email?: string | null;
+    emailVerified?: boolean | null;
+    gender?: string | null;
+    birthdate?: string | null;
+    zoneinfo?: string | null;
+    locale?: string | null;
+    phoneNumber?: string | null;
+    phoneNumberVerified?: boolean | null;
+    address?: MiniAppJsonValue | null;
+    updatedAt?: string | null;
+};
+
+export declare type MiniAppVfsApi = {
+    provisionProjectChat(options: MiniAppProvisionProjectChatOptions): MiniAppMaybePromise<MiniAppProvisionProjectChatResult>;
+    writeFile(conversationId: string, path: string, data: Uint8Array): MiniAppMaybePromise<null>;
+    mkdir(conversationId: string, path: string): MiniAppMaybePromise<null>;
+};
+
+export declare type MiniAppWorkflow = {
+    id: string;
+    name: string;
+    type: string;
+    createdAt: number;
+    updatedAt: number;
+};
+
+export declare type OpenNavigationOptions = {
+    path: string;
+};
+
+/**
+ * Public miniapp API installed by the host. Importing this value is safe in
+ * build tools and tests; an unsupported-environment error is raised only when a
+ * property is read before the host installs the API.
+ */
+export declare const sdk: MiniAppPlatformApi;
+
+export declare type SendChannelMessageOptions = {
+    workspaceId?: string;
+    channelId: string;
+    /**
+     * Optional stable client id for product-owned messages such as seeded
+     * lifecycle notices. Omit for ordinary miniapp messages.
+     */
+    clientMessageId?: string;
+    name?: string;
+    /** Display body to persist. When omitted, the host formats `name` and `content`. */
+    body?: string;
+    content: string;
+    /** Optional structured chat content persisted with the message. */
+    messageContent?: Record<string, MiniAppJsonValue>;
+};
+
+export declare type SendChannelMessageResult = {
+    messageId: string;
+    clientMessageId: string;
+};
+
+export declare type SendChannelSpecialistMessageOptions = {
+    workspaceId?: string;
+    channelId: string;
+    projectId: string;
+    specialistId: string;
+    clientMessageId: string;
+    body: string;
+    messageContent?: Record<string, MiniAppJsonValue>;
+};
+
+export declare type SendChannelSpecialistMessageResult = {
+    messageId: string;
+    clientMessageId: string;
+};
+
+export declare type ToolDefinition<TArguments = unknown, TResult = unknown> = {
+    displayName?: string;
+    description: string;
+    parametersSchema: JsonSchema;
+    timeoutMs?: number;
+    actionMessageTemplate?: string;
+    execute(arguments_: TArguments): TResult;
+};
+
+export declare type UIEntrypoint = {
+    type: UIEntrypointType;
+    id: string;
+    name: string;
+    entryPoint: string;
+    icon?: string;
+    persistWhenClosed?: boolean;
+};
+
+/**
+ * @capability integrations-and-marketplace
+ */
+export declare type UIEntrypointType = 'workspace-left-sidebar' | 'workspace-left-sidebar-item' | 'chat-right-sidebar' | 'chat-right-sidebar-item';
+
+export declare type UpdateProjectOptions = {
+    workspaceId?: string;
+    projectId: string;
+    name?: string;
+    discoverable?: boolean;
+    channelIds?: string[];
+    archivedChannelIds?: string[];
+};
+
+export declare type UpdateProjectResult = {
+    project: MiniAppProject;
+};
+
+export { }

package/dist/index.js

@@ -0,0 +1,2 @@
+export { defineApp } from "./config.js";
+export { sdk } from "./sdk.js";

package/dist/rspack/css-entry-loader.cjs

@@ -0,0 +1,27 @@
+/**
+ * @capability integrations-and-marketplace
+ */
+
+const getLoaderOptions = (loaderContext) => {
+  if (typeof loaderContext.getOptions === 'function') {
+    const options = loaderContext.getOptions();
+
+    if (options && Object.keys(options).length > 0) {
+      return options;
+    }
+  }
+
+  if (typeof loaderContext.query !== 'string') {
+    return {};
+  }
+
+  return Object.fromEntries(
+    new URLSearchParams(loaderContext.query.replace(/^\?/, '')),
+  );
+};
+
+module.exports = function tapCssEntryLoader() {
+  const options = getLoaderOptions(this);
+
+  return `import ${JSON.stringify(options.source)};`;
+};

package/dist/rspack/html-loader.cjs

@@ -0,0 +1,150 @@
+/**
+ * @capability integrations-and-marketplace
+ */
+
+const crypto = require('node:crypto');
+const fs = require('node:fs');
+const path = require('node:path');
+
+const SCRIPT_SRC_PATTERN = /<script\b([^>]*?)\bsrc=(["'])([^"']+)\2([^>]*)>/gi;
+const STYLESHEET_HREF_PATTERN =
+  /<link\b(?=[^>]*?\brel=(["'])stylesheet\1)([^>]*?)\bhref=(["'])([^"']+)\3([^>]*)>/gi;
+const SCRIPT_SRC_TOKEN_PREFIX = '__TAP_HTML_SCRIPT:';
+const STYLESHEET_HREF_TOKEN_PREFIX = '__TAP_HTML_STYLESHEET:';
+
+const isUrl = (value) => {
+  try {
+    new URL(value);
+    return true;
+  } catch {
+    return false;
+  }
+};
+
+const stripQuery = (value) => value.split('?')[0];
+
+const isLocalReference = (value) =>
+  !isUrl(value) &&
+  !value.startsWith('//') &&
+  !value.startsWith('#') &&
+  !value.startsWith('data:');
+
+const resolveHtmlAssetPath = (assetSource, sourcePath, manifestDirectory) =>
+  path.resolve(
+    assetSource.startsWith('/') ? manifestDirectory : path.dirname(sourcePath),
+    stripQuery(assetSource).replace(/^\/+/, ''),
+  );
+
+const toPosixPath = (value) => value.split(path.sep).join(path.posix.sep);
+
+const toEntryName = (filePath) =>
+  stripQuery(filePath)
+    .replace(/\.[^.]+$/, '')
+    .replace(/[^a-zA-Z0-9_./-]/g, '_');
+
+const toHtmlScriptEntryName = (filePath) =>
+  `tap-html-${toEntryName(filePath).replace(/[^a-zA-Z0-9_-]/g, '_')}`;
+
+const toHtmlStylesheetEntryName = (filePath) =>
+  `tap-html-css-${toEntryName(filePath).replace(/[^a-zA-Z0-9_-]/g, '_')}`;
+
+const hashContents = (contents) =>
+  crypto.createHash('sha256').update(contents).digest('hex').slice(0, 8);
+
+const realpathIfPossible = (filePath) => {
+  try {
+    return fs.realpathSync.native(filePath);
+  } catch {
+    return filePath;
+  }
+};
+
+const findNearestManifestDirectory = (startPath) => {
+  let currentDirectory = path.dirname(startPath);
+
+  while (currentDirectory !== path.dirname(currentDirectory)) {
+    if (fs.existsSync(path.join(currentDirectory, 'manifest.tap.json'))) {
+      return currentDirectory;
+    }
+
+    currentDirectory = path.dirname(currentDirectory);
+  }
+
+  return undefined;
+};
+
+const getLoaderOptions = (loaderContext) => {
+  if (typeof loaderContext.getOptions === 'function') {
+    const options = loaderContext.getOptions();
+
+    if (options && Object.keys(options).length > 0) {
+      return options;
+    }
+  }
+
+  if (typeof loaderContext.query !== 'string') {
+    return {};
+  }
+
+  return Object.fromEntries(
+    new URLSearchParams(loaderContext.query.replace(/^\?/, '')),
+  );
+};
+
+module.exports = function tapHtmlLoader(source) {
+  const callback = this.async();
+  const options = getLoaderOptions(this);
+  const sourcePath = realpathIfPossible(this.resourcePath);
+  const manifestDirectory = realpathIfPossible(
+    options.manifestDirectory ??
+      findNearestManifestDirectory(sourcePath) ??
+      this.rootContext,
+  );
+
+  const rewrittenScripts = source.replace(
+    SCRIPT_SRC_PATTERN,
+    (tag, beforeSrc, quote, scriptSource, afterSrc) => {
+      if (!isLocalReference(scriptSource)) {
+        return tag;
+      }
+
+      const scriptPath = resolveHtmlAssetPath(
+        scriptSource,
+        sourcePath,
+        manifestDirectory,
+      );
+      const relativeScript = toPosixPath(
+        path.relative(manifestDirectory, scriptPath),
+      );
+      const output = `${SCRIPT_SRC_TOKEN_PREFIX}${toHtmlScriptEntryName(relativeScript)}__`;
+
+      return `<script${beforeSrc}src=${quote}${output}${quote}${afterSrc}>`;
+    },
+  );
+  const rewrittenHtml = rewrittenScripts.replace(
+    STYLESHEET_HREF_PATTERN,
+    (tag, _relQuote, beforeHref, hrefQuote, stylesheetSource, afterHref) => {
+      if (!isLocalReference(stylesheetSource)) {
+        return tag;
+      }
+
+      const stylesheetPath = resolveHtmlAssetPath(
+        stylesheetSource,
+        sourcePath,
+        manifestDirectory,
+      );
+      const relativeStylesheet = toPosixPath(
+        path.relative(manifestDirectory, stylesheetPath),
+      );
+      const output = `${STYLESHEET_HREF_TOKEN_PREFIX}${toHtmlStylesheetEntryName(relativeStylesheet)}__`;
+
+      return `<link${beforeHref}href=${hrefQuote}${output}${hrefQuote}${afterHref}>`;
+    },
+  );
+
+  const parsedPath = path.parse(sourcePath);
+  const outputPath = `${parsedPath.name}.${hashContents(rewrittenHtml)}${parsedPath.ext}`;
+
+  this.emitFile(outputPath, rewrittenHtml);
+  callback(null, `export default ${JSON.stringify(outputPath)};`);
+};