@pinixai/core 0.2.0 → 0.4.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pinixai/core",
-  "version": "0.2.0",
+  "version": "0.4.0",
   "description": "Clip framework for Pinix — define once, run as CLI / MCP / Pinix bridge",
   "main": "src/index.ts",
   "module": "src/index.ts",

package/src/handler.ts

@@ -1,15 +1,19 @@
 import { z, type ZodType } from "zod";
 
+export interface Stream {
+  chunk(data: unknown): void;
+}
+
 export interface HandlerDef<I extends ZodType = ZodType, O extends ZodType = ZodType> {
   input: I;
   output: O;
-  fn: (input: z.infer<I>) => Promise<z.infer<O>>;
+  fn: (input: z.infer<I>, stream?: Stream) => Promise<z.infer<O>>;
 }
 
 export function handler<I extends ZodType, O extends ZodType>(
   input: I,
   output: O,
-  fn: (input: z.infer<I>) => Promise<z.infer<O>>,
+  fn: (input: z.infer<I>, stream?: Stream) => Promise<z.infer<O>>,
 ): HandlerDef<I, O> {
   return { input, output, fn };
 }

package/src/index.ts

@@ -1,7 +1,7 @@
 export { Clip } from "./clip";
 export { command } from "./command";
-export { handler, type HandlerDef } from "./handler";
+export { handler, type HandlerDef, type Stream } from "./handler";
 export { serveHTTP } from "./http";
-export { serveIPC } from "./ipc";
+export { serveIPC, invoke } from "./ipc";
 export { serveMCP } from "./mcp";
 export { z } from "zod";

package/src/ipc.ts

@@ -1,160 +1,176 @@
-import type { z } from "zod";
 import type { Clip } from "./clip";
+import type { Stream } from "./handler";
+import { createIPCManifest } from "./manifest";
 
-type IPCRequest = {
-  id?: unknown;
-  command?: unknown;
-  input?: unknown;
-};
+// === IPC Protocol Types ===
 
-type IPCResponse =
-  | {
-      id: unknown;
-      output: unknown;
-    }
-  | {
-      id: unknown;
-      error: {
-        message: string;
-        code: string;
-      };
-    };
+type MessageType = "register" | "registered" | "invoke" | "result" | "error" | "chunk" | "done";
 
-function toErrorMessage(error: unknown): string {
-  return error instanceof Error ? error.message : String(error);
+interface BaseMessage {
+  type: MessageType;
+  id?: string;
 }
 
-function writeResponse(response: IPCResponse): void {
-  process.stdout.write(`${JSON.stringify(response)}\n`);
+interface RegisterMessage extends BaseMessage {
+  type: "register";
+  manifest: { name: string; domain: string; commands: string[]; dependencies: string[] };
 }
 
-function isObject(value: unknown): value is Record<string, unknown> {
-  return value !== null && typeof value === "object";
+interface InvokeMessage extends BaseMessage {
+  type: "invoke";
+  id: string;
+  command?: string;
+  clip?: string;
+  input?: unknown;
 }
 
-function createErrorResponse(id: unknown, message: string, code: string): IPCResponse {
-  return {
-    id,
-    error: {
-      message,
-      code,
-    },
-  };
+interface ResultMessage extends BaseMessage {
+  type: "result";
+  id: string;
+  output: unknown;
 }
 
-async function handleRequestLine(clip: Clip, line: string): Promise<void> {
-  let request: IPCRequest;
-
-  try {
-    request = JSON.parse(line) as IPCRequest;
-  } catch (error) {
-    writeResponse(createErrorResponse(null, `Invalid JSON: ${toErrorMessage(error)}`, "INVALID_JSON"));
-    return;
-  }
+interface ErrorMessage extends BaseMessage {
+  type: "error";
+  id: string;
+  error: string;
+}
 
-  const { id = null, command, input } = request;
+// === State ===
 
-  if (typeof command !== "string" || command.length === 0) {
-    writeResponse(createErrorResponse(id, "Request command must be a non-empty string", "INVALID_REQUEST"));
-    return;
-  }
+const pendingInvokes = new Map<string, { resolve: (v: unknown) => void; reject: (e: Error) => void }>();
+let idCounter = 0;
 
-  const commandHandler = clip.getCommands().get(command);
+function nextId(): string {
+  return `c${++idCounter}`;
+}
 
-  if (!commandHandler) {
-    writeResponse(createErrorResponse(id, `Unknown command: ${command}`, "COMMAND_NOT_FOUND"));
-    return;
-  }
+function send(msg: Record<string, unknown>): void {
+  process.stdout.write(JSON.stringify(msg) + "\n");
+}
 
-  if (!isObject(input)) {
-    writeResponse(createErrorResponse(id, "Request input must be an object", "INVALID_INPUT"));
-    return;
-  }
+// === Public API ===
 
-  try {
-    const parsedInput = await commandHandler.input.parseAsync(input) as z.infer<typeof commandHandler.input>;
-    const output = await commandHandler.fn(parsedInput);
-    const parsedOutput = await commandHandler.output.parseAsync(output);
-
-    writeResponse({
-      id,
-      output: parsedOutput,
-    });
-  } catch (error) {
-    writeResponse(createErrorResponse(id, toErrorMessage(error), "COMMAND_ERROR"));
-  }
+export async function invoke(clip: string, command: string, input: unknown): Promise<unknown> {
+  const id = nextId();
+  return new Promise((resolve, reject) => {
+    pendingInvokes.set(id, { resolve, reject });
+    send({ id, type: "invoke", clip, command, input });
+  });
 }
 
-function redirectConsoleLogToStderr(): void {
-  console.log = (...args: unknown[]) => {
-    const serialized = args
-      .map((arg) => {
-        if (typeof arg === "string") {
-          return arg;
-        }
-
-        try {
-          return JSON.stringify(arg);
-        } catch {
-          return String(arg);
-        }
-      })
-      .join(" ");
+// === IPC Server ===
 
-    process.stderr.write(`${serialized}\n`);
+export async function serveIPC(clip: Clip): Promise<void> {
+  // Redirect console.log to stderr so stdout is reserved for IPC
+  const origLog = console.log;
+  console.log = (...args: unknown[]) => {
+    process.stderr.write(args.map(String).join(" ") + "\n");
   };
-}
 
-export async function serveIPC(clip: Clip): Promise<void> {
-  redirectConsoleLogToStderr();
+  // Register with pinixd
+  const manifest = createIPCManifest(clip);
+  send({ type: "register", manifest });
+
+  // Read messages from stdin
+  const reader = createLineReader(process.stdin);
+  const commands = clip.getCommands();
+
+  for await (const line of reader) {
+    let msg: BaseMessage;
+    try {
+      msg = JSON.parse(line) as BaseMessage;
+    } catch {
+      process.stderr.write(`[ipc] invalid JSON: ${line}\n`);
+      continue;
+    }
 
-  const reader = Bun.stdin.stream().getReader();
-  const decoder = new TextDecoder();
-  let buffer = "";
+    if (!msg.type) {
+      process.stderr.write(`[ipc] message missing type: ${line}\n`);
+      continue;
+    }
 
-  try {
-    while (true) {
-      const { done, value } = await reader.read();
+    switch (msg.type) {
+      case "registered":
+        // Registration confirmed
+        break;
 
-      if (done) {
+      case "invoke": {
+        const inv = msg as InvokeMessage;
+        handleInvoke(inv, commands);
         break;
       }
 
-      buffer += decoder.decode(value, { stream: true });
-
-      while (true) {
-        const newlineIndex = buffer.indexOf("\n");
+      case "result": {
+        const res = msg as ResultMessage;
+        const pending = pendingInvokes.get(res.id);
+        if (pending) {
+          pendingInvokes.delete(res.id);
+          pending.resolve(res.output);
+        }
+        break;
+      }
 
-        if (newlineIndex === -1) {
-          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;
+      }
+
+      default:
+        process.stderr.write(`[ipc] unknown message type: ${msg.type}\n`);
+    }
+  }
+}
 
-        const line = buffer.slice(0, newlineIndex).trim();
-        buffer = buffer.slice(newlineIndex + 1);
+async function handleInvoke(
+  msg: InvokeMessage,
+  commands: ReturnType<Clip["getCommands"]>,
+): Promise<void> {
+  const cmd = commands.get(msg.command ?? "");
+  if (!cmd) {
+    send({ id: msg.id, type: "error", error: `unknown command: ${msg.command}` });
+    return;
+  }
 
-        if (line.length === 0) {
-          continue;
-        }
+  try {
+    const parsed = cmd.input.parse(msg.input ?? {});
+    let streamed = false;
+    const stream: Stream = {
+      chunk(data: unknown): void {
+        streamed = true;
+        send({ id: msg.id, type: "chunk", output: data });
+      },
+    };
 
-        try {
-          await handleRequestLine(clip, line);
-        } catch (error) {
-          writeResponse(createErrorResponse(null, toErrorMessage(error), "INTERNAL_ERROR"));
-        }
-      }
+    const output = await cmd.fn(parsed, stream);
+
+    if (streamed) {
+      send({ id: msg.id, type: "done" });
+      return;
     }
 
-    buffer += decoder.decode();
-    const tail = buffer.trim();
+    send({ id: msg.id, type: "result", output });
+  } catch (err) {
+    send({ id: msg.id, type: "error", error: err instanceof Error ? err.message : String(err) });
+  }
+}
 
-    if (tail.length > 0) {
-      try {
-        await handleRequestLine(clip, tail);
-      } catch (error) {
-        writeResponse(createErrorResponse(null, toErrorMessage(error), "INTERNAL_ERROR"));
-      }
+// === Line Reader ===
+
+async function* createLineReader(stream: NodeJS.ReadableStream): AsyncGenerator<string> {
+  let buffer = "";
+  for await (const chunk of stream) {
+    buffer += chunk.toString();
+    const lines = buffer.split("\n");
+    buffer = lines.pop() ?? "";
+    for (const line of lines) {
+      if (line.trim()) yield line;
     }
-  } finally {
-    reader.releaseLock();
   }
+  if (buffer.trim()) yield buffer;
 }

package/src/manifest.ts

@@ -1,6 +1,13 @@
 import { z, type ZodType } from "zod";
 import type { Clip } from "./clip";
 
+export interface IPCManifest {
+  name: string;
+  domain: string;
+  commands: string[];
+  dependencies: string[];
+}
+
 function formatLiteralValue(value: unknown): string {
   return JSON.stringify(value);
 }
@@ -139,3 +146,16 @@ export function generateManifest(clip: Clip): string {
 
   return lines.join("\n");
 }
+
+export function createIPCManifest(clip: Clip): IPCManifest {
+  const dependencies = (clip as Clip & { dependencies?: unknown }).dependencies;
+
+  return {
+    name: clip.name,
+    domain: clip.domain,
+    commands: Array.from(clip.getCommands().keys()),
+    dependencies: Array.isArray(dependencies)
+      ? dependencies.filter((dependency): dependency is string => typeof dependency === "string")
+      : [],
+  };
+}