@vellumai/cli 0.1.10 → 0.1.12

package/src/components/TextInput.tsx

@@ -0,0 +1,115 @@
+import { useRef, useState, type ReactElement } from "react";
+import chalk from "chalk";
+import { Text, useInput } from "ink";
+
+interface TextInputProps {
+  value: string;
+  onChange: (value: string) => void;
+  onSubmit?: (value: string) => void;
+  focus?: boolean;
+  placeholder?: string;
+}
+
+function TextInput({
+  value,
+  onChange,
+  onSubmit,
+  focus = true,
+  placeholder = "",
+}: TextInputProps): ReactElement {
+  const cursorOffsetRef = useRef(value.length);
+  const valueRef = useRef(value);
+
+  valueRef.current = value;
+
+  if (cursorOffsetRef.current > value.length) {
+    cursorOffsetRef.current = value.length;
+  }
+
+  const [, setRenderTick] = useState(0);
+
+  useInput(
+    (input, key) => {
+      if (
+        key.upArrow ||
+        key.downArrow ||
+        (key.ctrl && input === "c") ||
+        key.tab ||
+        (key.shift && key.tab)
+      ) {
+        return;
+      }
+
+      if (key.return) {
+        onSubmit?.(valueRef.current);
+        return;
+      }
+
+      const currentValue = valueRef.current;
+      const currentOffset = cursorOffsetRef.current;
+      let nextValue = currentValue;
+      let nextOffset = currentOffset;
+
+      if (key.leftArrow) {
+        nextOffset = Math.max(0, currentOffset - 1);
+      } else if (key.rightArrow) {
+        nextOffset = Math.min(currentValue.length, currentOffset + 1);
+      } else if (key.backspace || key.delete) {
+        if (currentOffset > 0) {
+          nextValue = currentValue.slice(0, currentOffset - 1) + currentValue.slice(currentOffset);
+          nextOffset = currentOffset - 1;
+        }
+      } else {
+        nextValue =
+          currentValue.slice(0, currentOffset) + input + currentValue.slice(currentOffset);
+        nextOffset = currentOffset + input.length;
+      }
+
+      cursorOffsetRef.current = nextOffset;
+
+      if (nextValue !== currentValue) {
+        valueRef.current = nextValue;
+        onChange(nextValue);
+      }
+
+      setRenderTick((t) => t + 1);
+    },
+    { isActive: focus },
+  );
+
+  const cursorOffset = cursorOffsetRef.current;
+  let renderedValue: string;
+  let renderedPlaceholder: string | undefined;
+
+  if (focus) {
+    renderedPlaceholder =
+      placeholder.length > 0
+        ? chalk.inverse(placeholder[0]) + chalk.grey(placeholder.slice(1))
+        : chalk.inverse(" ");
+
+    if (value.length > 0) {
+      renderedValue = "";
+      let i = 0;
+      for (const char of value) {
+        renderedValue += i === cursorOffset ? chalk.inverse(char) : char;
+        i++;
+      }
+      if (cursorOffset === value.length) {
+        renderedValue += chalk.inverse(" ");
+      }
+    } else {
+      renderedValue = chalk.inverse(" ");
+    }
+  } else {
+    renderedValue = value;
+    renderedPlaceholder = placeholder ? chalk.grey(placeholder) : undefined;
+  }
+
+  return (
+    <Text>
+      {placeholder ? (value.length > 0 ? renderedValue : renderedPlaceholder) : renderedValue}
+    </Text>
+  );
+}
+
+export default TextInput;

package/src/index.ts

@@ -1,5 +1,6 @@
 #!/usr/bin/env bun
 
+import { client } from "./commands/client";
 import { hatch } from "./commands/hatch";
 import { ps } from "./commands/ps";
 import { retire } from "./commands/retire";
@@ -7,6 +8,7 @@ import { sleep } from "./commands/sleep";
 import { wake } from "./commands/wake";
 
 const commands = {
+  client,
   hatch,
   ps,
   retire,
@@ -24,8 +26,9 @@ async function main() {
     console.log("Usage: vellum-cli <command> [options]");
     console.log("");
     console.log("Commands:");
+    console.log("  client   Connect to a hatched assistant");
     console.log("  hatch    Create a new assistant instance");
-    console.log("  ps       List assistants and their health status");
+    console.log("  ps       List assistants (or processes for a specific assistant)");
     console.log("  retire   Delete an assistant instance");
     console.log("  sleep    Stop the daemon process");
     console.log("  wake     Start the daemon and gateway");

package/src/lib/constants.ts

@@ -1,5 +1,5 @@
 export const FIREWALL_TAG = "vellum-assistant";
-export const GATEWAY_PORT = 7830;
+export const GATEWAY_PORT = process.env.GATEWAY_PORT ? Number(process.env.GATEWAY_PORT) : 7830;
 export const VALID_REMOTE_HOSTS = ["local", "gcp", "aws", "custom"] as const;
 export type RemoteHost = (typeof VALID_REMOTE_HOSTS)[number];
 export const VALID_SPECIES = ["openclaw", "vellum"] as const;

package/src/lib/doctor-client.ts

@@ -0,0 +1,127 @@
+const DOCTOR_URL = process.env.DOCTOR_URL || "https://doctor.vellum.ai";
+
+export type ProgressPhase= "invoking_prompt" | "calling_tool" | "processing_tool_result";
+
+export interface ProgressEvent {
+  phase: ProgressPhase;
+  toolName?: string;
+}
+
+interface DoctorResult {
+  assistantId: string;
+  diagnostics: string | null;
+  recommendation: string | null;
+  error: string | null;
+}
+
+export interface ChatLogEntry {
+  role: "user" | "assistant" | "error";
+  content: string;
+}
+
+type DoctorProgressCallback = (event: ProgressEvent) => void;
+type DoctorLogCallback = (message: string) => void;
+
+async function streamDoctorResponse(
+  response: globalThis.Response,
+  onProgress?: DoctorProgressCallback,
+  onLog?: DoctorLogCallback,
+): Promise<DoctorResult> {
+  if (!response.body) {
+    throw new Error(
+      `No response body from doctor (HTTP ${response.status} ${response.statusText})`,
+    );
+  }
+
+  let result: DoctorResult | null = null;
+  const decoder = new TextDecoder();
+  let buffer = "";
+  let chunkCount = 0;
+  const receivedEventTypes: string[] = [];
+
+  try {
+    for await (const chunk of response.body) {
+      chunkCount++;
+      buffer += decoder.decode(chunk, { stream: true });
+      const lines = buffer.split("\n");
+      buffer = lines.pop() ?? "";
+
+      for (const line of lines) {
+        if (!line.trim()) continue;
+        const parsed = JSON.parse(line) as { type: string } & Record<string, unknown>;
+        receivedEventTypes.push(parsed.type);
+        if (parsed.type === "progress") {
+          onProgress?.(parsed as unknown as ProgressEvent);
+        } else if (parsed.type === "log") {
+          onLog?.((parsed as unknown as { message: string }).message);
+        } else if (parsed.type === "result") {
+          result = parsed as unknown as DoctorResult;
+        }
+      }
+    }
+  } catch (streamErr) {
+    const detail = streamErr instanceof Error ? streamErr.message : String(streamErr);
+    throw new Error(
+      `Doctor stream interrupted after ${chunkCount} chunks ` +
+        `(received events: [${receivedEventTypes.join(", ")}]): ${detail}`,
+    );
+  }
+
+  if (buffer.trim()) {
+    const parsed = JSON.parse(buffer) as { type: string } & Record<string, unknown>;
+    receivedEventTypes.push(parsed.type);
+    if (parsed.type === "result") {
+      result = parsed as unknown as DoctorResult;
+    }
+  }
+
+  if (!result) {
+    throw new Error(
+      `No result received from doctor. ` +
+        `HTTP ${response.status}, ${chunkCount} chunks read, ` +
+        `events received: [${receivedEventTypes.join(", ")}], ` +
+        `trailing buffer: ${buffer.trim() ? JSON.stringify(buffer.trim().slice(0, 200)) : "(empty)"}`,
+    );
+  }
+
+  return result;
+}
+
+async function callDoctorDaemon(
+  assistantId: string,
+  project?: string,
+  zone?: string,
+  userPrompt?: string,
+  onProgress?: DoctorProgressCallback,
+  sessionId?: string,
+  chatContext?: ChatLogEntry[],
+  onLog?: DoctorLogCallback,
+): Promise<DoctorResult> {
+  const MAX_RETRIES = 2;
+  let lastError: unknown;
+
+  for (let attempt = 0; attempt < MAX_RETRIES; attempt++) {
+    try {
+      const response = await fetch(`${DOCTOR_URL}/doctor`, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({ assistantId, project, zone, userPrompt, sessionId, chatContext }),
+      });
+      return await streamDoctorResponse(response, onProgress, onLog);
+    } catch (err) {
+      lastError = err;
+      const errMsg = err instanceof Error ? err.message : String(err);
+      const logMsg =
+        `[doctor-client] Attempt ${attempt + 1}/${MAX_RETRIES} failed: ${errMsg}`;
+      onLog?.(logMsg);
+      if (attempt < MAX_RETRIES - 1) {
+        await new Promise((resolve) => setTimeout(resolve, 500));
+      }
+    }
+  }
+
+  throw lastError;
+}
+
+export { callDoctorDaemon };
+export type { DoctorProgressCallback, DoctorResult };