assistant-ui 0.0.123 → 0.0.125

package/src/codemods/v0-9/edge-package-split.ts

@@ -1,11 +1,8 @@
 import { createTransformer } from "../utils/createTransformer";
 
-// Chat runtime and converter exports moved to react-ai-sdk
 const reactAiSdkExports: string[] = [
-  // Chat Runtime (replaces edge runtime)
   "useChatRuntime",
 
-  // Core Types
   "CoreMessage",
   "CoreUserMessage",
   "CoreAssistantMessage",
@@ -14,13 +11,11 @@ const reactAiSdkExports: string[] = [
   "CoreAssistantMessagePart",
   "CoreToolCallMessagePart",
 
-  // Core message converters
   "fromCoreMessages",
   "fromCoreMessage",
   "toCoreMessages",
   "toCoreMessage",
 
-  // Language model converters
   "toLanguageModelMessages",
   "toLanguageModelTools",
   "fromLanguageModelMessages",
@@ -29,150 +24,46 @@ const reactAiSdkExports: string[] = [
 ];
 
 const migrateToEdgePackage = createTransformer(({ j, root, markAsChanged }) => {
-  const sourcesToMigrate: string[] = ["@assistant-ui/react"];
-  const movedAiSdkSpecifiers: any[] = [];
-  let lastMigratedImportPath: any = null;
-
-  root
-    .find(j.ImportDeclaration)
-    .filter((path: any) => sourcesToMigrate.includes(path.value.source.value))
-    .forEach((path: any) => {
-      let hadMigratedSpecifiers = false;
-      const remainingSpecifiers: any[] = [];
-      path.value.specifiers.forEach((specifier: any) => {
-        if (
-          j.ImportSpecifier.check(specifier) &&
-          reactAiSdkExports.includes(specifier.imported.name as string)
-        ) {
-          movedAiSdkSpecifiers.push(specifier);
-          hadMigratedSpecifiers = true;
-        } else {
-          remainingSpecifiers.push(specifier);
-        }
-      });
-      if (hadMigratedSpecifiers) {
-        lastMigratedImportPath = path;
-      }
-      if (remainingSpecifiers.length === 0) {
-        j(path).remove();
-        markAsChanged();
-      } else if (remainingSpecifiers.length !== path.value.specifiers.length) {
-        path.value.specifiers = remainingSpecifiers;
-        markAsChanged();
-      }
-    });
-
-  // Add imports for react-ai-sdk (all edge-related imports now go here)
-  if (movedAiSdkSpecifiers.length > 0) {
-    const existingAiSdkImport = root.find(j.ImportDeclaration, {
-      source: { value: "@assistant-ui/react-ai-sdk" },
-    });
-    if (existingAiSdkImport.size() > 0) {
-      existingAiSdkImport.forEach((path: any) => {
-        movedAiSdkSpecifiers.forEach((specifier: any) => {
-          if (
-            !path.value.specifiers.some(
-              (s: any) => s.imported.name === specifier.imported.name,
-            )
-          ) {
-            path.value.specifiers.push(specifier);
-          }
-        });
-      });
-    } else {
-      const newImport = j.importDeclaration(
-        movedAiSdkSpecifiers,
-        j.literal("@assistant-ui/react-ai-sdk"),
-      );
-      if (lastMigratedImportPath) {
-        j(lastMigratedImportPath).insertAfter(newImport);
-      } else {
-        const firstImport = root.find(j.ImportDeclaration).at(0);
-        if (firstImport.size() > 0) {
-          firstImport.insertBefore(newImport);
-        } else {
-          root.get().node.program.body.unshift(newImport);
-        }
-      }
-    }
-    markAsChanged();
-  }
-
-  // Migrate imports from edge/converters
-  root.find(j.ImportDeclaration).forEach((path: any) => {
-    const sourceValue: string = path.value.source.value;
+  root.find(j.ImportDeclaration).forEach((path) => {
+    const source = path.node.source.value;
     if (
-      sourceValue.startsWith("@assistant-ui/react/") &&
-      (sourceValue.includes("edge/") ||
-        sourceValue.includes("dangerous-in-browser/"))
+      typeof source === "string" &&
+      source.startsWith("@assistant-ui/react/") &&
+      (source.includes("edge/") || source.includes("dangerous-in-browser/"))
     ) {
-      path.value.source = j.literal(
-        sourceValue.replace(
-          "@assistant-ui/react/",
-          "@assistant-ui/react-ai-sdk/",
-        ),
+      path.node.source = j.literal(
+        source.replace("@assistant-ui/react/", "@assistant-ui/react-ai-sdk/"),
       );
       markAsChanged();
+      return;
     }
-  });
 
-  // Migrate language model converter imports from react-edge to react-ai-sdk
-  root.find(j.ImportDeclaration).forEach((path: any) => {
-    const sourceValue: string = path.value.source.value;
     if (
-      sourceValue === "@assistant-ui/react-edge" ||
-      sourceValue === "@assistant-ui/react"
-    ) {
-      let hasLanguageModelConverters = false;
-      const remainingSpecifiers: any[] = [];
-      const aiSdkSpecifiers: any[] = [];
-
-      path.value.specifiers.forEach((specifier: any) => {
-        if (
-          j.ImportSpecifier.check(specifier) &&
-          reactAiSdkExports.includes(specifier.imported.name as string)
-        ) {
-          aiSdkSpecifiers.push(specifier);
-          hasLanguageModelConverters = true;
-        } else {
-          remainingSpecifiers.push(specifier);
-        }
-      });
-
-      if (hasLanguageModelConverters) {
-        if (remainingSpecifiers.length === 0) {
-          j(path).remove();
-        } else {
-          path.value.specifiers = remainingSpecifiers;
-        }
-
-        const existingAiSdkImport = root.find(j.ImportDeclaration, {
-          source: { value: "@assistant-ui/react-ai-sdk" },
-        });
+      source !== "@assistant-ui/react" &&
+      source !== "@assistant-ui/react-edge"
+    )
+      return;
 
-        if (existingAiSdkImport.size() > 0) {
-          existingAiSdkImport.forEach((importPath: any) => {
-            aiSdkSpecifiers.forEach((specifier: any) => {
-              if (
-                !importPath.value.specifiers.some(
-                  (s: any) => s.imported.name === specifier.imported.name,
-                )
-              ) {
-                importPath.value.specifiers.push(specifier);
-              }
-            });
-          });
-        } else {
-          const newImport = j.importDeclaration(
-            aiSdkSpecifiers,
-            j.literal("@assistant-ui/react-ai-sdk"),
-          );
-          j(path).insertAfter(newImport);
-        }
+    const specifiers = path.node.specifiers ?? [];
+    const moved = specifiers.filter(
+      (specifier) =>
+        j.ImportSpecifier.check(specifier) &&
+        reactAiSdkExports.includes(specifier.imported.name as string),
+    );
+    if (moved.length === 0) return;
 
-        markAsChanged();
-      }
+    const destination = j.literal("@assistant-ui/react-ai-sdk");
+    if (moved.length === specifiers.length) {
+      path.node.source = destination;
+    } else {
+      path.node.specifiers = specifiers.filter(
+        (specifier) => !moved.includes(specifier),
+      );
+      const declaration = j.importDeclaration(moved, destination);
+      declaration.importKind = path.node.importKind ?? "value";
+      j(path).insertAfter(declaration);
     }
+    markAsChanged();
   });
 });
 

package/src/commands/cloud.test.ts

@@ -9,6 +9,9 @@ const {
   fetchProjects,
   createProject,
   cloudAccessToken,
+  savedCloudAccessToken,
+  runCloudCommand,
+  loginToCloud,
   provisionCloudHarness,
   scaffold,
   select,
@@ -18,6 +21,9 @@ const {
   fetchProjects: vi.fn(),
   createProject: vi.fn(),
   cloudAccessToken: vi.fn(),
+  savedCloudAccessToken: vi.fn(),
+  runCloudCommand: vi.fn(),
+  loginToCloud: vi.fn(),
   provisionCloudHarness: vi.fn(),
   scaffold: vi.fn(),
   select: vi.fn(),
@@ -33,6 +39,12 @@ vi.mock("aui-auth/accounts", async (importOriginal) => ({
 vi.mock("../lib/cloud-auth", async (importOriginal) => ({
   ...(await importOriginal<typeof import("../lib/cloud-auth")>()),
   cloudAccessToken,
+  savedCloudAccessToken,
+  loginToCloud,
+}));
+vi.mock("../lib/cloud-remote", async (importOriginal) => ({
+  ...(await importOriginal<typeof import("../lib/cloud-remote")>()),
+  runCloudCommand,
 }));
 vi.mock("../lib/cloud-provision", async (importOriginal) => ({
   ...(await importOriginal<typeof import("../lib/cloud-provision")>()),
@@ -236,3 +248,49 @@ describe("cloud setup", () => {
     ]);
   });
 });
+
+describe("cloud remote forwarding", () => {
+  const forwarded = async (argv: string[]) => {
+    runCloudCommand.mockClear();
+    runCloudCommand.mockResolvedValue(4);
+    await cloud.parseAsync(argv, { from: "user" });
+    return runCloudCommand.mock.calls.map(([args]) => args);
+  };
+
+  it("forwards help, unknown subcommands and their flags verbatim", async () => {
+    for (const argv of [
+      [],
+      ["help"],
+      ["--help"],
+      ["-h"],
+      ["help", "projects"],
+      ["projects", "list", "--org", "acme", "--json"],
+      ["whoami", "--version"],
+      ["--org=acme", "projects"],
+    ]) {
+      await expect(forwarded(argv)).resolves.toEqual([argv]);
+    }
+    expect(process.exitCode).toBe(4);
+    process.exitCode = undefined;
+  });
+
+  it("keeps login local", async () => {
+    loginToCloud.mockResolvedValue(undefined);
+    await expect(forwarded(["login", "--no-open"])).resolves.toEqual([]);
+    expect(loginToCloud).toHaveBeenCalledWith(
+      expect.anything(),
+      expect.objectContaining({ noOpen: true }),
+    );
+  });
+
+  it("sends the saved login without starting a new one", async () => {
+    savedCloudAccessToken.mockResolvedValue(null);
+    runCloudCommand.mockImplementationOnce(async (_args, options) => {
+      await expect(options.accessToken()).resolves.toBeNull();
+      return 0;
+    });
+    await cloud.parseAsync(["whoami"], { from: "user" });
+    expect(savedCloudAccessToken).toHaveBeenCalled();
+    expect(cloudAccessToken).not.toHaveBeenCalled();
+  });
+});

package/src/commands/cloud.ts

@@ -15,8 +15,10 @@ import {
   cloudAuthConfig,
   loginToCloud,
   logoutFromCloud,
+  savedCloudAccessToken,
   validateCloudUrl,
 } from "../lib/cloud-auth";
+import { runCloudCommand } from "../lib/cloud-remote";
 import {
   readCloudProjectConfig,
   mergeCloudEnvironment,
@@ -370,9 +372,24 @@ export const setupCloud = async (
   );
 };
 
+const DEFAULT_CLOUD_URL = "https://cloud.assistant-ui.com";
+
 export const cloud = new Command()
   .name("cloud")
-  .description("sign in and set up a multiplayer Assistant Cloud chat")
+  .description("manage Assistant Cloud (run `assistant-ui cloud help`)")
+  .helpOption(false)
+  .helpCommand(false)
+  .argument("[command...]")
+  .allowUnknownOption()
+  .allowExcessArguments()
+  .action(async (args: string[]) => {
+    process.exitCode = await runCloudCommand(args, {
+      cloudUrl: process.env.ASSISTANT_UI_CLOUD_URL ?? DEFAULT_CLOUD_URL,
+      accessToken: () => savedCloudAccessToken(cloudAuthConfig()),
+      stdout: (text) => process.stdout.write(text),
+      stderr: (text) => process.stderr.write(text),
+    });
+  })
   .addCommand(
     new Command("login")
       .description("sign in to Assistant Cloud using your browser")
@@ -418,7 +435,7 @@ export const cloud = new Command()
       .option(
         "--api-url <url>",
         "Assistant Cloud management URL",
-        process.env.ASSISTANT_UI_CLOUD_URL ?? "https://cloud.assistant-ui.com",
+        process.env.ASSISTANT_UI_CLOUD_URL ?? DEFAULT_CLOUD_URL,
       )
       .option(
         "--access-code <code>",

package/src/commands/info.ts

@@ -38,6 +38,8 @@ const ASSISTANT_UI_PACKAGES = [
   "@assistant-ui/react-lexical",
   "@assistant-ui/react-syntax-highlighter",
   "@assistant-ui/react-hook-form",
+  "safe-content-frame",
+  "tw-shimmer",
   // Observability & DevTools
   "@assistant-ui/react-o11y",
   "@assistant-ui/react-devtools",
@@ -50,6 +52,7 @@ const ECOSYSTEM_PACKAGES = [
   "next",
   "vite",
   "expo",
+  "tailwindcss",
   "ai",
   "zod",
   "zustand",
@@ -112,6 +115,24 @@ function getAssistantUiPackageNames(
   return [...new Set([...ASSISTANT_UI_PACKAGES, ...declaredPackages])];
 }
 
+// Adapters peer on the provider SDK they wrap, so the installed packages
+// name the upstream versions a bug report needs.
+function getEcosystemPackageNames(
+  packages: PackageInfo[],
+  cwd: string,
+): string[] {
+  const upstreamPeers = packages
+    .flatMap((pkg) => Object.keys(getPeerDeps(pkg.name, cwd) ?? {}))
+    .filter(
+      (name) =>
+        !name.startsWith("@assistant-ui/") &&
+        !ASSISTANT_UI_PACKAGES.includes(name),
+    )
+    .sort();
+
+  return [...new Set([...ECOSYSTEM_PACKAGES, ...upstreamPeers])];
+}
+
 function getSpecifiedRange(
   pkg: string,
   projectPkg: Record<string, unknown>,
@@ -312,7 +333,11 @@ async function collectInfo(
     cwd,
     projectPkg,
   );
-  const ecosystem = collectPackages(ECOSYSTEM_PACKAGES, cwd, projectPkg);
+  const ecosystem = collectPackages(
+    getEcosystemPackageNames(packages, cwd),
+    cwd,
+    projectPkg,
+  );
   const warnings = collectWarnings(packages, cwd, projectPkg);
 
   return {

package/src/lib/cloud-auth.ts

@@ -230,16 +230,11 @@ export const loginToCloud = async (
   }
 };
 
-export const cloudAccessToken = async (
+export const savedCloudAccessToken = async (
   config: CloudAuthConfig,
-  options: {
-    noOpen?: boolean;
-    setupUrl?: string;
-    print?: (text: string) => void;
-  } = {},
-): Promise<string> => {
+): Promise<string | null> => {
   const saved = await readCloudCredentials(config);
-  if (!saved) return (await loginToCloud(config, options)).tokens.accessToken;
+  if (!saved) return null;
   const login = createDeviceLogin({
     issuer: config.issuer,
     clientId: config.clientId,
@@ -259,6 +254,17 @@ export const cloudAccessToken = async (
   }
 };
 
+export const cloudAccessToken = async (
+  config: CloudAuthConfig,
+  options: {
+    noOpen?: boolean;
+    setupUrl?: string;
+    print?: (text: string) => void;
+  } = {},
+): Promise<string> =>
+  (await savedCloudAccessToken(config)) ??
+  (await loginToCloud(config, options)).tokens.accessToken;
+
 export const logoutFromCloud = async (
   config: CloudAuthConfig,
 ): Promise<void> => {

package/src/lib/cloud-remote.test.ts

@@ -0,0 +1,156 @@
+import { afterEach, describe, expect, it, vi } from "vitest";
+import {
+  joinCloudArgs,
+  parseCloudCliResponse,
+  runCloudCommand,
+  sendCloudCommand,
+  type CloudCliResponse,
+} from "./cloud-remote";
+
+afterEach(() => {
+  vi.unstubAllGlobals();
+});
+
+const harness = (reply: CloudCliResponse, token: string | null = "token") => {
+  const output = { stdout: "", stderr: "" };
+  const send = vi.fn(async () => reply);
+  return {
+    output,
+    send,
+    run: (args: string[]) =>
+      runCloudCommand(args, {
+        cloudUrl: "https://cloud.example.com",
+        accessToken: async () => token,
+        stdout: (text) => {
+          output.stdout += text;
+        },
+        stderr: (text) => {
+          output.stderr += text;
+        },
+        send,
+      }),
+  };
+};
+
+describe("cloud remote commands", () => {
+  it("quotes arguments so a POSIX shell split gives them back", () => {
+    expect(
+      joinCloudArgs(["projects", "list", "--org", "my org", "it's", ""]),
+    ).toBe(`projects list --org 'my org' 'it'\\''s' ''`);
+  });
+
+  it("prints the envelope and exits with its code", async () => {
+    const { run, send, output } = harness({
+      stdout: "out\n",
+      stderr: "err\n",
+      exitCode: 3,
+    });
+    await expect(run(["whoami"])).resolves.toBe(3);
+    expect(send).toHaveBeenCalledWith(
+      "https://cloud.example.com",
+      ["whoami"],
+      "token",
+    );
+    expect(output).toEqual({ stdout: "out\n", stderr: "err\n" });
+  });
+
+  it("fails an action it does not know before printing anything", async () => {
+    const { run, output } = harness({
+      stdout: "uploading\n",
+      exitCode: 0,
+      actions: [{ type: "upload", arg: 2 }],
+    });
+    await expect(run(["files", "push", "a.txt"])).resolves.toBe(1);
+    expect(output.stdout).toBe("");
+    expect(output.stderr).toMatch(/newer assistant-ui.*"upload"/);
+  });
+
+  it("prints a failed request as one line and exits 1", async () => {
+    const { run, send, output } = harness({ exitCode: 0 });
+    send.mockRejectedValueOnce(new Error("Could not reach the cloud"));
+    await expect(run(["whoami"])).resolves.toBe(1);
+    expect(output.stderr).toBe("Could not reach the cloud\n");
+  });
+
+  it("sends anonymously when the saved login cannot be read", async () => {
+    const output = { stdout: "", stderr: "" };
+    const send = vi.fn(async () => ({ stdout: "help\n", exitCode: 0 }));
+    await expect(
+      runCloudCommand(["help"], {
+        cloudUrl: "https://cloud.example.com",
+        accessToken: async () => {
+          throw new Error("Invalid saved login.");
+        },
+        stdout: (text) => {
+          output.stdout += text;
+        },
+        stderr: (text) => {
+          output.stderr += text;
+        },
+        send,
+      }),
+    ).resolves.toBe(0);
+    expect(send).toHaveBeenCalledWith(
+      "https://cloud.example.com",
+      ["help"],
+      null,
+    );
+    expect(output).toEqual({
+      stdout: "help\n",
+      stderr: "Invalid saved login.\n",
+    });
+  });
+
+  it("accepts only a well-formed envelope", () => {
+    expect(parseCloudCliResponse({ stdout: "x", exitCode: 0 })).toEqual({
+      stdout: "x",
+      exitCode: 0,
+    });
+    for (const bad of [
+      null,
+      "text",
+      { stdout: "x" },
+      { exitCode: 1.5 },
+      { exitCode: 256 },
+      { exitCode: -1 },
+      { exitCode: 0, stderr: 3 },
+      { exitCode: 0, actions: [{}] },
+    ]) {
+      expect(parseCloudCliResponse(bad)).toBeNull();
+    }
+  });
+
+  it("posts the command string, client and bearer token", async () => {
+    const fetchMock = vi.fn(async () =>
+      Response.json({ stdout: "ok\n", exitCode: 0 }),
+    );
+    vi.stubGlobal("fetch", fetchMock);
+    await expect(
+      sendCloudCommand("https://cloud.example.com/", ["help", "a b"], "tok"),
+    ).resolves.toEqual({ stdout: "ok\n", exitCode: 0 });
+    const [url, init] = fetchMock.mock.calls[0] as unknown as [
+      string,
+      RequestInit,
+    ];
+    expect(url).toBe("https://cloud.example.com/api/cli/run");
+    expect(init.headers).toMatchObject({ Authorization: "Bearer tok" });
+    expect(JSON.parse(init.body as string)).toMatchObject({
+      command: "help 'a b'",
+      client: { name: "assistant-ui" },
+    });
+  });
+
+  it("sends no Authorization header when signed out and rejects a non-envelope", async () => {
+    const fetchMock = vi.fn(
+      async () => new Response("<html>", { status: 502 }),
+    );
+    vi.stubGlobal("fetch", fetchMock);
+    await expect(
+      sendCloudCommand("https://cloud.example.com", ["help"], null),
+    ).rejects.toThrow(/Unexpected response .*502/);
+    const init = (
+      fetchMock.mock.calls[0] as unknown as [string, RequestInit]
+    )[1];
+    expect(init.headers).not.toHaveProperty("Authorization");
+  });
+});