@pinixai/core 0.5.0 → 0.6.0

package/package.json

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

package/src/clip.ts

@@ -25,6 +25,14 @@ export abstract class Clip {
   dependencies: Record<string, { package: string; version: string }> = {};
   entities: Record<string, z.ZodObject<any>> = {};
 
+  /**
+   * How long (ms) the process stays alive after the last invoke completes.
+   * - `30_000` (default): exit after 30s idle
+   * - `0`: exit immediately after each invoke
+   * - `Infinity`: never exit (persistent)
+   */
+  idleTimeout: number = 30_000;
+
   protected readonly commands = new Map<string, HandlerDef>();
   protected readonly commandDescriptions = new Map<string, string>();
 

package/src/index.ts

@@ -4,6 +4,6 @@ export { command } from "./command";
 export { handler, type HandlerDef, type Stream } from "./handler";
 export { serveHTTP } from "./http";
 export { serveIPC, invoke, redirectConsoleToStderr } from "./ipc";
-export type { IPCManifest } from "./manifest";
+export type { IPCCommandInfo, IPCManifest } from "./manifest";
 export { serveMCP } from "./mcp";
 export { z } from "zod";

package/src/ipc.ts

@@ -176,10 +176,32 @@ export async function serveIPC(clip: Clip): Promise<void> {
   const manifest = createIPCManifest(clip);
   send({ type: "register", manifest });
 
+  // Idle timeout management
+  const idleTimeout = (clip as Clip & { idleTimeout?: number }).idleTimeout ?? 30_000;
+  let inflight = 0;
+  let idleTimer: ReturnType<typeof setTimeout> | null = null;
+
+  function clearIdleTimer(): void {
+    if (idleTimer !== null) {
+      clearTimeout(idleTimer);
+      idleTimer = null;
+    }
+  }
+
+  function resetIdleTimer(): void {
+    clearIdleTimer();
+    if (inflight > 0) return;
+    if (!Number.isFinite(idleTimeout) || idleTimeout < 0) return;
+    idleTimer = setTimeout(() => process.exit(0), idleTimeout);
+  }
+
   // Read messages from stdin
   const reader = createLineReader(process.stdin);
   const commands = clip.getCommands();
 
+  // Start idle timer after registration
+  resetIdleTimer();
+
   for await (const line of reader) {
     let msg: BaseMessage;
     try {
@@ -200,8 +222,13 @@ export async function serveIPC(clip: Clip): Promise<void> {
         break;
 
       case "invoke": {
+        clearIdleTimer();
+        inflight++;
         const inv = msg as InvokeMessage;
-        handleInvoke(inv, commands);
+        handleInvoke(inv, commands).finally(() => {
+          inflight--;
+          resetIdleTimer();
+        });
         break;
       }
 
@@ -247,6 +274,7 @@ export async function serveIPC(clip: Clip): Promise<void> {
   }
 
   // Clean up pending invokes on EOF
+  clearIdleTimer();
   for (const [id, pending] of pendingInvokes) {
     pending.reject(new Error("IPC connection closed"));
   }

package/src/manifest.ts

@@ -3,10 +3,17 @@ import { dirname, join } from "node:path";
 import { z, type ZodType } from "zod";
 import { getClipName, type Clip } from "./clip";
 
+export interface IPCCommandInfo {
+  name: string;
+  description?: string;
+  input?: string;
+  output?: string;
+}
+
 export interface IPCManifest {
   domain: string;
   description?: string;
-  commands: string[];
+  commands: IPCCommandInfo[];
   dependencies: Record<string, { package: string; version: string }>;
   package?: string;
   version?: string;
@@ -183,9 +190,26 @@ function asString(value: unknown): string | undefined {
 export function createIPCManifest(clip: Clip): IPCManifest {
   const pkgInfo = resolvePackageInfo();
 
+  const commands: IPCCommandInfo[] = [];
+
+  for (const [name, handler] of clip.getCommands()) {
+    const description = clip.getCommandDescription(name);
+    const cmd: IPCCommandInfo = { name };
+    if (description) cmd.description = description;
+
+    try {
+      cmd.input = JSON.stringify(z.toJSONSchema(handler.input));
+    } catch {}
+    try {
+      cmd.output = JSON.stringify(z.toJSONSchema(handler.output));
+    } catch {}
+
+    commands.push(cmd);
+  }
+
   return {
     domain: clip.domain,
-    commands: Array.from(clip.getCommands().keys()),
+    commands,
     dependencies: clip.dependencies,
     ...pkgInfo,
   };