@ricsam/r5d-worker 0.0.29 → 0.0.31

package/dist/mjs/process-tree.mjs

@@ -0,0 +1,93 @@
+const DEFAULT_TERMINATION_GRACE_MS = 2e3;
+const DEFAULT_FORCE_KILL_WAIT_MS = 2e3;
+const PROCESS_GROUP_POLL_INTERVAL_MS = 25;
+const processTerminations = /* @__PURE__ */ new WeakMap();
+function errorCode(error) {
+  if (!error || typeof error !== "object" || !("code" in error)) {
+    return void 0;
+  }
+  return typeof error.code === "string" ? error.code : void 0;
+}
+function delay(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+function isPosixProcessGroupRunning(processGroupId) {
+  try {
+    process.kill(-processGroupId, 0);
+    return true;
+  } catch (error) {
+    if (errorCode(error) === "ESRCH") {
+      return false;
+    }
+    if (errorCode(error) === "EPERM") {
+      return true;
+    }
+    throw error;
+  }
+}
+function signalPosixProcessGroup(processGroupId, signal) {
+  try {
+    process.kill(-processGroupId, signal);
+  } catch (error) {
+    if (errorCode(error) !== "ESRCH") {
+      throw error;
+    }
+  }
+}
+async function waitForPosixProcessGroupExit(processGroupId, timeoutMs) {
+  const deadline = Date.now() + Math.max(0, timeoutMs);
+  while (isPosixProcessGroupRunning(processGroupId)) {
+    const remainingMs = deadline - Date.now();
+    if (remainingMs <= 0) {
+      return false;
+    }
+    await delay(Math.min(PROCESS_GROUP_POLL_INTERVAL_MS, remainingMs));
+  }
+  return true;
+}
+async function runWindowsTaskkill(pid) {
+  const taskkill = Bun.spawn(["taskkill", "/PID", String(pid), "/T", "/F"], {
+    stdout: "ignore",
+    stderr: "pipe"
+  });
+  const [exitCode, stderr] = await Promise.all([
+    taskkill.exited,
+    taskkill.stderr ? new Response(taskkill.stderr).text() : Promise.resolve("")
+  ]);
+  if (exitCode !== 0 && !/not found|no running instance/i.test(stderr)) {
+    throw new Error(`Failed to terminate process tree ${pid}: ${stderr.trim() || `taskkill exited ${exitCode}`}`);
+  }
+}
+async function terminateProcessTreeOnce(subprocess, options) {
+  if (!Number.isSafeInteger(subprocess.pid) || subprocess.pid <= 0) {
+    throw new Error(`Cannot terminate invalid subprocess PID: ${subprocess.pid}`);
+  }
+  if (process.platform === "win32") {
+    await runWindowsTaskkill(subprocess.pid);
+    return;
+  }
+  const graceMs = options.graceMs ?? DEFAULT_TERMINATION_GRACE_MS;
+  const forceKillWaitMs = options.forceKillWaitMs ?? DEFAULT_FORCE_KILL_WAIT_MS;
+  signalPosixProcessGroup(subprocess.pid, "SIGTERM");
+  if (await waitForPosixProcessGroupExit(subprocess.pid, graceMs)) {
+    return;
+  }
+  signalPosixProcessGroup(subprocess.pid, "SIGKILL");
+  if (!await waitForPosixProcessGroupExit(subprocess.pid, forceKillWaitMs)) {
+    throw new Error(`Process group ${subprocess.pid} remained active after SIGKILL`);
+  }
+}
+function terminateProcessTree(subprocess, options = {}) {
+  const pending = processTerminations.get(subprocess);
+  if (pending) {
+    return pending;
+  }
+  const termination = terminateProcessTreeOnce(subprocess, options).finally(() => {
+    processTerminations.delete(subprocess);
+  });
+  processTerminations.set(subprocess, termination);
+  return termination;
+}
+export {
+  terminateProcessTree
+};

package/dist/types/main.d.ts

@@ -1,4 +1,16 @@
 #!/usr/bin/env bun
+type WorkerReadFileResult = {
+    type: "read";
+    kind: "text";
+    file: string;
+    gitBlobHash?: string;
+    content: string;
+    totalLines: number;
+    startLine: number;
+    endLine: number;
+    truncated: boolean;
+    continuation?: string;
+};
 type WorkerProjectManifestEntry = {
     projectId: string;
     repoSlug: string;
@@ -28,6 +40,34 @@ type WorkerRepositorySyncResult = {
         id: string;
     }>;
 };
+type WorkerGrepResult = {
+    type: "grep";
+    content: string;
+    matchCount: number;
+    truncated: boolean;
+};
+type WorkerFindResult = {
+    type: "find";
+    content: string;
+    count: number;
+    truncated: boolean;
+};
+type WorkerLsResult = {
+    type: "ls";
+    path: string;
+    content: string;
+    count: number;
+    truncated: boolean;
+};
+type WorkerViewFileBytesResult = {
+    type: "view_file_bytes";
+    filePath: string;
+    mediaType: "image/png" | "image/jpeg";
+    base64: string;
+    fileSizeBytes: number;
+    width: number;
+    height: number;
+};
 export declare function isArtifactEnvPath(filePath: string): boolean;
 export declare function syncSessionArtifacts(input: {
     baseUrl: string;
@@ -64,11 +104,21 @@ type GitAuth = {
     extraHeaderUrl: string;
     header: string;
 };
-export declare function resolveProjectFilePath(branchPath: string, virtualPath: string): {
+type ResolvedWorkerFilePath = {
     absolutePath: string;
-    virtualPath: string;
+    displayPath: string;
     repoRelativePath: string;
+    scope: "project";
+} | {
+    absolutePath: string;
+    displayPath: string;
+    repoRelativePath: null;
+    scope: "host";
 };
+export declare function resolveWorkerFilePath(branchPath: string, inputPath: string): ResolvedWorkerFilePath;
+export declare function resolveProjectFilePath(branchPath: string, inputPath: string): Extract<ResolvedWorkerFilePath, {
+    scope: "project";
+}>;
 export declare function ensureVisibleGitCheckout(input: {
     projectRoot: string;
     branchName: string;
@@ -99,6 +149,22 @@ export declare function syncManifestProjectsFromInternal(input: {
     manifests: WorkerProjectManifestEntry[];
     projectIds?: string[];
 }): Promise<WorkerRepositorySyncResult>;
+export declare function readWorkerTextFile(branchPath: string, filePath: string, offset?: number, limit?: number): WorkerReadFileResult;
+export declare function grepWorkerFiles(branchPath: string, input: {
+    pattern: string;
+    path?: string;
+    glob?: string;
+    caseSensitive?: boolean;
+    limit?: number;
+}): WorkerGrepResult;
+export declare function findWorkerFiles(branchPath: string, input: {
+    pattern?: string;
+    path?: string;
+    entryType?: string;
+    limit?: number;
+}): WorkerFindResult;
+export declare function listWorkerDirectory(branchPath: string, inputPath?: string, inputLimit?: number): WorkerLsResult;
+export declare function readWorkerImageFile(branchPath: string, filePath: string): WorkerViewFileBytesResult;
 export declare function resolveHostShell(command?: string, platform?: NodeJS.Platform): {
     file: string;
     args: string[];

package/dist/types/process-tree.d.ts

@@ -0,0 +1,16 @@
+export type KillableSubprocess = {
+    readonly pid: number;
+    readonly exited: Promise<number>;
+    kill(signal?: number | NodeJS.Signals): void;
+};
+type TerminateProcessTreeOptions = {
+    graceMs?: number;
+    forceKillWaitMs?: number;
+};
+/**
+ * Terminates a subprocess spawned with `detached: true` and every descendant
+ * that remains in its process group. Concurrent termination requests share one
+ * cleanup attempt.
+ */
+export declare function terminateProcessTree(subprocess: KillableSubprocess, options?: TerminateProcessTreeOptions): Promise<void>;
+export {};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ricsam/r5d-worker",
-  "version": "0.0.29",
+  "version": "0.0.31",
   "type": "module",
   "main": "./dist/cjs/main.cjs",
   "module": "./dist/mjs/main.mjs",