assistme 0.3.4 → 0.3.6

package/dist/job-runner-JT3JWZBV.js

@@ -0,0 +1,7 @@
+import {
+  JobRunner
+} from "./chunk-4YWS463E.js";
+import "./chunk-JVA6DHXD.js";
+export {
+  JobRunner
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "assistme",
-  "version": "0.3.4",
+  "version": "0.3.6",
   "description": "AssistMe CLI Agent - AI-powered assistant that controls your real browser",
   "type": "module",
   "main": "dist/index.js",
@@ -24,6 +24,7 @@
     "chalk": "^5.4.1",
     "commander": "^13.1.0",
     "conf": "^13.0.1",
+    "croner": "^10.0.1",
     "dotenv": "^16.5.0",
     "glob": "^11.0.1",
     "ora": "^8.2.0",

package/src/agent/event-hooks.ts

@@ -1,7 +1,17 @@
-import type { HookCallbackMatcher, HookCallback, PreToolUseHookInput, PostToolUseHookInput } from "@anthropic-ai/claude-agent-sdk";
+import type {
+  HookCallbackMatcher,
+  HookCallback,
+  PreToolUseHookInput,
+  PostToolUseHookInput,
+} from "@anthropic-ai/claude-agent-sdk";
 import { emitEvent } from "../db/supabase.js";
 import { log } from "../utils/logger.js";
 import type { ToolCallRecord } from "./skill-extractor.js";
+import {
+  MAX_TOOL_INPUT_LOG_LENGTH,
+  MAX_TOOL_RESULT_LENGTH,
+  MAX_SKILL_RECORD_RESULT_LENGTH,
+} from "../utils/constants.js";
 
 /**
  * Strip MCP server prefix from tool names for web UI compatibility.
@@ -29,7 +39,7 @@ export function createEventHooks(
     const displayName = stripMcpPrefix(rawName);
     const toolInput = preInput.tool_input;
 
-    log.tool(displayName, JSON.stringify(toolInput).slice(0, 200));
+    log.tool(displayName, JSON.stringify(toolInput).slice(0, MAX_TOOL_INPUT_LOG_LENGTH));
 
     await emitEvent(taskId, "tool_use_start", { name: displayName });
     await emitEvent(taskId, "tool_use_input", { input: toolInput });
@@ -55,22 +65,20 @@ export function createEventHooks(
     const toolResponse = postInput.tool_response;
 
     const resultStr =
-      typeof toolResponse === "string"
-        ? toolResponse
-        : JSON.stringify(toolResponse);
+      typeof toolResponse === "string" ? toolResponse : JSON.stringify(toolResponse);
 
-    log.result(resultStr.slice(0, 200));
+    log.result(resultStr.slice(0, MAX_TOOL_INPUT_LOG_LENGTH));
 
     await emitEvent(taskId, "tool_result", {
       name: displayName,
-      result: resultStr.slice(0, 10000),
+      result: resultStr.slice(0, MAX_TOOL_RESULT_LENGTH),
     });
 
     // Record for post-task skill extraction
     toolCallRecords.push({
       name: displayName,
       input: (toolInput as Record<string, unknown>) || {},
-      result: resultStr.slice(0, 300),
+      result: resultStr.slice(0, MAX_SKILL_RECORD_RESULT_LENGTH),
     });
 
     return {};

package/src/agent/job-runner.ts

@@ -1,5 +1,8 @@
 import { callMcpHandler } from "../db/api-client.js";
 import { log } from "../utils/logger.js";
+import { JobRowSchema, JobListRowSchema, JobRunRowSchema, safeParse } from "../utils/schemas.js";
+import { MAX_JOB_SUMMARY_LENGTH } from "../utils/constants.js";
+import { errorMessage } from "../utils/errors.js";
 
 // ── Interfaces ─────────────────────────────────────────────────────
 
@@ -37,32 +40,35 @@ export class JobRunner {
    */
   async loadJob(jobName: string): Promise<JobInfo | null> {
     try {
-      const data = await callMcpHandler<Array<Record<string, unknown>> | null>(
-        "job.get_with_skills",
-        { job_name: jobName }
-      );
+      const data = await callMcpHandler<unknown[]>("job.get_with_skills", {
+        job_name: jobName,
+      });
 
-      if (!data || (data as unknown[]).length === 0) {
+      if (!data || !Array.isArray(data) || data.length === 0) {
         return null;
       }
 
-      const rows = data as Array<Record<string, unknown>>;
-      const first = rows[0];
+      const rows = data.map((row) => safeParse(JobRowSchema, row)).filter(Boolean);
+      if (rows.length === 0) return null;
+
+      const first = rows[0]!;
 
       return {
-        jobId: first.job_id as string,
-        jobName: first.job_name as string,
-        jobDescription: first.job_description as string,
-        skills: rows.map((row) => ({
-          skillId: row.skill_id as string,
-          skillName: row.skill_name as string,
-          skillDescription: (row.skill_description as string) || "",
-          skillEmoji: (row.skill_emoji as string) || "",
-          skillContent: (row.skill_content as string) || "",
-        })),
+        jobId: first.job_id,
+        jobName: first.job_name,
+        jobDescription: first.job_description,
+        skills: rows
+          .filter((row) => row!.skill_id)
+          .map((row) => ({
+            skillId: row!.skill_id!,
+            skillName: row!.skill_name || "",
+            skillDescription: row!.skill_description,
+            skillEmoji: row!.skill_emoji,
+            skillContent: row!.skill_content,
+          })),
       };
     } catch (err) {
-      log.debug(`Failed to load job "${jobName}": ${err}`);
+      log.debug(`Failed to load job "${jobName}": ${errorMessage(err)}`);
       return null;
     }
   }
@@ -74,16 +80,19 @@ export class JobRunner {
     Array<{ id: string; name: string; description: string; skillCount: number }>
   > {
     try {
-      const data = await callMcpHandler<Array<Record<string, unknown>>>("job.list");
-
-      return (data || []).map((row) => ({
-        id: row.id as string,
-        name: row.name as string,
-        description: row.description as string,
-        skillCount: (row.skill_count as number) || 0,
-      }));
+      const data = await callMcpHandler<unknown[]>("job.list");
+
+      return (data || [])
+        .map((row) => safeParse(JobListRowSchema, row))
+        .filter(Boolean)
+        .map((row) => ({
+          id: row!.id,
+          name: row!.name,
+          description: row!.description,
+          skillCount: row!.skill_count,
+        }));
     } catch (err) {
-      log.debug(`Failed to list jobs: ${err}`);
+      log.debug(`Failed to list jobs: ${errorMessage(err)}`);
       return [];
     }
   }
@@ -106,7 +115,7 @@ export class JobRunner {
       });
       return data;
     } catch (err) {
-      log.debug(`Job run creation error: ${err}`);
+      log.debug(`Job run creation error: ${errorMessage(err)}`);
       return null;
     }
   }
@@ -123,7 +132,7 @@ export class JobRunner {
     await callMcpHandler("job.complete_run", {
       run_id: runId,
       status,
-      summary: summary?.slice(0, 10000) || null,
+      summary: summary?.slice(0, MAX_JOB_SUMMARY_LENGTH) || null,
     });
   }
 
@@ -132,22 +141,25 @@ export class JobRunner {
    */
   async getRunHistory(jobName?: string, limit = 10): Promise<JobRunInfo[]> {
     try {
-      const data = await callMcpHandler<Array<Record<string, unknown>>>("job.get_runs", {
+      const data = await callMcpHandler<unknown[]>("job.get_runs", {
         job_name: jobName || null,
         limit,
       });
 
-      return (data || []).map((row) => ({
-        runId: row.run_id as string,
-        jobName: row.job_name as string,
-        status: row.status as string,
-        triggerType: row.trigger_type as string,
-        startedAt: row.started_at as string,
-        completedAt: (row.completed_at as string) || null,
-        summary: (row.summary as string) || null,
-      }));
+      return (data || [])
+        .map((row) => safeParse(JobRunRowSchema, row))
+        .filter(Boolean)
+        .map((row) => ({
+          runId: row!.run_id,
+          jobName: row!.job_name,
+          status: row!.status,
+          triggerType: row!.trigger_type,
+          startedAt: row!.started_at,
+          completedAt: row!.completed_at ?? null,
+          summary: row!.summary ?? null,
+        }));
     } catch (err) {
-      log.debug(`Run history error: ${err}`);
+      log.debug(`Run history error: ${errorMessage(err)}`);
       return [];
     }
   }

package/src/agent/processor.ts

@@ -30,6 +30,13 @@ import {
 } from "./mcp-servers.js";
 import { createEventHooks } from "./event-hooks.js";
 import { BASE_SYSTEM_PROMPT } from "./system-prompt.js";
+import {
+  MAX_RESPONSE_CONTENT_LENGTH,
+  MAX_HISTORY_ENTRIES,
+  MAX_HISTORY_RESPONSE_LENGTH,
+  MAX_COMPLETE_TASK_RETRIES,
+} from "../utils/constants.js";
+import { errorMessage } from "../utils/errors.js";
 
 /**
  * Manages the task wall-clock timeout.
@@ -80,8 +87,7 @@ class TaskTimeout {
   }
 }
 
-const MAX_HISTORY_ENTRIES = 10;
-const MAX_RESPONSE_LENGTH = 1500;
+// Constants are now imported from utils/constants.ts
 
 export class TaskProcessor {
   private memoryManager: MemoryManager | null = null;
@@ -124,10 +130,8 @@ export class TaskProcessor {
     const config = getConfig();
     resetEventSequence();
 
-    // Wall-clock timeout for the entire task (default: 10 minutes)
-    const taskTimeoutMs =
-      (((config as unknown as Record<string, unknown>).taskTimeoutMinutes as number) || 10) *
-      60_000;
+    // Wall-clock timeout for the entire task
+    const taskTimeoutMs = config.taskTimeoutMinutes * 60_000;
 
     // Set correlation ID for this task's log messages
     newCorrelationId();
@@ -184,8 +188,8 @@ export class TaskProcessor {
         for (const entry of history) {
           historyPrompt += `User: ${entry.prompt}\n`;
           const truncated =
-            entry.response.length > MAX_RESPONSE_LENGTH
-              ? entry.response.slice(0, MAX_RESPONSE_LENGTH) + "…"
+            entry.response.length > MAX_HISTORY_RESPONSE_LENGTH
+              ? entry.response.slice(0, MAX_HISTORY_RESPONSE_LENGTH) + "…"
               : entry.response;
           historyPrompt += `Assistant: ${truncated}\n\n`;
         }
@@ -274,18 +278,12 @@ export class TaskProcessor {
         abortController,
       };
 
-      const taskStartTime = Date.now();
-
       try {
         for await (const message of query({
           prompt: promptMessages(),
           options,
         })) {
-          // Check timeout
-          if (Date.now() - taskStartTime > taskTimeoutMs) {
-            finalResponse += "\n\n[Task timed out]";
-            break;
-          }
+          // Timeout is handled by TaskTimeout + AbortController
 
           switch (message.type) {
             case "assistant": {
@@ -299,7 +297,8 @@ export class TaskProcessor {
                     text: block.text,
                   });
                 } else if (block.type === "thinking" && "thinking" in block) {
-                  const thinkingText = (block as unknown as { thinking: string }).thinking;
+                  const thinkingBlock = block as { type: "thinking"; thinking: string };
+                  const thinkingText = thinkingBlock.thinking;
                   log.debug(`Thinking: ${thinkingText.slice(0, 100)}...`);
                   await emitEvent(task.id, "thinking", {
                     text: thinkingText,
@@ -339,12 +338,11 @@ export class TaskProcessor {
 
             default:
               // Capture session ID from init message for post-task session resume
-              if (
-                message.type === "system" &&
-                "subtype" in message &&
-                (message as Record<string, unknown>).subtype === "init"
-              ) {
-                agentSessionId = (message as Record<string, unknown>).session_id as string;
+              if (message.type === "system" && "subtype" in message) {
+                const sysMsg = message as { type: string; subtype?: string; session_id?: string };
+                if (sysMsg.subtype === "init" && sysMsg.session_id) {
+                  agentSessionId = sysMsg.session_id;
+                }
               }
               log.debug(`SDK message type: ${message.type}`);
               break;
@@ -355,15 +353,14 @@ export class TaskProcessor {
       }
 
       // Truncate finalResponse to avoid edge function payload limits
-      const MAX_CONTENT_LENGTH = 50_000;
       const truncatedResponse =
-        finalResponse.length > MAX_CONTENT_LENGTH
-          ? finalResponse.slice(0, MAX_CONTENT_LENGTH) + "\n\n[Response truncated]"
+        finalResponse.length > MAX_RESPONSE_CONTENT_LENGTH
+          ? finalResponse.slice(0, MAX_RESPONSE_CONTENT_LENGTH) + "\n\n[Response truncated]"
           : finalResponse;
 
       // Complete the task (with retry for transient DB failures)
       await withRetry(() => completeTask(task.id, truncatedResponse, tokenUsage), {
-        maxRetries: 2,
+        maxRetries: MAX_COMPLETE_TASK_RETRIES,
         baseDelayMs: 300,
         label: "completeTask",
       });
@@ -386,7 +383,7 @@ export class TaskProcessor {
         );
       }
     } catch (err) {
-      const errorMsg = err instanceof Error ? err.message : String(err);
+      const errorMsg = errorMessage(err);
       log.error(`Task failed: ${errorMsg}`);
 
       await failTask(task.id, errorMsg);

package/src/agent/scheduler.ts

@@ -1,7 +1,8 @@
+import { Cron } from "croner";
 import { callMcpHandler } from "../db/api-client.js";
 import { log } from "../utils/logger.js";
-
-const SCHEDULER_INTERVAL = 30_000; // Check every 30 seconds
+import { SCHEDULER_INTERVAL_MS } from "../utils/constants.js";
+import { errorMessage } from "../utils/errors.js";
 
 export interface ScheduledTask {
   id: string;
@@ -22,69 +23,31 @@ export interface ScheduledTask {
 }
 
 /**
- * Parse a cron expression and calculate the next run time.
+ * Parse a cron expression and calculate the next run time using `croner`.
  * Supports: minute hour day-of-month month day-of-week
  * Examples: "0 8 * * *" (daily 8am), "0,30 * * * *" (every 30min)
+ *
+ * Handles edge cases correctly (Feb 29, month boundaries, invalid dates)
+ * that the previous hand-rolled parser missed.
  */
 export function getNextRunTime(cronExpr: string, timezone: string, fromDate?: Date): Date {
   const now = fromDate || new Date();
-  const parts = cronExpr.trim().split(/\s+/);
-  if (parts.length !== 5) {
-    throw new Error(`Invalid cron expression: ${cronExpr}`);
-  }
 
-  const [minExpr, hourExpr, domExpr, monExpr, dowExpr] = parts;
-
-  function parseField(expr: string, min: number, max: number): number[] {
-    const values: number[] = [];
-    for (const part of expr.split(",")) {
-      if (part === "*") {
-        for (let i = min; i <= max; i++) values.push(i);
-      } else if (part.startsWith("*/")) {
-        const step = parseInt(part.slice(2));
-        for (let i = min; i <= max; i += step) values.push(i);
-      } else if (part.includes("-")) {
-        const [start, end] = part.split("-").map(Number);
-        for (let i = start; i <= end; i++) values.push(i);
-      } else {
-        values.push(parseInt(part));
-      }
-    }
-    return values.sort((a, b) => a - b);
-  }
+  try {
+    const job = new Cron(cronExpr, { timezone: timezone || "UTC" });
+    const next = job.nextRun(now);
 
-  const minutes = parseField(minExpr, 0, 59);
-  const hours = parseField(hourExpr, 0, 23);
-  const daysOfMonth = parseField(domExpr, 1, 31);
-  const months = parseField(monExpr, 1, 12);
-  const daysOfWeek = parseField(dowExpr, 0, 6);
-
-  const useUTC = timezone === "UTC";
-
-  const candidate = new Date(now.getTime() + 60_000);
-  candidate.setSeconds(0, 0);
-
-  for (let i = 0; i < 527040; i++) {
-    const m = useUTC ? candidate.getUTCMinutes() : candidate.getMinutes();
-    const h = useUTC ? candidate.getUTCHours() : candidate.getHours();
-    const dom = useUTC ? candidate.getUTCDate() : candidate.getDate();
-    const mon = (useUTC ? candidate.getUTCMonth() : candidate.getMonth()) + 1;
-    const dow = useUTC ? candidate.getUTCDay() : candidate.getDay();
-
-    if (
-      minutes.includes(m) &&
-      hours.includes(h) &&
-      daysOfMonth.includes(dom) &&
-      months.includes(mon) &&
-      (dowExpr === "*" || daysOfWeek.includes(dow))
-    ) {
-      return candidate;
+    if (!next) {
+      throw new Error(`No future run time found for cron expression: ${cronExpr}`);
     }
 
-    candidate.setTime(candidate.getTime() + 60_000);
+    return next;
+  } catch (err) {
+    if (err instanceof Error && err.message.includes("No future run time")) {
+      throw err;
+    }
+    throw new Error(`Invalid cron expression "${cronExpr}": ${errorMessage(err)}`);
   }
-
-  return new Date(now.getTime() + 86400_000);
 }
 
 export class Scheduler {
@@ -98,7 +61,7 @@ export class Scheduler {
 
     await this.initializeNextRuns();
 
-    this.timer = setInterval(() => this.checkDueTasks(), SCHEDULER_INTERVAL);
+    this.timer = setInterval(() => this.checkDueTasks(), SCHEDULER_INTERVAL_MS);
     log.info("Scheduler started (checking every 30s)");
   }
 
@@ -124,7 +87,7 @@ export class Scheduler {
         }
       }
     } catch (err) {
-      log.debug(`Scheduler init: ${err}`);
+      log.debug(`Scheduler init: ${errorMessage(err)}`);
     }
   }
 
@@ -158,7 +121,7 @@ export class Scheduler {
           last_error: null,
         });
       } catch (err) {
-        const errMsg = err instanceof Error ? err.message : String(err);
+        const errMsg = errorMessage(err);
         await callMcpHandler("schedule.update", {
           task_id: task.id,
           last_error: errMsg,
@@ -166,7 +129,7 @@ export class Scheduler {
         log.error(`Scheduled task "${task.name}" failed: ${errMsg}`);
       }
     } catch (err) {
-      log.debug(`Scheduler check error: ${err}`);
+      log.debug(`Scheduler check error: ${errorMessage(err)}`);
     }
   }
 }

package/src/agent/skill-evaluator.ts

@@ -6,24 +6,8 @@ import {
 import { log } from "../utils/logger.js";
 import type { SkillManager } from "./skills.js";
 import { validateSkillName, normalizeSkillName } from "./skills.js";
-
-// ── Types ───────────────────────────────────────────────────────────
-
-interface SkillDecision {
-  action: "create" | "update" | "skip";
-  // For "create"
-  name?: string;
-  description?: string;
-  instructions?: string;
-  emoji?: string;
-  keywords?: string[];
-  // For "update"
-  existing_skill_name?: string;
-  improved_instructions?: string;
-  improved_description?: string;
-  // Always present
-  reason: string;
-}
+import { SkillDecisionSchema, type SkillDecision, safeParse } from "../utils/schemas.js";
+import { errorMessage } from "../utils/errors.js";
 
 // ── Agent Skills format spec (agentskills.io) ───────────────────────
 
@@ -78,9 +62,10 @@ export async function evaluateAndMaybeCreateSkill(opts: {
 
   // Build existing skills context so the agent knows what already exists
   const existingSkills = skillManager.getAll();
-  const existingList = existingSkills.length > 0
-    ? existingSkills.map((s) => `- ${s.name}: ${s.description}`).join("\n")
-    : "(no existing skills)";
+  const existingList =
+    existingSkills.length > 0
+      ? existingSkills.map((s) => `- ${s.name}: ${s.description}`).join("\n")
+      : "(no existing skills)";
 
   const prompt = `${SKILL_EVALUATION_PROMPT}
 
@@ -111,7 +96,9 @@ Respond with a JSON object now.`;
       } else if (message.type === "result") {
         const resultMsg = message as SDKResultMessage;
         if (resultMsg.subtype === "success" && "total_cost_usd" in resultMsg) {
-          log.debug(`Skill evaluation cost: $${(resultMsg as { total_cost_usd: number }).total_cost_usd.toFixed(4)}`);
+          log.debug(
+            `Skill evaluation cost: $${(resultMsg as { total_cost_usd: number }).total_cost_usd.toFixed(4)}`
+          );
         }
       }
     }
@@ -123,15 +110,12 @@ Respond with a JSON object now.`;
       return;
     }
 
-    if (!["create", "update", "skip"].includes(decision.action)) {
-      log.debug("Skill evaluation: invalid action");
-      return;
-    }
+    // Action is already validated by Zod schema
 
     // Execute the decision
     await executeSkillDecision(decision, skillManager);
   } catch (err) {
-    log.debug(`Skill evaluation error: ${err}`);
+    log.debug(`Skill evaluation error: ${errorMessage(err)}`);
   }
 }
 
@@ -149,14 +133,18 @@ async function executeSkillDecision(
         return;
       }
 
-      // Normalize name to valid kebab-case (model may return invalid format)
-      let skillName = decision.name;
-      if (validateSkillName(skillName)) {
-        skillName = normalizeSkillName(skillName);
-        if (!skillName || validateSkillName(skillName)) {
-          log.debug(`Skill create skipped: name "${decision.name}" cannot be normalized`);
-          return;
-        }
+      // Always normalize, then validate once
+      let skillName = normalizeSkillName(decision.name);
+      if (!skillName) {
+        log.debug(`Skill create skipped: name "${decision.name}" cannot be normalized`);
+        return;
+      }
+      const validationError = validateSkillName(skillName);
+      if (validationError) {
+        log.debug(`Skill create skipped: ${validationError}`);
+        return;
+      }
+      if (skillName !== decision.name) {
         log.debug(`Normalized skill name: "${decision.name}" → "${skillName}"`);
       }
 
@@ -228,31 +216,36 @@ async function executeSkillDecision(
  * Attempt to parse a SkillDecision from the model's response text.
  * Tries the full text first (model returned pure JSON), then falls
  * back to extracting the outermost balanced `{…}` block.
+ * Validates the parsed result against the Zod schema.
  */
 function parseJsonResponse(text: string): SkillDecision | null {
   const trimmed = text.trim();
 
-  // Fast path: entire response is JSON
-  try {
-    const parsed = JSON.parse(trimmed) as SkillDecision;
-    if (parsed.action) return parsed;
-  } catch { /* not pure JSON */ }
+  // Try to extract JSON — full text first, then balanced `{…}` block
+  const candidates: string[] = [trimmed];
 
-  // Fallback: find the first balanced `{…}` block
   const start = trimmed.indexOf("{");
-  if (start === -1) return null;
-
-  let depth = 0;
-  for (let i = start; i < trimmed.length; i++) {
-    if (trimmed[i] === "{") depth++;
-    else if (trimmed[i] === "}") depth--;
-    if (depth === 0) {
-      try {
-        return JSON.parse(trimmed.slice(start, i + 1)) as SkillDecision;
-      } catch {
-        return null;
+  if (start !== -1) {
+    let depth = 0;
+    for (let i = start; i < trimmed.length; i++) {
+      if (trimmed[i] === "{") depth++;
+      else if (trimmed[i] === "}") depth--;
+      if (depth === 0) {
+        candidates.push(trimmed.slice(start, i + 1));
+        break;
       }
     }
   }
+
+  for (const candidate of candidates) {
+    try {
+      const parsed = JSON.parse(candidate);
+      const validated = safeParse(SkillDecisionSchema, parsed);
+      if (validated) return validated;
+    } catch {
+      continue;
+    }
+  }
+
   return null;
 }