@cardstack/boxel-cli 0.2.0 → 0.3.0-unstable.13

package/bundled-types/host-app/commands/populate-with-sample-data.ts

@@ -0,0 +1,84 @@
+import { service } from '@ember/service';
+
+import {
+  ensureExtension,
+  identifyCard,
+  moduleFrom,
+} from '@cardstack/runtime-common';
+
+import { isBaseInstance, realmURL } from '@cardstack/runtime-common/constants';
+
+import type { CardDef, FieldDef } from 'https://cardstack.com/base/card-api';
+import type * as BaseCommandModule from 'https://cardstack.com/base/command';
+
+import HostBaseCommand from '../lib/host-base-command';
+
+import SendAiAssistantMessageCommand from './send-ai-assistant-message';
+
+import type AiAssistantPanelService from '../services/ai-assistant-panel-service';
+import type CommandService from '../services/command-service';
+import type MatrixService from '../services/matrix-service';
+import type StoreService from '../services/store';
+
+export default class PopulateWithSampleDataCommand extends HostBaseCommand<
+  typeof BaseCommandModule.CardIdCard,
+  undefined
+> {
+  @service declare private aiAssistantPanelService: AiAssistantPanelService;
+  @service declare private commandService: CommandService;
+  @service declare private matrixService: MatrixService;
+  @service declare private store: StoreService;
+
+  static actionVerb = 'Populate Sample Data';
+  description = 'Fill in the card with sample data';
+
+  async getInputType() {
+    let commandModule = await this.loadCommandModule();
+    const { CardIdCard } = commandModule;
+    return CardIdCard;
+  }
+
+  protected get prompt() {
+    return `Fill in sample data for the attached card instance.`;
+  }
+
+  protected getAttachedFileURLs(card: CardDef) {
+    const codeRef = identifyCard(card.constructor);
+    let cardModuleURL = codeRef
+      ? ensureExtension(moduleFrom(codeRef), { default: '.gts' })
+      : undefined;
+    return cardModuleURL ? [cardModuleURL] : [];
+  }
+
+  protected async run(input: BaseCommandModule.CardIdCard): Promise<undefined> {
+    if (!input.cardId) {
+      throw new Error('Card is required');
+    }
+
+    await this.aiAssistantPanelService.openPanel();
+    let card = await this.store.get<CardDef>(input.cardId);
+    if (!isCard(card)) {
+      throw new Error(`Could not load card: ${card.message}`);
+    }
+
+    let sendMessageCommand = new SendAiAssistantMessageCommand(
+      this.commandContext,
+    );
+
+    await sendMessageCommand.execute({
+      roomId: this.matrixService.currentRoomId,
+      prompt: this.prompt,
+      attachedCards: [card],
+      attachedFileIdentifiers: this.getAttachedFileURLs(card),
+      realmIdentifier: card[realmURL]?.href,
+    });
+  }
+}
+
+function isCardOrField(card: any): card is CardDef | FieldDef {
+  return card && typeof card === 'object' && isBaseInstance in card;
+}
+
+function isCard(card: any): card is CardDef {
+  return isCardOrField(card) && !('isFieldDef' in card.constructor);
+}

package/bundled-types/host-app/commands/preview-format.ts

@@ -0,0 +1,52 @@
+import { service } from '@ember/service';
+
+import type * as BaseCommandModule from 'https://cardstack.com/base/command';
+
+import HostBaseCommand from '../lib/host-base-command';
+
+import ShowCardCommand from './show-card';
+import SwitchSubmodeCommand from './switch-submode';
+
+import type OperatorModeStateService from '../services/operator-mode-state-service';
+
+export default class PreviewFormatCommand extends HostBaseCommand<
+  typeof BaseCommandModule.PreviewFormatInput
+> {
+  @service declare private operatorModeStateService: OperatorModeStateService;
+
+  description =
+    'Open code mode, navigate to a module, set preview panel to isolated view, and show a card in the specified format.';
+
+  static actionVerb = 'Preview Format';
+
+  async getInputType() {
+    let commandModule = await this.loadCommandModule();
+    const { PreviewFormatInput } = commandModule;
+    return PreviewFormatInput;
+  }
+
+  requireInputFields = ['cardId', 'format', 'modulePath'];
+
+  protected async run(
+    input: BaseCommandModule.PreviewFormatInput,
+  ): Promise<undefined> {
+    // 1. Switch to code submode
+    await new SwitchSubmodeCommand(this.commandContext).execute({
+      submode: 'code',
+      codePath: input.modulePath,
+    });
+
+    // 2. Set module inspector to preview
+    this.operatorModeStateService.persistModuleInspectorView(
+      input.modulePath,
+      'preview',
+    );
+
+    // 3. Show the card in the specified format using ShowCardCommand
+    let showCardCommand = new ShowCardCommand(this.commandContext);
+    await showCardCommand.execute({
+      cardId: input.cardId,
+      format: input.format,
+    });
+  }
+}

package/bundled-types/host-app/commands/read-binary-file.ts

@@ -0,0 +1,62 @@
+import { service } from '@ember/service';
+
+import type * as BaseCommandModule from 'https://cardstack.com/base/command';
+
+import HostBaseCommand from '../lib/host-base-command';
+
+import type NetworkService from '../services/network';
+
+function uint8ArrayToBase64(bytes: Uint8Array): string {
+  const maybeBuffer = (globalThis as any).Buffer as
+    | { from(input: Uint8Array): { toString(encoding: string): string } }
+    | undefined;
+
+  if (typeof maybeBuffer !== 'undefined') {
+    return maybeBuffer.from(bytes).toString('base64');
+  }
+
+  let binary = '';
+  for (let i = 0; i < bytes.byteLength; i++) {
+    binary += String.fromCharCode(bytes[i]);
+  }
+  return btoa(binary);
+}
+
+export default class ReadBinaryFileCommand extends HostBaseCommand<
+  typeof BaseCommandModule.ReadBinaryFileInput,
+  typeof BaseCommandModule.ReadBinaryFileResult
+> {
+  @service declare private network: NetworkService;
+
+  description =
+    'Read a binary file from a URL and return its content as base64';
+  static actionVerb = 'Read';
+
+  async getInputType() {
+    let commandModule = await this.loadCommandModule();
+    const { ReadBinaryFileInput } = commandModule;
+    return ReadBinaryFileInput;
+  }
+
+  requireInputFields = ['fileIdentifier'];
+
+  protected async run(
+    input: BaseCommandModule.ReadBinaryFileInput,
+  ): Promise<BaseCommandModule.ReadBinaryFileResult> {
+    let response = await this.network.authedFetch(input.fileIdentifier);
+    let { ReadBinaryFileResult } = await this.loadCommandModule();
+
+    if (!response.ok) {
+      throw new Error(
+        `Error reading binary file ${input.fileIdentifier}: ${response.statusText}`,
+      );
+    }
+
+    let arrayBuffer = await response.arrayBuffer();
+    let bytes = new Uint8Array(arrayBuffer);
+    let base64Content = uint8ArrayToBase64(bytes);
+    let contentType = response.headers.get('content-type') ?? '';
+
+    return new ReadBinaryFileResult({ base64Content, contentType });
+  }
+}

package/bundled-types/host-app/commands/read-card-for-ai-assistant.ts

@@ -0,0 +1,50 @@
+import { service } from '@ember/service';
+
+import { isCardInstance } from '@cardstack/runtime-common';
+
+import type { CardDef } from 'https://cardstack.com/base/card-api';
+import type * as BaseCommandModule from 'https://cardstack.com/base/command';
+import type { FileDef } from 'https://cardstack.com/base/file-api';
+
+import HostBaseCommand from '../lib/host-base-command';
+
+import type MatrixService from '../services/matrix-service';
+import type StoreService from '../services/store';
+
+export default class ReadCardForAssistantCommand extends HostBaseCommand<
+  typeof BaseCommandModule.CardIdCard,
+  typeof BaseCommandModule.CardForAttachmentCard
+> {
+  @service declare private matrixService: MatrixService;
+  @service declare private store: StoreService;
+
+  static actionVerb = 'Send';
+
+  async getInputType() {
+    let commandModule = await this.loadCommandModule();
+    const { CardIdCard } = commandModule;
+    return CardIdCard;
+  }
+
+  requireInputFields = ['cardId'];
+
+  protected async run(
+    input: BaseCommandModule.CardIdCard,
+  ): Promise<BaseCommandModule.CardForAttachmentCard> {
+    let { matrixService } = this;
+
+    await matrixService.ready;
+    let maybeCard = await this.store.get<CardDef>(input.cardId);
+    if (isCardInstance(maybeCard)) {
+      let cardFileDef = (
+        await matrixService.uploadCards([maybeCard])
+      )[0] as FileDef;
+      let commandModule = await this.loadCommandModule();
+      const { CardForAttachmentCard } = commandModule;
+      return new CardForAttachmentCard({ cardForAttachment: cardFileDef });
+    } else {
+      console.error(`Failed to read card for AI assistant: ${maybeCard}`);
+      throw new Error(maybeCard.message);
+    }
+  }
+}

package/bundled-types/host-app/commands/read-file-for-ai-assistant.ts

@@ -0,0 +1,46 @@
+import { service } from '@ember/service';
+
+import type * as BaseCommandModule from 'https://cardstack.com/base/command';
+import type { FileDef } from 'https://cardstack.com/base/file-api';
+
+import HostBaseCommand from '../lib/host-base-command';
+
+import type MatrixService from '../services/matrix-service';
+
+export default class ReadFileForAssistantCommand extends HostBaseCommand<
+  typeof BaseCommandModule.FileIdentifierCard,
+  typeof BaseCommandModule.FileForAttachmentCard
+> {
+  @service declare private matrixService: MatrixService;
+
+  static actionVerb = 'Send';
+
+  async getInputType() {
+    let commandModule = await this.loadCommandModule();
+    const { FileIdentifierCard } = commandModule;
+    return FileIdentifierCard;
+  }
+
+  requireInputFields = ['fileIdentifier'];
+
+  protected async run(
+    input: BaseCommandModule.FileIdentifierCard,
+  ): Promise<BaseCommandModule.FileForAttachmentCard> {
+    let { matrixService } = this;
+
+    let fileUrl = input.fileIdentifier;
+
+    await matrixService.ready;
+    let file: FileDef | undefined = matrixService.fileAPI.createFileDef({
+      sourceUrl: fileUrl,
+      name: fileUrl.split('/').pop(),
+      contentType: 'text/plain',
+    });
+    if (file) {
+      file = (await matrixService.uploadFiles([file]))[0] as FileDef;
+    }
+    let commandModule = await this.loadCommandModule();
+    const { FileForAttachmentCard } = commandModule;
+    return new FileForAttachmentCard({ fileForAttachment: file });
+  }
+}

package/bundled-types/host-app/commands/read-source.ts

@@ -0,0 +1,46 @@
+import { service } from '@ember/service';
+
+import { SupportedMimeType } from '@cardstack/runtime-common';
+
+import type * as BaseCommandModule from 'https://cardstack.com/base/command';
+
+import HostBaseCommand from '../lib/host-base-command';
+
+import type NetworkService from '../services/network';
+
+export default class ReadSourceCommand extends HostBaseCommand<
+  typeof BaseCommandModule.ReadSourceInput,
+  typeof BaseCommandModule.FileContents
+> {
+  @service declare private network: NetworkService;
+
+  description = `Read a card source file from a realm.`;
+  static actionVerb = 'Read';
+
+  async getInputType() {
+    let commandModule = await this.loadCommandModule();
+    const { ReadSourceInput } = commandModule;
+    return ReadSourceInput;
+  }
+
+  requireInputFields = ['path'];
+
+  protected async run(
+    input: BaseCommandModule.ReadSourceInput,
+  ): Promise<BaseCommandModule.FileContents> {
+    let url = input.realm
+      ? new URL(input.path, input.realm)
+      : new URL(input.path);
+    let response = await this.network.authedFetch(url, {
+      headers: { Accept: SupportedMimeType.CardSource },
+    });
+
+    let { FileContents } = await this.loadCommandModule();
+    if (response.ok) {
+      return new FileContents({
+        content: await response.text(),
+      });
+    }
+    throw new Error(`Error reading file ${url}: ${response.statusText}`);
+  }
+}

package/bundled-types/host-app/commands/read-text-file.ts

@@ -0,0 +1,44 @@
+import { service } from '@ember/service';
+
+import type * as BaseCommandModule from 'https://cardstack.com/base/command';
+
+import HostBaseCommand from '../lib/host-base-command';
+
+import type NetworkService from '../services/network';
+
+export default class ReadTextFileCommand extends HostBaseCommand<
+  typeof BaseCommandModule.ReadTextFileInput,
+  typeof BaseCommandModule.FileContents
+> {
+  @service declare private network: NetworkService;
+
+  description = `Read a text file from a realm, such as a module or a card.`;
+  static actionVerb = 'Read';
+
+  async getInputType() {
+    let commandModule = await this.loadCommandModule();
+    const { ReadTextFileInput } = commandModule;
+    return ReadTextFileInput;
+  }
+
+  requireInputFields = ['path'];
+
+  protected async run(
+    input: BaseCommandModule.ReadTextFileInput,
+  ): Promise<BaseCommandModule.FileContents> {
+    let url = input.realm
+      ? new URL(input.path, input.realm)
+      : new URL(input.path);
+    let response = await this.network.authedFetch(url, {
+      headers: { Accept: 'text/plain' },
+    });
+
+    let { FileContents } = await this.loadCommandModule();
+    if (response.ok) {
+      return new FileContents({
+        content: await response.text(),
+      });
+    }
+    throw new Error(`Error reading file ${url}: ${response.statusText}`);
+  }
+}

package/bundled-types/host-app/commands/register-bot.ts

@@ -0,0 +1,42 @@
+import { service } from '@ember/service';
+
+import type * as BaseCommandModule from 'https://cardstack.com/base/command';
+
+import HostBaseCommand from '../lib/host-base-command';
+
+import type RealmServerService from '../services/realm-server';
+
+type RegisterBotResult = {
+  botRegistrationId: string;
+};
+
+export default class RegisterBotCommand extends HostBaseCommand<
+  typeof BaseCommandModule.RegisterBotInput,
+  typeof BaseCommandModule.RegisterBotResult
+> {
+  @service declare private realmServer: RealmServerService;
+
+  static actionVerb = 'Register';
+  description = 'Register bot';
+
+  async getInputType() {
+    let commandModule = await this.loadCommandModule();
+    const { RegisterBotInput } = commandModule;
+    return RegisterBotInput;
+  }
+
+  protected async run(
+    input: BaseCommandModule.RegisterBotInput,
+  ): Promise<BaseCommandModule.RegisterBotResult> {
+    const commandModule = await this.loadCommandModule();
+    const { RegisterBotResult } = commandModule;
+
+    let registration = (await this.realmServer.registerBot(
+      input.username,
+    )) as RegisterBotResult;
+
+    return new RegisterBotResult({
+      botRegistrationId: registration.botRegistrationId,
+    });
+  }
+}

package/bundled-types/host-app/commands/reindex-realm.ts

@@ -0,0 +1,30 @@
+import { service } from '@ember/service';
+
+import type * as BaseCommandModule from 'https://cardstack.com/base/command';
+
+import HostBaseCommand from '../lib/host-base-command';
+
+import type RealmService from '../services/realm';
+
+export default class ReindexRealmCommand extends HostBaseCommand<
+  typeof BaseCommandModule.RealmIdentifierCard,
+  undefined
+> {
+  @service declare private realm: RealmService;
+
+  static actionVerb = 'Reindex';
+  description =
+    'Reindex a realm using the lighter/default mode. This republishes a from-scratch indexing job but only revisits files whose indexed state appears stale based on current mtime, deletion, or error semantics. Use this when a user wants to pick up normal recent changes or refresh a realm without performing a full reindex.';
+
+  async getInputType() {
+    let commandModule = await this.loadCommandModule();
+    const { RealmIdentifierCard } = commandModule;
+    return RealmIdentifierCard;
+  }
+
+  protected async run(
+    input: BaseCommandModule.RealmIdentifierCard,
+  ): Promise<undefined> {
+    await this.realm.reindex(input.realmIdentifier);
+  }
+}

package/bundled-types/host-app/commands/retry-submission-workflow.ts

@@ -0,0 +1,119 @@
+import { service } from '@ember/service';
+
+import { isCardInstance, rri } from '@cardstack/runtime-common';
+
+import type * as BaseCommandModule from 'https://cardstack.com/base/command';
+
+import HostBaseCommand from '../lib/host-base-command';
+
+import SendBotTriggerEventCommand from './bot-requests/send-bot-trigger-event';
+
+import type RealmService from '../services/realm';
+import type StoreService from '../services/store';
+
+// Local view: host's tsconfig maps @cardstack/catalog/* to the legacy
+// in-monorepo catalog-realm, which lacks `failedStep`. Drop this once
+// that path points at boxel-catalog (the canonical source).
+interface WorkflowCardView {
+  roomId?: string;
+  listing?: { id?: string };
+  failedStep?: string | null;
+}
+
+// Re-emits the `pr-listing-retry` bot trigger event for an existing
+// SubmissionWorkflowCard that ended in a failed state. Reads roomId + listing
+// off the card so the same Matrix room is reused (preserving the prior
+// conversation and the bot-runner's view of the workflow).
+export default class RetrySubmissionWorkflowCommand extends HostBaseCommand<
+  typeof BaseCommandModule.RetrySubmissionWorkflowInput
+> {
+  @service declare private store: StoreService;
+  @service declare private realm: RealmService;
+
+  description =
+    'Retry a failed submission workflow by re-emitting the bot trigger event into the original room.';
+
+  async getInputType() {
+    let commandModule = await this.loadCommandModule();
+    const { RetrySubmissionWorkflowInput } = commandModule;
+    return RetrySubmissionWorkflowInput;
+  }
+
+  requireInputFields = ['workflowCardId'];
+
+  protected async run(
+    input: BaseCommandModule.RetrySubmissionWorkflowInput,
+  ): Promise<undefined> {
+    let { workflowCardId } = input;
+
+    let result = await this.store.get(workflowCardId);
+    if (!result || !isCardInstance(result)) {
+      throw new Error(
+        `Cannot retry: workflow card ${workflowCardId} not found`,
+      );
+    }
+    let workflowCard = result as unknown as WorkflowCardView;
+
+    let roomId = workflowCard.roomId;
+    let listingId = workflowCard.listing?.id;
+    if (!roomId) {
+      throw new Error(
+        'Cannot retry: workflow card has no roomId — only newer submissions support retry',
+      );
+    }
+    if (!listingId) {
+      throw new Error('Cannot retry: workflow card has no linked listing');
+    }
+
+    let listingRealm = this.realm.realmOf(rri(listingId));
+    if (!listingRealm) {
+      throw new Error(
+        `Cannot retry: cannot determine realm for listing ${listingId}`,
+      );
+    }
+
+    // Snapshot the prior failedStep so we can restore it if the send fails
+    // — without it, the optimistic clear below would hide the Retry button
+    // (canRetry requires prCreationError || failedStep) and strand the user.
+    let priorFailedStep = workflowCard.failedStep ?? null;
+
+    // Optimistic clear for instant UI feedback. Re-set on send failure.
+    await this.store.patch(
+      workflowCardId,
+      {
+        attributes: {
+          prCreationError: null,
+          failedStep: null,
+        },
+      },
+      { doNotWaitForPersist: true },
+    );
+
+    try {
+      await new SendBotTriggerEventCommand(this.commandContext).execute({
+        roomId,
+        realm: listingRealm,
+        type: 'pr-listing-retry',
+        input: {
+          workflowCardUrl: workflowCardId,
+          workflowCardRealm:
+            this.realm.realmOf(rri(workflowCardId)) ?? undefined,
+        },
+      });
+    } catch (sendError: any) {
+      let message =
+        sendError instanceof Error ? sendError.message : String(sendError);
+      await this.store.patch(
+        workflowCardId,
+        {
+          attributes: {
+            prCreationError: `Failed to send retry: ${message}`,
+            failedStep: priorFailedStep,
+          },
+        },
+        { doNotWaitForPersist: true },
+      );
+      throw sendError;
+    }
+  }
+}

package/bundled-types/host-app/commands/sanitize-module-list.ts

@@ -0,0 +1,83 @@
+import {
+  isScopedCSSRequest,
+  rri,
+  trimExecutableExtension,
+} from '@cardstack/runtime-common';
+
+import type * as BaseCommandModule from 'https://cardstack.com/base/command';
+
+import HostBaseCommand from '../lib/host-base-command';
+
+import CanReadRealmCommand from './can-read-realm';
+import GetRealmOfResourceIdentifierCommand from './get-realm-of-resource-identifier';
+
+const GLOBAL_URL_STEMS = [
+  'https://cardstack.com',
+  'https://packages',
+  'https://boxel-icons.boxel.ai',
+];
+
+export default class SanitizeModuleListCommand extends HostBaseCommand<
+  typeof BaseCommandModule.SanitizeModuleListInput,
+  typeof BaseCommandModule.SanitizeModuleListResult
+> {
+  description =
+    'Filter and deduplicate a list of module URLs, removing globals and unreadable realms';
+
+  async getInputType() {
+    let commandModule = await this.loadCommandModule();
+    const { SanitizeModuleListInput } = commandModule;
+    return SanitizeModuleListInput;
+  }
+
+  requireInputFields = ['moduleIdentifiers'];
+
+  protected async run(
+    input: BaseCommandModule.SanitizeModuleListInput,
+  ): Promise<BaseCommandModule.SanitizeModuleListResult> {
+    // Normalize to extensionless URLs before deduplication so that e.g.
+    // "https://…/foo.gts" and "https://…/foo" don't produce separate entries.
+    const seen = new Map<string, string>(); // normalized → original
+    for (const m of input.moduleIdentifiers) {
+      const normalized = trimExecutableExtension(rri(m));
+      if (!seen.has(normalized)) {
+        seen.set(normalized, m);
+      }
+    }
+    let uniqueModules = Array.from(seen.values());
+
+    const results = await Promise.all(
+      uniqueModules.map(async (dep) => {
+        // Exclude scoped CSS requests
+        if (isScopedCSSRequest(dep)) {
+          return null;
+        }
+        // Exclude known global/package/icon sources
+        if (GLOBAL_URL_STEMS.some((urlStem) => dep.startsWith(urlStem))) {
+          return null;
+        }
+
+        // Only allow modules that belong to a realm we can read
+        const { realmIdentifier } =
+          await new GetRealmOfResourceIdentifierCommand(
+            this.commandContext,
+          ).execute({ resourceIdentifier: dep });
+        if (!realmIdentifier) {
+          return null;
+        }
+        const { canRead } = await new CanReadRealmCommand(
+          this.commandContext,
+        ).execute({ realmIdentifier });
+        return canRead ? dep : null;
+      }),
+    );
+
+    const moduleIdentifiers = results.filter(
+      (dep): dep is string => dep !== null,
+    );
+
+    let commandModule = await this.loadCommandModule();
+    const { SanitizeModuleListResult } = commandModule;
+    return new SanitizeModuleListResult({ moduleIdentifiers });
+  }
+}