@lazyingart/agintiflow 0.1.0

package/src/cli.js

@@ -0,0 +1,181 @@
+import { runAgent } from "./agent-runner.js";
+import { loadConfig } from "./config.js";
+import { listAgentWrappers } from "./tool-wrappers.js";
+import { getModelPresets } from "./model-routing.js";
+import { getDockerSandboxStatus, runDockerPreflight } from "./docker-sandbox.js";
+
+function readOption(argv, index) {
+  const value = argv[index + 1];
+  if (!value || value.startsWith("--")) return "";
+  return value;
+}
+
+export function parseArgs(argv) {
+  const result = {
+    goal: "",
+    startUrl: "",
+    resume: "",
+    sessionId: "",
+    provider: "",
+    model: "",
+    routingMode: "",
+    commandCwd: "",
+    sandboxMode: "",
+    packageInstallPolicy: "",
+    allowShellTool: undefined,
+    allowWrapperTools: undefined,
+    useDockerSandbox: undefined,
+    headless: undefined,
+    maxSteps: undefined,
+    listRoutes: false,
+    listWrappers: false,
+    sandboxStatus: false,
+    sandboxPreflight: false,
+  };
+
+  const parts = [];
+  for (let i = 0; i < argv.length; i += 1) {
+    const arg = argv[i];
+    if (arg === "--start-url") {
+      result.startUrl = readOption(argv, i);
+      i += 1;
+      continue;
+    }
+    if (arg === "--resume") {
+      result.resume = readOption(argv, i);
+      i += 1;
+      continue;
+    }
+    if (arg === "--session-id") {
+      result.sessionId = readOption(argv, i);
+      i += 1;
+      continue;
+    }
+    if (arg === "--provider") {
+      result.provider = readOption(argv, i);
+      i += 1;
+      continue;
+    }
+    if (arg === "--model") {
+      result.model = readOption(argv, i);
+      i += 1;
+      continue;
+    }
+    if (arg === "--routing") {
+      result.routingMode = readOption(argv, i);
+      i += 1;
+      continue;
+    }
+    if (arg === "--cwd") {
+      result.commandCwd = readOption(argv, i);
+      i += 1;
+      continue;
+    }
+    if (arg === "--sandbox-mode") {
+      result.sandboxMode = readOption(argv, i);
+      i += 1;
+      continue;
+    }
+    if (arg === "--package-install-policy") {
+      result.packageInstallPolicy = readOption(argv, i);
+      i += 1;
+      continue;
+    }
+    if (arg === "--approve-package-installs") {
+      result.packageInstallPolicy = "allow";
+      result.sandboxMode = result.sandboxMode || "docker-workspace";
+      continue;
+    }
+    if (arg === "--max-steps") {
+      result.maxSteps = Number(readOption(argv, i));
+      i += 1;
+      continue;
+    }
+    if (arg === "--allow-shell") {
+      result.allowShellTool = true;
+      continue;
+    }
+    if (arg === "--allow-wrappers") {
+      result.allowWrapperTools = true;
+      continue;
+    }
+    if (arg === "--docker-sandbox") {
+      result.useDockerSandbox = true;
+      result.sandboxMode = result.sandboxMode || "docker-readonly";
+      continue;
+    }
+    if (arg === "--headless") {
+      result.headless = true;
+      continue;
+    }
+    if (arg === "--list-routes") {
+      result.listRoutes = true;
+      continue;
+    }
+    if (arg === "--list-wrappers") {
+      result.listWrappers = true;
+      continue;
+    }
+    if (arg === "--sandbox-status") {
+      result.sandboxStatus = true;
+      continue;
+    }
+    if (arg === "--sandbox-preflight") {
+      result.sandboxPreflight = true;
+      result.useDockerSandbox = true;
+      result.sandboxMode = result.sandboxMode || "docker-readonly";
+      continue;
+    }
+    parts.push(arg);
+  }
+
+  result.goal = parts.join(" ").trim();
+  return result;
+}
+
+function printRoutes() {
+  const presets = getModelPresets();
+  for (const preset of Object.values(presets)) {
+    const reasoning = preset.reasoning ? ` reasoning=${preset.reasoning}` : "";
+    console.log(`${preset.id}: provider=${preset.provider} model=${preset.model}${reasoning} - ${preset.description}`);
+  }
+}
+
+function printWrappers() {
+  for (const wrapper of listAgentWrappers()) {
+    console.log(`${wrapper.name}: ${wrapper.available ? "available" : "missing"} - ${wrapper.role}`);
+  }
+}
+
+export async function main(argv = process.argv.slice(2)) {
+  const args = parseArgs(argv);
+
+  if (args.listRoutes) {
+    printRoutes();
+    return;
+  }
+
+  if (args.listWrappers) {
+    printWrappers();
+    return;
+  }
+
+  if (args.sandboxStatus || args.sandboxPreflight) {
+    const config = loadConfig({ ...args, goal: args.goal || "sandbox preflight" });
+    const result = args.sandboxPreflight
+      ? await runDockerPreflight(config, { buildImage: true })
+      : { ok: true, status: await getDockerSandboxStatus(config) };
+    console.log(JSON.stringify(result, null, 2));
+    return;
+  }
+
+  if (!args.goal && !args.resume) {
+    console.error(
+      'Usage: aginti-cli [--routing smart|fast|complex|manual] [--sandbox-mode host|docker-readonly|docker-workspace] [--package-install-policy block|prompt|allow] [--allow-shell] [--allow-wrappers] [--sandbox-status|--sandbox-preflight] "your task"'
+    );
+    process.exit(1);
+  }
+
+  const config = loadConfig(args);
+  await runAgent(config);
+}

package/src/command-policy.js

@@ -0,0 +1,185 @@
+export const SANDBOX_MODES = ["host", "docker-readonly", "docker-workspace"];
+export const PACKAGE_INSTALL_POLICIES = ["block", "prompt", "allow"];
+
+const READ_ONLY_PATTERNS = [
+  /^pwd$/,
+  /^date$/,
+  /^whoami$/,
+  /^uname(?:\s+-a)?$/,
+  /^ls(?:\s+[-\w./~*]+)*$/,
+  /^find(?:\s+[./~\w-]+)*(?:\s+-maxdepth\s+\d+)?(?:\s+-type\s+[fd])?$/,
+  /^rg(?:\s+.+)?$/,
+  /^cat(?:\s+[-\w./~*]+)+$/,
+  /^head(?:\s+.+)?$/,
+  /^tail(?:\s+.+)?$/,
+  /^wc(?:\s+.+)?$/,
+  /^sed\s+-n\s+['"0-9,:p\s-]+\s+[-\w./~*]+$/,
+  /^git\s+(status|branch|log|show|diff(?:\s+--stat)?|remote\s+-v)(?:\s+.+)?$/,
+  /^node\s+-v$/,
+  /^npm\s+-v$/,
+  /^python(?:3)?\s+--version$/,
+  /^pip(?:3)?\s+--version$/,
+  /^conda\s+--version$/,
+  /^echo(?:\s+.+)?$/,
+];
+
+const TEST_PATTERNS = [
+  /^npm\s+(run\s+)?(check|test|build|lint)(?:\s+--\s+[-\w./:=]+)*$/,
+  /^npm\s+test$/,
+  /^node\s+--check\s+[-\w./]+$/,
+  /^python(?:3)?\s+-m\s+pytest(?:\s+[-\w./:=]+)*$/,
+  /^pytest(?:\s+[-\w./:=]+)*$/,
+];
+
+const PACKAGE_INSTALL_PATTERNS = [
+  /^npm\s+ci$/,
+  /^npm\s+install$/,
+  /^pnpm\s+install$/,
+  /^yarn\s+install$/,
+  /^python(?:3)?\s+-m\s+pip\s+install\s+-r\s+[-\w./]+$/,
+  /^pip(?:3)?\s+install\s+-r\s+[-\w./]+$/,
+  /^conda\s+env\s+(create|update)\s+-f\s+[-\w./]+$/,
+];
+
+const ENV_SETUP_PATTERNS = [
+  /^python(?:3)?\s+-m\s+venv\s+\.venv$/,
+  /^python(?:3)?\s+-m\s+venv\s+venv$/,
+  /^npm\s+init\s+-y$/,
+];
+
+const BLOCKED_SHELL_TOKENS = ["&&", "||", ";", "|", ">", "<", "$(", "`"];
+const BLOCKED_WRITE_TOKENS = [
+  "sudo ",
+  " rm",
+  " mv",
+  " cp",
+  " chmod",
+  " chown",
+  " mkdir",
+  " rmdir",
+  " touch",
+  " tee",
+  "-delete",
+  "git add",
+  "git commit",
+  "git push",
+  "git pull",
+  "git checkout",
+  "git switch",
+  "git reset",
+  "git clean",
+  "curl ",
+  "wget ",
+];
+
+const ALWAYS_BLOCKED_PATTERNS = [
+  /^npm\s+publish\b/i,
+  /^npm\s+token\b/i,
+  /^npm\s+(login|adduser)\b/i,
+  /^npm\s+config\s+set\s+.*(?:_authToken|token)\b/i,
+  /NPM_TOKEN\s*=/i,
+  /_authToken\s*=/i,
+  /OPENAI_API_KEY\s*=/i,
+  /DEEPSEEK_API_KEY\s*=/i,
+];
+
+function normalizePolicy(value, allowed, fallback) {
+  return allowed.includes(value) ? value : fallback;
+}
+
+export function normalizeSandboxMode(value) {
+  return normalizePolicy(value, SANDBOX_MODES, "host");
+}
+
+export function normalizePackageInstallPolicy(value) {
+  return normalizePolicy(value, PACKAGE_INSTALL_POLICIES, "prompt");
+}
+
+function matchAny(patterns, command) {
+  return patterns.some((pattern) => pattern.test(command));
+}
+
+export function classifyCommand(command) {
+  const normalized = String(command || "").trim();
+  if (!normalized) return { category: "blocked", reason: "Command is empty." };
+
+  if (ALWAYS_BLOCKED_PATTERNS.some((pattern) => pattern.test(normalized))) {
+    return { category: "blocked", reason: "Command is blocked because it may expose secrets or publish packages." };
+  }
+
+  const lowered = ` ${normalized.toLowerCase()} `;
+  if (BLOCKED_SHELL_TOKENS.some((part) => normalized.includes(part))) {
+    return { category: "blocked", reason: `Command contains blocked shell syntax: ${normalized}` };
+  }
+  if (BLOCKED_WRITE_TOKENS.some((part) => lowered.includes(part))) {
+    return { category: "blocked", reason: `Command contains a write-capable or network token: ${normalized}` };
+  }
+
+  if (matchAny(READ_ONLY_PATTERNS, normalized)) {
+    return { category: "read-only", needsNetwork: false, writesWorkspace: false };
+  }
+  if (matchAny(TEST_PATTERNS, normalized)) {
+    return { category: "test", needsNetwork: false, writesWorkspace: false };
+  }
+  if (matchAny(PACKAGE_INSTALL_PATTERNS, normalized)) {
+    return { category: "package-install", needsNetwork: true, writesWorkspace: true };
+  }
+  if (matchAny(ENV_SETUP_PATTERNS, normalized)) {
+    return { category: "env-setup", needsNetwork: false, writesWorkspace: true };
+  }
+
+  return { category: "blocked", reason: `Command is outside the execution allowlist: ${normalized}` };
+}
+
+export function evaluateCommandPolicy(command, config) {
+  const classification = classifyCommand(command);
+  const sandboxMode = normalizeSandboxMode(config.sandboxMode);
+  const packageInstallPolicy = normalizePackageInstallPolicy(config.packageInstallPolicy);
+
+  if (classification.category === "blocked") {
+    return { allowed: false, ...classification, sandboxMode, packageInstallPolicy };
+  }
+
+  if (!config.allowShellTool) {
+    return {
+      allowed: false,
+      category: classification.category,
+      reason: "Shell tool is disabled for this run.",
+      sandboxMode,
+      packageInstallPolicy,
+    };
+  }
+
+  if (classification.category === "package-install" || classification.category === "env-setup") {
+    if (packageInstallPolicy !== "allow") {
+      return {
+        allowed: false,
+        category: classification.category,
+        needsApproval: true,
+        reason:
+          packageInstallPolicy === "prompt"
+            ? "Environment setup or package install requires explicit approval in the UI."
+            : "Environment setup and package installs are blocked by policy.",
+        sandboxMode,
+        packageInstallPolicy,
+      };
+    }
+
+    if (sandboxMode !== "docker-workspace") {
+      return {
+        allowed: false,
+        category: classification.category,
+        reason: "Approved package/environment setup must run in Docker workspace-write sandbox mode.",
+        sandboxMode,
+        packageInstallPolicy,
+      };
+    }
+  }
+
+  return {
+    allowed: true,
+    ...classification,
+    sandboxMode,
+    packageInstallPolicy,
+  };
+}

package/src/config.js

@@ -0,0 +1,89 @@
+import path from "node:path";
+import crypto from "node:crypto";
+import { getProviderDefaults, normalizeRoutingMode, selectModelRoute } from "./model-routing.js";
+import { normalizePackageInstallPolicy, normalizeSandboxMode } from "./command-policy.js";
+
+function parseBoolean(value, fallback) {
+  if (value === undefined) return fallback;
+  return String(value).toLowerCase() === "true";
+}
+
+function parseNumber(value, fallback) {
+  const parsed = Number(value);
+  return Number.isFinite(parsed) ? parsed : fallback;
+}
+
+function parseList(value) {
+  if (!value) return [];
+  return String(value)
+    .split(",")
+    .map((item) => item.trim())
+    .filter(Boolean);
+}
+
+export function resolveRuntimeConfig(args, overrides = {}) {
+  const requestedProvider =
+    overrides.provider ||
+    args.provider ||
+    process.env.AGENT_PROVIDER ||
+    (process.env.DEEPSEEK_API_KEY ? "deepseek" : process.env.OPENAI_API_KEY ? "openai" : "deepseek");
+  const routingMode = normalizeRoutingMode(overrides.routingMode || args.routingMode || process.env.AGENT_ROUTING_MODE || "smart");
+  const route = selectModelRoute({
+    routingMode,
+    provider: requestedProvider,
+    model: overrides.model || args.model || process.env.LLM_MODEL || "",
+    goal: args.goal || "",
+  });
+
+  const defaults = getProviderDefaults(route.provider);
+  const baseDir = path.resolve(overrides.baseDir || process.cwd());
+  const dockerRequested = parseBoolean(overrides.useDockerSandbox ?? args.useDockerSandbox ?? process.env.USE_DOCKER_SANDBOX, false);
+  const requestedSandboxMode =
+    overrides.sandboxMode || args.sandboxMode || process.env.SANDBOX_MODE || (dockerRequested ? "docker-readonly" : "host");
+  const sandboxMode = normalizeSandboxMode(requestedSandboxMode);
+
+  return {
+    ...defaults,
+    baseDir,
+    goal: args.goal || "",
+    startUrl: args.startUrl || "",
+    resume: args.resume || "",
+    sessionId: overrides.sessionId || args.sessionId || process.env.SESSION_ID || `web-agent-${crypto.randomUUID()}`,
+    routingMode,
+    routeReason: route.reason,
+    routeComplexityScore: route.complexityScore,
+    requestedProvider,
+    requestedModel: overrides.model || args.model || process.env.LLM_MODEL || "",
+    provider: route.provider,
+    apiKey: overrides.apiKey || defaults.apiKey,
+    baseURL: overrides.baseURL || defaults.baseURL,
+    model: route.model || defaults.model,
+    maxSteps: parseNumber(overrides.maxSteps ?? args.maxSteps ?? process.env.MAX_STEPS, 15),
+    headless: parseBoolean(overrides.headless ?? args.headless ?? process.env.HEADLESS, false),
+    allowedDomains: Array.isArray(overrides.allowedDomains)
+      ? overrides.allowedDomains
+      : parseList(process.env.ALLOWED_DOMAINS),
+    allowPasswords: parseBoolean(overrides.allowPasswords ?? process.env.ALLOW_PASSWORDS, false),
+    allowDestructive: parseBoolean(overrides.allowDestructive ?? process.env.ALLOW_DESTRUCTIVE, false),
+    allowShellTool: parseBoolean(overrides.allowShellTool ?? args.allowShellTool ?? process.env.ALLOW_SHELL_TOOL, false),
+    allowWrapperTools: parseBoolean(
+      overrides.allowWrapperTools ?? args.allowWrapperTools ?? process.env.ALLOW_WRAPPER_TOOLS,
+      false
+    ),
+    wrapperTimeoutMs: parseNumber(overrides.wrapperTimeoutMs ?? process.env.WRAPPER_TIMEOUT_MS, 120000),
+    sandboxMode,
+    packageInstallPolicy: normalizePackageInstallPolicy(
+      overrides.packageInstallPolicy || args.packageInstallPolicy || process.env.PACKAGE_INSTALL_POLICY || "prompt"
+    ),
+    useDockerSandbox: sandboxMode !== "host" || dockerRequested,
+    dockerSandboxImage: overrides.dockerSandboxImage || process.env.DOCKER_SANDBOX_IMAGE || "agintiflow-sandbox:latest",
+    commandCwd: path.resolve(overrides.commandCwd || args.commandCwd || process.env.COMMAND_CWD || process.cwd()),
+    sessionsDir: path.resolve(baseDir, ".sessions"),
+    onLog: overrides.onLog,
+    onEvent: overrides.onEvent,
+  };
+}
+
+export function loadConfig(args) {
+  return resolveRuntimeConfig(args);
+}