assistme 0.3.1 → 0.3.2

package/src/browser/types.ts

@@ -0,0 +1,70 @@
+export interface CDPTab {
+  id: string;
+  title: string;
+  url: string;
+  type: string;
+  webSocketDebuggerUrl?: string;
+}
+
+export interface CDPResponse {
+  id: number;
+  result?: Record<string, unknown>;
+  error?: { code: number; message: string };
+}
+
+/** Shape returned by Runtime.evaluate CDP calls */
+export interface CDPEvalResult {
+  result?: { value?: unknown; description?: string };
+}
+
+/** Shape returned by Page.captureScreenshot CDP calls */
+export interface CDPScreenshotResult {
+  data?: string;
+}
+
+// ── Ref System Types ────────────────────────────────────────────────
+
+export interface BoundingBox {
+  x: number;
+  y: number;
+  width: number;
+  height: number;
+}
+
+export interface RefEntry {
+  id: number;
+  role: string;
+  name: string;
+  tag: string;
+  inputType: string;
+  box: BoundingBox;
+}
+
+export interface SnapshotResult {
+  image: string;
+  refs: RefEntry[];
+  url: string;
+  title: string;
+}
+
+export type ActionSpec =
+  | { action: "click"; ref: number }
+  | { action: "type"; ref: number; text: string }
+  | { action: "select"; ref: number; option: string }
+  | { action: "press"; key: string }
+  | { action: "scroll"; direction: "up" | "down" }
+  | { action: "wait"; ms: number };
+
+export interface ActionResult {
+  action: string;
+  ref?: number;
+  result: string;
+  success: boolean;
+}
+
+export interface AutoLaunchResult {
+  success: boolean;
+  action: "already_available" | "launched" | "chrome_not_found" | "launch_failed" | "port_conflict";
+  chromePath?: string;
+  detail?: string;
+}

package/src/commands/credential.ts

@@ -0,0 +1,190 @@
+import { Command } from "commander";
+import chalk from "chalk";
+import { createInterface } from "readline";
+import { getCredentialStore, type CredentialType } from "../credentials/index.js";
+import { log } from "../utils/logger.js";
+
+const VALID_TYPES: CredentialType[] = ["api_key", "oauth_token", "login", "secret", "custom"];
+
+export function registerCredentialCommands(program: Command): void {
+  const credCmd = program
+    .command("credential")
+    .alias("cred")
+    .description("Manage locally stored credentials (encrypted, never sent to server)");
+
+  credCmd
+    .command("list")
+    .description("List all stored credentials (metadata only, no secrets)")
+    .option("-s, --skill <name>", "Filter by skill name")
+    .option("-t, --type <type>", "Filter by credential type")
+    .action(async (opts) => {
+      const store = getCredentialStore();
+      let results = store.list();
+
+      if (opts.skill) {
+        results = results.filter((m) => m.skillName === opts.skill);
+      }
+      if (opts.type) {
+        results = results.filter((m) => m.type === opts.type);
+      }
+
+      if (results.length === 0) {
+        console.log(chalk.yellow("  No credentials stored."));
+        console.log(chalk.dim("  Use `assistme credential set <name>` to add one."));
+        return;
+      }
+
+      console.log(chalk.bold("\n  Stored Credentials:\n"));
+      for (const m of results) {
+        const skill = m.skillName ? chalk.dim(` [${m.skillName}]`) : "";
+        const tags = m.tags.length > 0 ? chalk.dim(` (${m.tags.join(", ")})`) : "";
+        console.log(`  ${chalk.cyan(m.name)} ${chalk.gray(`(${m.type})`)}${skill}${tags}`);
+        console.log(chalk.dim(`    ID: ${m.id}  Created: ${m.createdAt.slice(0, 10)}`));
+      }
+      console.log();
+    });
+
+  credCmd
+    .command("set <name>")
+    .description("Store or update a credential interactively")
+    .option("-t, --type <type>", `Credential type: ${VALID_TYPES.join(", ")}`, "secret")
+    .option("-s, --skill <name>", "Associate with a skill")
+    .option("--tags <tags>", "Comma-separated tags")
+    .action(async (name, opts) => {
+      if (!VALID_TYPES.includes(opts.type)) {
+        log.error(`Invalid type "${opts.type}". Must be one of: ${VALID_TYPES.join(", ")}`);
+        process.exit(1);
+      }
+
+      const rl = createInterface({
+        input: process.stdin,
+        output: process.stdout,
+      });
+
+      const ask = (q: string): Promise<string> =>
+        new Promise((resolve) => {
+          rl.question(q, (answer) => resolve(answer.trim()));
+        });
+
+      console.log(chalk.bold(`\n  Set credential: ${name}`));
+      console.log(chalk.dim("  Enter key-value pairs. Empty key to finish.\n"));
+
+      const data: Record<string, string> = {};
+
+      // For common types, provide helpful prompts
+      if (opts.type === "login") {
+        data.username = await ask(chalk.cyan("  Username: "));
+        data.password = await ask(chalk.cyan("  Password: "));
+      } else if (opts.type === "api_key") {
+        data.api_key = await ask(chalk.cyan("  API Key: "));
+      } else {
+        // Generic key-value input
+        while (true) {
+          const key = await ask(chalk.cyan("  Key (empty to finish): "));
+          if (!key) break;
+          const value = await ask(chalk.cyan(`  Value for "${key}": `));
+          data[key] = value;
+        }
+      }
+
+      rl.close();
+
+      if (Object.keys(data).length === 0) {
+        console.log(chalk.yellow("  No data provided. Credential not saved."));
+        return;
+      }
+
+      const store = getCredentialStore();
+      const tags = opts.tags ? opts.tags.split(",").map((t: string) => t.trim()) : [];
+      const meta = store.save(name, opts.type, data, {
+        skillName: opts.skill,
+        tags,
+      });
+
+      log.success(`Credential "${meta.name}" saved (ID: ${meta.id})`);
+      console.log(chalk.dim("  Encrypted and stored at ~/.config/assistme/credentials/"));
+    });
+
+  credCmd
+    .command("get <name>")
+    .description("Show credential metadata (use --reveal to show secrets)")
+    .option("-r, --reveal", "Reveal secret values")
+    .action(async (name, opts) => {
+      const store = getCredentialStore();
+      const credential = store.getByName(name);
+
+      if (!credential) {
+        log.error(`Credential not found: ${name}`);
+        process.exit(1);
+      }
+
+      const m = credential.meta;
+      console.log(chalk.bold(`\n  ${m.name} (${m.type})`));
+      if (m.skillName) console.log(`  Skill: ${m.skillName}`);
+      if (m.tags.length > 0) console.log(`  Tags: ${m.tags.join(", ")}`);
+      console.log(`  Created: ${m.createdAt}`);
+      console.log(`  Updated: ${m.updatedAt}`);
+
+      if (opts.reveal) {
+        console.log(chalk.bold("\n  Data:"));
+        for (const [key, value] of Object.entries(credential.data)) {
+          console.log(`    ${chalk.cyan(key)}: ${value}`);
+        }
+      } else {
+        console.log(chalk.bold("\n  Data keys:"));
+        for (const key of Object.keys(credential.data)) {
+          console.log(`    ${chalk.cyan(key)}: ${"*".repeat(8)}`);
+        }
+        console.log(chalk.dim("\n  Use --reveal to show secret values."));
+      }
+      console.log();
+    });
+
+  credCmd
+    .command("remove <name>")
+    .description("Remove a stored credential")
+    .action(async (name) => {
+      const store = getCredentialStore();
+      const removed = store.removeByName(name);
+      if (removed) {
+        log.success(`Credential "${name}" removed.`);
+      } else {
+        log.error(`Credential not found: ${name}`);
+      }
+    });
+
+  credCmd
+    .command("clear")
+    .description("Remove ALL stored credentials")
+    .action(async () => {
+      const store = getCredentialStore();
+      const count = store.list().length;
+
+      if (count === 0) {
+        console.log(chalk.yellow("  No credentials to clear."));
+        return;
+      }
+
+      const rl = createInterface({
+        input: process.stdin,
+        output: process.stdout,
+      });
+
+      const answer = await new Promise<string>((resolve) => {
+        rl.question(
+          chalk.red(`  Remove ALL ${count} credential(s)? This cannot be undone. (yes/no): `),
+          (ans) => {
+            rl.close();
+            resolve(ans.trim().toLowerCase());
+          },
+        );
+      });
+
+      if (answer === "yes" || answer === "y") {
+        store.clear();
+        log.success(`All ${count} credential(s) removed.`);
+      } else {
+        console.log(chalk.dim("  Cancelled."));
+      }
+    });
+}

package/src/commands/job.ts

@@ -3,14 +3,10 @@ import chalk from "chalk";
 import { getCurrentUserId } from "../db/supabase.js";
 import { callMcpHandler } from "../db/api-client.js";
 import { log } from "../utils/logger.js";
-import {
-  createScheduledTask,
-} from "../agent/scheduler.js";
+import { createScheduledTask } from "../agent/scheduler.js";
 
 export function registerJobCommands(program: Command): void {
-  const jobCmd = program
-    .command("job")
-    .description("Manage and run automated jobs");
+  const jobCmd = program.command("job").description("Manage and run automated jobs");
 
   jobCmd
     .command("list")
@@ -19,22 +15,18 @@ export function registerJobCommands(program: Command): void {
       try {
         const userId = await getCurrentUserId();
         const { JobRunner } = await import("../agent/job-runner.js");
-        const runner = new JobRunner(userId);
+        const runner = new JobRunner();
         const jobs = await runner.listJobs();
 
         if (jobs.length === 0) {
           console.log(chalk.yellow("No jobs defined."));
-          console.log(
-            'Use "assistme" and tell the agent about your job to generate skills.'
-          );
+          console.log('Use "assistme" and tell the agent about your job to generate skills.');
           return;
         }
 
         console.log(chalk.bold("\nYour Jobs:"));
         for (const job of jobs) {
-          console.log(
-            `  ${chalk.cyan(job.name)} (${job.skillCount} skills)`
-          );
+          console.log(`  ${chalk.cyan(job.name)} (${job.skillCount} skills)`);
           console.log(
             `    ${job.description.slice(0, 80)}${job.description.length > 80 ? "..." : ""}`
           );
@@ -54,26 +46,15 @@ export function registerJobCommands(program: Command): void {
       try {
         const userId = await getCurrentUserId();
         const { JobRunner } = await import("../agent/job-runner.js");
-        const runner = new JobRunner(userId);
-        const runs = await runner.getRunHistory(
-          name,
-          parseInt(opts.limit || "5")
-        );
+        const runner = new JobRunner();
+        const runs = await runner.getRunHistory(name, parseInt(opts.limit || "5"));
 
         if (runs.length === 0) {
-          console.log(
-            chalk.yellow(
-              name ? `No runs found for "${name}".` : "No job runs yet."
-            )
-          );
+          console.log(chalk.yellow(name ? `No runs found for "${name}".` : "No job runs yet."));
           return;
         }
 
-        console.log(
-          chalk.bold(
-            `\nJob Run History${name ? ` — ${name}` : ""}:`
-          )
-        );
+        console.log(chalk.bold(`\nJob Run History${name ? ` — ${name}` : ""}:`));
         for (const run of runs) {
           const icon =
             run.status === "completed"
@@ -88,14 +69,10 @@ export function registerJobCommands(program: Command): void {
             ? `${Math.round((new Date(run.completedAt).getTime() - new Date(run.startedAt).getTime()) / 1000)}s`
             : "in progress";
 
-          console.log(
-            `  ${icon} ${chalk.bold(run.jobName)} | ${run.triggerType} | ${date}`
-          );
+          console.log(`  ${icon} ${chalk.bold(run.jobName)} | ${run.triggerType} | ${date}`);
           console.log(`    Duration: ${duration}`);
           if (run.summary) {
-            console.log(
-              `    ${chalk.dim(run.summary.slice(0, 100))}`
-            );
+            console.log(`    ${chalk.dim(run.summary.slice(0, 100))}`);
           }
           console.log();
         }
@@ -126,29 +103,21 @@ export function registerJobCommands(program: Command): void {
         }
         const userId = await getCurrentUserId();
         const { JobRunner } = await import("../agent/job-runner.js");
-        const runner = new JobRunner(userId);
+        const runner = new JobRunner();
         const job = await runner.loadJob(name);
 
         if (!job) {
           log.error(`Job "${name}" not found.`);
           const jobs = await runner.listJobs();
           if (jobs.length > 0) {
-            console.log(
-              `Available: ${jobs.map((j) => j.name).join(", ")}`
-            );
+            console.log(`Available: ${jobs.map((j) => j.name).join(", ")}`);
           }
           process.exit(1);
         }
 
         const tz = opts.timezone || "UTC";
         const prompt = `[JobRun: ${name}] Run the "${name}" job. Use job_run to execute it.`;
-        const task = await createScheduledTask(
-          userId,
-          `Job: ${name}`,
-          prompt,
-          opts.cron,
-          tz
-        );
+        const task = await createScheduledTask(`Job: ${name}`, prompt, opts.cron, tz);
 
         // Link job_id
         await callMcpHandler("schedule.link_job", {

package/src/commands/memory.ts

@@ -5,9 +5,7 @@ import { log } from "../utils/logger.js";
 import { MemoryManager } from "../agent/memory.js";
 
 export function registerMemoryCommands(program: Command): void {
-  const memoryCmd = program
-    .command("memory")
-    .description("Manage the agent's memory about you");
+  const memoryCmd = program.command("memory").description("Manage the agent's memory about you");
 
   memoryCmd
     .command("list")
@@ -16,18 +14,13 @@ export function registerMemoryCommands(program: Command): void {
     .option("-l, --limit <number>", "Max items (default: 20)")
     .action(async (opts) => {
       try {
-        const userId = await getCurrentUserId();
-        const mm = new MemoryManager(userId);
-        const memories = await mm.list(
-          opts.category,
-          parseInt(opts.limit || "20")
-        );
+        await getCurrentUserId();
+        const mm = new MemoryManager();
+        const memories = await mm.list(opts.category, parseInt(opts.limit || "20"));
 
         if (memories.length === 0) {
           console.log(chalk.yellow("No memories stored yet."));
-          console.log(
-            "The agent will automatically remember things as you interact with it."
-          );
+          console.log("The agent will automatically remember things as you interact with it.");
           return;
         }
 
@@ -66,20 +59,16 @@ export function registerMemoryCommands(program: Command): void {
     .option("-t, --tags <tags>", "Comma-separated tags")
     .action(async (content, opts) => {
       try {
-        const userId = await getCurrentUserId();
-        const mm = new MemoryManager(userId);
-        const tags = opts.tags
-          ? opts.tags.split(",").map((t: string) => t.trim())
-          : [];
+        await getCurrentUserId();
+        const mm = new MemoryManager();
+        const tags = opts.tags ? opts.tags.split(",").map((t: string) => t.trim()) : [];
         const mem = await mm.add(
           content,
           opts.category || "general",
           parseInt(opts.importance || "5"),
           tags
         );
-        log.success(
-          `Memory stored: "${mem.content.slice(0, 60)}..." [${mem.category}]`
-        );
+        log.success(`Memory stored: "${mem.content.slice(0, 60)}..." [${mem.category}]`);
       } catch (err) {
         log.error(`${err instanceof Error ? err.message : err}`);
         process.exit(1);
@@ -91,8 +80,8 @@ export function registerMemoryCommands(program: Command): void {
     .description("Search memories")
     .action(async (query) => {
       try {
-        const userId = await getCurrentUserId();
-        const mm = new MemoryManager(userId);
+        await getCurrentUserId();
+        const mm = new MemoryManager();
         const results = await mm.search(query);
 
         if (results.length === 0) {
@@ -116,8 +105,8 @@ export function registerMemoryCommands(program: Command): void {
     .description("Delete a specific memory")
     .action(async (id) => {
       try {
-        const userId = await getCurrentUserId();
-        const mm = new MemoryManager(userId);
+        await getCurrentUserId();
+        const mm = new MemoryManager();
         const memories = await mm.list();
         const mem = memories.find((m) => m.id.startsWith(id));
         if (!mem) {
@@ -138,12 +127,10 @@ export function registerMemoryCommands(program: Command): void {
     .option("-c, --category <category>", "Only clear specific category")
     .action(async (opts) => {
       try {
-        const userId = await getCurrentUserId();
-        const mm = new MemoryManager(userId);
+        await getCurrentUserId();
+        const mm = new MemoryManager();
         await mm.clear(opts.category);
-        log.success(
-          `Memories cleared${opts.category ? ` (${opts.category})` : ""}`
-        );
+        log.success(`Memories cleared${opts.category ? ` (${opts.category})` : ""}`);
       } catch (err) {
         log.error(`${err instanceof Error ? err.message : err}`);
         process.exit(1);

package/src/commands/schedule.ts

@@ -10,22 +10,14 @@ import {
 } from "../agent/scheduler.js";
 
 export function registerScheduleCommands(program: Command): void {
-  const scheduleCmd = program
-    .command("schedule")
-    .description("Manage scheduled (cron) tasks");
+  const scheduleCmd = program.command("schedule").description("Manage scheduled (cron) tasks");
 
   scheduleCmd
     .command("add")
     .description("Add a scheduled task")
     .requiredOption("-n, --name <name>", "Task name")
-    .requiredOption(
-      "-p, --prompt <prompt>",
-      "Task prompt (what the AI should do)"
-    )
-    .requiredOption(
-      "-c, --cron <expression>",
-      "Cron expression (e.g. '0 8 * * *' for daily 8am)"
-    )
+    .requiredOption("-p, --prompt <prompt>", "Task prompt (what the AI should do)")
+    .requiredOption("-c, --cron <expression>", "Cron expression (e.g. '0 8 * * *' for daily 8am)")
     .option("-t, --timezone <tz>", "Timezone (default: UTC)")
     .action(async (opts) => {
       try {
@@ -38,14 +30,8 @@ export function registerScheduleCommands(program: Command): void {
           console.log('  Examples: "0 9 * * *" (daily 9am), "*/15 * * * *" (every 15 min)');
           process.exit(1);
         }
-        const userId = await getCurrentUserId();
-        const task = await createScheduledTask(
-          userId,
-          opts.name,
-          opts.prompt,
-          opts.cron,
-          opts.timezone
-        );
+        await getCurrentUserId();
+        const task = await createScheduledTask(opts.name, opts.prompt, opts.cron, opts.timezone);
         log.success(`Scheduled task created: ${task.name}`);
         console.log(`  ID:       ${task.id.slice(0, 8)}...`);
         console.log(`  Cron:     ${task.cron_expression}`);
@@ -63,8 +49,8 @@ export function registerScheduleCommands(program: Command): void {
     .description("List all scheduled tasks")
     .action(async () => {
       try {
-        const userId = await getCurrentUserId();
-        const tasks = await listScheduledTasks(userId);
+        await getCurrentUserId();
+        const tasks = await listScheduledTasks();
 
         if (tasks.length === 0) {
           console.log(chalk.yellow("No scheduled tasks."));
@@ -76,22 +62,14 @@ export function registerScheduleCommands(program: Command): void {
         for (const t of tasks) {
           const icon = t.enabled ? chalk.green("●") : chalk.dim("○");
           console.log(`  ${icon} ${t.name} (${t.id.slice(0, 8)}...)`);
-          console.log(
-            `    Cron:     ${t.cron_expression} (${t.timezone})`
-          );
-          console.log(
-            `    Prompt:   ${t.prompt.slice(0, 60)}${t.prompt.length > 60 ? "..." : ""}`
-          );
+          console.log(`    Cron:     ${t.cron_expression} (${t.timezone})`);
+          console.log(`    Prompt:   ${t.prompt.slice(0, 60)}${t.prompt.length > 60 ? "..." : ""}`);
           console.log(`    Runs:     ${t.run_count}`);
           if (t.next_run_at) {
-            console.log(
-              `    Next run: ${new Date(t.next_run_at).toLocaleString()}`
-            );
+            console.log(`    Next run: ${new Date(t.next_run_at).toLocaleString()}`);
           }
           if (t.last_error) {
-            console.log(
-              chalk.red(`    Error:    ${t.last_error.slice(0, 80)}`)
-            );
+            console.log(chalk.red(`    Error:    ${t.last_error.slice(0, 80)}`));
           }
           console.log();
         }
@@ -106,8 +84,8 @@ export function registerScheduleCommands(program: Command): void {
     .description("Enable/disable a scheduled task")
     .action(async (id) => {
       try {
-        const userId = await getCurrentUserId();
-        const tasks = await listScheduledTasks(userId);
+        await getCurrentUserId();
+        const tasks = await listScheduledTasks();
         const task = tasks.find((t) => t.id.startsWith(id));
         if (!task) {
           log.error(`Task not found: ${id}`);
@@ -126,8 +104,8 @@ export function registerScheduleCommands(program: Command): void {
     .description("Delete a scheduled task")
     .action(async (id) => {
       try {
-        const userId = await getCurrentUserId();
-        const tasks = await listScheduledTasks(userId);
+        await getCurrentUserId();
+        const tasks = await listScheduledTasks();
         const task = tasks.find((t) => t.id.startsWith(id));
         if (!task) {
           log.error(`Task not found: ${id}`);

package/src/commands/start.ts

@@ -13,20 +13,13 @@ export function registerStartCommand(program: Command): void {
   program
     .command("start", { isDefault: true, hidden: true })
     .description("Start the agent (default command)")
-    .option(
-      "-w, --workspace <path>",
-      "Workspace path (default: current directory)"
-    )
+    .option("-w, --workspace <path>", "Workspace path (default: current directory)")
     .option("-n, --name <name>", "Session name")
     .option("-v, --verbose", "Enable verbose/debug logging")
     .action(runAgent);
 }
 
-async function runAgent(opts: {
-  workspace?: string;
-  name?: string;
-  verbose?: boolean;
-}) {
+async function runAgent(opts: { workspace?: string; name?: string; verbose?: boolean }) {
   if (opts.verbose) {
     setLogLevel("debug");
   }
@@ -39,26 +32,10 @@ async function runAgent(opts: {
   }
 
   console.log();
-  console.log(
-    chalk.bold.cyan(
-      "  ╔══════════════════════════════════════════╗"
-    )
-  );
-  console.log(
-    chalk.bold.cyan(
-      "  ║          AssistMe CLI Agent              ║"
-    )
-  );
-  console.log(
-    chalk.bold.cyan(
-      "  ║   AI that controls your real browser     ║"
-    )
-  );
-  console.log(
-    chalk.bold.cyan(
-      "  ╚══════════════════════════════════════════╝"
-    )
-  );
+  console.log(chalk.bold.cyan("  ╔══════════════════════════════════════════╗"));
+  console.log(chalk.bold.cyan("  ║          AssistMe CLI Agent              ║"));
+  console.log(chalk.bold.cyan("  ║   AI that controls your real browser     ║"));
+  console.log(chalk.bold.cyan("  ╚══════════════════════════════════════════╝"));
   console.log();
 
   let userId: string;
@@ -79,9 +56,7 @@ async function runAgent(opts: {
         launchSpinner.succeed("Browser detected (CDP port 9222)");
         break;
       case "launched":
-        launchSpinner.succeed(
-          "Browser launched with remote debugging (debug profile)"
-        );
+        launchSpinner.succeed("Browser launched with remote debugging (debug profile)");
         break;
     }
   } else {
@@ -92,10 +67,7 @@ async function runAgent(opts: {
         break;
       case "port_conflict":
         launchSpinner.fail("Port 9222 is in use by another process");
-        log.info(
-          launchResult.detail ??
-            "Stop the conflicting process or use a different port."
-        );
+        log.info(launchResult.detail ?? "Stop the conflicting process or use a different port.");
         break;
       default:
         launchSpinner.fail("Failed to start Chrome with remote debugging");
@@ -105,15 +77,13 @@ async function runAgent(opts: {
         if (launchResult.chromePath) {
           log.info(`Chrome binary: ${launchResult.chromePath}`);
         }
-        log.info(
-          "Browser will be auto-launched when the first task needs it."
-        );
+        log.info("Browser will be auto-launched when the first task needs it.");
         break;
     }
   }
 
   const processor = new TaskProcessor();
-  processor.setUserId(userId);
+  processor.init(userId);
   const sessionManager = new SessionManager();
 
   // Graceful shutdown
@@ -191,9 +161,7 @@ async function runAgent(opts: {
 
     rl.on("close", shutdown);
   } catch (err) {
-    log.error(
-      `Failed to start: ${err instanceof Error ? err.message : err}`
-    );
+    log.error(`Failed to start: ${err instanceof Error ? err.message : err}`);
     process.exit(1);
   }
 }