codesail 0.1.0

package/dist/index.js

@@ -0,0 +1,658 @@
+import {
+  authenticate,
+  createAuthRequest,
+  createSocketClient,
+  fetchSessions,
+  loadConfig,
+  loadCredentials,
+  saveCredentials,
+  setConfigValue
+} from "./chunk-SFXOQ3OG.js";
+import {
+  isDaemonRunning,
+  readDaemonState
+} from "./chunk-4OXDCPSF.js";
+import {
+  base64urlEncode,
+  boxOpen,
+  decodeBase64,
+  decryptValue,
+  encodeBase64,
+  encryptToBase64,
+  generateBoxKeyPair,
+  resolveSessionEncryption
+} from "./chunk-LWJDKIJF.js";
+import {
+  DEFAULT_SERVER_URL,
+  QR_PREFIX
+} from "./chunk-HG54UP2Y.js";
+
+// src/index.ts
+import { Command } from "commander";
+
+// src/commands/login.ts
+import nacl from "tweetnacl";
+import chalk from "chalk";
+import ora from "ora";
+import qrcode from "qrcode-terminal";
+
+// src/core/crypto/backup.ts
+var BASE32_ALPHABET = "ABCDEFGHIJKLMNOPQRSTUVWXYZ234567";
+var OCR_CORRECTIONS = {
+  "0": "O",
+  "1": "I",
+  "8": "B",
+  "l": "I",
+  "o": "O"
+};
+function base32Encode(data) {
+  let bits = 0;
+  let value = 0;
+  let result = "";
+  for (const byte of data) {
+    value = value << 8 | byte;
+    bits += 8;
+    while (bits >= 5) {
+      bits -= 5;
+      result += BASE32_ALPHABET[value >>> bits & 31];
+    }
+  }
+  if (bits > 0) {
+    result += BASE32_ALPHABET[value << 5 - bits & 31];
+  }
+  while (result.length % 8 !== 0) {
+    result += "=";
+  }
+  return result;
+}
+function base32Decode(input) {
+  const cleaned = input.replace(/[\s-]/g, "").replace(/=+$/, "").split("").map((c) => OCR_CORRECTIONS[c] ?? c.toUpperCase()).join("");
+  const bytes = [];
+  let bits = 0;
+  let value = 0;
+  for (const char of cleaned) {
+    const idx = BASE32_ALPHABET.indexOf(char);
+    if (idx === -1) throw new Error(`Invalid Base32 character: ${char}`);
+    value = value << 5 | idx;
+    bits += 5;
+    if (bits >= 8) {
+      bits -= 8;
+      bytes.push(value >>> bits & 255);
+    }
+  }
+  return new Uint8Array(bytes);
+}
+function formatBase32(encoded) {
+  const clean = encoded.replace(/=+$/, "");
+  return clean.match(/.{1,4}/g)?.join("-") ?? clean;
+}
+
+// src/commands/login.ts
+async function loginCommand(opts) {
+  const serverURL = opts.server ?? DEFAULT_SERVER_URL;
+  const existing = await loadCredentials();
+  if (existing) {
+    console.log(chalk.yellow("Already logged in. Showing QR for mobile pairing..."));
+    await showPairingQR(serverURL);
+    return;
+  }
+  console.log(chalk.bold("Creating new CodeSail account...\n"));
+  const masterSecret = nacl.randomBytes(32);
+  const spinner = ora("Authenticating with server...").start();
+  let token;
+  try {
+    token = await authenticate(masterSecret, serverURL);
+    spinner.succeed("Authenticated successfully");
+  } catch (err) {
+    spinner.fail("Authentication failed");
+    console.error(chalk.red(err.message));
+    process.exit(1);
+  }
+  await saveCredentials({
+    token,
+    masterSecret: encodeBase64(masterSecret),
+    serverURL
+  });
+  console.log(chalk.green("Credentials saved to ~/.codesail/credentials.json"));
+  const backupKey = formatBase32(base32Encode(masterSecret));
+  console.log("\n" + chalk.bold("Backup Key (save this somewhere safe!):"));
+  console.log(chalk.cyan(backupKey));
+  console.log(chalk.dim("You can restore your account on any device with this key.\n"));
+  await showPairingQR(serverURL);
+}
+async function showPairingQR(serverURL) {
+  const resolvedURL = serverURL ?? DEFAULT_SERVER_URL;
+  const ephemeral = generateBoxKeyPair();
+  const publicKeyBase64 = encodeBase64(ephemeral.publicKey);
+  const publicKeyBase64url = base64urlEncode(ephemeral.publicKey);
+  const spinner = ora("Creating pairing request...").start();
+  try {
+    await createAuthRequest(publicKeyBase64, true, resolvedURL);
+    spinner.succeed("Pairing request created");
+  } catch (err) {
+    spinner.fail("Failed to create pairing request");
+    console.error(chalk.red(err.message));
+    return;
+  }
+  const qrContent = QR_PREFIX + publicKeyBase64url;
+  console.log("\n" + chalk.bold("Scan this QR code with the CodeSail iOS app:"));
+  qrcode.generate(qrContent, { small: true });
+  console.log(chalk.dim("\nWaiting for mobile app to scan and approve..."));
+  const pollSpinner = ora("Polling...").start();
+  for (let i = 0; i < 120; i++) {
+    await sleep(1e3);
+    try {
+      const result = await createAuthRequest(publicKeyBase64, true, resolvedURL);
+      if (result.response) {
+        pollSpinner.succeed("Mobile app approved the pairing!");
+        const responseData = Buffer.from(result.response, "base64");
+        const decrypted = boxOpen(new Uint8Array(responseData), ephemeral.secretKey);
+        if (decrypted[0] === 0 && decrypted.length === 33) {
+          console.log(chalk.green("V2 pairing complete \u2014 content public key received"));
+        } else if (decrypted.length === 32) {
+          console.log(chalk.green("V1 pairing complete \u2014 master secret received"));
+          const token = await authenticate(decrypted, resolvedURL);
+          await saveCredentials({
+            token,
+            masterSecret: encodeBase64(decrypted),
+            serverURL: resolvedURL
+          });
+          console.log(chalk.green("Credentials updated"));
+        }
+        return;
+      }
+      if (result.status === "not_found") {
+        pollSpinner.text = "Request expired, creating new one...";
+        await createAuthRequest(publicKeyBase64, true, resolvedURL);
+      }
+    } catch {
+    }
+  }
+  pollSpinner.fail("Pairing timed out. Run `codesail auth login` to try again.");
+}
+function sleep(ms) {
+  return new Promise((resolve2) => setTimeout(resolve2, ms));
+}
+
+// src/commands/daemon.ts
+import { fork } from "child_process";
+import { fileURLToPath } from "url";
+import { dirname, join } from "path";
+import chalk2 from "chalk";
+import ora2 from "ora";
+function findDaemonEntry() {
+  const thisFile = fileURLToPath(import.meta.url);
+  const distDir = dirname(thisFile);
+  const candidate = join(distDir, "daemon", "index.js");
+  return candidate;
+}
+async function daemonStartCommand() {
+  const creds = await loadCredentials();
+  if (!creds) {
+    console.error(chalk2.red("Not logged in. Run `codesail login` first."));
+    process.exit(1);
+  }
+  if (await isDaemonRunning()) {
+    const state2 = await readDaemonState();
+    console.log(chalk2.yellow(`Daemon already running (PID: ${state2?.pid}, port: ${state2?.httpPort})`));
+    return;
+  }
+  const spinner = ora2("Starting daemon...").start();
+  const daemonEntry = findDaemonEntry();
+  const child = fork(daemonEntry, [], {
+    detached: true,
+    stdio: "ignore"
+  });
+  child.unref();
+  await new Promise((resolve2) => setTimeout(resolve2, 2e3));
+  const state = await readDaemonState();
+  if (state) {
+    spinner.succeed(`Daemon started (PID: ${state.pid}, port: ${state.httpPort})`);
+  } else {
+    spinner.fail("Daemon may have failed to start. Check logs.");
+  }
+}
+async function daemonStopCommand() {
+  const state = await readDaemonState();
+  if (!state) {
+    console.log(chalk2.yellow("Daemon is not running."));
+    return;
+  }
+  const spinner = ora2("Stopping daemon...").start();
+  try {
+    process.kill(state.pid, "SIGTERM");
+    await new Promise((resolve2) => setTimeout(resolve2, 1e3));
+    spinner.succeed(`Daemon stopped (was PID: ${state.pid})`);
+  } catch {
+    spinner.warn("Daemon process not found \u2014 cleaning up state file.");
+    const { removeDaemonState } = await import("./state-J732R3HC.js");
+    await removeDaemonState();
+  }
+}
+async function daemonStatusCommand() {
+  const running = await isDaemonRunning();
+  const state = await readDaemonState();
+  if (running && state) {
+    console.log(chalk2.green("Daemon is running"));
+    console.log(`  PID:  ${state.pid}`);
+    console.log(`  Port: ${state.httpPort}`);
+    console.log(`  URL:  http://127.0.0.1:${state.httpPort}`);
+  } else {
+    console.log(chalk2.yellow("Daemon is not running"));
+  }
+}
+
+// src/commands/sessions.ts
+import chalk3 from "chalk";
+import ora3 from "ora";
+async function sessionsCommand() {
+  if (await isDaemonRunning()) {
+    const state = await readDaemonState();
+    if (state) {
+      try {
+        const resp = await fetch(`http://127.0.0.1:${state.httpPort}/sessions`);
+        const data = await resp.json();
+        displayDaemonSessions(data.sessions);
+        return;
+      } catch {
+      }
+    }
+  }
+  const creds = await loadCredentials();
+  if (!creds) {
+    console.error(chalk3.red("Not logged in. Run `codesail login` first."));
+    process.exit(1);
+  }
+  const spinner = ora3("Fetching sessions...").start();
+  try {
+    const masterSecret = decodeBase64(creds.masterSecret);
+    const serverURL = creds.serverURL ?? DEFAULT_SERVER_URL;
+    const rawSessions = await fetchSessions(creds.token, serverURL);
+    spinner.succeed(`Found ${rawSessions.length} sessions`);
+    displaySessions(rawSessions, masterSecret);
+  } catch (err) {
+    spinner.fail("Failed to fetch sessions");
+    console.error(chalk3.red(err.message));
+    process.exit(1);
+  }
+}
+function displaySessions(rawSessions, masterSecret) {
+  if (rawSessions.length === 0) {
+    console.log(chalk3.dim("No sessions found."));
+    return;
+  }
+  console.log("");
+  for (const raw of rawSessions) {
+    const encryption = resolveSessionEncryption(raw.dataEncryptionKey, masterSecret);
+    let metadata = null;
+    let agentState = null;
+    try {
+      const metaData = decodeBase64(raw.metadata);
+      metadata = decryptValue(encryption, metaData);
+    } catch {
+    }
+    if (raw.agentState) {
+      try {
+        const stateData = decodeBase64(raw.agentState);
+        agentState = decryptValue(encryption, stateData);
+      } catch {
+      }
+    }
+    const name = metadata?.name ?? metadata?.path?.split("/").pop() ?? raw.id.slice(0, 8);
+    const path = metadata?.path ?? "";
+    const host = metadata?.host ?? "";
+    const hasPending = agentState?.requests && Object.keys(agentState.requests).length > 0;
+    const lifecycle = metadata?.lifecycleState;
+    const updatedAt = new Date(raw.updatedAt).toLocaleString();
+    let status = chalk3.dim("idle");
+    if (hasPending) {
+      const tools = Object.values(agentState.requests).map((r) => r.tool);
+      status = chalk3.yellow(`\u26A0 permission: ${tools[0]}`);
+    } else if (lifecycle === "archived") {
+      status = chalk3.dim("archived");
+    }
+    console.log(chalk3.bold(name) + chalk3.dim(` [${raw.id.slice(0, 8)}]`));
+    console.log(`  ${chalk3.dim("Path:")}  ${path}`);
+    if (host) console.log(`  ${chalk3.dim("Host:")}  ${host}`);
+    console.log(`  ${chalk3.dim("Status:")} ${status}`);
+    console.log(`  ${chalk3.dim("Updated:")} ${updatedAt}`);
+    if (metadata?.summary?.text) {
+      console.log(`  ${chalk3.dim("Summary:")} ${metadata.summary.text.slice(0, 100)}`);
+    }
+    console.log("");
+  }
+}
+function displayDaemonSessions(sessions) {
+  if (sessions.length === 0) {
+    console.log(chalk3.dim("No sessions found."));
+    return;
+  }
+  console.log("");
+  for (const s of sessions) {
+    const name = s.name || s.id.slice(0, 8);
+    const path = s.path || "";
+    const host = s.host || "";
+    const hasPending = s.hasPendingPermission === true;
+    const updatedAt = new Date(s.updatedAt).toLocaleString();
+    const lifecycle = s.lifecycleState;
+    let status = chalk3.dim("idle");
+    if (hasPending) {
+      const reqs = s.pendingRequests;
+      const tools = Object.values(reqs).map((r) => r.tool);
+      status = chalk3.yellow(`\u26A0 permission: ${tools[0]}`);
+    } else if (lifecycle === "archived") {
+      status = chalk3.dim("archived");
+    } else {
+      const activity = s.activity;
+      if (activity?.isThinking) status = chalk3.blue("thinking...");
+      else if (activity?.isActive) status = chalk3.green("active");
+    }
+    console.log(chalk3.bold(name) + chalk3.dim(` [${s.id.slice(0, 8)}]`));
+    console.log(`  ${chalk3.dim("Path:")}  ${path}`);
+    if (host) console.log(`  ${chalk3.dim("Host:")}  ${host}`);
+    console.log(`  ${chalk3.dim("Status:")} ${status}`);
+    console.log(`  ${chalk3.dim("Updated:")} ${updatedAt}`);
+    if (s.summary) {
+      console.log(`  ${chalk3.dim("Summary:")} ${s.summary.slice(0, 100)}`);
+    }
+    console.log("");
+  }
+}
+
+// src/commands/send.ts
+import chalk4 from "chalk";
+import ora4 from "ora";
+async function sendCommand(sessionQuery, message) {
+  if (await isDaemonRunning()) {
+    const state = await readDaemonState();
+    if (state) {
+      try {
+        const sessionId = await resolveSessionId(sessionQuery, state.httpPort);
+        const resp = await fetch(`http://127.0.0.1:${state.httpPort}/send-message`, {
+          method: "POST",
+          headers: { "Content-Type": "application/json" },
+          body: JSON.stringify({ sessionId, text: message })
+        });
+        const data = await resp.json();
+        if (data.success) {
+          console.log(chalk4.green("Message sent."));
+        } else {
+          console.error(chalk4.red(`Failed: ${data.error}`));
+        }
+        return;
+      } catch {
+      }
+    }
+  }
+  const creds = await loadCredentials();
+  if (!creds) {
+    console.error(chalk4.red("Not logged in. Run `codesail login` first."));
+    process.exit(1);
+  }
+  const spinner = ora4("Sending message...").start();
+  const masterSecret = decodeBase64(creds.masterSecret);
+  const serverURL = creds.serverURL ?? DEFAULT_SERVER_URL;
+  const rawSessions = await fetchSessions(creds.token, serverURL);
+  const session = rawSessions.find(
+    (s) => s.id === sessionQuery || s.id.startsWith(sessionQuery)
+  );
+  if (!session) {
+    spinner.fail(`Session not found: ${sessionQuery}`);
+    process.exit(1);
+  }
+  const encryption = resolveSessionEncryption(session.dataEncryptionKey, masterSecret);
+  const content = {
+    role: "user",
+    content: { type: "text", text: message },
+    meta: { sentFrom: "cli" }
+  };
+  const encrypted = encryptToBase64(encryption, content);
+  const socket = createSocketClient(serverURL, creds.token);
+  await new Promise((resolve2, reject) => {
+    const timeout = setTimeout(() => {
+      socket.disconnect();
+      reject(new Error("Connection timeout"));
+    }, 1e4);
+    socket.onConnect(() => {
+      clearTimeout(timeout);
+      socket.sendMessage(session.id, encrypted);
+      setTimeout(() => {
+        socket.disconnect();
+        resolve2();
+      }, 500);
+    });
+    socket.connect();
+  });
+  spinner.succeed("Message sent.");
+}
+async function resolveSessionId(query, daemonPort) {
+  const resp = await fetch(`http://127.0.0.1:${daemonPort}/sessions`);
+  const data = await resp.json();
+  const exact = data.sessions.find((s) => s.id === query);
+  if (exact) return exact.id;
+  const prefix = data.sessions.find((s) => s.id.startsWith(query));
+  if (prefix) return prefix.id;
+  const name = data.sessions.find(
+    (s) => s.name.toLowerCase().includes(query.toLowerCase()) || s.path.toLowerCase().includes(query.toLowerCase())
+  );
+  if (name) return name.id;
+  throw new Error(`Session not found: ${query}`);
+}
+
+// src/commands/approve.ts
+import chalk5 from "chalk";
+import ora5 from "ora";
+async function approveCommand(sessionQuery, opts) {
+  const decision = opts.decision ?? "approved";
+  await handlePermission(sessionQuery, true, decision);
+}
+async function denyCommand(sessionQuery) {
+  await handlePermission(sessionQuery, false, "denied");
+}
+async function handlePermission(sessionQuery, approved, decision) {
+  const action = approved ? "Approving" : "Denying";
+  const pastAction = approved ? "approved" : "denied";
+  if (await isDaemonRunning()) {
+    const state = await readDaemonState();
+    if (state) {
+      try {
+        const { sessionId, requestId: requestId2 } = await findPendingVia(sessionQuery, state.httpPort);
+        const endpoint = approved ? "approve-permission" : "deny-permission";
+        const body = { sessionId, requestId: requestId2 };
+        if (approved) body.decision = decision;
+        const resp = await fetch(`http://127.0.0.1:${state.httpPort}/${endpoint}`, {
+          method: "POST",
+          headers: { "Content-Type": "application/json" },
+          body: JSON.stringify(body)
+        });
+        const data = await resp.json();
+        if (data.success) {
+          console.log(chalk5.green(`Permission ${pastAction}.`));
+        } else {
+          console.error(chalk5.red(`Failed: ${data.error}`));
+        }
+        return;
+      } catch (err) {
+        console.error(chalk5.dim(`Daemon error: ${err.message}, falling back to direct API`));
+      }
+    }
+  }
+  const creds = await loadCredentials();
+  if (!creds) {
+    console.error(chalk5.red("Not logged in. Run `codesail login` first."));
+    process.exit(1);
+  }
+  const spinner = ora5(`${action} permission...`).start();
+  const masterSecret = decodeBase64(creds.masterSecret);
+  const serverURL = creds.serverURL ?? DEFAULT_SERVER_URL;
+  const rawSessions = await fetchSessions(creds.token, serverURL);
+  const session = rawSessions.find(
+    (s) => s.id === sessionQuery || s.id.startsWith(sessionQuery)
+  );
+  if (!session) {
+    spinner.fail(`Session not found: ${sessionQuery}`);
+    process.exit(1);
+  }
+  const encryption = resolveSessionEncryption(session.dataEncryptionKey, masterSecret);
+  let agentState = null;
+  if (session.agentState) {
+    try {
+      const stateData = decodeBase64(session.agentState);
+      const { decryptValue: decryptValue2 } = await import("./encryption-IBHFWEPA.js");
+      agentState = decryptValue2(encryption, stateData);
+    } catch {
+    }
+  }
+  if (!agentState?.requests || Object.keys(agentState.requests).length === 0) {
+    spinner.fail("No pending permission requests for this session.");
+    process.exit(1);
+  }
+  const [requestId, request] = Object.entries(agentState.requests)[0];
+  spinner.text = `${action} "${request.tool}" request...`;
+  const params = {
+    id: requestId,
+    approved,
+    decision
+  };
+  const encrypted = encryptToBase64(encryption, params);
+  const socket = createSocketClient(serverURL, creds.token);
+  const result = await new Promise((resolve2, reject) => {
+    const timeout = setTimeout(() => {
+      socket.disconnect();
+      reject(new Error("Connection timeout"));
+    }, 15e3);
+    socket.onConnect(async () => {
+      clearTimeout(timeout);
+      try {
+        const res = await socket.rpcCall(`${session.id}:permission`, encrypted);
+        socket.disconnect();
+        resolve2(res);
+      } catch (err) {
+        socket.disconnect();
+        reject(err);
+      }
+    });
+    socket.connect();
+  });
+  spinner.succeed(`Permission ${pastAction} for "${request.tool}".`);
+}
+async function findPendingVia(sessionQuery, daemonPort) {
+  const resp = await fetch(`http://127.0.0.1:${daemonPort}/sessions`);
+  const data = await resp.json();
+  const session = data.sessions.find(
+    (s) => s.id === sessionQuery || s.id.startsWith(sessionQuery) || s.name.toLowerCase().includes(sessionQuery.toLowerCase()) || s.path.toLowerCase().includes(sessionQuery.toLowerCase())
+  );
+  if (!session) throw new Error(`Session not found: ${sessionQuery}`);
+  if (!session.hasPendingPermission) throw new Error("No pending permission requests");
+  const requestId = Object.keys(session.pendingRequests)[0];
+  return { sessionId: session.id, requestId };
+}
+
+// src/commands/backup.ts
+import chalk6 from "chalk";
+import ora6 from "ora";
+import { createInterface } from "readline/promises";
+import { stdin, stdout } from "process";
+async function backupShowCommand() {
+  const creds = await loadCredentials();
+  if (!creds) {
+    console.error(chalk6.red("Not logged in. Run `codesail login` first."));
+    process.exit(1);
+  }
+  const masterSecret = decodeBase64(creds.masterSecret);
+  const encoded = formatBase32(base32Encode(masterSecret));
+  console.log(chalk6.bold("\nBackup Key:"));
+  console.log(chalk6.cyan(encoded));
+  console.log(chalk6.dim("\nStore this key safely. It can restore your account on any device."));
+}
+async function backupRestoreCommand(opts) {
+  const serverURL = opts.server ?? DEFAULT_SERVER_URL;
+  const rl = createInterface({ input: stdin, output: stdout });
+  const input = await rl.question(chalk6.bold("Enter your backup key: "));
+  rl.close();
+  if (!input.trim()) {
+    console.error(chalk6.red("No key entered."));
+    process.exit(1);
+  }
+  const spinner = ora6("Decoding backup key...").start();
+  let masterSecret;
+  try {
+    masterSecret = base32Decode(input.trim());
+    if (masterSecret.length !== 32) {
+      throw new Error(`Expected 32 bytes, got ${masterSecret.length}`);
+    }
+    spinner.succeed("Backup key decoded");
+  } catch (err) {
+    spinner.fail("Invalid backup key");
+    console.error(chalk6.red(err.message));
+    process.exit(1);
+  }
+  spinner.start("Authenticating...");
+  try {
+    const token = await authenticate(masterSecret, serverURL);
+    await saveCredentials({
+      token,
+      masterSecret: encodeBase64(masterSecret),
+      serverURL
+    });
+    spinner.succeed("Account restored successfully");
+    console.log(chalk6.green("Credentials saved to ~/.codesail/credentials.json"));
+  } catch (err) {
+    spinner.fail("Authentication failed");
+    console.error(chalk6.red(err.message));
+    process.exit(1);
+  }
+}
+
+// src/commands/config.ts
+import chalk7 from "chalk";
+async function configSetCommand(key, value) {
+  await setConfigValue(key, value);
+  console.log(chalk7.green(`Set ${key} = ${value}`));
+}
+async function configGetCommand(key) {
+  const config2 = await loadConfig();
+  const value = config2[key];
+  if (value === void 0) {
+    console.log(chalk7.dim(`${key} is not set`));
+  } else {
+    console.log(`${key} = ${value}`);
+  }
+}
+async function configListCommand() {
+  const config2 = await loadConfig();
+  const entries = Object.entries(config2);
+  if (entries.length === 0) {
+    console.log(chalk7.dim("No config values set."));
+    return;
+  }
+  for (const [key, value] of entries) {
+    console.log(`${key} = ${value}`);
+  }
+}
+
+// src/index.ts
+var program = new Command();
+program.name("codesail").description("CLI for CodeSail \u2014 control Claude Code sessions from your terminal").version("0.1.0");
+program.command("login").description("Create new account or show QR for mobile pairing").option("-s, --server <url>", "Server URL").action(loginCommand);
+var auth = program.command("auth").description("Authentication commands");
+auth.command("login").description("Display QR code for mobile app to scan & pair").option("-s, --server <url>", "Server URL").action(async (opts) => {
+  await showPairingQR(opts.server);
+});
+var daemon = program.command("daemon").description("Background daemon management");
+daemon.command("start").description("Start the background daemon").action(daemonStartCommand);
+daemon.command("stop").description("Stop the background daemon").action(daemonStopCommand);
+daemon.command("status").description("Show daemon status").action(daemonStatusCommand);
+program.command("sessions").description("List active sessions").action(sessionsCommand);
+program.command("send <session> <message>").description("Send a message to a session").action(sendCommand);
+program.command("approve <session>").description("Approve pending permission request").option("-d, --decision <decision>", "Decision type (approved, approved_for_session)", "approved").action(approveCommand);
+program.command("deny <session>").description("Deny pending permission request").action(denyCommand);
+var backup = program.command("backup").description("Backup key management");
+backup.command("show").description("Display your backup key").action(backupShowCommand);
+backup.command("restore").description("Restore account from backup key").option("-s, --server <url>", "Server URL").action(backupRestoreCommand);
+var config = program.command("config").description("Configuration management");
+config.command("set <key> <value>").description("Set a config value").action(configSetCommand);
+config.command("get <key>").description("Get a config value").action(configGetCommand);
+config.command("list").description("List all config values").action(configListCommand);
+program.parse();
+//# sourceMappingURL=index.js.map