@pinixai/core 0.6.1 → 0.7.0

package/src/hub.ts

@@ -0,0 +1,70 @@
+import { createClient } from "@connectrpc/connect";
+import { createConnectTransport } from "@connectrpc/connect-web";
+import { HubService, type ClipInfo } from "./gen/hub_pb";
+
+const PINIX_URL = process.env.PINIX_URL ?? "http://127.0.0.1:9000";
+
+function getTransport(hubUrl?: string) {
+  return createConnectTransport({
+    baseUrl: hubUrl ?? PINIX_URL,
+  });
+}
+
+function getClient(hubUrl?: string) {
+  return createClient(HubService, getTransport(hubUrl));
+}
+
+const encoder = new TextEncoder();
+const decoder = new TextDecoder();
+
+/**
+ * Invoke a command on a remote clip via Hub's Connect-RPC Invoke RPC.
+ * The Invoke RPC is server-streaming: we collect all output chunks and return the aggregated result.
+ */
+export async function hubInvoke(
+  clipName: string,
+  command: string,
+  input: unknown,
+  clipToken?: string,
+  hubUrl?: string,
+): Promise<unknown> {
+  const client = getClient(hubUrl);
+  const inputBytes = encoder.encode(JSON.stringify(input));
+
+  let outputBytes = new Uint8Array(0);
+
+  for await (const response of client.invoke({
+    clipName,
+    command,
+    input: inputBytes,
+    clipToken: clipToken ?? "",
+  })) {
+    if (response.error) {
+      throw new Error(response.error.message || response.error.code || "Hub invoke error");
+    }
+
+    if (response.output.length > 0) {
+      // Aggregate output chunks
+      const merged = new Uint8Array(outputBytes.length + response.output.length);
+      merged.set(outputBytes);
+      merged.set(response.output, outputBytes.length);
+      outputBytes = merged;
+    }
+  }
+
+  if (outputBytes.length === 0) {
+    return undefined;
+  }
+
+  const outputJson = decoder.decode(outputBytes);
+  return JSON.parse(outputJson) as unknown;
+}
+
+/**
+ * List all clips registered on the Hub.
+ */
+export async function hubListClips(hubUrl?: string): Promise<ClipInfo[]> {
+  const client = getClient(hubUrl);
+  const response = await client.listClips({});
+  return response.clips;
+}

package/src/index.ts

@@ -3,6 +3,7 @@ export type { Binding, Bindings } from "./bindings";
 export { command } from "./command";
 export { handler, type HandlerDef, type Stream } from "./handler";
 export { serveHTTP } from "./http";
+export { hubListClips } from "./hub";
 export { serveIPC, invoke, redirectConsoleToStderr } from "./ipc";
 export type { IPCCommandInfo, IPCManifest } from "./manifest";
 export { serveMCP } from "./mcp";

package/src/ipc.ts

@@ -4,11 +4,12 @@ import { StringDecoder } from "node:string_decoder";
 import type { Binding, Bindings } from "./bindings";
 import type { Clip } from "./clip";
 import type { Stream } from "./handler";
+import { hubInvoke } from "./hub";
 import { createIPCManifest, type IPCManifest } from "./manifest";
 
 // === IPC Protocol Types ===
 
-type MessageType = "register" | "registered" | "invoke" | "result" | "error" | "chunk" | "done";
+type MessageType = "register" | "registered" | "invoke";
 
 interface BaseMessage {
   type: MessageType;
@@ -36,33 +37,8 @@ interface InvokeMessage extends BaseMessage {
   clip_token?: string;
 }
 
-interface ResultMessage extends BaseMessage {
-  type: "result";
-  id: string;
-  output: unknown;
-}
-
-interface ErrorMessage extends BaseMessage {
-  type: "error";
-  id: string;
-  error: string;
-}
-
-interface ChunkMessage extends BaseMessage {
-  type: "chunk";
-  id: string;
-  output: unknown;
-}
-
-interface DoneMessage extends BaseMessage {
-  type: "done";
-  id: string;
-}
-
 // === State ===
 
-const pendingInvokes = new Map<string, { resolve: (v: unknown) => void; reject: (e: Error) => void }>();
-let idCounter = 0;
 let registeredAlias: string | undefined;
 const bindings = loadBindings();
 
@@ -126,10 +102,6 @@ function asNonEmptyString(value: unknown): string | undefined {
   return typeof value === "string" && value.length > 0 ? value : undefined;
 }
 
-function nextId(): string {
-  return `c${++idCounter}`;
-}
-
 function send(msg: Record<string, unknown>): void {
   process.stdout.write(JSON.stringify(msg) + "\n");
 }
@@ -138,21 +110,11 @@ function send(msg: Record<string, unknown>): void {
 
 export async function invoke(slot: string, command: string, input: unknown): Promise<unknown> {
   const binding = bindings[slot];
-  const id = nextId();
-
-  return new Promise((resolve, reject) => {
-    pendingInvokes.set(id, { resolve, reject });
-    send({
-      id,
-      type: "invoke",
-      clip: binding?.alias ?? slot,
-      command,
-      input,
-      hub: binding?.hub,
-      hub_token: binding?.hub_token,
-      clip_token: binding?.clip_token,
-    });
-  });
+  const clipName = binding?.alias ?? slot;
+  const clipToken = binding?.clip_token;
+  const hubUrl = binding?.hub;
+
+  return hubInvoke(clipName, command, input, clipToken, hubUrl);
 }
 
 // === Stdout Protection ===
@@ -232,53 +194,12 @@ export async function serveIPC(clip: Clip): Promise<void> {
         break;
       }
 
-      case "result": {
-        const res = msg as ResultMessage;
-        const pending = pendingInvokes.get(res.id);
-        if (pending) {
-          pendingInvokes.delete(res.id);
-          pending.resolve(res.output);
-        }
-        break;
-      }
-
-      case "error": {
-        const err = msg as ErrorMessage;
-        const pending = pendingInvokes.get(err.id);
-        if (pending) {
-          pendingInvokes.delete(err.id);
-          pending.reject(new Error(err.error));
-        }
-        break;
-      }
-
-      case "chunk": {
-        // Streaming chunks — currently ignored on client side
-        // Future: could accumulate or forward to a stream callback
-        break;
-      }
-
-      case "done": {
-        const done = msg as DoneMessage;
-        const pending = pendingInvokes.get(done.id);
-        if (pending) {
-          pendingInvokes.delete(done.id);
-          pending.resolve(undefined);
-        }
-        break;
-      }
-
       default:
         process.stderr.write(`[ipc] unknown message type: ${msg.type}\n`);
     }
   }
 
-  // Clean up pending invokes on EOF
   clearIdleTimer();
-  for (const [id, pending] of pendingInvokes) {
-    pending.reject(new Error("IPC connection closed"));
-  }
-  pendingInvokes.clear();
 }
 
 async function handleInvoke(