terminal-commands 0.1.1 → 0.1.3

package/dist/index.js

@@ -18390,11 +18390,11 @@ var require_parse = __commonJS({
         segments[segments.length] = parent;
       }
       var n = key.length;
-      var open2 = first;
+      var open3 = first;
       var collected = 0;
-      while (open2 >= 0 && collected < options.depth) {
+      while (open3 >= 0 && collected < options.depth) {
         var level = 1;
-        var i = open2 + 1;
+        var i = open3 + 1;
         var close = -1;
         while (i < n && close < 0) {
           var cu = key.charCodeAt(i);
@@ -18409,23 +18409,23 @@ var require_parse = __commonJS({
           i += 1;
         }
         if (close < 0) {
-          segments[segments.length] = "[" + key.slice(open2) + "]";
+          segments[segments.length] = "[" + key.slice(open3) + "]";
           return segments;
         }
-        var seg = key.slice(open2, close + 1);
+        var seg = key.slice(open3, close + 1);
         var content = seg.slice(1, -1);
         if (!options.plainObjects && has.call(Object.prototype, content) && !options.allowPrototypes) {
           return;
         }
         segments[segments.length] = seg;
         collected += 1;
-        open2 = key.indexOf("[", close + 1);
+        open3 = key.indexOf("[", close + 1);
       }
-      if (open2 >= 0) {
+      if (open3 >= 0) {
         if (options.strictDepth === true) {
           throw new RangeError("Input depth exceeded depth option of " + options.depth + " and strictDepth is true");
         }
-        segments[segments.length] = "[" + key.slice(open2) + "]";
+        segments[segments.length] = "[" + key.slice(open3) + "]";
       }
       return segments;
     };
@@ -54524,7 +54524,7 @@ var StreamableHTTPServerTransport = class {
 };
 
 // src/server.ts
-import { readFile, readdir, writeFile } from "node:fs/promises";
+import { readdir, writeFile } from "node:fs/promises";
 
 // node_modules/zod/v3/helpers/util.js
 var util;
@@ -62498,9 +62498,30 @@ var EMPTY_COMPLETION_RESULT = {
   }
 };
 
-// src/runner.ts
-import { execFile } from "node:child_process";
-import { promisify } from "node:util";
+// src/file-reader.ts
+import { open as open2 } from "node:fs/promises";
+async function readBoundedTextFile(filename, maxCharacters) {
+  const handle = await open2(filename, "r");
+  try {
+    const stats = await handle.stat();
+    const buffer = Buffer.allocUnsafe(maxCharacters * 4 + 4);
+    const { bytesRead } = await handle.read(buffer, 0, buffer.length, 0);
+    const hasUnreadBytes = bytesRead < stats.size;
+    const decoded = new TextDecoder().decode(buffer.subarray(0, bytesRead), {
+      stream: hasUnreadBytes
+    });
+    return {
+      contents: decoded.slice(0, maxCharacters),
+      truncated: hasUnreadBytes || decoded.length > maxCharacters
+    };
+  } finally {
+    await handle.close();
+  }
+}
+
+// src/process-manager.ts
+import { randomUUID } from "node:crypto";
+import { spawn } from "node:child_process";
 
 // src/security.ts
 import { constants as constants2 } from "node:fs";
@@ -62590,38 +62611,144 @@ function assertProgramAllowed(program) {
   }
 }
 
-// src/runner.ts
-var execFileAsync = promisify(execFile);
-async function runProgram(options) {
-  assertProgramAllowed(options.program);
-  try {
-    const { stdout, stderr } = await execFileAsync(
-      options.program,
-      options.args,
-      {
-        cwd: options.cwd,
-        env: safeEnvironment(),
-        encoding: "utf8",
-        maxBuffer: options.maxOutputChars,
-        timeout: options.timeoutMs,
-        windowsHide: true
-      }
+// src/process-manager.ts
+function appendBounded(current, value, limit) {
+  if (current.length >= limit) return current;
+  return `${current}${value.toString("utf8")}`.slice(0, limit);
+}
+function snapshot(session) {
+  return {
+    sessionId: session.sessionId,
+    program: session.program,
+    args: session.args,
+    cwd: session.cwd,
+    pid: session.child.pid ?? null,
+    running: session.running,
+    exitCode: session.exitCode,
+    signal: session.signal,
+    stdout: session.stdout,
+    stderr: session.stderr,
+    timedOut: session.timedOut
+  };
+}
+var ProcessManager = class {
+  #sessions = /* @__PURE__ */ new Map();
+  start(options) {
+    assertProgramAllowed(options.program);
+    const child = spawn(options.program, options.args, {
+      cwd: options.cwd,
+      env: safeEnvironment(),
+      stdio: ["ignore", "pipe", "pipe"],
+      windowsHide: true
+    });
+    const session = {
+      sessionId: randomUUID(),
+      program: options.program,
+      args: [...options.args],
+      cwd: options.cwd,
+      child,
+      maxOutputCharacters: options.maxOutputCharacters,
+      stdout: "",
+      stderr: "",
+      running: true,
+      exitCode: null,
+      signal: null,
+      timedOut: false
+    };
+    this.#sessions.set(session.sessionId, session);
+    child.stdout.on("data", (chunk) => {
+      session.stdout = appendBounded(
+        session.stdout,
+        chunk,
+        session.maxOutputCharacters
+      );
+    });
+    child.stderr.on("data", (chunk) => {
+      session.stderr = appendBounded(
+        session.stderr,
+        chunk,
+        session.maxOutputCharacters
+      );
+    });
+    child.once("error", (error62) => {
+      session.stderr = appendBounded(
+        session.stderr,
+        error62.message,
+        session.maxOutputCharacters
+      );
+      session.running = false;
+      session.exitCode = null;
+      session.signal = null;
+      if (session.timeout) clearTimeout(session.timeout);
+    });
+    child.once("close", (exitCode, signal) => {
+      session.running = false;
+      session.exitCode = exitCode;
+      session.signal = signal;
+      if (session.timeout) clearTimeout(session.timeout);
+    });
+    session.timeout = setTimeout(() => {
+      if (!session.running) return;
+      session.timedOut = true;
+      child.kill("SIGTERM");
+    }, options.timeoutMs);
+    const result = snapshot(session);
+    return {
+      ...result,
+      nextStdoutOffset: result.stdout.length,
+      nextStderrOffset: result.stderr.length
+    };
+  }
+  read(sessionId, stdoutOffset, stderrOffset, maxOutputCharacters) {
+    const session = this.#sessions.get(sessionId);
+    if (!session)
+      throw new Error("The requested process session was not found.");
+    const safeStdoutOffset = Math.max(
+      0,
+      Math.min(stdoutOffset, session.stdout.length)
+    );
+    const safeStderrOffset = Math.max(
+      0,
+      Math.min(stderrOffset, session.stderr.length)
+    );
+    const stdout = session.stdout.slice(
+      safeStdoutOffset,
+      safeStdoutOffset + maxOutputCharacters
+    );
+    const stderr = session.stderr.slice(
+      safeStderrOffset,
+      safeStderrOffset + maxOutputCharacters
     );
-    return { exitCode: 0, signal: null, stdout, stderr, timedOut: false };
-  } catch (error62) {
-    const failure2 = error62;
     return {
-      exitCode: typeof failure2.code === "number" ? failure2.code : null,
-      signal: failure2.signal ?? null,
-      stdout: failure2.stdout ?? "",
-      stderr: failure2.stderr ?? failure2.message,
-      timedOut: failure2.killed === true && failure2.signal === "SIGTERM"
+      ...snapshot(session),
+      stdout,
+      stderr,
+      nextStdoutOffset: safeStdoutOffset + stdout.length,
+      nextStderrOffset: safeStderrOffset + stderr.length
     };
   }
-}
+  terminate(sessionId) {
+    const session = this.#sessions.get(sessionId);
+    if (!session)
+      throw new Error("The requested process session was not found.");
+    if (session.running) session.child.kill("SIGTERM");
+    return snapshot(session);
+  }
+  list() {
+    return [...this.#sessions.values()].map(snapshot);
+  }
+  close() {
+    for (const session of this.#sessions.values()) {
+      if (session.timeout) clearTimeout(session.timeout);
+      if (session.running) session.child.kill("SIGTERM");
+    }
+    this.#sessions.clear();
+  }
+};
 
 // src/server.ts
 var roots = configuredRoots();
+var processManager = new ProcessManager();
 function textResult(value) {
   return {
     content: [{ type: "text", text: JSON.stringify(value, null, 2) }],
@@ -62717,11 +62844,14 @@ function createServer() {
     },
     async ({ path: requestedPath, maxCharacters }) => {
       const filename = await resolveReadablePath(requestedPath, roots);
-      const contents = await readFile(filename, "utf8");
+      const { contents, truncated } = await readBoundedTextFile(
+        filename,
+        maxCharacters
+      );
       return textResult({
         path: filename,
-        contents: contents.slice(0, maxCharacters),
-        truncated: contents.length > maxCharacters
+        contents,
+        truncated
       });
     }
   );
@@ -62758,10 +62888,10 @@ function createServer() {
     }
   );
   server.registerTool(
-    "run_program",
+    "start_process",
     {
-      title: "Run a local program",
-      description: "Run one executable without a shell. Shells and privilege-elevation programs are blocked unless explicitly enabled by local configuration.",
+      title: "Start a process",
+      description: "Start one approved executable without a shell on this machine and return a session ID for reading its output.",
       inputSchema: {
         program: external_exports.string().min(1),
         args: external_exports.array(external_exports.string()).max(100).default([]),
@@ -62770,14 +62900,19 @@ function createServer() {
         maxOutputCharacters: external_exports.number().int().min(1e3).max(2e5).default(5e4)
       },
       outputSchema: {
+        sessionId: external_exports.string(),
         program: external_exports.string(),
         args: external_exports.array(external_exports.string()),
         cwd: external_exports.string(),
+        pid: external_exports.number().int().nullable(),
+        running: external_exports.boolean(),
         exitCode: external_exports.number().int().nullable(),
         signal: external_exports.string().nullable(),
         stdout: external_exports.string(),
         stderr: external_exports.string(),
-        timedOut: external_exports.boolean()
+        timedOut: external_exports.boolean(),
+        nextStdoutOffset: external_exports.number().int().nonnegative(),
+        nextStderrOffset: external_exports.number().int().nonnegative()
       },
       annotations: {
         readOnlyHint: false,
@@ -62790,16 +62925,114 @@ function createServer() {
         cwd ?? roots[0],
         roots
       );
-      const result = await runProgram({
-        program,
-        args,
-        cwd: workingDirectory,
-        timeoutMs,
-        maxOutputChars: maxOutputCharacters
-      });
-      return textResult({ program, args, cwd: workingDirectory, ...result });
+      return textResult(
+        processManager.start({
+          program,
+          args,
+          cwd: workingDirectory,
+          timeoutMs,
+          maxOutputCharacters
+        })
+      );
     }
   );
+  server.registerTool(
+    "read_process_output",
+    {
+      title: "Read process output",
+      description: "Read new stdout and stderr from a previously started process session.",
+      inputSchema: {
+        sessionId: external_exports.string().uuid(),
+        stdoutOffset: external_exports.number().int().min(0).default(0),
+        stderrOffset: external_exports.number().int().min(0).default(0),
+        maxOutputCharacters: external_exports.number().int().min(1e3).max(2e5).default(5e4)
+      },
+      outputSchema: {
+        sessionId: external_exports.string(),
+        program: external_exports.string(),
+        args: external_exports.array(external_exports.string()),
+        cwd: external_exports.string(),
+        pid: external_exports.number().int().nullable(),
+        running: external_exports.boolean(),
+        exitCode: external_exports.number().int().nullable(),
+        signal: external_exports.string().nullable(),
+        stdout: external_exports.string(),
+        stderr: external_exports.string(),
+        timedOut: external_exports.boolean(),
+        nextStdoutOffset: external_exports.number().int().nonnegative(),
+        nextStderrOffset: external_exports.number().int().nonnegative()
+      },
+      annotations: {
+        readOnlyHint: true,
+        destructiveHint: false,
+        openWorldHint: false
+      }
+    },
+    async ({ sessionId, stdoutOffset, stderrOffset, maxOutputCharacters }) => textResult(
+      processManager.read(
+        sessionId,
+        stdoutOffset,
+        stderrOffset,
+        maxOutputCharacters
+      )
+    )
+  );
+  server.registerTool(
+    "terminate_process",
+    {
+      title: "Terminate a process",
+      description: "Stop a previously started process session on this machine.",
+      inputSchema: { sessionId: external_exports.string().uuid() },
+      outputSchema: {
+        sessionId: external_exports.string(),
+        program: external_exports.string(),
+        args: external_exports.array(external_exports.string()),
+        cwd: external_exports.string(),
+        pid: external_exports.number().int().nullable(),
+        running: external_exports.boolean(),
+        exitCode: external_exports.number().int().nullable(),
+        signal: external_exports.string().nullable(),
+        stdout: external_exports.string(),
+        stderr: external_exports.string(),
+        timedOut: external_exports.boolean()
+      },
+      annotations: {
+        readOnlyHint: false,
+        destructiveHint: true,
+        openWorldHint: false
+      }
+    },
+    async ({ sessionId }) => textResult(processManager.terminate(sessionId))
+  );
+  server.registerTool(
+    "list_processes",
+    {
+      title: "List process sessions",
+      description: "List process sessions started through Terminal Commands.",
+      inputSchema: {},
+      outputSchema: {
+        processes: external_exports.array(
+          external_exports.object({
+            sessionId: external_exports.string(),
+            program: external_exports.string(),
+            args: external_exports.array(external_exports.string()),
+            cwd: external_exports.string(),
+            pid: external_exports.number().int().nullable(),
+            running: external_exports.boolean(),
+            exitCode: external_exports.number().int().nullable(),
+            signal: external_exports.string().nullable(),
+            timedOut: external_exports.boolean()
+          })
+        )
+      },
+      annotations: {
+        readOnlyHint: true,
+        destructiveHint: false,
+        openWorldHint: false
+      }
+    },
+    async () => textResult({ processes: processManager.list() })
+  );
   return server;
 }
 
@@ -62860,6 +63093,7 @@ var listener = app.listen(port, host, () => {
 });
 function shutdown(signal) {
   console.log(`Received ${signal}; shutting down.`);
+  processManager.close();
   listener.close((error62) => {
     if (error62) {
       console.error(error62);