@hasna/recordings 0.1.33 → 0.1.35

package/dist/cli/index.js

@@ -2955,7 +2955,7 @@ var require_dist = __commonJS((exports) => {
   function parse(stream, callback) {
     const parser = new parser_1.Parser;
     stream.on("data", (buffer) => parser.parse(buffer, callback));
-    return new Promise((resolve) => stream.on("end", () => resolve()));
+    return new Promise((resolve2) => stream.on("end", () => resolve2()));
   }
   exports.parse = parse;
 });
@@ -3634,12 +3634,12 @@ var require_client = __commonJS((exports, module) => {
         this._connect(callback);
         return;
       }
-      return new this._Promise((resolve, reject) => {
+      return new this._Promise((resolve2, reject) => {
         this._connect((error) => {
           if (error) {
             reject(error);
           } else {
-            resolve(this);
+            resolve2(this);
           }
         });
       });
@@ -3971,8 +3971,8 @@ var require_client = __commonJS((exports, module) => {
         readTimeout = config.query_timeout || this.connectionParameters.query_timeout;
         query = new Query(config, values, callback);
         if (!query.callback) {
-          result = new this._Promise((resolve, reject) => {
-            query.callback = (err, res) => err ? reject(err) : resolve(res);
+          result = new this._Promise((resolve2, reject) => {
+            query.callback = (err, res) => err ? reject(err) : resolve2(res);
           }).catch((err) => {
             Error.captureStackTrace(err);
             throw err;
@@ -4047,8 +4047,8 @@ var require_client = __commonJS((exports, module) => {
       if (cb) {
         this.connection.once("end", cb);
       } else {
-        return new this._Promise((resolve) => {
-          this.connection.once("end", resolve);
+        return new this._Promise((resolve2) => {
+          this.connection.once("end", resolve2);
         });
       }
     }
@@ -4095,8 +4095,8 @@ var require_pg_pool = __commonJS((exports, module) => {
     const cb = function(err, client) {
       err ? rej(err) : res(client);
     };
-    const result = new Promise2(function(resolve, reject) {
-      res = resolve;
+    const result = new Promise2(function(resolve2, reject) {
+      res = resolve2;
       rej = reject;
     }).catch((err) => {
       Error.captureStackTrace(err);
@@ -4157,7 +4157,7 @@ var require_pg_pool = __commonJS((exports, module) => {
       if (typeof Promise2.try === "function") {
         return Promise2.try(f);
       }
-      return new Promise2((resolve) => resolve(f()));
+      return new Promise2((resolve2) => resolve2(f()));
     }
     _isFull() {
       return this._clients.length >= this.options.max;
@@ -4533,8 +4533,8 @@ var require_query2 = __commonJS((exports, module) => {
   NativeQuery.prototype._getPromise = function() {
     if (this._promise)
       return this._promise;
-    this._promise = new Promise(function(resolve, reject) {
-      this._once("end", resolve);
+    this._promise = new Promise(function(resolve2, reject) {
+      this._once("end", resolve2);
       this._once("error", reject);
     }.bind(this));
     return this._promise;
@@ -4708,12 +4708,12 @@ var require_client2 = __commonJS((exports, module) => {
       this._connect(callback);
       return;
     }
-    return new this._Promise((resolve, reject) => {
+    return new this._Promise((resolve2, reject) => {
       this._connect((error) => {
         if (error) {
           reject(error);
         } else {
-          resolve(this);
+          resolve2(this);
         }
       });
     });
@@ -4737,8 +4737,8 @@ var require_client2 = __commonJS((exports, module) => {
       query = new NativeQuery(config, values, callback);
       if (!query.callback) {
         let resolveOut, rejectOut;
-        result = new this._Promise((resolve, reject) => {
-          resolveOut = resolve;
+        result = new this._Promise((resolve2, reject) => {
+          resolveOut = resolve2;
           rejectOut = reject;
         }).catch((err) => {
           Error.captureStackTrace(err);
@@ -4796,8 +4796,8 @@ var require_client2 = __commonJS((exports, module) => {
     }
     let result;
     if (!cb) {
-      result = new this._Promise(function(resolve, reject) {
-        cb = (err) => err ? reject(err) : resolve();
+      result = new this._Promise(function(resolve2, reject) {
+        cb = (err) => err ? reject(err) : resolve2();
       });
     }
     this.native.end(function() {
@@ -5098,7 +5098,7 @@ var init_pg_migrate = __esm(() => {
 var require_package = __commonJS((exports, module) => {
   module.exports = {
     name: "@hasna/recordings",
-    version: "0.1.33",
+    version: "0.1.35",
     type: "module",
     description: "Speech-to-text recording tool with MCP and CLI \u2014 records, transcribes, and optionally enhances text using AI",
     repository: {
@@ -5148,7 +5148,7 @@ var require_package = __commonJS((exports, module) => {
       "LICENSE"
     ],
     dependencies: {
-      "@hasna/events": "^0.1.3",
+      "@hasna/events": "^0.1.11",
       "@modelcontextprotocol/sdk": "^1.12.1",
       chalk: "^5.4.1",
       commander: "^13.1.0",
@@ -5190,29 +5190,83 @@ function getPathValue(input, path) {
     return;
   }, input);
 }
-function wildcardToRegExp(pattern) {
-  const escaped = pattern.replace(/[|\\{}()[\]^$+?.]/g, "\\$&").replace(/\*/g, ".*");
-  return new RegExp(`^${escaped}$`);
+function getFieldValues(input, path) {
+  const values = [];
+  const push = (value) => {
+    if (!values.some((item) => Object.is(item, value)))
+      values.push(value);
+  };
+  if (path.includes(".") && path in input)
+    push(input[path]);
+  const nestedValue = getPathValue(input, path);
+  if (nestedValue !== undefined || !path.includes("."))
+    push(nestedValue);
+  return values;
 }
-function matchString(value, matcher) {
+function wildcardToRegExp(pattern, options = {}) {
+  let body = "";
+  for (let index = 0;index < pattern.length; index += 1) {
+    const char = pattern[index];
+    if (char === "*") {
+      if (pattern[index + 1] === "*") {
+        body += ".*";
+        index += 1;
+      } else {
+        body += options.segmentSafe ? "[^/]*" : ".*";
+      }
+    } else {
+      body += char.replace(/[|\\{}()[\]^$+?.]/g, "\\$&");
+    }
+  }
+  return new RegExp(`^${body}$`);
+}
+function matchString(value, matcher, options = {}) {
   if (matcher === undefined)
     return true;
   if (value === undefined)
     return false;
   const matchers = Array.isArray(matcher) ? matcher : [matcher];
-  return matchers.some((item) => wildcardToRegExp(item).test(value));
+  return matchers.some((item) => wildcardToRegExp(item, options).test(value));
 }
 function matchRecord(input, matcher) {
   if (!matcher)
     return true;
   return Object.entries(matcher).every(([path, expected]) => {
-    const actual = getPathValue(input, path);
-    if (typeof expected === "string" || Array.isArray(expected)) {
-      return matchString(actual === undefined ? undefined : String(actual), expected);
-    }
-    return actual === expected;
+    const actualValues = getFieldValues(input, path);
+    return matchField(actualValues, expected, path);
   });
 }
+function matchField(actualValues, expected, path) {
+  if (isNegativeMatcher(expected)) {
+    return !actualValues.some((actual) => matchPositiveField(actual, expected.not, path));
+  }
+  return actualValues.some((actual) => matchPositiveField(actual, expected, path));
+}
+function matchPositiveField(actual, expected, path) {
+  if (typeof expected === "string" || Array.isArray(expected)) {
+    return stringCandidates(actual).some((candidate) => matchString(candidate, expected, {
+      segmentSafe: path.endsWith("_path") || path.endsWith(".path")
+    }));
+  }
+  if (Array.isArray(actual)) {
+    return actual.some((item) => item === expected);
+  }
+  return actual === expected;
+}
+function stringCandidates(actual) {
+  if (actual === undefined)
+    return [];
+  if (Array.isArray(actual)) {
+    return actual.flatMap((item) => isPrimitiveFieldValue(item) ? [String(item)] : []);
+  }
+  return [String(actual)];
+}
+function isPrimitiveFieldValue(value) {
+  return value === null || typeof value === "string" || typeof value === "number" || typeof value === "boolean";
+}
+function isNegativeMatcher(value) {
+  return Boolean(value && typeof value === "object" && !Array.isArray(value) && "not" in value);
+}
 function eventMatchesFilter(event, filter) {
   return matchString(event.source, filter.source) && matchString(event.type, filter.type) && matchString(event.subject, filter.subject) && matchString(event.severity, filter.severity) && matchRecord(event.data, filter.data) && matchRecord(event.metadata, filter.metadata);
 }
@@ -5228,6 +5282,13 @@ var HASNA_EVENTS_HOME_ENV = "HASNA_EVENTS_HOME";
 function getEventsDataDir(override) {
   return override || process.env[HASNA_EVENTS_DIR_ENV] || process.env[HASNA_EVENTS_HOME_ENV] || join(homedir(), ".hasna", "events");
 }
+function getActiveEventsDirEnv() {
+  if (process.env[HASNA_EVENTS_DIR_ENV])
+    return HASNA_EVENTS_DIR_ENV;
+  if (process.env[HASNA_EVENTS_HOME_ENV])
+    return HASNA_EVENTS_HOME_ENV;
+  return null;
+}
 
 class JsonEventsStore {
   dataDir;
@@ -5340,6 +5401,52 @@ class JsonEventsStore {
     });
   }
 }
+async function getEventsStatus(dataDir) {
+  const store = new JsonEventsStore(dataDir);
+  await store.init();
+  const [channels, events, deliveries] = await Promise.all([
+    store.listChannels(),
+    store.listEvents(),
+    store.listDeliveries()
+  ]);
+  const transports = channels.reduce((counts, channel) => {
+    counts[channel.transport] = (counts[channel.transport] ?? 0) + 1;
+    return counts;
+  }, {});
+  return {
+    service: "events",
+    schemaVersion: "1.0",
+    dataDir: store.dataDir,
+    env: {
+      primary: HASNA_EVENTS_DIR_ENV,
+      fallback: HASNA_EVENTS_HOME_ENV,
+      active: getActiveEventsDirEnv()
+    },
+    files: {
+      channels: statusFile(store.dataDir, "channels.json", channels.length),
+      events: statusFile(store.dataDir, "events.json", events.length),
+      deliveries: statusFile(store.dataDir, "deliveries.json", deliveries.length)
+    },
+    counts: {
+      channels: channels.length,
+      enabledChannels: channels.filter((channel) => channel.enabled).length,
+      disabledChannels: channels.filter((channel) => !channel.enabled).length,
+      events: events.length,
+      deliveries: deliveries.length
+    },
+    transports,
+    safety: {
+      includesEventPayloads: false,
+      includesWebhookSecrets: false,
+      listOutputsRedactSecrets: true,
+      statusOutputIsMetadataOnly: true
+    }
+  };
+}
+function statusFile(dataDir, fileName, records) {
+  const path = join(dataDir, fileName);
+  return { path, exists: existsSync(path), records };
+}
 var DEFAULT_SIGNATURE_TOLERANCE_MS = 5 * 60 * 1000;
 function buildSignatureBase(timestamp, body) {
   return `${timestamp}.${body}`;
@@ -5565,7 +5672,7 @@ class EventsClient {
     }
     return deliveries;
   }
-  async testChannel(id, input = {}) {
+  async matchChannel(id, input = {}) {
     const channel = await this.store.getChannel(id);
     if (!channel)
       throw new Error(`Channel not found: ${id}`);
@@ -5582,6 +5689,34 @@ class EventsClient {
       time: input.time,
       id: input.id
     });
+    const matched = channelMatchesEvent(channel, event);
+    return {
+      channelId: channel.id,
+      matched,
+      event,
+      filters: channel.filters,
+      reason: matched ? undefined : channel.enabled ? "event did not match channel filters" : "channel is disabled"
+    };
+  }
+  async testChannel(id, input = {}, options = {}) {
+    const channel = await this.store.getChannel(id);
+    if (!channel)
+      throw new Error(`Channel not found: ${id}`);
+    const match = await this.matchChannel(id, input);
+    const event = match.event;
+    if (options.honorFilters && !match.matched) {
+      const timestamp = new Date().toISOString();
+      const result2 = createDeliveryResult(event, channel, [{
+        attempt: 1,
+        status: "skipped",
+        startedAt: timestamp,
+        completedAt: timestamp,
+        error: match.reason
+      }]);
+      result2.metadata = { reason: "filter_mismatch" };
+      await this.store.appendDelivery(result2);
+      return result2;
+    }
     const eventForChannel = await this.applyRedaction(event, channel);
     const result = await this.deliverWithRetry(eventForChannel, channel);
     await this.store.appendDelivery(result);
@@ -5692,6 +5827,76 @@ function normalizeRetryPolicy(policy) {
     multiplier: Math.max(1, policy?.multiplier ?? 2)
   };
 }
+function parseFieldMatchers(values, label, typed = false) {
+  if (!values?.length)
+    return;
+  const result = {};
+  for (const value of values) {
+    const parsed = parseMatcherExpression(value, label);
+    const path = parsed.path;
+    if (path in result)
+      throw new Error(`Duplicate ${label} filter path: ${path}`);
+    const matcherValue = typed ? parseTypedMatcherValue(parsed.rawValue, label) : parsed.rawValue;
+    result[path] = parsed.negated ? { not: matcherValue } : matcherValue;
+  }
+  return result;
+}
+function parseFilterOptions(options) {
+  const filter2 = {};
+  if (options.source)
+    filter2.source = options.source;
+  if (options.type)
+    filter2.type = options.type;
+  if (options.subject)
+    filter2.subject = options.subject;
+  if (options.severity)
+    filter2.severity = options.severity;
+  const data = mergeMatchers(parseFieldMatchers(options.data, "data"), parseFieldMatchers(options.dataJson, "data-json", true));
+  const metadata = mergeMatchers(parseFieldMatchers(options.metadata, "metadata"), parseFieldMatchers(options.metadataJson, "metadata-json", true));
+  if (Object.keys(data).length > 0)
+    filter2.data = data;
+  if (Object.keys(metadata).length > 0)
+    filter2.metadata = metadata;
+  return Object.keys(filter2).length > 0 ? [filter2] : undefined;
+}
+function mergeMatchers(...records) {
+  const result = {};
+  for (const record of records) {
+    if (!record)
+      continue;
+    for (const [path, value] of Object.entries(record)) {
+      if (path in result)
+        throw new Error(`Duplicate filter path: ${path}`);
+      result[path] = value;
+    }
+  }
+  return result;
+}
+function parseTypedMatcherValue(value, label) {
+  const parsed = JSON.parse(value);
+  if (parsed === null || typeof parsed === "string" || typeof parsed === "number" || typeof parsed === "boolean" || Array.isArray(parsed) && parsed.every((item) => typeof item === "string")) {
+    return parsed;
+  }
+  throw new Error(`${label} filter JSON values must be string, string[], number, boolean, or null`);
+}
+function parseMatcherExpression(value, label) {
+  const negativeSeparator = value.indexOf("!=");
+  if (negativeSeparator > 0) {
+    return {
+      path: value.slice(0, negativeSeparator),
+      rawValue: value.slice(negativeSeparator + 2),
+      negated: true
+    };
+  }
+  const separator = value.indexOf("=");
+  if (separator <= 0)
+    throw new Error(`Invalid ${label} filter, expected path=value or path!=value: ${value}`);
+  return {
+    path: value.slice(0, separator),
+    rawValue: value.slice(separator + 1),
+    negated: false
+  };
+}
 function parseJsonObject(value, fallback) {
   if (!value)
     return fallback;
@@ -5713,18 +5918,6 @@ function parseHeaders(values) {
   }
   return headers;
 }
-function parseFilter(options) {
-  const filter2 = {};
-  if (options.source)
-    filter2.source = options.source;
-  if (options.type)
-    filter2.type = options.type;
-  if (options.subject)
-    filter2.subject = options.subject;
-  if (options.severity)
-    filter2.severity = options.severity;
-  return Object.keys(filter2).length > 0 ? [filter2] : undefined;
-}
 function createClient(options) {
   if (options.createClient)
     return options.createClient();
@@ -5736,16 +5929,22 @@ function print(value, json, text) {
   else
     console.log(text);
 }
+function hasJsonOption(options) {
+  return Boolean(options?.json || options?.opts?.().json || options?.optsWithGlobals?.().json || options?.parent?.opts?.().json || options?.parent?.optsWithGlobals?.().json);
+}
+function wantsJson(actionOptions, command) {
+  return hasJsonOption(actionOptions) || hasJsonOption(command);
+}
 function registerWebhookCommands(program, options) {
   const webhooks = program.command(options.webhooksCommandName ?? "webhooks").description("Manage Hasna event webhook subscriptions");
-  webhooks.command("add").description("Add or replace a webhook or command subscription").argument("<target>", "Webhook URL or command binary").requiredOption("--id <id>", "Subscription/channel identifier").option("--transport <kind>", "Transport kind: webhook or command", "webhook").option("--name <name>", "Display name").option("--type <pattern>", "Event type filter, e.g. todos.task.*").option("--source <pattern>", "Event source filter").option("--subject <pattern>", "Event subject filter").option("--severity <pattern>", "Event severity filter").option("--secret <secret>", "Webhook HMAC secret").option("--header <name=value...>", "Webhook header", collectValues, []).option("--arg <arg...>", "Command argument", collectValues, []).option("--timeout-ms <ms>", "Transport timeout in milliseconds", parseNumber).option("--retry-attempts <n>", "Maximum delivery attempts", parseNumber).option("--retry-backoff-ms <ms>", "Initial retry backoff in milliseconds", parseNumber).option("--redact <path...>", "Event field path to redact before delivery", collectValues, []).option("--disabled", "Create channel disabled", false).option("-j, --json", "Print JSON output", false).action(async (target, actionOptions) => {
+  webhooks.command("add").description("Add or replace a webhook or command subscription").argument("<target>", "Webhook URL or command binary").requiredOption("--id <id>", "Subscription/channel identifier").option("--transport <kind>", "Transport kind: webhook or command", "webhook").option("--name <name>", "Display name").option("--type <pattern>", "Event type filter, e.g. todos.task.*").option("--source <pattern>", "Event source filter").option("--subject <pattern>", "Event subject filter").option("--severity <pattern>", "Event severity filter").option("--data <path=value...>", "Event data field filter; string values, path!=value negatives, array-member matching, dot paths, * segment wildcard, ** recursive wildcard", collectValues, []).option("--metadata <path=value...>", "Event metadata field filter; string values, path!=value negatives, array-member matching, dot paths, * segment wildcard, ** recursive wildcard", collectValues, []).option("--data-json <path=json...>", "Event data field filter with typed JSON value; path!=json negatives supported", collectValues, []).option("--metadata-json <path=json...>", "Event metadata field filter with typed JSON value; path!=json negatives supported", collectValues, []).option("--secret <secret>", "Webhook HMAC secret").option("--header <name=value...>", "Webhook header", collectValues, []).option("--arg <arg...>", "Command argument", collectValues, []).option("--timeout-ms <ms>", "Transport timeout in milliseconds", parseNumber).option("--retry-attempts <n>", "Maximum delivery attempts", parseNumber).option("--retry-backoff-ms <ms>", "Initial retry backoff in milliseconds", parseNumber).option("--redact <path...>", "Event field path to redact before delivery", collectValues, []).option("--disabled", "Create channel disabled", false).option("-j, --json", "Print JSON output", false).action(async (target, actionOptions, command) => {
     const timestamp = new Date().toISOString();
     const channel = {
       id: actionOptions.id,
       name: actionOptions.name,
       enabled: !actionOptions.disabled,
       transport: actionOptions.transport,
-      filters: parseFilter(actionOptions),
+      filters: parseFilterOptions(actionOptions),
       retry: actionOptions.retryAttempts || actionOptions.retryBackoffMs ? { maxAttempts: actionOptions.retryAttempts, backoffMs: actionOptions.retryBackoffMs } : undefined,
       redact: actionOptions.redact?.length ? { paths: actionOptions.redact } : undefined,
       createdAt: timestamp,
@@ -5759,11 +5958,11 @@ function registerWebhookCommands(program, options) {
       throw new Error(`Transport ${actionOptions.transport} is reserved for future use and cannot be added yet`);
     }
     const saved = await createClient(options).addChannel(channel);
-    print(sanitizeChannelForOutput(saved), Boolean(actionOptions.json), `Added ${saved.transport} channel ${saved.id}`);
+    print(sanitizeChannelForOutput(saved), wantsJson(actionOptions, command), `Added ${saved.transport} channel ${saved.id}`);
   });
-  webhooks.command("list").description("List configured subscriptions").option("-j, --json", "Print JSON output", false).action(async (actionOptions) => {
+  webhooks.command("list").description("List configured subscriptions").option("-j, --json", "Print JSON output", false).action(async (actionOptions, command) => {
     const channels = await createClient(options).listChannels();
-    if (actionOptions.json) {
+    if (wantsJson(actionOptions, command)) {
       console.log(JSON.stringify(sanitizeChannelsForOutput(channels), null, 2));
       return;
     }
@@ -5775,25 +5974,41 @@ function registerWebhookCommands(program, options) {
       console.log(`${channel.id}	${channel.enabled ? "enabled" : "disabled"}	${channel.transport}	${channel.webhook?.url ?? channel.command?.command ?? channel.transport}`);
     }
   });
-  webhooks.command("remove").description("Remove a subscription").argument("<id>", "Subscription/channel identifier").option("-j, --json", "Print JSON output", false).action(async (id, actionOptions) => {
+  webhooks.command("status").description("Show events webhook storage status").option("-j, --json", "Print JSON output", false).action(async (actionOptions, command) => {
+    const status = await getEventsStatus(options.dataDir);
+    print(status, wantsJson(actionOptions, command), `events dataDir: ${status.dataDir}`);
+  });
+  webhooks.command("remove").description("Remove a subscription").argument("<id>", "Subscription/channel identifier").option("-j, --json", "Print JSON output", false).action(async (id, actionOptions, command) => {
     const removed = await createClient(options).removeChannel(id);
-    print({ removed }, Boolean(actionOptions.json), removed ? `Removed ${id}` : `Channel not found: ${id}`);
+    print({ removed }, wantsJson(actionOptions, command), removed ? `Removed ${id}` : `Channel not found: ${id}`);
   });
-  webhooks.command("test").description("Send a test event to one subscription").argument("<id>", "Subscription/channel identifier").option("--type <type>", "Event type", "events.test").option("--subject <subject>", "Event subject").option("--message <message>", "Event message", "Hasna events test delivery").option("--data <json>", "Event data JSON object").option("-j, --json", "Print JSON output", false).action(async (id, actionOptions) => {
+  webhooks.command("test").description("Send a test event to one subscription").argument("<id>", "Subscription/channel identifier").option("--source <source>", "Event source override").option("--type <type>", "Event type", "events.test").option("--subject <subject>", "Event subject").option("--message <message>", "Event message", "Hasna events test delivery").option("--data <json>", "Event data JSON object").option("--metadata <json>", "Event metadata JSON object").option("--honor-filters", "Skip delivery when the sample event does not match channel filters", false).option("-j, --json", "Print JSON output", false).action(async (id, actionOptions, command) => {
     const result = await createClient(options).testChannel(id, {
-      source: options.source,
+      source: actionOptions.source ?? options.source,
       type: actionOptions.type,
       subject: actionOptions.subject ?? id,
       message: actionOptions.message,
-      data: parseJsonObject(actionOptions.data, { test: true })
+      data: parseJsonObject(actionOptions.data, { test: true }),
+      metadata: parseJsonObject(actionOptions.metadata, {})
+    }, { honorFilters: actionOptions.honorFilters });
+    print(result, wantsJson(actionOptions, command), `${result.status}: ${result.channelId}`);
+  });
+  webhooks.command("match").description("Check whether a sample event matches one subscription without delivering").argument("<id>", "Subscription/channel identifier").option("--source <source>", "Event source override").option("--type <type>", "Event type", "events.test").option("--subject <subject>", "Event subject").option("--message <message>", "Event message", "Hasna events match preview").option("--data <json>", "Event data JSON object").option("--metadata <json>", "Event metadata JSON object").option("-j, --json", "Print JSON output", false).action(async (id, actionOptions, command) => {
+    const result = await createClient(options).matchChannel(id, {
+      source: actionOptions.source ?? options.source,
+      type: actionOptions.type,
+      subject: actionOptions.subject ?? id,
+      message: actionOptions.message,
+      data: parseJsonObject(actionOptions.data, { test: true }),
+      metadata: parseJsonObject(actionOptions.metadata, {})
     });
-    print(result, Boolean(actionOptions.json), `${result.status}: ${result.channelId}`);
+    print(result, wantsJson(actionOptions, command), `${result.matched ? "matched" : "skipped"}: ${result.channelId}`);
   });
   return webhooks;
 }
 function registerEventCommands(program, options) {
   const events = program.command(options.eventsCommandName ?? "events").description("Emit, list, and replay Hasna events");
-  events.command("emit").description("Emit an event from this app").argument("<type>", "Event type").option("--source <source>", "Event source override").option("--subject <subject>", "Event subject").option("--severity <severity>", "Event severity", "info").option("--message <message>", "Event message").option("--dedupe-key <key>", "Dedupe key").option("--data <json>", "Event data JSON object").option("--metadata <json>", "Event metadata JSON object").option("--no-deliver", "Record without delivering").option("--no-dedupe", "Allow duplicate id/dedupeKey events").option("-j, --json", "Print JSON output", false).action(async (type, actionOptions) => {
+  events.command("emit").description("Emit an event from this app").argument("<type>", "Event type").option("--source <source>", "Event source override").option("--subject <subject>", "Event subject").option("--severity <severity>", "Event severity", "info").option("--message <message>", "Event message").option("--dedupe-key <key>", "Dedupe key").option("--data <json>", "Event data JSON object").option("--metadata <json>", "Event metadata JSON object").option("--no-deliver", "Record without delivering").option("--no-dedupe", "Allow duplicate id/dedupeKey events").option("-j, --json", "Print JSON output", false).action(async (type, actionOptions, command) => {
     const result = await createClient(options).emit({
       source: actionOptions.source ?? options.source,
       type,
@@ -5804,9 +6019,9 @@ function registerEventCommands(program, options) {
       data: parseJsonObject(actionOptions.data, {}),
       metadata: parseJsonObject(actionOptions.metadata, {})
     }, { deliver: actionOptions.deliver, dedupe: actionOptions.dedupe });
-    print(result, Boolean(actionOptions.json), `${result.deduped ? "Deduped" : "Emitted"} ${result.event.id} to ${result.deliveries.length} channel(s)`);
+    print(result, wantsJson(actionOptions, command), `${result.deduped ? "Deduped" : "Emitted"} ${result.event.id} to ${result.deliveries.length} channel(s)`);
   });
-  events.command("list").description("List recorded events").option("--source <source>", "Filter by source").option("--type <type>", "Filter by type").option("--limit <n>", "Limit results", parseNumber).option("-j, --json", "Print JSON output", false).action(async (actionOptions) => {
+  events.command("list").description("List recorded events").option("--source <source>", "Filter by source").option("--type <type>", "Filter by type").option("--limit <n>", "Limit results", parseNumber).option("-j, --json", "Print JSON output", false).action(async (actionOptions, command) => {
     let rows = await createClient(options).listEvents();
     if (actionOptions.source)
       rows = rows.filter((event) => event.source === actionOptions.source);
@@ -5814,7 +6029,7 @@ function registerEventCommands(program, options) {
       rows = rows.filter((event) => event.type === actionOptions.type);
     if (actionOptions.limit)
       rows = rows.slice(-actionOptions.limit);
-    if (actionOptions.json) {
+    if (wantsJson(actionOptions, command)) {
       console.log(JSON.stringify(rows, null, 2));
       return;
     }
@@ -5825,14 +6040,14 @@ function registerEventCommands(program, options) {
     for (const event of rows)
       console.log(`${event.time}	${event.id}	${event.source}	${event.type}	${event.severity}`);
   });
-  events.command("replay").description("Replay recorded events").option("--id <id>", "Replay one event id").option("--source <source>", "Filter by source").option("--type <type>", "Filter by type").option("--dry-run", "Preview without delivery", false).option("-j, --json", "Print JSON output", false).action(async (actionOptions) => {
+  events.command("replay").description("Replay recorded events").option("--id <id>", "Replay one event id").option("--source <source>", "Filter by source").option("--type <type>", "Filter by type").option("--dry-run", "Preview without delivery", false).option("-j, --json", "Print JSON output", false).action(async (actionOptions, command) => {
     const result = await createClient(options).replay({
       eventId: actionOptions.id,
       source: actionOptions.source,
       type: actionOptions.type,
       dryRun: actionOptions.dryRun
     });
-    print(result, Boolean(actionOptions.json), `Replayed ${result.events.length} event(s), ${result.deliveries.length} delivery result(s)`);
+    print(result, wantsJson(actionOptions, command), `Replayed ${result.events.length} event(s), ${result.deliveries.length} delivery result(s)`);
   });
   return events;
 }
@@ -5855,12 +6070,12 @@ function collectValues(value, previous) {
 import chalk2 from "chalk";
 import { spawnSync } from "child_process";
 import { existsSync as existsSync5, readFileSync as readFileSync3 } from "fs";
-import { dirname as dirname2, join as pathJoin } from "path";
+import { dirname as dirname3, join as pathJoin } from "path";
 import { fileURLToPath } from "url";
 
 // src/lib/config.ts
-import { existsSync as existsSync2, readFileSync, mkdirSync, cpSync, readdirSync, statSync } from "fs";
-import { join as join2 } from "path";
+import { copyFileSync, existsSync as existsSync2, readFileSync, mkdirSync, readdirSync, statSync } from "fs";
+import { dirname, join as join2, resolve } from "path";
 import { homedir as homedir2 } from "os";
 var DEFAULT_CONFIG = {
   openai_api_key: "",
@@ -5954,44 +6169,53 @@ function expandEnvBackedConfig(config) {
   return expanded;
 }
 function findConfigFile() {
-  let dir = process.cwd();
-  const root = "/";
-  while (dir !== root) {
-    const candidate = join2(dir, ".recordings", "config.json");
-    if (existsSync2(candidate))
-      return candidate;
-    const parent = join2(dir, "..");
-    if (parent === dir)
-      break;
-    dir = parent;
-  }
-  return null;
+  return findProjectRecordingsPath("config.json");
 }
 function getDataDir() {
-  let dir = process.cwd();
-  const root = "/";
-  while (dir !== root) {
-    const candidate = join2(dir, ".recordings");
-    if (existsSync2(candidate))
-      return candidate;
-    const parent = join2(dir, "..");
-    if (parent === dir)
-      break;
-    dir = parent;
-  }
-  const home = homedir2();
+  const projectLocalDir = findProjectRecordingsPath();
+  if (projectLocalDir)
+    return projectLocalDir;
+  const home = getHomeDir();
   const newDir = join2(home, ".hasna", "recordings");
   const oldDir = join2(home, ".recordings");
-  if (!existsSync2(newDir) && existsSync2(oldDir)) {
+  if (existsSync2(oldDir)) {
     try {
-      mkdirSync(join2(home, ".hasna"), { recursive: true });
-      cpSync(oldDir, newDir, { recursive: true });
+      mergeDirectoryContents(oldDir, newDir);
     } catch {}
   }
   return newDir;
 }
+function findProjectRecordingsPath(entry) {
+  const home = resolve(getHomeDir());
+  let dir = resolve(process.cwd());
+  while (true) {
+    if (dir !== home) {
+      const candidate = entry ? join2(dir, ".recordings", entry) : join2(dir, ".recordings");
+      if (existsSync2(candidate))
+        return candidate;
+    }
+    const parent = dirname(dir);
+    if (parent === dir)
+      break;
+    dir = parent;
+  }
+  return null;
+}
+function mergeDirectoryContents(sourceDir, targetDir) {
+  mkdirSync(targetDir, { recursive: true });
+  for (const entry of readdirSync(sourceDir)) {
+    const sourcePath = join2(sourceDir, entry);
+    const targetPath = join2(targetDir, entry);
+    const sourceStats = statSync(sourcePath);
+    if (sourceStats.isDirectory()) {
+      mergeDirectoryContents(sourcePath, targetPath);
+    } else if (!existsSync2(targetPath)) {
+      copyFileSync(sourcePath, targetPath);
+    }
+  }
+}
 function loadSecretKey(keyName) {
-  const secretsPath = join2(homedir2(), ".secrets");
+  const secretsPath = join2(getHomeDir(), ".secrets");
   if (!existsSync2(secretsPath))
     return "";
   for (const candidate of listSecretFiles(secretsPath)) {
@@ -6032,6 +6256,9 @@ function listSecretFiles(path) {
     return [];
   }
 }
+function getHomeDir() {
+  return process.env["HOME"] || process.env["USERPROFILE"] || homedir2();
+}
 function ensureDataDir(config) {
   const { mkdirSync: mkdirSync2 } = __require("fs");
   mkdirSync2(config.audio_dir, { recursive: true });
@@ -6073,7 +6300,7 @@ class SqliteAdapter {
 
 // src/db/database.ts
 import { mkdirSync as mkdirSync2 } from "fs";
-import { dirname } from "path";
+import { dirname as dirname2 } from "path";
 var _db = null;
 var _adapter = null;
 var MIGRATIONS = [
@@ -6159,7 +6386,7 @@ function getDatabase(dbPath) {
   if (_db)
     return _db;
   const path = dbPath || loadConfig().db_path;
-  const dir = dirname(path);
+  const dir = dirname2(path);
   mkdirSync2(dir, { recursive: true });
   _adapter = new SqliteAdapter(path);
   _db = _adapter.raw;
@@ -6762,7 +6989,7 @@ async function processText(rawText, config, systemPrompt) {
 }
 
 // src/version.ts
-var VERSION = "0.1.33";
+var VERSION = "0.1.35";
 
 // src/cli/storage.ts
 import chalk from "chalk";
@@ -7156,13 +7383,13 @@ program.command("record").description("Record from microphone, transcribe, and o
   } else {
     console.log(chalk2.blue("Recording... Press") + chalk2.yellow(" Enter ") + chalk2.blue("to stop."));
     audioPath = startRecording(config);
-    await new Promise((resolve) => {
+    await new Promise((resolve2) => {
       process.stdin.setRawMode?.(true);
       process.stdin.resume();
       process.stdin.once("data", () => {
         process.stdin.setRawMode?.(false);
         process.stdin.pause();
-        resolve();
+        resolve2();
       });
     });
     stopRecording();
@@ -8086,7 +8313,7 @@ function tccAuthValueLabel(value) {
   }
 }
 function findPackageRoot() {
-  let current = dirname2(fileURLToPath(import.meta.url));
+  let current = dirname3(fileURLToPath(import.meta.url));
   while (true) {
     const packagePath = pathJoin(current, "package.json");
     if (existsSync5(packagePath)) {
@@ -8097,7 +8324,7 @@ function findPackageRoot() {
         }
       } catch {}
     }
-    const parent = dirname2(current);
+    const parent = dirname3(current);
     if (parent === current) {
       return process.cwd();
     }