appduct 0.10.0 → 0.11.0

package/dist/cli/routes/init.js

@@ -0,0 +1,1486 @@
+// src/commands/init.ts
+import { chmod, mkdir, readFile as readFile3, writeFile } from "node:fs/promises";
+import { dirname as dirname3, join as join5, resolve as resolve2 } from "node:path";
+
+// src/rpc/client.ts
+import { join as join2 } from "node:path";
+import { RPC_METHODS } from "@appduct/shared";
+
+// src/daemon/config.ts
+var DEFAULT_DAEMON_LOG_MAX_BYTES = 10 * 1024 * 1024;
+
+// src/package-root.ts
+import { existsSync, readFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+var PACKAGE_NAME = "appduct";
+var cached;
+var getPackageRoot = () => {
+  if (cached !== void 0) {
+    return cached;
+  }
+  let dir = dirname(fileURLToPath(import.meta.url));
+  for (; ; ) {
+    const candidate = join(dir, "package.json");
+    if (existsSync(candidate)) {
+      let name;
+      try {
+        name = JSON.parse(readFileSync(candidate, "utf8")).name;
+      } catch {
+      }
+      if (name === PACKAGE_NAME) {
+        cached = dir;
+        return dir;
+      }
+    }
+    const parent = dirname(dir);
+    if (parent === dir) {
+      throw new Error(`Could not locate the "${PACKAGE_NAME}" package root above ${import.meta.url}.`);
+    }
+    dir = parent;
+  }
+};
+
+// src/rpc/client.ts
+var defaultBinPath = join2(getPackageRoot(), "bin.js");
+var DaemonRpcError = class extends Error {
+  constructor(code, message, data) {
+    super(message);
+    this.code = code;
+    this.data = data;
+    this.name = "DaemonRpcError";
+  }
+};
+var DaemonUnavailableError = class extends Error {
+  constructor(message, reason = "unreachable") {
+    super(message);
+    this.reason = reason;
+    this.name = "DaemonUnavailableError";
+  }
+};
+var describeLiveState = (state) => {
+  const parts = [];
+  if (state.sessions > 0) {
+    parts.push(`${state.sessions} connected session(s)`);
+  }
+  if (state.pendingLinks > 0) {
+    parts.push(`${state.pendingLinks} unclaimed link(s)`);
+  }
+  return parts.join(" and ");
+};
+var DaemonVersionMismatchError = class extends Error {
+  constructor(daemonVersion, clientVersion, live, message) {
+    super(
+      message ?? `The running Appduct daemon is version ${daemonVersion}, but this client is version ${clientVersion}. It was not restarted automatically because ${describeLiveState(live)} would be lost. Run "appduct daemon stop" once that state is expendable, or force it with "--daemon-restart".`
+    );
+    this.daemonVersion = daemonVersion;
+    this.clientVersion = clientVersion;
+    this.name = "DaemonVersionMismatchError";
+    this.sessionCount = live.sessions;
+    this.pendingLinkCount = live.pendingLinks;
+  }
+  sessionCount;
+  pendingLinkCount;
+};
+var isConnectionMissingError = (error) => {
+  const code = error.code;
+  return code === "ENOENT" || code === "ECONNREFUSED";
+};
+var isDaemonUnreachableError = (error) => {
+  return error instanceof DaemonUnavailableError || isConnectionMissingError(error);
+};
+
+// src/errors.ts
+var EXIT_CODE_BY_ERROR_TYPE = {
+  usage_error: 64,
+  validation_error: 65,
+  // EX_NOINPUT (66): "an input file did not exist or was not readable" — `doctor` throws this for a
+  // missing external tool or an unreadable/corrupt artifact, deliberately distinct from every other
+  // code here so a release pipeline can't mistake "we couldn't tell" for either a clean pass or an
+  // assertion failure (docs/tasks/08-appduct-doctor.md).
+  inspection_error: 66,
+  connection_error: 70,
+  session_error: 71,
+  tool_error: 72,
+  permission_error: 77,
+  internal_error: 1,
+  // `doctor --assert-present`/`--assert-absent`: the artifact was inspected successfully and the
+  // assertion did not hold. Distinct from `inspection_error` (66) — this means the answer is known
+  // and it's "no", not "couldn't tell" — and distinct from `internal_error` (1) so a caller can't
+  // conflate a normal assertion failure with an unexpected crash.
+  assertion_error: 3
+};
+var RPC_ERROR_EXIT_CLASS = {
+  no_session: "session_error",
+  ambiguous_session: "session_error",
+  unknown_session: "session_error",
+  session_not_active: "session_error",
+  session_suspended: "session_error",
+  tool_not_found: "tool_error",
+  tool_input_validation_error: "tool_error",
+  tool_output_validation_error: "tool_error",
+  tool_execution_error: "tool_error",
+  tool_serialization_error: "tool_error",
+  tool_timeout: "tool_error",
+  tool_cancelled: "tool_error",
+  policy_denied: "permission_error",
+  invalid_request: "validation_error"
+};
+var AppductCliError = class extends Error {
+  type;
+  details;
+  constructor(type, message, details) {
+    super(message);
+    this.name = "AppductCliError";
+    this.type = type;
+    this.details = details;
+  }
+};
+var usageError = (message, details) => {
+  return new AppductCliError("usage_error", message, details);
+};
+var isAppductCliError = (value) => {
+  return value instanceof AppductCliError;
+};
+var rpcErrorClass = (error) => {
+  const type = error.data?.type;
+  return type ? RPC_ERROR_EXIT_CLASS[type] : void 0;
+};
+var toCliError = (error) => {
+  if (isAppductCliError(error)) {
+    return {
+      type: error.type,
+      message: error.message,
+      details: error.details
+    };
+  }
+  if (error instanceof DaemonVersionMismatchError) {
+    return {
+      type: "connection_error",
+      message: error.message,
+      details: {
+        daemon_version: error.daemonVersion,
+        client_version: error.clientVersion,
+        session_count: error.sessionCount,
+        pending_link_count: error.pendingLinkCount
+      }
+    };
+  }
+  if (error instanceof DaemonRpcError && error.data?.type) {
+    return {
+      type: error.data.type,
+      message: error.message,
+      details: error.data.details
+    };
+  }
+  if (isDaemonUnreachableError(error)) {
+    return {
+      type: "connection_error",
+      message: error instanceof Error ? error.message : "The Appduct daemon is unreachable."
+    };
+  }
+  if (error instanceof Error) {
+    return {
+      type: "internal_error",
+      message: error.message
+    };
+  }
+  return {
+    type: "internal_error",
+    message: "An unexpected error occurred.",
+    details: error
+  };
+};
+var getExitCodeForError = (error) => {
+  if (isAppductCliError(error)) {
+    return EXIT_CODE_BY_ERROR_TYPE[error.type];
+  }
+  if (error instanceof DaemonVersionMismatchError) {
+    return EXIT_CODE_BY_ERROR_TYPE.connection_error;
+  }
+  if (error instanceof DaemonRpcError) {
+    const cliErrorClass = rpcErrorClass(error);
+    return EXIT_CODE_BY_ERROR_TYPE[cliErrorClass ?? "internal_error"];
+  }
+  if (isDaemonUnreachableError(error)) {
+    return EXIT_CODE_BY_ERROR_TYPE.connection_error;
+  }
+  return EXIT_CODE_BY_ERROR_TYPE.internal_error;
+};
+
+// src/cli/open-target.ts
+var APP_ID_PATTERN = /^[A-Za-z0-9][A-Za-z0-9._-]*$/u;
+var isValidAppId = (value) => APP_ID_PATTERN.test(value);
+var invalidAppIdMessage = (value) => `"${value}" is not a valid app id (letters, digits, ".", "_" and "-", starting with a letter or digit).`;
+
+// src/scheme.ts
+import { readFile as readFile2 } from "node:fs/promises";
+import { homedir } from "node:os";
+import { dirname as dirname2, join as join4, resolve } from "node:path";
+
+// src/native-scheme.ts
+import { readdir, readFile, stat } from "node:fs/promises";
+import { join as join3 } from "node:path";
+var MAX_PROBE_FILE_BYTES = 2 * 1024 * 1024;
+var MAX_PLIST_WALK_DEPTH = 2;
+var MAX_WALK_ENTRIES = 5e3;
+var EXCLUDED_WALK_DIRS = /* @__PURE__ */ new Set(["Pods", "build", "node_modules", "DerivedData"]);
+var readCappedText = async (path) => {
+  const buffer = await readCappedBuffer(path);
+  if (!buffer.ok) {
+    return buffer;
+  }
+  return { ok: true, text: buffer.data.toString("utf8") };
+};
+var readCappedBuffer = async (path) => {
+  let size;
+  try {
+    const stats = await stat(path);
+    if (!stats.isFile()) {
+      return { ok: false, reason: "not-found" };
+    }
+    size = stats.size;
+  } catch {
+    return { ok: false, reason: "not-found" };
+  }
+  if (size > MAX_PROBE_FILE_BYTES) {
+    return { ok: false, reason: "too-large" };
+  }
+  try {
+    return { ok: true, data: await readFile(path) };
+  } catch {
+    return { ok: false, reason: "unreadable" };
+  }
+};
+var requireValidNativeScheme = (value, origin) => {
+  if (!isValidScheme(value)) {
+    throw usageError(
+      `Invalid deep-link scheme ${JSON.stringify(value)} from ${origin}: a scheme must start with a letter and contain only letters, digits, "+", "-" or "." (for example "myapp") \u2014 do not include "://".`
+    );
+  }
+  return value;
+};
+var GRADLE_PLACEHOLDER_PATTERN = /manifestPlaceholders\s*(?:\[\s*["']appductScheme["']\s*\]|\.\s*appductScheme)\s*=\s*["']([^"']*)["']/u;
+var extractGradleScheme = (text) => {
+  const match = GRADLE_PLACEHOLDER_PATTERN.exec(text);
+  const value = match?.[1];
+  return value !== void 0 && value.length > 0 ? value : void 0;
+};
+var probeAndroidGradle = async (root) => {
+  const candidates = [join3(root, "app", "build.gradle.kts"), join3(root, "app", "build.gradle")];
+  const notes = [];
+  for (const candidate of candidates) {
+    const read = await readCappedText(candidate);
+    if (!read.ok) {
+      if (read.reason === "too-large") {
+        notes.push(`${candidate} (too large, skipped)`);
+      }
+      continue;
+    }
+    const scheme = extractGradleScheme(read.text);
+    if (scheme !== void 0) {
+      requireValidNativeScheme(scheme, `"appductScheme" in ${candidate}`);
+      return {
+        result: {
+          source: "android-gradle",
+          scheme,
+          origin: `"appductScheme" in ${candidate}`
+        },
+        tried: [describeAndroidGradleTried(candidates, notes)]
+      };
+    }
+  }
+  return { tried: [describeAndroidGradleTried(candidates, notes)] };
+};
+var describeAndroidGradleTried = (candidates, notes) => {
+  const base = `${candidates.join(", ")} ("appductScheme" manifest placeholder)`;
+  return notes.length === 0 ? base : `${base} \u2014 ${notes.join(", ")}`;
+};
+var INTENT_FILTER_PATTERN = /<intent-filter\b[^>]*>([\s\S]*?)<\/intent-filter>/giu;
+var VIEW_ACTION_PATTERN = /<action\b[^>]*\bandroid:name\s*=\s*["']android\.intent\.action\.VIEW["']/iu;
+var DATA_SCHEME_PATTERN = /<data\b[^>]*\bandroid:scheme\s*=\s*["']([^"']*)["']/iu;
+var extractManifestScheme = (xml) => {
+  for (const match of xml.matchAll(INTENT_FILTER_PATTERN)) {
+    const block = match[1] ?? "";
+    if (!VIEW_ACTION_PATTERN.test(block)) {
+      continue;
+    }
+    const dataMatch = DATA_SCHEME_PATTERN.exec(block);
+    const scheme = dataMatch?.[1];
+    if (scheme !== void 0 && scheme.length > 0) {
+      return scheme;
+    }
+  }
+  return void 0;
+};
+var probeAndroidManifest = async (root) => {
+  const manifestPath = join3(root, "app", "src", "main", "AndroidManifest.xml");
+  const read = await readCappedText(manifestPath);
+  const description = `${manifestPath} (first <data android:scheme> in a VIEW intent-filter)`;
+  if (!read.ok) {
+    return {
+      tried: [read.reason === "too-large" ? `${description} \u2014 too large, skipped` : description]
+    };
+  }
+  const scheme = extractManifestScheme(read.text);
+  if (scheme === void 0) {
+    return { tried: [description] };
+  }
+  requireValidNativeScheme(scheme, `"android:scheme" in ${manifestPath}`);
+  return {
+    result: {
+      source: "android-manifest",
+      scheme,
+      origin: `"android:scheme" in ${manifestPath}`
+    },
+    tried: [description]
+  };
+};
+var XML_ENTITIES = { amp: "&", lt: "<", gt: ">", quot: '"', apos: "'" };
+var decodeXmlEntities = (text) => {
+  return text.replace(/&(#x[0-9a-fA-F]+|#[0-9]+|[a-zA-Z]+);/gu, (whole, entity) => {
+    if (entity.startsWith("#x")) {
+      const code = Number.parseInt(entity.slice(2), 16);
+      return Number.isNaN(code) ? whole : String.fromCodePoint(code);
+    }
+    if (entity.startsWith("#")) {
+      const code = Number.parseInt(entity.slice(1), 10);
+      return Number.isNaN(code) ? whole : String.fromCodePoint(code);
+    }
+    return XML_ENTITIES[entity] ?? whole;
+  });
+};
+var tokenizePlistXml = (xml) => {
+  const cleaned = xml.replace(/<\?[\s\S]*?\?>/gu, "").replace(/<!DOCTYPE[\s\S]*?>/giu, "").replace(/<!--[\s\S]*?-->/gu, "");
+  const root = { tag: "#root", children: [], text: "" };
+  const stack = [root];
+  const tagOrTextPattern = /<(\/?)([a-zA-Z][\w.:-]*)\b[^>]*?(\/?)>|([^<]+)/gu;
+  for (const match of cleaned.matchAll(tagOrTextPattern)) {
+    const [, closing, name, selfClosing, text] = match;
+    const top = stack[stack.length - 1];
+    if (text !== void 0) {
+      top.text += decodeXmlEntities(text);
+      continue;
+    }
+    if (closing) {
+      if (stack.length > 1) {
+        stack.pop();
+      }
+      continue;
+    }
+    const node = { tag: name ?? "", children: [], text: "" };
+    top.children.push(node);
+    if (!selfClosing) {
+      stack.push(node);
+    }
+  }
+  return root;
+};
+var plistNodeToValue = (node) => {
+  switch (node.tag) {
+    case "true":
+      return true;
+    case "false":
+      return false;
+    case "integer": {
+      const value = Number.parseInt(node.text.trim(), 10);
+      return Number.isNaN(value) ? node.text.trim() : value;
+    }
+    case "real": {
+      const value = Number.parseFloat(node.text.trim());
+      return Number.isNaN(value) ? node.text.trim() : value;
+    }
+    case "array":
+      return node.children.map(plistNodeToValue);
+    case "dict": {
+      const result = {};
+      for (let index = 0; index < node.children.length; index += 2) {
+        const keyNode = node.children[index];
+        const valueNode = node.children[index + 1];
+        if (keyNode?.tag === "key" && valueNode !== void 0) {
+          result[keyNode.text.trim()] = plistNodeToValue(valueNode);
+        }
+      }
+      return result;
+    }
+    default:
+      return node.text.trim();
+  }
+};
+var parsePlistXml = (xml) => {
+  const root = tokenizePlistXml(xml);
+  const plistNode = root.children.find((child) => child.tag === "plist");
+  const valueNode = plistNode?.children[0];
+  return valueNode ? plistNodeToValue(valueNode) : void 0;
+};
+var isBinaryPlist = (buffer) => {
+  return buffer.length >= 6 && buffer.subarray(0, 6).toString("latin1") === "bplist";
+};
+var firstPlistUrlScheme = (cfBundleURLTypes) => {
+  if (!Array.isArray(cfBundleURLTypes)) {
+    return void 0;
+  }
+  for (const entry of cfBundleURLTypes) {
+    if (typeof entry !== "object" || entry === null || Array.isArray(entry)) {
+      continue;
+    }
+    const scheme = firstConfiguredScheme(entry.CFBundleURLSchemes);
+    if (scheme !== void 0) {
+      return scheme;
+    }
+  }
+  return void 0;
+};
+var walkForFilename = async (root, filename, maxDepth) => {
+  const hits = [];
+  let visited = 0;
+  const walk = async (dir, depth) => {
+    let entries;
+    try {
+      entries = await readdir(dir, { withFileTypes: true });
+    } catch {
+      return;
+    }
+    for (const entry of entries) {
+      if (visited >= MAX_WALK_ENTRIES) {
+        return;
+      }
+      visited += 1;
+      if (entry.isSymbolicLink()) {
+        continue;
+      }
+      if (entry.isDirectory()) {
+        if (EXCLUDED_WALK_DIRS.has(entry.name)) {
+          continue;
+        }
+        if (depth < maxDepth) {
+          await walk(join3(dir, entry.name), depth + 1);
+        }
+        continue;
+      }
+      if (entry.isFile() && entry.name === filename) {
+        hits.push({ path: join3(dir, entry.name), depth });
+      }
+    }
+  };
+  await walk(root, 0);
+  hits.sort((a, b) => a.depth - b.depth || a.path.localeCompare(b.path));
+  return hits;
+};
+var probeIosInfoPlist = async (root) => {
+  const files = await walkForFilename(root, "Info.plist", MAX_PLIST_WALK_DEPTH);
+  const describeSearch = (notes2) => {
+    const base = files.length === 0 ? `Info.plist up to ${MAX_PLIST_WALK_DEPTH} levels below ${root} (excluding Pods/build/node_modules/DerivedData) \u2014 none found` : `${files.map((file) => file.path).join(", ")} (first "CFBundleURLSchemes" entry)`;
+    return notes2.length === 0 ? base : `${base} \u2014 ${notes2.join(", ")}`;
+  };
+  const notes = [];
+  for (const file of files) {
+    const read = await readCappedBuffer(file.path);
+    if (!read.ok) {
+      notes.push(
+        `${file.path} (${read.reason === "too-large" ? "too large, skipped" : "unreadable"})`
+      );
+      continue;
+    }
+    if (isBinaryPlist(read.data)) {
+      notes.push(`${file.path} (binary plist \u2014 unreadable, use --scheme)`);
+      continue;
+    }
+    const value = parsePlistXml(read.data.toString("utf8"));
+    if (typeof value !== "object" || value === null || Array.isArray(value)) {
+      continue;
+    }
+    const scheme = firstPlistUrlScheme(value.CFBundleURLTypes);
+    if (scheme === void 0) {
+      continue;
+    }
+    requireValidNativeScheme(scheme, `"CFBundleURLSchemes" in ${file.path}`);
+    return {
+      result: {
+        source: "ios-info-plist",
+        scheme,
+        origin: `"CFBundleURLSchemes" in ${file.path}`
+      },
+      tried: [describeSearch(notes)]
+    };
+  }
+  return { tried: [describeSearch(notes)] };
+};
+var PROJECT_YML_SCHEME_PATTERN = /CFBundleURLSchemes\s*:\s*(?:\[\s*["']?([^"'\],\r\n]*)["']?|\r?\n[ \t]*-[ \t]*["']?([^"'\r\n]*)["']?)/u;
+var extractProjectYmlScheme = (text) => {
+  const match = PROJECT_YML_SCHEME_PATTERN.exec(text);
+  const raw = (match?.[1] ?? match?.[2])?.trim();
+  return raw !== void 0 && raw.length > 0 ? raw : void 0;
+};
+var probeIosProjectYml = async (root) => {
+  const path = join3(root, "project.yml");
+  const description = `${path} ("info.properties.CFBundleURLTypes" > "CFBundleURLSchemes")`;
+  const read = await readCappedText(path);
+  if (!read.ok) {
+    return {
+      tried: [read.reason === "too-large" ? `${description} \u2014 too large, skipped` : description]
+    };
+  }
+  const scheme = extractProjectYmlScheme(read.text);
+  if (scheme === void 0) {
+    return { tried: [description] };
+  }
+  requireValidNativeScheme(scheme, `"CFBundleURLSchemes" in ${path}`);
+  return {
+    result: { source: "ios-project-yml", scheme, origin: `"CFBundleURLSchemes" in ${path}` },
+    tried: [description]
+  };
+};
+var PROBES = [
+  probeAndroidGradle,
+  probeAndroidManifest,
+  probeIosInfoPlist,
+  probeIosProjectYml
+];
+var discoverNativeScheme = async (root) => {
+  const tried = [];
+  const results = [];
+  for (const probe of PROBES) {
+    const outcome = await probe(root);
+    tried.push(...outcome.tried);
+    if (outcome.result !== void 0) {
+      results.push(outcome.result);
+    }
+  }
+  if (results.length === 0) {
+    return { tried };
+  }
+  const distinctSchemes = new Set(results.map((entry) => entry.scheme));
+  if (distinctSchemes.size > 1) {
+    throw usageError(
+      "Conflicting deep-link schemes found in this project: " + results.map((entry) => `${entry.origin} says ${JSON.stringify(entry.scheme)}`).join(", but ") + ". Appduct will not guess which one is right \u2014 pass --scheme <scheme> to pick one."
+    );
+  }
+  return { result: results[0], tried };
+};
+
+// src/scheme.ts
+var PROJECT_CONFIG_DIR = ".appduct";
+var PROJECT_CONFIG_FILENAME = "config.json";
+var PROJECT_CONFIG_RELATIVE_PATH = join4(PROJECT_CONFIG_DIR, PROJECT_CONFIG_FILENAME);
+var APP_JSON_FILENAME = "app.json";
+var SCHEME_ENV_VAR = "APPDUCT_SCHEME";
+var SCHEME_PATTERN = /^[a-zA-Z][a-zA-Z0-9+.-]*$/u;
+var isValidScheme = (value) => SCHEME_PATTERN.test(value);
+var requireValidScheme = (value, origin) => {
+  if (!isValidScheme(value)) {
+    throw usageError(
+      `Invalid deep-link scheme ${JSON.stringify(value)} from ${origin}: a scheme must start with a letter and contain only letters, digits, "+", "-" or "." (for example "myapp") \u2014 do not include "://".`
+    );
+  }
+  return value;
+};
+var isPlainObject = (value) => {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+};
+var readJsonFile = async (path) => {
+  let text;
+  try {
+    text = await readFile2(path, "utf8");
+  } catch (error) {
+    const code = error.code;
+    if (code === "ENOENT" || code === "ENOTDIR" || code === "EISDIR") {
+      return void 0;
+    }
+    throw error;
+  }
+  try {
+    return { raw: JSON.parse(text) };
+  } catch (error) {
+    throw usageError(`Could not parse ${path}: ${error.message}`);
+  }
+};
+var firstConfiguredScheme = (value) => {
+  if (Array.isArray(value)) {
+    return value.find((entry) => typeof entry === "string" && entry.length > 0);
+  }
+  return typeof value === "string" && value.length > 0 ? value : void 0;
+};
+var discoverExpoScheme = async (dir) => {
+  const path = join4(resolve(dir), APP_JSON_FILENAME);
+  const file = await readJsonFile(path);
+  if (!file || !isPlainObject(file.raw)) {
+    return void 0;
+  }
+  const expo = file.raw.expo;
+  if (!isPlainObject(expo)) {
+    return void 0;
+  }
+  const scheme = firstConfiguredScheme(expo.scheme);
+  return scheme === void 0 ? void 0 : requireValidScheme(scheme, `"expo.scheme" in ${path}`);
+};
+var discoverStaticProjectScheme = async (cwd) => {
+  const appJsonPath = join4(resolve(cwd), APP_JSON_FILENAME);
+  const tried = [`${appJsonPath} ("expo.scheme")`];
+  const appJsonScheme = await discoverExpoScheme(cwd);
+  if (appJsonScheme !== void 0) {
+    return { scheme: appJsonScheme, source: "app-json", origin: appJsonPath, tried };
+  }
+  const native = await discoverNativeScheme(resolve(cwd));
+  tried.push(...native.tried);
+  if (native.result !== void 0) {
+    return {
+      scheme: native.result.scheme,
+      source: native.result.source,
+      origin: native.result.origin,
+      tried
+    };
+  }
+  return { tried };
+};
+var globalConfigDirs = (options = {}) => {
+  const excluded = /* @__PURE__ */ new Set([join4(resolve(options.homeDir ?? homedir()), PROJECT_CONFIG_DIR)]);
+  if (options.stateDirRoot !== void 0) {
+    excluded.add(resolve(options.stateDirRoot));
+  }
+  return excluded;
+};
+
+// src/commands/init.ts
+var readExistingConfig = async (path) => {
+  let text;
+  try {
+    text = await readFile3(path, "utf8");
+  } catch (error) {
+    const code = error.code;
+    if (code === "ENOENT") {
+      return void 0;
+    }
+    if (code === "ENOTDIR") {
+      throw usageError(
+        `Cannot write ${path}: a file already exists where the "${PROJECT_CONFIG_DIR}" directory needs to go. Remove or rename it, then re-run \`appduct init\`.`
+      );
+    }
+    if (code === "EISDIR") {
+      throw usageError(
+        `Cannot write ${path}: it is a directory, not a file. Remove it, then re-run \`appduct init\`.`
+      );
+    }
+    throw error;
+  }
+  let raw;
+  try {
+    raw = JSON.parse(text);
+  } catch (error) {
+    throw usageError(
+      `Could not parse the existing ${path}: ${error.message}. Fix or delete it, then re-run \`appduct init\`.`
+    );
+  }
+  if (typeof raw !== "object" || raw === null || Array.isArray(raw)) {
+    throw usageError(
+      `The existing ${path} is not a JSON object. Fix or delete it, then re-run \`appduct init\`.`
+    );
+  }
+  return raw;
+};
+var readExistingScheme = (existing, path, replaceable) => {
+  const scheme = existing?.scheme;
+  if (scheme === void 0) {
+    return void 0;
+  }
+  if (typeof scheme !== "string" || !isValidScheme(scheme)) {
+    if (replaceable) {
+      return void 0;
+    }
+    throw usageError(
+      `${path} records an invalid deep-link scheme ${JSON.stringify(scheme)}: a scheme must start with a letter and contain only letters, digits, "+", "-" or "." (for example "myapp") \u2014 do not include "://". Fix it, or re-run with \`--scheme <scheme> --force\` to replace it.`
+    );
+  }
+  return scheme;
+};
+var readExistingAppId = (existing, path, platform, flagName, replaceable) => {
+  const appId = existing?.appId;
+  if (appId === void 0) {
+    return void 0;
+  }
+  if (typeof appId !== "object" || appId === null || Array.isArray(appId)) {
+    if (replaceable) {
+      return void 0;
+    }
+    throw usageError(
+      `${path} records an invalid "appId" (must be an object with "ios" and/or "android" keys). Fix it, or re-run with \`${flagName} <id> --force\` to replace it.`
+    );
+  }
+  const value = appId[platform];
+  if (value === void 0) {
+    return void 0;
+  }
+  if (typeof value !== "string" || value.length === 0) {
+    if (replaceable) {
+      return void 0;
+    }
+    throw usageError(
+      `${path} records an invalid "appId.${platform}" (must be a non-empty string). Fix it, or re-run with \`${flagName} <id> --force\` to replace it.`
+    );
+  }
+  return value;
+};
+var handleInitCommand = async (options, context = {}) => {
+  const root = resolve2(context.cwd ?? process.cwd());
+  const projectDir = join5(root, PROJECT_CONFIG_DIR);
+  const configPath = join5(projectDir, PROJECT_CONFIG_FILENAME);
+  if (globalConfigDirs({ stateDirRoot: context.stateDir, homeDir: context.homeDir }).has(projectDir)) {
+    throw usageError(
+      `Refusing to write ${configPath}: that is Appduct's own state directory (it holds the daemon's private key and audit log), not a project config. Run \`appduct init\` from your app's root directory instead.`
+    );
+  }
+  if (options.scheme !== void 0 && !isValidScheme(options.scheme)) {
+    throw usageError(
+      `Invalid deep-link scheme ${JSON.stringify(options.scheme)} from --scheme: a scheme must start with a letter and contain only letters, digits, "+", "-" or "." (for example "myapp") \u2014 do not include "://".`
+    );
+  }
+  for (const [flag, value] of [
+    ["--ios-app-id", options.iosAppId],
+    ["--android-app-id", options.androidAppId]
+  ]) {
+    if (value !== void 0 && !isValidAppId(value)) {
+      throw usageError(`${invalidAppIdMessage(value)} (from ${flag})`);
+    }
+  }
+  const existing = await readExistingConfig(configPath);
+  const existingScheme = readExistingScheme(
+    existing,
+    configPath,
+    options.force === true || options.scheme !== void 0
+  );
+  const existingIosAppId = readExistingAppId(
+    existing,
+    configPath,
+    "ios",
+    "--ios-app-id",
+    options.force === true || options.iosAppId !== void 0
+  );
+  const existingAndroidAppId = readExistingAppId(
+    existing,
+    configPath,
+    "android",
+    "--android-app-id",
+    options.force === true || options.androidAppId !== void 0
+  );
+  if (options.iosAppId !== void 0 && existingIosAppId !== void 0 && existingIosAppId !== options.iosAppId && !options.force) {
+    throw usageError(
+      `${configPath} already records "appId.ios" as "${existingIosAppId}", but --ios-app-id asked for "${options.iosAppId}". Re-run with --force to replace it (every other key in the file is preserved), or drop --ios-app-id to keep what is recorded.`
+    );
+  }
+  if (options.androidAppId !== void 0 && existingAndroidAppId !== void 0 && existingAndroidAppId !== options.androidAppId && !options.force) {
+    throw usageError(
+      `${configPath} already records "appId.android" as "${existingAndroidAppId}", but --android-app-id asked for "${options.androidAppId}". Re-run with --force to replace it (every other key in the file is preserved), or drop --android-app-id to keep what is recorded.`
+    );
+  }
+  const iosAppId = options.iosAppId ?? existingIosAppId;
+  const androidAppId = options.androidAppId ?? existingAndroidAppId;
+  const appIdChanged = iosAppId !== existingIosAppId || androidAppId !== existingAndroidAppId;
+  const discovered = await discoverStaticProjectScheme(root);
+  const discoveredScheme = discovered.scheme;
+  const discoveredSourceLabel = discovered.source === void 0 ? void 0 : discovered.source === "app-json" ? "app.json" : discovered.source;
+  const [scheme, source, origin] = (() => {
+    if (options.scheme !== void 0) {
+      return [options.scheme, "--scheme", void 0];
+    }
+    if (options.force && discoveredScheme !== void 0) {
+      return [discoveredScheme, discoveredSourceLabel ?? "app.json", discovered.origin];
+    }
+    return existingScheme === void 0 ? [discoveredScheme, discoveredSourceLabel ?? "app.json", discovered.origin] : [existingScheme, "already-recorded", void 0];
+  })();
+  if (scheme === void 0) {
+    throw usageError(
+      `No deep-link scheme found for ${root}, and none was given. Looked in, in order:
+${discovered.tried.map((location, index) => `  ${index + 1}. ${location}`).join("\n")}
+Run \`appduct init --scheme <scheme>\` with the scheme your app registers for deep links (e.g. "myapp"), or declare it in one of the locations above.`
+    );
+  }
+  if (options.scheme !== void 0 && existingScheme !== void 0 && existingScheme !== options.scheme && !options.force) {
+    throw usageError(
+      `${configPath} already records the scheme "${existingScheme}", but --scheme asked for "${options.scheme}". Re-run with --force to replace it (every other key in the file is preserved), or drop --scheme to keep what is recorded.`
+    );
+  }
+  const note = options.scheme === void 0 && scheme === existingScheme && discoveredScheme !== void 0 && discoveredScheme !== scheme ? `${discovered.origin} declares "${discoveredScheme}", but ${configPath} records "${existingScheme}", which is what Appduct uses. Run \`appduct init --force\` to adopt that value instead.` : void 0;
+  const alreadyCorrect = existingScheme === scheme && !appIdChanged;
+  if (!alreadyCorrect) {
+    const next = { ...existing ?? {}, scheme };
+    if (iosAppId !== void 0 || androidAppId !== void 0) {
+      next.appId = {
+        ...iosAppId === void 0 ? {} : { ios: iosAppId },
+        ...androidAppId === void 0 ? {} : { android: androidAppId }
+      };
+    }
+    await mkdir(dirname3(configPath), { recursive: true, mode: 448 });
+    await writeFile(configPath, `${JSON.stringify(next, null, 2)}
+`, {
+      encoding: "utf8",
+      mode: 384
+    });
+  }
+  await chmod(dirname3(configPath), 448);
+  await chmod(configPath, 384);
+  return {
+    ok: true,
+    data: {
+      path: configPath,
+      scheme,
+      source,
+      ...origin === void 0 ? {} : { origin },
+      created: existing === void 0,
+      changed: !alreadyCorrect,
+      ...iosAppId === void 0 && androidAppId === void 0 ? {} : {
+        appId: {
+          ...iosAppId === void 0 ? {} : { ios: iosAppId },
+          ...androidAppId === void 0 ? {} : { android: androidAppId }
+        }
+      },
+      ...note === void 0 ? {} : { note },
+      mcpServerEntry: {
+        command: "appduct",
+        args: ["mcp", "--scheme", scheme]
+      },
+      nextSteps: [
+        'Add `import "@appduct/react-native/auto";` to your app entry (index.js / App.tsx) \u2014 it is what starts the in-app agent endpoint.',
+        `Add the Appduct MCP server entry to your agent's MCP config. "--scheme ${scheme}" keeps that entry self-contained; ${SCHEME_ENV_VAR} and this ${PROJECT_CONFIG_RELATIVE_PATH} work too.`,
+        "With the app running, pair a device: `appduct link --open ios-sim` (or `--open android`).",
+        ...origin === void 0 ? [] : [`Scheme "${scheme}" was read from ${origin}.`],
+        ...iosAppId === void 0 && androidAppId === void 0 ? [
+          "Delivering to a physical iPhone (`--open ios-device`) or an Android device/emulator (`--open android`) needs the installed app's id: run `appduct init --ios-app-id <id> --android-app-id <id>`, or pass --app-id on `appduct link`."
+        ] : [],
+        `This file is safe to commit \u2014 it holds only "scheme" and "appId". Do not point --state-dir at this directory: the state dir holds the daemon's private key and audit log, which must never be committed.`
+      ]
+    }
+  };
+};
+
+// src/cli/global-flags.ts
+var formatJson = (value, flags) => {
+  return flags.pretty ? JSON.stringify(value, null, 2) : JSON.stringify(value);
+};
+
+// src/output.ts
+import pc from "picocolors";
+import {
+  formatAgentWebSocketUrl,
+  renderToolSignature,
+  summarizeToolDescription
+} from "@appduct/shared";
+
+// src/qr-terminal.ts
+import { toQR } from "toqr";
+var HALF_UPPER = "\u2580";
+var HALF_LOWER = "\u2584";
+var FULL = "\u2588";
+var renderQrToTerminal = (content, options) => {
+  const margin = options?.margin ?? 0;
+  const ecLevel = options?.ecLevel ?? 1;
+  const modules = toQR(content, ecLevel);
+  const side = Math.sqrt(modules.length);
+  if (!Number.isInteger(side)) {
+    throw new Error("Invalid QR matrix size");
+  }
+  const dim = side + 2 * margin;
+  const isDark = (row, col) => {
+    if (row < margin || col < margin || row >= margin + side || col >= margin + side) {
+      return false;
+    }
+    const mr = row - margin;
+    const mc = col - margin;
+    return modules[mr * side + mc] === 1;
+  };
+  const lines = [];
+  for (let row = 0; row < dim; row += 2) {
+    let line = "";
+    for (let col = 0; col < dim; col++) {
+      const top = isDark(row, col);
+      const bottom = row + 1 < dim ? isDark(row + 1, col) : false;
+      line += top ? bottom ? FULL : HALF_UPPER : bottom ? HALF_LOWER : " ";
+    }
+    lines.push(line);
+  }
+  return lines.join("\n");
+};
+
+// src/output.ts
+var renderMetaLines = (meta) => {
+  if (!meta) {
+    return [];
+  }
+  return [
+    "Meta",
+    `  Command: ${meta.command}`,
+    `  Timestamp: ${meta.timestamp}`,
+    ...typeof meta.duration_ms === "number" ? [`  Duration: ${meta.duration_ms} ms`] : []
+  ];
+};
+var formatScalar = (value, flags) => {
+  if (typeof value === "string") {
+    return value;
+  }
+  if (typeof value === "number" || typeof value === "boolean") {
+    return String(value);
+  }
+  if (value === null || value === void 0) {
+    return "null";
+  }
+  return formatJson(value, flags);
+};
+var renderFields = (title, fields, flags) => {
+  const visibleFields = fields.filter(([, value]) => value !== void 0);
+  if (visibleFields.length === 0) {
+    return [];
+  }
+  const width = Math.max(...visibleFields.map(([label]) => label.length));
+  return [
+    title,
+    ...visibleFields.map(([label, value]) => `  ${label.padEnd(width)}  ${formatScalar(value, flags)}`)
+  ];
+};
+var formatAge = (fromIso, toIso) => {
+  const elapsedMs = Math.max(0, new Date(toIso).getTime() - new Date(fromIso).getTime());
+  const elapsedSeconds = Math.floor(elapsedMs / 1e3);
+  if (elapsedSeconds < 60) {
+    return `${elapsedSeconds}s`;
+  }
+  const elapsedMinutes = Math.floor(elapsedSeconds / 60);
+  if (elapsedMinutes < 60) {
+    return `${elapsedMinutes}m`;
+  }
+  const elapsedHours = Math.floor(elapsedMinutes / 60);
+  if (elapsedHours < 24) {
+    return `${elapsedHours}h`;
+  }
+  return `${Math.floor(elapsedHours / 24)}d`;
+};
+var formatDevice = (device) => {
+  const parts = [device.manufacturer, device.model].filter((part) => Boolean(part));
+  const label = parts.length > 0 ? parts.join(" ") : "unknown device";
+  return device.os ? `${label} (${device.os})` : label;
+};
+var renderLsData = (colors, data, now) => {
+  if (data.length === 0) {
+    return [colors.dim("Sessions"), "  No Appduct sessions are registered."];
+  }
+  const nowIso = now.toISOString();
+  const headers = ["Alias", "State", "Device", "Tools", "Age"];
+  const rows = data.map((session) => [
+    session.alias,
+    session.state,
+    formatDevice(session.device),
+    String(session.toolCount),
+    formatAge(session.claimedAt ?? session.createdAt, nowIso)
+  ]);
+  const widths = headers.map(
+    (header, index) => Math.max(header.length, ...rows.map((row) => row[index].length))
+  );
+  return [
+    colors.green("Sessions"),
+    `  ${headers.map((header, index) => header.padEnd(widths[index])).join("  ")}`,
+    ...rows.map((row) => `  ${row.map((cell, index) => cell.padEnd(widths[index])).join("  ")}`)
+  ];
+};
+var isToolsListing = (data) => {
+  return typeof data === "object" && data !== null && Array.isArray(data.tools);
+};
+var isToolGroupsListing = (data) => {
+  return typeof data === "object" && data !== null && Array.isArray(data.groups) && !Array.isArray(data.tools);
+};
+var UNGROUPED_LABEL = "(ungrouped)";
+var MAX_FOOTER_GROUPS = 10;
+var hasAnyGroup = (groups) => {
+  return (groups ?? []).some((entry) => entry.group !== null);
+};
+var topLevelGroups = (groups) => {
+  return (groups ?? []).filter((entry) => entry.group !== null && !entry.group.includes("/"));
+};
+var renderEmptyToolsLine = (data) => {
+  if (data.total > 0) {
+    return `  No tools at offset ${data.offset ?? 0}; ${data.total} matching tool${data.total === 1 ? "" : "s"} in total.`;
+  }
+  if (data.group !== void 0) {
+    const match = data.filter === void 0 ? "" : ` match ${JSON.stringify(data.filter)}`;
+    return `  No tools in group ${JSON.stringify(data.group)}${match}. Run \`appduct tools --groups\` to see the session's groups.`;
+  }
+  return data.filter === void 0 ? "  No tools registered." : `  No tools match ${JSON.stringify(data.filter)}.`;
+};
+var renderGroupHint = (data) => {
+  if (data.group !== void 0 || !hasAnyGroup(data.groups)) {
+    return void 0;
+  }
+  const top = topLevelGroups(data.groups);
+  const named = top.slice(0, MAX_FOOTER_GROUPS).map((entry) => `${entry.group} ${entry.total}`);
+  const more = top.length > MAX_FOOTER_GROUPS ? `, ... ${top.length - MAX_FOOTER_GROUPS} more; see --groups` : "";
+  return `--group <name> (groups: ${named.join(", ")}${more})`;
+};
+var renderTruncationLine = (data) => {
+  if (data.tools.length >= data.total) {
+    return [];
+  }
+  const groupHint = renderGroupHint(data);
+  const narrow = groupHint === void 0 ? "--filter <text> or" : `${groupHint} or --filter <text>, or`;
+  return [
+    "",
+    `Showing ${data.tools.length} of ${data.total} tools (offset ${data.offset ?? 0}). Narrow with ${narrow} page with --offset <n>.`
+  ];
+};
+var renderToolSummaryLines = (tool, indent) => {
+  const tag = tool.policy === "allow" ? "" : `  [${tool.policy}]`;
+  return [`${indent}${renderToolSignature(tool)}${tag}`, `${indent}  ${summarizeToolDescription(tool.description)}`];
+};
+var renderGroupedToolLines = (colors, tools) => {
+  const byGroup = /* @__PURE__ */ new Map();
+  for (const tool of tools) {
+    const key = tool.group ?? null;
+    const bucket = byGroup.get(key);
+    if (bucket) {
+      bucket.push(tool);
+    } else {
+      byGroup.set(key, [tool]);
+    }
+  }
+  const tops = /* @__PURE__ */ new Map();
+  for (const key of byGroup.keys()) {
+    if (key === null) {
+      continue;
+    }
+    const slash = key.indexOf("/");
+    const top = slash === -1 ? key : key.slice(0, slash);
+    const subs = tops.get(top) ?? [];
+    if (slash !== -1) {
+      subs.push(key);
+    }
+    tops.set(top, subs);
+  }
+  const byCodePoint = (a, b) => a < b ? -1 : a > b ? 1 : 0;
+  const lines = [];
+  for (const top of [...tops.keys()].sort(byCodePoint)) {
+    lines.push(`  ${colors.cyan(top)}`);
+    lines.push(...(byGroup.get(top) ?? []).flatMap((tool) => renderToolSummaryLines(tool, "    ")));
+    for (const sub of tops.get(top).sort(byCodePoint)) {
+      lines.push(`    ${colors.cyan(sub)}`);
+      lines.push(...byGroup.get(sub).flatMap((tool) => renderToolSummaryLines(tool, "      ")));
+    }
+  }
+  const ungrouped = byGroup.get(null);
+  if (ungrouped) {
+    lines.push(`  ${colors.cyan(UNGROUPED_LABEL)}`);
+    lines.push(...ungrouped.flatMap((tool) => renderToolSummaryLines(tool, "    ")));
+  }
+  return lines;
+};
+var renderToolsTitle = (colors, data) => {
+  return colors.green(data.group === void 0 ? "Tools" : `Tools in group ${data.group}`);
+};
+var renderToolSummaryTable = (colors, data) => {
+  if (data.tools.length === 0) {
+    return [renderToolsTitle(colors, data), renderEmptyToolsLine(data)];
+  }
+  const grouped = data.group === void 0 && hasAnyGroup(data.groups);
+  return [
+    renderToolsTitle(colors, data),
+    ...grouped ? renderGroupedToolLines(colors, data.tools) : data.tools.flatMap((tool) => renderToolSummaryLines(tool, "  ")),
+    ...renderTruncationLine(data),
+    "",
+    "Run `appduct tools <name>` for a tool's full schema."
+  ];
+};
+var renderToolDetail = (colors, tool, flags) => {
+  return renderFields(
+    colors.green(`Tool: ${tool.name}`),
+    [
+      ["Signature", renderToolSignature(tool)],
+      ["Description", tool.description],
+      ["Input schema", tool.input_schema],
+      ["Output schema", tool.output_schema],
+      // `?? undefined` keeps an ungrouped tool's row hidden rather than printing a bare "null":
+      // `renderFields` drops undefined rows, and the machine form's `null` is for consumers, not
+      // for a human scanning one tool's schema.
+      ["Group", tool.group ?? void 0],
+      ["Annotations", tool.annotations],
+      // Only rendered for a tool that declares one; `renderFields` drops undefined rows, so a
+      // tool on the daemon's default deadline shows no line at all rather than a misleading
+      // "10000".
+      ["Timeout (ms)", tool.timeout_ms]
+    ],
+    flags
+  );
+};
+var renderToolsFullListing = (colors, data, flags) => {
+  if (data.tools.length === 0) {
+    return [renderToolsTitle(colors, data), renderEmptyToolsLine(data)];
+  }
+  return [
+    ...data.tools.flatMap((tool, index) => [
+      ...index > 0 ? [""] : [],
+      ...renderToolDetail(colors, tool, flags)
+    ]),
+    ...renderTruncationLine(data)
+  ];
+};
+var renderToolGroups = (colors, data) => {
+  if (data.groups.length === 0) {
+    return [colors.green("Groups"), "  No tools registered."];
+  }
+  const label = (entry) => {
+    if (entry.group === null) {
+      return UNGROUPED_LABEL;
+    }
+    return entry.group.includes("/") ? `  ${entry.group}` : entry.group;
+  };
+  const width = Math.max(...data.groups.map((entry) => label(entry).length));
+  const countWidth = Math.max(...data.groups.map((entry) => String(entry.total).length));
+  return [
+    colors.green("Groups"),
+    ...data.groups.map((entry) => `  ${label(entry).padEnd(width)}  ${String(entry.total).padStart(countWidth)}`),
+    "",
+    `${data.total} tool${data.total === 1 ? "" : "s"} in total. ` + (hasAnyGroup(data.groups) ? "Run `appduct tools --group <name>` to list one group's tools." : "No tool declares a group.")
+  ];
+};
+var renderToolsData = (colors, data, flags, full) => {
+  if (isToolGroupsListing(data)) {
+    return renderToolGroups(colors, data);
+  }
+  if (!isToolsListing(data)) {
+    return renderToolDetail(colors, data, flags);
+  }
+  return full ? renderToolsFullListing(colors, data, flags) : renderToolSummaryTable(colors, data);
+};
+var renderInvokeData = (colors, data, flags) => {
+  return [colors.green("Result"), formatScalar(data, flags)];
+};
+var renderLinkData = (colors, data, flags, qr) => {
+  const lines = [
+    colors.green("Link Created"),
+    ...renderFields(
+      "Link",
+      [
+        ["Session", data.sessionId],
+        ["Deep link", data.deepLink],
+        ["Endpoint", formatAgentWebSocketUrl(data.endpoint)],
+        ["Pin", data.pin],
+        ["Expires", new Date(data.expiresAt * 1e3).toISOString()],
+        ["Delivered", data.delivered ? `yes (${data.target})` : void 0]
+      ],
+      flags
+    )
+  ];
+  if (qr) {
+    lines.push("", "QR", renderQrToTerminal(data.deepLink));
+  }
+  return lines;
+};
+var renderRevokeData = (colors, _data) => {
+  return [colors.green("Session Revoked")];
+};
+var renderKeygenData = (colors, data, flags) => {
+  return [
+    colors.green("Key Ready"),
+    ...renderFields(
+      "Key",
+      [
+        ["Path", data.path],
+        ["Fingerprint", data.pin]
+      ],
+      flags
+    )
+  ];
+};
+var renderInitData = (colors, data, flags) => {
+  const snippet = JSON.stringify(
+    { mcpServers: { appduct: data.mcpServerEntry } },
+    null,
+    2
+  );
+  return [
+    colors.green(data.changed ? "Project Initialized" : "Project Already Initialized"),
+    ...renderFields(
+      "Config",
+      [
+        ["Path", data.path],
+        ["Scheme", data.scheme],
+        ["Source", data.source],
+        // Only present for a scheme discovery read off a static project file (app.json, or one of
+        // the native Android/iOS probes) — names the exact file/key, not just which platform.
+        ["Read from", data.origin],
+        ["Written", data.changed ? data.created ? "created" : "updated" : "unchanged"]
+      ],
+      flags
+    ),
+    ...data.note === void 0 ? [] : ["", colors.yellow(`Note: ${data.note}`)],
+    "",
+    "MCP server entry",
+    ...snippet.split("\n").map((line) => `  ${line}`),
+    "",
+    "Next",
+    ...data.nextSteps.map((step, index) => `  ${index + 1}. ${step}`)
+  ];
+};
+var renderDaemonRunData = (colors, data, flags) => {
+  return [
+    colors.green("Daemon Running"),
+    ...renderFields(
+      "Daemon",
+      [
+        ["PID", data.daemon.pid],
+        ["State dir", data.daemon.state_dir],
+        ["Socket", data.daemon.socket_path]
+      ],
+      flags
+    )
+  ];
+};
+var renderDaemonStartData = (colors, data, flags) => {
+  return [
+    colors.green("Daemon Started"),
+    ...renderFields(
+      "Daemon",
+      [
+        ["PID", data.daemon.pid],
+        ["WSS port", data.daemon.wss_port],
+        ["Started at", data.daemon.started_at]
+      ],
+      flags
+    )
+  ];
+};
+var renderDaemonStopData = (colors, data, flags) => {
+  return [
+    colors.green("Daemon Stopped"),
+    ...renderFields("Daemon", [["Method", data.daemon.method]], flags)
+  ];
+};
+var formatByteSize = (bytes) => {
+  const units = ["B", "KiB", "MiB", "GiB", "TiB"];
+  let value = bytes;
+  let unit = 0;
+  while (value >= 1024 && unit < units.length - 1) {
+    value /= 1024;
+    unit += 1;
+  }
+  return `${unit === 0 ? value : value.toFixed(1)} ${units[unit]}`;
+};
+var renderDaemonStatusData = (colors, data, flags) => {
+  return [
+    colors.green("Daemon Status"),
+    ...renderFields(
+      "Daemon",
+      [
+        ["Version", data.daemon.version],
+        ["PID", data.daemon.pid],
+        ["Started at", data.daemon.started_at],
+        ["WSS port", data.daemon.wss_port],
+        ["Pinned keys", data.daemon.pinned_keys.length],
+        ["Sessions", data.daemon.session_count]
+      ],
+      flags
+    ),
+    "",
+    ...renderFields(
+      "Policy",
+      [
+        ["Default", data.policy.default],
+        ["Destructive", data.policy.destructive],
+        ["Overrides", data.policy.tools ? Object.keys(data.policy.tools).length : 0]
+      ],
+      flags
+    ),
+    "",
+    // The retention rows drop out entirely against a daemon that predates them (`renderFields`
+    // skips `undefined`), rather than printing "undefined" or an invented zero.
+    ...renderFields(
+      "Audit",
+      [
+        ["Path", data.audit.path],
+        ["Retention", data.audit.retention_days === void 0 ? void 0 : `${data.audit.retention_days} days`],
+        ["Files", data.audit.files],
+        ["Size", data.audit.bytes === void 0 ? void 0 : formatByteSize(data.audit.bytes)],
+        ["Failed writes", data.audit.failed_writes],
+        ["Failed prunes", data.audit.failed_prunes]
+      ],
+      flags
+    ),
+    // Version drift (issue #30) is the one thing here an operator has to act on, so it goes last
+    // — the line still on screen after the block scrolls — and in yellow, not a quiet field row.
+    ...data.warning ? ["", colors.yellow(`Warning: ${data.warning}`)] : []
+  ];
+};
+var renderDoctorData = (colors, data, flags) => {
+  return [
+    data.present ? colors.green("Appduct Present") : colors.yellow("Appduct Absent"),
+    ...renderFields(
+      "Artifact",
+      [
+        ["Path", data.artifact],
+        ["Platform", data.platform],
+        ["Format", data.format],
+        ["Present", data.present],
+        ["Signals", data.signals.length > 0 ? data.signals.join(", ") : "none"],
+        ["Assertion", data.assertion ? `${data.assertion.expected} (holds)` : void 0]
+      ],
+      flags
+    )
+  ];
+};
+var renderSuccessData = (colors, command, data, options) => {
+  const flags = options.flags;
+  switch (command) {
+    case "init":
+      return renderInitData(colors, data, flags);
+    case "keygen":
+      return renderKeygenData(colors, data, flags);
+    case "link":
+      return renderLinkData(colors, data, flags, options.qr);
+    case "ls":
+      return renderLsData(colors, data, options.now ?? /* @__PURE__ */ new Date());
+    case "tools":
+      return renderToolsData(colors, data, flags, options.full);
+    case "invoke":
+      return renderInvokeData(colors, data, flags);
+    case "revoke":
+      return renderRevokeData(colors, data);
+    case "daemon run":
+      return renderDaemonRunData(colors, data, flags);
+    case "daemon start":
+      return renderDaemonStartData(colors, data, flags);
+    case "daemon stop":
+      return renderDaemonStopData(colors, data, flags);
+    case "daemon status":
+      return renderDaemonStatusData(colors, data, flags);
+    case "doctor":
+      return renderDoctorData(colors, data, flags);
+    default:
+      return [colors.green("Command Complete"), formatJson(data, flags)];
+  }
+};
+var renderHumanError = (colors, error, flags, meta) => {
+  return [
+    colors.red("Command Failed"),
+    ...renderFields(
+      "Error",
+      [
+        ["Type", error.type],
+        ["Message", error.message],
+        ["Details", error.details]
+      ],
+      flags
+    ),
+    ...meta ? ["", ...renderMetaLines(meta)] : []
+  ].join("\n");
+};
+var renderResult = (result, options) => {
+  if (options.flags.json) {
+    return {
+      stdout: `${formatJson(result, options.flags)}
+`
+    };
+  }
+  const colors = pc.createColors(options.flags.color);
+  if (!result.ok) {
+    return {
+      stderr: `${renderHumanError(colors, result.error, options.flags, result.meta)}
+`
+    };
+  }
+  const lines = [
+    ...renderSuccessData(colors, options.command, result.data, options),
+    "",
+    ...renderMetaLines(result.meta)
+  ].filter((line, index, collection) => {
+    if (line !== "") {
+      return true;
+    }
+    return index > 0 && collection[index - 1] !== "" && index < collection.length - 1;
+  });
+  return {
+    stdout: `${lines.join("\n")}
+`
+  };
+};
+
+// src/cli/envelope.ts
+var createCommandMeta = (command, startedAt, finishedAt) => {
+  return {
+    command,
+    timestamp: finishedAt.toISOString(),
+    duration_ms: finishedAt.getTime() - startedAt.getTime()
+  };
+};
+var finalizeResult = (result, timing, flags) => {
+  if (!flags.verbose) {
+    return result;
+  }
+  return {
+    ...result,
+    meta: createCommandMeta(timing.command, timing.startedAt, timing.finishedAt)
+  };
+};
+
+// src/cli/runner.ts
+var writeRenderedOutput = (rendered, writers) => {
+  if (rendered.stdout) {
+    writers.stdout.write(rendered.stdout);
+  }
+  if (rendered.stderr) {
+    writers.stderr.write(rendered.stderr);
+  }
+};
+var executeCommand = async (command, handler, env, render = {}) => {
+  const startedAt = env.clock.now();
+  try {
+    const result = await handler();
+    const finishedAt = env.clock.now();
+    const finalized = finalizeResult(result, { command, startedAt, finishedAt }, env.flags);
+    const renderOptions = {
+      command,
+      flags: env.flags,
+      now: finishedAt,
+      qr: render.qr,
+      full: render.full
+    };
+    writeRenderedOutput(renderResult(finalized, renderOptions), env);
+    return 0;
+  } catch (error) {
+    const finishedAt = env.clock.now();
+    const cliError = toCliError(error);
+    const result = { ok: false, error: cliError };
+    const finalized = finalizeResult(result, { command, startedAt, finishedAt }, env.flags);
+    const renderOptions = {
+      command,
+      flags: env.flags,
+      now: finishedAt,
+      qr: render.qr,
+      full: render.full
+    };
+    writeRenderedOutput(renderResult(finalized, renderOptions), env);
+    return getExitCodeForError(error);
+  }
+};
+
+// src/cli/router.ts
+var commandName = (context) => {
+  return context.path.join(" ");
+};
+
+// src/cli/routes/init.ts
+var route = async (context) => {
+  const { options, stateDir } = context;
+  return executeCommand(
+    commandName(context),
+    () => handleInitCommand(
+      {
+        scheme: typeof options.scheme === "string" ? options.scheme : void 0,
+        force: Boolean(options.force),
+        // cac camelCases `--ios-app-id`/`--android-app-id`; the dashed spellings are kept as a
+        // fallback so a parser change can't silently drop the flag.
+        iosAppId: typeof options.iosAppId === "string" ? options.iosAppId : typeof options["ios-app-id"] === "string" ? options["ios-app-id"] : void 0,
+        androidAppId: typeof options.androidAppId === "string" ? options.androidAppId : typeof options["android-app-id"] === "string" ? options["android-app-id"] : void 0
+      },
+      // `init` never reads the state dir, but it must know which directory it is so it can
+      // refuse to write a "safe to commit" project config into the daemon's own state.
+      { stateDir }
+    ),
+    context.env
+  );
+};
+export {
+  route
+};