@asteroidai/cli 1.9.2 → 1.9.11

package/src/sync/workflow-push.ts

@@ -0,0 +1,155 @@
+import { UsageError } from "../args";
+import { join, sha256 } from "./paths";
+import {
+  type FileTree,
+  get,
+  MANIFEST,
+  type Manifest,
+  statusOf,
+  type Sync,
+} from "./types";
+import { writeManifest } from "./workflow-pull";
+
+export interface WorkflowPushResult {
+  workflowId: string;
+  dir: string;
+  written: string[];
+  deleted: string[];
+  rev: number;
+  versionId: string;
+}
+
+export async function readManifest(sync: Sync, dir: string): Promise<Manifest> {
+  const bytes = await sync.files.read(join(dir, MANIFEST));
+  if (!bytes) {
+    throw new UsageError(
+      `no pulled workflow in ${dir}. Run \`asteroid workflow pull <workflow-id>\`, then push from the head folder it writes.`,
+    );
+  }
+  const manifest = JSON.parse(Buffer.from(bytes).toString("utf8")) as Manifest;
+  if (!manifest.head) {
+    throw new UsageError(
+      `${dir} holds a pinned workflow version, which is read-only. Push from a pulled head.`,
+    );
+  }
+  return manifest;
+}
+
+async function localChanges(sync: Sync, dir: string, manifest: Manifest) {
+  const local = (await sync.files.list(dir)).filter(
+    (path) => path !== MANIFEST,
+  );
+  const writes: { path: string; contentBase64: string; hash: string }[] = [];
+  for (const path of local) {
+    const bytes = await sync.files.read(join(dir, path));
+    if (!bytes) continue;
+    const hash = sha256(bytes);
+    if (manifest.files[path] === hash) continue;
+    writes.push({
+      path,
+      contentBase64: Buffer.from(bytes).toString("base64"),
+      hash,
+    });
+  }
+  const present = new Set(local);
+  const deletes = Object.keys(manifest.files).filter(
+    (path) => !present.has(path),
+  );
+  return { writes, deletes };
+}
+
+async function patch(
+  sync: Sync,
+  manifest: Manifest,
+  writes: { path: string; contentBase64: string }[],
+  deletes: string[],
+) {
+  try {
+    await sync.remote.json({
+      method: "PATCH",
+      path: `/agents/v2/workflows/${manifest.workflowId}/head/files`,
+      query: new URLSearchParams(),
+      json: { baseRev: manifest.rev, writes, deletes },
+    });
+  } catch (error) {
+    if (statusOf(error) !== 409) throw error;
+    throw new UsageError(
+      `the workflow head changed since your pull (rev ${manifest.rev}). Copy your edits aside, run \`asteroid workflow pull ${manifest.workflowId}\`, reapply them, then push again.`,
+    );
+  }
+}
+
+async function refresh(
+  sync: Sync,
+  dir: string,
+  manifest: Manifest,
+  pushed: Map<string, string>,
+) {
+  const tree = (await sync.remote.json(
+    get(`/agents/v2/workflows/${manifest.workflowId}/head/files`),
+  )) as FileTree;
+  const files: Record<string, string> = {};
+  for (const entry of tree.files) {
+    if (entry.content !== undefined) {
+      const bytes = Buffer.from(entry.content, "utf8");
+      files[entry.path] = sha256(bytes);
+      if (pushed.get(entry.path) !== files[entry.path])
+        await sync.files.write(join(dir, entry.path), bytes);
+    } else {
+      const local = await sync.files.read(join(dir, entry.path));
+      const hash = local
+        ? sha256(local)
+        : (pushed.get(entry.path) ?? entry.checksum);
+      if (hash) files[entry.path] = hash;
+    }
+  }
+  for (const path of await sync.files.list(dir)) {
+    if (path !== MANIFEST && !(path in files))
+      await sync.files.remove(join(dir, path));
+  }
+  const next = { ...manifest, versionId: tree.versionId, rev: tree.rev, files };
+  await writeManifest(sync, dir, next);
+  return next;
+}
+
+export async function pushWorkflow(
+  sync: Sync,
+  dir: string,
+): Promise<WorkflowPushResult> {
+  const manifest = await readManifest(sync, dir);
+  const { writes, deletes } = await localChanges(sync, dir, manifest);
+  const result = {
+    workflowId: manifest.workflowId,
+    dir,
+    written: writes.map((w) => w.path),
+    deleted: deletes,
+  };
+  if (writes.length === 0 && deletes.length === 0) {
+    return { ...result, rev: manifest.rev, versionId: manifest.versionId };
+  }
+  await patch(
+    sync,
+    manifest,
+    writes.map(({ path, contentBase64 }) => ({ path, contentBase64 })),
+    deletes,
+  );
+  const next = await refresh(
+    sync,
+    dir,
+    manifest,
+    new Map(writes.map((w) => [w.path, w.hash])),
+  );
+  return { ...result, rev: next.rev, versionId: next.versionId };
+}
+
+export function formatWorkflowPush(result: WorkflowPushResult): string {
+  if (result.written.length === 0 && result.deleted.length === 0) {
+    return `Nothing to push: ${result.dir}/ matches the head you pulled (rev ${result.rev}).`;
+  }
+  return [
+    `Pushed to workflow ${result.workflowId}: ${result.written.length} written, ${result.deleted.length} deleted.`,
+    ...result.written.map((path) => `  + ${path}`),
+    ...result.deleted.map((path) => `  - ${path}`),
+    `Head is now rev ${result.rev} (version ${result.versionId}).`,
+  ].join("\n");
+}

package/src/types.ts

@@ -16,6 +16,7 @@ export interface Option {
   description?: string;
   enum?: string[];
   explode?: boolean;
+  negatable?: boolean;
 }
 
 export interface BodySpec {
@@ -39,4 +40,5 @@ export interface CliCommand {
   binary: boolean;
   readOnly: boolean;
   destructive: boolean;
+  local?: boolean;
 }