@rigkit/runtime-client 0.2.6 → 0.2.8

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rigkit/runtime-client",
-  "version": "0.2.6",
+  "version": "0.2.8",
   "type": "module",
   "repository": {
     "type": "git",

package/src/api.ts

@@ -18,6 +18,7 @@ export const RuntimeControlHealthEffectSchema = Schema.Struct({
   projectDir: Schema.String,
   configPath: Schema.String,
   statePath: OptionalString,
+  globalFragmentRoot: OptionalString,
   engineVersion: Schema.String,
   runtimeVersion: Schema.String,
   expiresAt: Schema.String,
@@ -99,6 +100,41 @@ export const RuntimeControlSnapshotsResponseEffectSchema = Schema.Struct({
   snapshots: Schema.Array(Schema.Unknown),
 }).annotations({ identifier: "SnapshotsResponse" });
 
+export const RuntimeControlCacheEntryEffectSchema = Schema.Struct({
+  scope: Schema.Literal("local", "global"),
+  workflow: Schema.String,
+  nodePath: Schema.String,
+  nodeName: Schema.String,
+  nodeKind: Schema.String,
+  runId: Schema.String,
+  invalidated: Schema.Boolean,
+  createdAt: Schema.String,
+  fragmentHash: Schema.optional(Schema.String),
+}).annotations({ identifier: "CacheEntry" });
+
+export const RuntimeControlCacheResponseEffectSchema = Schema.Struct({
+  entries: Schema.Array(RuntimeControlCacheEntryEffectSchema),
+}).annotations({ identifier: "CacheResponse" });
+
+export const RuntimeControlCacheClearRequestEffectSchema = Schema.Struct({
+  scope: Schema.optional(Schema.Literal("local", "global", "all")),
+}).annotations({ identifier: "CacheClearRequest" });
+
+export const RuntimeControlCacheClearResponseEffectSchema = Schema.Struct({
+  ok: Schema.Boolean,
+  deleted: Schema.Number,
+}).annotations({ identifier: "CacheClearResponse" });
+
+export const RuntimeControlCacheInvalidateRequestEffectSchema = Schema.Struct({
+  workflow: Schema.optional(Schema.String),
+  nodePaths: Schema.optional(Schema.Array(Schema.String)),
+}).annotations({ identifier: "CacheInvalidateRequest" });
+
+export const RuntimeControlCacheInvalidateResponseEffectSchema = Schema.Struct({
+  ok: Schema.Boolean,
+  invalidated: Schema.Number,
+}).annotations({ identifier: "CacheInvalidateResponse" });
+
 export const RuntimeControlRunEffectSchema = Schema.Struct({
   runId: Schema.String,
   operation: Schema.String,
@@ -157,6 +193,12 @@ export type RuntimeControlWorkflowsResponse = Schema.Schema.Type<typeof RuntimeC
 export type RuntimeControlWorkspace = Schema.Schema.Type<typeof RuntimeControlWorkspaceEffectSchema>;
 export type RuntimeControlWorkspacesResponse = Schema.Schema.Type<typeof RuntimeControlWorkspacesResponseEffectSchema>;
 export type RuntimeControlSnapshotsResponse = Schema.Schema.Type<typeof RuntimeControlSnapshotsResponseEffectSchema>;
+export type RuntimeControlCacheEntry = Schema.Schema.Type<typeof RuntimeControlCacheEntryEffectSchema>;
+export type RuntimeControlCacheResponse = Schema.Schema.Type<typeof RuntimeControlCacheResponseEffectSchema>;
+export type RuntimeControlCacheClearRequest = Schema.Schema.Type<typeof RuntimeControlCacheClearRequestEffectSchema>;
+export type RuntimeControlCacheClearResponse = Schema.Schema.Type<typeof RuntimeControlCacheClearResponseEffectSchema>;
+export type RuntimeControlCacheInvalidateRequest = Schema.Schema.Type<typeof RuntimeControlCacheInvalidateRequestEffectSchema>;
+export type RuntimeControlCacheInvalidateResponse = Schema.Schema.Type<typeof RuntimeControlCacheInvalidateResponseEffectSchema>;
 export type RuntimeControlRunOperationRequest = Schema.Schema.Type<typeof RuntimeControlRunOperationRequestEffectSchema>;
 export type RuntimeControlRun = Schema.Schema.Type<typeof RuntimeControlRunEffectSchema>;
 export type RuntimeControlRunsResponse = Schema.Schema.Type<typeof RuntimeControlRunsResponseEffectSchema>;
@@ -180,6 +222,13 @@ export const runtimeControlApi = HttpApi.make("rigkit-runtime")
       .add(HttpApiEndpoint.get("workflows", "/workflows").addSuccess(RuntimeControlWorkflowsResponseEffectSchema))
       .add(HttpApiEndpoint.get("workspaces", "/workspaces").addSuccess(RuntimeControlWorkspacesResponseEffectSchema))
       .add(HttpApiEndpoint.get("snapshots", "/snapshots").addSuccess(RuntimeControlSnapshotsResponseEffectSchema))
+      .add(HttpApiEndpoint.get("cache", "/cache").addSuccess(RuntimeControlCacheResponseEffectSchema))
+      .add(HttpApiEndpoint.post("clearCache", "/cache/clear")
+        .setPayload(RuntimeControlCacheClearRequestEffectSchema)
+        .addSuccess(RuntimeControlCacheClearResponseEffectSchema))
+      .add(HttpApiEndpoint.post("invalidateCache", "/cache/invalidate")
+        .setPayload(RuntimeControlCacheInvalidateRequestEffectSchema)
+        .addSuccess(RuntimeControlCacheInvalidateResponseEffectSchema))
       .add(HttpApiEndpoint.get("runs", "/runs").addSuccess(RuntimeControlRunsResponseEffectSchema))
       .add(HttpApiEndpoint.post("startRun", "/runs")
         .setPayload(RuntimeControlRunOperationRequestEffectSchema)

package/src/client.ts

@@ -22,6 +22,11 @@ import {
   runtimeControlApi,
   type RuntimeControlHealth,
   type RuntimeControlHostResponse,
+  type RuntimeControlCacheClearRequest,
+  type RuntimeControlCacheClearResponse,
+  type RuntimeControlCacheInvalidateRequest,
+  type RuntimeControlCacheInvalidateResponse,
+  type RuntimeControlCacheResponse,
   type RuntimeControlMetadata,
   type RuntimeControlOkResponse,
   type RuntimeControlOperationsManifest,
@@ -49,6 +54,9 @@ export type RuntimeHttpClient = {
   workflows(): Promise<RuntimeControlWorkflowsResponse>;
   workspaces(): Promise<RuntimeControlWorkspacesResponse>;
   snapshots(): Promise<RuntimeControlSnapshotsResponse>;
+  cache(): Promise<RuntimeControlCacheResponse>;
+  clearCache(body: RuntimeControlCacheClearRequest): Promise<RuntimeControlCacheClearResponse>;
+  invalidateCache(body: RuntimeControlCacheInvalidateRequest): Promise<RuntimeControlCacheInvalidateResponse>;
   runs(): Promise<RuntimeControlRunsResponse>;
   startRun(body: RuntimeControlRunOperationRequest): Promise<RuntimeControlRunStarted>;
   run(runId: string): Promise<RuntimeControlRun>;
@@ -125,6 +133,21 @@ function makeRuntimeHttpClient(options: RuntimeHttpClientOptions): RuntimeHttpCl
         method: "GET",
         path: "/snapshots",
       }),
+    cache: () =>
+      runRuntimeHttpRequest(withRuntimeControlClient(options, (client) => client.cache({ withResponse: true })), {
+        method: "GET",
+        path: "/cache",
+      }),
+    clearCache: (body) =>
+      runRuntimeHttpRequest(
+        withRuntimeControlClient(options, (client) => client.clearCache({ payload: body, withResponse: true })),
+        { method: "POST", path: "/cache/clear" },
+      ),
+    invalidateCache: (body) =>
+      runRuntimeHttpRequest(
+        withRuntimeControlClient(options, (client) => client.invalidateCache({ payload: body, withResponse: true })),
+        { method: "POST", path: "/cache/invalidate" },
+      ),
     runs: () =>
       runRuntimeHttpRequest(withRuntimeControlClient(options, (client) => client.runs({ withResponse: true })), {
         method: "GET",

package/src/index.ts

@@ -31,6 +31,10 @@ export {
   RuntimeControlOperationCliEffectSchema,
   RuntimeControlOperationEffectSchema,
   RuntimeControlOperationsManifestEffectSchema,
+  RuntimeControlCacheEntryEffectSchema,
+  RuntimeControlCacheResponseEffectSchema,
+  RuntimeControlCacheClearRequestEffectSchema,
+  RuntimeControlCacheClearResponseEffectSchema,
   RuntimeControlProjectInfoEffectSchema,
   RuntimeControlRunEffectSchema,
   RuntimeControlRunOperationRequestEffectSchema,
@@ -49,6 +53,10 @@ export {
   type RuntimeControlOperation,
   type RuntimeControlOperationCli,
   type RuntimeControlOperationsManifest,
+  type RuntimeControlCacheEntry,
+  type RuntimeControlCacheResponse,
+  type RuntimeControlCacheClearRequest,
+  type RuntimeControlCacheClearResponse,
   type RuntimeControlProjectInfo,
   type RuntimeControlRun,
   type RuntimeControlRunOperationRequest,

package/src/manager.ts

@@ -1,4 +1,4 @@
-import { chmodSync, existsSync, mkdirSync, readFileSync, readdirSync, rmSync, statSync, writeFileSync } from "node:fs";
+import { chmodSync, closeSync, existsSync, mkdirSync, openSync, readFileSync, readdirSync, realpathSync, rmSync, statSync, writeFileSync } from "node:fs";
 import { spawn, type ChildProcessByStdio } from "node:child_process";
 import { createHash, randomUUID } from "node:crypto";
 import { dirname, join, resolve } from "node:path";
@@ -34,6 +34,7 @@ export type RuntimeProjectOptions = {
   projectDir: string;
   configPath: string;
   statePath?: string;
+  globalFragmentRoot?: string;
   source?: unknown;
 };
 
@@ -67,6 +68,9 @@ export type RuntimePaths = {
   handlePath: string;
   tokenPath: string;
   lockPath: string;
+  // Where the daemon's stderr is captured. The CLI tails this on run failure
+  // so users see real stack traces instead of "Internal server error".
+  runtimeLogPath: string;
 };
 
 const DEFAULT_IDLE_MS = 30 * 60 * 1000;
@@ -87,6 +91,9 @@ async function getOrStartRuntimeUnsafe(options: GetOrStartRuntimeOptions): Promi
   const projectDir = resolve(options.projectDir);
   const configPath = resolve(options.configPath);
   const statePath = options.statePath ? resolve(options.statePath) : undefined;
+  const globalFragmentRoot = options.globalFragmentRoot
+    ? resolve(options.globalFragmentRoot)
+    : join(options.rigkitHome ?? defaultRigkitHome(), "fragments");
   const projectId = projectIdFor({
     projectDir,
     configPath,
@@ -97,6 +104,7 @@ async function getOrStartRuntimeUnsafe(options: GetOrStartRuntimeOptions): Promi
     projectDir,
     configPath,
     statePath,
+    ...(options.globalFragmentRoot ? { globalFragmentRoot } : {}),
     source: options.source,
   });
   const paths = runtimePaths(projectId, options.rigkitHome);
@@ -112,6 +120,7 @@ async function getOrStartRuntimeUnsafe(options: GetOrStartRuntimeOptions): Promi
       projectDir,
       configPath,
       statePath,
+      globalFragmentRoot,
       projectId,
       runtimeFingerprint,
       paths,
@@ -145,6 +154,7 @@ export function runtimeFingerprintFor(options: RuntimeProjectOptions): string {
   const projectDir = resolve(options.projectDir);
   const configPath = resolve(options.configPath);
   const statePath = options.statePath ? resolve(options.statePath) : null;
+  const globalFragmentRoot = options.globalFragmentRoot ? resolve(options.globalFragmentRoot) : null;
   const hash = createHash("sha256");
 
   hash.update("project\0");
@@ -153,6 +163,8 @@ export function runtimeFingerprintFor(options: RuntimeProjectOptions): string {
   hash.update(configPath);
   hash.update("\0state\0");
   hash.update(statePath ?? "");
+  hash.update("\0global-fragment-root\0");
+  hash.update(globalFragmentRoot ?? "");
   hash.update("\0source\0");
   hash.update(JSON.stringify(options.source ?? null));
 
@@ -172,6 +184,7 @@ export function runtimePaths(projectId: string, rigkitHome = defaultRigkitHome()
     handlePath: join(root, `${projectId}.json`),
     tokenPath: join(root, `${projectId}.token`),
     lockPath: join(root, `${projectId}.lock`),
+    runtimeLogPath: join(root, `${projectId}.log`),
   };
 }
 
@@ -248,13 +261,22 @@ async function startRuntime(input: GetOrStartRuntimeOptions & {
     String(input.idleMs ?? DEFAULT_IDLE_MS),
   ];
   if (input.statePath) args.push("--state", input.statePath);
+  if (input.globalFragmentRoot) args.push("--global-fragment-root", input.globalFragmentRoot);
   if (input.source !== undefined) args.push("--source-json", JSON.stringify(input.source));
 
+  mkdirSync(input.paths.root, { recursive: true });
+  const stderrFd = openSync(input.paths.runtimeLogPath, "a");
   const proc = spawn(runtimeBin, args, {
     detached: true,
-    stdio: ["ignore", "pipe", "inherit"],
+    stdio: ["ignore", "pipe", stderrFd],
     env: process.env,
-  });
+  }) as ChildProcessByStdio<null, Readable, null>;
+  // The child inherits the fd; the parent can release its own handle.
+  try {
+    closeSync(stderrFd);
+  } catch {
+    // best-effort
+  }
 
   const line = await readReadyLine(proc, input.paths, input.projectDir);
   let ready: ReturnType<typeof RuntimeReadySchema.parse>;
@@ -535,16 +557,38 @@ function updateProjectSurfaceFingerprint(hash: ReturnType<typeof createHash>, pr
 }
 
 function updateRigkitPackageFingerprint(hash: ReturnType<typeof createHash>, scopeDir: string): void {
-  if (!existsSync(scopeDir)) return;
-  const packageDirs = readdirSync(scopeDir, { withFileTypes: true })
-    .filter((entry) => entry.isDirectory() || entry.isSymbolicLink())
-    .map((entry) => join(scopeDir, entry.name))
-    .sort();
-
-  for (const packageDir of packageDirs) {
-    updateFileFingerprint(hash, "rigkit-package", join(packageDir, "package.json"));
-    for (const file of collectFiles(join(packageDir, "src"))) {
-      updateFileFingerprint(hash, "rigkit-source", file);
+  // Walk every @rigkit scope reachable from the project's node_modules. We
+  // recurse into each package's own `node_modules/@rigkit` so that nested
+  // installs (e.g. @rigkit/engine living under @rigkit/sdk/node_modules) are
+  // hashed too. Without this, edits to a transitive @rigkit package wouldn't
+  // shift the runtime fingerprint and the daemon wouldn't auto-restart.
+  const visited = new Set<string>();
+  const stack: string[] = [scopeDir];
+
+  while (stack.length > 0) {
+    const dir = stack.pop()!;
+    if (!existsSync(dir)) continue;
+    let canonical: string;
+    try {
+      canonical = realpathSync(dir);
+    } catch {
+      continue;
+    }
+    if (visited.has(canonical)) continue;
+    visited.add(canonical);
+
+    const packageDirs = readdirSync(dir, { withFileTypes: true })
+      .filter((entry) => entry.isDirectory() || entry.isSymbolicLink())
+      .map((entry) => join(dir, entry.name))
+      .sort();
+
+    for (const packageDir of packageDirs) {
+      updateFileFingerprint(hash, "rigkit-package", join(packageDir, "package.json"));
+      for (const file of collectFiles(join(packageDir, "src"))) {
+        updateFileFingerprint(hash, "rigkit-source", file);
+      }
+      // Recurse into this package's own @rigkit scope, if it has nested deps.
+      stack.push(join(packageDir, "node_modules", "@rigkit"));
     }
   }
 }

package/src/schemas.ts

@@ -42,6 +42,7 @@ export const RuntimeHandleEffectSchema = Schema.Struct({
   projectDir: Schema.String,
   configPath: Schema.String,
   statePath: Schema.optional(Schema.String),
+  globalFragmentRoot: Schema.optional(Schema.String),
   pid: Schema.Int,
   url: Schema.String,
   tokenPath: Schema.String,
@@ -64,6 +65,7 @@ export const RuntimeHealthEffectSchema = Schema.Struct({
   projectDir: Schema.optional(Schema.String),
   configPath: Schema.optional(Schema.String),
   statePath: Schema.optional(Schema.String),
+  globalFragmentRoot: Schema.optional(Schema.String),
   engineVersion: Schema.optional(Schema.String),
   runtimeVersion: Schema.optional(Schema.String),
   expiresAt: Schema.optional(Schema.String),

package/src/version.ts

@@ -1 +1 @@
-export const RIGKIT_RUNTIME_CLIENT_VERSION = "0.2.6";
+export const RIGKIT_RUNTIME_CLIENT_VERSION = "0.2.8";