palmier 0.7.6 → 0.7.8

package/dist/nats-client.js

@@ -1,11 +1,14 @@
-import { connect } from "nats";
+import { connect, jwtAuthenticator } from "nats";
 /**
- * Connect to NATS using the host config's TCP URL and token auth.
+ * Connect to NATS using the host config's JWT credentials.
  */
 export async function connectNats(config) {
+    if (!config.natsJwt || !config.natsNkeySeed) {
+        throw new Error("NATS JWT credentials not configured. Re-run palmier init.");
+    }
     const nc = await connect({
         servers: config.natsUrl,
-        token: config.natsToken,
+        authenticator: jwtAuthenticator(config.natsJwt, new TextEncoder().encode(config.natsNkeySeed)),
     });
     // Do not log anything as that will pollute stdout for mcp server.
     return nc;

package/dist/pending-requests.d.ts

@@ -1,27 +1,49 @@
 import type { RequiredPermission } from "./types.js";
+export interface PendingRequestMeta {
+    /** Doubles as task_id for permission-type entries (the key the task uses). */
+    session_id?: string;
+    /** Human-readable label for whoever opened the prompt — agent name for
+     *  confirm/input, task name for permission. */
+    session_name?: string;
+    description?: string;
+    input_questions?: string[];
+}
 export interface PendingRequest {
     type: "confirmation" | "permission" | "input";
     resolve: (value: string[]) => void;
     /** Permission list (for 'permission') or input descriptions (for 'input'). */
     params?: RequiredPermission[] | string[];
+    /** Display context for PWAs that connect while this request is already open. */
+    meta?: PendingRequestMeta;
 }
 /**
- * Register a pending request for a task. Returns a Promise that resolves
- * when `resolvePending` is called with the user's response.
- * Only one pending request per task at a time.
+ * Register a pending request keyed by either a sessionId (confirmation / input)
+ * or a taskId (permission). The `meta` is surfaced to PWAs that connect after
+ * the request was opened, so their modals can render without replaying events.
+ * Only one pending request per key at a time.
  */
-export declare function registerPending(taskId: string, type: PendingRequest["type"], params?: PendingRequest["params"]): Promise<string[]>;
+export declare function registerPending(key: string, type: PendingRequest["type"], params?: PendingRequest["params"], meta?: PendingRequestMeta): Promise<string[]>;
 /**
  * Resolve a pending request with the user's response.
  * Returns true if a pending request was found and resolved.
  */
-export declare function resolvePending(taskId: string, value: string[]): boolean;
+export declare function resolvePending(key: string, value: string[]): boolean;
 /**
- * Get the current pending request for a task (if any).
+ * Get the current pending request for a key (if any).
  */
-export declare function getPending(taskId: string): PendingRequest | undefined;
+export declare function getPending(key: string): PendingRequest | undefined;
 /**
  * Remove a pending request without resolving it.
  */
-export declare function removePending(taskId: string): void;
+export declare function removePending(key: string): void;
+/**
+ * List all currently-pending requests, stripped of the unserializable `resolve`
+ * callback. Used by `host.info` so the PWA can seed its modal state on connect.
+ */
+export declare function listPending(): Array<{
+    key: string;
+    type: PendingRequest["type"];
+    params?: PendingRequest["params"];
+    meta?: PendingRequestMeta;
+}>;
 //# sourceMappingURL=pending-requests.d.ts.map

package/dist/pending-requests.js

@@ -1,39 +1,52 @@
 const pending = new Map();
 /**
- * Register a pending request for a task. Returns a Promise that resolves
- * when `resolvePending` is called with the user's response.
- * Only one pending request per task at a time.
+ * Register a pending request keyed by either a sessionId (confirmation / input)
+ * or a taskId (permission). The `meta` is surfaced to PWAs that connect after
+ * the request was opened, so their modals can render without replaying events.
+ * Only one pending request per key at a time.
  */
-export function registerPending(taskId, type, params) {
-    if (pending.has(taskId)) {
-        return Promise.reject(new Error(`Task ${taskId} already has a pending request`));
+export function registerPending(key, type, params, meta) {
+    if (pending.has(key)) {
+        return Promise.reject(new Error(`Key ${key} already has a pending request`));
     }
     return new Promise((resolve) => {
-        pending.set(taskId, { type, resolve, params });
+        pending.set(key, { type, resolve, params, meta });
     });
 }
 /**
  * Resolve a pending request with the user's response.
  * Returns true if a pending request was found and resolved.
  */
-export function resolvePending(taskId, value) {
-    const entry = pending.get(taskId);
+export function resolvePending(key, value) {
+    const entry = pending.get(key);
     if (!entry)
         return false;
-    pending.delete(taskId);
+    pending.delete(key);
     entry.resolve(value);
     return true;
 }
 /**
- * Get the current pending request for a task (if any).
+ * Get the current pending request for a key (if any).
  */
-export function getPending(taskId) {
-    return pending.get(taskId);
+export function getPending(key) {
+    return pending.get(key);
 }
 /**
  * Remove a pending request without resolving it.
  */
-export function removePending(taskId) {
-    pending.delete(taskId);
+export function removePending(key) {
+    pending.delete(key);
+}
+/**
+ * List all currently-pending requests, stripped of the unserializable `resolve`
+ * callback. Used by `host.info` so the PWA can seed its modal state on connect.
+ */
+export function listPending() {
+    return [...pending.entries()].map(([key, entry]) => ({
+        key,
+        type: entry.type,
+        params: entry.params,
+        meta: entry.meta,
+    }));
 }
 //# sourceMappingURL=pending-requests.js.map