@vellumai/assistant 0.12.1-dev.202609141913.5e16607 → 0.12.1-staging.2

package/src/cli/commands/__tests__/apps.test.ts

@@ -1,245 +0,0 @@
-/**
- * Tests for `assistant apps inspect` and `assistant apps refresh`.
- */
-
-import { mkdirSync, rmSync, writeFileSync } from "node:fs";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
-import { afterEach, beforeEach, describe, expect, mock, test } from "bun:test";
-
-import { createApp, getAppDirPath } from "../../../apps/app-store.js";
-import { writeAppSourceFingerprint } from "../../../apps/source-fingerprint.js";
-import { getWorkspacePluginsDir } from "../../../util/platform.js";
-import { runCliCommand } from "./cli-test-harness.js";
-
-let lastIpcCall: {
-  method: string;
-  params?: Record<string, unknown>;
-} | null = null;
-
-let mockIpcResult: {
-  ok: boolean;
-  result?: unknown;
-  error?: string;
-  statusCode?: number;
-} = { ok: true, result: { ok: true, compiled: true } };
-
-mock.module("../../../ipc/cli-client.js", () => ({
-  cliIpcCall: async (method: string, params?: Record<string, unknown>) => {
-    lastIpcCall = { method, params };
-    return mockIpcResult;
-  },
-  exitCodeFromIpcResult: (r: { statusCode?: number }) => {
-    if (r.statusCode === undefined) {
-      return 10;
-    }
-    if (r.statusCode >= 500) {
-      return 3;
-    }
-    if (r.statusCode >= 400) {
-      return 2;
-    }
-    return 1;
-  },
-}));
-
-const { registerAppsCommand } = await import("../apps.js");
-
-let workspaceDir: string;
-let previousWorkspaceDir: string | undefined;
-
-function freshWorkspace(): string {
-  return join(
-    tmpdir(),
-    `vellum-apps-cli-${Date.now()}-${Math.random().toString(36).slice(2)}`,
-  );
-}
-
-function uniqueAppName(prefix: string): string {
-  return `${prefix} ${Math.random().toString(36).slice(2, 8)}`;
-}
-
-beforeEach(() => {
-  previousWorkspaceDir = process.env.VELLUM_WORKSPACE_DIR;
-  workspaceDir = freshWorkspace();
-  process.env.VELLUM_WORKSPACE_DIR = workspaceDir;
-  lastIpcCall = null;
-  mockIpcResult = {
-    ok: true,
-    result: {
-      ok: true,
-      appId: "app-1",
-      name: "Budget",
-      compiled: true,
-      compile_duration_ms: 12,
-    },
-  };
-});
-
-afterEach(() => {
-  rmSync(workspaceDir, { recursive: true, force: true });
-  if (previousWorkspaceDir === undefined) {
-    delete process.env.VELLUM_WORKSPACE_DIR;
-  } else {
-    process.env.VELLUM_WORKSPACE_DIR = previousWorkspaceDir;
-  }
-});
-
-function parseJson(stdout: string): Record<string, unknown> {
-  return JSON.parse(stdout.trim()) as Record<string, unknown>;
-}
-
-describe("assistant apps inspect", () => {
-  test("reports never_compiled for a new workspace app", async () => {
-    const name = uniqueAppName("Inspect Fresh");
-    const created = createApp({
-      name,
-      schemaJson: "{}",
-      htmlDefinition: "<h1>Budget</h1>",
-    });
-
-    const result = await runCliCommand(registerAppsCommand, [
-      "apps",
-      "inspect",
-      created.id,
-      "--json",
-    ]);
-
-    expect(result.exitCode).toBe(0);
-    const body = parseJson(result.stdout);
-    expect(body.ok).toBe(true);
-    const compile = body.compile as { status: string };
-    expect(compile.status).toBe("never_compiled");
-  });
-
-  test("reports stale after source changes since the last fingerprint", async () => {
-    const name = uniqueAppName("Inspect Stale");
-    const created = createApp({
-      name,
-      schemaJson: "{}",
-      htmlDefinition: "<h1>Budget</h1>",
-    });
-    const appDir = getAppDirPath(created.id);
-    expect(appDir.length).toBeGreaterThan(0);
-    mkdirSync(join(appDir, "src"), { recursive: true });
-    writeFileSync(join(appDir, "src", "main.tsx"), "export const n = 1;\n");
-    mkdirSync(join(appDir, "dist"), { recursive: true });
-    writeFileSync(join(appDir, "dist", "index.html"), "<html></html>");
-    writeAppSourceFingerprint(appDir, join(appDir, "dist"));
-    writeFileSync(join(appDir, "src", "main.tsx"), "export const n = 2;\n");
-
-    const result = await runCliCommand(registerAppsCommand, [
-      "apps",
-      "inspect",
-      created.id,
-      "--json",
-    ]);
-
-    expect(result.exitCode).toBe(0);
-    const body = parseJson(result.stdout);
-    const app = body.app as { id: string; source: string };
-    expect(app.id).toBe(created.id);
-    expect(app.source).toBe(appDir);
-    const compile = body.compile as {
-      status: string;
-      modified: string[];
-    };
-    expect(compile.status).toBe("stale");
-    expect(compile.modified).toEqual(["src/main.tsx"]);
-  });
-
-  test("exits 1 for an unknown app", async () => {
-    const result = await runCliCommand(registerAppsCommand, [
-      "apps",
-      "inspect",
-      "missing",
-      "--json",
-    ]);
-    expect(result.exitCode).toBe(1);
-    const body = parseJson(result.stdout);
-    expect(body.ok).toBe(false);
-    expect(String(body.error)).toContain("assistant apps list");
-  });
-});
-
-describe("assistant apps refresh", () => {
-  test("sends apps_refresh IPC for a workspace app", async () => {
-    const name = uniqueAppName("Refresh");
-    const created = createApp({
-      name,
-      schemaJson: "{}",
-      htmlDefinition: "<h1>Budget</h1>",
-    });
-
-    const result = await runCliCommand(registerAppsCommand, [
-      "apps",
-      "refresh",
-      created.id,
-      "--json",
-    ]);
-
-    expect(result.exitCode).toBe(0);
-    expect(lastIpcCall).toEqual({
-      method: "apps_refresh",
-      params: { pathParams: { id: created.id } },
-    });
-    const body = parseJson(result.stdout);
-    expect(body.compiled).toBe(true);
-  });
-
-  test("sends apps_refresh IPC for a plugin app", async () => {
-    const pluginName = `charts-${Math.random().toString(36).slice(2, 8)}`;
-    const pluginDir = join(getWorkspacePluginsDir(), pluginName);
-    mkdirSync(pluginDir, { recursive: true });
-    writeFileSync(
-      join(pluginDir, "package.json"),
-      JSON.stringify({ name: pluginName, version: "1.0.0" }),
-    );
-    mkdirSync(join(pluginDir, "apps", "viewer"), { recursive: true });
-    writeFileSync(join(pluginDir, "apps", "viewer", "index.html"), "<h1></h1>");
-
-    const result = await runCliCommand(registerAppsCommand, [
-      "apps",
-      "refresh",
-      "viewer",
-      "--json",
-    ]);
-
-    expect(result.exitCode).toBe(0);
-    expect(lastIpcCall).toEqual({
-      method: "apps_refresh",
-      params: { pathParams: { id: `plugins~${pluginName}~viewer` } },
-    });
-  });
-
-  test("exits 1 when compile fails", async () => {
-    const name = uniqueAppName("Refresh Fail");
-    const created = createApp({
-      name,
-      schemaJson: "{}",
-      htmlDefinition: "<h1>Budget</h1>",
-    });
-    mockIpcResult = {
-      ok: true,
-      result: {
-        ok: true,
-        appId: created.id,
-        name,
-        compiled: false,
-        compile_duration_ms: 8,
-        compile_errors: [{ text: "Could not resolve foo" }],
-      },
-    };
-
-    const result = await runCliCommand(registerAppsCommand, [
-      "apps",
-      "refresh",
-      created.id,
-      "--json",
-    ]);
-
-    expect(result.exitCode).toBe(1);
-    const body = parseJson(result.stdout);
-    expect(body.compiled).toBe(false);
-  });
-});

package/src/cli/commands/__tests__/bash.test.ts

@@ -1,53 +0,0 @@
-/**
- * Tests for `assistant bash`: local sanitized spawn, no IPC round-trip.
- */
-
-import { describe, expect, mock, test } from "bun:test";
-
-import { runCliCommand } from "./cli-test-harness.js";
-
-const ipcCalls: Array<{ method: string }> = [];
-
-mock.module("../../../ipc/cli-client.js", () => ({
-  cliIpcCall: async (method: string) => {
-    ipcCalls.push({ method });
-    return { ok: false, error: "IPC should not be used" };
-  },
-}));
-
-mock.module("../../logger.js", () => ({
-  log: {
-    info: () => {},
-    warn: () => {},
-    error: (message: string) => {
-      process.stderr.write(`${message}\n`);
-    },
-    debug: () => {},
-  },
-}));
-
-const { registerBashCommand } = await import("../bash.js");
-
-describe("assistant bash", () => {
-  test("spawns locally and prints stdout without IPC", async () => {
-    ipcCalls.length = 0;
-    const result = await runCliCommand(registerBashCommand, [
-      "bash",
-      "echo hello",
-    ]);
-    expect(ipcCalls).toEqual([]);
-    expect(result.stdout.trim()).toBe("hello");
-    expect(result.exitCode).toBe(0);
-  });
-
-  test("rejects a non-positive timeout", async () => {
-    const result = await runCliCommand(registerBashCommand, [
-      "bash",
-      "echo hello",
-      "--timeout",
-      "0",
-    ]);
-    expect(result.stderr).toContain("Invalid timeout value");
-    expect(result.exitCode).toBe(1);
-  });
-});

package/src/cli/commands/__tests__/roadmap.help.test.ts

@@ -1,19 +0,0 @@
-import { describe, expect, test } from "bun:test";
-
-import { roadmapHelp } from "../roadmap.help.js";
-
-const DISCORD_URL = "https://vellum.ai/community";
-
-describe("roadmap help is feature-proposal-only", () => {
-  test("top-level help describes feature proposals and routes bugs to Discord", () => {
-    const description = roadmapHelp.description;
-    const helpText = roadmapHelp.helpText ?? "";
-    const combined = `${description}\n${helpText}`.toLowerCase();
-
-    expect(combined).toMatch(/feature proposals?/);
-    expect(description.split(DISCORD_URL)).toHaveLength(2);
-    expect(helpText).toContain(DISCORD_URL);
-    expect(combined).toContain("instruct the user");
-    expect(combined).not.toMatch(/support@|github\.com|share feedback/);
-  });
-});

package/src/cli/commands/channels/__tests__/send.test.ts

@@ -1,218 +0,0 @@
-import { beforeEach, describe, expect, mock, test } from "bun:test";
-
-// The command is a door onto the daemon's one send implementation, so what
-// matters is the request it hands the route and what it does with the
-// answer. IPC is stubbed to capture that request; the exit-code helper
-// stays real, so the tests assert the mapping that ships.
-
-const ipcCalls: Array<{
-  method: string;
-  params: Record<string, unknown>;
-  opts?: Record<string, unknown>;
-}> = [];
-let ipcResult: Record<string, unknown> = {
-  ok: true,
-  result: {
-    channel: "slack",
-    chatId: "C0123456789",
-    messageIds: ["1700000000.000100"],
-    lastMessageId: "1700000000.000100",
-    recordedIn: "conv-home",
-  },
-};
-
-const actualCliClient = await import("../../../../ipc/cli-client.js");
-mock.module("../../../../ipc/cli-client.js", () => ({
-  ...actualCliClient,
-  cliIpcCall: async (
-    method: string,
-    params: Record<string, unknown>,
-    opts?: Record<string, unknown>,
-  ) => {
-    ipcCalls.push({ method, params, ...(opts ? { opts } : {}) });
-    return ipcResult;
-  },
-}));
-
-// Imported after the mock is installed, so the command module under test
-// binds the stubbed IPC call rather than the real one.
-const { runCliCommand } = await import("../../__tests__/cli-test-harness.js");
-const { registerChannelsCommand } = await import("../index.js");
-
-beforeEach(() => {
-  ipcCalls.length = 0;
-  ipcResult = {
-    ok: true,
-    result: {
-      channel: "slack",
-      chatId: "C0123456789",
-      messageIds: ["1700000000.000100"],
-      lastMessageId: "1700000000.000100",
-      recordedIn: "conv-home",
-    },
-  };
-});
-
-// The shipped registration as-is: `send` declares its own `--json`, which is
-// why the program's global leaf-option pass skips it.
-function runSend(args: string[]) {
-  return runCliCommand(registerChannelsCommand, ["channels", "send", ...args]);
-}
-
-/** The body the command handed the route on its one call. */
-function sentBody(): Record<string, unknown> {
-  expect(ipcCalls).toHaveLength(1);
-  expect(ipcCalls[0]!.method).toBe("channels_send_post");
-  return ipcCalls[0]!.params.body as Record<string, unknown>;
-}
-
-describe("the request the command makes", () => {
-  test("names the chat and asks for the channel's rich rendering", async () => {
-    const r = await runSend([
-      "slack",
-      "C0123456789",
-      "--text",
-      "deploy is green",
-    ]);
-    expect(r.exitCode).toBe(0);
-    expect(sentBody()).toEqual({
-      channel: "slack",
-      target: { kind: "chat", chatId: "C0123456789" },
-      text: "deploy is green",
-      renderRichly: true,
-    });
-  });
-
-  test("carries a named thread as the target's thread", async () => {
-    await runSend([
-      "slack",
-      "C0123456789",
-      "--thread",
-      "1700000000.000001",
-      "--text",
-      "and the smoke tests passed",
-    ]);
-    expect(sentBody().target).toEqual({
-      kind: "chat",
-      chatId: "C0123456789",
-      threadId: "1700000000.000001",
-    });
-  });
-
-  test("--plain asks for the text verbatim", async () => {
-    await runSend(["telegram", "123456789", "--text", "morning", "--plain"]);
-    const body = sentBody();
-    expect(body.renderRichly).toBeUndefined();
-    expect(body.channel).toBe("telegram");
-  });
-
-  test("sends the text as the caller wrote it, whitespace included", async () => {
-    await runSend([
-      "slack",
-      "C0123456789",
-      "--text",
-      "  indented  ",
-      "--plain",
-    ]);
-    expect(sentBody().text).toBe("  indented  ");
-  });
-
-  test("waits longer than the IPC default, since the send itself retries", async () => {
-    await runSend(["slack", "C0123456789", "--text", "hi"]);
-    expect(ipcCalls[0]!.opts).toMatchObject({ timeoutMs: 120_000 });
-  });
-
-  test("refuses an empty text before it sends anything", async () => {
-    for (const args of [
-      ["slack", "C0123456789"],
-      ["slack", "C0123456789", "--text", "   "],
-    ]) {
-      ipcCalls.length = 0;
-      const r = await runSend(args);
-      expect(r.exitCode).toBe(1);
-      expect(r.stderr).toContain("--text is required");
-      expect(ipcCalls).toEqual([]);
-    }
-  });
-});
-
-describe("what the command reports", () => {
-  test("names where the post landed and the conversation it was recorded in", async () => {
-    const r = await runSend(["slack", "C0123456789", "--text", "hello"]);
-    expect(r.stdout).toContain("C0123456789");
-    expect(r.stdout).toContain("1700000000.000100");
-    expect(r.stdout).toContain("conv-home");
-  });
-
-  test("says so when the channel split the text", async () => {
-    ipcResult = {
-      ok: true,
-      result: {
-        channel: "telegram",
-        chatId: "123456789",
-        messageIds: ["10", "11", "12"],
-        lastMessageId: "12",
-      },
-    };
-    const r = await runSend(["telegram", "123456789", "--text", "a long one"]);
-    expect(r.stdout).toContain("3 posts");
-  });
-
-  test("--json answers with the route's own result", async () => {
-    const r = await runSend([
-      "slack",
-      "C0123456789",
-      "--text",
-      "hello",
-      "--json",
-    ]);
-    expect(JSON.parse(r.stdout)).toEqual({
-      channel: "slack",
-      chatId: "C0123456789",
-      messageIds: ["1700000000.000100"],
-      lastMessageId: "1700000000.000100",
-      recordedIn: "conv-home",
-    });
-  });
-
-  test("a refused send reports the route's reason and its exit code", async () => {
-    ipcResult = {
-      ok: false,
-      error: 'Channel "email" is not addressable',
-      statusCode: 400,
-    };
-    const r = await runSend(["email", "someone", "--text", "hello"]);
-    expect(r.exitCode).toBe(
-      actualCliClient.exitCodeFromIpcResult({ statusCode: 400 }),
-    );
-    expect(r.stderr).toContain("not addressable");
-  });
-
-  test("a timeout is reported as an unknown outcome, not a failure to retry", async () => {
-    ipcResult = { ok: false, error: "Request timed out", timedOut: true };
-    const r = await runSend(["slack", "C0123456789", "--text", "hello"]);
-    expect(r.stderr).toContain("may still be in flight");
-    expect(r.stderr).toContain("before sending again");
-    expect(r.stderr).not.toContain("The send failed");
-  });
-
-  test("a refusal in --json mode is a JSON error envelope", async () => {
-    ipcResult = {
-      ok: false,
-      error: 'Channel "slack" did not acknowledge the send',
-      statusCode: 502,
-    };
-    const r = await runSend([
-      "slack",
-      "C0123456789",
-      "--text",
-      "hello",
-      "--json",
-    ]);
-    expect(JSON.parse(r.stdout)).toEqual({
-      ok: false,
-      error: 'Channel "slack" did not acknowledge the send',
-    });
-    expect(r.exitCode).toBe(3);
-  });
-});

package/src/cli/commands/channels/send.ts

@@ -1,128 +0,0 @@
-/**
- * `assistant channels send`: post text to a chat on a channel, as the
- * assistant's own bot.
- *
- * The send door. It runs the daemon function the messaging tool runs
- * (`sendChannelText`, over `POST /v1/channels/send`), so a send from the
- * command line reaches the chat through the channel's transport and leaves
- * the same record: threaded where a thread is named, rendered the way the
- * channel renders a reply, and written to the chat's conversation only once
- * the channel has acknowledged it.
- *
- * Posting the same text through `channels request` reaches the platform API
- * directly and leaves no record of what was said, which is why this command
- * exists beside it. Both act as the bot and both carry the same rating: the
- * effect is a message either way.
- *
- * A channel whose transport cannot be addressed from a named chat is
- * refused by the route before anything is sent.
- */
-
-import type { Command } from "commander";
-
-import { cliIpcCall, exitCodeFromIpcResult } from "../../../ipc/cli-client.js";
-import { subcommand } from "../../lib/cli-command-help.js";
-import { log } from "../../logger.js";
-import { shouldOutputJson, writeError, writeOutput } from "../../output.js";
-
-/** What the channel acknowledged, and where the post was recorded. */
-interface ChannelSendResponse {
-  channel: string;
-  chatId: string;
-  threadId?: string;
-  messageIds: string[];
-  lastMessageId: string;
-  recordedIn?: string;
-}
-
-interface ChannelSendOptions {
-  text?: string;
-  thread?: string;
-  plain?: boolean;
-}
-
-/**
- * How long to wait for the daemon before giving up on an answer.
- *
- * Longer than the IPC default because the work behind this call is a
- * platform request that retries: a rate-limited Slack send sleeps for the
- * `Retry-After` Slack names and tries again up to three times
- * (`MAX_RATE_LIMIT_RETRIES`, providers/slack/web-api-transport.ts), and the
- * other channels back off similarly. Waiting past that is better than
- * abandoning a send that is still being made, because giving up tells the
- * caller nothing about whether the message went out.
- */
-const SEND_CALL_TIMEOUT_MS = 120_000;
-
-export function registerChannelsSendCommand(channels: Command): void {
-  subcommand(channels, "send").action(
-    async (
-      channel: string,
-      chatId: string,
-      opts: ChannelSendOptions,
-      cmd: Command,
-    ) => {
-      // Trimmed only to reject a blank message: the text goes out as the
-      // caller wrote it, which `--plain` in particular promises.
-      const text = opts.text;
-      if (!text?.trim()) {
-        writeError(cmd, "--text is required and cannot be empty.");
-        process.exitCode = 1;
-        return;
-      }
-
-      const threadId = opts.thread?.trim();
-      const r = await cliIpcCall<ChannelSendResponse>(
-        "channels_send_post",
-        {
-          body: {
-            channel,
-            target: {
-              kind: "chat",
-              chatId,
-              ...(threadId ? { threadId } : {}),
-            },
-            text,
-            // Rich unless asked otherwise, so a send from here reads like
-            // the assistant's other posts in that chat rather than like a
-            // different sender.
-            ...(opts.plain ? {} : { renderRichly: true }),
-          },
-        },
-        { timeoutMs: SEND_CALL_TIMEOUT_MS },
-      );
-      if (!r.ok) {
-        // A timeout is not a failure: closing the client socket does not
-        // stop the daemon, so the message may still go out. Saying so is
-        // what keeps a retry from posting it twice.
-        const message = r.timedOut
-          ? `The daemon did not answer within ${Math.round(SEND_CALL_TIMEOUT_MS / 1000)}s. The send may still be in flight, so it may or may not have gone out. Check the chat before sending again.`
-          : (r.error ?? "The send failed.");
-        // Reported rather than exited, so `--json` gets an error envelope
-        // like every other answer this command gives.
-        writeError(cmd, message);
-        process.exitCode = exitCodeFromIpcResult({
-          statusCode: r.statusCode,
-        });
-        return;
-      }
-
-      const sent = r.result!;
-      if (shouldOutputJson(cmd)) {
-        writeOutput(cmd, sent);
-        return;
-      }
-
-      const where = sent.threadId
-        ? `${sent.chatId}, thread ${sent.threadId}`
-        : sent.chatId;
-      log.info(`Sent to ${channel} ${where} (id: ${sent.lastMessageId})`);
-      if (sent.messageIds.length > 1) {
-        log.info(`The channel split it into ${sent.messageIds.length} posts`);
-      }
-      if (sent.recordedIn) {
-        log.info(`Recorded in conversation ${sent.recordedIn}`);
-      }
-    },
-  );
-}