@actiondock/cli 2.0.0

package/src/commands/state.ts

@@ -0,0 +1,396 @@
+import { existsSync } from "node:fs";
+import {
+  createStorage,
+  filterWithFallbackInfo,
+  findProjectRoot,
+  listLinkedPackages,
+  loadProjectConfig,
+  resolvePackageRoot,
+} from "@actiondock/core";
+import { Command } from "commander";
+import { resolveIntent } from "../utils/filter";
+
+function getTargetRoot(packageOption?: string, keyHint?: string): { root: string; key: string } {
+  let targetPackage = packageOption;
+  let effectiveKey = keyHint || "";
+
+  if (!targetPackage && keyHint) {
+    if (keyHint.includes("/")) {
+      const slashIdx = keyHint.indexOf("/");
+      targetPackage = keyHint.slice(0, slashIdx);
+      effectiveKey = keyHint.slice(slashIdx + 1);
+    }
+  }
+
+  const root = resolvePackageRoot(targetPackage);
+  if (!root) {
+    if (targetPackage) {
+      console.error(`Error: Package '${targetPackage}' not found in linked packages or path`);
+    } else {
+      console.error(
+        "Error: Not in an ActionDock project (actiondock.json not found).\nPlease specify -P, --package <id> or cd into a project directory."
+      );
+    }
+    process.exit(1);
+  }
+  return { root, key: effectiveKey };
+}
+
+export function registerStateCommands(program: Command): void {
+  const stateCmd = program
+    .command("state")
+    .description("Inspect and manage Shared State store");
+
+  // state list
+  stateCmd
+    .command("list [prefix]")
+    .description("List state keys matching prefix, namespace, or intent pattern (in current project or linked packages)")
+    .option("-P, --package <id>", "Target package ID or path")
+    .option("-n, --namespace <ns>", "Filter by specific namespace")
+    .option("-i, --intent <pattern>", "Regex or fuzzy intent filter; falls back to full list when no match")
+    .option("--no-fallback", "Disable fallback to full list when no items match intent")
+    .option("-d, --detail", "Show detailed state entry objects (including namespace, expiration, update time)")
+    .option("--json", "Output as JSON")
+    .action(async (prefix = "", options) => {
+      try {
+        const effectiveIntent = resolveIntent(options.intent, prefix ? [prefix] : []);
+        const shouldFallback = options.fallback !== false;
+
+        const targetRoot = options.package
+          ? resolvePackageRoot(options.package)
+          : findProjectRoot();
+
+        if (options.package && !targetRoot) {
+          console.error(`Error: Package '${options.package}' not found in linked packages or path`);
+          process.exit(1);
+        }
+
+        if (targetRoot) {
+          const projConfig = loadProjectConfig(targetRoot);
+          const storage = createStorage(projConfig.id, { projectRoot: targetRoot });
+
+          if (options.detail && options.json) {
+            const entries = await storage.listStateEntries({
+              namespace: options.namespace,
+              prefix: prefix || undefined,
+            });
+            storage.close();
+
+            const filterRes = filterWithFallbackInfo(
+              entries,
+              effectiveIntent,
+              [(e) => e.fullKey, (e) => e.key, (e) => e.namespace],
+              shouldFallback
+            );
+
+            console.log(JSON.stringify(filterRes.items, null, 2));
+            return;
+          }
+
+          const allKeys = await storage.listStateKeys(
+            options.namespace !== undefined ? options.namespace : null,
+            prefix
+          );
+          storage.close();
+
+          const filterRes = filterWithFallbackInfo(
+            allKeys,
+            effectiveIntent,
+            [(k) => k],
+            shouldFallback
+          );
+
+          if (options.json) {
+            console.log(JSON.stringify(filterRes.items, null, 2));
+          } else {
+            const nsDesc = options.namespace ? ` [namespace: ${options.namespace}]` : "";
+            const filterDesc = prefix ? ` (filter: ${prefix})` : "";
+            console.log(`State keys for ${projConfig.id} (${targetRoot})${nsDesc}${filterDesc}:\n`);
+            if (filterRes.isFallback && effectiveIntent) {
+              console.log(`(No state keys matched intent '${effectiveIntent}', showing all keys)\n`);
+            }
+            if (filterRes.items.length === 0) {
+              console.log("  (no state keys found)\n");
+            } else {
+              for (const k of filterRes.items) {
+                console.log(`  - ${k}`);
+              }
+            }
+          }
+          return;
+        }
+
+        // Outside project: list state keys across all linked packages
+        const linkedList = listLinkedPackages();
+        if (linkedList.length === 0) {
+          console.log("No ActionDock project in current directory, and no packages linked.");
+          console.log("Run 'ac link' inside an Action package to register it.");
+          return;
+        }
+
+        const aggregated: Array<{
+          packageId: string;
+          packageName: string;
+          path: string;
+          keys: string[];
+          entries?: any[];
+        }> = [];
+
+        for (const pkg of linkedList) {
+          if (!existsSync(pkg.path)) continue;
+          try {
+            const projConfig = loadProjectConfig(pkg.path);
+            const storage = createStorage(projConfig.id, { projectRoot: pkg.path });
+
+            if (options.detail && options.json) {
+              const entries = await storage.listStateEntries({
+                namespace: options.namespace,
+                prefix: prefix || undefined,
+              });
+              storage.close();
+              aggregated.push({
+                packageId: pkg.id,
+                packageName: pkg.name,
+                path: pkg.path,
+                keys: entries.map((e) => e.fullKey),
+                entries,
+              });
+            } else {
+              const keys = await storage.listStateKeys(
+                options.namespace !== undefined ? options.namespace : null,
+                prefix
+              );
+              storage.close();
+              aggregated.push({
+                packageId: pkg.id,
+                packageName: pkg.name,
+                path: pkg.path,
+                keys,
+              });
+            }
+          } catch {
+            // Ignore broken linked package
+          }
+        }
+
+        let filteredPackages: typeof aggregated = [];
+        if (!effectiveIntent) {
+          filteredPackages = aggregated;
+        } else {
+          for (const pkg of aggregated) {
+            const pkgMatches = filterWithFallbackInfo(
+              [pkg],
+              effectiveIntent,
+              [(p) => p.packageId, (p) => p.packageName, (p) => p.path],
+              false
+            ).matchedCount > 0;
+
+            if (pkgMatches) {
+              filteredPackages.push(pkg);
+            } else {
+              const matchedKeys = filterWithFallbackInfo(
+                pkg.keys,
+                effectiveIntent,
+                [(k) => k],
+                false
+              ).items;
+
+              if (matchedKeys.length > 0) {
+                filteredPackages.push({
+                  ...pkg,
+                  keys: matchedKeys,
+                });
+              }
+            }
+          }
+
+          if (filteredPackages.length === 0 && shouldFallback) {
+            filteredPackages = aggregated;
+          }
+        }
+
+        if (options.json) {
+          console.log(JSON.stringify(filteredPackages, null, 2));
+        } else {
+          console.log("State Keys in Linked Packages:\n");
+          for (const pkg of filteredPackages) {
+            console.log(`* Package: ${pkg.packageId} (${pkg.path})`);
+            if (pkg.keys.length === 0) {
+              console.log("    (no state keys found)");
+            } else {
+              for (const k of pkg.keys) {
+                console.log(`    - ${k}`);
+              }
+            }
+          }
+        }
+      } catch (err: any) {
+        console.error(`Error: ${err.message}`);
+        process.exit(1);
+      }
+    });
+
+  // state get
+  stateCmd
+    .command("get <key>")
+    .description("Get a state value by key, namespace:key, or package/namespace:key")
+    .option("-P, --package <id>", "Target package ID or path")
+    .option("-n, --namespace <ns>", "Target namespace")
+    .option("--json", "Output as JSON")
+    .action(async (rawKey, options) => {
+      const { root, key } = getTargetRoot(options.package, rawKey);
+      try {
+        const projConfig = loadProjectConfig(root);
+        const storage = createStorage(projConfig.id, { projectRoot: root });
+
+        let val: unknown;
+        let entryNamespace = options.namespace || "";
+
+        if (options.namespace !== undefined) {
+          val = await storage.getState(options.namespace, key);
+        } else {
+          const entry = await storage.findState(key);
+          if (entry) {
+            val = entry.value;
+            entryNamespace = entry.namespace;
+          }
+        }
+        storage.close();
+
+        if (val === undefined) {
+          console.error(`Error: State key '${key}' not found in ${projConfig.id}`);
+          process.exit(1);
+        }
+
+        if (options.json) {
+          console.log(
+            JSON.stringify(
+              {
+                key,
+                packageId: projConfig.id,
+                namespace: entryNamespace,
+                value: val,
+              },
+              null,
+              2
+            )
+          );
+        } else {
+          console.log(val !== undefined ? JSON.stringify(val, null, 2) : "undefined");
+        }
+      } catch (err: any) {
+        console.error(`Error: ${err.message}`);
+        process.exit(1);
+      }
+    });
+
+  // state set
+  stateCmd
+    .command("set <key> <value>")
+    .description("Set a state value by key, namespace:key, or package/namespace:key")
+    .option("-P, --package <id>", "Target package ID or path")
+    .option("-n, --namespace <ns>", "Target namespace")
+    .option("--ttl <seconds>", "Time to live in seconds", (v) => parseInt(v, 10))
+    .action(async (rawKey, rawValue, options) => {
+      const { root, key } = getTargetRoot(options.package, rawKey);
+      try {
+        const projConfig = loadProjectConfig(root);
+        const storage = createStorage(projConfig.id, { projectRoot: root });
+
+        let ns = "";
+        let actualKey = key;
+
+        if (options.namespace !== undefined) {
+          ns = options.namespace;
+          actualKey = key;
+        } else if (key.includes(":")) {
+          const colonIdx = key.indexOf(":");
+          ns = key.slice(0, colonIdx);
+          actualKey = key.slice(colonIdx + 1);
+        }
+
+        let parsed: unknown = rawValue;
+        try {
+          parsed = JSON.parse(rawValue);
+        } catch {
+          parsed = rawValue;
+        }
+
+        await storage.setState(ns, actualKey, parsed, options.ttl);
+        storage.close();
+
+        const displayKey = ns ? `${ns}:${actualKey}` : actualKey;
+        console.log(
+          `[OK] State '${displayKey}' set to ${JSON.stringify(parsed)}${options.ttl ? ` (TTL: ${options.ttl}s)` : ""} in ${projConfig.id}`
+        );
+      } catch (err: any) {
+        console.error(`Error: ${err.message}`);
+        process.exit(1);
+      }
+    });
+
+  // state delete
+  stateCmd
+    .command("delete <key>")
+    .alias("rm")
+    .description("Delete a state value by key, namespace:key, or package/namespace:key")
+    .option("-P, --package <id>", "Target package ID or path")
+    .option("-n, --namespace <ns>", "Target namespace")
+    .option("--silent", "Do not exit with error if key is not found")
+    .action(async (rawKey, options) => {
+      const { root, key } = getTargetRoot(options.package, rawKey);
+      try {
+        const projConfig = loadProjectConfig(root);
+        const storage = createStorage(projConfig.id, { projectRoot: root });
+        const deleted = await storage.deleteStateSmart(key, options.namespace);
+        storage.close();
+
+        if (deleted) {
+          console.log(`[OK] State '${key}' deleted from ${projConfig.id}`);
+        } else {
+          if (!options.silent) {
+            console.error(`Error: State key '${key}' not found in ${projConfig.id}`);
+            process.exit(1);
+          }
+        }
+      } catch (err: any) {
+        console.error(`Error: ${err.message}`);
+        process.exit(1);
+      }
+    });
+
+  // state clear
+  stateCmd
+    .command("clear [prefix]")
+    .alias("clean")
+    .description("Clear state entries by namespace, prefix, or all")
+    .option("-P, --package <id>", "Target package ID or path")
+    .option("-n, --namespace <ns>", "Target namespace to clear")
+    .option("-a, --all", "Clear all state entries across all namespaces in this package")
+    .action(async (prefix = "", options) => {
+      const { root } = getTargetRoot(options.package);
+      try {
+        const projConfig = loadProjectConfig(root);
+        const storage = createStorage(projConfig.id, { projectRoot: root });
+        const count = await storage.clearState({
+          namespace: options.namespace,
+          all: options.all,
+          prefix: prefix || undefined,
+        });
+        storage.close();
+
+        const scopeDesc = options.all
+          ? "all namespaces"
+          : options.namespace
+            ? `namespace '${options.namespace}'`
+            : prefix
+              ? `prefix '${prefix}'`
+              : "root namespace";
+        console.log(`[OK] Cleared ${count} state entry(s) (${scopeDesc}) from ${projConfig.id}`);
+      } catch (err: any) {
+        console.error(`Error: ${err.message}`);
+        process.exit(1);
+      }
+    });
+}
+

package/src/commands/test.ts

@@ -0,0 +1,26 @@
+import { findProjectRoot } from "@actiondock/core";
+import { Command } from "commander";
+
+export function registerTestCommand(program: Command): void {
+  program
+    .command("test [pattern]")
+    .description("Run project tests using Bun test runner")
+    .action((pattern) => {
+      const root = findProjectRoot();
+      const cwd = root || process.cwd();
+
+      const args = ["bun", "test"];
+      if (pattern) {
+        args.push(pattern);
+      }
+
+      const proc = Bun.spawnSync(args, {
+        cwd,
+        stdio: ["inherit", "inherit", "inherit"],
+      });
+
+      if (proc.exitCode !== 0) {
+        process.exit(proc.exitCode ?? 1);
+      }
+    });
+}

package/src/index.ts

@@ -0,0 +1,20 @@
+export * from "./commands";
+
+import { createCliProgram } from "./commands";
+
+/**
+ * ActionDock CLI 主执行入口函数。
+ * 
+ * @param argv 命令行参数数组（默认使用 process.argv）
+ */
+export async function main(argv: string[] = process.argv): Promise<void> {
+  const program = createCliProgram();
+  await program.parseAsync(argv);
+}
+
+if (import.meta.main) {
+  main().catch((err) => {
+    console.error("Fatal error:", err);
+    process.exit(1);
+  });
+}

package/src/utils/bytes.ts

@@ -0,0 +1,36 @@
+/**
+ * Parses human-readable byte size string into number of bytes.
+ * e.g. "1mb" -> 1048576, "500kb" -> 512000, "1048576" -> 1048576
+ */
+export function parseByteSize(str: string): number {
+  const trimmed = str.trim().toLowerCase();
+  const match = trimmed.match(/^(\d+(?:\.\d+)?)\s*([a-z]+)?$/);
+  if (!match) {
+    const num = Number(trimmed);
+    if (!isNaN(num) && num > 0) return num;
+    throw new Error(`Invalid byte size format: '${str}'. Examples: '1mb', '500kb', '1048576'`);
+  }
+
+  const value = parseFloat(match[1]);
+  const unit = match[2] || "b";
+
+  switch (unit) {
+    case "b":
+    case "bytes":
+      return Math.floor(value);
+    case "k":
+    case "kb":
+    case "kib":
+      return Math.floor(value * 1024);
+    case "m":
+    case "mb":
+    case "mib":
+      return Math.floor(value * 1024 * 1024);
+    case "g":
+    case "gb":
+    case "gib":
+      return Math.floor(value * 1024 * 1024 * 1024);
+    default:
+      throw new Error(`Unsupported byte size unit '${unit}' in '${str}'`);
+  }
+}

package/src/utils/duration.ts

@@ -0,0 +1 @@
+export { parseDuration } from "@actiondock/core";

package/src/utils/filter.ts

@@ -0,0 +1,24 @@
+/**
+ * Resolves effective intent string from an explicit option (--intent)
+ * and optional positional pattern arguments.
+ * Multiple terms are combined with '|' (regex OR).
+ */
+export function resolveIntent(
+  optionsIntent?: string,
+  positionalPatterns?: string[]
+): string | undefined {
+  const parts: string[] = [];
+  if (optionsIntent && optionsIntent.trim()) {
+    parts.push(optionsIntent.trim());
+  }
+  if (positionalPatterns && positionalPatterns.length > 0) {
+    for (const p of positionalPatterns) {
+      if (typeof p === "string" && p.trim()) {
+        parts.push(p.trim());
+      }
+    }
+  }
+  if (parts.length === 0) return undefined;
+  if (parts.length === 1) return parts[0];
+  return parts.join("|");
+}