@vellumai/assistant 0.11.5 → 0.11.6-staging.1

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

@@ -15,6 +15,7 @@
 import type { Command } from "commander";
 
 import { cliIpcCall, exitFromIpcResult } from "../../../ipc/cli-client.js";
+import type { ChannelReadinessSnapshot } from "../../../runtime/channel-readiness-types.js";
 import { applyCommandHelp, subcommand } from "../../lib/cli-command-help.js";
 import { registerCommand } from "../../lib/register-command.js";
 import { log } from "../../logger.js";
@@ -22,26 +23,16 @@ import { shouldOutputJson, writeOutput } from "../../output.js";
 import { channelsHelp } from "./index.help.js";
 
 // ---------------------------------------------------------------------------
-// Snapshot shape (mirrors runtime/routes/channel-readiness-routes.ts)
+// Snapshot shape
 // ---------------------------------------------------------------------------
 
-interface ReadinessCheck {
-  name: string;
-  passed: boolean;
-  message: string;
-}
-
-interface ChannelSnapshot {
-  channel: string;
-  ready: boolean;
-  setupStatus: "not_configured" | "incomplete" | "ready";
-  checkedAt: number;
-  stale: boolean;
-  reasons: Array<{ code: string; text: string }>;
-  localChecks: ReadinessCheck[];
-  remoteChecks?: ReadinessCheck[];
-  channelHandle?: unknown;
-}
+/**
+ * The readiness service's own snapshot type, not a copy of it. A local
+ * mirror is what let this command fall a field behind the contract: it had
+ * no `health`, so a channel whose setup was complete and whose delivery had
+ * stopped rendered as unfinished setup.
+ */
+type ChannelSnapshot = ChannelReadinessSnapshot;
 
 interface ReadinessResponse {
   success: boolean;
@@ -52,26 +43,49 @@ interface ReadinessResponse {
 // Rendering
 // ---------------------------------------------------------------------------
 
-function statusGlyph(s: ChannelSnapshot): string {
-  if (s.ready) {
-    return "✅";
-  }
-  if (s.setupStatus === "not_configured") {
-    return "○ ";
-  }
-  return "⚠️ ";
-}
-
-function statusWord(s: ChannelSnapshot): string {
+/**
+ * Two axes, reported as one line each.
+ *
+ * `setupStatus` says whether setup finished; `health` says whether the
+ * channel is delivering. Collapsing them into setup progress alone is how a
+ * configured channel whose socket had died came to print as `incomplete`,
+ * which tells the reader to go finish a setup that is already complete.
+ * Ordered so the operational answer wins: once setup is done, what remains
+ * to say is whether it works.
+ */
+function statusState(
+  s: ChannelSnapshot,
+):
+  | "ready"
+  | "not configured"
+  | "not delivering"
+  | "state unknown"
+  | "incomplete" {
   if (s.ready) {
     return "ready";
   }
   if (s.setupStatus === "not_configured") {
     return "not configured";
   }
+  if (s.setupStatus === "ready") {
+    return s.health === "unknown" ? "state unknown" : "not delivering";
+  }
   return "incomplete";
 }
 
+const STATE_GLYPHS: Record<ReturnType<typeof statusState>, string> = {
+  ready: "✅",
+  "not configured": "○ ",
+  "not delivering": "⚠️ ",
+  // Neither vouched for nor condemned: the checks ran and settled nothing.
+  "state unknown": "? ",
+  incomplete: "⚠️ ",
+};
+
+function statusGlyph(s: ChannelSnapshot): string {
+  return STATE_GLYPHS[statusState(s)];
+}
+
 function renderList(snapshots: ChannelSnapshot[]): void {
   const sorted = [...snapshots].sort((a, b) =>
     a.channel.localeCompare(b.channel),
@@ -79,12 +93,12 @@ function renderList(snapshots: ChannelSnapshot[]): void {
   log.info("Channel        Status");
   log.info("-------------  ------");
   for (const s of sorted) {
-    log.info(`${statusGlyph(s)} ${s.channel.padEnd(12)}  ${statusWord(s)}`);
+    log.info(`${statusGlyph(s)} ${s.channel.padEnd(12)}  ${statusState(s)}`);
   }
 }
 
 function renderSnapshot(s: ChannelSnapshot): void {
-  log.info(`${statusGlyph(s)} ${s.channel} — ${s.setupStatus}`);
+  log.info(`${statusGlyph(s)} ${s.channel} — ${statusState(s)}`);
   if (s.reasons.length > 0) {
     log.info("");
     log.info("Reasons:");

package/src/cli/commands/inference-profiles.ts

@@ -28,6 +28,8 @@ interface ProfileSummary {
   source: "managed" | "user";
   provider_connection?: string;
   availability: { status: string; message?: string } | null;
+  /** Static problem with the stored entry itself; absent when it checks out. */
+  config_issue?: { code: string; message: string };
 }
 
 interface ProfileWriteResult {
@@ -37,6 +39,29 @@ interface ProfileWriteResult {
   warnings: string[];
   /** Live-call command the daemon suggests for verifying the written profile. */
   verify?: string;
+  /** Save-time probe verdict (null = no verdict); absent when the daemon predates the route. */
+  check?: ProfileCheck | null;
+}
+
+interface ProfileCheck {
+  ok: boolean;
+  blame?: string;
+  message?: string;
+}
+
+/**
+ * Probe the just-written profile with one minimal request through the
+ * daemon's validate route. Advisory: any transport or route error (e.g. a
+ * daemon predating the route) yields undefined and the save flow proceeds.
+ */
+async function fetchProfileCheck(
+  name: string,
+): Promise<ProfileCheck | null | undefined> {
+  const probe = await cliIpcCall<{ check: ProfileCheck | null }>(
+    "inference_profiles_validate",
+    { pathParams: { name } },
+  );
+  return probe.ok ? probe.result!.check : undefined;
 }
 
 type WriteFlags = {
@@ -123,6 +148,9 @@ function printWriteResult(
   for (const warning of result.warnings) {
     writeLine(`warning: ${warning}`);
   }
+  if (result.check && !result.check.ok && result.check.message) {
+    writeLine(`warning: ${result.check.message}`);
+  }
   writeLine(`profile ${result.name} ${verb}`);
   if (result.verify) {
     writeLine(`Verify it works: ${result.verify}`);
@@ -152,7 +180,16 @@ export function attachProfilesSubcommand(inference: Command): void {
       return;
     }
     renderTable(
-      ["NAME", "LABEL", "PROVIDER", "MODEL", "STATUS", "SOURCE", "AVAIL"],
+      [
+        "NAME",
+        "LABEL",
+        "PROVIDER",
+        "MODEL",
+        "STATUS",
+        "SOURCE",
+        "AVAIL",
+        "CONFIG",
+      ],
       rows.map((p) => [
         p.name,
         p.label ?? "-",
@@ -161,6 +198,7 @@ export function attachProfilesSubcommand(inference: Command): void {
         p.status,
         p.source,
         p.availability ? p.availability.status : "-",
+        p.config_issue ? p.config_issue.code : "ok",
       ]),
     );
   });
@@ -172,6 +210,7 @@ export function attachProfilesSubcommand(inference: Command): void {
         name: string;
         entry: Record<string, unknown>;
         availability: { status: string; message?: string } | null;
+        config_issue?: { code: string; message: string };
       }>("inference_profiles_get", { pathParams: { name } });
       if (!ipcResult.ok) {
         writeCliError(ipcResult.error ?? "Unknown error", opts.json);
@@ -192,6 +231,10 @@ export function attachProfilesSubcommand(inference: Command): void {
           writeLine(`    ${result.availability.message}`);
         }
       }
+      if (result.config_issue) {
+        writeLine(`  config: ${result.config_issue.code}`);
+        writeLine(`    ${result.config_issue.message}`);
+      }
     },
   );
 
@@ -219,7 +262,12 @@ export function attachProfilesSubcommand(inference: Command): void {
         writeCliError(ipcResult.error ?? "Unknown error", opts.json);
         return;
       }
-      printWriteResult("created", ipcResult.result!, opts.json);
+      const check = await fetchProfileCheck(name);
+      printWriteResult(
+        "created",
+        { ...ipcResult.result!, ...(check !== undefined ? { check } : {}) },
+        opts.json,
+      );
     },
   );
 
@@ -246,7 +294,12 @@ export function attachProfilesSubcommand(inference: Command): void {
         writeCliError(ipcResult.error ?? "Unknown error", opts.json);
         return;
       }
-      printWriteResult("updated", ipcResult.result!, opts.json);
+      const check = await fetchProfileCheck(name);
+      printWriteResult(
+        "updated",
+        { ...ipcResult.result!, ...(check !== undefined ? { check } : {}) },
+        opts.json,
+      );
     },
   );
 

package/src/cli/commands/inference-providers.ts

@@ -23,6 +23,7 @@ import { cliIpcCall } from "../../ipc/cli-client.js";
 import type { OAuth2Config } from "../../security/oauth2.js";
 import { subcommand } from "../lib/cli-command-help.js";
 import { writeCliError } from "../lib/cli-output.js";
+import { openInHostBrowser } from "../lib/open-browser.js";
 import { attachDefaultProviderSubcommand } from "./inference-providers-default.js";
 
 // ---------------------------------------------------------------------------
@@ -41,6 +42,22 @@ interface ProviderConnection {
   baseUrl?: string | null;
   createdAt: string;
   updatedAt: string;
+  /** Save-time probe of a custom base URL; advisory, never blocks the save. */
+  endpoint_check?: {
+    ok: boolean;
+    status?: number;
+    resolved_url: string;
+    hint?: string;
+  };
+}
+
+/** Human-mode warning line for a failed save-time endpoint probe. */
+function formatEndpointCheckWarning(conn: ProviderConnection): string {
+  const check = conn.endpoint_check;
+  if (!check || check.ok) {
+    return "";
+  }
+  return `Warning: ${check.hint ?? `The endpoint returned HTTP ${check.status} for a test request.`} (probed ${check.resolved_url})\n`;
 }
 
 // ---------------------------------------------------------------------------
@@ -304,6 +321,7 @@ function attachCreateSubcommand(parent: Command): void {
         } else {
           process.stdout.write(
             `Added provider "${conn.name}" (provider=${conn.provider})\n` +
+              formatEndpointCheckWarning(conn) +
               `Verify it works: point a profile at "${conn.name}", then run: assistant inference send --profile <profile> "Reply with OK"\n`,
           );
         }
@@ -394,6 +412,7 @@ function attachUpdateSubcommand(parent: Command): void {
         } else {
           process.stdout.write(
             `Updated provider "${name}" (auth=${formatAuth(conn.auth)})\n` +
+              formatEndpointCheckWarning(conn) +
               `Verify it works: assistant inference send --profile <profile-using-this-provider> "Reply with OK"\n`,
           );
         }
@@ -456,12 +475,19 @@ function attachLoginChatgptSubcommand(providers: Command): void {
           import("../../security/secure-keys.js"),
         ]);
         // Step 1: Run browser-based PKCE OAuth flow
-        process.stdout.write("Opening browser for ChatGPT authentication...\n");
+        if (!opts.json) {
+          process.stdout.write(
+            "Opening browser for ChatGPT authentication...\n",
+          );
+        }
         const result = await startOAuth2Flow(
           OPENAI_CODEX_OAUTH_CONFIG,
           {
             openUrl: (url) => {
-              Bun.spawn(["open", url]);
+              openInHostBrowser(url);
+              const fallbackMessage = `If the browser did not open, visit:\n${url}\n`;
+              const output = opts.json ? process.stderr : process.stdout;
+              output.write(fallbackMessage);
             },
           },
           {

package/src/cli/commands/oauth/index.help.ts

@@ -776,6 +776,11 @@ the same provider will resolve against the wrong host or path and fail (often
 with an opaque HTML 404). When in doubt, pass an absolute URL: it is the safe
 form for any service other than the provider's default.
 
+The body (-d) is JSON by default. Give a non-JSON Content-Type and the body
+travels to the provider exactly as written, which is what multipart, XML, and
+form-encoded payloads need. Body files (-d @<path>) are read as UTF-8 text, so
+a payload that is not valid UTF-8 cannot be sent this way.
+
 Note: The Authorization header is set automatically. User-supplied
 -H "Authorization: ..." will be overridden by the OAuth bearer token.
 
@@ -784,7 +789,8 @@ Examples:
   $ assistant oauth request --provider google /gmail/v1/users/me/messages -G
   $ assistant oauth request --provider twitter -X POST -d '{"text":"Hello"}' https://api.x.com/2/tweets
   $ assistant oauth request --provider google https://www.googleapis.com/calendar/v3/calendars/primary/events
-  $ assistant oauth request --provider slack -H "Content-Type: application/json" -d '{"channel":"C123"}' /api/chat.postMessage --json`,
+  $ assistant oauth request --provider slack -H "Content-Type: application/json" -d '{"channel":"C123"}' /api/chat.postMessage --json
+  $ assistant oauth request --provider google -X POST -H "Content-Type: multipart/related; boundary=b" -d @upload.txt "https://www.googleapis.com/upload/drive/v3/files?uploadType=multipart"`,
     },
     {
       name: "disconnect",

package/src/cli/commands/oauth/request.test.ts

@@ -0,0 +1,290 @@
+import { mkdtempSync, readFileSync, 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";
+
+const PNG_MAGIC = Buffer.from([
+  0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a, 0xff, 0xfe, 0x00,
+]);
+
+const ipcCalls: string[] = [];
+const handleRequestCalls: unknown[] = [];
+
+let handleRequestResult: {
+  ok: boolean;
+  status: number;
+  headers: Record<string, string>;
+  body: unknown;
+  bodyEncoding?: "base64";
+  account?: string | null;
+} = {
+  ok: true,
+  status: 200,
+  headers: { "content-type": "application/json" },
+  body: { hello: "world" },
+  account: "user@example.com",
+};
+
+mock.module("../../../ipc/cli-client.js", () => ({
+  cliIpcCall: async (method: string) => {
+    ipcCalls.push(method);
+    return { ok: false, error: `Unexpected IPC method ${method}` };
+  },
+  exitFromIpcResult: (r: { error?: string }) => {
+    throw new Error(r.error ?? "IPC error");
+  },
+}));
+
+mock.module("../../../runtime/routes/oauth-commands-routes.js", () => ({
+  handleRequest: async (args: unknown) => {
+    handleRequestCalls.push(args);
+    return handleRequestResult;
+  },
+}));
+
+import { Command } from "commander";
+
+import { applyCommandHelp } from "../../lib/cli-command-help.js";
+import { oauthHelp } from "./index.help.js";
+import { readBodyData, registerRequestCommand } from "./request.js";
+
+let tempDir: string;
+
+beforeEach(() => {
+  ipcCalls.length = 0;
+  handleRequestCalls.length = 0;
+  process.exitCode = 0;
+  tempDir = mkdtempSync(join(tmpdir(), "oauth-request-"));
+  handleRequestResult = {
+    ok: true,
+    status: 200,
+    headers: { "content-type": "application/json" },
+    body: { hello: "world" },
+    account: "user@example.com",
+  };
+});
+
+afterEach(() => {
+  rmSync(tempDir, { recursive: true, force: true });
+  process.exitCode = 0;
+});
+
+async function runRequestCommand(args: string[]): Promise<{
+  stdout: Buffer;
+  exitCode: number;
+}> {
+  const chunks: Buffer[] = [];
+  const originalWrite = process.stdout.write;
+  process.stdout.write = ((chunk: string | Uint8Array) => {
+    chunks.push(
+      typeof chunk === "string" ? Buffer.from(chunk) : Buffer.from(chunk),
+    );
+    return true;
+  }) as typeof process.stdout.write;
+
+  try {
+    const program = new Command();
+    program.exitOverride();
+    const oauth = program.command("oauth").description(oauthHelp.description);
+    applyCommandHelp(oauth, oauthHelp);
+    registerRequestCommand(oauth);
+    const request = oauth.commands.find(
+      (command) => command.name() === "request",
+    );
+    if (request) {
+      request.option("--json");
+    }
+    await program.parseAsync(["node", "test", "oauth", "request", ...args]);
+  } catch {
+    // Commander may throw under exitOverride for parse errors.
+  } finally {
+    process.stdout.write = originalWrite;
+  }
+
+  return {
+    stdout: Buffer.concat(chunks),
+    exitCode: Number(process.exitCode ?? 0),
+  };
+}
+
+describe("assistant oauth request", () => {
+  test("runs handleRequest in-process and does not call IPC", async () => {
+    const { stdout } = await runRequestCommand([
+      "--provider",
+      "google",
+      "-s",
+      "https://gmail.googleapis.com/gmail/v1/users/me/messages",
+    ]);
+
+    expect(ipcCalls).toEqual([]);
+    expect(handleRequestCalls).toEqual([
+      {
+        body: {
+          provider: "google",
+          url: "https://gmail.googleapis.com/gmail/v1/users/me/messages",
+        },
+      },
+    ]);
+    expect(stdout.toString("utf8")).toContain("hello");
+  });
+});
+
+describe("oauth request body encoding", () => {
+  const MULTIPART_BODY = [
+    "--boundary",
+    "Content-Type: application/json; charset=UTF-8",
+    "",
+    '{"name":"Sheet"}',
+    "--boundary--",
+    "",
+  ].join("\r\n");
+
+  const MULTIPART_HEADERS = {
+    "Content-Type": "multipart/related; boundary=boundary",
+  };
+
+  test("keeps a multipart body as the exact string it was given", async () => {
+    expect(readBodyData(MULTIPART_BODY, MULTIPART_HEADERS)).toBe(
+      MULTIPART_BODY,
+    );
+  });
+
+  test("parses a JSON body into an object", async () => {
+    expect(
+      readBodyData('{"name":"Sheet"}', {
+        "Content-Type": "application/json",
+      }),
+    ).toEqual({ name: "Sheet" });
+  });
+
+  test("parses a JSON body when no Content-Type is given", async () => {
+    expect(readBodyData('{"name":"Sheet"}', {})).toEqual({
+      name: "Sheet",
+    });
+  });
+
+  test("keeps a JSON-looking body raw under a non-JSON Content-Type", async () => {
+    expect(
+      readBodyData('{"name":"Sheet"}', { "content-type": "text/plain" }),
+    ).toBe('{"name":"Sheet"}');
+  });
+
+  test("keeps unparseable text raw when no Content-Type is given", async () => {
+    expect(readBodyData("not json at all", {})).toBe("not json at all");
+  });
+
+  test("reads a @file body under the caller's Content-Type", async () => {
+    const filePath = join(tempDir, "upload.txt");
+    writeFileSync(filePath, MULTIPART_BODY, "utf-8");
+
+    expect(readBodyData(`@${filePath}`, MULTIPART_HEADERS)).toBe(
+      MULTIPART_BODY,
+    );
+  });
+
+  test("forwards a multipart body to the route handler as a string", async () => {
+    const { exitCode } = await runRequestCommand([
+      "--provider",
+      "google",
+      "-s",
+      "-X",
+      "POST",
+      "-H",
+      "Content-Type: multipart/related; boundary=boundary",
+      "-d",
+      MULTIPART_BODY,
+      "https://www.googleapis.com/upload/drive/v3/files?uploadType=multipart",
+    ]);
+
+    expect(exitCode).toBe(0);
+    expect(handleRequestCalls).toEqual([
+      {
+        body: {
+          provider: "google",
+          url: "https://www.googleapis.com/upload/drive/v3/files?uploadType=multipart",
+          method: "POST",
+          headers: {
+            "Content-Type": "multipart/related; boundary=boundary",
+          },
+          parsed_data: MULTIPART_BODY,
+        },
+      },
+    ]);
+  });
+});
+
+describe("oauth request body output", () => {
+  beforeEach(() => {
+    handleRequestResult = {
+      ok: true,
+      status: 200,
+      headers: { "content-type": "application/octet-stream" },
+      body: PNG_MAGIC.toString("base64"),
+      bodyEncoding: "base64",
+    };
+  });
+
+  test("decodes a base64 envelope to raw bytes when writing a file", async () => {
+    const outputPath = join(tempDir, "drive.bin");
+    const { exitCode } = await runRequestCommand([
+      "--provider",
+      "google",
+      "-s",
+      "-o",
+      outputPath,
+      "https://www.googleapis.com/drive/v3/files/file-123?alt=media",
+    ]);
+
+    expect(exitCode).toBe(0);
+    expect(readFileSync(outputPath).equals(PNG_MAGIC)).toBe(true);
+  });
+
+  test("writes raw binary bytes to stdout without an extra newline", async () => {
+    const { stdout, exitCode } = await runRequestCommand([
+      "--provider",
+      "google",
+      "-s",
+      "https://www.googleapis.com/drive/v3/files/file-123?alt=media",
+    ]);
+
+    expect(exitCode).toBe(0);
+    expect(stdout.equals(PNG_MAGIC)).toBe(true);
+  });
+
+  test("keeps the encoded envelope in --json mode", async () => {
+    const { stdout, exitCode } = await runRequestCommand([
+      "--json",
+      "--provider",
+      "google",
+      "-s",
+      "https://www.googleapis.com/drive/v3/files/file-123?alt=media",
+    ]);
+
+    expect(exitCode).toBe(0);
+    const parsed = JSON.parse(stdout.toString("utf8")) as {
+      body: string;
+      bodyEncoding?: string;
+    };
+    expect(parsed.body).toBe(PNG_MAGIC.toString("base64"));
+    expect(parsed.bodyEncoding).toBe("base64");
+  });
+
+  test("writes text bodies as UTF-8 and appends a newline on stdout", async () => {
+    handleRequestResult = {
+      ok: true,
+      status: 200,
+      headers: { "content-type": "text/plain" },
+      body: "hello café",
+    };
+
+    const { stdout, exitCode } = await runRequestCommand([
+      "--provider",
+      "google",
+      "-s",
+      "https://www.googleapis.com/drive/v3/files/file-123",
+    ]);
+
+    expect(exitCode).toBe(0);
+    expect(stdout.toString("utf8")).toBe("hello café\n");
+  });
+});