@kaluchi/jdtbridge 1.3.0 → 1.4.0

package/README.md

@@ -71,10 +71,26 @@ jdt rename <FQN> <newName> --field <old>               # rename field
 jdt move <FQN> <target.package>                        # move type to another package
 ```
 
+### Launches
+
+```bash
+jdt launch list                                        # list launches (running + terminated)
+jdt launch configs                                     # list saved launch configurations
+jdt launch run <config> [-f] [-q]                      # launch a configuration
+jdt launch debug <config> [-f] [-q]                    # launch in debug mode
+jdt launch logs <name> [-f] [--tail N]                 # show console output
+jdt launch stop <name>                                 # stop a running launch
+jdt launch clear [name]                                # remove terminated launches
+```
+
+`-f` streams output in real-time until the process terminates.
+Without `-f`, `launch run` prints an onboarding guide with available commands (`-q` to suppress).
+Console output persists in Eclipse and is available via `launch logs` at any time.
+
 ### Editor
 
 ```bash
-jdt active-editor                                      # (alias: ae) current file and cursor line
+jdt editors                                             # (alias: ed) list all open editors (absolute paths)
 jdt open <FQMN>                                        # open in Eclipse editor
 ```
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kaluchi/jdtbridge",
-  "version": "1.3.0",
+  "version": "1.4.0",
   "description": "CLI for Eclipse JDT Bridge — semantic Java analysis via Eclipse JDT SearchEngine",
   "type": "module",
   "bin": {

package/src/cli.mjs

@@ -24,11 +24,29 @@ import {
   moveHelp,
 } from "./commands/refactoring.mjs";
 import {
-  activeEditor,
+  editors,
   open,
-  activeEditorHelp,
+  editorsHelp,
   openHelp,
 } from "./commands/editor.mjs";
+import {
+  launchList,
+  launchConfigs,
+  launchRun,
+  launchDebug,
+  launchStop,
+  launchClear,
+  launchLogs,
+  launchConsole,
+  launchListHelp,
+  launchConfigsHelp,
+  launchRunHelp,
+  launchDebugHelp,
+  launchStopHelp,
+  launchClearHelp,
+  launchLogsHelp,
+  launchConsoleHelp,
+} from "./commands/launch.mjs";
 import { setup, help as setupHelp } from "./commands/setup.mjs";
 import { isConnectionError } from "./client.mjs";
 import { bold, red, dim } from "./color.mjs";
@@ -36,6 +54,45 @@ import { createRequire } from "node:module";
 
 const { version } = createRequire(import.meta.url)("../package.json");
 
+const launchSubcommands = {
+  list: { fn: launchList, help: launchListHelp },
+  configs: { fn: launchConfigs, help: launchConfigsHelp },
+  run: { fn: launchRun, help: launchRunHelp },
+  debug: { fn: launchDebug, help: launchDebugHelp },
+  stop: { fn: launchStop, help: launchStopHelp },
+  clear: { fn: launchClear, help: launchClearHelp },
+  logs: { fn: launchLogs, help: launchLogsHelp },
+  console: { fn: launchConsole, help: launchConsoleHelp },
+};
+
+const launchHelp = `Manage launches (running and terminated processes).
+
+Subcommands:
+  jdt launch list                           list all launches
+  jdt launch configs                        list saved launch configurations
+  jdt launch run <config> [-f] [-q]         launch a configuration
+  jdt launch debug <config> [-f] [-q]       launch in debug mode
+  jdt launch logs <name> [-f] [--tail N]    show console output
+  jdt launch stop <name>                    stop a running launch
+  jdt launch clear [name]                   remove terminated launches
+
+Use "jdt help launch <subcommand>" for details.`;
+
+async function launchDispatch(args) {
+  const [sub, ...rest] = args;
+  if (!sub || sub === "--help") {
+    console.log(launchHelp);
+    return;
+  }
+  const cmd = launchSubcommands[sub];
+  if (!cmd) {
+    console.error(`Unknown launch subcommand: ${sub}`);
+    console.log(launchHelp);
+    process.exit(1);
+  }
+  await cmd.fn(rest);
+}
+
 const commands = {
   projects: { fn: projects, help: projectsHelp },
   "project-info": { fn: projectInfo, help: projectInfoHelp },
@@ -53,8 +110,9 @@ const commands = {
   format: { fn: format, help: formatHelp },
   rename: { fn: rename, help: renameHelp },
   move: { fn: move, help: moveHelp },
-  "active-editor": { fn: activeEditor, help: activeEditorHelp },
+  editors: { fn: editors, help: editorsHelp },
   open: { fn: open, help: openHelp },
+  launch: { fn: launchDispatch, help: launchHelp },
   setup: { fn: setup, help: setupHelp },
 };
 
@@ -67,7 +125,7 @@ const aliases = {
   pi: "project-info",
   ti: "type-info",
   oi: "organize-imports",
-  ae: "active-editor",
+  ed: "editors",
   src: "source",
   b: "build",
   err: "errors",
@@ -120,8 +178,17 @@ Refactoring:
   rename <FQMN> <newName> [--field <old>]     rename type/method/field
   move <FQN> <target.package>                 move type to another package
 
+Launches:
+  launch list                                 list launches (running + terminated)
+  launch configs                              list saved launch configurations
+  launch run <config> [-f] [-q]               launch a configuration
+  launch debug <config> [-f] [-q]             launch in debug mode
+  launch logs <name> [-f] [--tail N]          show console output
+  launch stop <name>                          stop a running launch
+  launch clear [name]                         remove terminated launches
+
 Editor:
-  active-editor${fmtAliases("active-editor")}                               current file and cursor line
+  editors${fmtAliases("editors")}                                    list open editors (absolute paths)
   open <FQMN>                                 open in Eclipse editor
 
 Setup:
@@ -146,7 +213,9 @@ export async function run(argv) {
   if (command === "help") {
     const topic = rest[0];
     const resolved = topic ? resolve(topic) : null;
-    if (resolved) {
+    if (resolved === "launch" && rest[1] && launchSubcommands[rest[1]]) {
+      console.log(launchSubcommands[rest[1]].help);
+    } else if (resolved) {
       console.log(commands[resolved].help);
     } else if (topic) {
       console.error(`Unknown command: ${topic}`);

package/src/client.mjs

@@ -158,6 +158,44 @@ export function getRaw(path, timeoutMs = 10_000) {
   });
 }
 
+/**
+ * HTTP GET with streaming response. Pipes text/plain chunks to
+ * the provided writable stream (typically process.stdout).
+ * Resolves when the server closes the connection.
+ * Rejects on non-200 status or connection error.
+ * @param {string} path
+ * @param {import('stream').Writable} dest
+ * @returns {Promise<void>}
+ */
+export function getStream(path, dest) {
+  const inst = connect();
+  return new Promise((resolve, reject) => {
+    const req = request(
+      {
+        hostname: "127.0.0.1",
+        port: inst.port,
+        path,
+        method: "GET",
+        timeout: 0, // no timeout for streaming
+        headers: authHeaders(),
+      },
+      (res) => {
+        if (res.statusCode !== 200) {
+          let data = "";
+          res.on("data", (chunk) => (data += chunk));
+          res.on("end", () => reject(new Error(data.trim())));
+          return;
+        }
+        res.pipe(dest, { end: false });
+        res.on("end", resolve);
+        res.on("error", reject);
+      },
+    );
+    req.on("error", reject);
+    req.end();
+  });
+}
+
 /**
  * Check if error is a connection refused error.
  * @param {Error} e

package/src/commands/editor.mjs

@@ -1,17 +1,18 @@
 import { get } from "../client.mjs";
 import { extractPositional, parseFlags, parseFqmn } from "../args.mjs";
-import { stripProject } from "../paths.mjs";
 
-export async function activeEditor() {
-  const result = await get("/active-editor");
-  if (result.error) {
-    console.error(result.error);
+export async function editors() {
+  const results = await get("/editors");
+  if (results.error) {
+    console.error(results.error);
     process.exit(1);
   }
-  if (result.file === null) {
-    console.log("(no file open)");
-  } else {
-    console.log(`${stripProject(result.file)}:${result.line}`);
+  if (results.length === 0) {
+    console.log("(no open editors)");
+    return;
+  }
+  for (const r of results) {
+    console.log(r.file);
   }
 }
 
@@ -38,9 +39,11 @@ export async function open(args) {
   console.log("Opened");
 }
 
-export const activeEditorHelp = `Show the file and cursor line of the active Eclipse editor.
+export const editorsHelp = `List all open editors in Eclipse. Active editor first.
+
+Usage:  jdt editors
 
-Usage:  jdt active-editor`;
+Output: absolute file paths, one per line.`;
 
 export const openHelp = `Open a type or method in the Eclipse editor.
 

package/src/commands/launch.mjs

@@ -0,0 +1,308 @@
+import { get, getStream } from "../client.mjs";
+import { extractPositional, parseFlags } from "../args.mjs";
+
+export async function launchList() {
+  const results = await get("/launch/list");
+  if (results.error) {
+    console.error(results.error);
+    process.exit(1);
+  }
+  if (results.length === 0) {
+    console.log("(no launches)");
+    return;
+  }
+  for (const r of results) {
+    const status = r.terminated
+      ? `terminated${r.exitCode !== undefined ? ` (${r.exitCode})` : ""}`
+      : "running";
+    const parts = [r.name, r.type, r.mode, status];
+    if (r.pid) parts.push(`pid:${r.pid}`);
+    console.log(parts.join("  "));
+  }
+}
+
+export async function launchConfigs() {
+  const results = await get("/launch/configs");
+  if (results.error) {
+    console.error(results.error);
+    process.exit(1);
+  }
+  if (results.length === 0) {
+    console.log("(no launch configurations)");
+    return;
+  }
+  for (const r of results) {
+    console.log(`${r.name}  ${r.type}`);
+  }
+}
+
+export async function launchClear(args) {
+  const pos = extractPositional(args);
+  let url = "/launch/clear";
+  if (pos[0]) url += `?name=${encodeURIComponent(pos[0])}`;
+  const result = await get(url);
+  if (result.error) {
+    console.error(result.error);
+    process.exit(1);
+  }
+  console.log(`Removed ${result.removed} terminated launch${result.removed !== 1 ? "es" : ""}`);
+}
+
+/**
+ * Launch a configuration. Without -f, prints onboarding guide.
+ * With -f, streams console output until termination.
+ */
+export async function launchRun(args) {
+  return launchWithMode(args, "run");
+}
+
+/** Launch in debug mode. Same interface as run. */
+export async function launchDebug(args) {
+  return launchWithMode(args, "debug");
+}
+
+async function launchWithMode(args, mode) {
+  const pos = extractPositional(args);
+  const name = pos[0];
+  if (!name) {
+    console.error(`Usage: launch ${mode} <config-name> [-f] [-q]`);
+    process.exit(1);
+  }
+
+  let url = `/launch/run?name=${encodeURIComponent(name)}`;
+  if (mode === "debug") url += "&debug";
+  const result = await get(url, 30_000);
+  if (result.error) {
+    console.error(result.error);
+    process.exit(1);
+  }
+
+  const follow = args.includes("-f") || args.includes("--follow");
+  if (follow) {
+    console.error(formatLaunched(result));
+    const exitCode = await followLogs(result.name, args);
+    process.exit(exitCode);
+  }
+
+  const quiet = args.includes("-q") || args.includes("--quiet");
+  const n = result.name;
+  console.log(formatLaunched(result));
+
+  if (!quiet) {
+    console.log(launchGuide(n));
+  }
+}
+
+function formatLaunched(result) {
+  const parts = [`Launched ${result.name} (${result.mode})`];
+  if (result.type) parts[0] += ` [${result.type}]`;
+  if (result.pid) parts.push(`  PID:        ${result.pid}`);
+  if (result.workingDir) parts.push(`  Working dir: ${result.workingDir}`);
+  if (result.cmdline) {
+    parts.push(`  Command:    ${result.cmdline}`);
+  }
+  return parts.join("\n");
+}
+
+function launchGuide(name) {
+  return `
+  Console output is captured by Eclipse and remains available
+  after the process terminates. You can read it at any time,
+  filter with grep, or pipe through tail/head.
+
+  View logs:
+    jdt launch logs ${name}
+    jdt launch logs ${name} --tail 30
+
+  Wait for completion (blocks until process exits):
+    jdt launch logs ${name} -f | tail -20
+    jdt launch logs ${name} -f
+
+  Manage:
+    jdt launch list
+    jdt launch stop ${name}
+    jdt launch clear
+
+  Run modes:
+    jdt launch run <config>           launch (this output)
+    jdt launch run <config> -f        launch + stream output
+    jdt launch run <config> -f | tail launch + wait + bounded
+    jdt launch debug <config>         launch with debugger
+
+  Add -q to suppress this guide.`;
+}
+
+export async function launchStop(args) {
+  const pos = extractPositional(args);
+  const name = pos[0];
+  if (!name) {
+    console.error("Usage: launch stop <name>");
+    process.exit(1);
+  }
+  const url = `/launch/stop?name=${encodeURIComponent(name)}`;
+  const result = await get(url);
+  if (result.error) {
+    console.error(result.error);
+    process.exit(1);
+  }
+  console.log(`Stopped ${result.name}`);
+}
+
+/**
+ * Show console output. "logs" is the primary name,
+ * "console" is kept as an alias.
+ */
+export async function launchLogs(args) {
+  const pos = extractPositional(args);
+  const flags = parseFlags(args);
+  const name = pos[0];
+  if (!name) {
+    console.error(
+      "Usage: launch logs <name> [-f|--follow] [--tail N]",
+    );
+    process.exit(1);
+  }
+
+  const follow = args.includes("-f") || args.includes("--follow");
+  if (follow) {
+    const exitCode = await followLogs(name, args);
+    process.exit(exitCode);
+  }
+
+  // Snapshot mode
+  let url = `/launch/console?name=${encodeURIComponent(name)}`;
+  if (flags.tail !== undefined && flags.tail !== true)
+    url += `&tail=${flags.tail}`;
+  if (args.includes("--stderr")) url += "&stream=stderr";
+  else if (args.includes("--stdout")) url += "&stream=stdout";
+  const result = await get(url, 30_000);
+  if (result.error) {
+    console.error(result.error);
+    process.exit(1);
+  }
+  if (result.output) {
+    const text = result.output.endsWith("\n")
+      ? result.output.slice(0, -1)
+      : result.output;
+    console.log(text);
+  }
+}
+
+/** Alias: console → logs */
+export const launchConsole = launchLogs;
+
+/**
+ * Stream console output until process terminates or Ctrl+C.
+ * Returns the process exit code (0 on detach).
+ */
+async function followLogs(name, args) {
+  const flags = parseFlags(args);
+  let url = `/launch/console/stream?name=${encodeURIComponent(name)}`;
+  if (flags.tail !== undefined && flags.tail !== true)
+    url += `&tail=${flags.tail}`;
+  if (args.includes("--stderr")) url += "&stream=stderr";
+  else if (args.includes("--stdout")) url += "&stream=stdout";
+
+  // Ctrl+C = detach, not kill
+  let detached = false;
+  const onSigint = () => {
+    detached = true;
+    process.stdout.write("\n");
+    process.exit(0);
+  };
+  process.on("SIGINT", onSigint);
+
+  try {
+    await getStream(url, process.stdout);
+  } catch (e) {
+    if (!detached) {
+      console.error(e.message);
+      return 1;
+    }
+    return 0;
+  } finally {
+    process.removeListener("SIGINT", onSigint);
+  }
+
+  // Stream ended — fetch exit code
+  try {
+    const list = await get("/launch/list");
+    const entry = Array.isArray(list)
+      ? list.find((l) => l.name === name && l.terminated)
+      : null;
+    return entry?.exitCode ?? 0;
+  } catch {
+    return 0;
+  }
+}
+
+export const launchRunHelp = `Launch a saved configuration.
+
+Usage:  jdt launch run <config-name> [-f] [-q]
+
+Without -f, launches and prints a guide with available commands.
+With -f, launches and streams console output until the process terminates.
+
+Flags:
+  -f, --follow   stream output (Ctrl+C to detach, process keeps running)
+  -q, --quiet    suppress onboarding guide
+
+Examples:
+  jdt launch run m8-server                run + show guide
+  jdt launch run m8-server -q             run silently
+  jdt launch run jdtbridge-verify -f      run + stream all output
+  jdt launch run m8-server -f | tail -20  run + wait + bounded output`;
+
+export const launchDebugHelp = `Launch a configuration in debug mode.
+
+Usage:  jdt launch debug <config-name> [-f] [-q]
+
+Same as "launch run" but attaches the Eclipse debugger.
+
+Examples:
+  jdt launch debug m8-server
+  jdt launch debug m8-server -f`;
+
+export const launchStopHelp = `Stop a running launch.
+
+Usage:  jdt launch stop <name>
+
+Example:  jdt launch stop m8-server`;
+
+export const launchConfigsHelp = `List saved launch configurations (Run → Run Configurations).
+
+Usage:  jdt launch configs
+
+Output: configuration name and type, one per line.`;
+
+export const launchClearHelp = `Remove terminated launches and their console output.
+
+Usage:  jdt launch clear [name]
+
+Without name, removes all terminated launches. With name, removes only that one.`;
+
+export const launchListHelp = `List all launches (running and terminated).
+
+Usage:  jdt launch list
+
+Output: name, type, mode, status — one launch per line.`;
+
+export const launchLogsHelp = `Show console output of a launch.
+
+Console output is captured by Eclipse and persists after the process
+terminates. Without -f, returns a snapshot. With -f, streams in real-time.
+
+Usage:  jdt launch logs <name> [-f|--follow] [--tail N]
+
+Flags:
+  -f, --follow   stream until process terminates (Ctrl+C to detach)
+  --tail <N>     last N lines only (snapshot), or start N lines back (follow)
+
+Examples:
+  jdt launch logs m8-server                full output snapshot
+  jdt launch logs m8-server --tail 30      last 30 lines
+  jdt launch logs m8-server -f             stream live
+  jdt launch logs m8-server -f | tail -20  wait + bounded output`;
+
+// Keep old name for backward compatibility
+export const launchConsoleHelp = launchLogsHelp;