assistme 0.2.8 → 0.3.0

package/dist/job-runner-N4XAAWLJ.js

@@ -0,0 +1,7 @@
+import {
+  JobRunner
+} from "./chunk-UWE5WVQI.js";
+import "./chunk-TTEGHE2E.js";
+export {
+  JobRunner
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "assistme",
-  "version": "0.2.8",
+  "version": "0.3.0",
   "description": "AssistMe CLI Agent - AI-powered assistant that controls your real browser",
   "type": "module",
   "main": "dist/index.js",
@@ -20,7 +20,6 @@
   },
   "dependencies": {
     "@anthropic-ai/claude-agent-sdk": "^0.2.63",
-    "@supabase/supabase-js": "^2.76.0",
     "zod": "^4.0.0",
     "chalk": "^5.4.1",
     "commander": "^13.1.0",

package/src/agent/job-runner.ts

@@ -1,4 +1,4 @@
-import { getSupabase } from "../db/supabase.js";
+import { callMcpHandler } from "../db/api-client.js";
 import { log } from "../utils/logger.js";
 
 // ── Interfaces ─────────────────────────────────────────────────────
@@ -31,10 +31,8 @@ export interface JobRunInfo {
 // ── JobRunner ──────────────────────────────────────────────────────
 
 export class JobRunner {
-  private userId: string;
-
-  constructor(userId: string) {
-    this.userId = userId;
+  constructor(_userId: string) {
+    // userId is no longer needed — auth is handled by the MCP token in callMcpHandler
   }
 
   /**
@@ -43,13 +41,12 @@ export class JobRunner {
    */
   async loadJob(jobName: string): Promise<JobInfo | null> {
     try {
-      const sb = getSupabase();
-      const { data, error } = await sb.rpc("get_job_with_skills", {
-        p_user_id: this.userId,
-        p_job_name: jobName,
-      });
+      const data = await callMcpHandler<Array<Record<string, unknown>> | null>(
+        "job.get_with_skills",
+        { job_name: jobName },
+      );
 
-      if (error || !data || (data as unknown[]).length === 0) {
+      if (!data || (data as unknown[]).length === 0) {
         return null;
       }
 
@@ -79,33 +76,16 @@ export class JobRunner {
    */
   async listJobs(): Promise<Array<{ id: string; name: string; description: string; skillCount: number }>> {
     try {
-      const sb = getSupabase();
-
-      const { data: jobs, error } = await sb
-        .from("agent_jobs")
-        .select("id, name, description")
-        .eq("user_id", this.userId)
-        .eq("is_active", true)
-        .order("name");
-
-      if (error || !jobs) return [];
-
-      const result: Array<{ id: string; name: string; description: string; skillCount: number }> = [];
-      for (const job of jobs) {
-        const { count } = await sb
-          .from("agent_job_skills")
-          .select("id", { count: "exact", head: true })
-          .eq("job_id", job.id);
-
-        result.push({
-          id: job.id,
-          name: job.name,
-          description: job.description,
-          skillCount: count || 0,
-        });
-      }
-
-      return result;
+      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,
+      }));
     } catch (err) {
       log.debug(`Failed to list jobs: ${err}`);
       return [];
@@ -122,21 +102,13 @@ export class JobRunner {
     options?: { sessionId?: string; messageId?: string; triggerType?: string }
   ): Promise<string | null> {
     try {
-      const sb = getSupabase();
-      const { data, error } = await sb.rpc("create_job_run", {
-        p_user_id: this.userId,
-        p_job_id: jobId,
-        p_session_id: options?.sessionId || null,
-        p_message_id: options?.messageId || null,
-        p_trigger_type: options?.triggerType || "manual",
+      const data = await callMcpHandler<string>("job.create_run", {
+        job_id: jobId,
+        session_id: options?.sessionId || null,
+        message_id: options?.messageId || null,
+        trigger_type: options?.triggerType || "manual",
       });
-
-      if (error) {
-        log.debug(`Failed to create job run: ${error.message}`);
-        return null;
-      }
-
-      return data as string;
+      return data;
     } catch (err) {
       log.debug(`Job run creation error: ${err}`);
       return null;
@@ -152,17 +124,11 @@ export class JobRunner {
     status: "completed" | "failed" | "cancelled" = "completed",
     summary?: string
   ): Promise<void> {
-    const sb = getSupabase();
-    const { error } = await sb.rpc("complete_job_run", {
-      p_run_id: runId,
-      p_status: status,
-      p_summary: summary?.slice(0, 10000) || null,
-      p_user_id: this.userId,
+    await callMcpHandler("job.complete_run", {
+      run_id: runId,
+      status,
+      summary: summary?.slice(0, 10000) || null,
     });
-    if (error) {
-      log.error(`Failed to mark run ${runId} as ${status}: ${error.message}`);
-      throw new Error(`Run completion failed: ${error.message}`);
-    }
   }
 
   /**
@@ -170,16 +136,12 @@ export class JobRunner {
    */
   async getRunHistory(jobName?: string, limit = 10): Promise<JobRunInfo[]> {
     try {
-      const sb = getSupabase();
-      const { data, error } = await sb.rpc("get_job_runs", {
-        p_user_id: this.userId,
-        p_job_name: jobName || null,
-        p_limit: limit,
-      });
-
-      if (error || !data) return [];
+      const data = await callMcpHandler<Array<Record<string, unknown>>>(
+        "job.get_runs",
+        { job_name: jobName || null, limit },
+      );
 
-      return (data as Array<Record<string, unknown>>).map((row) => ({
+      return (data || []).map((row) => ({
         runId: row.run_id as string,
         jobName: row.job_name as string,
         status: row.status as string,

package/src/agent/mcp-servers.ts

@@ -8,9 +8,10 @@ import { executeTool } from "../tools/index.js";
 import { getLimiterForTool } from "../utils/rate-limiter.js";
 import { log } from "../utils/logger.js";
 import type { MemoryManager, MemoryCategory } from "./memory.js";
-import type { SkillManager, SkillVariable } from "./skills.js";
-import { substituteArguments, substituteVariables, preprocessDynamicContext } from "./skills.js";
-import { getSupabase, emitEvent, setActionRequest, pollActionResponse } from "../db/supabase.js";
+import type { SkillManager } from "./skills.js";
+import { substituteArguments, preprocessDynamicContext, validateSkillName } from "./skills.js";
+import { emitEvent, setActionRequest, pollActionResponse } from "../db/supabase.js";
+import { callMcpHandler } from "../db/api-client.js";
 import { JobRunner } from "./job-runner.js";
 import {
   createScheduledTask,
@@ -214,28 +215,25 @@ export function createAgentToolsServer(deps: AgentToolsDeps): McpSdkServerConfig
       ),
       tool(
         "skill_create",
-        "Create a new skill and add it to the user's collection. Returns the skill ID on success. " +
-          "Use {{variable_name}} syntax in instructions for user-specific data (e.g. {{github_repos}}, {{slack_channel}}).",
+        "Create a new skill and add it to the user's collection. Returns the skill ID on success.",
         {
           name: z.string().describe("Skill name in kebab-case, e.g. 'flight-booking'"),
           description: z.string().describe("One-line description of what this skill does"),
-          instructions: z.string().describe(
-            "Markdown step-by-step instructions. Use {{variable_name}} placeholders for user-specific data " +
-              "(e.g. {{github_repos}}, {{trello_board}}, {{slack_channel}}). These will be resolved with user's config at invoke time."
-          ),
+          instructions: z.string().describe("Markdown step-by-step instructions"),
           emoji: z.string().optional().describe("Single emoji representing this skill"),
-          variables: z.array(z.object({
-            name: z.string().describe("Variable name matching {{name}} in instructions"),
-            description: z.string().describe("Human-readable description of what this variable is for"),
-            type: z.enum(["string", "string[]", "number", "boolean"]).describe("Data type"),
-            required: z.boolean().describe("Whether the skill needs this to function"),
-            default: z.string().optional().describe("Default value if user doesn't configure"),
-            example: z.string().optional().describe("Example value to guide the user"),
-          })).optional().describe(
-            "Variables that need user-specific configuration. Define one for each {{variable}} used in instructions."
-          ),
         },
         async (args) => {
+          // Validate skill name format
+          const nameError = validateSkillName(args.name);
+          if (nameError) {
+            return {
+              content: [{
+                type: "text",
+                text: `Invalid skill name: ${nameError}. Use lowercase kebab-case like "flight-booking".`,
+              }],
+            };
+          }
+
           // Check for duplicates in user's collection
           const existing = skillManager.findSimilar(args.name);
           if (existing) {
@@ -254,11 +252,7 @@ export function createAgentToolsServer(deps: AgentToolsDeps): McpSdkServerConfig
             args.name,
             args.description,
             args.instructions,
-            {
-              source: "manual",
-              emoji: args.emoji,
-              variables: args.variables as SkillVariable[] | undefined,
-            }
+            { source: "manual", emoji: args.emoji }
           );
 
           if (!result) {
@@ -277,27 +271,17 @@ export function createAgentToolsServer(deps: AgentToolsDeps): McpSdkServerConfig
               source: "manual",
               emoji: args.emoji,
               sourceSkillId: result.id,
-              variables: args.variables as SkillVariable[] | undefined,
             }
           );
 
-          // Build response with variable info
-          let responseText = `Skill "${args.name}" created and added to your collection (ID: ${result.id}).`;
-          if (args.variables && args.variables.length > 0) {
-            const requiredVars = args.variables.filter((v) => v.required);
-            if (requiredVars.length > 0) {
-              responseText += `\n\n**Variables that need configuration:**\n`;
-              for (const v of requiredVars) {
-                const example = v.example ? ` (e.g. ${v.example})` : "";
-                responseText += `- \`{{${v.name}}}\`: ${v.description}${example}\n`;
-              }
-              responseText += `\nUse \`skill_configure\` to set these values for the user, or ask the user to provide them.`;
-            }
-          }
-
           log.success(`Skill "${args.name}" created and added to collection`);
           return {
-            content: [{ type: "text", text: responseText }],
+            content: [
+              {
+                type: "text",
+                text: `Skill "${args.name}" created and added to your collection (ID: ${result.id}).`,
+              },
+            ],
           };
         }
       ),
@@ -382,9 +366,6 @@ export function createAgentToolsServer(deps: AgentToolsDeps): McpSdkServerConfig
 
           let content = skill.content;
 
-          // Substitute {{variable}} placeholders with user config values
-          content = substituteVariables(content, skill.config, skill.variables);
-
           // Substitute $ARGUMENTS placeholders
           if (args.arguments) {
             content = substituteArguments(content, args.arguments);
@@ -405,16 +386,6 @@ export function createAgentToolsServer(deps: AgentToolsDeps): McpSdkServerConfig
             response += `\n\n**Allowed tools for this skill:** ${skill.allowedTools.join(", ")}\n`;
           }
 
-          // Warn about unconfigured required variables
-          const unconfigured = skillManager.getUnconfiguredVariables(args.name);
-          if (unconfigured.length > 0) {
-            response += `\n\n**⚠ Unconfigured variables — use \`skill_configure\` to set these:**\n`;
-            for (const v of unconfigured) {
-              const example = v.example ? ` (e.g. ${v.example})` : "";
-              response += `- \`{{${v.name}}}\`: ${v.description}${example}\n`;
-            }
-          }
-
           log.info(`Skill invoked: "${args.name}"`);
 
           // Log invocation to DB (fire-and-forget)
@@ -457,56 +428,6 @@ export function createAgentToolsServer(deps: AgentToolsDeps): McpSdkServerConfig
           return { content: [{ type: "text", text: response }] };
         }
       ),
-      tool(
-        "skill_configure",
-        "Set user-specific variable values for a skill. Variables are defined in the skill template (e.g. {{github_repos}}) " +
-          "and need to be configured with the user's actual data before the skill can work properly.",
-        {
-          name: z.string().describe("Name of the skill to configure"),
-          config: z.record(z.unknown()).describe(
-            "Key-value pairs of variable values. Keys must match variable names defined in the skill. " +
-              "Example: {\"github_repos\": [\"octocat/hello-world\", \"myorg/myrepo\"], \"github_username\": \"octocat\"}"
-          ),
-        },
-        async (args) => {
-          const skill = skillManager.get(args.name);
-          if (!skill) {
-            const available = skillManager.getAll().map((s) => s.name).join(", ");
-            return {
-              content: [{
-                type: "text",
-                text: `Skill "${args.name}" not found. Available: ${available}`,
-              }],
-            };
-          }
-
-          const updated = await skillManager.updateConfig(args.name, args.config);
-          if (!updated) {
-            return {
-              content: [{ type: "text", text: `Failed to update config for "${args.name}".` }],
-            };
-          }
-
-          // Check if there are still unconfigured required variables
-          const unconfigured = skillManager.getUnconfiguredVariables(args.name);
-          let responseText = `Configuration updated for skill "${args.name}".`;
-
-          if (unconfigured.length > 0) {
-            responseText += `\n\n**Still needs configuration:**\n`;
-            for (const v of unconfigured) {
-              const example = v.example ? ` (e.g. ${v.example})` : "";
-              responseText += `- \`{{${v.name}}}\`: ${v.description}${example}\n`;
-            }
-          } else {
-            responseText += ` All required variables are configured.`;
-          }
-
-          log.info(`Config updated for skill "${args.name}": ${Object.keys(args.config).join(", ")}`);
-          return {
-            content: [{ type: "text", text: responseText }],
-          };
-        }
-      ),
       tool(
         "skill_generate",
         "Prepare context for generating skills from a job description. Returns existing skills and job info " +
@@ -542,39 +463,15 @@ export function createAgentToolsServer(deps: AgentToolsDeps): McpSdkServerConfig
           response += `- name: kebab-case name (e.g. "slack-message-check")\n`;
           response += `- description: one-line description\n`;
           response += `- instructions: detailed step-by-step markdown instructions the agent can follow\n`;
-          response += `- emoji: a single emoji representing the skill\n`;
-          response += `- variables: define user-specific data needed by the skill (see below)\n\n`;
+          response += `- emoji: a single emoji representing the skill\n\n`;
           response += `skill_create automatically adds the skill to the user's collection — no need to call skill_add.\n\n`;
           response += `After ALL skills are created, call \`skill_link_job\` with job_name="${args.job_name}" and the list of created skill names to link them and mark the job as analyzed.\n\n`;
           response += `**Guidelines for skill instructions:**\n`;
           response += `- Write clear, actionable markdown steps\n`;
           response += `- Reference browser tools (browser_navigate, browser_click, browser_read_page, etc.) for web tasks\n`;
           response += `- Include error handling steps\n`;
-          response += `- Each skill should be a single, well-defined workflow (10-25 steps)\n\n`;
-          response += `**IMPORTANT — Use {{variables}} for user-specific data:**\n`;
-          response += `Skills often need user-specific information (accounts, repos, boards, channels, etc.).\n`;
-          response += `Instead of hardcoding or asking at runtime, use \`{{variable_name}}\` placeholders in instructions.\n\n`;
-          response += `Example: A GitHub PR review skill should use \`{{github_repos}}\` in its instructions:\n`;
-          response += `  "Navigate to each repository in {{github_repos}} and check for open PRs..."\n\n`;
-          response += `For each \`{{variable}}\` used in instructions, add a matching entry in the \`variables\` array:\n`;
-          response += `\`\`\`json\n`;
-          response += `{\n`;
-          response += `  "name": "github_repos",\n`;
-          response += `  "description": "GitHub repositories to monitor (owner/repo format)",\n`;
-          response += `  "type": "string[]",\n`;
-          response += `  "required": true,\n`;
-          response += `  "example": "octocat/hello-world, myorg/myrepo"\n`;
-          response += `}\n`;
-          response += `\`\`\`\n\n`;
-          response += `Common variables by platform:\n`;
-          response += `- GitHub: github_repos, github_username, github_org\n`;
-          response += `- Trello: trello_board_url, trello_list_names\n`;
-          response += `- Slack: slack_channels, slack_workspace_url\n`;
-          response += `- Email: email_labels, email_filters\n`;
-          response += `- E-commerce: store_url, competitor_urls, product_categories\n`;
-          response += `- General: timezone, language, notification_channel\n\n`;
-          response += `After creating skills, if any have required variables, call \`skill_configure\` to set initial values `;
-          response += `(ask the user for the values first).\n`;
+          response += `- Use placeholders like {query}, {date} for variable inputs\n`;
+          response += `- Each skill should be a single, well-defined workflow (10-25 steps)\n`;
 
           return { content: [{ type: "text", text: response }] };
         }
@@ -719,7 +616,78 @@ export function createAgentToolsServer(deps: AgentToolsDeps): McpSdkServerConfig
         }
       ),
 
-      // ── User Confirmation Tool ─────────────────────────────────
+      // ── User Interaction Tools ──────────────────────────────────
+
+      tool(
+        "request_user_input",
+        "Ask the user a clarifying question and wait for their free-text response. " +
+          "Use this when you need information that cannot be inferred from context, memory, or the workspace — " +
+          "e.g. which account to use, specific preferences, ambiguous instructions, or missing parameters for a skill. " +
+          "Do NOT use this for information you can discover yourself (git remote, file contents, etc.).",
+        {
+          question: z.string().describe("The question to ask the user (supports markdown). Be specific about what you need and why."),
+          placeholder: z.string().optional().describe("Placeholder text for the input field (e.g. 'https://github.com/owner/repo')"),
+          timeout_seconds: z.number().optional().describe("How long to wait for response (default: 300)"),
+        },
+        async (args) => {
+          const actionId = `input_${Date.now()}_${Math.random().toString(36).slice(2, 8)}`;
+          const timeout = (args.timeout_seconds || 300) * 1000;
+
+          const actionData = {
+            id: actionId,
+            type: "input",
+            message: args.question,
+            placeholder: args.placeholder || "",
+            created_at: new Date().toISOString(),
+          };
+
+          try {
+            await setActionRequest(taskId, actionData);
+            log.info(`Input request ${actionId}: "${args.question.slice(0, 80)}..."`);
+
+            emitEvent(taskId, "user_action_request", actionData).catch(() => {});
+
+            const startTime = Date.now();
+            const pollInterval = 2000;
+
+            while (Date.now() - startTime < timeout) {
+              const response = await pollActionResponse(taskId);
+              // Match response to this specific request by action_id
+              if (response && (!response.action_id || response.action_id === actionId)) {
+                const text = (response.text || response.value || "") as string;
+                log.info(`User input received: "${text.slice(0, 80)}"`);
+                return {
+                  content: [{
+                    type: "text",
+                    text: JSON.stringify({ status: "responded", text }),
+                  }],
+                };
+              }
+
+              await new Promise((resolve) => setTimeout(resolve, pollInterval));
+            }
+
+            log.warn(`Input request ${actionId} timed out`);
+            return {
+              content: [{
+                type: "text",
+                text: JSON.stringify({
+                  status: "timeout",
+                  message: "User did not respond within the timeout period.",
+                }),
+              }],
+            };
+          } catch (err) {
+            log.error(`request_user_input failed: ${err}`);
+            return {
+              content: [{
+                type: "text",
+                text: `Failed to request user input: ${err instanceof Error ? err.message : err}`,
+              }],
+            };
+          }
+        }
+      ),
 
       tool(
         "request_user_confirmation",
@@ -761,7 +729,8 @@ export function createAgentToolsServer(deps: AgentToolsDeps): McpSdkServerConfig
 
             while (Date.now() - startTime < timeout) {
               const response = await pollActionResponse(taskId);
-              if (response) {
+              // Match response to this specific request by action_id
+              if (response && (!response.action_id || response.action_id === actionId)) {
                 const actionKey = (response.action_key || response.action || "") as string;
                 const label = (response.label || actionKey) as string;
                 log.info(`User responded: ${label} (${actionKey})`);
@@ -916,11 +885,10 @@ export function createAgentToolsServer(deps: AgentToolsDeps): McpSdkServerConfig
             const task = await createScheduledTask(userId, name, prompt, args.cron, tz);
 
             // Link the job_id to the scheduled task
-            const sb = getSupabase();
-            await sb
-              .from("agent_scheduled_tasks")
-              .update({ job_id: job.jobId })
-              .eq("id", task.id);
+            await callMcpHandler("schedule.link_job", {
+              task_id: task.id,
+              job_id: job.jobId,
+            });
 
             const nextRun = task.next_run_at
               ? new Date(task.next_run_at).toLocaleString()
@@ -1034,27 +1002,19 @@ export function createAgentToolsServer(deps: AgentToolsDeps): McpSdkServerConfig
 // ── Helper: persist job and link skills ────────────────────────────
 
 async function saveJobToDb(
-  userId: string,
+  _userId: string,
   jobName: string,
   jobDescription: string,
   createdSkillNames: string[]
 ): Promise<void> {
   try {
-    const sb = getSupabase();
-
-    const { data, error } = await sb.rpc("save_job_with_skills", {
-      p_user_id: userId,
-      p_job_name: jobName,
-      p_job_description: jobDescription,
-      p_skill_names: createdSkillNames,
+    const data = await callMcpHandler("job.save_with_skills", {
+      job_name: jobName,
+      job_description: jobDescription,
+      skill_names: createdSkillNames,
     });
 
-    if (error) {
-      log.debug(`Failed to save job "${jobName}" via RPC: ${error.message}`);
-      return;
-    }
-
-    log.debug(`Job "${jobName}" saved via RPC (id: ${data}), ${createdSkillNames.length} skill(s) linked`);
+    log.debug(`Job "${jobName}" saved via edge function (id: ${data}), ${createdSkillNames.length} skill(s) linked`);
   } catch (err) {
     log.debug(`saveJobToDb error: ${err}`);
   }