@asteroidai/cli 1.9.27 → 1.9.28

package/src/sync/paths.ts

@@ -1,45 +0,0 @@
-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

@@ -1,136 +0,0 @@
-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;
-}

package/src/sync/sync.test.ts

@@ -1,502 +0,0 @@
-import { describe, expect, it } from "vitest";
-
-import { UsageError } from "../args";
-import type { BuiltRequest } from "../request";
-import { formatExecutionPull, pullExecution } from "./execution-pull";
-import { sha256 } from "./paths";
-import {
-  type FileTree,
-  get,
-  type LocalFiles,
-  MANIFEST,
-  type Manifest,
-  type Sync,
-} from "./types";
-import { pullWorkflow } from "./workflow-pull";
-import { pushWorkflow } from "./workflow-push";
-
-const WF = "11111111-aaaa-bbbb-cccc-000000000000";
-const HEAD = "22222222-aaaa-bbbb-cccc-000000000000";
-
-function memoryFiles(initial: Record<string, string> = {}) {
-  const store = new Map(
-    Object.entries(initial).map(([path, text]) => [path, Buffer.from(text)]),
-  );
-  const files: LocalFiles = {
-    read: async (path) => store.get(path),
-    write: async (path, bytes) => void store.set(path, Buffer.from(bytes)),
-    remove: async (path) => void store.delete(path),
-    list: async (dir) =>
-      [...store.keys()]
-        .filter((path) => path.startsWith(`${dir}/`))
-        .map((path) => path.slice(dir.length + 1))
-        .sort(),
-  };
-  const text = (path: string) => store.get(path)?.toString("utf8");
-  return { files, store, text };
-}
-
-function fakeRemote(
-  routes: Record<string, (request: BuiltRequest) => unknown>,
-) {
-  const calls: BuiltRequest[] = [];
-  const downloads: string[] = [];
-  const remote = {
-    async json(request: BuiltRequest) {
-      calls.push(request);
-      const handler = routes[`${request.method} ${request.path}`];
-      if (!handler)
-        throw new Error(`unexpected ${request.method} ${request.path}`);
-      return handler(request);
-    },
-    async download(url: string) {
-      downloads.push(url);
-      return Buffer.from(`bytes of ${url}`);
-    },
-  };
-  return { remote, calls, downloads };
-}
-
-function tree(overrides: Partial<FileTree> = {}): FileTree {
-  return {
-    rev: 7,
-    version: 3,
-    versionId: HEAD,
-    workflowName: "Fill Form",
-    files: [
-      {
-        path: "settings.yaml",
-        kind: "structural",
-        size: 14,
-        content: "start: Login\n",
-      },
-      {
-        path: "memory.md",
-        kind: "agent_file",
-        size: 5,
-        contentBase64: Buffer.from("notes").toString("base64"),
-      },
-      { path: "big.pdf", kind: "agent_file", size: 9000000, fileId: "f-big" },
-    ],
-    ...overrides,
-  };
-}
-
-const headFiles = `GET /agents/v2/workflows/${WF}/head/files`;
-const headRequest = () => get(`/agents/v2/workflows/${WF}/head/files`);
-const signedBig = `GET /agents/v2/workflows/${WF}/versions/${HEAD}/files/f-big/signed-url`;
-
-function manifestOf(
-  local: ReturnType<typeof memoryFiles>,
-  dir: string,
-): Manifest {
-  return JSON.parse(local.text(`${dir}/${MANIFEST}`)!) as Manifest;
-}
-
-describe("pullWorkflow", () => {
-  function pulled(initial: Record<string, string> = {}) {
-    const local = memoryFiles(initial);
-    const { remote, calls, downloads } = fakeRemote({
-      [headFiles]: () => tree(),
-      [signedBig]: () => ({ url: "https://storage/big" }),
-    });
-    const sync: Sync = { remote, files: local.files };
-    return { sync, local, calls, downloads };
-  }
-
-  it("writes every file's bytes into the folder", async () => {
-    const { sync, local, downloads } = pulled();
-
-    const result = await pullWorkflow(sync, {
-      workflowId: WF,
-      request: headRequest(),
-      dir: "out/Fill_Form/head",
-    });
-
-    expect(result.dir).toBe("out/Fill_Form/head");
-    expect(local.text("out/Fill_Form/head/settings.yaml")).toBe(
-      "start: Login\n",
-    );
-    expect(local.text("out/Fill_Form/head/memory.md")).toBe("notes");
-    expect(local.text("out/Fill_Form/head/big.pdf")).toBe(
-      "bytes of https://storage/big",
-    );
-    expect(downloads).toEqual(["https://storage/big"]);
-  });
-
-  it("asks for every file's contents", async () => {
-    const { sync, calls } = pulled();
-
-    await pullWorkflow(sync, {
-      workflowId: WF,
-      request: headRequest(),
-      dir: "Fill_Form/head",
-    });
-
-    expect(calls[0].query.get("contents")).toBe("all");
-  });
-
-  it("records the rev and each file's hash for a later push", async () => {
-    const { sync, local } = pulled();
-
-    await pullWorkflow(sync, {
-      workflowId: WF,
-      request: headRequest(),
-      dir: "Fill_Form/head",
-    });
-
-    const manifest = JSON.parse(
-      local.text(`Fill_Form/head/${MANIFEST}`)!,
-    ) as Manifest;
-    expect(manifest).toMatchObject({
-      workflowId: WF,
-      versionId: HEAD,
-      head: true,
-      rev: 7,
-    });
-    expect(manifest.files["memory.md"]).toBe(sha256(Buffer.from("notes")));
-  });
-
-  it("removes local files the workflow no longer has", async () => {
-    const { sync, local } = pulled({
-      "Fill_Form/head/nodes/Old/instructions.md": "gone",
-    });
-
-    await pullWorkflow(sync, {
-      workflowId: WF,
-      request: headRequest(),
-      dir: "Fill_Form/head",
-    });
-
-    expect(local.store.has("Fill_Form/head/nodes/Old/instructions.md")).toBe(
-      false,
-    );
-  });
-
-  it("skips files over the size limit instead of downloading them", async () => {
-    const { sync, local, downloads } = pulled();
-
-    const result = await pullWorkflow(sync, {
-      workflowId: WF,
-      request: headRequest(),
-      dir: "Fill_Form/head",
-      maxFileBytes: 1000,
-    });
-
-    expect(downloads).toEqual([]);
-    expect(local.store.has("Fill_Form/head/big.pdf")).toBe(false);
-    expect(result.skipped).toEqual([
-      "big.pdf (9000000 bytes, over the size limit)",
-    ]);
-  });
-
-  it("marks a pinned version read-only in its manifest", async () => {
-    const local = memoryFiles();
-    const { remote } = fakeRemote({
-      [`GET /agents/v2/workflows/${WF}/versions/${HEAD}/files`]: () =>
-        tree({ files: [] }),
-    });
-
-    const result = await pullWorkflow(
-      { remote, files: local.files },
-      {
-        workflowId: WF,
-        request: get(`/agents/v2/workflows/${WF}/versions/${HEAD}/files`),
-        dir: "v3",
-      },
-    );
-
-    expect(manifestOf(local, "v3").head).toBe(false);
-  });
-
-  it("refuses an entry whose path leaves the folder", async () => {
-    const local = memoryFiles();
-    const { remote } = fakeRemote({
-      [headFiles]: () =>
-        tree({
-          files: [
-            { path: "../escape", kind: "structural", size: 1, content: "x" },
-          ],
-        }),
-    });
-
-    const result = await pullWorkflow(
-      { remote, files: local.files },
-      { workflowId: WF, request: headRequest(), dir: "Fill_Form/head" },
-    );
-
-    expect(result.skipped).toEqual(["../escape (unsafe path)"]);
-    expect([...local.store.keys()]).toEqual([`Fill_Form/head/${MANIFEST}`]);
-  });
-});
-
-describe("pushWorkflow", () => {
-  const dir = "Fill_Form/head";
-
-  function pulledHead(edits: Record<string, string | null>) {
-    const base: Record<string, string> = {
-      "settings.yaml": "start: Login\n",
-      "memory.md": "notes",
-      "old.md": "old",
-    };
-    const manifest: Manifest = {
-      workflowId: WF,
-      versionId: HEAD,
-      head: true,
-      rev: 7,
-      files: Object.fromEntries(
-        Object.entries(base).map(([p, t]) => [p, sha256(Buffer.from(t))]),
-      ),
-    };
-    const merged = { ...base, ...edits };
-    const initial: Record<string, string> = {
-      [`${dir}/${MANIFEST}`]: JSON.stringify(manifest),
-    };
-    for (const [path, text] of Object.entries(merged)) {
-      if (text !== null) initial[`${dir}/${path}`] = text;
-    }
-    return memoryFiles(initial);
-  }
-
-  it("sends changed and new files as writes and removed files as deletes", async () => {
-    const local = pulledHead({
-      "memory.md": "more notes",
-      "new.md": "hi",
-      "old.md": null,
-    });
-    let patched: unknown;
-    const { remote } = fakeRemote({
-      [`PATCH /agents/v2/workflows/${WF}/head/files`]: (request) => {
-        patched = request.json;
-        return {};
-      },
-      [headFiles]: () => tree({ rev: 8, files: [] }),
-    });
-
-    const result = await pushWorkflow({ remote, files: local.files }, dir, WF);
-
-    expect(patched).toEqual({
-      baseRev: 7,
-      writes: [
-        {
-          path: "memory.md",
-          contentBase64: Buffer.from("more notes").toString("base64"),
-        },
-        { path: "new.md", contentBase64: Buffer.from("hi").toString("base64") },
-      ],
-      deletes: ["old.md"],
-    });
-    expect(result).toMatchObject({
-      written: ["memory.md", "new.md"],
-      deleted: ["old.md"],
-      rev: 8,
-    });
-  });
-
-  it("takes the server's rendering of structural files and the new rev", async () => {
-    const local = pulledHead({ "settings.yaml": "start:   Login\n" });
-    const { remote } = fakeRemote({
-      [`PATCH /agents/v2/workflows/${WF}/head/files`]: () => ({}),
-      [headFiles]: () =>
-        tree({
-          rev: 8,
-          files: [
-            {
-              path: "settings.yaml",
-              kind: "structural",
-              size: 13,
-              content: "start: Login\n",
-            },
-            { path: "memory.md", kind: "agent_file", size: 5 },
-            { path: "old.md", kind: "agent_file", size: 3 },
-          ],
-        }),
-    });
-
-    await pushWorkflow({ remote, files: local.files }, dir, WF);
-
-    expect(local.text(`${dir}/settings.yaml`)).toBe("start: Login\n");
-    const manifest = JSON.parse(local.text(`${dir}/${MANIFEST}`)!) as Manifest;
-    expect(manifest.rev).toBe(8);
-    expect(manifest.files["settings.yaml"]).toBe(
-      sha256(Buffer.from("start: Login\n")),
-    );
-  });
-
-  it("sends nothing when the folder matches the pull", async () => {
-    const local = pulledHead({});
-    const { remote, calls } = fakeRemote({});
-
-    const result = await pushWorkflow({ remote, files: local.files }, dir, WF);
-
-    expect(calls).toEqual([]);
-    expect(result).toMatchObject({ written: [], deleted: [], rev: 7 });
-  });
-
-  it("tells the user to pull again when the head moved", async () => {
-    const local = pulledHead({ "memory.md": "edit" });
-    const { remote } = fakeRemote({
-      [`PATCH /agents/v2/workflows/${WF}/head/files`]: () => {
-        throw Object.assign(new Error("stale"), { status: 409 });
-      },
-    });
-
-    const push = pushWorkflow({ remote, files: local.files }, dir, WF);
-
-    await expect(push).rejects.toThrow(UsageError);
-    await expect(push).rejects.toThrow("changed since your pull");
-  });
-
-  it("refuses a folder with no pull in it", async () => {
-    const { remote } = fakeRemote({});
-
-    const push = pushWorkflow({ remote, files: memoryFiles().files }, dir, WF);
-
-    await expect(push).rejects.toThrow("no pulled workflow");
-  });
-
-  it("refuses a folder pulled from another workflow", async () => {
-    const local = pulledHead({});
-    const { remote } = fakeRemote({});
-
-    const push = pushWorkflow({ remote, files: local.files }, dir, "other");
-
-    await expect(push).rejects.toThrow(`holds workflow ${WF}, not other`);
-  });
-
-  it("refuses a pinned version", async () => {
-    const manifest = {
-      workflowId: WF,
-      versionId: HEAD,
-      head: false,
-      rev: 1,
-      files: {},
-    };
-    const local = memoryFiles({
-      [`${dir}/${MANIFEST}`]: JSON.stringify(manifest),
-    });
-    const { remote } = fakeRemote({});
-
-    const push = pushWorkflow({ remote, files: local.files }, dir, WF);
-
-    await expect(push).rejects.toThrow("read-only");
-  });
-});
-
-describe("pullExecution", () => {
-  const EX = "33333333-aaaa-bbbb-cccc-000000000000";
-  const execution = {
-    id: EX,
-    status: "completed",
-    workflowId: WF,
-    workflowVersionId: HEAD,
-    workflowName: "Fill Form",
-    createdAt: "2026-10-09T10:00:00Z",
-    executionResult: { outcome: "success", reasoning: "done" },
-  };
-  const file = (id: string, directory: string, name: string, size = 10) => ({
-    id,
-    fileName: name,
-    filePath: `org/${EX}/${directory}/${name}`,
-    fileSize: size,
-    directory,
-  });
-
-  function setup(overrides: Record<string, unknown> = {}) {
-    const local = memoryFiles();
-    const { remote, downloads } = fakeRemote({
-      [`GET /agents/v2/executions/${EX}`]: () => ({
-        ...execution,
-        ...overrides,
-      }),
-      [`GET /agents/v2/executions/${EX}/activities`]: () => [
-        { payload: { activityType: "generic", message: "hello" } },
-      ],
-      [`GET /agents/v2/executions/${EX}/files`]: () => ({
-        directories: {
-          workspace: [file("a", "workspace", "out.csv")],
-          downloads: [file("b", "downloads", "big.zip", 5000)],
-          uploads: [file("c", "uploads", "input.pdf")],
-        },
-      }),
-      [`GET /agents/v2/executions/${EX}/files/a/signed-url`]: () => ({
-        url: "https://s/a",
-      }),
-      [`GET /agents/v2/executions/${EX}/files/b/signed-url`]: () => ({
-        url: "https://s/b",
-      }),
-    });
-    return { sync: { remote, files: local.files }, local, downloads };
-  }
-
-  it("writes the summary, activities and run files under the workflow's executions folder", async () => {
-    const { sync, local } = setup();
-
-    const result = await pullExecution(sync, { executionId: EX, root: "" });
-
-    const dir = "Fill_Form/executions/33333333";
-    expect(result.dir).toBe(dir);
-    expect(JSON.parse(local.text(`${dir}/summary.json`)!).id).toBe(EX);
-    expect(local.text(`${dir}/activities.md`)).toContain("[message]:\nhello");
-    expect(local.text(`${dir}/workspace/out.csv`)).toBe("bytes of https://s/a");
-    expect(local.text(`${dir}/downloads/big.zip`)).toBe("bytes of https://s/b");
-    expect(local.store.has(`${dir}/uploads/input.pdf`)).toBe(false);
-  });
-
-  it("filters files by glob and size and names what it skipped", async () => {
-    const { sync, downloads } = setup();
-
-    const result = await pullExecution(sync, {
-      executionId: EX,
-      root: "",
-      glob: "**/*.zip",
-      maxFileBytes: 100,
-    });
-
-    expect(downloads).toEqual([]);
-    expect(result.skipped).toEqual([
-      "workspace/out.csv (excluded by --files)",
-      "downloads/big.zip (5000 bytes, over the size limit)",
-    ]);
-  });
-
-  it("skips downloads with files off", async () => {
-    const { sync, downloads } = setup();
-
-    const result = await pullExecution(sync, {
-      executionId: EX,
-      root: "",
-      files: false,
-    });
-
-    expect(downloads).toEqual([]);
-    expect(formatExecutionPull(result)).toContain(
-      "downloads skipped (--no-files)",
-    );
-  });
-
-  it("stops at the summary for a purged run", async () => {
-    const { sync, local } = setup({ purgedAt: "2026-10-01T00:00:00Z" });
-
-    const result = await pullExecution(sync, { executionId: EX, root: "" });
-
-    expect(result.written).toEqual(["summary.json"]);
-    expect(local.store.has("Fill_Form/executions/33333333/activities.md")).toBe(
-      false,
-    );
-    expect(formatExecutionPull(result)).toContain("retention-purged");
-  });
-
-  it("uses the folder a caller chooses", async () => {
-    const { sync } = setup();
-
-    const result = await pullExecution(sync, {
-      executionId: EX,
-      root: "",
-      files: false,
-      dir: () => "mine/executions/x",
-    });
-
-    expect(result.dir).toBe("mine/executions/x");
-  });
-});