@elmundi/ship-cli 0.8.1 → 0.12.0

package/lib/commands/telemetry.mjs

@@ -0,0 +1,390 @@
+import fs from "node:fs";
+import readline from "node:readline";
+import { randomUUID } from "node:crypto";
+import {
+  findShipRoot,
+  readConfig,
+  writeConfig,
+  readState,
+  writeState,
+} from "../config/io.mjs";
+import { validateConfig } from "../config/schema.mjs";
+import {
+  outboxPath,
+  listEvents,
+  countEvents,
+  clearEvents,
+  writeAllEvents,
+  ALLOWED_EVENT_TYPES,
+} from "../telemetry/outbox.mjs";
+import {
+  postTelemetry,
+  exportTelemetry,
+  deleteTelemetry,
+} from "../http.mjs";
+
+const KNOWN_SCOPES = ["artifact_usage", "improvement_drafts", "errors"];
+
+function parseArgs(rest) {
+  const out = {
+    cwd: process.cwd(),
+    yes: false,
+    dryRun: false,
+    out: null,
+    scope: null,
+    limit: null,
+    positional: [],
+  };
+  const copy = [...rest];
+  while (copy.length) {
+    const a = copy[0];
+    if (a === "--cwd" && copy[1]) {
+      copy.shift();
+      out.cwd = String(copy.shift());
+      continue;
+    }
+    if (a.startsWith("--cwd=")) {
+      out.cwd = a.slice("--cwd=".length);
+      copy.shift();
+      continue;
+    }
+    if (a === "--yes" || a === "-y") {
+      out.yes = true;
+      copy.shift();
+      continue;
+    }
+    if (a === "--dry-run") {
+      out.dryRun = true;
+      copy.shift();
+      continue;
+    }
+    if (a === "--out" && copy[1]) {
+      copy.shift();
+      out.out = String(copy.shift());
+      continue;
+    }
+    if (a.startsWith("--out=")) {
+      out.out = a.slice("--out=".length);
+      copy.shift();
+      continue;
+    }
+    if (a === "--scope" && copy[1]) {
+      copy.shift();
+      out.scope = String(copy.shift());
+      continue;
+    }
+    if (a.startsWith("--scope=")) {
+      out.scope = a.slice("--scope=".length);
+      copy.shift();
+      continue;
+    }
+    if (a === "--limit" && copy[1]) {
+      copy.shift();
+      out.limit = parseInt(copy.shift(), 10);
+      continue;
+    }
+    if (a.startsWith("--limit=")) {
+      out.limit = parseInt(a.slice("--limit=".length), 10);
+      copy.shift();
+      continue;
+    }
+    out.positional.push(copy.shift());
+  }
+  return out;
+}
+
+function requireShipRoot(cwd) {
+  const root = findShipRoot(cwd);
+  if (!root) {
+    console.error(".ship/ not found. Run 'shipctl config init' first.");
+    process.exit(10);
+  }
+  return root;
+}
+
+function resolveBaseUrl(ctx, config) {
+  return (
+    ctx?.baseUrl ||
+    process.env.SHIP_API_BASE ||
+    config?.api?.base_url ||
+    "https://ship.elmundi.com"
+  ).replace(/\/$/, "");
+}
+
+async function promptConfirm(msg) {
+  if (!process.stdin.isTTY) return false;
+  const rl = readline.createInterface({ input: process.stdin, output: process.stderr });
+  try {
+    const answer = await new Promise((resolve) => rl.question(`${msg} [y/N] `, resolve));
+    return /^y(es)?$/i.test(String(answer || "").trim());
+  } finally {
+    rl.close();
+  }
+}
+
+async function promptLine(msg) {
+  const rl = readline.createInterface({ input: process.stdin, output: process.stderr });
+  try {
+    return await new Promise((resolve) => rl.question(msg, resolve));
+  } finally {
+    rl.close();
+  }
+}
+
+function saveConfig(root, config) {
+  const { filePath } = readConfig(root);
+  const valid = validateConfig(config);
+  if (!valid.ok) {
+    for (const e of valid.errors) console.error(e);
+    process.exit(10);
+  }
+  writeConfig(filePath, config);
+}
+
+function printStatus(root) {
+  const { config } = readConfig(root);
+  const { state } = readState(root);
+  const share = config.telemetry?.share === true;
+  const id = config.telemetry?.anonymous_id || "(none)";
+  const scope = config.telemetry?.scope || {};
+  const scopeStr = KNOWN_SCOPES.map((k) => `${k}=${scope[k] === true}`).join(",");
+  const pending = countEvents(root);
+  const last = state.last_flush_at || "never";
+  console.log(`share=${share}`);
+  console.log(`anonymous_id=${id}`);
+  console.log(`scope=${scopeStr}`);
+  console.log(`outbox_pending=${pending}`);
+  console.log(`last_flush_at=${last}`);
+}
+
+async function cmdOn(root, args) {
+  const { config } = readConfig(root);
+  config.telemetry = config.telemetry || {};
+  config.telemetry.scope = config.telemetry.scope || {
+    artifact_usage: true,
+    improvement_drafts: true,
+    errors: false,
+  };
+
+  if (args.scope) {
+    const parts = args.scope.split(",").map((s) => s.trim()).filter(Boolean);
+    for (const p of parts) {
+      if (!KNOWN_SCOPES.includes(p)) {
+        console.error(`unknown scope: ${p}; allowed=${KNOWN_SCOPES.join(",")}`);
+        process.exit(1);
+      }
+    }
+    for (const p of parts) config.telemetry.scope[p] = true;
+  }
+
+  if (!args.yes) {
+    const ok = await promptConfirm(
+      "Enable anonymous telemetry (artifact usage + feedback metadata)?",
+    );
+    if (!ok) {
+      console.error("aborted.");
+      process.exit(1);
+    }
+  }
+  config.telemetry.share = true;
+  if (!config.telemetry.anonymous_id) {
+    config.telemetry.anonymous_id = randomUUID();
+  }
+  saveConfig(root, config);
+  console.log(
+    `telemetry.share=true anonymous_id=${config.telemetry.anonymous_id} scope=${KNOWN_SCOPES.map(
+      (k) => `${k}=${config.telemetry.scope[k] === true}`,
+    ).join(",")}`,
+  );
+}
+
+function cmdOff(root) {
+  const { config } = readConfig(root);
+  config.telemetry = config.telemetry || {};
+  config.telemetry.share = false;
+  config.telemetry.scope = {
+    artifact_usage: false,
+    improvement_drafts: false,
+    errors: false,
+  };
+  saveConfig(root, config);
+  console.log("telemetry.share=false");
+}
+
+function cmdShowId(root) {
+  const { config } = readConfig(root);
+  const id = config.telemetry?.anonymous_id;
+  if (!id) {
+    console.error("no anonymous_id set. Run 'shipctl telemetry on' to generate one.");
+    process.exit(1);
+  }
+  console.log(id);
+}
+
+function cmdResetId(root) {
+  const { config } = readConfig(root);
+  config.telemetry = config.telemetry || {};
+  config.telemetry.anonymous_id = randomUUID();
+  saveConfig(root, config);
+  console.log(config.telemetry.anonymous_id);
+}
+
+async function cmdFlush(ctx, root, args) {
+  const { config } = readConfig(root);
+  if (config.telemetry?.share !== true) {
+    console.log("telemetry disabled; nothing to send");
+    return;
+  }
+  const events = listEvents(root);
+  if (events.length === 0) {
+    console.log("flushed 0 events, 0 failed");
+    return;
+  }
+  if (args.dryRun) {
+    console.log(`would flush ${events.length} events to ${resolveBaseUrl(ctx, config)}/telemetry`);
+    return;
+  }
+
+  const baseUrl = resolveBaseUrl(ctx, config);
+  let flushed = 0;
+  let failed = 0;
+  const pending = [];
+
+  for (let i = 0; i < events.length; i += 100) {
+    const batch = events.slice(i, i + 100);
+    const stripped = batch.map((ev) => ({
+      type: ev.type,
+      anonymous_id: ev.anonymous_id || config.telemetry.anonymous_id,
+      timestamp: ev.timestamp,
+      payload: ev.payload || {},
+    }));
+    const res = await postTelemetry(baseUrl, stripped);
+    if (res.ok) {
+      flushed += batch.length;
+    } else {
+      failed += batch.length;
+      pending.push(...batch);
+    }
+  }
+
+  writeAllEvents(root, pending);
+
+  if (flushed > 0) {
+    try {
+      const { state } = readState(root);
+      writeState(root, { ...state, last_flush_at: new Date().toISOString() });
+    } catch {
+      // non-fatal
+    }
+  }
+
+  console.log(`flushed ${flushed} events, ${failed} failed`);
+  if (failed > 0) process.exit(20);
+}
+
+async function cmdExport(ctx, root, args) {
+  const { config } = readConfig(root);
+  const id = config.telemetry?.anonymous_id;
+  if (!id) {
+    console.error("no anonymous_id set.");
+    process.exit(1);
+  }
+  const baseUrl = resolveBaseUrl(ctx, config);
+  const data = await exportTelemetry(baseUrl, id);
+  const json = JSON.stringify(data, null, 2);
+  if (args.out) {
+    fs.writeFileSync(args.out, json + "\n", "utf8");
+    console.log(`wrote ${args.out}`);
+  } else {
+    console.log(json);
+  }
+}
+
+async function cmdDeleteMyData(ctx, root) {
+  const { config } = readConfig(root);
+  const id = config.telemetry?.anonymous_id;
+  if (!id) {
+    console.error("no anonymous_id set; nothing to delete.");
+    process.exit(1);
+  }
+  if (!process.stdin.isTTY) {
+    console.error("delete-my-data requires an interactive terminal.");
+    process.exit(1);
+  }
+  const typed = (
+    await promptLine(`Are you sure? Type the anonymous_id to confirm: `)
+  ).trim();
+  if (typed !== id) {
+    console.error("mismatch; aborted.");
+    process.exit(1);
+  }
+  const baseUrl = resolveBaseUrl(ctx, config);
+  const data = await deleteTelemetry(baseUrl, id);
+  console.log(JSON.stringify({ deleted: data?.deleted ?? 0 }));
+}
+
+function summarizePayload(payload) {
+  if (!payload || typeof payload !== "object") return "";
+  const parts = [];
+  for (const k of ["kind", "id", "version", "agent", "source", "updates_count", "failures_count"]) {
+    if (payload[k] !== undefined) parts.push(`${k}=${JSON.stringify(payload[k])}`);
+  }
+  if (parts.length === 0) {
+    const first = Object.keys(payload).slice(0, 3);
+    for (const k of first) parts.push(`${k}=${JSON.stringify(payload[k])}`);
+  }
+  return parts.join(" ");
+}
+
+function cmdBuffer(root, args) {
+  const limit = Number.isFinite(args.limit) && args.limit > 0 ? args.limit : 20;
+  const events = listEvents(root);
+  const tail = events.slice(-limit);
+  for (const ev of tail) {
+    console.log(
+      `${ev.timestamp || "-"}  ${ev.type || "-"}  ${summarizePayload(ev.payload)}`,
+    );
+  }
+  console.log(`(${tail.length}/${events.length} shown; outbox=${outboxPath(root)})`);
+}
+
+export async function telemetryCommand(ctx, rest) {
+  const args = parseArgs(rest);
+  const sub = args.positional[0];
+  const root = requireShipRoot(args.cwd);
+
+  switch (sub) {
+    case "status":
+      printStatus(root);
+      return;
+    case "on":
+      await cmdOn(root, args);
+      return;
+    case "off":
+      cmdOff(root);
+      return;
+    case "show-id":
+      cmdShowId(root);
+      return;
+    case "reset-id":
+      cmdResetId(root);
+      return;
+    case "flush":
+      await cmdFlush(ctx, root, args);
+      return;
+    case "export":
+      await cmdExport(ctx, root, args);
+      return;
+    case "delete-my-data":
+      await cmdDeleteMyData(ctx, root);
+      return;
+    case "buffer":
+      cmdBuffer(root, args);
+      return;
+    default:
+      console.error(
+        `usage: shipctl telemetry <status|on|off|show-id|reset-id|flush|export|delete-my-data|buffer>\nallowed event types: ${ALLOWED_EVENT_TYPES.join(", ")}`,
+      );
+      process.exit(2);
+  }
+}

package/lib/commands/trigger.mjs

@@ -0,0 +1,196 @@
+import { readConfig } from "../config/io.mjs";
+
+const VERSION = "v1";
+
+export async function triggerCommand(ctx, rest) {
+  const opts = parseArgs(rest);
+  const baseUrl = resolveBaseUrl(opts.baseUrl || ctx.baseUrl);
+  const token = requireToken();
+  let workspaceId = opts.workspace;
+  if (!workspaceId) workspaceId = await resolveSoleWorkspace(baseUrl, token);
+  const repoId = await resolveRepoId(baseUrl, token, workspaceId, opts.repo);
+  const { config } = readConfig(opts.cwd || process.cwd());
+
+  const result = await apiPostJson(
+    baseUrl,
+    `/v1/workspaces/${encodeURIComponent(workspaceId)}/repos/${encodeURIComponent(repoId)}/trigger`,
+    {
+      event: opts.event,
+      config,
+      github: {
+        event_name: process.env.SHIP_EVENT_NAME || process.env.GITHUB_EVENT_NAME || "",
+        ref: process.env.SHIP_REF || process.env.GITHUB_REF || "",
+        sha: process.env.SHIP_SHA || process.env.GITHUB_SHA || "",
+        run_id: process.env.GITHUB_RUN_ID || "",
+      },
+    },
+    token,
+  );
+
+  if (ctx.json || opts.json) {
+    console.log(JSON.stringify(result, null, 2));
+    return;
+  }
+  const due = Array.isArray(result.due_lanes) ? result.due_lanes : [];
+  if (!due.length) {
+    console.log(`Ship trigger ${opts.event}: no lanes due.`);
+    return;
+  }
+  console.log(`Ship trigger ${opts.event}: ${due.length} lane(s) due`);
+  for (const lane of due) console.log(`  - ${lane.lane_id}`);
+}
+
+function printHelp() {
+  console.log(`shipctl trigger — ask Ship which lanes are due (${VERSION})
+
+USAGE
+  shipctl trigger --event schedule --repo <id|owner/name> [--workspace <id>] [--json]
+
+ENV
+  SHIP_API_TOKEN             Required.
+  SHIP_WORKSPACE_API_BASE    Optional API base override.
+  SHIP_API_BASE              Fallback API base override.
+`);
+}
+
+function parseArgs(args) {
+  const out = {
+    event: null,
+    workspace: null,
+    repo: null,
+    baseUrl: null,
+    cwd: null,
+    json: false,
+  };
+  const copy = [...args];
+  const consume = (flag, key) => {
+    if (copy[0] === flag && copy[1] !== undefined) {
+      copy.shift();
+      out[key] = String(copy.shift());
+      return true;
+    }
+    const p = `${flag}=`;
+    if (copy[0] && copy[0].startsWith(p)) {
+      out[key] = copy[0].slice(p.length);
+      copy.shift();
+      return true;
+    }
+    return false;
+  };
+  while (copy.length) {
+    if (
+      consume("--event", "event") ||
+      consume("--workspace", "workspace") ||
+      consume("--repo", "repo") ||
+      consume("--base-url", "baseUrl") ||
+      consume("--cwd", "cwd")
+    ) {
+      continue;
+    }
+    if (copy[0] === "--json") {
+      out.json = true;
+      copy.shift();
+      continue;
+    }
+    if (copy[0] === "--help" || copy[0] === "-h") {
+      printHelp();
+      process.exit(0);
+    }
+    console.error(`Unknown flag: ${copy[0]}`);
+    process.exit(1);
+  }
+  if (!out.event) {
+    console.error("Usage: shipctl trigger --event <schedule> --repo <id|owner/name>");
+    process.exit(1);
+  }
+  if (!["schedule", "manual", "pull_request", "push"].includes(out.event)) {
+    console.error("--event must be one of: schedule, manual, pull_request, push");
+    process.exit(1);
+  }
+  return out;
+}
+
+function requireToken() {
+  const token = process.env.SHIP_API_TOKEN || "";
+  if (!token) {
+    console.error("SHIP_API_TOKEN is required.");
+    process.exit(1);
+  }
+  return token;
+}
+
+function resolveBaseUrl(explicit) {
+  if (explicit) return explicit.replace(/\/+$/, "");
+  if (process.env.SHIP_WORKSPACE_API_BASE) return process.env.SHIP_WORKSPACE_API_BASE.replace(/\/+$/, "");
+  if (process.env.SHIP_API_BASE) return process.env.SHIP_API_BASE.replace(/\/+$/, "");
+  return "https://api.ship.elmundi.com";
+}
+
+async function resolveSoleWorkspace(baseUrl, token) {
+  const rows = await apiGetJson(baseUrl, "/v1/workspaces", token);
+  if (!Array.isArray(rows) || rows.length === 0) {
+    console.error("No workspaces visible to this token.");
+    process.exit(1);
+  }
+  if (rows.length > 1) {
+    console.error("Token has access to more than one workspace; pass --workspace <id>.");
+    process.exit(1);
+  }
+  return String(rows[0].id);
+}
+
+async function resolveRepoId(baseUrl, token, workspaceId, hint) {
+  if (hint && /^[0-9a-fA-F-]{32,36}$/.test(hint) && hint.includes("-")) return hint;
+  const rows = await apiGetJson(baseUrl, `/v1/workspaces/${encodeURIComponent(workspaceId)}/repos`, token);
+  if (!Array.isArray(rows) || rows.length === 0) {
+    console.error(`Workspace ${workspaceId} has no activated repos.`);
+    process.exit(1);
+  }
+  if (hint) {
+    const match = rows.find((r) => r.full_name === hint || `${r.owner ?? ""}/${r.name ?? ""}` === hint || r.id === hint);
+    if (!match) {
+      console.error(`--repo ${hint} doesn't match any activated repo in workspace ${workspaceId}.`);
+      process.exit(1);
+    }
+    return String(match.id);
+  }
+  return String(rows[0].id);
+}
+
+async function apiGetJson(baseUrl, path, token) {
+  return apiRequest(baseUrl, path, "GET", token, null);
+}
+
+async function apiPostJson(baseUrl, path, body, token) {
+  return apiRequest(baseUrl, path, "POST", token, body);
+}
+
+async function apiRequest(baseUrl, path, method, token, body) {
+  const url = `${baseUrl}${path}`;
+  let res;
+  try {
+    res = await fetch(url, {
+      method,
+      headers: {
+        "Content-Type": "application/json",
+        Accept: "application/json",
+        Authorization: `Bearer ${token}`,
+      },
+      body: body === null ? undefined : JSON.stringify(body),
+    });
+  } catch (err) {
+    console.error(`Network error calling ${url}: ${err instanceof Error ? err.message : err}`);
+    process.exit(3);
+  }
+  const text = await res.text();
+  let data = null;
+  try {
+    data = text ? JSON.parse(text) : null;
+  } catch {
+    data = text;
+  }
+  if (res.ok) return data;
+  const msg = typeof data === "string" ? data : JSON.stringify(data);
+  console.error(`HTTP ${res.status} ${res.statusText} on ${method} ${url}\n${msg}`);
+  process.exit(res.status >= 500 ? 3 : 1);
+}