@gh-symphony/cli 0.0.13 → 0.0.15

package/dist/init-EZXQAXZM.js

@@ -0,0 +1,17 @@
+#!/usr/bin/env node
+import {
+  abortIfCancelled,
+  generateProjectId,
+  init_default,
+  writeConfig,
+  writeEcosystem
+} from "./chunk-IWR4UQEJ.js";
+import "./chunk-JO3AXHQI.js";
+import "./chunk-ROGRTUFI.js";
+export {
+  abortIfCancelled,
+  init_default as default,
+  generateProjectId,
+  writeConfig,
+  writeEcosystem
+};

package/dist/logs-6LNGT2GF.js

@@ -0,0 +1,188 @@
+#!/usr/bin/env node
+import {
+  handleMissingManagedProjectConfig,
+  resolveManagedProjectConfig
+} from "./chunk-TH5QPO3Y.js";
+import {
+  orchestratorLogPath
+} from "./chunk-ROGRTUFI.js";
+
+// src/commands/logs.ts
+import { readFile, readdir, stat } from "fs/promises";
+import { join, resolve } from "path";
+import { createReadStream } from "fs";
+import { createInterface } from "readline";
+function parseLogsArgs(args) {
+  const parsed = { follow: false };
+  for (let i = 0; i < args.length; i += 1) {
+    const arg = args[i];
+    if (arg === "--follow" || arg === "-f") {
+      parsed.follow = true;
+    }
+    if (arg === "--issue") {
+      parsed.issue = args[i + 1];
+      i += 1;
+    }
+    if (arg === "--run") {
+      parsed.run = args[i + 1];
+      i += 1;
+    }
+    if (arg === "--level") {
+      parsed.level = args[i + 1];
+      i += 1;
+    }
+    if (arg === "--project" || arg === "--project-id") {
+      parsed.projectId = args[i + 1];
+      i += 1;
+    }
+  }
+  return parsed;
+}
+var handler = async (args, options) => {
+  const parsed = parseLogsArgs(args);
+  const runtimeRoot = resolve(options.configDir);
+  if (parsed.run) {
+    const eventsPath = parsed.projectId ? join(
+      runtimeRoot,
+      "projects",
+      parsed.projectId,
+      "runs",
+      parsed.run,
+      "events.ndjson"
+    ) : await resolveRunEventsPath(runtimeRoot, parsed.run);
+    if (!eventsPath) {
+      process.stderr.write(`No events found for run: ${parsed.run}
+`);
+      process.exitCode = 1;
+      return;
+    }
+    try {
+      const content = await readFile(eventsPath, "utf8");
+      const lines = content.trim().split("\n").filter(Boolean);
+      for (const line of lines) {
+        const event = JSON.parse(line);
+        if (parsed.projectId && event.projectId !== parsed.projectId) continue;
+        if (parsed.level && event.level !== parsed.level) continue;
+        if (parsed.issue && event.issueIdentifier !== parsed.issue) continue;
+        process.stdout.write(formatEvent(event) + "\n");
+      }
+    } catch {
+      process.stderr.write(`No events found for run: ${parsed.run}
+`);
+      process.exitCode = 1;
+    }
+    return;
+  }
+  if (parsed.follow) {
+    const projectConfig = await resolveManagedProjectConfig({
+      configDir: options.configDir,
+      requestedProjectId: parsed.projectId
+    });
+    if (!projectConfig) {
+      handleMissingManagedProjectConfig();
+      return;
+    }
+    const logPath = orchestratorLogPath(
+      options.configDir,
+      projectConfig.projectId
+    );
+    try {
+      const stream = createReadStream(logPath, { encoding: "utf8" });
+      const rl = createInterface({ input: stream });
+      for await (const line of rl) {
+        process.stdout.write(line + "\n");
+      }
+      const { watchFile } = await import("fs");
+      let lastSize = 0;
+      watchFile(logPath, { interval: 1e3 }, async (curr) => {
+        if (curr.size > lastSize) {
+          const fd = await import("fs/promises");
+          const handle = await fd.open(logPath, "r");
+          const buf = Buffer.alloc(curr.size - lastSize);
+          await handle.read(buf, 0, buf.length, lastSize);
+          await handle.close();
+          process.stdout.write(buf.toString("utf8"));
+          lastSize = curr.size;
+        }
+      });
+      await new Promise(() => {
+      });
+    } catch {
+      process.stderr.write(
+        "No log file found. Start the orchestrator first.\n"
+      );
+      process.exitCode = 1;
+    }
+    return;
+  }
+  const runRoots = parsed.projectId ? [join(runtimeRoot, "projects", parsed.projectId, "runs")] : await listProjectRunRoots(runtimeRoot);
+  let foundRuns = false;
+  try {
+    for (const runsDir of runRoots) {
+      const entries = await safeReadDir(runsDir);
+      if (entries.length === 0) {
+        continue;
+      }
+      foundRuns = true;
+      for (const entry of entries) {
+        const eventsPath = join(runsDir, entry, "events.ndjson");
+        try {
+          const content = await readFile(eventsPath, "utf8");
+          const lines = content.trim().split("\n").filter(Boolean);
+          for (const line of lines) {
+            const event = JSON.parse(line);
+            if (parsed.projectId && event.projectId !== parsed.projectId)
+              continue;
+            if (parsed.level && event.level !== parsed.level) continue;
+            if (parsed.issue && event.issueIdentifier !== parsed.issue) continue;
+            process.stdout.write(formatEvent(event) + "\n");
+          }
+        } catch {
+        }
+      }
+    }
+  } catch {
+  }
+  if (!foundRuns) {
+    process.stderr.write("No runs found. Start the orchestrator first.\n");
+  }
+};
+var logs_default = handler;
+function formatEvent(event) {
+  const at = event.at ?? "";
+  const eventType = event.event ?? "unknown";
+  const issue = event.issueIdentifier ?? "";
+  const extra = event.error ? ` error=${event.error}` : "";
+  return `[${at}] ${eventType} ${issue}${extra}`;
+}
+async function listProjectRunRoots(runtimeRoot) {
+  try {
+    const projectIds = await readdir(join(runtimeRoot, "projects"));
+    return projectIds.map(
+      (projectId) => join(runtimeRoot, "projects", projectId, "runs")
+    );
+  } catch {
+    return [];
+  }
+}
+async function resolveRunEventsPath(runtimeRoot, runId) {
+  for (const runsDir of await listProjectRunRoots(runtimeRoot)) {
+    const eventsPath = join(runsDir, runId, "events.ndjson");
+    try {
+      await stat(eventsPath);
+      return eventsPath;
+    } catch {
+    }
+  }
+  return null;
+}
+async function safeReadDir(path) {
+  try {
+    return await readdir(path);
+  } catch {
+    return [];
+  }
+}
+export {
+  logs_default as default
+};