agent-factorio 0.2.0

package/README.md

@@ -0,0 +1,72 @@
+# agent-factorio
+
+CLI for [AgentFactorio](https://github.com/your-org/agent-factorio) — AI Agent Fleet Management hub.
+
+Register and manage your AI agents from any project.
+
+## Install
+
+```bash
+npm install -g agent-factorio
+```
+
+Or use directly with `npx`:
+
+```bash
+npx agent-factorio <command>
+```
+
+## Commands
+
+### `agent-factorio login`
+
+Connect to an AgentFactorio hub and join an organization.
+
+```bash
+npx agent-factorio login
+```
+
+Prompts for hub URL and email, then lets you create or join an organization via invite code.
+
+### `agent-factorio push`
+
+Detect and push agent configuration to the hub.
+
+```bash
+npx agent-factorio push
+```
+
+Auto-detects git repo, CLAUDE.md, MCP servers, skills, and plugins from the current project directory.
+
+### `agent-factorio status`
+
+Show registration status for the current project.
+
+```bash
+npx agent-factorio status
+```
+
+### `agent-factorio whoami`
+
+Show login info (hub URL, organizations).
+
+```bash
+npx agent-factorio whoami
+```
+
+### `agent-factorio logout`
+
+Remove global config and log out.
+
+```bash
+npx agent-factorio logout
+```
+
+## Configuration
+
+- Global config: `~/.agent-factorio/config.json` (hub URL, member ID, organizations)
+- Project config: `.agent-factorio/config.json` (agent ID, hub URL — gitignored)
+
+## Requirements
+
+- Node.js >= 18

package/bin.js

@@ -0,0 +1,65 @@
+#!/usr/bin/env node
+
+/**
+ * AgentFactorio CLI — register and manage agents from any project
+ *
+ * Usage:
+ *   npx agent-factorio login     # Connect to hub + join organization
+ *   npx agent-factorio push      # Push agent config to hub
+ *   npx agent-factorio status    # Show registration status
+ *   npx agent-factorio whoami    # Show login info
+ *   npx agent-factorio logout    # Remove global config
+ */
+
+import { readFileSync } from "fs";
+import { fileURLToPath } from "url";
+import { dirname, join } from "path";
+import { Command } from "commander";
+import { loginCommand } from "./commands/login.mjs";
+import { pushCommand } from "./commands/push.mjs";
+import { statusCommand } from "./commands/status.mjs";
+import { whoamiCommand } from "./commands/whoami.mjs";
+import { logoutCommand } from "./commands/logout.mjs";
+import { connectCommand } from "./commands/connect.mjs";
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const pkg = JSON.parse(readFileSync(join(__dirname, "package.json"), "utf-8"));
+
+const program = new Command();
+
+program
+  .name("agent-factorio")
+  .description("AgentFactorio CLI — AI Agent Fleet Management")
+  .version(pkg.version);
+
+program
+  .command("login")
+  .description("Connect to an AgentFactorio hub and join an organization")
+  .action(loginCommand);
+
+program
+  .command("push")
+  .description("Detect and push agent configuration to the hub")
+  .action(pushCommand);
+
+program
+  .command("status")
+  .description("Show registration status for the current project")
+  .action(statusCommand);
+
+program
+  .command("whoami")
+  .description("Show login info (hub URL, organizations)")
+  .action(whoamiCommand);
+
+program
+  .command("logout")
+  .description("Remove global config and log out")
+  .action(logoutCommand);
+
+program
+  .command("connect")
+  .description("Poll hub and relay messages to local OpenClaw Gateway")
+  .action(connectCommand);
+
+program.parse();

package/commands/connect.mjs

@@ -0,0 +1,163 @@
+/**
+ * agent-factorio connect — Poll hub for messages, relay to local OpenClaw Gateway
+ */
+import { readLocalConfig, findProjectRoot } from "../lib/config.mjs";
+import { success, error, info, label, heading } from "../lib/log.mjs";
+
+const POLL_INTERVAL_MS = 2000;
+const LOCAL_GATEWAY_URL = "http://localhost:18789";
+
+export async function connectCommand() {
+  const projectRoot = findProjectRoot();
+  const localConfig = readLocalConfig(projectRoot);
+
+  if (!localConfig?.agentId || !localConfig?.hubUrl || !localConfig?.pollToken) {
+    error(
+      "Missing agentId, hubUrl, or pollToken in .agent-factorio/config.json.\n" +
+      "Run `agent-factorio push` with runtimeType=openclaw first."
+    );
+    process.exit(1);
+  }
+
+  const { agentId, hubUrl, pollToken, agentName } = localConfig;
+  const pollUrl = `${hubUrl}/api/agents/${agentId}/poll`;
+  const respondUrl = `${hubUrl}/api/agents/${agentId}/respond`;
+  const headers = {
+    Authorization: `Bearer ${pollToken}`,
+    "Content-Type": "application/json",
+  };
+
+  heading("AgentFactorio Connector");
+  label("Agent", agentName || agentId);
+  label("Hub", hubUrl);
+  label("Gateway", LOCAL_GATEWAY_URL);
+  info(`Polling every ${POLL_INTERVAL_MS / 1000}s... (Ctrl+C to stop)\n`);
+
+  // Graceful shutdown
+  let running = true;
+  process.on("SIGINT", () => {
+    running = false;
+    info("\nShutting down connector...");
+    process.exit(0);
+  });
+
+  while (running) {
+    try {
+      // 1. Poll for pending messages
+      const pollRes = await fetch(pollUrl, { headers });
+      if (!pollRes.ok) {
+        const errText = await pollRes.text().catch(() => "");
+        error(`Poll failed (${pollRes.status}): ${errText}`);
+        await sleep(POLL_INTERVAL_MS);
+        continue;
+      }
+
+      const { items } = await pollRes.json();
+
+      if (!items || items.length === 0) {
+        await sleep(POLL_INTERVAL_MS);
+        continue;
+      }
+
+      // 2. Process each item
+      for (const item of items) {
+        info(`Received message: "${item.message.slice(0, 60)}${item.message.length > 60 ? "..." : ""}"`);
+
+        try {
+          // 3. Forward to local OpenClaw Gateway
+          const gwRes = await fetch(`${LOCAL_GATEWAY_URL}/api/message`, {
+            method: "POST",
+            headers: { "Content-Type": "application/json" },
+            body: JSON.stringify({
+              message: item.message,
+              history: item.history,
+            }),
+          });
+
+          if (!gwRes.ok) {
+            const errText = await gwRes.text().catch(() => "Gateway error");
+            error(`Gateway returned ${gwRes.status}: ${errText}`);
+
+            // Report failure back to hub
+            await fetch(respondUrl, {
+              method: "POST",
+              headers,
+              body: JSON.stringify({
+                queueItemId: item.queueItemId,
+                content: `[Error] Gateway returned ${gwRes.status}: ${errText}`,
+              }),
+            });
+            continue;
+          }
+
+          // Collect response — handle both SSE and plain JSON
+          let responseText = "";
+          const contentType = gwRes.headers.get("content-type") || "";
+
+          if (contentType.includes("text/event-stream") && gwRes.body) {
+            // Parse SSE stream
+            const reader = gwRes.body.getReader();
+            const decoder = new TextDecoder();
+            while (true) {
+              const { done, value } = await reader.read();
+              if (done) break;
+              const chunk = decoder.decode(value, { stream: true });
+              const lines = chunk.split("\n");
+              for (const line of lines) {
+                if (line.startsWith("data: ")) {
+                  try {
+                    const parsed = JSON.parse(line.slice(6));
+                    const text = parsed.text ?? parsed.content ?? "";
+                    if (text) responseText += text;
+                  } catch {
+                    responseText += line.slice(6);
+                  }
+                }
+              }
+            }
+          } else {
+            // Plain JSON response
+            const data = await gwRes.json().catch(() => null);
+            responseText = data?.content ?? data?.text ?? data?.message ?? JSON.stringify(data);
+          }
+
+          // 4. Send response back to hub
+          const respondRes = await fetch(respondUrl, {
+            method: "POST",
+            headers,
+            body: JSON.stringify({
+              queueItemId: item.queueItemId,
+              content: responseText,
+            }),
+          });
+
+          if (respondRes.ok) {
+            success(`Response sent (${responseText.length} chars)`);
+          } else {
+            const errText = await respondRes.text().catch(() => "");
+            error(`Failed to send response: ${errText}`);
+          }
+        } catch (gwErr) {
+          error(`Gateway error: ${gwErr.message}`);
+          // Report failure
+          await fetch(respondUrl, {
+            method: "POST",
+            headers,
+            body: JSON.stringify({
+              queueItemId: item.queueItemId,
+              content: `[Error] ${gwErr.message}`,
+            }),
+          }).catch(() => {});
+        }
+      }
+    } catch (pollErr) {
+      error(`Poll error: ${pollErr.message}`);
+    }
+
+    await sleep(POLL_INTERVAL_MS);
+  }
+}
+
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}

package/commands/login.mjs

@@ -0,0 +1,153 @@
+/**
+ * agent-factorio login — Connect to hub + join organization (with email verification)
+ */
+import { ask, choose } from "../lib/prompt.mjs";
+import { readGlobalConfig, upsertOrg } from "../lib/config.mjs";
+import { apiCall, checkHub } from "../lib/api.mjs";
+import { success, error, info, dim } from "../lib/log.mjs";
+
+/**
+ * Poll verification status until verified or expired
+ * @param {string} hubUrl
+ * @param {string} loginToken
+ * @returns {Promise<{ userId: string, email: string }>}
+ */
+async function waitForVerification(hubUrl, loginToken) {
+  const POLL_INTERVAL = 2000; // 2 seconds
+  const MAX_WAIT = 10 * 60 * 1000; // 10 minutes
+  const start = Date.now();
+
+  while (Date.now() - start < MAX_WAIT) {
+    const res = await apiCall(hubUrl, "/api/cli/login", {
+      body: { action: "check-verification", loginToken },
+    });
+
+    if (res.status === 410) {
+      throw new Error("Verification link expired. Please try again.");
+    }
+
+    if (!res.ok) {
+      throw new Error(res.data?.error || "Verification check failed.");
+    }
+
+    if (res.data.verified) {
+      return { userId: res.data.userId, email: res.data.email };
+    }
+
+    // Wait before next poll
+    await new Promise((resolve) => setTimeout(resolve, POLL_INTERVAL));
+  }
+
+  throw new Error("Verification timed out. Please try again.");
+}
+
+export async function loginCommand() {
+  const existing = readGlobalConfig();
+  const defaultUrl = existing?.organizations?.[0]?.hubUrl || "";
+
+  // 1. Hub URL
+  const hubUrl = await ask("AgentFactorio Hub URL", defaultUrl || "http://localhost:3000");
+  if (!hubUrl) {
+    error("Hub URL is required.");
+    process.exit(1);
+  }
+
+  // Check connectivity
+  const reachable = await checkHub(hubUrl);
+  if (!reachable) {
+    error(`Cannot connect to ${hubUrl}. Is the hub running?`);
+    process.exit(1);
+  }
+  success("Hub connected.");
+
+  // 2. Email input
+  const email = await ask("Your email (used as your identifier)");
+  if (!email) {
+    error("Email is required.");
+    process.exit(1);
+  }
+
+  // 3. Send verification email
+  info("Sending verification email...");
+  const sendRes = await apiCall(hubUrl, "/api/cli/login", {
+    body: { action: "send-verification", email },
+  });
+
+  if (!sendRes.ok) {
+    error(`Failed to send verification email: ${sendRes.data?.error || "Unknown error"}`);
+    process.exit(1);
+  }
+
+  const { loginToken } = sendRes.data;
+  success("Verification email sent!");
+  info("Check your inbox and click the verification link.");
+  dim("Waiting for verification...");
+
+  // 4. Poll for verification
+  let userId;
+  try {
+    const result = await waitForVerification(hubUrl, loginToken);
+    userId = result.userId;
+  } catch (err) {
+    error(err.message);
+    process.exit(1);
+  }
+
+  success("Email verified!");
+
+  // 5. Name input
+  const memberName = await ask("Your name (displayed in the org)", "CLI User");
+
+  // 6. Create or Join
+  const { index: actionIdx } = await choose("Create or join an organization?", [
+    "Join existing (invite code)",
+    "Create new",
+  ]);
+
+  if (actionIdx === 1) {
+    // Create new org
+    const orgName = await ask("Organization name");
+    if (!orgName) {
+      error("Organization name is required.");
+      process.exit(1);
+    }
+
+    const res = await apiCall(hubUrl, "/api/cli/login", {
+      body: { action: "create", orgName, memberName, email, userId },
+    });
+
+    if (!res.ok) {
+      error(`Failed to create organization: ${res.data?.error || "Unknown error"}`);
+      process.exit(1);
+    }
+
+    const { orgId, orgName: name, inviteCode, memberId } = res.data;
+    upsertOrg({ hubUrl, orgId, orgName: name, inviteCode, memberName, email, memberId, userId });
+
+    success(`Created "${name}" (${orgId})`);
+    info(`Invite code: ${inviteCode} — share with your team!`);
+  } else {
+    // Join existing
+    const inviteCode = await ask("Invite code");
+    if (!inviteCode) {
+      error("Invite code is required.");
+      process.exit(1);
+    }
+
+    const res = await apiCall(hubUrl, "/api/cli/login", {
+      body: { action: "join", inviteCode, memberName, email, userId },
+    });
+
+    if (!res.ok) {
+      error(`Failed to join: ${res.data?.error || "Invalid invite code"}`);
+      process.exit(1);
+    }
+
+    const { orgId, orgName, memberId } = res.data;
+    upsertOrg({ hubUrl, orgId, orgName, inviteCode: inviteCode.toUpperCase(), memberName, email, memberId, userId });
+
+    success(`Joined "${orgName}" (${orgId})`);
+  }
+
+  console.log("\nLogged in! Run `agent-factorio push` in any project to register an agent.");
+}

package/commands/logout.mjs

@@ -0,0 +1,18 @@
+/**
+ * agent-factorio logout — Delete global config
+ */
+import { deleteGlobalConfig, GLOBAL_CONFIG } from "../lib/config.mjs";
+import { success, warn } from "../lib/log.mjs";
+import * as fs from "fs";
+
+export async function logoutCommand() {
+  try {
+    fs.accessSync(GLOBAL_CONFIG);
+  } catch {
+    warn("Not logged in.");
+    return;
+  }
+
+  deleteGlobalConfig();
+  success("Logged out. Global config removed.");
+}

package/commands/push.mjs

@@ -0,0 +1,144 @@
+/**
+ * agent-factorio push — Detect and push agent config to hub
+ */
+import * as path from "path";
+import { ask, choose } from "../lib/prompt.mjs";
+import { getDefaultOrg, readLocalConfig, writeLocalConfig, findProjectRoot } from "../lib/config.mjs";
+import { apiCall } from "../lib/api.mjs";
+import { detectAll } from "../lib/detect.mjs";
+import { success, error, info, label, heading } from "../lib/log.mjs";
+
+export async function pushCommand() {
+  // 1. Check login
+  const org = getDefaultOrg();
+  if (!org) {
+    error("Not logged in. Run `agent-factorio login` first.");
+    process.exit(1);
+  }
+
+  const projectRoot = findProjectRoot();
+  const localConfig = readLocalConfig(projectRoot);
+
+  // 2. Auto-detect
+  heading("Detecting agent configuration...");
+  const detected = detectAll(projectRoot);
+
+  label("Git repo", detected.git.repoUrl || "(none)");
+  label("Skills", detected.skills.length > 0
+    ? `${detected.skills.join(", ")} (${detected.skills.length})`
+    : "(none)");
+  label("MCP servers", detected.mcpServers.length > 0
+    ? `${detected.mcpServers.join(", ")} (${detected.mcpServers.length})`
+    : "(none)");
+  label("CLAUDE.md", detected.claudeMd.found
+    ? `found (${detected.claudeMd.path})`
+    : "(not found)");
+  label("Subscriptions", detected.subscriptions.length > 0
+    ? `${detected.subscriptions.map((s) => s.name).join(", ")} (auto-detected)`
+    : "(none)");
+  console.log();
+
+  // 3. Agent name, vendor, model
+  const defaultName = localConfig?.agentName || path.basename(projectRoot);
+  const agentName = await ask("Agent name", defaultName);
+
+  const vendorOptions = ["anthropic", "openai", "google"];
+  const { value: vendor } = await choose("Vendor", vendorOptions);
+
+  const modelOptions = getModelOptions(vendor);
+  const defaultModel = localConfig?.model;
+  const { value: model } = defaultModel && modelOptions.includes(defaultModel)
+    ? { value: defaultModel }
+    : await choose("Model", modelOptions);
+
+  // 4. Build request body
+  const body = {
+    agentId: localConfig?.agentId || undefined,
+    agentName,
+    vendor,
+    model,
+    orgId: org.orgId,
+    memberId: org.memberId || undefined,
+    description: `Pushed via CLI at ${new Date().toISOString()}`,
+  };
+
+  // Attach MCP tools
+  if (detected.mcpServers.length > 0) {
+    body.mcpTools = detected.mcpServers.map((name) => ({ name, server: name }));
+  }
+
+  // Attach skills
+  if (detected.skills.length > 0) {
+    body.skills = detected.skills;
+  }
+
+  // Attach git repo URL
+  if (detected.git.repoUrl) {
+    body.repoUrl = detected.git.repoUrl;
+  }
+
+  // Attach detected subscriptions
+  if (detected.subscriptions.length > 0) {
+    body.detectedSubscriptions = detected.subscriptions;
+  }
+
+  // Attach CLAUDE.md as context
+  if (detected.claudeMd.found) {
+    body.context = [{
+      type: "claude-md",
+      content: detected.claudeMd.content,
+      sourceFile: detected.claudeMd.path,
+    }];
+  }
+
+  // 5. Push to hub
+  console.log();
+  info(`Pushing to "${org.orgName}" at ${org.hubUrl}...`);
+
+  const res = await apiCall(org.hubUrl, "/api/cli/push", { body });
+
+  if (!res.ok) {
+    error(`Failed to push: ${res.data?.error || "Unknown error"}`);
+    process.exit(1);
+  }
+
+  const { id: agentId, updated, pollToken } = res.data;
+
+  const configData = {
+    hubUrl: org.hubUrl,
+    orgId: org.orgId,
+    agentId,
+    agentName,
+    vendor,
+    model,
+    pushedAt: new Date().toISOString(),
+  };
+
+  // Save pollToken if returned (openclaw agents)
+  if (pollToken) {
+    configData.pollToken = pollToken;
+  }
+
+  writeLocalConfig(configData, projectRoot);
+
+  if (updated) {
+    success(`Agent updated! (${agentId})`);
+  } else {
+    success(`Agent registered! (${agentId})`);
+  }
+
+  console.log(`\nDashboard: ${org.hubUrl}`);
+}
+
+function getModelOptions(vendor) {
+  switch (vendor) {
+    case "anthropic":
+      return ["claude-opus-4-6", "claude-sonnet-4-6", "claude-haiku-4-5-20251001"];
+    case "openai":
+      return ["gpt-4o", "gpt-4o-mini", "o1", "o3-mini"];
+    case "google":
+      return ["gemini-2.0-flash", "gemini-2.0-pro", "gemini-1.5-pro"];
+    default:
+      return ["default"];
+  }
+}

package/commands/status.mjs

@@ -0,0 +1,44 @@
+/**
+ * agent-factorio status — Show registration status for current project
+ */
+import { readLocalConfig, getDefaultOrg, findProjectRoot } from "../lib/config.mjs";
+import { label, heading, warn, success } from "../lib/log.mjs";
+
+export async function statusCommand() {
+  const org = getDefaultOrg();
+
+  // Account info
+  heading("Account");
+  if (org) {
+    label("Name", org.memberName || "(not set)");
+    label("Email", org.email || "(not set)");
+    label("Member ID", org.memberId || "(not set)");
+    label("Organization", org.orgName);
+    label("Org ID", org.orgId);
+    label("Invite code", org.inviteCode);
+    label("Hub URL", org.hubUrl);
+  } else {
+    warn("Not logged in. Run `agent-factorio login` first.");
+  }
+
+  console.log();
+
+  // Agent info
+  const projectRoot = findProjectRoot();
+  const localConfig = readLocalConfig(projectRoot);
+
+  heading("Agent");
+  if (!localConfig) {
+    warn("No agent registered in this project.");
+    console.log('Run `agent-factorio push` to register.');
+    return;
+  }
+
+  label("Agent ID", localConfig.agentId);
+  label("Agent name", localConfig.agentName);
+  label("Vendor", localConfig.vendor);
+  label("Model", localConfig.model);
+  label("Last pushed", localConfig.pushedAt || "unknown");
+  console.log();
+  success("Agent is registered.");
+}

package/commands/whoami.mjs

@@ -0,0 +1,30 @@
+/**
+ * agent-factorio whoami — Show login info (hub URL, organizations)
+ */
+import { readGlobalConfig } from "../lib/config.mjs";
+import { label, heading, warn } from "../lib/log.mjs";
+
+export async function whoamiCommand() {
+  const config = readGlobalConfig();
+
+  if (!config || !config.organizations?.length) {
+    warn("Not logged in.");
+    console.log('Run `agent-factorio login` to connect to a hub.');
+    return;
+  }
+
+  heading("Login Info");
+
+  for (const org of config.organizations) {
+    const isDefault = org.orgId === config.defaultOrg ? " (default)" : "";
+    console.log();
+    label("Organization", `${org.orgName}${isDefault}`);
+    label("Org ID", org.orgId);
+    label("Hub URL", org.hubUrl);
+    label("Invite code", org.inviteCode);
+    if (org.memberName) {
+      label("Member name", org.memberName);
+    }
+  }
+  console.log();
+}

package/lib/api.mjs

@@ -0,0 +1,57 @@
+/**
+ * Hub API call helper
+ */
+
+/**
+ * Make an API request to the AgentFactorio hub
+ * @param {string} hubUrl - Base URL of the hub
+ * @param {string} path - API path (e.g. "/api/cli/login")
+ * @param {{ method?: string, body?: unknown }} [options]
+ * @returns {Promise<{ ok: boolean, status: number, data: unknown }>}
+ */
+export async function apiCall(hubUrl, path, options = {}) {
+  const url = `${hubUrl.replace(/\/$/, "")}${path}`;
+  const method = options.method || (options.body ? "POST" : "GET");
+
+  const fetchOptions = {
+    method,
+    headers: { "Content-Type": "application/json" },
+  };
+
+  if (options.body) {
+    fetchOptions.body = JSON.stringify(options.body);
+  }
+
+  const res = await fetch(url, fetchOptions);
+  let data;
+  try {
+    data = await res.json();
+  } catch {
+    data = null;
+  }
+
+  return { ok: res.ok, status: res.status, data };
+}
+
+/**
+ * Check if hub is reachable
+ * @param {string} hubUrl
+ * @returns {Promise<boolean>}
+ */
+export async function checkHub(hubUrl) {
+  try {
+    const res = await fetch(`${hubUrl.replace(/\/$/, "")}/api/cli/login`, {
+      method: "OPTIONS",
+    });
+    // Any response (even 405) means the server is reachable
+    return res.status < 500;
+  } catch {
+    // Try a simple GET to the root
+    try {
+      const res = await fetch(hubUrl);
+      return res.ok;
+    } catch {
+      return false;
+    }
+  }
+}

package/lib/config.mjs

@@ -0,0 +1,122 @@
+/**
+ * Global (~/.agent-factorio/config.json) and local (.agent-factorio/config.json) config management
+ */
+import * as fs from "fs";
+import * as path from "path";
+import * as os from "os";
+
+const GLOBAL_DIR = path.join(os.homedir(), ".agent-factorio");
+const GLOBAL_CONFIG = path.join(GLOBAL_DIR, "config.json");
+const LOCAL_DIR_NAME = ".agent-factorio";
+const LOCAL_CONFIG_NAME = "config.json";
+
+// --- Global config ---
+
+/**
+ * @typedef {{ hubUrl: string, orgId: string, orgName: string, inviteCode: string, memberName?: string, email?: string, memberId?: string, userId?: string }} OrgEntry
+ * @typedef {{ organizations: OrgEntry[], defaultOrg?: string }} GlobalConfig
+ */
+
+/** @returns {GlobalConfig | null} */
+export function readGlobalConfig() {
+  try {
+    const raw = fs.readFileSync(GLOBAL_CONFIG, "utf-8");
+    return JSON.parse(raw);
+  } catch {
+    return null;
+  }
+}
+
+/** @param {GlobalConfig} config */
+export function writeGlobalConfig(config) {
+  fs.mkdirSync(GLOBAL_DIR, { recursive: true });
+  fs.writeFileSync(GLOBAL_CONFIG, JSON.stringify(config, null, 2) + "\n");
+}
+
+export function deleteGlobalConfig() {
+  try {
+    fs.unlinkSync(GLOBAL_CONFIG);
+  } catch {
+    // ignore if not exists
+  }
+}
+
+/**
+ * Get the default (or only) organization from global config
+ * @returns {OrgEntry | null}
+ */
+export function getDefaultOrg() {
+  const config = readGlobalConfig();
+  if (!config || !config.organizations?.length) return null;
+
+  if (config.defaultOrg) {
+    const found = config.organizations.find((o) => o.orgId === config.defaultOrg);
+    if (found) return found;
+  }
+  return config.organizations[0];
+}
+
+/**
+ * Add or update an organization in global config
+ * @param {OrgEntry} org
+ */
+export function upsertOrg(org) {
+  const config = readGlobalConfig() || { organizations: [] };
+  const idx = config.organizations.findIndex(
+    (o) => o.orgId === org.orgId && o.hubUrl === org.hubUrl
+  );
+  if (idx >= 0) {
+    config.organizations[idx] = org;
+  } else {
+    config.organizations.push(org);
+  }
+  if (!config.defaultOrg) {
+    config.defaultOrg = org.orgId;
+  }
+  writeGlobalConfig(config);
+}
+
+// --- Local (project) config ---
+
+/**
+ * @typedef {{ hubUrl: string, orgId: string, agentId: string, agentName: string, vendor: string, model: string, pushedAt: string }} LocalConfig
+ */
+
+/**
+ * Find project root by looking for .git directory
+ * @param {string} [startDir]
+ * @returns {string}
+ */
+export function findProjectRoot(startDir) {
+  let dir = startDir || process.cwd();
+  while (dir !== path.dirname(dir)) {
+    if (fs.existsSync(path.join(dir, ".git"))) return dir;
+    dir = path.dirname(dir);
+  }
+  return process.cwd();
+}
+
+/** @param {string} [projectRoot] @returns {LocalConfig | null} */
+export function readLocalConfig(projectRoot) {
+  const root = projectRoot || findProjectRoot();
+  const configPath = path.join(root, LOCAL_DIR_NAME, LOCAL_CONFIG_NAME);
+  try {
+    const raw = fs.readFileSync(configPath, "utf-8");
+    return JSON.parse(raw);
+  } catch {
+    return null;
+  }
+}
+
+/** @param {LocalConfig} config @param {string} [projectRoot] */
+export function writeLocalConfig(config, projectRoot) {
+  const root = projectRoot || findProjectRoot();
+  const dir = path.join(root, LOCAL_DIR_NAME);
+  fs.mkdirSync(dir, { recursive: true });
+  fs.writeFileSync(
+    path.join(dir, LOCAL_CONFIG_NAME),
+    JSON.stringify(config, null, 2) + "\n"
+  );
+}
+
+export { GLOBAL_CONFIG };

package/lib/detect.mjs

@@ -0,0 +1,249 @@
+/**
+ * Auto-detect project configuration: git repo, skills, MCP servers, CLAUDE.md
+ */
+import * as fs from "fs";
+import * as path from "path";
+import { execSync } from "child_process";
+import { findProjectRoot } from "./config.mjs";
+
+/**
+ * Detect git remote URL and repo root
+ * @param {string} [projectRoot]
+ * @returns {{ repoUrl: string | null, repoRoot: string }}
+ */
+export function detectGitRepo(projectRoot) {
+  const root = projectRoot || findProjectRoot();
+  let repoUrl = null;
+  try {
+    repoUrl = execSync("git remote get-url origin", { cwd: root, encoding: "utf-8" }).trim();
+  } catch {
+    // no git remote
+  }
+  return { repoUrl, repoRoot: root };
+}
+
+/**
+ * Detect skills from .claude/commands/*.md and .claude/skills/ ** /*.md
+ * @param {string} [projectRoot]
+ * @returns {string[]}
+ */
+export function detectSkills(projectRoot) {
+  const root = projectRoot || findProjectRoot();
+  const skills = [];
+
+  // .claude/commands/*.md
+  const commandsDir = path.join(root, ".claude", "commands");
+  if (fs.existsSync(commandsDir)) {
+    for (const file of readdirRecursive(commandsDir, ".md")) {
+      const name = extractSkillName(file);
+      if (name) skills.push(name);
+    }
+  }
+
+  // .claude/skills/**/SKILL.md (only the entry-point file per skill)
+  const skillsDir = path.join(root, ".claude", "skills");
+  if (fs.existsSync(skillsDir)) {
+    for (const file of readdirRecursive(skillsDir, ".md")) {
+      if (path.basename(file) !== "SKILL.md") continue;
+      const name = extractSkillName(file);
+      if (name) skills.push(name);
+    }
+  }
+
+  // Also check top-level skills/ directory (same: only SKILL.md)
+  const topSkillsDir = path.join(root, "skills");
+  if (fs.existsSync(topSkillsDir)) {
+    for (const file of readdirRecursive(topSkillsDir, ".md")) {
+      if (path.basename(file) !== "SKILL.md") continue;
+      const name = extractSkillName(file);
+      if (name) skills.push(name);
+    }
+  }
+
+  return [...new Set(skills)];
+}
+
+/**
+ * Detect MCP servers from multiple config locations:
+ *  1. .claude/settings.local.json (project-local)
+ *  2. .claude/settings.json (project-local)
+ *  3. ~/.claude.json (global, project-scoped settings)
+ * @param {string} [projectRoot]
+ * @returns {string[]}
+ */
+export function detectMcpServers(projectRoot) {
+  const root = projectRoot || findProjectRoot();
+  const servers = new Set();
+
+  // 1. Project-local settings
+  for (const filename of ["settings.local.json", "settings.json"]) {
+    const settingsPath = path.join(root, ".claude", filename);
+    try {
+      const raw = fs.readFileSync(settingsPath, "utf-8");
+      const settings = JSON.parse(raw);
+      if (settings.mcpServers && typeof settings.mcpServers === "object") {
+        for (const name of Object.keys(settings.mcpServers)) {
+          servers.add(name);
+        }
+      }
+    } catch {
+      // file not found or invalid JSON
+    }
+  }
+
+  // 2. Global ~/.claude.json — project-scoped MCP settings
+  const resolvedRoot = fs.realpathSync(root);
+  const globalConfigPath = path.join(process.env.HOME || "", ".claude.json");
+  try {
+    const raw = fs.readFileSync(globalConfigPath, "utf-8");
+    const config = JSON.parse(raw);
+    if (config.projects && typeof config.projects === "object") {
+      const projectSettings = config.projects[resolvedRoot];
+      if (projectSettings?.mcpServers && typeof projectSettings.mcpServers === "object") {
+        for (const name of Object.keys(projectSettings.mcpServers)) {
+          if (Object.keys(projectSettings.mcpServers[name]).length > 0) {
+            servers.add(name);
+          }
+        }
+      }
+    }
+  } catch {
+    // file not found or invalid JSON
+  }
+
+  return [...servers];
+}
+
+/**
+ * Detect CLAUDE.md content
+ * @param {string} [projectRoot]
+ * @returns {{ found: boolean, path: string | null, content: string | null }}
+ */
+export function detectClaudeMd(projectRoot) {
+  const root = projectRoot || findProjectRoot();
+
+  // Check .claude/CLAUDE.md first, then root CLAUDE.md
+  for (const relPath of [".claude/CLAUDE.md", "CLAUDE.md"]) {
+    const fullPath = path.join(root, relPath);
+    try {
+      const content = fs.readFileSync(fullPath, "utf-8");
+      return { found: true, path: relPath, content };
+    } catch {
+      // not found
+    }
+  }
+
+  return { found: false, path: null, content: null };
+}
+
+/**
+ * Detect AI service subscriptions from environment and local tooling
+ * @returns {{ name: string, detectionSource: string }[]}
+ */
+export function detectSubscriptions() {
+  const subs = [];
+
+  // Claude Code — always true when running inside Claude Code
+  if (process.env.CLAUDE_CODE_VERSION) {
+    subs.push({ name: "Claude Code", detectionSource: "env_var" });
+  }
+
+  // API keys
+  if (process.env.ANTHROPIC_API_KEY) {
+    subs.push({ name: "Anthropic API", detectionSource: "env_var" });
+  }
+  if (process.env.OPENAI_API_KEY) {
+    subs.push({ name: "OpenAI API", detectionSource: "env_var" });
+  }
+
+  // Cursor
+  const cursorDir = path.join(process.env.HOME || "", ".cursor");
+  if (fs.existsSync(cursorDir)) {
+    subs.push({ name: "Cursor", detectionSource: "cli_push" });
+  }
+
+  // GitHub Copilot
+  const vscodeExtDir = path.join(process.env.HOME || "", ".vscode", "extensions");
+  try {
+    if (fs.existsSync(vscodeExtDir)) {
+      const entries = fs.readdirSync(vscodeExtDir);
+      if (entries.some((e) => e.startsWith("github.copilot"))) {
+        subs.push({ name: "GitHub Copilot", detectionSource: "cli_push" });
+      }
+    }
+  } catch {
+    // ignore
+  }
+
+  // Windsurf
+  const windsurfDir = path.join(process.env.HOME || "", ".windsurf");
+  if (fs.existsSync(windsurfDir)) {
+    subs.push({ name: "Windsurf", detectionSource: "cli_push" });
+  }
+
+  return subs;
+}
+
+/**
+ * Run all detections and return a summary
+ * @param {string} [projectRoot]
+ */
+export function detectAll(projectRoot) {
+  const root = projectRoot || findProjectRoot();
+  return {
+    git: detectGitRepo(root),
+    skills: detectSkills(root),
+    mcpServers: detectMcpServers(root),
+    claudeMd: detectClaudeMd(root),
+    subscriptions: detectSubscriptions(),
+  };
+}
+
+// --- Helpers ---
+
+/**
+ * Recursively find files with a given extension
+ * @param {string} dir
+ * @param {string} ext
+ * @returns {string[]}
+ */
+function readdirRecursive(dir, ext) {
+  const results = [];
+  try {
+    const entries = fs.readdirSync(dir, { withFileTypes: true });
+    for (const entry of entries) {
+      const fullPath = path.join(dir, entry.name);
+      if (entry.isDirectory()) {
+        results.push(...readdirRecursive(fullPath, ext));
+      } else if (entry.name.endsWith(ext)) {
+        results.push(fullPath);
+      }
+    }
+  } catch {
+    // permission error or not found
+  }
+  return results;
+}
+
+/**
+ * Extract skill name from a markdown file (first heading or filename)
+ * @param {string} filePath
+ * @returns {string | null}
+ */
+function extractSkillName(filePath) {
+  try {
+    const content = fs.readFileSync(filePath, "utf-8");
+    // Try to find first heading
+    const match = content.match(/^#\s+(.+)/m);
+    if (match) return match[1].trim();
+  } catch {
+    // fall through
+  }
+  // Use filename without extension
+  const base = path.basename(filePath, ".md");
+  if (base === "SKILL" || base === "README") {
+    // Use parent directory name
+    return path.basename(path.dirname(filePath));
+  }
+  return base;
+}

package/lib/log.mjs

@@ -0,0 +1,43 @@
+/**
+ * Colored output utilities for CLI
+ */
+
+const RESET = "\x1b[0m";
+const GREEN = "\x1b[32m";
+const RED = "\x1b[31m";
+const YELLOW = "\x1b[33m";
+const CYAN = "\x1b[36m";
+const DIM = "\x1b[2m";
+const BOLD = "\x1b[1m";
+
+export function success(msg) {
+  console.log(`${GREEN}\u2713${RESET} ${msg}`);
+}
+
+export function error(msg) {
+  console.error(`${RED}\u2717${RESET} ${msg}`);
+}
+
+export function warn(msg) {
+  console.log(`${YELLOW}!${RESET} ${msg}`);
+}
+
+export function info(msg) {
+  console.log(`${CYAN}i${RESET} ${msg}`);
+}
+
+export function dim(msg) {
+  console.log(`${DIM}${msg}${RESET}`);
+}
+
+export function bold(msg) {
+  return `${BOLD}${msg}${RESET}`;
+}
+
+export function label(key, value) {
+  console.log(`  ${DIM}${key}:${RESET}  ${value}`);
+}
+
+export function heading(msg) {
+  console.log(`\n${BOLD}${msg}${RESET}`);
+}

package/lib/prompt.mjs

@@ -0,0 +1,79 @@
+/**
+ * Interactive CLI prompts (reuses patterns from scripts/lib/stdin.mjs)
+ */
+import * as readline from "readline";
+
+/**
+ * Ask a question and return the user's answer
+ * @param {string} question - The prompt to display
+ * @param {string} [defaultValue] - Default value if user presses Enter
+ * @returns {Promise<string>}
+ */
+export function ask(question, defaultValue) {
+  const rl = readline.createInterface({
+    input: process.stdin,
+    output: process.stderr,
+  });
+
+  const hint = defaultValue ? ` [${defaultValue}]` : "";
+  const prompt = `? ${question}${hint}: `;
+
+  return new Promise((resolve) => {
+    rl.question(prompt, (answer) => {
+      rl.close();
+      resolve(answer.trim() || defaultValue || "");
+    });
+  });
+}
+
+/**
+ * Ask user to choose from a list of options
+ * @param {string} question - The prompt to display
+ * @param {string[]} options - List of options
+ * @returns {Promise<{index: number, value: string}>}
+ */
+export function choose(question, options) {
+  const rl = readline.createInterface({
+    input: process.stdin,
+    output: process.stderr,
+  });
+
+  return new Promise((resolve) => {
+    process.stderr.write(`? ${question}\n`);
+    options.forEach((opt, i) => {
+      process.stderr.write(`  ${i + 1}. ${opt}\n`);
+    });
+    rl.question("Choice: ", (answer) => {
+      rl.close();
+      const idx = parseInt(answer, 10) - 1;
+      if (idx >= 0 && idx < options.length) {
+        resolve({ index: idx, value: options[idx] });
+      } else {
+        resolve({ index: 0, value: options[0] });
+      }
+    });
+  });
+}
+
+/**
+ * Ask a yes/no question
+ * @param {string} question - The prompt to display
+ * @param {boolean} [defaultYes=true] - Default answer
+ * @returns {Promise<boolean>}
+ */
+export function confirm(question, defaultYes = true) {
+  const suffix = defaultYes ? "[Y/n]" : "[y/N]";
+  const rl = readline.createInterface({
+    input: process.stdin,
+    output: process.stderr,
+  });
+
+  return new Promise((resolve) => {
+    rl.question(`? ${question} ${suffix}: `, (answer) => {
+      rl.close();
+      const a = answer.trim().toLowerCase();
+      if (a === "") resolve(defaultYes);
+      else resolve(a === "y" || a === "yes");
+    });
+  });
+}

package/package.json

@@ -0,0 +1,34 @@
+{
+  "name": "agent-factorio",
+  "version": "0.2.0",
+  "description": "CLI for AgentFactorio — AI Agent Fleet Management hub",
+  "type": "module",
+  "bin": {
+    "agent-factorio": "bin.js"
+  },
+  "files": [
+    "bin.js",
+    "commands/",
+    "lib/"
+  ],
+  "engines": {
+    "node": ">=18"
+  },
+  "keywords": [
+    "ai",
+    "agent",
+    "claude",
+    "fleet",
+    "management",
+    "cli"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/gmuffiness/agent-factorio.git",
+    "directory": "cli"
+  },
+  "license": "MIT",
+  "dependencies": {
+    "commander": "^14.0.3"
+  }
+}