@thirdfy/agent-cli 0.1.48 → 0.2.1

package/src/cli/register.mjs

@@ -0,0 +1,118 @@
+import { Command } from 'commander';
+import { CLI_MANIFEST } from './manifest.mjs';
+import { attachGlobalOptions, attachOptionBundles } from './options/index.mjs';
+import { collectLegacyFlags, collectRootFlags } from './flags.mjs';
+import { configureCommanderErrors } from './errors.mjs';
+
+function parentPathKey(pathSegments) {
+  return pathSegments.slice(0, -1).join(' ');
+}
+
+function fullPathKey(pathSegments) {
+  return pathSegments.join(' ');
+}
+
+function ensureParentCommands(program, pathSegments, nodeByPath) {
+  let parent = program;
+  const built = [];
+  for (let i = 0; i < pathSegments.length - 1; i += 1) {
+    built.push(pathSegments[i]);
+    const key = built.join(' ');
+    if (!nodeByPath.has(key)) {
+      const sub = parent.command(pathSegments[i]);
+      nodeByPath.set(key, sub);
+      parent = sub;
+    } else {
+      parent = nodeByPath.get(key);
+    }
+  }
+  return parent;
+}
+
+function registerManifestEntry(program, entry, nodeByPath, deps) {
+  const { handlers, prepareContextFromFlags, negotiateCapabilities, getContext } = deps;
+  const path = entry.path;
+  const parent = ensureParentCommands(program, path, nodeByPath);
+  const leafName = path[path.length - 1];
+  const fullKey = fullPathKey(path);
+
+  if (nodeByPath.has(fullKey)) {
+    return;
+  }
+
+  const leaf = parent.command(leafName);
+  if (entry.description) leaf.description(entry.description);
+  attachOptionBundles(leaf, entry.options || []);
+
+  if (entry.args?.address) {
+    leaf.argument(entry.args.address);
+  }
+  if (entry.args?.query) {
+    leaf.argument(entry.args.query);
+  }
+
+  const handler = handlers[entry.handler];
+  if (!handler) {
+    throw new Error(`Missing CLI handler: ${entry.handler} for ${fullKey}`);
+  }
+
+  leaf.action(async (...actionArgs) => {
+    const command = actionArgs[actionArgs.length - 1];
+    const extra = {};
+
+    if (entry.args?.address) {
+      extra.address = actionArgs[0];
+    } else if (entry.args?.query) {
+      const queryArg = actionArgs[0];
+      extra.query = Array.isArray(queryArg) ? queryArg : queryArg !== undefined ? [queryArg] : [];
+    }
+
+    const flags = collectLegacyFlags(program, command, extra);
+    const ctx = prepareContextFromFlags(flags);
+
+    if (entry.tier === 'online') {
+      const capabilities = await negotiateCapabilities(ctx);
+      ctx.negotiatedCapabilitiesCache = capabilities;
+      if (entry.trackKind) {
+        await handler(ctx, flags, capabilities, entry.trackKind);
+      } else if (entry.handler === 'commandPrompt') {
+        const tokens = Array.isArray(extra.query) ? extra.query : [];
+        await handler(ctx, flags, capabilities, tokens);
+      } else {
+        await handler(ctx, flags, capabilities);
+      }
+      return;
+    }
+
+    if (entry.trackKind) {
+      await handler(ctx, flags, null, entry.trackKind);
+    } else {
+      await handler(ctx, flags);
+    }
+  });
+
+  nodeByPath.set(fullKey, leaf);
+}
+
+export function buildCliProgram(deps) {
+  const program = new Command('thirdfy-agent');
+  program.name('thirdfy-agent');
+  attachGlobalOptions(program);
+  program.addHelpCommand(false);
+  program.showHelpAfterError(false);
+
+  configureCommanderErrors(program, {
+    getJsonMode: deps.getJsonMode,
+    printEnvelope: deps.printEnvelope,
+    CLI_VERSION: deps.CLI_VERSION,
+    getApiBase: () => deps.getContext().apiBase,
+    collectRootFlags,
+  });
+
+  const nodeByPath = new Map();
+  for (const entry of CLI_MANIFEST) {
+    registerManifestEntry(program, entry, nodeByPath, deps);
+  }
+
+  return program;
+}

package/src/commands/agent.mjs

@@ -0,0 +1,194 @@
+import { createRequire } from 'module';
+import { requireFlag, parseJsonFlag } from '../core/args.mjs';
+import { apiPost, safeJsonParse } from '../core/http.mjs';
+import { createCliError } from '../core/envelope.mjs';
+import { DEFAULT_TIMEOUT_MS } from '../core/constants.mjs';
+
+const require = createRequire(import.meta.url);
+const { version: CLI_VERSION } = require('../../package.json');
+export function createAgentCommands({ printEnvelope, extractAgentApiKey, extractAgentKey, buildOwnerAuthHeaders }) {
+async function commandAgentRegister(ctx, flags, capabilities) {
+  const ownerHeaders = buildOwnerAuthHeaders(
+    flags,
+    'Missing owner auth for agent register: provide --auth-token (THIRDFY_AUTH_TOKEN) or --owner-session-token'
+  );
+  const payload = {
+    agentKey: requireFlag(flags, 'agentKey', 'Missing --agent-key'),
+    name: requireFlag(flags, 'name', 'Missing --name'),
+  };
+  if (flags.email) payload.email = String(flags.email);
+  if (flags.bio) payload.bio = String(flags.bio);
+  if (flags.website) payload.website = String(flags.website);
+  if (flags.github) payload.github = String(flags.github);
+  if (flags.tags) {
+    payload.tags = String(flags.tags)
+      .split(',')
+      .map((s) => s.trim())
+      .filter(Boolean);
+  }
+  if (flags.strategy) payload.strategy = parseJsonFlag(flags, 'strategy');
+  if (flags.apiKeyEnvelopePublicKey) payload.apiKeyEnvelopePublicKey = String(flags.apiKeyEnvelopePublicKey);
+
+  const route = ownerHeaders['x-owner-session-token']
+    ? '/api/v1/agent/onboarding/register-with-wallet'
+    : '/api/v1/agent/onboarding/register-with-privy';
+  const response = await apiPost(ctx, route, payload, ownerHeaders);
+  if (!flags.__suppressOutput) {
+    printEnvelope({
+      success: true,
+      code: 'AGENT_REGISTERED',
+      message: 'Agent registered',
+      data: response,
+      meta: {
+        apiBase: ctx.apiBase,
+        capabilitiesVersion: capabilities?.contractVersion || null,
+      },
+    });
+  }
+  return response;
+}
+
+async function commandAgentKeyRotate(ctx, flags, capabilities) {
+  const ownerHeaders = buildOwnerAuthHeaders(
+    flags,
+    'Missing owner auth for agent key rotate: provide --auth-token (THIRDFY_AUTH_TOKEN) or --owner-session-token'
+  );
+  const payload = {};
+  if (flags.agentKey) payload.agentKey = String(flags.agentKey).trim();
+  const response = await apiPost(ctx, '/api/v1/agent/onboarding/me/api-key/rotate', payload, ownerHeaders);
+  printEnvelope({
+    success: true,
+    code: 'AGENT_KEY_ROTATED',
+    message: 'Agent API key rotated',
+    data: response,
+    meta: {
+      apiBase: ctx.apiBase,
+      capabilitiesVersion: capabilities?.contractVersion || null,
+    },
+  });
+}
+
+async function commandAgentKeyRevoke(ctx, flags, capabilities) {
+  const ownerHeaders = buildOwnerAuthHeaders(
+    flags,
+    'Missing owner auth for agent key revoke: provide --auth-token (THIRDFY_AUTH_TOKEN) or --owner-session-token'
+  );
+  const payload = {};
+  if (flags.agentKey) payload.agentKey = String(flags.agentKey).trim();
+  const response = await apiPost(ctx, '/api/v1/agent/onboarding/me/api-key/revoke', payload, ownerHeaders);
+  printEnvelope({
+    success: true,
+    code: 'AGENT_KEY_REVOKED',
+    message: 'Agent API key revoked',
+    data: response,
+    meta: {
+      apiBase: ctx.apiBase,
+      capabilitiesVersion: capabilities?.contractVersion || null,
+    },
+  });
+}
+
+function buildWalletChallengePayload(flags) {
+  const payload = {
+    agentKey: requireFlag(flags, 'agentKey', 'Missing --agent-key'),
+    chainId: Number(flags.chainId || 8453),
+  };
+  if (flags.walletAddress) payload.walletAddress = String(flags.walletAddress).trim();
+  return payload;
+}
+
+async function commandAgentAuthChallenge(ctx, flags, capabilities) {
+  const response = await apiPost(
+    ctx,
+    '/api/v1/agent/onboarding/wallet/challenge',
+    buildWalletChallengePayload(flags)
+  );
+  printEnvelope({
+    success: true,
+    code: 'OWNER_CHALLENGE_CREATED',
+    message: 'Wallet challenge created',
+    data: response,
+    meta: {
+      apiBase: ctx.apiBase,
+      capabilitiesVersion: capabilities?.contractVersion || null,
+    },
+  });
+}
+
+async function commandAgentAuthVerify(ctx, flags, capabilities) {
+  const response = await verifyOwnerWalletChallenge(ctx, flags);
+  printEnvelope({
+    success: true,
+    code: 'OWNER_VERIFIED',
+    message: 'Wallet challenge verified',
+    data: response,
+    meta: {
+      apiBase: ctx.apiBase,
+      capabilitiesVersion: capabilities?.contractVersion || null,
+    },
+  });
+}
+
+async function verifyOwnerWalletChallenge(ctx, flags) {
+  const payload = {
+    challengeId: requireFlag(flags, 'challengeId', 'Missing --challenge-id'),
+    signature: requireFlag(flags, 'signature', 'Missing --signature'),
+    agentKey: requireFlag(flags, 'agentKey', 'Missing --agent-key'),
+  };
+  if (flags.walletAddress) payload.walletAddress = String(flags.walletAddress).trim();
+  return apiPost(ctx, '/api/v1/agent/onboarding/wallet/verify', payload);
+}
+
+function resolveMcpBase(flags) {
+  return String(flags.mcpBase || process.env.THIRDFY_MCP_BASE_URL || 'https://mcp.thirdfy.com').trim().replace(/\/+$/, '');
+}
+
+async function issueBootstrapToken(ctx, flags, payload) {
+  const mcpBase = resolveMcpBase(flags);
+  const controller = new AbortController();
+  const timeout = setTimeout(() => controller.abort(), Number(ctx.timeoutMs || DEFAULT_TIMEOUT_MS));
+  let response;
+  let text = '';
+  try {
+    response = await fetch(`${mcpBase}/auth/bootstrap/issue`, {
+      method: 'POST',
+      headers: {
+        'content-type': 'application/json',
+        'x-cli-version': CLI_VERSION,
+      },
+      body: JSON.stringify(payload),
+      signal: controller.signal,
+    });
+    text = await response.text();
+  } catch (error) {
+    if (error?.name === 'AbortError') {
+      throw createCliError('TIMEOUT', `Request timed out after ${ctx.timeoutMs}ms`, {
+        routes: ['/auth/bootstrap/issue'],
+      });
+    }
+    throw error;
+  } finally {
+    clearTimeout(timeout);
+  }
+  const data = text ? safeJsonParse(text) : {};
+  if (!response.ok) {
+    const message = data?.error || data?.message || 'Bootstrap token issuance failed';
+    throw createCliError('BOOTSTRAP_TOKEN_ISSUE_FAILED', message, data);
+  }
+  return {
+    mcpBase,
+    data,
+  };
+}
+
+  return {
+    commandAgentRegister,
+    commandAgentKeyRotate,
+    commandAgentKeyRevoke,
+    buildWalletChallengePayload,
+    commandAgentAuthChallenge,
+    commandAgentAuthVerify,
+    verifyOwnerWalletChallenge,
+    issueBootstrapToken,
+  };
+}