@zonease/happy 0.6.37 → 0.6.39

package/dist/enroll-BxlbVftP.cjs

@@ -0,0 +1,115 @@
+'use strict';
+
+var axios = require('axios');
+var tweetnacl = require('tweetnacl');
+var node_crypto = require('node:crypto');
+var logger = require('./persistence-JLUn_Nou.cjs');
+var auth = require('./auth-BIleVCw0.cjs');
+require('node:fs/promises');
+require('node:fs');
+require('node:os');
+require('node:path');
+require('zod');
+require('chalk');
+require('fs');
+require('qrcode-terminal');
+require('./time-Bj2HRkKH.cjs');
+require('./browser-Cc08m7of.cjs');
+require('open');
+require('react');
+require('ink');
+
+async function hmac_sha512(key, data) {
+  const hmac = node_crypto.createHmac("sha512", key);
+  hmac.update(data);
+  return new Uint8Array(hmac.digest());
+}
+
+async function deriveSecretKeyTreeRoot(seed, usage) {
+  const I = await hmac_sha512(new TextEncoder().encode(usage + " Master Seed"), seed);
+  return {
+    key: I.slice(0, 32),
+    chainCode: I.slice(32)
+  };
+}
+async function deriveSecretKeyTreeChild(chainCode, index) {
+  const data = new Uint8Array([0, ...new TextEncoder().encode(index)]);
+  const I = await hmac_sha512(chainCode, data);
+  return {
+    key: I.subarray(0, 32),
+    chainCode: I.subarray(32)
+  };
+}
+async function deriveKey(master, usage, path) {
+  let state = await deriveSecretKeyTreeRoot(master, usage);
+  let remaining = [...path];
+  while (remaining.length > 0) {
+    let index = remaining[0];
+    remaining = remaining.slice(1);
+    state = await deriveSecretKeyTreeChild(state.chainCode, index);
+  }
+  return state.key;
+}
+
+function parseEnrollToken(raw) {
+  const trimmed = raw.trim();
+  const separator = trimmed.indexOf(".");
+  if (separator <= 0 || separator === trimmed.length - 1) {
+    throw new Error("Invalid enrollment token format");
+  }
+  const lookupId = trimmed.slice(0, separator);
+  const secret = logger.decodeBase64(trimmed.slice(separator + 1), "base64url");
+  if (secret.length !== 32) {
+    throw new Error("Invalid enrollment token secret");
+  }
+  return { lookupId, secret };
+}
+async function enrollDevice(rawToken, options = {}) {
+  const existing = await logger.readCredentials();
+  if (existing && !options.force) {
+    return { alreadyEnrolled: true };
+  }
+  const { lookupId, secret } = parseEnrollToken(rawToken);
+  let response;
+  try {
+    const result = await axios.post(
+      `${logger.configuration.serverUrl}/v1/devices/enroll`,
+      { lookupId },
+      { timeout: 3e4 }
+    );
+    response = result.data;
+  } catch (error) {
+    if (axios.isAxiosError(error) && error.response) {
+      const message = error.response.data?.error ?? `HTTP ${error.response.status}`;
+      throw new Error(`Enrollment failed: ${message}`);
+    }
+    throw error;
+  }
+  const sealed = logger.decodeBase64(response.response);
+  const boxSecretKey = tweetnacl.hash(secret).slice(0, 32);
+  const opened = auth.decryptWithEphemeralKey(sealed, boxSecretKey);
+  if (!opened) {
+    throw new Error("Enrollment failed: could not open the account key with this token");
+  }
+  await logger.updateSettings((settings) => ({ ...settings, deviceMode: true }));
+  if (opened.length === 32) {
+    const contentDataKey = await deriveKey(opened, "Happy EnCoder", ["content"]);
+    await logger.writeCredentialsDataKey({
+      publicKey: logger.libsodiumPublicKeyFromSecretKey(contentDataKey),
+      machineKey: node_crypto.randomBytes(32),
+      token: response.token
+    });
+    return { alreadyEnrolled: false };
+  }
+  if (opened[0] === 0 && opened.length >= 33) {
+    await logger.writeCredentialsDataKey({
+      publicKey: opened.slice(1, 33),
+      machineKey: node_crypto.randomBytes(32),
+      token: response.token
+    });
+    return { alreadyEnrolled: false };
+  }
+  throw new Error("Enrollment failed: unsupported account key format");
+}
+
+exports.enrollDevice = enrollDevice;

package/dist/enroll-C52x8oly.mjs

@@ -0,0 +1,113 @@
+import axios from 'axios';
+import tweetnacl from 'tweetnacl';
+import { createHmac, randomBytes } from 'node:crypto';
+import { r as readCredentials, c as configuration, e as decodeBase64, u as updateSettings, w as writeCredentialsDataKey, o as libsodiumPublicKeyFromSecretKey } from './persistence-BFjvtUad.mjs';
+import { decryptWithEphemeralKey } from './auth-BE8dD20T.mjs';
+import 'node:fs/promises';
+import 'node:fs';
+import 'node:os';
+import 'node:path';
+import 'zod';
+import 'chalk';
+import 'fs';
+import 'qrcode-terminal';
+import './time-DgsBLJA_.mjs';
+import './browser-Dll5hxOV.mjs';
+import 'open';
+import 'react';
+import 'ink';
+
+async function hmac_sha512(key, data) {
+  const hmac = createHmac("sha512", key);
+  hmac.update(data);
+  return new Uint8Array(hmac.digest());
+}
+
+async function deriveSecretKeyTreeRoot(seed, usage) {
+  const I = await hmac_sha512(new TextEncoder().encode(usage + " Master Seed"), seed);
+  return {
+    key: I.slice(0, 32),
+    chainCode: I.slice(32)
+  };
+}
+async function deriveSecretKeyTreeChild(chainCode, index) {
+  const data = new Uint8Array([0, ...new TextEncoder().encode(index)]);
+  const I = await hmac_sha512(chainCode, data);
+  return {
+    key: I.subarray(0, 32),
+    chainCode: I.subarray(32)
+  };
+}
+async function deriveKey(master, usage, path) {
+  let state = await deriveSecretKeyTreeRoot(master, usage);
+  let remaining = [...path];
+  while (remaining.length > 0) {
+    let index = remaining[0];
+    remaining = remaining.slice(1);
+    state = await deriveSecretKeyTreeChild(state.chainCode, index);
+  }
+  return state.key;
+}
+
+function parseEnrollToken(raw) {
+  const trimmed = raw.trim();
+  const separator = trimmed.indexOf(".");
+  if (separator <= 0 || separator === trimmed.length - 1) {
+    throw new Error("Invalid enrollment token format");
+  }
+  const lookupId = trimmed.slice(0, separator);
+  const secret = decodeBase64(trimmed.slice(separator + 1), "base64url");
+  if (secret.length !== 32) {
+    throw new Error("Invalid enrollment token secret");
+  }
+  return { lookupId, secret };
+}
+async function enrollDevice(rawToken, options = {}) {
+  const existing = await readCredentials();
+  if (existing && !options.force) {
+    return { alreadyEnrolled: true };
+  }
+  const { lookupId, secret } = parseEnrollToken(rawToken);
+  let response;
+  try {
+    const result = await axios.post(
+      `${configuration.serverUrl}/v1/devices/enroll`,
+      { lookupId },
+      { timeout: 3e4 }
+    );
+    response = result.data;
+  } catch (error) {
+    if (axios.isAxiosError(error) && error.response) {
+      const message = error.response.data?.error ?? `HTTP ${error.response.status}`;
+      throw new Error(`Enrollment failed: ${message}`);
+    }
+    throw error;
+  }
+  const sealed = decodeBase64(response.response);
+  const boxSecretKey = tweetnacl.hash(secret).slice(0, 32);
+  const opened = decryptWithEphemeralKey(sealed, boxSecretKey);
+  if (!opened) {
+    throw new Error("Enrollment failed: could not open the account key with this token");
+  }
+  await updateSettings((settings) => ({ ...settings, deviceMode: true }));
+  if (opened.length === 32) {
+    const contentDataKey = await deriveKey(opened, "Happy EnCoder", ["content"]);
+    await writeCredentialsDataKey({
+      publicKey: libsodiumPublicKeyFromSecretKey(contentDataKey),
+      machineKey: randomBytes(32),
+      token: response.token
+    });
+    return { alreadyEnrolled: false };
+  }
+  if (opened[0] === 0 && opened.length >= 33) {
+    await writeCredentialsDataKey({
+      publicKey: opened.slice(1, 33),
+      machineKey: randomBytes(32),
+      token: response.token
+    });
+    return { alreadyEnrolled: false };
+  }
+  throw new Error("Enrollment failed: unsupported account key format");
+}
+
+export { enrollDevice };

package/dist/evidence-Ccd9iYcj.mjs

@@ -0,0 +1,127 @@
+import chalk from 'chalk';
+import { constants } from 'node:fs';
+import { mkdir, appendFile, access, readFile } from 'node:fs/promises';
+import { randomUUID } from 'node:crypto';
+import { basename, dirname, resolve } from 'node:path';
+import { c as configuration } from './persistence-BFjvtUad.mjs';
+import { r as renderEvidenceReport, i as inferEvidenceKind } from './workflowReports-Dd8-4-8f.mjs';
+import { p as parseWorkflowArgs, s as stringFlag, b as booleanFlag, a as printOrWriteOutput } from './workflowCommon-B0d01Y_a.mjs';
+import 'node:os';
+import 'zod';
+import 'tweetnacl';
+import 'fs';
+
+const EVIDENCE_FILE = `${configuration.happyHomeDir}/evidence/evidence.jsonl`;
+function printEvidenceHelp() {
+  console.log(`
+${chalk.bold("happy evidence")} - Collect and render UI/debug evidence
+
+${chalk.bold("Usage:")}
+  happy evidence add <path-or-url> [options]
+  happy evidence list [options]
+  happy evidence report [options]
+
+${chalk.bold("Options:")}
+  --title <text>       Human-readable evidence title
+  --kind <kind>        image | log | url | file (default: inferred)
+  --session <id>       Attach evidence to a Happy session
+  --note <text>        Short note shown in reports
+  --out <path>         Write report/list markdown to a file
+  --json               Print machine-readable JSON
+  -h, --help           Show this help
+`);
+}
+function normalizeEvidenceTarget(target) {
+  if (/^(https?:|file:)/i.test(target)) return target;
+  return resolve(target);
+}
+async function readEvidenceEntries() {
+  try {
+    const content = await readFile(EVIDENCE_FILE, "utf8");
+    return content.split("\n").map((line) => line.trim()).filter(Boolean).map((line) => JSON.parse(line));
+  } catch (error) {
+    if (error.code === "ENOENT") return [];
+    throw error;
+  }
+}
+function filterEvidenceEntries(entries, sessionId) {
+  if (!sessionId) return entries;
+  return entries.filter((entry) => entry.sessionId === sessionId);
+}
+async function assertLocalFileExists(target) {
+  if (/^https?:/i.test(target) || /^file:/i.test(target)) return;
+  await access(target, constants.R_OK);
+}
+function parseKind(kind, target) {
+  if (!kind) return inferEvidenceKind(target);
+  if (kind === "image" || kind === "log" || kind === "url" || kind === "file") return kind;
+  throw new Error("--kind must be one of: image, log, url, file.");
+}
+async function addEvidence(args) {
+  const parsed = parseWorkflowArgs(args, /* @__PURE__ */ new Set(["--title", "--kind", "--session", "--note"]));
+  const target = parsed.positionals[0];
+  if (!target) {
+    throw new Error('Evidence target required. Use "happy evidence add <path-or-url>".');
+  }
+  const normalizedTarget = normalizeEvidenceTarget(target);
+  await assertLocalFileExists(normalizedTarget);
+  const entry = {
+    id: randomUUID(),
+    createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+    target: normalizedTarget,
+    title: stringFlag(parsed, "--title") ?? basename(normalizedTarget),
+    kind: parseKind(stringFlag(parsed, "--kind"), normalizedTarget),
+    sessionId: stringFlag(parsed, "--session"),
+    note: stringFlag(parsed, "--note")
+  };
+  await mkdir(dirname(EVIDENCE_FILE), { recursive: true });
+  await appendFile(EVIDENCE_FILE, `${JSON.stringify(entry)}
+`, "utf8");
+  if (booleanFlag(parsed, "--json")) {
+    console.log(JSON.stringify(entry, null, 2));
+  } else {
+    console.log(`Added evidence ${entry.id}: ${entry.target}`);
+  }
+}
+async function listEvidence(args) {
+  const parsed = parseWorkflowArgs(args, /* @__PURE__ */ new Set(["--session", "--out"]));
+  const entries = filterEvidenceEntries(await readEvidenceEntries(), stringFlag(parsed, "--session"));
+  if (booleanFlag(parsed, "--json")) {
+    console.log(JSON.stringify(entries, null, 2));
+    return;
+  }
+  const output = entries.length === 0 ? "No evidence recorded." : entries.map((entry) => `- ${entry.createdAt} [${entry.kind}] ${entry.title}: ${entry.target}`).join("\n");
+  await printOrWriteOutput(output, stringFlag(parsed, "--out"));
+}
+async function reportEvidence(args) {
+  const parsed = parseWorkflowArgs(args, /* @__PURE__ */ new Set(["--session", "--out", "--title"]));
+  const entries = filterEvidenceEntries(await readEvidenceEntries(), stringFlag(parsed, "--session"));
+  const title = stringFlag(parsed, "--title") ?? "Evidence Report";
+  if (booleanFlag(parsed, "--json")) {
+    console.log(JSON.stringify({ title, entries }, null, 2));
+    return;
+  }
+  await printOrWriteOutput(renderEvidenceReport(entries, title), stringFlag(parsed, "--out"));
+}
+async function handleEvidenceCommand(args) {
+  const action = args[0];
+  if (!action || action === "-h" || action === "--help") {
+    printEvidenceHelp();
+    return;
+  }
+  if (action === "add") {
+    await addEvidence(args.slice(1));
+    return;
+  }
+  if (action === "list") {
+    await listEvidence(args.slice(1));
+    return;
+  }
+  if (action === "report") {
+    await reportEvidence(args.slice(1));
+    return;
+  }
+  throw new Error(`Unknown evidence command: ${action}. Use add, list, or report.`);
+}
+
+export { handleEvidenceCommand };

package/dist/evidence-CjWBG5rX.cjs

@@ -0,0 +1,129 @@
+'use strict';
+
+var chalk = require('chalk');
+var fs = require('node:fs');
+var promises = require('node:fs/promises');
+var node_crypto = require('node:crypto');
+var path = require('node:path');
+var logger = require('./persistence-JLUn_Nou.cjs');
+var workflowReports = require('./workflowReports-BEWuQesA.cjs');
+var workflowCommon = require('./workflowCommon-Bl568-rt.cjs');
+require('node:os');
+require('zod');
+require('tweetnacl');
+require('fs');
+
+const EVIDENCE_FILE = `${logger.configuration.happyHomeDir}/evidence/evidence.jsonl`;
+function printEvidenceHelp() {
+  console.log(`
+${chalk.bold("happy evidence")} - Collect and render UI/debug evidence
+
+${chalk.bold("Usage:")}
+  happy evidence add <path-or-url> [options]
+  happy evidence list [options]
+  happy evidence report [options]
+
+${chalk.bold("Options:")}
+  --title <text>       Human-readable evidence title
+  --kind <kind>        image | log | url | file (default: inferred)
+  --session <id>       Attach evidence to a Happy session
+  --note <text>        Short note shown in reports
+  --out <path>         Write report/list markdown to a file
+  --json               Print machine-readable JSON
+  -h, --help           Show this help
+`);
+}
+function normalizeEvidenceTarget(target) {
+  if (/^(https?:|file:)/i.test(target)) return target;
+  return path.resolve(target);
+}
+async function readEvidenceEntries() {
+  try {
+    const content = await promises.readFile(EVIDENCE_FILE, "utf8");
+    return content.split("\n").map((line) => line.trim()).filter(Boolean).map((line) => JSON.parse(line));
+  } catch (error) {
+    if (error.code === "ENOENT") return [];
+    throw error;
+  }
+}
+function filterEvidenceEntries(entries, sessionId) {
+  if (!sessionId) return entries;
+  return entries.filter((entry) => entry.sessionId === sessionId);
+}
+async function assertLocalFileExists(target) {
+  if (/^https?:/i.test(target) || /^file:/i.test(target)) return;
+  await promises.access(target, fs.constants.R_OK);
+}
+function parseKind(kind, target) {
+  if (!kind) return workflowReports.inferEvidenceKind(target);
+  if (kind === "image" || kind === "log" || kind === "url" || kind === "file") return kind;
+  throw new Error("--kind must be one of: image, log, url, file.");
+}
+async function addEvidence(args) {
+  const parsed = workflowCommon.parseWorkflowArgs(args, /* @__PURE__ */ new Set(["--title", "--kind", "--session", "--note"]));
+  const target = parsed.positionals[0];
+  if (!target) {
+    throw new Error('Evidence target required. Use "happy evidence add <path-or-url>".');
+  }
+  const normalizedTarget = normalizeEvidenceTarget(target);
+  await assertLocalFileExists(normalizedTarget);
+  const entry = {
+    id: node_crypto.randomUUID(),
+    createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+    target: normalizedTarget,
+    title: workflowCommon.stringFlag(parsed, "--title") ?? path.basename(normalizedTarget),
+    kind: parseKind(workflowCommon.stringFlag(parsed, "--kind"), normalizedTarget),
+    sessionId: workflowCommon.stringFlag(parsed, "--session"),
+    note: workflowCommon.stringFlag(parsed, "--note")
+  };
+  await promises.mkdir(path.dirname(EVIDENCE_FILE), { recursive: true });
+  await promises.appendFile(EVIDENCE_FILE, `${JSON.stringify(entry)}
+`, "utf8");
+  if (workflowCommon.booleanFlag(parsed, "--json")) {
+    console.log(JSON.stringify(entry, null, 2));
+  } else {
+    console.log(`Added evidence ${entry.id}: ${entry.target}`);
+  }
+}
+async function listEvidence(args) {
+  const parsed = workflowCommon.parseWorkflowArgs(args, /* @__PURE__ */ new Set(["--session", "--out"]));
+  const entries = filterEvidenceEntries(await readEvidenceEntries(), workflowCommon.stringFlag(parsed, "--session"));
+  if (workflowCommon.booleanFlag(parsed, "--json")) {
+    console.log(JSON.stringify(entries, null, 2));
+    return;
+  }
+  const output = entries.length === 0 ? "No evidence recorded." : entries.map((entry) => `- ${entry.createdAt} [${entry.kind}] ${entry.title}: ${entry.target}`).join("\n");
+  await workflowCommon.printOrWriteOutput(output, workflowCommon.stringFlag(parsed, "--out"));
+}
+async function reportEvidence(args) {
+  const parsed = workflowCommon.parseWorkflowArgs(args, /* @__PURE__ */ new Set(["--session", "--out", "--title"]));
+  const entries = filterEvidenceEntries(await readEvidenceEntries(), workflowCommon.stringFlag(parsed, "--session"));
+  const title = workflowCommon.stringFlag(parsed, "--title") ?? "Evidence Report";
+  if (workflowCommon.booleanFlag(parsed, "--json")) {
+    console.log(JSON.stringify({ title, entries }, null, 2));
+    return;
+  }
+  await workflowCommon.printOrWriteOutput(workflowReports.renderEvidenceReport(entries, title), workflowCommon.stringFlag(parsed, "--out"));
+}
+async function handleEvidenceCommand(args) {
+  const action = args[0];
+  if (!action || action === "-h" || action === "--help") {
+    printEvidenceHelp();
+    return;
+  }
+  if (action === "add") {
+    await addEvidence(args.slice(1));
+    return;
+  }
+  if (action === "list") {
+    await listEvidence(args.slice(1));
+    return;
+  }
+  if (action === "report") {
+    await reportEvidence(args.slice(1));
+    return;
+  }
+  throw new Error(`Unknown evidence command: ${action}. Use add, list, or report.`);
+}
+
+exports.handleEvidenceCommand = handleEvidenceCommand;

package/dist/formatImageMessage-B4lSxlk2.mjs

@@ -0,0 +1,43 @@
+import { d as downloadImage } from './downloadImage-DfSFLb-h.mjs';
+
+async function formatMessageForClaude(text, images) {
+  const content = [];
+  for (const image of images) {
+    const downloaded = await downloadImage(image.url);
+    content.push({
+      type: "image",
+      source: {
+        type: "base64",
+        media_type: downloaded.mimeType,
+        data: downloaded.base64
+      }
+    });
+  }
+  if (text.trim()) {
+    content.push({
+      type: "text",
+      text
+    });
+  }
+  return content;
+}
+async function formatMessageForGemini(text, images) {
+  const parts = [];
+  for (const image of images) {
+    const downloaded = await downloadImage(image.url);
+    parts.push({
+      inlineData: {
+        mimeType: downloaded.mimeType,
+        data: downloaded.base64
+      }
+    });
+  }
+  if (text.trim()) {
+    parts.push({
+      text
+    });
+  }
+  return { parts };
+}
+
+export { formatMessageForClaude as a, formatMessageForGemini as f };

package/dist/formatImageMessage-DbyG8c2j.cjs

@@ -0,0 +1,46 @@
+'use strict';
+
+var downloadImage = require('./downloadImage-MQMrUUxS.cjs');
+
+async function formatMessageForClaude(text, images) {
+  const content = [];
+  for (const image of images) {
+    const downloaded = await downloadImage.downloadImage(image.url);
+    content.push({
+      type: "image",
+      source: {
+        type: "base64",
+        media_type: downloaded.mimeType,
+        data: downloaded.base64
+      }
+    });
+  }
+  if (text.trim()) {
+    content.push({
+      type: "text",
+      text
+    });
+  }
+  return content;
+}
+async function formatMessageForGemini(text, images) {
+  const parts = [];
+  for (const image of images) {
+    const downloaded = await downloadImage.downloadImage(image.url);
+    parts.push({
+      inlineData: {
+        mimeType: downloaded.mimeType,
+        data: downloaded.base64
+      }
+    });
+  }
+  if (text.trim()) {
+    parts.push({
+      text
+    });
+  }
+  return { parts };
+}
+
+exports.formatMessageForClaude = formatMessageForClaude;
+exports.formatMessageForGemini = formatMessageForGemini;

package/dist/github-DKcyF1zp.mjs

@@ -0,0 +1,57 @@
+import chalk from 'chalk';
+import { b as buildGithubTakeoverReport } from './workflowReports-Dd8-4-8f.mjs';
+import { p as parseWorkflowArgs, b as booleanFlag, s as stringFlag, a as printOrWriteOutput } from './workflowCommon-B0d01Y_a.mjs';
+import 'node:path';
+import 'node:fs/promises';
+
+function printGithubHelp() {
+  console.log(`
+${chalk.bold("happy github")} - GitHub workflow helpers
+
+${chalk.bold("Usage:")}
+  happy github takeover <issue-or-pr-url-or-number> [options]
+
+${chalk.bold("Options:")}
+  --repo <owner/name>      Repository when target is not a full URL
+  --mode <auto|pr|issue>   Target type hint (default: auto)
+  --out <path>             Write the prompt/checklist to a markdown file
+  --json                   Print machine-readable JSON
+  -h, --help               Show this help
+`);
+}
+async function handleGithubCommand(args) {
+  const action = args[0];
+  if (!action || action === "-h" || action === "--help") {
+    printGithubHelp();
+    return;
+  }
+  if (action !== "takeover") {
+    throw new Error(`Unknown github command: ${action}. Use "happy github takeover".`);
+  }
+  const parsed = parseWorkflowArgs(args.slice(1), /* @__PURE__ */ new Set(["--repo", "--mode", "--out"]));
+  if (booleanFlag(parsed, "--help") || booleanFlag(parsed, "-h")) {
+    printGithubHelp();
+    return;
+  }
+  const target = parsed.positionals[0];
+  if (!target) {
+    throw new Error('Target required. Use "happy github takeover <issue-or-pr-url-or-number>".');
+  }
+  const mode = stringFlag(parsed, "--mode") ?? "auto";
+  if (mode !== "auto" && mode !== "pr" && mode !== "issue") {
+    throw new Error("--mode must be one of: auto, pr, issue.");
+  }
+  const input = {
+    target,
+    repo: stringFlag(parsed, "--repo"),
+    mode
+  };
+  const report = buildGithubTakeoverReport(input);
+  if (booleanFlag(parsed, "--json")) {
+    console.log(JSON.stringify({ ...input, report }, null, 2));
+    return;
+  }
+  await printOrWriteOutput(report, stringFlag(parsed, "--out"));
+}
+
+export { handleGithubCommand };

package/dist/github-h9GhJJ_C.cjs

@@ -0,0 +1,59 @@
+'use strict';
+
+var chalk = require('chalk');
+var workflowReports = require('./workflowReports-BEWuQesA.cjs');
+var workflowCommon = require('./workflowCommon-Bl568-rt.cjs');
+require('node:path');
+require('node:fs/promises');
+
+function printGithubHelp() {
+  console.log(`
+${chalk.bold("happy github")} - GitHub workflow helpers
+
+${chalk.bold("Usage:")}
+  happy github takeover <issue-or-pr-url-or-number> [options]
+
+${chalk.bold("Options:")}
+  --repo <owner/name>      Repository when target is not a full URL
+  --mode <auto|pr|issue>   Target type hint (default: auto)
+  --out <path>             Write the prompt/checklist to a markdown file
+  --json                   Print machine-readable JSON
+  -h, --help               Show this help
+`);
+}
+async function handleGithubCommand(args) {
+  const action = args[0];
+  if (!action || action === "-h" || action === "--help") {
+    printGithubHelp();
+    return;
+  }
+  if (action !== "takeover") {
+    throw new Error(`Unknown github command: ${action}. Use "happy github takeover".`);
+  }
+  const parsed = workflowCommon.parseWorkflowArgs(args.slice(1), /* @__PURE__ */ new Set(["--repo", "--mode", "--out"]));
+  if (workflowCommon.booleanFlag(parsed, "--help") || workflowCommon.booleanFlag(parsed, "-h")) {
+    printGithubHelp();
+    return;
+  }
+  const target = parsed.positionals[0];
+  if (!target) {
+    throw new Error('Target required. Use "happy github takeover <issue-or-pr-url-or-number>".');
+  }
+  const mode = workflowCommon.stringFlag(parsed, "--mode") ?? "auto";
+  if (mode !== "auto" && mode !== "pr" && mode !== "issue") {
+    throw new Error("--mode must be one of: auto, pr, issue.");
+  }
+  const input = {
+    target,
+    repo: workflowCommon.stringFlag(parsed, "--repo"),
+    mode
+  };
+  const report = workflowReports.buildGithubTakeoverReport(input);
+  if (workflowCommon.booleanFlag(parsed, "--json")) {
+    console.log(JSON.stringify({ ...input, report }, null, 2));
+    return;
+  }
+  await workflowCommon.printOrWriteOutput(report, workflowCommon.stringFlag(parsed, "--out"));
+}
+
+exports.handleGithubCommand = handleGithubCommand;