@harness.farm/clawfirm 0.1.0

package/bin/cli.js

@@ -0,0 +1,105 @@
+#!/usr/bin/env node
+import { createRequire } from "node:module";
+import { fileURLToPath } from "node:url";
+import { resolve, dirname } from "node:path";
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+
+async function loadConfig() {
+  const configPath = resolve(__dirname, "../clawfirm.config.js");
+  const { default: config } = await import(configPath);
+  return config;
+}
+
+function printHelp(config) {
+  console.log(`
+  clawfirm — dev tool manager
+
+  Usage:
+    clawfirm login             Log in to clawfirm.dev
+    clawfirm whoami            Show current session
+    clawfirm logout            Log out
+    clawfirm new "<description>"  Start a project from natural language
+    clawfirm install [tool]    Install all tools (or a specific one)
+    clawfirm uninstall [tool]  Uninstall all tools (or a specific one)
+    clawfirm list              List registered tools
+    clawfirm <name> [args]     Dispatch to clawfirm-<name>
+    clawfirm help              Show this message
+
+  Tools in registry:
+${config.tools.map((t) => `    ${t.name.padEnd(14)} ${t.description}`).join("\n")}
+`);
+}
+
+function printList(config) {
+  console.log(`\n  Registered tools:\n`);
+  for (const t of config.tools) {
+    console.log(`    ${t.name.padEnd(14)} ${t.description}`);
+    console.log(`    ${"".padEnd(14)} ${t.homepage}\n`);
+  }
+}
+
+async function main() {
+  const [, , command, ...rest] = process.argv;
+
+  const config = await loadConfig();
+
+  if (!command || command === "help" || command === "--help" || command === "-h") {
+    printHelp(config);
+    return;
+  }
+
+  if (command === "list") {
+    printList(config);
+    return;
+  }
+
+  if (command === "login") {
+    const { runLogin } = await import("../lib/login.js");
+    await runLogin();
+    return;
+  }
+
+  if (command === "whoami") {
+    const { runWhoami } = await import("../lib/login.js");
+    await runWhoami();
+    return;
+  }
+
+  if (command === "logout") {
+    const { runLogout } = await import("../lib/login.js");
+    await runLogout();
+    return;
+  }
+
+  // Commands below require a valid license
+  const { checkLicense } = await import("../lib/auth.js");
+  checkLicense();
+
+  if (command === "new") {
+    const { runNew } = await import("../lib/new.js");
+    await runNew(rest.join(" "));
+    return;
+  }
+
+  if (command === "install") {
+    const { runInstall } = await import("../lib/install.js");
+    await runInstall(config, rest[0]);
+    return;
+  }
+
+  if (command === "uninstall") {
+    const { runUninstall } = await import("../lib/install.js");
+    await runUninstall(config, rest[0]);
+    return;
+  }
+
+  // Plugin dispatch: clawfirm <name> → clawfirm-<name>
+  const { dispatch } = await import("../lib/dispatch.js");
+  dispatch(command, rest);
+}
+
+main().catch((err) => {
+  console.error(err.message);
+  process.exit(1);
+});

package/clawfirm.config.js

@@ -0,0 +1,44 @@
+/**
+ * clawfirm tool registry
+ * Each tool needs: name, install command, and the binary it provides.
+ */
+export default {
+  tools: [
+    {
+      name: "openvault",
+      description: "Encrypted local secret manager",
+      requires: "go",
+      install: "go install github.com/npc-live/openvault@latest",
+      uninstall: "rm -f $(which openvault)",
+      check: "openvault",
+      homepage: "https://openvault.sh",
+    },
+    {
+      name: "skillctl",
+      description: "Sync AI skills across coding tools",
+      requires: "npm",
+      install: "npm install -g @harness.farm/skillctl",
+      uninstall: "npm uninstall -g @harness.farm/skillctl",
+      check: "skillctl",
+      homepage: "https://skillctl.dev",
+    },
+    {
+      name: "whipflow",
+      description: "Deterministic AI workflow runner",
+      requires: "npm",
+      install: "npm install -g @harness.farm/whipflow",
+      uninstall: "npm uninstall -g @harness.farm/whipflow",
+      check: "whipflow",
+      homepage: "https://whipflow.dev",
+    },
+    {
+      name: "agent-browser",
+      description: "Browser automation for AI agents",
+      requires: "npm",
+      install: "npm install -g agent-browser",
+      uninstall: "npm uninstall -g agent-browser",
+      check: "agent-browser",
+      homepage: "https://www.npmjs.com/package/agent-browser",
+    },
+  ],
+};

package/lib/auth.js

@@ -0,0 +1,59 @@
+import { readFileSync, writeFileSync, mkdirSync, existsSync, unlinkSync } from "node:fs";
+import { homedir } from "node:os";
+import { join } from "node:path";
+
+const CONFIG_DIR = join(homedir(), ".clawfirm");
+const SESSION_FILE = join(CONFIG_DIR, "session.json");
+
+export const BASE_URL = "https://clawfirm.dev";
+
+function ensureDir() {
+  if (!existsSync(CONFIG_DIR)) mkdirSync(CONFIG_DIR, { recursive: true });
+}
+
+export function saveSession(data) {
+  ensureDir();
+  writeFileSync(SESSION_FILE, JSON.stringify(data, null, 2), { mode: 0o600 });
+}
+
+export function loadSession() {
+  if (!existsSync(SESSION_FILE)) return null;
+  try {
+    return JSON.parse(readFileSync(SESSION_FILE, "utf8"));
+  } catch {
+    return null;
+  }
+}
+
+export function clearSession() {
+  if (existsSync(SESSION_FILE)) unlinkSync(SESSION_FILE);
+}
+
+export function requireSession() {
+  const session = loadSession();
+  if (!session) {
+    console.error("\n  Not logged in. Run: clawfirm login\n");
+    process.exit(1);
+  }
+  return session;
+}
+
+export function checkLicense() {
+  const session = loadSession();
+
+  if (!session) {
+    console.error("\n  Not logged in. Run: clawfirm login\n");
+    process.exit(1);
+  }
+
+  if (!session.unlocked || !session.unlockedUntil) {
+    console.error("\n  Account not activated. Visit https://clawfirm.dev\n");
+    process.exit(1);
+  }
+
+  const expiry = new Date(session.unlockedUntil);
+  if (isNaN(expiry.getTime()) || expiry < new Date()) {
+    console.error(`\n  License expired (${session.unlockedUntil}). Visit https://clawfirm.dev to renew.\n`);
+    process.exit(1);
+  }
+}

package/lib/dispatch.js

@@ -0,0 +1,13 @@
+import { spawnSync } from "node:child_process";
+
+export function dispatch(name, args) {
+  const cmd = `clawfirm-${name}`;
+  const result = spawnSync(cmd, args, { stdio: "inherit" });
+
+  if (result.error?.code === "ENOENT") {
+    console.error(`\n  clawfirm: '${name}' not found (tried: ${cmd})\n`);
+    process.exit(127);
+  }
+
+  process.exit(result.status ?? 0);
+}

package/lib/install.js

@@ -0,0 +1,134 @@
+import { execSync, spawnSync } from "node:child_process";
+
+const GREEN = "\x1b[32m";
+const YELLOW = "\x1b[33m";
+const RED = "\x1b[31m";
+const BLUE = "\x1b[34m";
+const DIM = "\x1b[2m";
+const NC = "\x1b[0m";
+
+const ok = (msg) => console.log(`${GREEN}  ✓${NC}  ${msg}`);
+const info = (msg) => console.log(`${BLUE}  →${NC}  ${msg}`);
+const warn = (msg) => console.log(`${YELLOW}  !${NC}  ${msg}`);
+const fail = (msg) => console.log(`${RED}  ✗${NC}  ${msg}`);
+
+function isInstalled(cmd) {
+  const result = spawnSync("which", [cmd], { encoding: "utf8" });
+  return result.status === 0;
+}
+
+function hasRequirement(req) {
+  return isInstalled(req);
+}
+
+function installTool(tool) {
+  info(`Installing ${tool.name}${DIM} — ${tool.description}${NC}`);
+
+  if (!hasRequirement(tool.requires)) {
+    fail(`${tool.name}: requires '${tool.requires}' but it's not installed`);
+    return false;
+  }
+
+  try {
+    execSync(tool.install, { stdio: "inherit" });
+    ok(`${tool.name} updated`);
+    return true;
+  } catch {
+    fail(`${tool.name}: install failed`);
+    return false;
+  }
+}
+
+function uninstallTool(tool) {
+  info(`Uninstalling ${tool.name}${DIM} — ${tool.description}${NC}`);
+
+  if (!isInstalled(tool.check)) {
+    ok(`${tool.name} not installed, skipping`);
+    return true;
+  }
+
+  if (!tool.uninstall) {
+    fail(`${tool.name}: no uninstall command defined`);
+    return false;
+  }
+
+  try {
+    execSync(tool.uninstall, { stdio: "inherit", shell: true });
+    ok(`${tool.name} uninstalled`);
+    return true;
+  } catch {
+    fail(`${tool.name}: uninstall failed`);
+    return false;
+  }
+}
+
+export async function runUninstall(config, target) {
+  const tools = target
+    ? config.tools.filter((t) => t.name === target)
+    : config.tools;
+
+  if (target && tools.length === 0) {
+    fail(`Unknown tool: ${target}`);
+    console.log(
+      `\n  Available: ${config.tools.map((t) => t.name).join(", ")}\n`
+    );
+    process.exit(1);
+  }
+
+  console.log(`\n  clawfirm uninstall\n`);
+
+  const failed = [];
+  for (const tool of tools) {
+    const success = uninstallTool(tool);
+    if (!success) failed.push(tool.name);
+    console.log();
+  }
+
+  if (failed.length > 0) {
+    warn(`Failed: ${failed.join(", ")}`);
+    process.exit(1);
+  }
+
+  console.log(`  Done.\n`);
+}
+
+export async function runInstall(config, target) {
+  const tools = target
+    ? config.tools.filter((t) => t.name === target)
+    : config.tools;
+
+  if (target && tools.length === 0) {
+    fail(`Unknown tool: ${target}`);
+    console.log(
+      `\n  Available: ${config.tools.map((t) => t.name).join(", ")}\n`
+    );
+    process.exit(1);
+  }
+
+  console.log(`\n  clawfirm install\n`);
+
+  const failed = [];
+  for (const tool of tools) {
+    const ok = installTool(tool);
+    if (!ok) failed.push(tool.name);
+    console.log();
+  }
+
+  if (failed.length > 0) {
+    warn(`Failed: ${failed.join(", ")}`);
+    process.exit(1);
+  }
+
+  // Download encrypted skills (stored as .enc, not yet decrypted)
+  if (!target) {
+    const { loadSession } = await import("./auth.js");
+    const { installSkills } = await import("./skills.js");
+    const session = loadSession();
+    if (session) {
+      await installSkills(session);
+      console.log();
+    }
+  }
+
+  console.log(`  All tools ready.\n`);
+}

package/lib/login.js

@@ -0,0 +1,138 @@
+import { createInterface } from "node:readline";
+import { BASE_URL, saveSession, clearSession, loadSession } from "./auth.js";
+
+const GREEN = "\x1b[32m";
+const YELLOW = "\x1b[33m";
+const RED = "\x1b[31m";
+const BLUE = "\x1b[34m";
+const DIM = "\x1b[2m";
+const NC = "\x1b[0m";
+
+const ok = (msg) => console.log(`${GREEN}  ✓${NC}  ${msg}`);
+const info = (msg) => console.log(`${BLUE}  →${NC}  ${msg}`);
+const fail = (msg) => console.log(`${RED}  ✗${NC}  ${msg}`);
+
+function ask(question) {
+  const rl = createInterface({ input: process.stdin, output: process.stdout });
+  return new Promise((resolve) => {
+    rl.question(question, (ans) => { rl.close(); resolve(ans.trim()); });
+  });
+}
+
+function askPassword(question) {
+  return new Promise((resolve) => {
+    process.stdout.write(question);
+    let password = "";
+
+    if (process.stdin.isTTY) process.stdin.setRawMode(true);
+    process.stdin.resume();
+    process.stdin.setEncoding("utf8");
+
+    function onData(char) {
+      if (char === "\n" || char === "\r" || char === "\u0004") {
+        if (process.stdin.isTTY) process.stdin.setRawMode(false);
+        process.stdin.pause();
+        process.stdin.removeListener("data", onData);
+        process.stdout.write("\n");
+        resolve(password);
+      } else if (char === "\u0003") {
+        process.exit();
+      } else if (char === "\u007f" || char === "\b") {
+        password = password.slice(0, -1);
+      } else {
+        password += char;
+      }
+    }
+
+    process.stdin.on("data", onData);
+  });
+}
+
+async function fetchMe(cookie) {
+  const res = await fetch(`${BASE_URL}/api/auth/me`, {
+    headers: { Cookie: cookie },
+  });
+  if (!res.ok) return null;
+  return res.json();
+}
+
+export async function runLogin() {
+  console.log(`\n  clawfirm login\n`);
+
+  const email = await ask("  Email: ");
+  const password = await askPassword("  Password: ");
+
+  info("Signing in...");
+
+  let res;
+  try {
+    res = await fetch(`${BASE_URL}/api/auth/login`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ email, password }),
+    });
+  } catch (e) {
+    fail(`Network error: ${e.message}`);
+    process.exit(1);
+  }
+
+  if (!res.ok) {
+    const body = await res.json().catch(() => ({}));
+    fail(`Login failed: ${body.error ?? res.statusText}`);
+    process.exit(1);
+  }
+
+  // Extract session cookie from Set-Cookie header
+  const setCookie = res.headers.get("set-cookie");
+  if (!setCookie) {
+    fail("No session cookie returned");
+    process.exit(1);
+  }
+  const cookie = setCookie.split(";")[0];
+
+  // Fetch user info
+  const me = await fetchMe(cookie);
+  if (!me) {
+    fail("Could not verify session");
+    process.exit(1);
+  }
+
+  saveSession({
+    cookie,
+    email: me.email,
+    unlocked: me.unlocked ?? false,
+    unlockedUntil: me.unlockedUntil ?? null,
+  });
+
+  ok(`Logged in as ${me.email}`);
+  if (me.unlocked && me.unlockedUntil) {
+    ok(`Active until ${me.unlockedUntil}`);
+  } else {
+    console.log(`\n  ${YELLOW}Account not activated.${NC}\n`);
+  }
+  console.log();
+}
+
+export async function runWhoami() {
+  const session = loadSession();
+  if (!session) {
+    console.log(`\n  Not logged in.\n`);
+    return;
+  }
+
+  console.log(`\n  ${session.email}`);
+  if (session.unlocked && session.unlockedUntil) {
+    console.log(`  Active until: ${GREEN}${session.unlockedUntil}${NC}`);
+  } else {
+    console.log(`  Activated: ${YELLOW}no${NC}`);
+  }
+  console.log();
+}
+
+export async function runLogout() {
+  const { removeSkills } = await import("./skills.js");
+  removeSkills();
+  clearSession();
+  ok("Logged out");
+  console.log();
+}

package/lib/new.js

@@ -0,0 +1,117 @@
+import { spawnSync } from "node:child_process";
+import { writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { cwd } from "node:process";
+import { BASE_URL, requireSession } from "./auth.js";
+
+const POLL_INTERVAL = 3000;
+
+export async function runNew(description) {
+  if (!description) {
+    console.error("\n  Usage: clawfirm new \"<project description>\"\n");
+    process.exit(1);
+  }
+
+  const session = requireSession();
+  const headers = { "Content-Type": "application/json", Cookie: session.cookie };
+
+  // Step 1: submit job
+  let jobId;
+  try {
+    const res = await fetch(`${BASE_URL}/api/generate-whip`, {
+      method: "POST",
+      headers,
+      body: JSON.stringify({ description, save: false }),
+    });
+
+    const body = await res.json().catch(() => ({}));
+
+    if (res.status === 401) {
+      console.error("\n  Session expired. Run: clawfirm login\n");
+      process.exit(1);
+    }
+    if (res.status === 402 || res.status === 403) {
+      console.error(`\n  ${body.error ?? "Access denied. Visit https://clawfirm.dev"}\n`);
+      process.exit(1);
+    }
+    if (!res.ok) {
+      console.error(`\n  API error: ${body.error ?? res.statusText}\n`);
+      process.exit(1);
+    }
+
+    jobId = body.jobId;
+  } catch (e) {
+    console.error(`\n  Network error: ${e.message}\n`);
+    process.exit(1);
+  }
+
+  // Step 2: poll until done
+  const startTime = Date.now();
+  let whipContent, whipKey;
+
+  while (true) {
+    const elapsed = ((Date.now() - startTime) / 1000).toFixed(0);
+    process.stdout.write(`\r  Generating... ${elapsed}s `);
+
+    await new Promise(r => setTimeout(r, POLL_INTERVAL));
+
+    let poll;
+    try {
+      const res = await fetch(`${BASE_URL}/api/generate-whip?job=${jobId}`, { headers });
+      poll = await res.json().catch(() => ({}));
+
+      if (res.status === 401) {
+        process.stdout.write("\r                    \r");
+        console.error("\n  Session expired. Run: clawfirm login\n");
+        process.exit(1);
+      }
+      if (!res.ok) {
+        process.stdout.write("\r                    \r");
+        console.error(`\n  API error: ${poll.error ?? res.statusText}\n`);
+        process.exit(1);
+      }
+    } catch (e) {
+      process.stdout.write("\r                    \r");
+      console.error(`\n  Network error: ${e.message}\n`);
+      process.exit(1);
+    }
+
+    if (poll.status === "completed") {
+      whipKey = poll.key ?? `${jobId}/workflow-${Date.now()}.whip`;
+      if (poll.whip) {
+        whipContent = poll.whip;
+      } else {
+        // content delivered separately via /api/whips/{jobId}/{filename}
+        const dlRes = await fetch(`${BASE_URL}/api/whips/${whipKey}`, { headers });
+        whipContent = await dlRes.text();
+        if (!dlRes.ok || !whipContent) {
+          process.stdout.write("\r                    \r");
+          console.error(`\n  Could not fetch whip content (${dlRes.status}): ${whipContent}\n`);
+          process.exit(1);
+        }
+      }
+      break;
+    }
+    if (poll.status === "error") {
+      process.stdout.write("\r                    \r");
+      console.error(`\n  Generation failed: ${poll.error ?? "unknown error"}\n`);
+      process.exit(1);
+    }
+    // status === "pending" | "running" → keep polling
+  }
+
+  process.stdout.write("\r                    \r");
+
+  const whipFile = join(cwd(), whipKey.split("/").pop());
+  writeFileSync(whipFile, whipContent, "utf8");
+  console.log(`  Saved: ${whipFile}\n`);
+
+  const result = spawnSync("whipflow", ["run", whipFile], { stdio: "inherit" });
+
+  if (result.error?.code === "ENOENT") {
+    console.error("\n  whipflow not found. Run: clawfirm install\n");
+    process.exit(1);
+  }
+
+  process.exit(result.status ?? 0);
+}

package/lib/skills.js

@@ -0,0 +1,49 @@
+import { writeFileSync, mkdirSync, existsSync, readdirSync, unlinkSync } from "node:fs";
+import { homedir } from "node:os";
+import { join } from "node:path";
+import { BASE_URL } from "./auth.js";
+
+const SKILLS_DIR = join(homedir(), ".skillctl", "skills");
+
+const GREEN = "\x1b[32m";
+const BLUE = "\x1b[34m";
+const RED = "\x1b[31m";
+const NC = "\x1b[0m";
+
+const ok = (msg) => console.log(`${GREEN}  ✓${NC}  ${msg}`);
+const info = (msg) => console.log(`${BLUE}  →${NC}  ${msg}`);
+const fail = (msg) => console.log(`${RED}  ✗${NC}  ${msg}`);
+
+export async function installSkills(session) {
+  info("Fetching skills...");
+
+  let skills;
+  try {
+    const res = await fetch(`${BASE_URL}/api/skills`, {
+      headers: { Cookie: session.cookie },
+    });
+    if (!res.ok) {
+      if (res.status !== 404) fail(`Failed to fetch skills: ${res.statusText}`);
+      return false;
+    }
+    skills = await res.json(); // [{ name: string, content: string }]
+  } catch (e) {
+    fail(`Network error: ${e.message}`);
+    return false;
+  }
+
+  if (!existsSync(SKILLS_DIR)) mkdirSync(SKILLS_DIR, { recursive: true });
+
+  for (const skill of skills) {
+    writeFileSync(join(SKILLS_DIR, `${skill.name}.md`), skill.content);
+  }
+
+  ok(`${skills.length} skill(s) installed`);
+  return true;
+}
+
+export function removeSkills() {
+  if (!existsSync(SKILLS_DIR)) return;
+  const files = readdirSync(SKILLS_DIR).filter((f) => f.endsWith(".md"));
+  for (const f of files) unlinkSync(join(SKILLS_DIR, f));
+}

package/package.json

@@ -0,0 +1,34 @@
+{
+  "name": "@harness.farm/clawfirm",
+  "version": "0.1.0",
+  "description": "clawfirm 7*24 weather prediction market trading engine",
+  "type": "module",
+  "bin": {
+    "clawfirm": "./bin/cli.js"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "files": [
+    "bin",
+    "lib",
+    "src/core",
+    "clawfirm.config.js"
+  ],
+  "scripts": {
+    "trade": "tsx src/core/index.ts",
+    "trade:dry": "DRY_RUN=true tsx src/core/index.ts",
+    "typecheck": "tsc --noEmit --project tsconfig.core.json"
+  },
+  "engines": {
+    "node": ">=18"
+  },
+  "dependencies": {
+    "viem": "^2.21.0"
+  },
+  "devDependencies": {
+    "@types/node": "^20.0.0",
+    "tsx": "^4.7.0",
+    "typescript": "^5.4.0"
+  }
+}