assistme 0.3.3 → 0.3.4

package/dist/index.js

@@ -171,22 +171,36 @@ async function getConversationHistory(conversationId, excludeMessageId, limit =
 }
 
 // src/db/event.ts
+var MAX_EMIT_RETRIES = 2;
+var EMIT_RETRY_DELAY_MS = 500;
+async function emitWithRetry(messageId, eventType, eventData, seq) {
+  for (let attempt = 0; attempt <= MAX_EMIT_RETRIES; attempt++) {
+    try {
+      await callMcpHandler("event.emit", {
+        message_id: messageId,
+        event_type: eventType,
+        event_data: eventData,
+        seq
+      });
+      return;
+    } catch (err) {
+      if (attempt < MAX_EMIT_RETRIES) {
+        await new Promise((r) => setTimeout(r, EMIT_RETRY_DELAY_MS * (attempt + 1)));
+      } else {
+        log.warn(
+          `Failed to emit event after ${MAX_EMIT_RETRIES + 1} attempts: ${err instanceof Error ? err.message : err}`
+        );
+      }
+    }
+  }
+}
 var eventSequence = 0;
 function resetEventSequence() {
   eventSequence = 0;
 }
 async function emitEvent(messageId, eventType, eventData) {
   eventSequence++;
-  try {
-    await callMcpHandler("event.emit", {
-      message_id: messageId,
-      event_type: eventType,
-      event_data: eventData,
-      seq: eventSequence
-    });
-  } catch (err) {
-    log.warn(`Failed to emit event: ${err instanceof Error ? err.message : err}`);
-  }
+  await emitWithRetry(messageId, eventType, eventData, eventSequence);
 }
 
 // src/db/action.ts
@@ -4183,7 +4197,7 @@ function getCredentialStore() {
 
 // src/mcp/agent-tools-server.ts
 function createAgentToolsServer(deps) {
-  const { memoryManager, skillManager, taskId, sessionId } = deps;
+  const { memoryManager, skillManager, taskId, sessionId, onUserWaitStart, onUserWaitEnd } = deps;
   return createSdkMcpServer2({
     name: "assistme-agent",
     version: "1.0.0",
@@ -4688,52 +4702,56 @@ Use \`ask_user\` to request these from the user, or create them yourself (e.g. r
           try {
             await setActionRequest(taskId, actionData);
             log.info(`Ask user ${actionId}: "${args.question.slice(0, 80)}..."`);
-            emitEvent(taskId, "user_action_request", actionData).catch(() => {
-            });
-            emitEvent(taskId, "status_change", {
+            await emitEvent(taskId, "user_action_request", actionData);
+            await emitEvent(taskId, "status_change", {
               status: "waiting_for_user",
               message: args.question
-            }).catch(() => {
             });
+            onUserWaitStart?.();
             const startTime = Date.now();
             const pollInterval = 2e3;
-            while (Date.now() - startTime < timeout) {
-              const response = await pollActionResponse(taskId);
-              if (response && (!response.action_id || response.action_id === actionId)) {
-                const actionKey = response.action_key || "";
-                const text = response.text || "";
-                const label = response.label || actionKey || text;
-                log.info(`User responded: "${label}"`);
-                return {
-                  content: [
-                    {
-                      type: "text",
-                      text: JSON.stringify({
-                        status: "responded",
-                        action_key: actionKey || "custom_input",
-                        label,
-                        text: text || label
-                      })
-                    }
-                  ]
-                };
+            try {
+              while (Date.now() - startTime < timeout) {
+                const response = await pollActionResponse(taskId);
+                if (response && (!response.action_id || response.action_id === actionId)) {
+                  const actionKey = response.action_key || "";
+                  const text = response.text || "";
+                  const label = response.label || actionKey || text;
+                  log.info(`User responded: "${label}"`);
+                  return {
+                    content: [
+                      {
+                        type: "text",
+                        text: JSON.stringify({
+                          status: "responded",
+                          action_key: actionKey || "custom_input",
+                          label,
+                          text: text || label
+                        })
+                      }
+                    ]
+                  };
+                }
+                await new Promise((resolve2) => setTimeout(resolve2, pollInterval));
               }
-              await new Promise((resolve2) => setTimeout(resolve2, pollInterval));
+              log.warn(`Ask user ${actionId} timed out after ${args.timeout_seconds || 300}s`);
+              return {
+                content: [
+                  {
+                    type: "text",
+                    text: JSON.stringify({
+                      status: "timeout",
+                      message: "User did not respond within the timeout period. Continue the task with a reasonable default or skip the step that required user input."
+                    })
+                  }
+                ]
+              };
+            } finally {
+              onUserWaitEnd?.();
             }
-            log.warn(`Ask user ${actionId} timed out after ${args.timeout_seconds || 300}s`);
-            return {
-              content: [
-                {
-                  type: "text",
-                  text: JSON.stringify({
-                    status: "timeout",
-                    message: "User did not respond within the timeout period."
-                  })
-                }
-              ]
-            };
           } catch (err) {
             log.error(`ask_user failed: ${err}`);
+            onUserWaitEnd?.();
             return {
               content: [
                 {
@@ -5167,12 +5185,16 @@ Available capabilities:
    - Bash tool for shell commands
    - Glob and Grep for file search
 
-3. MEMORY:
+3. MEMORY & CREDENTIALS:
    - You can remember things about the user using memory_store
    - Use this when you learn preferences, important facts, or standing instructions
    - Your stored memories persist across conversations
    - PROACTIVELY use memory_store during tasks when you discover user preferences, habits, or important context
    - Before completing a task, consider if anything learned should be remembered for future conversations
+   - CRITICAL \u2014 Credential Storage: When you create, register, or receive any account credentials (username, password, API keys, tokens), you MUST use credential_set to save them locally. NEVER use memory_store for credentials \u2014 memory_store is for preferences and facts, credential_set is for secrets. Examples:
+     * After registering a new email/account \u2192 credential_set with type "login" and data { "username": "...", "password": "...", "email": "..." }
+     * After generating an API key \u2192 credential_set with type "api_key" and data { "api_key": "..." }
+     * Credentials saved via credential_set are encrypted on disk and viewable in the desktop app's Credentials panel
 
 4. SKILL-AWARE EXECUTION (CRITICAL \u2014 follow this for EVERY task):
    Step A \u2014 Search: Before executing ANY task, check if an existing skill matches (use skill_invoke or skill_search).
@@ -5252,6 +5274,42 @@ CRITICAL \u2014 Ask before you guess:
 Workspace path: {workspace_path}`;
 
 // src/agent/processor.ts
+var TaskTimeout = class {
+  constructor(abortController, timeoutMs) {
+    this.abortController = abortController;
+    this.remainingMs = timeoutMs;
+    this.resumedAt = Date.now();
+    this.schedule();
+  }
+  timeoutId = null;
+  remainingMs;
+  resumedAt;
+  schedule() {
+    this.timeoutId = setTimeout(() => {
+      this.abortController.abort();
+    }, this.remainingMs);
+  }
+  /** Pause the timeout (e.g. while waiting for user). */
+  pause() {
+    if (this.timeoutId) {
+      clearTimeout(this.timeoutId);
+      this.timeoutId = null;
+      const elapsed = Date.now() - this.resumedAt;
+      this.remainingMs = Math.max(0, this.remainingMs - elapsed);
+    }
+  }
+  /** Resume the timeout after user interaction completes. */
+  resume() {
+    this.resumedAt = Date.now();
+    this.schedule();
+  }
+  clear() {
+    if (this.timeoutId) {
+      clearTimeout(this.timeoutId);
+      this.timeoutId = null;
+    }
+  }
+};
 var MAX_HISTORY_ENTRIES = 10;
 var MAX_RESPONSE_LENGTH = 1500;
 var TaskProcessor = class {
@@ -5334,12 +5392,16 @@ var TaskProcessor = class {
         }
         systemPrompt += historyPrompt;
       }
+      const abortController = new AbortController();
+      const taskTimeout = new TaskTimeout(abortController, taskTimeoutMs);
       const browserServer = createBrowserMcpServer();
       const agentToolsServer = createAgentToolsServer({
         memoryManager: this.memoryManager,
         skillManager: this.skillManager,
         taskId: task.id,
-        sessionId: this.sessionId || void 0
+        sessionId: this.sessionId || void 0,
+        onUserWaitStart: () => taskTimeout.pause(),
+        onUserWaitEnd: () => taskTimeout.resume()
       });
       const eventHooks = createEventHooks(task.id, toolCallRecords);
       const allowedTools = [
@@ -5386,7 +5448,6 @@ var TaskProcessor = class {
           session_id: ""
         };
       }
-      const abortController = new AbortController();
       const options = {
         model: config.model,
         systemPrompt,
@@ -5404,9 +5465,6 @@ var TaskProcessor = class {
         abortController
       };
       const taskStartTime = Date.now();
-      const timeoutId = setTimeout(() => {
-        abortController.abort();
-      }, taskTimeoutMs);
       try {
         for await (const message of query2({
           prompt: promptMessages(),
@@ -5468,7 +5526,7 @@ var TaskProcessor = class {
           }
         }
       } finally {
-        clearTimeout(timeoutId);
+        taskTimeout.clear();
       }
       const MAX_CONTENT_LENGTH = 5e4;
       const truncatedResponse = finalResponse.length > MAX_CONTENT_LENGTH ? finalResponse.slice(0, MAX_CONTENT_LENGTH) + "\n\n[Response truncated]" : finalResponse;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "assistme",
-  "version": "0.3.3",
+  "version": "0.3.4",
   "description": "AssistMe CLI Agent - AI-powered assistant that controls your real browser",
   "type": "module",
   "main": "dist/index.js",

package/src/agent/processor.ts

@@ -31,6 +31,55 @@ import {
 import { createEventHooks } from "./event-hooks.js";
 import { BASE_SYSTEM_PROMPT } from "./system-prompt.js";
 
+/**
+ * Manages the task wall-clock timeout.
+ * Supports pausing while the agent is waiting for user input (ask_user)
+ * so that idle wait time doesn't count toward the timeout.
+ */
+class TaskTimeout {
+  private timeoutId: ReturnType<typeof setTimeout> | null = null;
+  private remainingMs: number;
+  private resumedAt: number;
+
+  constructor(
+    private abortController: AbortController,
+    timeoutMs: number
+  ) {
+    this.remainingMs = timeoutMs;
+    this.resumedAt = Date.now();
+    this.schedule();
+  }
+
+  private schedule(): void {
+    this.timeoutId = setTimeout(() => {
+      this.abortController.abort();
+    }, this.remainingMs);
+  }
+
+  /** Pause the timeout (e.g. while waiting for user). */
+  pause(): void {
+    if (this.timeoutId) {
+      clearTimeout(this.timeoutId);
+      this.timeoutId = null;
+      const elapsed = Date.now() - this.resumedAt;
+      this.remainingMs = Math.max(0, this.remainingMs - elapsed);
+    }
+  }
+
+  /** Resume the timeout after user interaction completes. */
+  resume(): void {
+    this.resumedAt = Date.now();
+    this.schedule();
+  }
+
+  clear(): void {
+    if (this.timeoutId) {
+      clearTimeout(this.timeoutId);
+      this.timeoutId = null;
+    }
+  }
+}
+
 const MAX_HISTORY_ENTRIES = 10;
 const MAX_RESPONSE_LENGTH = 1500;
 
@@ -143,6 +192,9 @@ export class TaskProcessor {
         systemPrompt += historyPrompt;
       }
 
+      const abortController = new AbortController();
+      const taskTimeout = new TaskTimeout(abortController, taskTimeoutMs);
+
       // Create MCP servers for custom tools
       const browserServer = createBrowserMcpServer();
       const agentToolsServer = createAgentToolsServer({
@@ -150,6 +202,8 @@ export class TaskProcessor {
         skillManager: this.skillManager,
         taskId: task.id,
         sessionId: this.sessionId || undefined,
+        onUserWaitStart: () => taskTimeout.pause(),
+        onUserWaitEnd: () => taskTimeout.resume(),
       });
 
       // Create event hooks for Supabase event emission
@@ -203,7 +257,6 @@ export class TaskProcessor {
         };
       }
 
-      const abortController = new AbortController();
       const options: Options = {
         model: config.model,
         systemPrompt,
@@ -221,11 +274,7 @@ export class TaskProcessor {
         abortController,
       };
 
-      // Wall-clock timeout via abort
       const taskStartTime = Date.now();
-      const timeoutId = setTimeout(() => {
-        abortController.abort();
-      }, taskTimeoutMs);
 
       try {
         for await (const message of query({
@@ -302,7 +351,7 @@ export class TaskProcessor {
           }
         }
       } finally {
-        clearTimeout(timeoutId);
+        taskTimeout.clear();
       }
 
       // Truncate finalResponse to avoid edge function payload limits

package/src/agent/system-prompt.ts

@@ -41,12 +41,16 @@ Available capabilities:
    - Bash tool for shell commands
    - Glob and Grep for file search
 
-3. MEMORY:
+3. MEMORY & CREDENTIALS:
    - You can remember things about the user using memory_store
    - Use this when you learn preferences, important facts, or standing instructions
    - Your stored memories persist across conversations
    - PROACTIVELY use memory_store during tasks when you discover user preferences, habits, or important context
    - Before completing a task, consider if anything learned should be remembered for future conversations
+   - CRITICAL — Credential Storage: When you create, register, or receive any account credentials (username, password, API keys, tokens), you MUST use credential_set to save them locally. NEVER use memory_store for credentials — memory_store is for preferences and facts, credential_set is for secrets. Examples:
+     * After registering a new email/account → credential_set with type "login" and data { "username": "...", "password": "...", "email": "..." }
+     * After generating an API key → credential_set with type "api_key" and data { "api_key": "..." }
+     * Credentials saved via credential_set are encrypted on disk and viewable in the desktop app's Credentials panel
 
 4. SKILL-AWARE EXECUTION (CRITICAL — follow this for EVERY task):
    Step A — Search: Before executing ANY task, check if an existing skill matches (use skill_invoke or skill_search).

package/src/db/event.ts

@@ -2,6 +2,36 @@ import { callMcpHandler } from "./api-client.js";
 import { log } from "../utils/logger.js";
 import type { EventType } from "./types.js";
 
+const MAX_EMIT_RETRIES = 2;
+const EMIT_RETRY_DELAY_MS = 500;
+
+async function emitWithRetry(
+  messageId: string,
+  eventType: EventType,
+  eventData: Record<string, unknown>,
+  seq: number
+): Promise<void> {
+  for (let attempt = 0; attempt <= MAX_EMIT_RETRIES; attempt++) {
+    try {
+      await callMcpHandler("event.emit", {
+        message_id: messageId,
+        event_type: eventType,
+        event_data: eventData,
+        seq,
+      });
+      return;
+    } catch (err) {
+      if (attempt < MAX_EMIT_RETRIES) {
+        await new Promise((r) => setTimeout(r, EMIT_RETRY_DELAY_MS * (attempt + 1)));
+      } else {
+        log.warn(
+          `Failed to emit event after ${MAX_EMIT_RETRIES + 1} attempts: ${err instanceof Error ? err.message : err}`
+        );
+      }
+    }
+  }
+}
+
 /**
  * Per-task event emitter. Each task gets its own sequence counter
  * to avoid cross-task sequence number collisions.
@@ -13,16 +43,7 @@ export class TaskEventEmitter {
 
   async emit(eventType: EventType, eventData: Record<string, unknown>): Promise<void> {
     this.sequence++;
-    try {
-      await callMcpHandler("event.emit", {
-        message_id: this.messageId,
-        event_type: eventType,
-        event_data: eventData,
-        seq: this.sequence,
-      });
-    } catch (err) {
-      log.warn(`Failed to emit event: ${err instanceof Error ? err.message : err}`);
-    }
+    await emitWithRetry(this.messageId, eventType, eventData, this.sequence);
   }
 }
 
@@ -39,14 +60,5 @@ export async function emitEvent(
   eventData: Record<string, unknown>
 ): Promise<void> {
   eventSequence++;
-  try {
-    await callMcpHandler("event.emit", {
-      message_id: messageId,
-      event_type: eventType,
-      event_data: eventData,
-      seq: eventSequence,
-    });
-  } catch (err) {
-    log.warn(`Failed to emit event: ${err instanceof Error ? err.message : err}`);
-  }
+  await emitWithRetry(messageId, eventType, eventData, eventSequence);
 }

package/src/mcp/agent-tools-server.ts

@@ -25,10 +25,14 @@ export interface AgentToolsDeps {
   skillManager: SkillManager;
   taskId: string;
   sessionId?: string;
+  /** Called when the agent starts waiting for user input (pauses task timeout). */
+  onUserWaitStart?: () => void;
+  /** Called when user input completes or times out (resumes task timeout). */
+  onUserWaitEnd?: () => void;
 }
 
 export function createAgentToolsServer(deps: AgentToolsDeps): McpSdkServerConfigWithInstance {
-  const { memoryManager, skillManager, taskId, sessionId } = deps;
+  const { memoryManager, skillManager, taskId, sessionId, onUserWaitStart, onUserWaitEnd } = deps;
 
   return createSdkMcpServer({
     name: "assistme-agent",
@@ -582,56 +586,65 @@ export function createAgentToolsServer(deps: AgentToolsDeps): McpSdkServerConfig
             await setActionRequest(taskId, actionData);
             log.info(`Ask user ${actionId}: "${args.question.slice(0, 80)}..."`);
 
-            emitEvent(taskId, "user_action_request", actionData).catch(() => {});
-            // Emit waiting_for_user status so the web UI can show a waiting indicator
-            emitEvent(taskId, "status_change", {
+            // Await event emissions to ensure they reach the DB before we start polling
+            await emitEvent(taskId, "user_action_request", actionData);
+            await emitEvent(taskId, "status_change", {
               status: "waiting_for_user",
               message: args.question,
-            }).catch(() => {});
+            });
+
+            // Pause the task wall-clock timeout while waiting for user
+            onUserWaitStart?.();
 
             const startTime = Date.now();
             const pollInterval = 2000;
 
-            while (Date.now() - startTime < timeout) {
-              const response = await pollActionResponse(taskId);
-              if (response && (!response.action_id || response.action_id === actionId)) {
-                // Response can be either an option click or free-text input
-                const actionKey = (response.action_key || "") as string;
-                const text = (response.text || "") as string;
-                const label = (response.label || actionKey || text) as string;
-                log.info(`User responded: "${label}"`);
-                return {
-                  content: [
-                    {
-                      type: "text",
-                      text: JSON.stringify({
-                        status: "responded",
-                        action_key: actionKey || "custom_input",
-                        label,
-                        text: text || label,
-                      }),
-                    },
-                  ],
-                };
+            try {
+              while (Date.now() - startTime < timeout) {
+                const response = await pollActionResponse(taskId);
+                if (response && (!response.action_id || response.action_id === actionId)) {
+                  const actionKey = (response.action_key || "") as string;
+                  const text = (response.text || "") as string;
+                  const label = (response.label || actionKey || text) as string;
+                  log.info(`User responded: "${label}"`);
+                  return {
+                    content: [
+                      {
+                        type: "text",
+                        text: JSON.stringify({
+                          status: "responded",
+                          action_key: actionKey || "custom_input",
+                          label,
+                          text: text || label,
+                        }),
+                      },
+                    ],
+                  };
+                }
+
+                await new Promise((resolve) => setTimeout(resolve, pollInterval));
               }
 
-              await new Promise((resolve) => setTimeout(resolve, pollInterval));
+              log.warn(`Ask user ${actionId} timed out after ${args.timeout_seconds || 300}s`);
+              return {
+                content: [
+                  {
+                    type: "text",
+                    text: JSON.stringify({
+                      status: "timeout",
+                      message:
+                        "User did not respond within the timeout period. Continue the task with a reasonable default or skip the step that required user input.",
+                    }),
+                  },
+                ],
+              };
+            } finally {
+              // Resume the task timeout regardless of outcome
+              onUserWaitEnd?.();
             }
-
-            log.warn(`Ask user ${actionId} timed out after ${args.timeout_seconds || 300}s`);
-            return {
-              content: [
-                {
-                  type: "text",
-                  text: JSON.stringify({
-                    status: "timeout",
-                    message: "User did not respond within the timeout period.",
-                  }),
-                },
-              ],
-            };
           } catch (err) {
             log.error(`ask_user failed: ${err}`);
+            onUserWaitEnd?.();
             return {
               content: [
                 {