@usebitl/cli 0.1.0

package/adapters/dist/core.mjs

@@ -0,0 +1,715 @@
+// ../../shared/src/crypto.ts
+var MASTER_KEY_BYTES = 32;
+var VERSION = "v1";
+var PAD_BLOCK = 32;
+var TAG_BYTES = 16;
+var subtle = () => globalThis.crypto.subtle;
+var utf8 = new TextEncoder();
+var fromUtf8 = new TextDecoder("utf-8", { fatal: true });
+function toBase64Url(bytes) {
+  let bin = "";
+  for (const b of bytes) bin += String.fromCharCode(b);
+  return btoa(bin).replace(/\+/g, "-").replace(/\//g, "_").replace(/=+$/, "");
+}
+function fromBase64Url(s) {
+  if (!/^[A-Za-z0-9_-]*$/.test(s)) throw new Error("invalid base64url");
+  const bin = atob(s.replace(/-/g, "+").replace(/_/g, "/") + "=".repeat((4 - s.length % 4) % 4));
+  return Uint8Array.from(bin, (c) => c.charCodeAt(0));
+}
+var generateMasterKey = () => globalThis.crypto.getRandomValues(new Uint8Array(MASTER_KEY_BYTES));
+var info = (name) => ({ name: "HKDF", hash: "SHA-256", salt: new Uint8Array(0), info: utf8.encode(`bitl/v1/${name}`) });
+async function deriveKeys(master) {
+  if (master.length !== MASTER_KEY_BYTES) throw new Error(`\uD0A4 \uAE38\uC774\uAC00 ${MASTER_KEY_BYTES}\uBC14\uC774\uD2B8\uAC00 \uC544\uB2D9\uB2C8\uB2E4`);
+  const base = await subtle().importKey("raw", new Uint8Array(master), "HKDF", false, ["deriveKey", "deriveBits"]);
+  const [enc, tag2, kidBits] = await Promise.all([
+    subtle().deriveKey(info("enc"), base, { name: "AES-GCM", length: 256 }, false, ["encrypt", "decrypt"]),
+    subtle().deriveKey(info("tag"), base, { name: "HMAC", hash: "SHA-256", length: 256 }, false, ["sign"]),
+    subtle().deriveBits(info("kid"), base, 48)
+  ]);
+  return { enc, tag: tag2, kid: toBase64Url(new Uint8Array(kidBits)), master: new Uint8Array(master) };
+}
+function pad(bytes) {
+  const out = new Uint8Array(Math.ceil((bytes.length + 1) / PAD_BLOCK) * PAD_BLOCK);
+  out.set(bytes);
+  out[bytes.length] = 128;
+  return out;
+}
+async function seal(keys, plaintext, aad2) {
+  const iv = globalThis.crypto.getRandomValues(new Uint8Array(12));
+  const ct = await subtle().encrypt({ name: "AES-GCM", iv, additionalData: utf8.encode(aad2) }, keys.enc, pad(utf8.encode(plaintext)));
+  return `${VERSION}.${keys.kid}.${toBase64Url(iv)}.${toBase64Url(new Uint8Array(ct))}`;
+}
+async function tag(keys, value) {
+  const mac = await subtle().sign("HMAC", keys.tag, utf8.encode(value));
+  return toBase64Url(new Uint8Array(mac).subarray(0, TAG_BYTES));
+}
+var sealerFor = (keys) => ({
+  seal: (plaintext, aad2) => seal(keys, plaintext, aad2),
+  tag: (value) => tag(keys, value)
+});
+async function keysFromBase64Url(master) {
+  return deriveKeys(fromBase64Url(master.trim()));
+}
+
+// ../../shared/src/kinds.ts
+var AGENT_SOURCES = ["claude-code", "codex", "antigravity", "claude-desktop", "claude-cloud", "manual"];
+
+// ../../shared/src/normalize.ts
+var str = (v) => typeof v === "string" && v.length > 0 ? v : void 0;
+var oneLine = (s, max = 120) => {
+  const flat = s.replace(/\s+/g, " ").trim();
+  return flat.length > max ? `${flat.slice(0, max - 1)}\u2026` : flat;
+};
+function commandText(v) {
+  if (!Array.isArray(v)) return str(v);
+  const parts = v.filter((x) => typeof x === "string");
+  const shell = parts.length === 3 && /^-l?c$/.test(parts[1] ?? "");
+  return str(shell ? parts[2] : parts.join(" "));
+}
+function summarizeToolInput(input) {
+  if (!input || typeof input !== "object") return void 0;
+  const i = input;
+  const first = (list, key) => Array.isArray(list) ? str(list[0]?.[key]) : void 0;
+  const pick = commandText(i.command) ?? str(i.file_path) ?? str(i.path) ?? str(i.pattern) ?? str(i.url) ?? str(i.query) ?? str(i.description) ?? str(i.prompt) ?? first(i.questions, "question") ?? str(i.plan) ?? // ExitPlanMode: { plan }
+  // Codex webrun: { search_query: [{ q }] } 또는 { weather: [{ location }] }
+  first(i.search_query, "q") ?? first(i.weather, "location");
+  return pick ? oneLine(pick) : void 0;
+}
+var USER_BLOCKING_TOOLS = {
+  AskUserQuestion: "question",
+  ExitPlanMode: "plan"
+};
+function waitingFromNotification(kind) {
+  switch (kind) {
+    case "permission_prompt":
+      return "permission";
+    case "idle_prompt":
+      return "idle";
+    case "elicitation_dialog":
+    case "elicitation_url_dialog":
+      return "elicitation";
+    case "agent_needs_input":
+      return "input";
+    default:
+      return void 0;
+  }
+}
+function normalizeHook(source, raw, receivedAt) {
+  const nativeType = str(raw.hook_event_name);
+  const sessionId = str(raw.session_id);
+  if (!nativeType || !sessionId) return null;
+  let type = "notice";
+  let text;
+  let waitingReason;
+  let tool;
+  const toolInfo = (failed) => {
+    const name = str(raw.tool_name);
+    if (!name) return void 0;
+    return {
+      name,
+      useId: str(raw.tool_use_id),
+      summary: summarizeToolInput(raw.tool_input),
+      ...failed ? { failed } : {}
+    };
+  };
+  switch (nativeType) {
+    case "SessionStart":
+      type = "session_start";
+      break;
+    case "SessionEnd":
+      type = "session_end";
+      break;
+    case "UserPromptSubmit":
+      type = "prompt";
+      text = str(raw.user_prompt) ?? str(raw.prompt);
+      break;
+    case "PreToolUse": {
+      tool = toolInfo();
+      const reason = tool && USER_BLOCKING_TOOLS[tool.name];
+      type = reason ? "waiting" : "tool_start";
+      waitingReason = reason;
+      break;
+    }
+    case "PostToolUse":
+      type = "tool_end";
+      tool = toolInfo();
+      break;
+    case "PostToolUseFailure":
+      type = "tool_end";
+      tool = toolInfo(true);
+      text = str(raw.error_message);
+      break;
+    case "PermissionRequest":
+      type = "waiting";
+      waitingReason = "permission";
+      tool = toolInfo();
+      break;
+    case "Notification": {
+      const kind = str(raw.notification_type);
+      waitingReason = waitingFromNotification(kind);
+      type = waitingReason ? "waiting" : "notice";
+      text = str(raw.message);
+      break;
+    }
+    case "Stop":
+    case "Interrupt":
+      type = "turn_end";
+      text = str(raw.last_assistant_message);
+      break;
+    case "StopFailure":
+      type = "error";
+      text = str(raw.error_message) ?? str(raw.error_type);
+      break;
+    case "SubagentStart":
+      type = "subagent_start";
+      text = str(raw.task_description);
+      break;
+    case "SubagentStop":
+      type = "subagent_end";
+      text = str(raw.last_assistant_message);
+      break;
+    default:
+      type = "notice";
+  }
+  return {
+    source,
+    sessionId,
+    type,
+    nativeType,
+    at: receivedAt,
+    cwd: str(raw.cwd),
+    turnId: str(raw.turn_id) ?? str(raw.prompt_id),
+    agentId: str(raw.agent_id),
+    agentType: str(raw.agent_type),
+    tool,
+    text,
+    waitingReason,
+    transcriptPath: str(raw.transcript_path),
+    model: str(raw.model),
+    raw
+  };
+}
+function normalizeCodexNotify(raw, receivedAt) {
+  const nativeType = str(raw.type);
+  const sessionId = str(raw["thread-id"]);
+  if (!nativeType || !sessionId) return null;
+  return {
+    source: "codex",
+    sessionId,
+    type: nativeType === "agent-turn-complete" ? "turn_end" : "notice",
+    nativeType,
+    at: receivedAt,
+    cwd: str(raw.cwd),
+    turnId: str(raw["turn-id"]),
+    text: str(raw["last-assistant-message"]),
+    raw
+  };
+}
+function agyTool(call, failed) {
+  const name = str(call?.name);
+  if (!name) return void 0;
+  const args = call?.args ?? {};
+  const summary = str(args.CommandLine) ?? summarizeToolInput(args) ?? str(args.toolSummary);
+  return { name, summary: summary && oneLine(summary), ...failed ? { failed } : {} };
+}
+function normalizeAntigravity(raw, receivedAt) {
+  const nativeType = str(raw.hook_event_name);
+  const sessionId = str(raw.conversationId);
+  if (!nativeType || !sessionId) return null;
+  let type;
+  let text;
+  let tool;
+  let waitingReason;
+  const call = raw.toolCall;
+  const error = str(raw.error);
+  switch (nativeType) {
+    case "PreInvocation":
+      if (raw.invocationNum !== 0) return null;
+      type = "prompt";
+      text = str(raw.prompt);
+      break;
+    case "PreToolUse":
+      tool = agyTool(call);
+      if (!tool) return null;
+      type = "tool_start";
+      break;
+    case "PostToolUse":
+      tool = agyTool(call, !!error);
+      if (!tool) return null;
+      type = "tool_end";
+      text = error;
+      break;
+    case "Stop":
+      type = error ? "error" : "turn_end";
+      text = error ?? str(raw.last_assistant_message);
+      break;
+    // 아래 둘은 agy 가 아니라 bitl-agy-watch.mjs 가 대화 DB 의 단계 상태를 보고 만든다
+    case "bitl:PermissionWaiting":
+      type = "waiting";
+      waitingReason = "permission";
+      tool = agyTool(call);
+      break;
+    case "bitl:PermissionResolved":
+      type = "progress";
+      break;
+    default:
+      return null;
+  }
+  const workspaces = Array.isArray(raw.workspacePaths) ? raw.workspacePaths : [];
+  return {
+    source: "antigravity",
+    sessionId,
+    type,
+    nativeType,
+    at: receivedAt,
+    cwd: str(workspaces[0]),
+    tool,
+    text,
+    waitingReason,
+    transcriptPath: str(raw.transcriptPath),
+    model: str(raw.modelName),
+    raw
+  };
+}
+var REPORT_TYPE = {
+  start: "prompt",
+  progress: "progress",
+  waiting: "waiting",
+  done: "turn_end",
+  error: "error",
+  end: "session_end"
+};
+function normalizeReport(source, raw, receivedAt) {
+  const event = str(raw.event);
+  const sessionId = str(raw.session_id);
+  if (!event || !sessionId || !(event in REPORT_TYPE)) return null;
+  const title = str(raw.title);
+  const detail = str(raw.detail);
+  return {
+    source,
+    sessionId,
+    type: REPORT_TYPE[event],
+    nativeType: `report:${event}`,
+    at: receivedAt,
+    cwd: str(raw.cwd),
+    // start 는 제목이 곧 지시 내용, 나머지는 상세 설명
+    text: event === "start" ? title ?? detail : detail,
+    request: str(raw.request),
+    waitingReason: event === "waiting" ? "input" : void 0,
+    raw
+  };
+}
+function normalizeRecord(rec) {
+  const at = rec.receivedAt && !Number.isNaN(Date.parse(rec.receivedAt)) ? new Date(rec.receivedAt).toISOString() : (/* @__PURE__ */ new Date()).toISOString();
+  if (rec.source === "codex-notify") return normalizeCodexNotify(rec.payload, at);
+  if (rec.source === "antigravity") return normalizeAntigravity(rec.payload, at);
+  if (!AGENT_SOURCES.includes(rec.source)) return null;
+  const source = rec.source;
+  const isReport = typeof rec.payload.event === "string" && rec.payload.hook_event_name === void 0;
+  return isReport ? normalizeReport(source, rec.payload, at) : normalizeHook(source, rec.payload, at);
+}
+
+// ../../shared/src/session.ts
+var sessionKey = (source, sessionId) => `${source}:${sessionId}`;
+
+// ../../shared/src/prepare.ts
+var WIRE_VERSION = 2;
+var TEXT_LIMIT = 500;
+var TITLE_LIMIT = 80;
+var clip = (s, max = TEXT_LIMIT) => {
+  const t = s.trim();
+  return t.length > max ? `${t.slice(0, max - 1)}\u2026` : t;
+};
+var carriesContext = (e) => e.type === "session_start" || e.type === "prompt" || e.type === "turn_end" || e.nativeType === "CwdChanged";
+function activityOf(e) {
+  if (!e.tool) return void 0;
+  const base = e.tool.summary ? `${e.tool.name}: ${e.tool.summary}` : e.tool.name;
+  return e.agentId && e.agentType ? `[${e.agentType}] ${base}` : base;
+}
+function splitEvent(e, extra = {}) {
+  const newCwd = e.nativeType === "CwdChanged" && typeof e.raw.new_cwd === "string" ? e.raw.new_cwd : void 0;
+  const signal = {
+    source: e.source,
+    sessionId: e.sessionId,
+    type: e.type,
+    nativeType: e.nativeType,
+    at: e.at,
+    turnId: e.turnId,
+    agentId: e.agentId,
+    agentNamed: e.agentId || e.agentType !== void 0 ? Boolean(e.agentType) : void 0,
+    waitingReason: e.waitingReason,
+    toolFailed: e.tool?.failed || void 0
+  };
+  const content = {
+    title: e.type === "prompt" && e.text ? oneLine(e.text, TITLE_LIMIT) : void 0,
+    text: e.text ? clip(e.text) : void 0,
+    request: e.request ? clip(e.request) : void 0,
+    activity: activityOf(e),
+    tool: e.tool?.name,
+    toolSummary: e.tool?.summary,
+    agentType: e.agentType || void 0,
+    cwd: newCwd ?? (carriesContext(e) ? e.cwd : void 0),
+    model: e.model,
+    ...extra
+  };
+  const tagSource = e.type === "prompt" ? e.request ?? e.text : e.request;
+  return { signal: dropUndefined(signal), content: dropUndefined(content), tagSource };
+}
+function dropUndefined(o) {
+  return Object.fromEntries(Object.entries(o).filter(([, v]) => v !== void 0 && v !== ""));
+}
+async function prepareRecord(e, sealer, extra = {}) {
+  const { signal, content, tagSource } = splitEvent(e, extra);
+  const aad2 = sessionKey(e.source, e.sessionId);
+  const sealed = {};
+  await Promise.all(
+    Object.entries(content).map(async ([k, v]) => {
+      sealed[k] = await sealer.seal(v, aad2);
+    })
+  );
+  if (tagSource) signal.requestTag = await sealer.tag(tagSource);
+  return { v: WIRE_VERSION, signal, content: sealed };
+}
+
+// ../../shared/src/node/antigravity.ts
+import { readFile, stat } from "node:fs/promises";
+var MAX_TRANSCRIPT_BYTES = 20 * 1024 * 1024;
+var RETRY_MS = 150;
+var RETRIES = 6;
+async function readSteps(path) {
+  try {
+    if ((await stat(path)).size > MAX_TRANSCRIPT_BYTES) return [];
+    const steps = [];
+    for (const line of (await readFile(path, "utf8")).split("\n")) {
+      if (!line.trim()) continue;
+      try {
+        steps.push(JSON.parse(line));
+      } catch {
+      }
+    }
+    return steps;
+  } catch {
+    return [];
+  }
+}
+function userRequestText(content) {
+  const m = /<USER_REQUEST>\s*([\s\S]*?)\s*<\/USER_REQUEST>/.exec(content);
+  return (m?.[1] ?? content).trim();
+}
+async function fillAntigravityText(payload) {
+  const path = typeof payload.transcriptPath === "string" ? payload.transcriptPath : void 0;
+  const event = payload.hook_event_name;
+  if (!path) return payload;
+  if (event === "PreInvocation" && payload.invocationNum === 0 && payload.prompt === void 0) {
+    const index = typeof payload.initialNumSteps === "number" ? payload.initialNumSteps - 1 : void 0;
+    for (let i = 0; i <= RETRIES; i++) {
+      const steps = await readSteps(path);
+      const input = steps.filter((s) => s.type === "USER_INPUT" && (index === void 0 || s.step_index === index)).at(-1);
+      if (typeof input?.content === "string") return { ...payload, prompt: userRequestText(input.content) };
+      await new Promise((r) => setTimeout(r, RETRY_MS));
+    }
+    return payload;
+  }
+  if (event === "Stop" && payload.last_assistant_message === void 0) {
+    const steps = await readSteps(path);
+    const reply = steps.filter((s) => s.type === "PLANNER_RESPONSE" && typeof s.content === "string" && s.content.trim()).at(-1);
+    return reply ? { ...payload, last_assistant_message: reply.content.trim() } : payload;
+  }
+  return payload;
+}
+var AGY_STEP = { RUNNING: 2, DONE: 3, CANCELLED: 6, REJECTED: 7, WAITING: 9 };
+function agyWatchStep(status, waited) {
+  if (status === AGY_STEP.WAITING) return waited ? "none" : "waiting";
+  if (status === AGY_STEP.DONE || status === AGY_STEP.CANCELLED || status === AGY_STEP.REJECTED) return waited ? "resolved" : "stop";
+  if (status === AGY_STEP.RUNNING && waited) return "resolved";
+  return "none";
+}
+
+// ../../shared/src/node/cloud.ts
+import { mkdirSync as mkdirSync2, readFileSync as readFileSync2, rmSync, writeFileSync as writeFileSync2 } from "node:fs";
+import { dirname as dirname2, join as join2 } from "node:path";
+
+// ../../shared/src/node/keys.ts
+import { mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { dirname, join } from "node:path";
+var bitlHome = (env = process.env.BITL_HOME) => env?.trim() ? env.trim() : join(homedir(), ".bitl");
+var keyPath = (home = bitlHome()) => join(home, "key");
+function loadOrCreateMasterKey(home = bitlHome(), env = process.env.BITL_KEY) {
+  if (env?.trim()) return env.trim();
+  const file = keyPath(home);
+  try {
+    const existing = readFileSync(file, "utf8").trim();
+    if (existing) return existing;
+  } catch {
+  }
+  const key = toBase64Url(generateMasterKey());
+  mkdirSync(dirname(file), { recursive: true });
+  try {
+    writeFileSync(file, key + "\n", { encoding: "utf8", mode: 384, flag: "wx" });
+    return key;
+  } catch (err) {
+    if (err.code === "EEXIST") return readFileSync(file, "utf8").trim();
+    throw err;
+  }
+}
+var loadKeys = (home = bitlHome()) => keysFromBase64Url(loadOrCreateMasterKey(home));
+
+// ../../shared/src/node/cloud.ts
+var cloudConfigPath = (home = bitlHome()) => join2(home, "cloud.json");
+var cloudKeyPath = (home = bitlHome()) => join2(home, "cloud-key");
+function readCloudConfig(home = bitlHome()) {
+  try {
+    const c = JSON.parse(readFileSync2(cloudConfigPath(home), "utf8"));
+    return c.url && c.deviceId && c.apiKey ? c : null;
+  } catch {
+    return null;
+  }
+}
+function resolveTarget(home = bitlHome()) {
+  const cloud = readCloudConfig(home);
+  if (cloud) {
+    return {
+      kind: "cloud",
+      url: cloud.url.replace(/\/+$/, ""),
+      headers: { authorization: `Bearer ${cloud.apiKey}` },
+      keys: () => keysFromBase64Url(readFileSync2(cloudKeyPath(home), "utf8"))
+    };
+  }
+  return {
+    kind: "local",
+    url: (process.env.BITL_URL?.trim() || `http://127.0.0.1:${process.env.BITL_PORT ?? 7777}`).replace(/\/+$/, ""),
+    headers: {},
+    keys: () => loadKeys(home)
+  };
+}
+
+// ../../shared/src/node/enrich.ts
+import { execFile } from "node:child_process";
+import { readFile as readFile2, stat as stat2 } from "node:fs/promises";
+import { basename } from "node:path";
+var BRANCH_TTL_MS = 6e4;
+var MAX_TRANSCRIPT_BYTES2 = 20 * 1024 * 1024;
+var branchCache = /* @__PURE__ */ new Map();
+function gitBranch(cwd) {
+  const hit = branchCache.get(cwd);
+  if (hit && Date.now() - hit.at < BRANCH_TTL_MS) return Promise.resolve(hit.branch);
+  return new Promise((resolve) => {
+    execFile("git", ["-C", cwd, "branch", "--show-current"], { timeout: 2e3, windowsHide: true }, (err, stdout) => {
+      const branch = err ? void 0 : stdout.trim() || void 0;
+      branchCache.set(cwd, { at: Date.now(), branch });
+      resolve(branch);
+    });
+  });
+}
+async function aiTitleFromTranscript(path) {
+  try {
+    if ((await stat2(path)).size > MAX_TRANSCRIPT_BYTES2) return void 0;
+    const text = await readFile2(path, "utf8");
+    let title;
+    for (const line of text.split("\n")) {
+      if (!line.includes('"ai-title"')) continue;
+      try {
+        const rec = JSON.parse(line);
+        if (rec.type === "ai-title" && rec.aiTitle) title = rec.aiTitle;
+      } catch {
+      }
+    }
+    return title;
+  } catch {
+    return void 0;
+  }
+}
+function gitRoot(cwd) {
+  const hit = rootCache.get(cwd);
+  if (hit && Date.now() - hit.at < BRANCH_TTL_MS) return Promise.resolve(hit.root);
+  return new Promise((resolve) => {
+    execFile("git", ["-C", cwd, "rev-parse", "--show-toplevel"], { timeout: 2e3, windowsHide: true }, (err, stdout) => {
+      const root = err ? void 0 : stdout.trim() || void 0;
+      rootCache.set(cwd, { at: Date.now(), root });
+      resolve(root);
+    });
+  });
+}
+var rootCache = /* @__PURE__ */ new Map();
+async function projectName(cwd) {
+  const root = await gitRoot(cwd);
+  return basename((root ?? cwd).replace(/[\\/]+$/, ""));
+}
+async function enrichEvent(e) {
+  const extra = {};
+  const newCwd = e.nativeType === "CwdChanged" && typeof e.raw.new_cwd === "string" ? e.raw.new_cwd : void 0;
+  const cwd = newCwd ?? e.cwd;
+  const tasks = [];
+  if (cwd && carriesContext(e)) {
+    tasks.push(
+      Promise.all([gitBranch(cwd), projectName(cwd)]).then(([branch, project]) => {
+        if (branch) extra.gitBranch = branch;
+        extra.project = project;
+      })
+    );
+  }
+  if (e.source === "claude-code" && e.transcriptPath && (e.type === "prompt" || e.type === "turn_end")) {
+    tasks.push(
+      aiTitleFromTranscript(e.transcriptPath).then((title) => {
+        if (title) extra.aiTitle = title;
+      })
+    );
+  }
+  await Promise.all(tasks.map((t) => t.catch(() => {
+  })));
+  return extra;
+}
+
+// ../../shared/src/approval.ts
+var APPROVAL_SIG_PATTERN = /^[A-Za-z0-9_-]{43}$/;
+var MAX_DETAIL = 4e3;
+var clip2 = (s, n) => s.length > n ? `${s.slice(0, n - 1)}\u2026` : s;
+var str2 = (v) => typeof v === "string" && v.length > 0 ? v : void 0;
+function newApprovalId() {
+  return toBase64Url(globalThis.crypto.getRandomValues(new Uint8Array(16)));
+}
+function describeToolRequest(toolName, input, extra = {}) {
+  const i = input && typeof input === "object" ? input : {};
+  const short = summarizeToolInput(i);
+  let detail;
+  if (typeof i.command === "string") detail = i.command;
+  else if (typeof i.file_path === "string") {
+    const body = str2(i.content) ?? (typeof i.new_string === "string" ? `- ${oneLine(String(i.old_string ?? ""), 300)}
++ ${i.new_string}` : void 0) ?? (Array.isArray(i.edits) ? `${i.edits.length}\uACF3 \uC218\uC815` : void 0);
+    detail = body ? `${i.file_path}
+
+${body}` : i.file_path;
+  } else if (typeof i.plan === "string") detail = i.plan;
+  else if (Object.keys(i).length) detail = JSON.stringify(i, null, 2);
+  return {
+    tool: toolName,
+    summary: oneLine(short ? `${toolName}: ${short}` : toolName, 200),
+    detail: detail ? clip2(detail, MAX_DETAIL) : void 0,
+    description: str2(i.description) ? oneLine(String(i.description), 300) : void 0,
+    ...extra
+  };
+}
+var aad = (id) => `approval:${id}`;
+var sealApprovalRequest = (keys, id, req) => seal(keys, JSON.stringify(req), aad(id));
+var approvalKeys = /* @__PURE__ */ new WeakMap();
+function approvalKey(keys) {
+  let k = approvalKeys.get(keys);
+  if (!k) {
+    k = globalThis.crypto.subtle.importKey("raw", keys.master, "HKDF", false, ["deriveKey"]).then(
+      (base) => globalThis.crypto.subtle.deriveKey(
+        { name: "HKDF", hash: "SHA-256", salt: new Uint8Array(0), info: new TextEncoder().encode("bitl/v1/approve") },
+        base,
+        { name: "HMAC", hash: "SHA-256", length: 256 },
+        false,
+        ["sign", "verify"]
+      )
+    );
+    approvalKeys.set(keys, k);
+  }
+  return k;
+}
+var message = (id, decision) => new TextEncoder().encode(`bitl/approval/v1
+${id}
+${decision}`);
+async function verifyDecision(keys, id, decision, sig) {
+  if (decision !== "allow" && decision !== "deny" || !APPROVAL_SIG_PATTERN.test(sig)) return false;
+  return globalThis.crypto.subtle.verify("HMAC", await approvalKey(keys), fromBase64Url(sig), message(id, decision));
+}
+
+// ../../shared/src/node/approve.ts
+var DEFAULT_APPROVAL_WAIT_MS = 10 * 6e4;
+var SKIP_TOOLS = /* @__PURE__ */ new Set(["AskUserQuestion"]);
+var POLL_MS = 25e3;
+var DENY_MESSAGE = "\uC0AC\uC6A9\uC790\uAC00 \uD734\uB300\uD3F0(BITL \uC6D0\uACA9 \uC2B9\uC778)\uC5D0\uC11C \uAC70\uBD80\uD588\uC2B5\uB2C8\uB2E4.";
+var sleep = (ms, signal) => new Promise((resolve) => {
+  const t = setTimeout(resolve, ms);
+  signal?.addEventListener("abort", () => (clearTimeout(t), resolve()), { once: true });
+});
+async function requestRemoteApproval(payload, opts = {}) {
+  const log = opts.log ?? (() => {
+  });
+  const tool = typeof payload.tool_name === "string" ? payload.tool_name : void 0;
+  const sessionId = typeof payload.session_id === "string" ? payload.session_id : void 0;
+  if (!tool || !sessionId || SKIP_TOOLS.has(tool)) return null;
+  const target = resolveTarget(opts.home ?? bitlHome());
+  const api = async (path, init) => {
+    const signals = [AbortSignal.timeout(init.timeoutMs), ...opts.signal && !init.keepOnAbort ? [opts.signal] : []];
+    const res = await fetch(`${target.url}${path}`, {
+      ...init,
+      headers: { "content-type": "application/json", ...target.headers },
+      signal: AbortSignal.any(signals)
+    });
+    if (!res.ok) throw new Error(`${path}: HTTP ${res.status}`);
+    return await res.json();
+  };
+  try {
+    if ((await api("/api/approvals/mode", { timeoutMs: 2e3 })).away !== true) return null;
+  } catch (err) {
+    log(`\uC6D0\uACA9 \uC2B9\uC778: \uC11C\uBC84\uC5D0 \uBB3C\uC744 \uC218 \uC5C6\uC5B4 \uD130\uBBF8\uB110\uC5D0\uC11C \uC2B9\uC778\uD569\uB2C8\uB2E4 (${err.message})`);
+    return null;
+  }
+  const keys = await target.keys();
+  const id = newApprovalId();
+  const cwd = typeof payload.cwd === "string" ? payload.cwd : void 0;
+  const project = cwd ? await projectName(cwd).catch(() => void 0) : void 0;
+  const request = await sealApprovalRequest(keys, id, describeToolRequest(tool, payload.tool_input, { project, cwd }));
+  const waitMs = opts.waitMs ?? DEFAULT_APPROVAL_WAIT_MS;
+  const source = typeof payload.source === "string" ? payload.source : "claude-code";
+  try {
+    await api("/api/approvals", {
+      method: "POST",
+      body: JSON.stringify({ id, sessionKey: `${source}:${sessionId}`, request, ttlSec: Math.ceil(waitMs / 1e3) }),
+      timeoutMs: 5e3
+    });
+  } catch (err) {
+    log(`\uC6D0\uACA9 \uC2B9\uC778: \uC694\uCCAD\uC744 \uC62C\uB9AC\uC9C0 \uBABB\uD588\uC2B5\uB2C8\uB2E4 (${err.message})`);
+    return null;
+  }
+  const deadline = Date.now() + waitMs;
+  const cancel = () => api(`/api/approvals/${id}/cancel`, { method: "POST", timeoutMs: 3e3, keepOnAbort: true }).catch(() => void 0);
+  while (Date.now() < deadline && !opts.signal?.aborted) {
+    let a;
+    try {
+      const ms = Math.min(POLL_MS, Math.max(deadline - Date.now(), 0));
+      a = await api(`/api/approvals/${id}/wait?ms=${ms}`, { timeoutMs: ms + 1e4 });
+    } catch {
+      await sleep(2e3, opts.signal);
+      continue;
+    }
+    const status = a.status;
+    if (status === "pending") continue;
+    if (status === "allow" || status === "deny") {
+      if (!await verifyDecision(keys, id, status, typeof a.sig === "string" ? a.sig : "")) {
+        log(`\uC6D0\uACA9 \uC2B9\uC778: \uC11C\uBA85\uC774 \uB9DE\uC9C0 \uC54A\uB294 \uACB0\uC815\uC744 \uBC1B\uC558\uC2B5\uB2C8\uB2E4 (${id}) \u2014 \uB530\uB974\uC9C0 \uC54A\uACE0 \uD130\uBBF8\uB110\uC5D0\uC11C \uC2B9\uC778\uD569\uB2C8\uB2E4`);
+        return null;
+      }
+      return status === "allow" ? { behavior: "allow" } : { behavior: "deny", message: DENY_MESSAGE };
+    }
+    return null;
+  }
+  await cancel();
+  return null;
+}
+
+// ../../shared/src/node/index.ts
+async function prepareRaw(rec, opts = {}) {
+  const filled = rec.source === "antigravity" && opts.enrich !== false ? { ...rec, payload: await fillAntigravityText(rec.payload) } : rec;
+  const e = normalizeRecord(filled);
+  if (!e) return null;
+  const extra = opts.enrich === false ? {} : await enrichEvent(e);
+  const keys = opts.keys ?? await loadKeys(opts.home ?? bitlHome());
+  return prepareRecord(e, sealerFor(keys), extra);
+}
+async function prepareForTarget(rec, home = bitlHome()) {
+  const target = resolveTarget(home);
+  const keys = await target.keys();
+  const record = await prepareRaw(rec, { keys, home });
+  return { kind: target.kind, url: target.url, headers: target.headers, kid: keys.kid, record };
+}
+export {
+  agyWatchStep,
+  prepareForTarget,
+  prepareRaw,
+  requestRemoteApproval
+};