@asteroidai/cli 1.9.4 → 1.9.12

package/src/sync/node-files.ts

@@ -0,0 +1,47 @@
+import { mkdir, readdir, readFile, rm, writeFile } from "node:fs/promises";
+import { dirname, relative, resolve, sep } from "node:path";
+
+import type { LocalFiles } from "./types";
+
+function missing(error: unknown): boolean {
+  return (error as NodeJS.ErrnoException).code === "ENOENT";
+}
+
+async function walk(root: string, dir: string, out: string[]): Promise<void> {
+  for (const entry of await readdir(dir, { withFileTypes: true })) {
+    const path = resolve(dir, entry.name);
+    if (entry.isDirectory()) await walk(root, path, out);
+    else if (entry.isFile())
+      out.push(relative(root, path).split(sep).join("/"));
+  }
+}
+
+export function nodeFiles(cwd: string): LocalFiles {
+  const at = (path: string) => resolve(cwd, path);
+  return {
+    async read(path) {
+      try {
+        return new Uint8Array(await readFile(at(path)));
+      } catch (error) {
+        if (missing(error)) return undefined;
+        throw error;
+      }
+    },
+    async write(path, bytes) {
+      await mkdir(dirname(at(path)), { recursive: true });
+      await writeFile(at(path), bytes);
+    },
+    async remove(path) {
+      await rm(at(path), { force: true });
+    },
+    async list(dir) {
+      const out: string[] = [];
+      try {
+        await walk(at(dir), at(dir), out);
+      } catch (error) {
+        if (!missing(error)) throw error;
+      }
+      return out.sort();
+    },
+  };
+}

package/src/sync/paths.ts

@@ -0,0 +1,45 @@
+import { agentDirName } from "@asteroid/workflow-files/names";
+import { createHash } from "node:crypto";
+
+export {
+  agentDirName,
+  executionDirName,
+  workflowDirName,
+} from "@asteroid/workflow-files/names";
+
+export function join(...parts: string[]): string {
+  return parts
+    .filter((part) => part !== "")
+    .join("/")
+    .replace(/\/{2,}/g, "/");
+}
+
+export function workflowRoot(root: string, workflowName: string): string {
+  return join(root, agentDirName(workflowName));
+}
+
+export function isContained(path: string): boolean {
+  if (path === "" || path.startsWith("/") || path.includes("\\")) return false;
+  return path.split("/").every((segment) => segment !== ".." && segment !== "");
+}
+
+export function sha256(bytes: Uint8Array): string {
+  return createHash("sha256").update(bytes).digest("hex");
+}
+
+export function matchesGlob(path: string, pattern: string): boolean {
+  let source = "";
+  for (let i = 0; i < pattern.length; i++) {
+    const ch = pattern[i];
+    if (ch === "*" && pattern[i + 1] === "*" && pattern[i + 2] === "/") {
+      source += "(?:.*/)?";
+      i += 2;
+    } else if (ch === "*" && pattern[i + 1] === "*") {
+      source += ".*";
+      i += 1;
+    } else if (ch === "*") source += "[^/]*";
+    else if (ch === "?") source += "[^/]";
+    else source += ch.replace(/[.+^${}()|[\]\\]/g, "\\$&");
+  }
+  return new RegExp(`^${source}$`).test(path);
+}

package/src/sync/run.ts

@@ -0,0 +1,136 @@
+import { type Parsed, UsageError } from "../args";
+import { buildRequest, type InputReader } from "../request";
+import type { CliCommand } from "../types";
+import {
+  type ExecutionPullOptions,
+  formatExecutionPull,
+  pullExecution,
+} from "./execution-pull";
+import { nodeFiles } from "./node-files";
+import type { LocalFiles, Remote, Sync } from "./types";
+import {
+  formatWorkflowPull,
+  pullWorkflow,
+  type WorkflowPullOptions,
+} from "./workflow-pull";
+import { formatWorkflowPush, pushWorkflow } from "./workflow-push";
+
+export { SYNC_COMMANDS } from "./commands";
+
+export interface SyncDeps {
+  cwd: string;
+  remote: Remote;
+  files?: LocalFiles;
+  stdout: (text: string) => void;
+  root?: string;
+  io?: InputReader;
+  workflowPull?: Partial<WorkflowPullOptions>;
+  executionPull?: Partial<ExecutionPullOptions>;
+}
+
+function flag(parsed: Parsed, name: string): string | undefined {
+  return parsed.flags.get(name)?.at(-1);
+}
+
+function integer(parsed: Parsed, name: string): number | undefined {
+  const raw = flag(parsed, name);
+  if (raw === undefined) return undefined;
+  if (!/^\d+$/.test(raw))
+    throw new UsageError(`--${name} must be a whole number`);
+  return Number(raw);
+}
+
+function executionOptions(parsed: Parsed): Omit<ExecutionPullOptions, "root"> {
+  const summaryOnly = flag(parsed, "summary-only") === "true";
+  const glob = flag(parsed, "files");
+  const dir = flag(parsed, "dir");
+  return {
+    executionId: parsed.positionals[0],
+    activities: !summaryOnly,
+    files: !summaryOnly && glob !== "false",
+    glob: glob === "false" ? undefined : glob,
+    maxFileBytes: integer(parsed, "max-file-size"),
+    dir: dir ? () => dir : undefined,
+  };
+}
+
+function withoutFlag(parsed: Parsed, name: string): Parsed {
+  const flags = new Map(parsed.flags);
+  flags.delete(name);
+  return { ...parsed, flags };
+}
+
+export function runsLocally(command: CliCommand, parsed: Parsed): boolean {
+  if (command.local) return true;
+  if (command.files === "pull") return !parsed.json;
+  if (command.files === "push") return parsed.body === undefined;
+  return false;
+}
+
+const PARTIAL = ["paths", "variants"];
+
+function rejectPartial(parsed: Parsed) {
+  const used = PARTIAL.filter((name) => parsed.flags.has(name));
+  if (used.length === 0) return;
+  throw new UsageError(
+    `pull writes the whole tree, so it cannot take ${used.map((name) => `--${name}`).join(" or ")}. Add --json to list those files instead.`,
+  );
+}
+
+async function pull(
+  command: CliCommand,
+  parsed: Parsed,
+  sync: Sync,
+  deps: SyncDeps,
+) {
+  rejectPartial(parsed);
+  const result = await pullWorkflow(sync, {
+    workflowId: parsed.positionals[0],
+    request: await buildRequest(command, withoutFlag(parsed, "out"), {
+      io: deps.io,
+    }),
+    dir: flag(parsed, "out"),
+    root: deps.root ?? "",
+    ...deps.workflowPull,
+  });
+  return { result, text: formatWorkflowPull(result) };
+}
+
+async function execute(
+  command: CliCommand,
+  parsed: Parsed,
+  sync: Sync,
+  deps: SyncDeps,
+) {
+  if (command.files === "pull") return pull(command, parsed, sync, deps);
+  if (command.files === "push") {
+    const result = await pushWorkflow(
+      sync,
+      flag(parsed, "from") ?? ".",
+      parsed.positionals[0] || undefined,
+    );
+    return { result, text: formatWorkflowPush(result) };
+  }
+  if (command.command !== "execution pull")
+    throw new UsageError(`unknown command ${command.command}`);
+  const result = await pullExecution(sync, {
+    ...executionOptions(parsed),
+    root: deps.root ?? "",
+    ...deps.executionPull,
+  });
+  return { result, text: formatExecutionPull(result) };
+}
+
+export async function runSync(
+  command: CliCommand,
+  parsed: Parsed,
+  deps: SyncDeps,
+) {
+  const sync = {
+    remote: deps.remote,
+    files: deps.files ?? nodeFiles(deps.cwd),
+  };
+  const { result, text } = await execute(command, parsed, sync, deps);
+  deps.stdout(`${parsed.json ? JSON.stringify(result, null, 2) : text}\n`);
+  return 0;
+}