@hivefloor/cli 0.0.0-stage → 0.1.1

package/dist/chunk-PY74LT2W.js

@@ -0,0 +1,41 @@
+#!/usr/bin/env node
+
+// src/api.ts
+var ApiError = class extends Error {
+  constructor(status, code, message) {
+    super(message);
+    this.status = status;
+    this.code = code;
+  }
+  status;
+  code;
+};
+async function apiRequest(ctx, host, path, opts = {}) {
+  const headers = { accept: "application/json", ...opts.headers };
+  if (opts.token) headers.authorization = `Bearer ${opts.token}`;
+  if (opts.body !== void 0) headers["content-type"] = "application/json";
+  const res = await ctx.fetch(`${host}${path}`, {
+    method: opts.method ?? (opts.body !== void 0 ? "POST" : "GET"),
+    headers,
+    body: opts.body !== void 0 ? JSON.stringify(opts.body) : void 0,
+    signal: AbortSignal.timeout(opts.timeoutMs ?? 15e3)
+  });
+  const text = await res.text();
+  let json = null;
+  try {
+    json = text ? JSON.parse(text) : null;
+  } catch {
+    json = null;
+  }
+  return { status: res.status, json };
+}
+function errorOf(r) {
+  const j = r.json ?? {};
+  return new ApiError(r.status, typeof j.error === "string" ? j.error : "error", typeof j.message === "string" ? j.message : `HTTP ${r.status}`);
+}
+
+export {
+  ApiError,
+  apiRequest,
+  errorOf
+};

package/dist/chunk-Q2TS3GT3.js

@@ -0,0 +1,356 @@
+#!/usr/bin/env node
+import {
+  atomicWrite,
+  atomicWriteUtf16,
+  configDir,
+  credentialsFile,
+  home,
+  isRecord,
+  readText,
+  removeFile
+} from "./chunk-WNDUGQDX.js";
+import {
+  cliNpxCommand,
+  runCmd
+} from "./chunk-ZYRPQPGL.js";
+
+// src/service/units.ts
+import os from "os";
+import path from "path";
+var LAUNCHD_LABEL = "dev.hivefloor.machine";
+var SYSTEMD_UNIT = "hivefloor.service";
+var SCHTASKS_TASK = "Hivefloor Machine";
+var xml = (s) => s.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;");
+var sdEscape = (s) => s.replace(/(["\\$])/g, "\\$1").replace(/%/g, "%%");
+var sdQuote = (s) => /^[\w@+=:,./-]+$/.test(s) ? s : `"${sdEscape(s)}"`;
+function launchdPlist(plan) {
+  const bin = path.dirname(plan.node);
+  return `<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+  <key>Label</key>
+  <string>${LAUNCHD_LABEL}</string>
+  <key>ProgramArguments</key>
+  <array>
+    <string>${xml(plan.node)}</string>
+    <string>${xml(plan.script)}</string>
+    <string>service</string>
+    <string>run</string>
+  </array>
+  <key>RunAtLoad</key>
+  <true/>
+  <key>KeepAlive</key>
+  <dict>
+    <key>SuccessfulExit</key>
+    <false/>
+  </dict>
+  <key>ThrottleInterval</key>
+  <integer>30</integer>
+  <key>EnvironmentVariables</key>
+  <dict>
+    <key>PATH</key>
+    <string>${xml(`${bin}:/usr/local/bin:/usr/bin:/bin:/usr/sbin:/sbin`)}</string>
+  </dict>
+  <key>StandardOutPath</key>
+  <string>/dev/null</string>
+  <key>StandardErrorPath</key>
+  <string>/dev/null</string>
+</dict>
+</plist>
+`;
+}
+function systemdUnit(plan) {
+  return `[Unit]
+Description=Hivefloor machine service
+After=network-online.target
+
+[Service]
+ExecStart=${sdQuote(plan.node)} ${sdQuote(plan.script)} service run
+Restart=on-failure
+RestartSec=30
+Environment="PATH=${sdEscape(`${path.dirname(plan.node)}:/usr/local/bin:/usr/bin:/bin`)}"
+
+[Install]
+WantedBy=default.target
+`;
+}
+var winQuote = (s) => /\s/.test(s) ? `"${s}"` : s;
+function windowsTaskExec(plan) {
+  return {
+    command: path.win32.normalize(plan.node),
+    arguments: `${winQuote(path.win32.normalize(plan.script))} service run`
+  };
+}
+function windowsUser(env = process.env) {
+  const name = env.USERNAME || os.userInfo().username;
+  return env.USERDOMAIN ? `${env.USERDOMAIN}\\${name}` : name;
+}
+function windowsTaskXml(plan, user) {
+  const ex = windowsTaskExec(plan);
+  return `<?xml version="1.0" encoding="UTF-16"?>
+<Task version="1.2" xmlns="http://schemas.microsoft.com/windows/2004/02/mit/task">
+  <RegistrationInfo>
+    <Description>Hivefloor machine service</Description>
+  </RegistrationInfo>
+  <Triggers>
+    <LogonTrigger>
+      <Enabled>true</Enabled>
+      <UserId>${xml(user)}</UserId>
+    </LogonTrigger>
+  </Triggers>
+  <Principals>
+    <Principal id="Author">
+      <UserId>${xml(user)}</UserId>
+      <LogonType>InteractiveToken</LogonType>
+      <RunLevel>LeastPrivilege</RunLevel>
+    </Principal>
+  </Principals>
+  <Settings>
+    <AllowStartOnDemand>true</AllowStartOnDemand>
+    <RestartOnFailure>
+      <Interval>PT1M</Interval>
+      <Count>255</Count>
+    </RestartOnFailure>
+    <ExecutionTimeLimit>PT0S</ExecutionTimeLimit>
+    <MultipleInstancesPolicy>IgnoreNew</MultipleInstancesPolicy>
+    <DisallowStartIfOnBatteries>false</DisallowStartIfOnBatteries>
+    <StopIfGoingOnBatteries>false</StopIfGoingOnBatteries>
+    <Enabled>true</Enabled>
+  </Settings>
+  <Actions Context="Author">
+    <Exec>
+      <Command>${xml(ex.command)}</Command>
+      <Arguments>${xml(ex.arguments)}</Arguments>
+    </Exec>
+  </Actions>
+</Task>
+`;
+}
+var launchdFile = () => path.join(home(), "Library", "LaunchAgents", `${LAUNCHD_LABEL}.plist`);
+var systemdFile = () => path.join(home(), ".config", "systemd", "user", SYSTEMD_UNIT);
+var windowsTaskFile = () => path.join(configDir(), "service-task.xml");
+async function installService(platform, run, plan, uid, env = process.env) {
+  const res = { lines: [], warnings: [] };
+  if (platform === "darwin") {
+    const file = launchdFile();
+    atomicWrite(file, launchdPlist(plan), 420);
+    const domain = `gui/${uid ?? 501}`;
+    await run("launchctl", ["bootout", `${domain}/${LAUNCHD_LABEL}`]);
+    const r = await run("launchctl", ["bootstrap", domain, file]);
+    res.installed = { kind: "launchd", file };
+    if (r.code === 0) res.lines.push(`Service: launchd agent ${LAUNCHD_LABEL} (${file})`);
+    else res.warnings.push(`the service unit was written to ${file} but launchctl could not start it; log out and in, or run: ${cliNpxCommand("service run")}`);
+    return res;
+  }
+  if (platform === "linux") {
+    const file = systemdFile();
+    atomicWrite(file, systemdUnit(plan), 420);
+    res.installed = { kind: "systemd", file };
+    await run("systemctl", ["--user", "daemon-reload"]);
+    const r = await run("systemctl", ["--user", "enable", "--now", SYSTEMD_UNIT]);
+    if (r.code === 0) res.lines.push(`Service: systemd user unit ${SYSTEMD_UNIT} (${file})`);
+    else res.warnings.push(`the service unit was written to ${file} but systemd could not start it (no user session?); run: ${cliNpxCommand("service run")}`);
+    const lg = await run("loginctl", ["show-user", process.env.USER ?? "", "-p", "Linger"]);
+    if (lg.code === 0 && /Linger=no/.test(lg.stdout)) res.warnings.push("to keep reporting while you are logged out, run once: loginctl enable-linger");
+    return res;
+  }
+  if (platform === "win32") {
+    const file = windowsTaskFile();
+    atomicWriteUtf16(file, windowsTaskXml(plan, windowsUser(env)), 384);
+    const create = await run("schtasks", ["/Create", "/TN", SCHTASKS_TASK, "/XML", file, "/F"]);
+    removeFile(file);
+    if (create.code !== 0) {
+      res.warnings.push(`schtasks could not create the Scheduled Task: hooks post directly, and the machine shows offline; run connect again, or start it by hand with: ${cliNpxCommand("service run")}`);
+      return res;
+    }
+    res.installed = { kind: "windows", file: SCHTASKS_TASK };
+    const r = await run("schtasks", ["/Run", "/TN", SCHTASKS_TASK]);
+    if (r.code === 0) res.lines.push(`Service: Scheduled Task "${SCHTASKS_TASK}" (starts when you log in)`);
+    else res.warnings.push(`the Scheduled Task was created but schtasks could not start it; start it by hand with: schtasks /Run /TN "${SCHTASKS_TASK}"`);
+    return res;
+  }
+  res.warnings.push("no background service on this system yet: hooks post directly, and the machine shows offline");
+  return res;
+}
+function parseCsvRow(line) {
+  const out = [];
+  let field = "";
+  let quoted = false;
+  for (let i = 0; i < line.length; i++) {
+    const c = line[i];
+    if (quoted) {
+      if (c !== '"') field += c;
+      else if (line[i + 1] === '"') {
+        field += '"';
+        i++;
+      } else quoted = false;
+    } else if (c === '"') quoted = true;
+    else if (c === ",") {
+      out.push(field);
+      field = "";
+    } else field += c;
+  }
+  out.push(field);
+  return out;
+}
+async function windowsServiceStatus(run) {
+  const r = await run("schtasks", ["/Query", "/TN", SCHTASKS_TASK, "/FO", "CSV", "/NH"]);
+  if (r.code !== 0) return "missing";
+  const row = r.stdout.split(/\r?\n/).find((l) => l.trim() !== "");
+  if (!row) return "missing";
+  const status = (parseCsvRow(row)[2] ?? "").trim();
+  return /^running$/i.test(status) ? "running" : "installed";
+}
+async function uninstallService(svc, run, uid) {
+  if (svc.kind === "launchd") await run("launchctl", ["bootout", `gui/${uid ?? 501}/${LAUNCHD_LABEL}`]);
+  else if (svc.kind === "systemd") {
+    await run("systemctl", ["--user", "disable", "--now", SYSTEMD_UNIT]);
+  } else {
+    await run("schtasks", ["/End", "/TN", SCHTASKS_TASK]);
+    await run("schtasks", ["/Delete", "/TN", SCHTASKS_TASK, "/F"]);
+  }
+  if (svc.kind !== "windows") removeFile(svc.file);
+  if (svc.kind === "systemd") await run("systemctl", ["--user", "daemon-reload"]);
+}
+
+// src/credentials.ts
+import fs from "fs";
+var SERVICE = "hivefloor";
+var realKeyring = async () => {
+  if (process.env.HIVEFLOOR_KEYRING === "0") return void 0;
+  try {
+    return await import("@napi-rs/keyring");
+  } catch {
+    return void 0;
+  }
+};
+var loadKeyring = realKeyring;
+var account = (host, tool) => `${host}#${tool}`;
+function readCredentials() {
+  const text = readText(credentialsFile());
+  const empty = { version: 1, hosts: {} };
+  if (!text) return empty;
+  try {
+    const j = JSON.parse(text);
+    if (isRecord(j) && isRecord(j.hosts)) return { version: 1, default_host: typeof j.default_host === "string" ? j.default_host : void 0, hosts: j.hosts };
+  } catch {
+  }
+  return empty;
+}
+function prepareConfigDir() {
+  const dir = configDir();
+  fs.mkdirSync(dir, { recursive: true, mode: 448 });
+  fs.chmodSync(dir, 448);
+  return dir;
+}
+function writeCredentials(c) {
+  prepareConfigDir();
+  const file = credentialsFile();
+  try {
+    if (fs.lstatSync(file).isSymbolicLink()) {
+      throw new Error(`${file} is a symbolic link; the token is not written through links. Remove the link and run connect again.`);
+    }
+  } catch (e) {
+    if (e.code !== "ENOENT") throw e;
+  }
+  atomicWrite(file, JSON.stringify(c, null, 2) + "\n", 384);
+}
+async function secureWindowsCredentials(run, username) {
+  if (!username) throw new Error("could not determine the Windows user; the token was not kept");
+  const dir = prepareConfigDir();
+  const d = await run("icacls", [dir, "/inheritance:r", "/grant:r", `${username}:(OI)(CI)F`]);
+  if (d.code !== 0) throw new Error("could not restrict the Hivefloor config to your Windows user with icacls; the token was not kept");
+}
+async function saveToken(host, tool, token, meta = {}, opts = {}) {
+  const creds = readCredentials();
+  const h = creds.hosts[host] ??= { tools: {} };
+  let storage = "file";
+  const kr = await loadKeyring();
+  if (kr) {
+    try {
+      const entry = new kr.Entry(SERVICE, account(host, tool));
+      entry.setPassword(token);
+      if (entry.getPassword() === token) storage = "keychain";
+    } catch {
+      storage = "file";
+    }
+  }
+  if (storage === "file" && (opts.platform ?? process.platform) === "win32") {
+    await secureWindowsCredentials(opts.run ?? runCmd, opts.username ?? windowsUser(process.env));
+  }
+  h.tools[tool] = { ...storage === "keychain" ? { keychain: true } : { token }, ...meta, saved_at: (/* @__PURE__ */ new Date()).toISOString() };
+  h.last_tool = tool;
+  creds.default_host = host;
+  writeCredentials(creds);
+  return storage;
+}
+function pickTool(h, tool) {
+  if (tool && h.tools[tool]) return tool;
+  if (h.last_tool && h.tools[h.last_tool]) return h.last_tool;
+  return Object.keys(h.tools)[0];
+}
+async function loadToken(host, tool) {
+  const h = readCredentials().hosts[host];
+  if (!h) return void 0;
+  const t = pickTool(h, tool);
+  const c = t ? h.tools[t] : void 0;
+  if (!t || !c) return void 0;
+  if (c.token) return { token: c.token, tool: t };
+  if (c.keychain) {
+    const kr = await loadKeyring();
+    if (!kr) return void 0;
+    try {
+      const v = new kr.Entry(SERVICE, account(host, t)).getPassword();
+      if (v) return { token: v, tool: t };
+    } catch {
+    }
+  }
+  return void 0;
+}
+function defaultHost() {
+  const c = readCredentials();
+  return c.default_host && c.hosts[c.default_host] ? c.default_host : Object.keys(c.hosts)[0];
+}
+async function deleteCredentials(host, tool) {
+  const creds = readCredentials();
+  const kr = await loadKeyring();
+  let n = 0;
+  for (const [h, hc] of Object.entries(creds.hosts)) {
+    if (host && h !== host) continue;
+    for (const [t, c] of Object.entries(hc.tools)) {
+      if (tool && t !== tool) continue;
+      if (c.keychain && kr) {
+        try {
+          const e = new kr.Entry(SERVICE, account(h, t));
+          if (e.deletePassword) e.deletePassword();
+          else e.deleteCredential?.();
+        } catch {
+        }
+      }
+      delete hc.tools[t];
+      n += 1;
+    }
+    if (hc.last_tool && !hc.tools[hc.last_tool]) hc.last_tool = Object.keys(hc.tools)[0];
+    if (Object.keys(hc.tools).length === 0) delete creds.hosts[h];
+  }
+  if (creds.default_host && !creds.hosts[creds.default_host]) creds.default_host = Object.keys(creds.hosts)[0];
+  if (n > 0) {
+    if (Object.keys(creds.hosts).length === 0) fs.rmSync(credentialsFile(), { force: true });
+    else writeCredentials(creds);
+  }
+  return n;
+}
+
+export {
+  SCHTASKS_TASK,
+  windowsUser,
+  installService,
+  windowsServiceStatus,
+  uninstallService,
+  readCredentials,
+  saveToken,
+  loadToken,
+  defaultHost,
+  deleteCredentials
+};

package/dist/chunk-SGDM7MAT.js

@@ -0,0 +1,237 @@
+#!/usr/bin/env node
+import {
+  configDir,
+  readText,
+  removeFile,
+  serviceLogFile,
+  spoolFile
+} from "./chunk-WNDUGQDX.js";
+
+// src/spool.ts
+import fs from "fs";
+import path from "path";
+var SPOOL_MAX_BYTES = 1024 * 1024;
+var LOCK_STALE_MS = 1e4;
+var CLAIM_STALE_MS = 6e4;
+var LOCK_WAIT_MS = 250;
+var CAP_SLACK = 64 * 1024;
+var counter = 0;
+var uniq = () => `${Date.now()}-${process.pid}-${counter++}`;
+function parseSpool(text) {
+  const out = [];
+  for (const line of text.split("\n")) {
+    if (!line.trim()) continue;
+    try {
+      out.push(JSON.parse(line));
+    } catch {
+    }
+  }
+  return out;
+}
+function capped(events, maxBytes = SPOOL_MAX_BYTES) {
+  const lines = events.map((e) => JSON.stringify(e));
+  let total = lines.reduce((n, l) => n + Buffer.byteLength(l) + 1, 0);
+  let start = 0;
+  while (total > maxBytes && start < lines.length) {
+    total -= Buffer.byteLength(lines[start]) + 1;
+    start += 1;
+  }
+  return { events: events.slice(start), dropped: start };
+}
+function droppedEvents(file = spoolFile()) {
+  try {
+    return Number(fs.readFileSync(`${file}.dropped`, "utf8").trim()) || 0;
+  } catch {
+    return 0;
+  }
+}
+function noteDropped(spool, dropped) {
+  if (dropped <= 0) return;
+  try {
+    fs.writeFileSync(`${spool}.dropped`, String(droppedEvents(spool) + dropped), { mode: 384 });
+  } catch {
+  }
+  try {
+    fs.appendFileSync(serviceLogFile(), `${(/* @__PURE__ */ new Date()).toISOString()} spool full: dropped ${dropped} event(s), the cap is ${SPOOL_MAX_BYTES} bytes
+`, { mode: 384 });
+  } catch {
+  }
+}
+function pause(ms) {
+  Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, ms);
+}
+var lockPath = (file) => `${file}.lock`;
+function acquireLock(file) {
+  const lp = lockPath(file);
+  const deadline = Date.now() + LOCK_WAIT_MS;
+  for (; ; ) {
+    try {
+      fs.closeSync(fs.openSync(lp, "wx", 384));
+      return true;
+    } catch (e) {
+      if (e.code !== "EEXIST") return false;
+    }
+    try {
+      if (Date.now() - fs.statSync(lp).mtimeMs > LOCK_STALE_MS) {
+        fs.rmSync(lp, { force: true });
+        continue;
+      }
+    } catch {
+      continue;
+    }
+    if (Date.now() >= deadline) return false;
+    pause(5);
+  }
+}
+function releaseLock(file) {
+  removeFile(lockPath(file));
+}
+var claimPath = (file) => `${file}.claim-${uniq()}`;
+var pendingPath = (file) => `${file}.pending-${uniq()}`;
+function sideFiles(dir, file, kind) {
+  const prefix = `${path.basename(file)}.${kind}-`;
+  let names;
+  try {
+    names = fs.readdirSync(dir);
+  } catch {
+    return [];
+  }
+  return names.filter((n) => n.startsWith(prefix)).sort().map((n) => path.join(dir, n));
+}
+function owner(file) {
+  const m = /\.(?:claim|pending)-(\d+)-(\d+)-\d+$/.exec(path.basename(file));
+  if (!m) return void 0;
+  return { ts: Number(m[1]), pid: Number(m[2]) };
+}
+function alive(pid) {
+  if (pid === process.pid) return true;
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (e) {
+    return e.code === "EPERM";
+  }
+}
+function abandoned(file) {
+  const o = owner(file);
+  if (!o) return false;
+  if (!alive(o.pid)) return true;
+  return Date.now() - o.ts > CLAIM_STALE_MS;
+}
+function writeEvents(file, events) {
+  const tmp = `${file}.tmp-${process.pid}-${counter++}`;
+  try {
+    fs.writeFileSync(tmp, events.map((e) => JSON.stringify(e)).join("\n") + (events.length ? "\n" : ""), { mode: 384 });
+    fs.renameSync(tmp, file);
+  } catch (e) {
+    removeFile(tmp);
+    throw e;
+  }
+}
+function writeSpool(file, events, maxBytes = SPOOL_MAX_BYTES) {
+  const { events: kept, dropped } = capped(events, maxBytes);
+  if (dropped > 0) noteDropped(file, dropped);
+  writeEvents(file, kept);
+}
+function recover(file) {
+  const dir = path.dirname(file);
+  const stale = [...sideFiles(dir, file, "claim").filter(abandoned), ...sideFiles(dir, file, "pending")].sort();
+  if (stale.length === 0) return;
+  const events = [];
+  for (const f of stale) events.push(...parseSpool(readText(f) ?? ""));
+  if (events.length > 0) {
+    const existing = parseSpool(readText(file) ?? "");
+    writeSpool(file, [...events, ...existing]);
+  }
+  for (const f of stale) removeFile(f);
+}
+function takeSpool(file = spoolFile()) {
+  fs.mkdirSync(configDir(), { recursive: true, mode: 448 });
+  if (!acquireLock(file)) return void 0;
+  try {
+    recover(file);
+    const claim = claimPath(file);
+    try {
+      fs.renameSync(file, claim);
+    } catch {
+      return void 0;
+    }
+    let events;
+    try {
+      events = parseSpool(fs.readFileSync(claim, "utf8"));
+    } catch {
+      return void 0;
+    }
+    if (events.length === 0) {
+      removeFile(claim);
+      return void 0;
+    }
+    return { spool: file, file: claim, events };
+  } finally {
+    releaseLock(file);
+  }
+}
+function releaseSpool(claim, keep, spool = spoolFile()) {
+  if (keep.length === 0) {
+    if (claim) removeFile(claim.file);
+    return;
+  }
+  const target = claim?.spool ?? spool;
+  try {
+    returnToSpool(keep, target);
+  } catch {
+    if (claim) {
+      try {
+        writeEvents(claim.file, keep);
+      } catch {
+      }
+      return;
+    }
+    try {
+      writeEvents(pendingPath(target), keep);
+    } catch {
+    }
+    return;
+  }
+  if (claim) removeFile(claim.file);
+}
+function returnToSpool(events, file = spoolFile()) {
+  if (events.length === 0) return;
+  fs.mkdirSync(configDir(), { recursive: true, mode: 448 });
+  if (!acquireLock(file)) {
+    writeEvents(pendingPath(file), events);
+    return;
+  }
+  try {
+    const existing = parseSpool(readText(file) ?? "");
+    writeSpool(file, [...events, ...existing]);
+  } finally {
+    releaseLock(file);
+  }
+}
+function appendToSpool(event, file = spoolFile()) {
+  fs.mkdirSync(configDir(), { recursive: true, mode: 448 });
+  const line = JSON.stringify(event) + "\n";
+  if (!acquireLock(file)) {
+    fs.appendFileSync(file, line, { mode: 384 });
+    return;
+  }
+  try {
+    fs.appendFileSync(file, line, { mode: 384 });
+    let size = 0;
+    try {
+      size = fs.statSync(file).size;
+    } catch {
+      size = 0;
+    }
+    if (size > SPOOL_MAX_BYTES) writeSpool(file, parseSpool(readText(file) ?? ""), SPOOL_MAX_BYTES - CAP_SLACK);
+  } finally {
+    releaseLock(file);
+  }
+}
+
+export {
+  takeSpool,
+  releaseSpool,
+  appendToSpool
+};

package/dist/chunk-TKMIV7BG.js

@@ -0,0 +1,46 @@
+#!/usr/bin/env node
+
+// src/args.ts
+var BOOLEAN = /* @__PURE__ */ new Set(["no-open", "yes", "y", "reveal", "help", "h", "json", "no-cli", "agent", "no-service"]);
+function parseArgs(argv) {
+  const positionals = [];
+  const flags = {};
+  for (let k = 0; k < argv.length; k++) {
+    const a = argv[k];
+    if (a === "--") {
+      positionals.push(...argv.slice(k + 1));
+      break;
+    }
+    if (a.startsWith("--") && a.length > 2) {
+      const eq = a.indexOf("=");
+      if (eq > 0) {
+        flags[a.slice(2, eq)] = a.slice(eq + 1);
+      } else {
+        const name = a.slice(2);
+        const next = argv[k + 1];
+        if (BOOLEAN.has(name) || next === void 0 || next.startsWith("--") || next === "-y" || next === "-h") {
+          flags[name] = true;
+        } else {
+          flags[name] = next;
+          k += 1;
+        }
+      }
+    } else if (a === "-y") flags.yes = true;
+    else if (a === "-h") flags.help = true;
+    else positionals.push(a);
+  }
+  return { positionals, flags };
+}
+var flagStr = (p, name) => typeof p.flags[name] === "string" ? p.flags[name] : void 0;
+function checkUnknownFlags(p, allowed) {
+  for (const f of Object.keys(p.flags)) {
+    if (!allowed.has(f)) return f;
+  }
+  return void 0;
+}
+
+export {
+  parseArgs,
+  flagStr,
+  checkUnknownFlags
+};