@agentrade/cli 0.1.1 → 0.1.2

package/LICENSE

@@ -0,0 +1,22 @@
+MIT License
+
+Copyright (c) 2026 Agentrade Contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+

package/dist/index.js

@@ -3,79 +3,6 @@
 // src/program.ts
 import { Command } from "commander";
 
-// ../../packages/config/src/index.ts
-var envString = (key, fallback) => {
-  const raw = process.env[key];
-  return raw && raw.length > 0 ? raw : fallback;
-};
-var PLACEHOLDER_VALUES = {
-  JWT_SECRET: "replace-this-secret",
-  ADMIN_SERVICE_KEY: "replace-this-admin-key"
-};
-var defaultConfig = {
-  appName: "Agentrade",
-  host: "0.0.0.0",
-  port: 3e3,
-  apiDefaultVersion: "v2",
-  databaseUrl: "postgresql://postgres:postgres@localhost:5432/agentrade",
-  redisUrl: "redis://localhost:6379",
-  enablePersistence: true,
-  enableRedisRateLimit: true,
-  trustProxy: false,
-  corsAllowedOrigins: [
-    "http://localhost:3000",
-    "http://127.0.0.1:3000",
-    "http://localhost:3001",
-    "http://127.0.0.1:3001"
-  ],
-  jwtSecret: PLACEHOLDER_VALUES.JWT_SECRET,
-  adminServiceKey: PLACEHOLDER_VALUES.ADMIN_SERVICE_KEY,
-  authChallengeTtlMinutes: 10,
-  authChallengeMaxEntries: 1e4,
-  authChallengeSweepIntervalMs: 3e4,
-  rateLimitPerMinute: 300,
-  rateLimitBurst: 60,
-  taskTitleMaxLength: 200,
-  taskDescriptionMaxLength: 2e4,
-  taskAcceptanceCriteriaMaxLength: 8e3,
-  taskSubmissionPayloadMaxLength: 2e4,
-  taskSubmissionAttachmentMaxCount: 10,
-  taskSubmissionAttachmentNameMaxLength: 200,
-  taskSubmissionAttachmentUrlMaxLength: 2e3,
-  taskSubmissionAttachmentMaxSizeBytes: 100 * 1024 * 1024,
-  disputeReasonMaxLength: 4e3,
-  taskSlotsMax: 100,
-  taskRewardPerSlotMax: 1e6,
-  taskDeadlineMaxHours: 4320,
-  taxRateBps: 500,
-  taxMin: 1,
-  rewardMin: 1,
-  initialAgentBalance: 1e3,
-  mintPerCycle: 1e4,
-  taskCompletionPublisherWorkload: 0.25,
-  taskCompletionWorkerWorkload: 0.25,
-  terminationPenaltyBps: 1e3,
-  submissionTimeoutHours: 72,
-  resubmitCooldownMinutes: 30,
-  disputeQuorum: 5,
-  disputeApprovalBps: 6e3,
-  reputationWeightPublisherBps: 2e3,
-  reputationWeightWorkerBps: 3e3,
-  reputationWeightSupervisorBps: 5e3,
-  scoreWeightReputationBps: 4500,
-  scoreWeightCompletionBps: 3500,
-  scoreWeightQualityBps: 2e3,
-  bridgeChain: "Base Sepolia",
-  bridgeMode: "OFFCHAIN_EXPORT_ONLY"
-};
-var loadCliRuntimeConfig = () => ({
-  apiBaseUrl: envString("AGENTRADE_API_BASE_URL", "https://agentrade.info/api"),
-  token: process.env.AGENTRADE_TOKEN,
-  adminServiceKey: process.env.AGENTRADE_ADMIN_SERVICE_KEY,
-  timeoutMs: envString("AGENTRADE_TIMEOUT_MS", "10000"),
-  retries: envString("AGENTRADE_RETRIES", "1")
-});
-
 // src/operation-bindings.ts
 var cliOperationBindings = {
   "activities list": "activitiesListV2",
@@ -2331,7 +2258,7 @@ var ApiClientError = class extends Error {
 var DEFAULT_TIMEOUT_MS = 1e4;
 var DEFAULT_RETRIES = 1;
 var sleep = async (ms) => {
-  await new Promise((resolve) => setTimeout(resolve, ms));
+  await new Promise((resolve2) => setTimeout(resolve2, ms));
 };
 var shouldRetryStatus = (status) => status === 429 || status >= 500;
 var retryDelayMs = (attempt) => Math.min(1e3, 100 * 2 ** (attempt - 1));
@@ -2686,6 +2613,233 @@ var AgentradeApiClient = class {
   }
 };
 
+// src/cli-config.ts
+import { existsSync, mkdirSync, readFileSync as readFileSync2, unlinkSync, writeFileSync } from "fs";
+import { homedir } from "os";
+import { dirname, isAbsolute, join, resolve } from "path";
+var CLI_DEFAULT_BASE_URL = "https://agentrade.info/api";
+var CLI_DEFAULT_TIMEOUT_MS = 1e4;
+var CLI_DEFAULT_RETRIES = 1;
+var configError = (path, message) => new CliConfigError(`invalid CLI config at ${path}: ${message}`);
+var parseOptionalString = (raw, path, field) => {
+  if (raw === void 0 || raw === null) {
+    return void 0;
+  }
+  if (typeof raw !== "string") {
+    throw configError(path, `${field} must be a string`);
+  }
+  const value = raw.trim();
+  return value.length > 0 ? value : void 0;
+};
+var parseOptionalInteger = (raw, path, field) => {
+  if (raw === void 0 || raw === null) {
+    return void 0;
+  }
+  if (typeof raw === "number") {
+    if (!Number.isSafeInteger(raw)) {
+      throw configError(path, `${field} must be a safe integer`);
+    }
+    return raw;
+  }
+  if (typeof raw !== "string") {
+    throw configError(path, `${field} must be an integer`);
+  }
+  const value = raw.trim();
+  if (value.length === 0) {
+    return void 0;
+  }
+  if (!/^-?\d+$/.test(value)) {
+    throw configError(path, `${field} must be an integer`);
+  }
+  const parsed = Number(value);
+  if (!Number.isSafeInteger(parsed)) {
+    throw configError(path, `${field} must be a safe integer`);
+  }
+  return parsed;
+};
+var parseCliPersistedConfig = (raw, path) => {
+  if (!raw || typeof raw !== "object" || Array.isArray(raw)) {
+    throw configError(path, "root value must be a JSON object");
+  }
+  const input = raw;
+  const parsed = {};
+  const baseUrl = parseOptionalString(input.baseUrl, path, "baseUrl");
+  const token = parseOptionalString(input.token, path, "token");
+  const adminKey = parseOptionalString(input.adminKey, path, "adminKey");
+  const timeoutMs = parseOptionalInteger(input.timeoutMs, path, "timeoutMs");
+  const retries = parseOptionalInteger(input.retries, path, "retries");
+  if (baseUrl !== void 0) {
+    let parsedUrl;
+    try {
+      parsedUrl = new URL(baseUrl);
+    } catch {
+      throw configError(path, "baseUrl must be a valid URL");
+    }
+    if (parsedUrl.protocol !== "http:" && parsedUrl.protocol !== "https:") {
+      throw configError(path, "baseUrl must start with http:// or https://");
+    }
+    parsed.baseUrl = baseUrl;
+  }
+  if (token !== void 0) {
+    parsed.token = token;
+  }
+  if (adminKey !== void 0) {
+    parsed.adminKey = adminKey;
+  }
+  if (timeoutMs !== void 0) {
+    if (timeoutMs <= 0) {
+      throw configError(path, "timeoutMs must be > 0");
+    }
+    parsed.timeoutMs = timeoutMs;
+  }
+  if (retries !== void 0) {
+    if (retries < 0) {
+      throw configError(path, "retries must be >= 0");
+    }
+    parsed.retries = retries;
+  }
+  return parsed;
+};
+var normalizeConfigForWrite = (values, path) => {
+  const normalized = parseCliPersistedConfig(values, path);
+  const ordered = {};
+  if (normalized.baseUrl !== void 0) {
+    ordered.baseUrl = normalized.baseUrl;
+  }
+  if (normalized.token !== void 0) {
+    ordered.token = normalized.token;
+  }
+  if (normalized.adminKey !== void 0) {
+    ordered.adminKey = normalized.adminKey;
+  }
+  if (normalized.timeoutMs !== void 0) {
+    ordered.timeoutMs = normalized.timeoutMs;
+  }
+  if (normalized.retries !== void 0) {
+    ordered.retries = normalized.retries;
+  }
+  return ordered;
+};
+var writeCliPersistedConfig = (path, values) => {
+  const normalized = normalizeConfigForWrite(values, path);
+  if (Object.keys(normalized).length === 0) {
+    if (existsSync(path)) {
+      unlinkSync(path);
+    }
+    return {
+      path,
+      exists: false,
+      values: {}
+    };
+  }
+  mkdirSync(dirname(path), { recursive: true, mode: 448 });
+  writeFileSync(path, `${JSON.stringify(normalized, null, 2)}
+`, {
+    encoding: "utf8",
+    mode: 384
+  });
+  return {
+    path,
+    exists: true,
+    values: normalized
+  };
+};
+var resolveCliConfigPath = () => {
+  const explicit = process.env.AGENTRADE_CLI_CONFIG_PATH;
+  if (explicit !== void 0) {
+    const value = explicit.trim();
+    if (value.length === 0) {
+      throw new CliConfigError("AGENTRADE_CLI_CONFIG_PATH must be non-empty when set");
+    }
+    return isAbsolute(value) ? value : resolve(value);
+  }
+  const xdgBase = process.env.XDG_CONFIG_HOME?.trim();
+  if (xdgBase) {
+    return join(xdgBase, "agentrade", "config.json");
+  }
+  const home = homedir().trim();
+  if (home.length === 0) {
+    throw new CliConfigError("unable to resolve home directory for CLI config");
+  }
+  return join(home, ".agentrade", "config.json");
+};
+var loadCliPersistedConfig = () => {
+  const path = resolveCliConfigPath();
+  if (!existsSync(path)) {
+    return {
+      path,
+      exists: false,
+      values: {}
+    };
+  }
+  let rawText;
+  try {
+    rawText = readFileSync2(path, "utf8");
+  } catch (error) {
+    throw new CliConfigError(
+      `unable to read CLI config at ${path}: ${error instanceof Error ? error.message : String(error)}`
+    );
+  }
+  if (rawText.trim().length === 0) {
+    return {
+      path,
+      exists: true,
+      values: {}
+    };
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(rawText);
+  } catch (error) {
+    throw new CliConfigError(
+      `invalid CLI config JSON at ${path}: ${error instanceof Error ? error.message : String(error)}`
+    );
+  }
+  return {
+    path,
+    exists: true,
+    values: parseCliPersistedConfig(parsed, path)
+  };
+};
+var setCliPersistedConfigValue = (key, value) => {
+  const current = loadCliPersistedConfig();
+  const next = { ...current.values };
+  switch (key) {
+    case "baseUrl":
+      next.baseUrl = String(value);
+      break;
+    case "token":
+      next.token = String(value);
+      break;
+    case "adminKey":
+      next.adminKey = String(value);
+      break;
+    case "timeoutMs":
+      next.timeoutMs = Number(value);
+      break;
+    case "retries":
+      next.retries = Number(value);
+      break;
+    default: {
+      const exhaustive = key;
+      throw new CliConfigError(`unsupported CLI config key: ${String(exhaustive)}`);
+    }
+  }
+  return writeCliPersistedConfig(current.path, next);
+};
+var unsetCliPersistedConfigKeys = (keys) => {
+  const current = loadCliPersistedConfig();
+  const next = { ...current.values };
+  for (const key of keys) {
+    delete next[key];
+  }
+  return writeCliPersistedConfig(current.path, next);
+};
+var clearCliPersistedConfig = () => {
+  const current = loadCliPersistedConfig();
+  return writeCliPersistedConfig(current.path, {});
+};
+
 // src/context.ts
 var resolveCommandPath = (command) => {
   const segments = [];
@@ -2702,19 +2856,26 @@ var normalizeOptional = (value) => {
   }
   return value.trim().length > 0 ? value : void 0;
 };
-var resolveGlobalOptions = (command) => {
+var parsePositiveInteger = (value, flag) => {
+  return ensurePositiveInteger(String(value), flag);
+};
+var parseNonNegativeInteger = (value, flag) => {
+  return ensureNonNegativeInteger(String(value), flag);
+};
+var resolveGlobalOptions = (command, persistedConfig = loadCliPersistedConfig().values) => {
   const raw = command.optsWithGlobals();
-  const rawBaseUrl = normalizeOptional(raw.baseUrl);
-  if (!rawBaseUrl) {
-    throw new CliConfigError("--base-url is required");
-  }
-  const baseUrl = ensureHttpUrl(rawBaseUrl, "--base-url");
-  const timeoutMs = typeof raw.timeoutMs === "number" ? raw.timeoutMs : ensurePositiveInteger(String(raw.timeoutMs ?? "10000"), "--timeout-ms");
-  const retries = typeof raw.retries === "number" ? raw.retries : ensureNonNegativeInteger(String(raw.retries ?? "1"), "--retries");
+  const rawBaseUrl = raw.baseUrl === void 0 ? persistedConfig.baseUrl : String(raw.baseUrl);
+  const baseUrl = ensureHttpUrl(rawBaseUrl ?? CLI_DEFAULT_BASE_URL, "--base-url");
+  const rawToken = raw.token === void 0 ? persistedConfig.token : String(raw.token);
+  const rawAdminKey = raw.adminKey === void 0 ? persistedConfig.adminKey : String(raw.adminKey);
+  const rawTimeoutMs = raw.timeoutMs === void 0 ? persistedConfig.timeoutMs ?? CLI_DEFAULT_TIMEOUT_MS : raw.timeoutMs;
+  const timeoutMs = parsePositiveInteger(rawTimeoutMs, "--timeout-ms");
+  const rawRetries = raw.retries === void 0 ? persistedConfig.retries ?? CLI_DEFAULT_RETRIES : raw.retries;
+  const retries = parseNonNegativeInteger(rawRetries, "--retries");
   return {
     baseUrl,
-    token: normalizeOptional(raw.token),
-    adminKey: normalizeOptional(raw.adminKey),
+    token: normalizeOptional(rawToken),
+    adminKey: normalizeOptional(rawAdminKey),
     timeoutMs,
     retries,
     pretty: Boolean(raw.pretty)
@@ -2735,13 +2896,13 @@ var createCommandContext = (command) => {
     client,
     requireToken: () => {
       if (!options.token) {
-        throw new CliConfigError("missing token: use --token or AGENTRADE_TOKEN");
+        throw new CliConfigError("missing token: use --token");
       }
       return options.token;
     },
     requireAdminKey: () => {
       if (!options.adminKey) {
-        throw new CliConfigError("missing admin key: use --admin-key or AGENTRADE_ADMIN_SERVICE_KEY");
+        throw new CliConfigError("missing admin key: use --admin-key");
       }
       return options.adminKey;
     }
@@ -3100,6 +3261,157 @@ var registerAuthCommands = (program) => {
   });
 };
 
+// src/commands/config.ts
+var KEY_ALIASES = {
+  "base-url": "baseUrl",
+  base_url: "baseUrl",
+  token: "token",
+  "admin-key": "adminKey",
+  admin_key: "adminKey",
+  "timeout-ms": "timeoutMs",
+  timeout_ms: "timeoutMs",
+  retries: "retries"
+};
+var VALID_SET_KEYS = "base-url|token|admin-key|timeout-ms|retries";
+var attachCommandPath = (error, commandPath) => {
+  if (!error || typeof error !== "object") {
+    return;
+  }
+  const tagged = error;
+  if (!tagged.commandPath) {
+    tagged.commandPath = commandPath;
+  }
+};
+var resolvePretty = (command) => {
+  const raw = command.optsWithGlobals();
+  return Boolean(raw.pretty);
+};
+var maskSecret = (value) => {
+  if (!value) {
+    return null;
+  }
+  const trimmed = value.trim();
+  if (trimmed.length === 0) {
+    return null;
+  }
+  if (trimmed.length <= 8) {
+    return "***";
+  }
+  return `${trimmed.slice(0, 4)}...${trimmed.slice(-4)}`;
+};
+var toConfigOutput = (path, exists, values) => {
+  return {
+    path,
+    exists,
+    configured: {
+      baseUrl: values.baseUrl ?? null,
+      token: maskSecret(values.token),
+      tokenConfigured: Boolean(values.token),
+      adminKey: maskSecret(values.adminKey),
+      adminKeyConfigured: Boolean(values.adminKey),
+      timeoutMs: values.timeoutMs ?? null,
+      retries: values.retries ?? null
+    },
+    effective: {
+      baseUrl: values.baseUrl ?? CLI_DEFAULT_BASE_URL,
+      tokenConfigured: Boolean(values.token),
+      adminKeyConfigured: Boolean(values.adminKey),
+      timeoutMs: values.timeoutMs ?? CLI_DEFAULT_TIMEOUT_MS,
+      retries: values.retries ?? CLI_DEFAULT_RETRIES
+    }
+  };
+};
+var parseSetKey = (raw) => {
+  const normalized = raw.trim().toLowerCase();
+  const key = KEY_ALIASES[normalized];
+  if (!key) {
+    throw new CliValidationError(
+      `invalid config key '${raw}': expected one of ${VALID_SET_KEYS}`
+    );
+  }
+  return key;
+};
+var parseUnsetKey = (raw) => {
+  const normalized = raw.trim().toLowerCase();
+  if (normalized === "all") {
+    return "all";
+  }
+  return parseSetKey(raw);
+};
+var parseSetValue = (key, rawValue) => {
+  switch (key) {
+    case "baseUrl":
+      return ensureHttpUrl(rawValue, "<value>");
+    case "token":
+      return ensureNonEmpty(rawValue, "<value>");
+    case "adminKey":
+      return ensureNonEmpty(rawValue, "<value>");
+    case "timeoutMs":
+      return ensurePositiveInteger(rawValue, "<value>");
+    case "retries":
+      return ensureNonNegativeInteger(rawValue, "<value>");
+    default: {
+      const exhaustive = key;
+      return exhaustive;
+    }
+  }
+};
+var registerConfigCommands = (program) => {
+  const config = program.command("config").description("Manage global CLI runtime configuration");
+  config.command("show").description("Show persisted global CLI config and effective runtime values").action(function() {
+    try {
+      const snapshot = loadCliPersistedConfig();
+      printJson(
+        {
+          ok: true,
+          ...toConfigOutput(snapshot.path, snapshot.exists, snapshot.values)
+        },
+        resolvePretty(this)
+      );
+    } catch (error) {
+      attachCommandPath(error, "config show");
+      throw error;
+    }
+  });
+  config.command("set").description("Persist one global CLI setting (supports *_ aliases)").argument("<key>", `setting key (${VALID_SET_KEYS})`).argument("<value>", "setting value").action(function(rawKey, rawValue) {
+    try {
+      const key = parseSetKey(rawKey);
+      const value = parseSetValue(key, rawValue);
+      const snapshot = setCliPersistedConfigValue(key, value);
+      printJson(
+        {
+          ok: true,
+          action: "set",
+          key,
+          ...toConfigOutput(snapshot.path, snapshot.exists, snapshot.values)
+        },
+        resolvePretty(this)
+      );
+    } catch (error) {
+      attachCommandPath(error, "config set");
+      throw error;
+    }
+  });
+  config.command("unset").description("Remove one persisted key or clear all keys").argument("<key>", "setting key (base-url|token|admin-key|timeout-ms|retries|all)").action(function(rawKey) {
+    try {
+      const key = parseUnsetKey(rawKey);
+      const snapshot = key === "all" ? clearCliPersistedConfig() : unsetCliPersistedConfigKeys([key]);
+      printJson(
+        {
+          ok: true,
+          action: "unset",
+          key,
+          ...toConfigOutput(snapshot.path, snapshot.exists, snapshot.values)
+        },
+        resolvePretty(this)
+      );
+    } catch (error) {
+      attachCommandPath(error, "config unset");
+      throw error;
+    }
+  });
+};
+
 // src/commands/cycles.ts
 var registerCycleCommands = (program) => {
   const cycles = program.command("cycles").description("Cycle and settlement visibility commands");
@@ -3352,12 +3664,6 @@ var registerTaskCommands = (program) => {
 };
 
 // src/program.ts
-var cliRuntime = loadCliRuntimeConfig();
-var DEFAULT_BASE_URL = cliRuntime.apiBaseUrl;
-var DEFAULT_TOKEN = cliRuntime.token;
-var DEFAULT_ADMIN_KEY = cliRuntime.adminServiceKey;
-var DEFAULT_TIMEOUT_MS2 = cliRuntime.timeoutMs;
-var DEFAULT_RETRIES2 = cliRuntime.retries;
 var GLOBAL_OPTIONS_WITH_VALUE = /* @__PURE__ */ new Set([
   "--base-url",
   "--token",
@@ -3367,12 +3673,21 @@ var GLOBAL_OPTIONS_WITH_VALUE = /* @__PURE__ */ new Set([
 ]);
 var GLOBAL_BOOLEAN_OPTIONS = /* @__PURE__ */ new Set(["--pretty"]);
 var HELP_APPENDIX = `
-Environment variable fallbacks:
-  AGENTRADE_API_BASE_URL
-  AGENTRADE_TOKEN
-  AGENTRADE_ADMIN_SERVICE_KEY
-  AGENTRADE_TIMEOUT_MS
-  AGENTRADE_RETRIES
+CLI runtime setting precedence:
+  1) command flags
+  2) global config file (agentrade config set/show/unset)
+  3) built-in defaults
+
+Global config file path:
+  $AGENTRADE_CLI_CONFIG_PATH
+  or $XDG_CONFIG_HOME/agentrade/config.json
+  or ~/.agentrade/config.json
+
+Built-in defaults:
+  --base-url (default: ${CLI_DEFAULT_BASE_URL})
+  --timeout-ms (default: ${CLI_DEFAULT_TIMEOUT_MS})
+  --retries (default: ${CLI_DEFAULT_RETRIES})
+  --token / --admin-key remain optional unless required by command auth mode
 
 Output contract:
   success: stdout JSON
@@ -3411,10 +3726,11 @@ var detectCommandFromArgv = (argv) => {
 };
 var buildProgram = () => {
   const program = new Command();
-  program.name("agentrade").description("Agentrade CLI for complete agent/admin lifecycle operations").version("0.1.1").option("--base-url <url>", "API base URL", DEFAULT_BASE_URL).option("--token <token>", "bearer token for authenticated routes", DEFAULT_TOKEN).option("--admin-key <key>", "admin service key for admin routes", DEFAULT_ADMIN_KEY).option("--timeout-ms <ms>", "request timeout in milliseconds", DEFAULT_TIMEOUT_MS2).option("--retries <count>", "retry count for network/429/5xx errors", DEFAULT_RETRIES2).option("--pretty", "pretty-print JSON output", false).showHelpAfterError(false).configureOutput({
+  program.name("agentrade").description("Agentrade CLI for complete agent/admin lifecycle operations").version("0.1.2").option("--base-url <url>", "API base URL").option("--token <token>", "bearer token for authenticated routes").option("--admin-key <key>", "admin service key for admin routes").option("--timeout-ms <ms>", "request timeout in milliseconds").option("--retries <count>", "retry count for network/429/5xx errors").option("--pretty", "pretty-print JSON output", false).showHelpAfterError(false).configureOutput({
     writeErr: () => void 0
   }).addHelpText("after", HELP_APPENDIX).exitOverride();
   registerAuthCommands(program);
+  registerConfigCommands(program);
   registerSystemCommands(program);
   registerTaskCommands(program);
   registerSubmissionCommands(program);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@agentrade/cli",
-  "version": "0.1.1",
+  "version": "0.1.2",
   "type": "module",
   "bin": {
     "agentrade": "dist/index.js"
@@ -11,28 +11,27 @@
   "publishConfig": {
     "access": "public"
   },
-  "scripts": {
-    "clean": "rm -rf dist",
-    "dev": "tsx src/index.ts",
-    "build": "tsup --config tsup.config.ts",
-    "prepublishOnly": "pnpm run build",
-    "test": "tsx --test test/**/*.test.ts",
-    "test:persistence": "tsx --test --test-concurrency=1 test/persistence.stress.test.ts",
-    "lint": "tsc -p tsconfig.json --noEmit"
-  },
   "dependencies": {
     "commander": "^13.1.0",
     "viem": "^2.23.5",
     "zod": "^3.24.2"
   },
   "devDependencies": {
-    "@agentrade/config": "workspace:*",
-    "@agentrade/contracts": "workspace:*",
-    "@agentrade/sdk": "workspace:*",
-    "@agentrade/types": "workspace:*",
     "@types/node": "^22.13.10",
     "tsup": "^8.2.4",
     "tsx": "^4.19.3",
-    "typescript": "^5.7.3"
+    "typescript": "^5.7.3",
+    "@agentrade/config": "0.1.0",
+    "@agentrade/sdk": "0.1.0",
+    "@agentrade/contracts": "0.1.0",
+    "@agentrade/types": "0.1.0"
+  },
+  "scripts": {
+    "clean": "rm -rf dist",
+    "dev": "tsx src/index.ts",
+    "build": "tsup --config tsup.config.ts",
+    "test": "tsx --test test/**/*.test.ts",
+    "test:persistence": "tsx --test --test-concurrency=1 test/persistence.stress.test.ts",
+    "lint": "tsc -p tsconfig.json --noEmit"
   }
-}
+}