@optima-chat/browser-cli 0.1.5 → 0.2.0

package/dist/index.js

@@ -1,29 +1,82 @@
 #!/usr/bin/env node
 
 // src/index.ts
+import { createRequire } from "module";
 import { Command } from "commander";
 
 // src/config.ts
 import { readFileSync, existsSync } from "fs";
 import { join } from "path";
 import { homedir } from "os";
-var TOKEN_PATH = join(homedir(), ".optima", "token.json");
-var BACKEND_URLS = {
-  ci: "https://browser-api.stage.optima.onl",
-  stage: "https://browser-api.stage.optima.onl",
-  prod: "https://browser-api.optima.onl"
+var ENV_CONFIG = {
+  production: {
+    apiUrl: "https://browser-api.optima.onl"
+  },
+  stage: {
+    apiUrl: "https://browser-api.stage.optima.onl"
+  },
+  development: {
+    apiUrl: "http://localhost:7292"
+  }
 };
-function loadTokenData() {
-  if (!existsSync(TOKEN_PATH)) return null;
+var OPTIMA_TOKEN_FILE = join(homedir(), ".optima", "token.json");
+function tokenEnvToBrowserEnv(tokenEnv) {
+  switch (tokenEnv) {
+    case "prod":
+    case "production":
+      return "production";
+    case "stage":
+      return "stage";
+    case "ci":
+    case "development":
+      return "development";
+    default:
+      return null;
+  }
+}
+function readOptimaToken() {
+  if (!existsSync(OPTIMA_TOKEN_FILE)) return null;
   try {
-    return JSON.parse(readFileSync(TOKEN_PATH, "utf-8"));
+    return JSON.parse(readFileSync(OPTIMA_TOKEN_FILE, "utf-8"));
   } catch {
     return null;
   }
 }
-var tokenData = loadTokenData();
-var BROWSER_API_URL = process.env.BROWSER_API_URL || (tokenData ? BACKEND_URLS[tokenData.env] : null) || "http://localhost:7292";
-var ACCESS_TOKEN = tokenData?.access_token || null;
+function getCurrentEnv() {
+  const browserEnv = process.env.BROWSER_ENV;
+  if (browserEnv && ["production", "stage", "development"].includes(browserEnv)) {
+    return browserEnv;
+  }
+  const optimaEnv = process.env.OPTIMA_ENV;
+  if (optimaEnv && ["production", "stage", "development"].includes(optimaEnv)) {
+    return optimaEnv;
+  }
+  const optimaToken = readOptimaToken();
+  if (optimaToken?.env) {
+    const mapped = tokenEnvToBrowserEnv(optimaToken.env);
+    if (mapped) return mapped;
+  }
+  return "development";
+}
+function loadConfig() {
+  const env = getCurrentEnv();
+  const envConfig = ENV_CONFIG[env];
+  let token = process.env.BROWSER_TOKEN || null;
+  if (!token) {
+    const optimaToken = readOptimaToken();
+    if (optimaToken?.access_token) {
+      token = optimaToken.access_token;
+    }
+  }
+  return {
+    apiUrl: process.env.BROWSER_API_URL || envConfig.apiUrl,
+    token,
+    env
+  };
+}
+var config = loadConfig();
+var BROWSER_API_URL = config.apiUrl;
+var ACCESS_TOKEN = config.token;
 
 // src/api.ts
 var BrowserAPIError = class extends Error {
@@ -62,7 +115,11 @@ async function request(path, options = {}) {
         `HTTP ${response.status}: ${response.statusText}`
       );
     }
-    throw new BrowserAPIError(response.status, body.error, body.message);
+    const detail = body.detail || body;
+    throw new BrowserAPIError(response.status, detail.error, detail.message);
+  }
+  if (response.status === 204) {
+    return void 0;
   }
   return await response.json();
 }
@@ -91,7 +148,8 @@ async function requestBinary(path) {
         `HTTP ${response.status}: ${response.statusText}`
       );
     }
-    throw new BrowserAPIError(response.status, body.error, body.message);
+    const detail = body.detail || body;
+    throw new BrowserAPIError(response.status, detail.error, detail.message);
   }
   const arrayBuffer = await response.arrayBuffer();
   return Buffer.from(arrayBuffer);
@@ -191,6 +249,50 @@ var BrowserAPI = class {
       { method: "DELETE" }
     );
   }
+  // Workflow methods
+  async saveWorkflow(sessionId, name, description) {
+    return request("/api/workflows", {
+      method: "POST",
+      body: JSON.stringify({ session_id: sessionId, name, description })
+    });
+  }
+  async listWorkflows(name) {
+    const query = name ? `?name=${encodeURIComponent(name)}` : "";
+    return request(`/api/workflows${query}`);
+  }
+  async getWorkflow(workflowId) {
+    return request(`/api/workflows/${workflowId}`);
+  }
+  async updateWorkflow(workflowId, updates) {
+    return request(`/api/workflows/${workflowId}`, {
+      method: "PUT",
+      body: JSON.stringify(updates)
+    });
+  }
+  async deleteWorkflow(workflowId) {
+    await request(`/api/workflows/${workflowId}`, { method: "DELETE" });
+  }
+  async runWorkflow(workflowId, params = {}, force) {
+    return request(`/api/workflows/${workflowId}/run`, {
+      method: "POST",
+      body: JSON.stringify({ params, force: !!force })
+    });
+  }
+  async getTaskStatus(taskId) {
+    return request(`/api/workflow-tasks/${taskId}`);
+  }
+  async provideInput(taskId, values, confirm) {
+    return request(`/api/workflow-tasks/${taskId}/input`, {
+      method: "POST",
+      body: JSON.stringify({ values: values ?? null, confirm: confirm ?? null })
+    });
+  }
+  async cancelTask(taskId) {
+    return request(`/api/workflow-tasks/${taskId}/cancel`, {
+      method: "POST",
+      body: JSON.stringify({})
+    });
+  }
 };
 var api = new BrowserAPI();
 
@@ -200,11 +302,18 @@ import { join as join2 } from "path";
 import { homedir as homedir2 } from "os";
 var OPTIMA_DIR = join2(homedir2(), ".optima");
 var SESSION_FILE = join2(OPTIMA_DIR, "browser-session-id");
+var _sessionOverride = null;
+function setSessionOverride(id) {
+  _sessionOverride = id;
+}
 function saveSessionId(id) {
   mkdirSync(OPTIMA_DIR, { recursive: true });
   writeFileSync(SESSION_FILE, id, "utf-8");
 }
 function loadSessionId() {
+  if (_sessionOverride) {
+    return _sessionOverride;
+  }
   if (!existsSync2(SESSION_FILE)) {
     throw new Error(
       "No active browser session. Run 'browser-cli launch' first."
@@ -286,6 +395,67 @@ function formatError(err) {
 function formatTabsInline(tabs) {
   return tabs.map((t) => `[${t.tab_id}] ${t.title}`).join(", ");
 }
+function formatWorkflowSaved(workflow) {
+  return `\u2713 Workflow '${workflow.name}' saved (id: ${workflow.id}, ${workflow.steps.length} steps)`;
+}
+function formatWorkflowList(workflows) {
+  if (workflows.length === 0) {
+    return "No workflows found.";
+  }
+  const lines = ["Workflows:", ""];
+  for (const wf of workflows) {
+    const desc = wf.description ? ` \u2014 ${wf.description}` : "";
+    lines.push(`  ${wf.name} (${wf.step_count} steps)${desc}`);
+  }
+  return lines.join("\n");
+}
+function formatWorkflowInfo(workflow) {
+  const lines = [];
+  lines.push(`Workflow: ${workflow.name}`);
+  lines.push(`ID: ${workflow.id}`);
+  if (workflow.description) lines.push(`Description: ${workflow.description}`);
+  lines.push(`Steps: ${workflow.steps.length}`);
+  lines.push(`Created: ${workflow.created_at}`);
+  lines.push("");
+  if (workflow.input_schema.length > 0) {
+    lines.push("Input variables:");
+    for (const v of workflow.input_schema) {
+      const req = v.required ? " (required)" : "";
+      lines.push(`  ${v.name}: ${v.type}${req}`);
+    }
+    lines.push("");
+  }
+  lines.push("Steps:");
+  for (let i = 0; i < workflow.steps.length; i++) {
+    const s = workflow.steps[i];
+    lines.push(`  ${i + 1}. [${s.step_type}] ${s.description}`);
+  }
+  return lines.join("\n");
+}
+function formatWorkflowTask(task) {
+  const lines = [];
+  const name = task.workflow_name ? ` (${task.workflow_name})` : "";
+  lines.push(`Task: ${task.id}${name}`);
+  lines.push(`Status: ${task.status}`);
+  lines.push(`Progress: ${task.current_step}/${task.total_steps}`);
+  if (task.session_id) lines.push(`Session: ${task.session_id}`);
+  if (task.missing_vars && task.missing_vars.length > 0) {
+    lines.push(`Missing: ${task.missing_vars.join(", ")}`);
+  }
+  if (task.pending_confirmation) {
+    lines.push(`Confirmation: ${task.pending_confirmation}`);
+  }
+  if (task.error) lines.push(`Error: ${task.error}`);
+  if (task.output) {
+    const entries = Object.entries(task.output).filter(([k]) => !k.startsWith("_")).map(([k, v]) => `${k}: ${v}`).join(", ");
+    if (entries) lines.push(`Output: ${entries}`);
+  }
+  if (task.completed_at) lines.push(`Completed: ${task.completed_at}`);
+  return lines.join("\n");
+}
+function formatWorkflowDeleted(name) {
+  return `\u2713 Workflow '${name}' deleted`;
+}
 
 // src/commands/lifecycle.ts
 function registerLifecycleCommands(program2) {
@@ -506,12 +676,306 @@ function registerTabCommands(program2) {
   });
 }
 
+// src/commands/workflow.ts
+function registerWorkflowCommands(program2) {
+  program2.command("save-workflow").argument("<name>", "Workflow name").description("Save current session actions as a workflow").option("--description <desc>", "Workflow description").action(async (name, opts) => {
+    try {
+      const sessionId = loadSessionId();
+      const workflow = await api.saveWorkflow(sessionId, name, opts.description);
+      console.log(formatWorkflowSaved(workflow));
+    } catch (err) {
+      console.error(formatError(err));
+      process.exit(1);
+    }
+  });
+  program2.command("list-workflows").description("List saved workflows").action(async () => {
+    try {
+      const workflows = await api.listWorkflows();
+      console.log(formatWorkflowList(workflows));
+    } catch (err) {
+      console.error(formatError(err));
+      process.exit(1);
+    }
+  });
+  program2.command("workflow-info").argument("<name>", "Workflow name").description("Show workflow details").action(async (name) => {
+    try {
+      const workflows = await api.listWorkflows(name);
+      if (workflows.length === 0) {
+        console.error(formatError(new Error(`Workflow '${name}' not found`)));
+        process.exit(1);
+      }
+      const workflow = await api.getWorkflow(workflows[0].id);
+      console.log(formatWorkflowInfo(workflow));
+    } catch (err) {
+      console.error(formatError(err));
+      process.exit(1);
+    }
+  });
+  program2.command("run-workflow").argument("<name>", "Workflow name").description("Execute a saved workflow").option("--param <params...>", "Parameters as key=value").option("--force", "Force run even if another task is active").action(async (name, opts) => {
+    try {
+      const workflows = await api.listWorkflows(name);
+      if (workflows.length === 0) {
+        console.error(formatError(new Error(`Workflow '${name}' not found`)));
+        process.exit(1);
+      }
+      const params = {};
+      if (opts.param) {
+        for (const p of opts.param) {
+          const [k, ...rest] = p.split("=");
+          params[k] = rest.join("=");
+        }
+      }
+      const task = await api.runWorkflow(workflows[0].id, params, opts.force);
+      console.log(formatWorkflowTask(task));
+    } catch (err) {
+      console.error(formatError(err));
+      process.exit(1);
+    }
+  });
+  program2.command("workflow-status").argument("<task_id>", "Task ID").description("Check workflow task status").action(async (taskId) => {
+    try {
+      const task = await api.getTaskStatus(taskId);
+      console.log(formatWorkflowTask(task));
+    } catch (err) {
+      console.error(formatError(err));
+      process.exit(1);
+    }
+  });
+  program2.command("workflow-cancel").argument("<task_id>", "Task ID").description("Cancel a running workflow task").action(async (taskId) => {
+    try {
+      const task = await api.cancelTask(taskId);
+      console.log(formatWorkflowTask(task));
+    } catch (err) {
+      console.error(formatError(err));
+      process.exit(1);
+    }
+  });
+  program2.command("workflow-input").argument("<task_id>", "Task ID").description("Provide input or confirmation to a waiting workflow task").option("--value <value>", "Provide a single value (only when one variable is missing)").option("--var <vars...>", "Provide named variables as key=value").option("--confirm", "Confirm a sensitive operation").action(async (taskId, opts) => {
+    try {
+      const values = {};
+      if (opts.value) {
+        const task = await api.getTaskStatus(taskId);
+        if (!task.missing_vars || task.missing_vars.length !== 1) {
+          console.error(formatError(new Error("--value can only be used when exactly one variable is missing. Use --var key=value instead.")));
+          process.exit(1);
+        }
+        values[task.missing_vars[0]] = opts.value;
+      }
+      if (opts.var) {
+        for (const v of opts.var) {
+          const [k, ...rest] = v.split("=");
+          values[k] = rest.join("=");
+        }
+      }
+      const hasValues = Object.keys(values).length > 0;
+      const result = await api.provideInput(taskId, hasValues ? values : void 0, opts.confirm);
+      console.log(formatWorkflowTask(result));
+    } catch (err) {
+      console.error(formatError(err));
+      process.exit(1);
+    }
+  });
+  program2.command("delete-workflow").argument("<name>", "Workflow name").description("Delete a saved workflow").action(async (name) => {
+    try {
+      const workflows = await api.listWorkflows(name);
+      if (workflows.length === 0) {
+        console.error(formatError(new Error(`Workflow '${name}' not found`)));
+        process.exit(1);
+      }
+      await api.deleteWorkflow(workflows[0].id);
+      console.log(formatWorkflowDeleted(name));
+    } catch (err) {
+      console.error(formatError(err));
+      process.exit(1);
+    }
+  });
+  program2.command("edit-workflow").argument("<name>", "Workflow name").description("Edit a workflow").option("--set-var", "Set a step value as variable").option("--step <n>", "Step number (1-based)", parseInt).option("--name <varName>", "Variable name").option("--add-input <varName>", "Add an input variable").option("--type <type>", "Variable type", "string").option("--required", "Mark variable as required").option("--add-step <type>", "Add a step (extract, wait_for_element)").option("--selectors <json>", "CSS selectors for extract step").option("--screenshot", "Include screenshot in extract step").option("--selector <css>", "CSS selector for wait_for_element step").option("--timeout <seconds>", "Timeout for wait_for_element step", parseInt).option("--remove-step <n>", "Remove step N (1-based)", parseInt).option("--update-step <n>", "Update step N (1-based)", parseInt).option("--requires-confirmation", "Mark step as requiring confirmation").option("--no-requires-confirmation", "Unmark step confirmation requirement").option("--target-text <text>", "Update step target text").option("--auto-clean", "Auto-clean redundant steps").action(async (name, opts) => {
+    try {
+      const workflows = await api.listWorkflows(name);
+      if (workflows.length === 0) {
+        console.error(formatError(new Error(`Workflow '${name}' not found`)));
+        process.exit(1);
+      }
+      const workflow = await api.getWorkflow(workflows[0].id);
+      if (opts.setVar && opts.step && opts.name) {
+        const stepIdx = opts.step - 1;
+        if (stepIdx < 0 || stepIdx >= workflow.steps.length) {
+          console.error(formatError(new Error(`Step ${opts.step} out of range`)));
+          process.exit(1);
+        }
+        const step = workflow.steps[stepIdx];
+        if (step.step_type === "navigate" && step.url) {
+          step.url = `{${opts.name}}`;
+        } else if (step.value !== void 0 && step.value !== null) {
+          step.value = `{${opts.name}}`;
+        } else {
+          console.error(formatError(new Error(`Step ${opts.step} ([${step.step_type}]) has no value or url to parameterize`)));
+          process.exit(1);
+        }
+        await api.updateWorkflow(workflow.id, { steps: workflow.steps });
+        console.log(`\u2713 Step ${opts.step} value set to {${opts.name}}`);
+      } else if (opts.addInput) {
+        const inputVar = {
+          name: opts.addInput,
+          type: opts.type || "string",
+          description: "",
+          required: !!opts.required,
+          default: null,
+          sensitive: false
+        };
+        const schema = workflow.input_schema || [];
+        schema.push(inputVar);
+        await api.updateWorkflow(workflow.id, { input_schema: schema });
+        console.log(`\u2713 Input variable '${opts.addInput}' added`);
+      } else if (opts.addStep === "extract") {
+        const extractStep = {
+          step_type: "extract",
+          description: "Extract data",
+          extract_selectors: opts.selectors ? JSON.parse(opts.selectors) : {},
+          extract_screenshot: !!opts.screenshot
+        };
+        workflow.steps.push(extractStep);
+        await api.updateWorkflow(workflow.id, { steps: workflow.steps });
+        console.log(`\u2713 Extract step added`);
+      } else if (opts.addStep === "wait_for_element") {
+        const waitStep = {
+          step_type: "wait_for_element",
+          description: `Wait for ${opts.selector || "element"}`,
+          wait_selector: opts.selector || "",
+          wait_timeout: opts.timeout || 30
+        };
+        workflow.steps.push(waitStep);
+        await api.updateWorkflow(workflow.id, { steps: workflow.steps });
+        console.log(`\u2713 wait_for_element step added`);
+      } else if (opts.removeStep) {
+        const stepIdx = opts.removeStep - 1;
+        if (stepIdx < 0 || stepIdx >= workflow.steps.length) {
+          console.error(formatError(new Error(`Step ${opts.removeStep} out of range`)));
+          process.exit(1);
+        }
+        const removed = workflow.steps.splice(stepIdx, 1)[0];
+        await api.updateWorkflow(workflow.id, { steps: workflow.steps });
+        console.log(`\u2713 Step ${opts.removeStep} removed ([${removed.step_type}] ${removed.description})`);
+      } else if (opts.updateStep) {
+        const stepIdx = opts.updateStep - 1;
+        if (stepIdx < 0 || stepIdx >= workflow.steps.length) {
+          console.error(formatError(new Error(`Step ${opts.updateStep} out of range`)));
+          process.exit(1);
+        }
+        const step = workflow.steps[stepIdx];
+        let changed = false;
+        if (opts.requiresConfirmation === true) {
+          step.requires_confirmation = true;
+          changed = true;
+        } else if (opts.requiresConfirmation === false) {
+          step.requires_confirmation = false;
+          changed = true;
+        }
+        if (opts.targetText) {
+          step.target_text = opts.targetText;
+          changed = true;
+        }
+        if (!changed) {
+          console.log("Specify what to update: --requires-confirmation, --target-text <text>");
+          process.exit(1);
+        }
+        await api.updateWorkflow(workflow.id, { steps: workflow.steps });
+        console.log(`\u2713 Step ${opts.updateStep} updated`);
+      } else if (opts.autoClean) {
+        const before = workflow.steps.length;
+        const cleaned = autoCleanSteps(workflow.steps);
+        await api.updateWorkflow(workflow.id, { steps: cleaned });
+        const removed = before - cleaned.length;
+        console.log(`\u2713 Auto-clean: ${removed} step(s) removed (${before} \u2192 ${cleaned.length})`);
+      } else {
+        console.log("Usage:");
+        console.log("  edit-workflow <name> --set-var --step N --name varName");
+        console.log("  edit-workflow <name> --add-input varName --type T [--required]");
+        console.log("  edit-workflow <name> --add-step extract --selectors '{...}' [--screenshot]");
+        console.log("  edit-workflow <name> --add-step wait_for_element --selector '.css' [--timeout 30]");
+        console.log("  edit-workflow <name> --remove-step N");
+        console.log("  edit-workflow <name> --update-step N --requires-confirmation");
+        console.log("  edit-workflow <name> --update-step N --target-text 'new text'");
+        console.log("  edit-workflow <name> --auto-clean");
+      }
+    } catch (err) {
+      console.error(formatError(err));
+      process.exit(1);
+    }
+  });
+}
+function autoCleanSteps(steps) {
+  let result = [...steps];
+  result = cleanNavigateBackNavigate(result);
+  result = cleanConsecutiveInput(result);
+  result = cleanConsecutiveScroll(result);
+  result = cleanConsecutiveClick(result);
+  return result;
+}
+function cleanNavigateBackNavigate(steps) {
+  const result = [];
+  let i = 0;
+  while (i < steps.length) {
+    if (i + 2 < steps.length && steps[i].step_type === "navigate" && steps[i + 1].step_type === "go_back" && steps[i + 2].step_type === "navigate") {
+      i += 2;
+      continue;
+    }
+    result.push(steps[i]);
+    i++;
+  }
+  return result;
+}
+function sameElement(a, b) {
+  return !!a.target_text && a.target_text === b.target_text && a.element_tag === b.element_tag;
+}
+function cleanConsecutiveInput(steps) {
+  const result = [];
+  for (let i = 0; i < steps.length; i++) {
+    if (steps[i].step_type === "input" && i + 1 < steps.length && steps[i + 1].step_type === "input" && sameElement(steps[i], steps[i + 1])) {
+      continue;
+    }
+    result.push(steps[i]);
+  }
+  return result;
+}
+function cleanConsecutiveScroll(steps) {
+  const result = [];
+  for (let i = 0; i < steps.length; i++) {
+    if (steps[i].step_type === "scroll" && i + 1 < steps.length && steps[i + 1].step_type === "scroll" && steps[i].scroll_down === steps[i + 1].scroll_down) {
+      const amount = (steps[i].scroll_amount || 1) + (steps[i + 1].scroll_amount || 1);
+      steps[i + 1] = { ...steps[i + 1], scroll_amount: amount };
+      continue;
+    }
+    result.push(steps[i]);
+  }
+  return result;
+}
+function cleanConsecutiveClick(steps) {
+  const result = [];
+  for (let i = 0; i < steps.length; i++) {
+    if (steps[i].step_type === "click" && i + 1 < steps.length && steps[i + 1].step_type === "click" && sameElement(steps[i], steps[i + 1])) {
+      continue;
+    }
+    result.push(steps[i]);
+  }
+  return result;
+}
+
 // src/index.ts
+var require2 = createRequire(import.meta.url);
+var { version } = require2("../package.json");
 var program = new Command();
-program.name("browser-cli").description("CLI client for browser-backend").version("0.1.0");
+program.name("browser-cli").description("CLI client for browser-backend").version(version).option("--session <id>", "Override session ID");
+program.hook("preAction", () => {
+  const opts = program.opts();
+  if (opts.session) {
+    setSessionOverride(opts.session);
+  }
+});
 registerLifecycleCommands(program);
 registerNavigationCommands(program);
 registerInteractionCommands(program);
 registerInfoCommands(program);
 registerTabCommands(program);
+registerWorkflowCommands(program);
 program.parse();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@optima-chat/browser-cli",
-  "version": "0.1.5",
+  "version": "0.2.0",
   "type": "module",
   "main": "./dist/index.js",
   "bin": {