@agfs/cli 0.1.0 → 0.1.2

package/dist/index.js

@@ -7,21 +7,179 @@ import { Command } from "commander";
 import { createReadStream, createWriteStream } from "fs";
 import { mkdir as mkdir2, stat } from "fs/promises";
 import path3 from "path";
-import { Transform } from "stream";
+import { Readable, Transform } from "stream";
 import { lookup as lookupMime } from "mime-types";
-import {
-  devicePollResponseSchema,
-  deviceStartResponseSchema,
-  listEntriesResponseSchema,
-  shareCreateResponseSchema,
-  shareListResponseSchema,
-  successResponseSchema,
-  tokenCreateResponseSchema,
-  tokenListResponseSchema,
-  treeEntriesResponseSchema,
-  uploadIntentSchema,
-  whoAmIResponseSchema
-} from "@agfs/contracts";
+
+// ../contracts/src/index.ts
+import { z } from "zod";
+var ENTRY_KIND_VALUES = ["file", "folder"];
+var TOKEN_SOURCE_VALUES = ["session", "api-token"];
+var DEVICE_STATUS_VALUES = ["pending", "approved", "consumed", "expired"];
+var STORAGE_PLAN_ID_VALUES = ["free", "paid"];
+var pathSchema = z.string().min(1).max(4096).startsWith("/");
+var ttlSchema = z.string().regex(/^\d+\s*(m|h|d)$/i, "TTL must use m, h, or d units");
+var entryKindSchema = z.enum(ENTRY_KIND_VALUES);
+var tokenSourceSchema = z.enum(TOKEN_SOURCE_VALUES);
+var deviceStatusSchema = z.enum(DEVICE_STATUS_VALUES);
+var storagePlanIdSchema = z.enum(STORAGE_PLAN_ID_VALUES);
+var sessionUserSchema = z.object({
+  id: z.string(),
+  name: z.string().nullable(),
+  email: z.string().email(),
+  image: z.string().url().nullable().optional()
+});
+var fsEntrySchema = z.object({
+  id: z.string(),
+  ownerId: z.string(),
+  parentPath: z.string().nullable(),
+  path: pathSchema,
+  name: z.string(),
+  kind: entryKindSchema,
+  size: z.number().int().nonnegative().nullable(),
+  contentType: z.string().nullable(),
+  etag: z.string().nullable(),
+  updatedAt: z.string(),
+  createdAt: z.string()
+});
+var fsTreeNodeSchema = z.lazy(
+  () => z.object({
+    id: z.string(),
+    path: pathSchema,
+    name: z.string(),
+    kind: entryKindSchema,
+    size: z.number().int().nonnegative().nullable(),
+    children: z.array(fsTreeNodeSchema).optional()
+  })
+);
+var uploadIntentSchema = z.object({
+  uploadId: z.string(),
+  url: z.string().url(),
+  method: z.literal("PUT"),
+  headers: z.record(z.string(), z.string()),
+  objectKey: z.string(),
+  expiresAt: z.string()
+});
+var apiTokenRecordSchema = z.object({
+  id: z.string(),
+  label: z.string(),
+  prefix: z.string(),
+  lastUsedAt: z.string().nullable(),
+  expiresAt: z.string().nullable(),
+  createdAt: z.string(),
+  revokedAt: z.string().nullable()
+});
+var shareLinkRecordSchema = z.object({
+  id: z.string(),
+  path: pathSchema,
+  url: z.string().url(),
+  expiresAt: z.string(),
+  createdAt: z.string(),
+  revokedAt: z.string().nullable()
+});
+var whoAmIResponseSchema = z.object({
+  user: sessionUserSchema,
+  authSource: tokenSourceSchema
+});
+var accountSummarySchema = z.object({
+  planId: storagePlanIdSchema,
+  planName: z.string(),
+  storageUsedBytes: z.number().int().nonnegative(),
+  storageLimitBytes: z.number().int().nonnegative(),
+  storageRemainingBytes: z.number().int().nonnegative(),
+  isOverLimit: z.boolean(),
+  paidPlanComingSoon: z.boolean()
+});
+var deviceStartRequestSchema = z.object({
+  clientName: z.string().min(1).max(100).default("agfs cli")
+});
+var deviceStartResponseSchema = z.object({
+  deviceCode: z.string(),
+  userCode: z.string(),
+  verificationUri: z.string().url(),
+  verificationUriComplete: z.string().url(),
+  intervalSeconds: z.number().int().positive(),
+  expiresAt: z.string()
+});
+var devicePollRequestSchema = z.object({
+  deviceCode: z.string().min(1)
+});
+var devicePollResponseSchema = z.union([
+  z.object({
+    status: z.literal("pending"),
+    intervalSeconds: z.number().int().positive(),
+    expiresAt: z.string()
+  }),
+  z.object({
+    status: z.literal("approved"),
+    accessToken: z.string(),
+    tokenType: z.literal("Bearer"),
+    expiresAt: z.string().nullable()
+  }),
+  z.object({
+    status: z.literal("expired")
+  })
+]);
+var deviceApproveRequestSchema = z.object({
+  userCode: z.string().min(1),
+  label: z.string().min(1).max(100).default("CLI login")
+});
+var listEntriesRequestSchema = z.object({
+  path: pathSchema.default("/")
+});
+var listEntriesResponseSchema = z.object({
+  path: pathSchema,
+  entries: z.array(fsEntrySchema)
+});
+var treeEntriesRequestSchema = z.object({
+  path: pathSchema.default("/")
+});
+var treeEntriesResponseSchema = z.object({
+  path: pathSchema,
+  tree: z.array(fsTreeNodeSchema)
+});
+var mkdirRequestSchema = z.object({
+  path: pathSchema
+});
+var moveEntryRequestSchema = z.object({
+  from: pathSchema,
+  to: pathSchema
+});
+var deleteEntryRequestSchema = z.object({
+  path: pathSchema,
+  recursive: z.boolean().default(false)
+});
+var uploadIntentRequestSchema = z.object({
+  path: pathSchema,
+  contentType: z.string().min(1).max(255),
+  size: z.number().int().nonnegative()
+});
+var uploadCommitRequestSchema = z.object({
+  etag: z.string().min(1)
+});
+var shareCreateRequestSchema = z.object({
+  path: pathSchema,
+  ttl: ttlSchema.default("15m")
+});
+var shareCreateResponseSchema = z.object({
+  share: shareLinkRecordSchema
+});
+var shareListResponseSchema = z.object({
+  shares: z.array(shareLinkRecordSchema)
+});
+var tokenListResponseSchema = z.object({
+  tokens: z.array(apiTokenRecordSchema)
+});
+var tokenCreateRequestSchema = z.object({
+  label: z.string().min(1).max(100),
+  ttl: ttlSchema.optional()
+});
+var tokenCreateResponseSchema = z.object({
+  token: z.string(),
+  record: apiTokenRecordSchema
+});
+var successResponseSchema = z.object({
+  ok: z.literal(true)
+});
 
 // src/lib/config.ts
 import { chmod, mkdir, readFile, writeFile } from "fs/promises";
@@ -225,6 +383,10 @@ var AgfsClient = class _AgfsClient {
     const response = await this.request("/api/v1/whoami");
     return whoAmIResponseSchema.parse(await response.json());
   }
+  async account() {
+    const response = await this.request("/api/v1/account");
+    return accountSummarySchema.parse(await response.json());
+  }
   async startDeviceLogin(clientName = "agfs cli") {
     const response = await this.request("/api/v1/device/start", {
       method: "POST",
@@ -298,13 +460,14 @@ var AgfsClient = class _AgfsClient {
     });
     let uploadResponse;
     try {
+      const uploadBody = Readable.toWeb(createReadStream(localPath).pipe(progressStream));
       uploadResponse = await fetch(intent.url, {
         method: intent.method,
         headers: {
           ...intent.headers,
           "Content-Length": String(fileSize)
         },
-        body: createReadStream(localPath).pipe(progressStream),
+        body: uploadBody,
         duplex: "half"
       });
       if (!uploadResponse.ok) {
@@ -491,6 +654,46 @@ function registerAuthCommands(program2) {
 }
 
 // src/lib/format.ts
+function formatStorageBytes(bytes) {
+  if (!Number.isFinite(bytes) || bytes < 1024) {
+    return `${bytes} B`;
+  }
+  if (bytes < 1024 * 1024) {
+    return `${(bytes / 1024).toFixed(1)} KB`;
+  }
+  if (bytes < 1024 * 1024 * 1024) {
+    return `${(bytes / (1024 * 1024)).toFixed(1)} MB`;
+  }
+  return `${(bytes / (1024 * 1024 * 1024)).toFixed(1)} GB`;
+}
+function renderMeter(currentBytes, limitBytes, width = 24) {
+  if (limitBytes <= 0) {
+    return `[${"-".repeat(width)}]`;
+  }
+  const ratio = Math.min(currentBytes / limitBytes, 1);
+  const filled = Math.round(ratio * width);
+  return `[${"#".repeat(filled).padEnd(width, "-")}]`;
+}
+function wrapInBox(title, lines) {
+  const width = Math.max(title.length, ...lines.map((line) => line.length));
+  const top = `\u256D${"\u2500".repeat(width + 2)}\u256E`;
+  const bottom = `\u2570${"\u2500".repeat(width + 2)}\u256F`;
+  const content = [`\u2502 ${title.padEnd(width)} \u2502`, ...lines.map((line) => `\u2502 ${line.padEnd(width)} \u2502`)];
+  return [top, ...content, bottom].join("\n");
+}
+function renderAccountSummary(summary) {
+  const percentUsed = summary.storageLimitBytes > 0 ? Math.round(summary.storageUsedBytes / summary.storageLimitBytes * 100) : 0;
+  const status = summary.isOverLimit ? `Over by ${formatStorageBytes(summary.storageUsedBytes - summary.storageLimitBytes)}` : `${percentUsed}% used`;
+  const lines = [
+    `Plan      ${summary.planName}`,
+    `Used      ${formatStorageBytes(summary.storageUsedBytes)} / ${formatStorageBytes(summary.storageLimitBytes)}`,
+    `Left      ${formatStorageBytes(summary.storageRemainingBytes)}`,
+    `Status    ${status}`,
+    `Meter     ${renderMeter(summary.storageUsedBytes, summary.storageLimitBytes)}`,
+    ...summary.paidPlanComingSoon && summary.planId === "free" ? ["Upgrade   Paid self-serve is coming soon"] : []
+  ];
+  return wrapInBox("AGFS storage", lines);
+}
 function renderEntries(entries) {
   if (entries.length === 0) {
     return "(empty)";
@@ -529,6 +732,11 @@ function registerFsCommands(program2) {
     const result = await client.tree(pathname);
     console.log(renderTree(result.tree));
   });
+  program2.command("usage").description("Show the current plan, storage usage, and remaining quota").action(async () => {
+    const client = await AgfsClient.fromConfig();
+    const result = await client.account();
+    console.log(renderAccountSummary(result));
+  });
   program2.command("mkdir").description("Create a folder path").argument("<path>", "Remote path").action(async (pathname) => {
     const client = await AgfsClient.fromConfig();
     await client.mkdir(pathname);

package/package.json

@@ -1,22 +1,28 @@
 {
   "name": "@agfs/cli",
-  "version": "0.1.0",
+  "version": "0.1.2",
   "type": "module",
   "bin": {
     "agfs": "./dist/index.js"
   },
+  "files": [
+    "dist"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
   "scripts": {
-    "build": "tsup src/index.ts --format esm --dts --clean",
+    "build": "tsup --config tsup.config.ts",
     "test": "vitest run --passWithNoTests",
     "typecheck": "tsc --noEmit"
   },
   "dependencies": {
-    "@agfs/contracts": "workspace:*",
     "commander": "^14.0.0",
     "mime-types": "^3.0.1",
     "zod": "^4.1.12"
   },
   "devDependencies": {
+    "@agfs/contracts": "workspace:*",
     "@types/mime-types": "^3.0.1",
     "tsup": "^8.5.0",
     "typescript": "^5.8.3"

package/src/commands/auth.ts

@@ -1,73 +0,0 @@
-import { Command } from "commander";
-import { AgfsClient } from "../lib/client";
-import { readConfig, writeConfig } from "../lib/config";
-
-function sleep(ms: number) {
-  return new Promise((resolve) => setTimeout(resolve, ms));
-}
-
-export function registerAuthCommands(program: Command) {
-  program
-    .command("login")
-    .description("Authenticate the CLI with device flow or a provided API token")
-    .option("--token <token>", "Persist an existing AGFS API token")
-    .option("--base-url <url>", "Override the AGFS base URL for this machine")
-    .action(async (options: { token?: string; baseUrl?: string }) => {
-      const config = await readConfig();
-      const baseUrl = options.baseUrl ?? config.baseUrl ?? process.env.AGFS_BASE_URL ?? "https://agfs.dev";
-
-      if (options.token) {
-        await writeConfig({
-          ...config,
-          baseUrl,
-          token: options.token,
-        });
-        console.log(`Stored AGFS token for ${baseUrl}`);
-        return;
-      }
-
-      const client = new AgfsClient(baseUrl.replace(/\/+$/, ""), null);
-      const start = await client.startDeviceLogin("agfs cli");
-      console.log(`Open ${start.verificationUriComplete}`);
-      console.log(`Code: ${start.userCode}`);
-
-      while (true) {
-        const result = await client.pollDeviceLogin(start.deviceCode);
-        if (result.status === "approved") {
-          await writeConfig({
-            ...config,
-            baseUrl,
-            token: result.accessToken,
-          });
-          console.log("Login approved and token stored.");
-          return;
-        }
-        if (result.status === "expired") {
-          throw new Error("Device login expired before approval");
-        }
-
-        await sleep(result.intervalSeconds * 1000);
-      }
-    });
-
-  program
-    .command("logout")
-    .description("Clear the locally stored AGFS token")
-    .action(async () => {
-      const config = await readConfig();
-      await writeConfig({
-        ...config,
-        token: undefined,
-      });
-      console.log("Removed local AGFS token.");
-    });
-
-  program
-    .command("whoami")
-    .description("Show the current authenticated user")
-    .action(async () => {
-      const client = await AgfsClient.fromConfig();
-      const result = await client.whoAmI();
-      console.log(`${result.user.email} (${result.authSource})`);
-    });
-}

package/src/commands/fs.ts

@@ -1,96 +0,0 @@
-import { Command } from "commander";
-import { AgfsClient } from "../lib/client";
-import { renderEntries, renderTree } from "../lib/format";
-
-export function registerFsCommands(program: Command) {
-  program
-    .command("ls")
-    .description("List the direct children at a remote path")
-    .argument("[path]", "Remote path", "/")
-    .action(async (pathname: string) => {
-      const client = await AgfsClient.fromConfig();
-      const result = await client.list(pathname);
-      console.log(renderEntries(result.entries));
-    });
-
-  program
-    .command("tree")
-    .description("Render a tree view of a remote folder")
-    .argument("[path]", "Remote path", "/")
-    .action(async (pathname: string) => {
-      const client = await AgfsClient.fromConfig();
-      const result = await client.tree(pathname);
-      console.log(renderTree(result.tree));
-    });
-
-  program
-    .command("mkdir")
-    .description("Create a folder path")
-    .argument("<path>", "Remote path")
-    .action(async (pathname: string) => {
-      const client = await AgfsClient.fromConfig();
-      await client.mkdir(pathname);
-      console.log(`Created ${pathname}`);
-    });
-
-  program
-    .command("mv")
-    .description("Move or rename a file or folder")
-    .argument("<from>", "Current path")
-    .argument("<to>", "Destination path")
-    .action(async (from: string, to: string) => {
-      const client = await AgfsClient.fromConfig();
-      await client.move(from, to);
-      console.log(`Moved ${from} -> ${to}`);
-    });
-
-  program
-    .command("rm")
-    .description("Delete a file or folder")
-    .argument("<path>", "Remote path")
-    .option("--recursive", "Delete folders recursively")
-    .action(async (pathname: string, options: { recursive?: boolean }) => {
-      const client = await AgfsClient.fromConfig();
-      await client.remove(pathname, Boolean(options.recursive));
-      console.log(`Removed ${pathname}`);
-    });
-
-  program
-    .command("upload")
-    .description("Upload a local file into AGFS")
-    .argument("<localPath>", "Local file path")
-    .argument("[remotePath]", "Remote destination path")
-    .option("--share <ttl>", "Create a preview link after upload")
-    .action(async (localPath: string, remotePath: string | undefined, options: { share?: string }) => {
-      const client = await AgfsClient.fromConfig();
-      const destination = remotePath ?? `/${localPath.split("/").at(-1)}`;
-      await client.upload(localPath, destination);
-      console.log(`Uploaded ${destination}`);
-      if (options.share) {
-        const share = await client.share(destination, options.share);
-        console.log(`Share URL: ${share.share.url}`);
-      }
-    });
-
-  program
-    .command("download")
-    .description("Download a file or folder from AGFS")
-    .argument("<remotePath>", "Remote file or folder path")
-    .argument("[localPath]", "Destination path on disk")
-    .action(async (remotePath: string, localPath?: string) => {
-      const client = await AgfsClient.fromConfig();
-      const destination = await client.download(remotePath, localPath);
-      console.log(`Saved ${destination}`);
-    });
-
-  program
-    .command("share")
-    .description("Generate a preview URL for a file")
-    .argument("<remotePath>", "Remote file path")
-    .option("--ttl <ttl>", "Link lifetime", "15m")
-    .action(async (remotePath: string, options: { ttl: string }) => {
-      const client = await AgfsClient.fromConfig();
-      const result = await client.share(remotePath, options.ttl);
-      console.log(result.share.url);
-    });
-}

package/src/index.ts

@@ -1,17 +0,0 @@
-#!/usr/bin/env node
-import { Command } from "commander";
-import { registerAuthCommands } from "./commands/auth";
-import { registerFsCommands } from "./commands/fs";
-
-const program = new Command()
-  .name("agfs")
-  .description("AgentFilesystem CLI")
-  .version("0.1.0");
-
-registerAuthCommands(program);
-registerFsCommands(program);
-
-program.parseAsync(process.argv).catch((error: unknown) => {
-  console.error(error instanceof Error ? error.message : "Command failed");
-  process.exitCode = 1;
-});

package/src/lib/client.ts

@@ -1,307 +0,0 @@
-import { createReadStream, createWriteStream } from "node:fs";
-import { mkdir, stat } from "node:fs/promises";
-import path from "node:path";
-import { Transform } from "node:stream";
-import { lookup as lookupMime } from "mime-types";
-import {
-  devicePollResponseSchema,
-  deviceStartResponseSchema,
-  listEntriesResponseSchema,
-  shareCreateResponseSchema,
-  shareListResponseSchema,
-  successResponseSchema,
-  tokenCreateResponseSchema,
-  tokenListResponseSchema,
-  treeEntriesResponseSchema,
-  uploadIntentSchema,
-  whoAmIResponseSchema,
-} from "@agfs/contracts";
-import { getResolvedBaseUrl, getResolvedToken, readConfig } from "./config";
-import { flattenTree, getRemoteLeafName, joinRelativeDestination, resolveFileDestination, resolveFolderDestination } from "./download";
-import { summarizeFolderDownload, TransferProgress } from "./progress";
-
-async function parseError(response: Response) {
-  try {
-    const payload = await response.json();
-    return payload.error ?? response.statusText;
-  } catch {
-    return response.statusText;
-  }
-}
-
-export class AgfsClient {
-  constructor(
-    readonly baseUrl: string,
-    readonly token: string | null,
-  ) {}
-
-  static async fromConfig() {
-    const config = await readConfig();
-    return new AgfsClient(getResolvedBaseUrl(config), getResolvedToken(config));
-  }
-
-  private async request(pathname: string, init?: RequestInit) {
-    const headers = new Headers(init?.headers);
-    if (this.token) {
-      headers.set("authorization", `Bearer ${this.token}`);
-    }
-
-    const response = await fetch(`${this.baseUrl}${pathname}`, {
-      ...init,
-      headers,
-    });
-
-    if (!response.ok) {
-      throw new Error(await parseError(response));
-    }
-
-    return response;
-  }
-
-  async whoAmI() {
-    const response = await this.request("/api/v1/whoami");
-    return whoAmIResponseSchema.parse(await response.json());
-  }
-
-  async startDeviceLogin(clientName = "agfs cli") {
-    const response = await this.request("/api/v1/device/start", {
-      method: "POST",
-      headers: { "content-type": "application/json" },
-      body: JSON.stringify({ clientName }),
-    });
-    return deviceStartResponseSchema.parse(await response.json());
-  }
-
-  async pollDeviceLogin(deviceCode: string) {
-    const response = await this.request("/api/v1/device/poll", {
-      method: "POST",
-      headers: { "content-type": "application/json" },
-      body: JSON.stringify({ deviceCode }),
-    });
-    return devicePollResponseSchema.parse(await response.json());
-  }
-
-  async list(pathname: string) {
-    const response = await this.request(`/api/v1/fs/list?path=${encodeURIComponent(pathname)}`);
-    return listEntriesResponseSchema.parse(await response.json());
-  }
-
-  async tree(pathname: string) {
-    const response = await this.request(`/api/v1/fs/tree?path=${encodeURIComponent(pathname)}`);
-    return treeEntriesResponseSchema.parse(await response.json());
-  }
-
-  async mkdir(pathname: string) {
-    const response = await this.request("/api/v1/fs/mkdir", {
-      method: "POST",
-      headers: { "content-type": "application/json" },
-      body: JSON.stringify({ path: pathname }),
-    });
-    return successResponseSchema.parse(await response.json());
-  }
-
-  async move(from: string, to: string) {
-    const response = await this.request("/api/v1/fs/move", {
-      method: "POST",
-      headers: { "content-type": "application/json" },
-      body: JSON.stringify({ from, to }),
-    });
-    return successResponseSchema.parse(await response.json());
-  }
-
-  async remove(pathname: string, recursive = false) {
-    const response = await this.request("/api/v1/fs/delete", {
-      method: "POST",
-      headers: { "content-type": "application/json" },
-      body: JSON.stringify({ path: pathname, recursive }),
-    });
-    return successResponseSchema.parse(await response.json());
-  }
-
-  async upload(localPath: string, remotePath: string) {
-    const fileStat = await stat(localPath);
-    const fileSize = fileStat.size;
-    const contentType = lookupMime(localPath) || "application/octet-stream";
-    const intentResponse = await this.request("/api/v1/fs/upload-intents", {
-      method: "POST",
-      headers: { "content-type": "application/json" },
-      body: JSON.stringify({
-        path: remotePath,
-        contentType,
-        size: fileSize,
-      }),
-    });
-    const intent = uploadIntentSchema.parse(await intentResponse.json());
-    const progress = new TransferProgress(`Upload ${path.basename(localPath)}`, fileSize);
-    let uploadedBytes = 0;
-    const progressStream = new Transform({
-      transform(chunk, _encoding, callback) {
-        uploadedBytes += chunk.length;
-        progress.update(uploadedBytes);
-        callback(null, chunk);
-      },
-    });
-
-    let uploadResponse: Response;
-    try {
-      uploadResponse = await fetch(intent.url, {
-        method: intent.method,
-        headers: {
-          ...intent.headers,
-          "Content-Length": String(fileSize),
-        },
-        body: createReadStream(localPath).pipe(progressStream),
-        duplex: "half",
-      });
-      if (!uploadResponse.ok) {
-        throw new Error(`R2 upload failed with status ${uploadResponse.status}`);
-      }
-      progress.complete();
-    } catch (error) {
-      progress.fail();
-      throw error;
-    }
-
-    const commitResponse = await this.request(`/api/v1/fs/uploads/${intent.uploadId}/commit`, {
-      method: "POST",
-      headers: { "content-type": "application/json" },
-      body: JSON.stringify({
-        etag: uploadResponse.headers.get("etag") ?? "uploaded",
-      }),
-    });
-
-    return await commitResponse.json();
-  }
-
-  private async writeRemoteFile(remotePath: string, localPath?: string) {
-    const response = await this.request(`/api/v1/fs/download?path=${encodeURIComponent(remotePath)}`);
-    let destination = resolveFileDestination(remotePath, localPath);
-    if (localPath) {
-      try {
-        const localStat = await stat(localPath);
-        if (localStat.isDirectory()) {
-          destination = path.join(localPath, getRemoteLeafName(remotePath));
-        }
-      } catch {
-        // Treat a missing path as the intended file destination.
-      }
-    }
-
-    await mkdir(path.dirname(destination), { recursive: true });
-    const totalBytes = Number(response.headers.get("content-length") ?? 0);
-    const progress = new TransferProgress(`Download ${path.basename(destination)}`, totalBytes || 0);
-    const body = response.body;
-    if (!body) {
-      progress.fail();
-      throw new Error(`No response body returned for ${remotePath}`);
-    }
-
-    const writer = createWriteStream(destination);
-    const reader = body.getReader();
-    let writtenBytes = 0;
-
-    try {
-      while (true) {
-        const { done, value } = await reader.read();
-        if (done) {
-          break;
-        }
-
-        writtenBytes += value.byteLength;
-        progress.update(totalBytes > 0 ? writtenBytes : Math.max(writtenBytes, 1));
-
-        await new Promise<void>((resolve, reject) => {
-          writer.write(Buffer.from(value), (error) => {
-            if (error) {
-              reject(error);
-              return;
-            }
-            resolve();
-          });
-        });
-      }
-
-      await new Promise<void>((resolve, reject) => {
-        writer.end((error) => {
-          if (error) {
-            reject(error);
-            return;
-          }
-          resolve();
-        });
-      });
-
-      if (totalBytes > 0) {
-        progress.complete();
-      } else {
-        progress.update(writtenBytes);
-        progress.complete();
-      }
-    } catch (error) {
-      progress.fail();
-      writer.destroy();
-      throw error;
-    }
-
-    return destination;
-  }
-
-  async download(remotePath: string, localPath?: string) {
-    let isFolder = false;
-    try {
-      await this.list(remotePath);
-      isFolder = true;
-    } catch {
-      isFolder = false;
-    }
-
-    if (!isFolder) {
-      return this.writeRemoteFile(remotePath, localPath);
-    }
-
-    const destinationRoot = resolveFolderDestination(remotePath, localPath);
-    await mkdir(destinationRoot, { recursive: true });
-
-    const tree = await this.tree(remotePath);
-    const flattened = flattenTree(tree.tree);
-
-    for (const directory of flattened.directories) {
-      await mkdir(joinRelativeDestination(destinationRoot, directory), { recursive: true });
-    }
-
-    for (const file of flattened.files) {
-      await this.writeRemoteFile(file.path, joinRelativeDestination(destinationRoot, file.relativePath));
-    }
-
-    console.error(summarizeFolderDownload(flattened.files.length, destinationRoot));
-    return destinationRoot;
-  }
-
-  async share(pathname: string, ttl = "15m") {
-    const response = await this.request("/api/v1/shares", {
-      method: "POST",
-      headers: { "content-type": "application/json" },
-      body: JSON.stringify({ path: pathname, ttl }),
-    });
-    return shareCreateResponseSchema.parse(await response.json());
-  }
-
-  async listTokens() {
-    const response = await this.request("/api/v1/tokens");
-    return tokenListResponseSchema.parse(await response.json());
-  }
-
-  async createToken(label: string, ttl?: string) {
-    const response = await this.request("/api/v1/tokens", {
-      method: "POST",
-      headers: { "content-type": "application/json" },
-      body: JSON.stringify({ label, ttl }),
-    });
-    return tokenCreateResponseSchema.parse(await response.json());
-  }
-
-  async listShares() {
-    const response = await this.request("/api/v1/shares");
-    return shareListResponseSchema.parse(await response.json());
-  }
-}

package/src/lib/config.test.ts

@@ -1,31 +0,0 @@
-import { mkdtemp, rm } from "node:fs/promises";
-import os from "node:os";
-import path from "node:path";
-import { afterEach, beforeEach, describe, expect, it } from "vitest";
-import { getConfigPath, readConfig, writeConfig } from "./config";
-
-let tempDir = "";
-const previousXdg = process.env.XDG_CONFIG_HOME;
-
-describe("config persistence", () => {
-  beforeEach(async () => {
-    tempDir = await mkdtemp(path.join(os.tmpdir(), "agfs-cli-"));
-    process.env.XDG_CONFIG_HOME = tempDir;
-  });
-
-  afterEach(async () => {
-    process.env.XDG_CONFIG_HOME = previousXdg;
-    if (tempDir) {
-      await rm(tempDir, { recursive: true, force: true });
-    }
-  });
-
-  it("writes and reads config from XDG config home", async () => {
-    await writeConfig({ baseUrl: "https://example.com", token: "secret" });
-    expect(getConfigPath()).toContain(tempDir);
-    await expect(readConfig()).resolves.toEqual({
-      baseUrl: "https://example.com",
-      token: "secret",
-    });
-  });
-});

package/src/lib/config.ts

@@ -1,42 +0,0 @@
-import { chmod, mkdir, readFile, writeFile } from "node:fs/promises";
-import os from "node:os";
-import path from "node:path";
-
-export interface CliConfig {
-  baseUrl?: string;
-  token?: string;
-}
-
-function getConfigDir() {
-  return process.env.XDG_CONFIG_HOME
-    ? path.join(process.env.XDG_CONFIG_HOME, "agfs")
-    : path.join(os.homedir(), ".config", "agfs");
-}
-
-export function getConfigPath() {
-  return path.join(getConfigDir(), "config.json");
-}
-
-export async function readConfig(): Promise<CliConfig> {
-  try {
-    const content = await readFile(getConfigPath(), "utf8");
-    return JSON.parse(content) as CliConfig;
-  } catch {
-    return {};
-  }
-}
-
-export async function writeConfig(config: CliConfig) {
-  const filePath = getConfigPath();
-  await mkdir(path.dirname(filePath), { recursive: true });
-  await writeFile(filePath, JSON.stringify(config, null, 2), "utf8");
-  await chmod(filePath, 0o600);
-}
-
-export function getResolvedBaseUrl(config: CliConfig) {
-  return (process.env.AGFS_BASE_URL ?? config.baseUrl ?? "https://agfs.dev").replace(/\/+$/, "");
-}
-
-export function getResolvedToken(config: CliConfig) {
-  return process.env.AGFS_TOKEN ?? config.token ?? null;
-}

package/src/lib/download.test.ts

@@ -1,71 +0,0 @@
-import { describe, expect, it } from "vitest";
-import { flattenTree, getRemoteLeafName, joinRelativeDestination, resolveFolderDestination } from "./download";
-
-describe("getRemoteLeafName", () => {
-  it("uses the final segment for normal paths", () => {
-    expect(getRemoteLeafName("/screenshots/shot.png")).toBe("shot.png");
-    expect(getRemoteLeafName("/screenshots")).toBe("screenshots");
-  });
-
-  it("uses agfs-root for root downloads", () => {
-    expect(getRemoteLeafName("/")).toBe("agfs-root");
-  });
-});
-
-describe("flattenTree", () => {
-  it("separates directories and files while preserving relative paths", () => {
-    const result = flattenTree([
-      {
-        id: "dir_1",
-        path: "/screenshots",
-        name: "screenshots",
-        kind: "folder",
-        size: null,
-        children: [
-          {
-            id: "file_1",
-            path: "/screenshots/a.png",
-            name: "a.png",
-            kind: "file",
-            size: 12,
-          },
-          {
-            id: "dir_2",
-            path: "/screenshots/nested",
-            name: "nested",
-            kind: "folder",
-            size: null,
-            children: [
-              {
-                id: "file_2",
-                path: "/screenshots/nested/b.png",
-                name: "b.png",
-                kind: "file",
-                size: 18,
-              },
-            ],
-          },
-        ],
-      },
-    ] as any);
-
-    expect(result.directories).toEqual(["screenshots", "screenshots/nested"]);
-    expect(result.files).toEqual([
-      {
-        path: "/screenshots/a.png",
-        relativePath: "screenshots/a.png",
-      },
-      {
-        path: "/screenshots/nested/b.png",
-        relativePath: "screenshots/nested/b.png",
-      },
-    ]);
-  });
-});
-
-describe("destination helpers", () => {
-  it("uses the provided folder destination as-is", () => {
-    expect(resolveFolderDestination("/screenshots", "./downloads")).toBe("./downloads");
-    expect(joinRelativeDestination("./downloads", "screenshots/a.png")).toBe("downloads/screenshots/a.png");
-  });
-});

package/src/lib/download.ts

@@ -1,58 +0,0 @@
-import path from "node:path";
-import type { FsTreeNode } from "@agfs/contracts";
-
-export interface FlattenedTree {
-  directories: string[];
-  files: Array<{
-    path: string;
-    relativePath: string;
-  }>;
-}
-
-export function getRemoteLeafName(remotePath: string): string {
-  const normalized = remotePath.replace(/\/+$/, "");
-  if (!normalized || normalized === "/") {
-    return "agfs-root";
-  }
-
-  return normalized.split("/").filter(Boolean).at(-1) ?? "agfs-root";
-}
-
-export function flattenTree(nodes: FsTreeNode[]): FlattenedTree {
-  const directories: string[] = [];
-  const files: Array<{ path: string; relativePath: string }> = [];
-
-  function walk(items: FsTreeNode[], parentSegments: string[]) {
-    for (const item of items) {
-      const segments = [...parentSegments, item.name];
-      const relativePath = segments.join("/");
-
-      if (item.kind === "folder") {
-        directories.push(relativePath);
-        walk((item.children ?? []) as FsTreeNode[], segments);
-        continue;
-      }
-
-      files.push({
-        path: item.path,
-        relativePath,
-      });
-    }
-  }
-
-  walk(nodes, []);
-
-  return { directories, files };
-}
-
-export function resolveFolderDestination(remotePath: string, localPath?: string): string {
-  return localPath ?? getRemoteLeafName(remotePath);
-}
-
-export function resolveFileDestination(remotePath: string, localPath?: string): string {
-  return localPath ?? getRemoteLeafName(remotePath);
-}
-
-export function joinRelativeDestination(root: string, relativePath: string): string {
-  return path.join(root, ...relativePath.split("/"));
-}

package/src/lib/format.test.ts

@@ -1,49 +0,0 @@
-import { describe, expect, it } from "vitest";
-import { renderEntries, renderTree } from "./format";
-
-describe("renderEntries", () => {
-  it("renders a tabular listing", () => {
-    expect(
-      renderEntries([
-        {
-          id: "1",
-          ownerId: "user_1",
-          parentPath: "/",
-          path: "/shots",
-          name: "shots",
-          kind: "folder",
-          size: null,
-          contentType: null,
-          etag: null,
-          createdAt: new Date().toISOString(),
-          updatedAt: new Date().toISOString(),
-        },
-      ]),
-    ).toContain("/shots\tfolder\tfolder");
-  });
-});
-
-describe("renderTree", () => {
-  it("renders nested branches", () => {
-    expect(
-      renderTree([
-        {
-          id: "folder_1",
-          path: "/shots",
-          name: "shots",
-          kind: "folder",
-          size: null,
-          children: [
-            {
-              id: "file_1",
-              path: "/shots/a.png",
-              name: "a.png",
-              kind: "file",
-              size: 128,
-            },
-          ],
-        },
-      ]),
-    ).toContain("shots/");
-  });
-});

package/src/lib/format.ts

@@ -1,33 +0,0 @@
-import type { FsEntry, FsTreeNode } from "@agfs/contracts";
-
-export function renderEntries(entries: FsEntry[]) {
-  if (entries.length === 0) {
-    return "(empty)";
-  }
-
-  return entries
-    .map((entry) => {
-      const size = entry.size == null ? "folder" : `${entry.size} bytes`;
-      return `${entry.path}\t${entry.kind}\t${size}`;
-    })
-    .join("\n");
-}
-
-function renderTreeNode(node: FsTreeNode, prefix: string, isLast: boolean): string[] {
-  const branch = prefix ? `${prefix}${isLast ? "└─ " : "├─ "}` : "";
-  const lines = [`${branch}${node.name}${node.kind === "folder" ? "/" : ""}`];
-  const nextPrefix = prefix ? `${prefix}${isLast ? "   " : "│  "}` : "";
-  const children = (node.children ?? []) as FsTreeNode[];
-  children.forEach((child, index) => {
-    lines.push(...renderTreeNode(child, nextPrefix, index === children.length - 1));
-  });
-  return lines;
-}
-
-export function renderTree(nodes: FsTreeNode[]) {
-  if (nodes.length === 0) {
-    return "(empty)";
-  }
-
-  return nodes.flatMap((node, index) => renderTreeNode(node, "", index === nodes.length - 1)).join("\n");
-}

package/src/lib/progress.test.ts

@@ -1,12 +0,0 @@
-import { describe, expect, it } from "vitest";
-import { summarizeFolderDownload } from "./progress";
-
-describe("summarizeFolderDownload", () => {
-  it("uses the singular noun for one file", () => {
-    expect(summarizeFolderDownload(1, "./downloads")).toBe("Downloaded 1 file into ./downloads");
-  });
-
-  it("uses the plural noun for multiple files", () => {
-    expect(summarizeFolderDownload(3, "./downloads")).toBe("Downloaded 3 files into ./downloads");
-  });
-});

package/src/lib/progress.ts

@@ -1,110 +0,0 @@
-import readline from "node:readline";
-
-function formatBytes(bytes: number): string {
-  if (!Number.isFinite(bytes) || bytes < 1024) {
-    return `${bytes} B`;
-  }
-  if (bytes < 1024 * 1024) {
-    return `${(bytes / 1024).toFixed(1)} KB`;
-  }
-  if (bytes < 1024 * 1024 * 1024) {
-    return `${(bytes / (1024 * 1024)).toFixed(1)} MB`;
-  }
-  return `${(bytes / (1024 * 1024 * 1024)).toFixed(1)} GB`;
-}
-
-function formatDuration(ms: number): string {
-  if (ms < 1000) {
-    return "<1s";
-  }
-  const seconds = Math.round(ms / 1000);
-  if (seconds < 60) {
-    return `${seconds}s`;
-  }
-  const minutes = Math.floor(seconds / 60);
-  const remainingSeconds = seconds % 60;
-  return `${minutes}m${remainingSeconds}s`;
-}
-
-function trimLabel(label: string, maxLength = 26): string {
-  if (label.length <= maxLength) {
-    return label;
-  }
-
-  return `${label.slice(0, maxLength - 1)}…`;
-}
-
-export class TransferProgress {
-  private current = 0;
-  private readonly startedAt = Date.now();
-  private lastRenderAt = 0;
-  private readonly isInteractive = Boolean(process.stderr.isTTY);
-
-  constructor(
-    private readonly label: string,
-    private readonly totalBytes: number,
-  ) {}
-
-  update(currentBytes: number) {
-    this.current = currentBytes;
-    const now = Date.now();
-    if (now - this.lastRenderAt < 50 && currentBytes < this.totalBytes) {
-      return;
-    }
-
-    this.lastRenderAt = now;
-    this.render();
-  }
-
-  complete() {
-    if (this.totalBytes > 0) {
-      this.current = this.totalBytes;
-    }
-    this.render(true);
-  }
-
-  fail() {
-    if (this.isInteractive) {
-      process.stderr.write("\n");
-    }
-  }
-
-  private render(done = false) {
-    const elapsed = Math.max(Date.now() - this.startedAt, 1);
-    const rate = this.current / (elapsed / 1000);
-    const width = 20;
-    const hasTotal = this.totalBytes > 0;
-    const ratio = hasTotal ? Math.min(this.current / this.totalBytes, 1) : 0;
-    const percent = Math.round(ratio * 100);
-    const filled = Math.round(ratio * width);
-    const bar = hasTotal
-      ? `${"=".repeat(Math.max(0, filled - 1))}${filled > 0 ? ">" : ""}${" ".repeat(width - filled)}`
-      : `${"=".repeat(((Math.floor(elapsed / 120) % width) + 1)).padEnd(width, " ")}`;
-    const etaMs = rate > 0 && hasTotal ? ((this.totalBytes - this.current) / rate) * 1000 : 0;
-    const detail = hasTotal
-      ? `${String(percent).padStart(3)}% ${formatBytes(this.current)}/${formatBytes(this.totalBytes)} ${formatBytes(
-          Math.round(rate),
-        )}/s${done ? "" : ` ETA ${formatDuration(etaMs)}`}`
-      : `${formatBytes(this.current)} transferred ${formatBytes(Math.round(rate))}/s`;
-    const line = `${trimLabel(this.label).padEnd(27)} [${bar}] ${detail}`;
-
-    if (this.isInteractive) {
-      readline.cursorTo(process.stderr, 0);
-      process.stderr.write(line);
-      readline.clearLine(process.stderr, 1);
-      if (done) {
-        process.stderr.write("\n");
-      }
-      return;
-    }
-
-    if (done) {
-      process.stderr.write(`${line}\n`);
-    }
-  }
-}
-
-export function summarizeFolderDownload(fileCount: number, destination: string) {
-  const noun = fileCount === 1 ? "file" : "files";
-  return `Downloaded ${fileCount} ${noun} into ${destination}`;
-}

package/tsconfig.json

@@ -1,10 +0,0 @@
-{
-  "extends": "../../tsconfig.base.json",
-  "compilerOptions": {
-    "baseUrl": ".",
-    "rootDir": "src"
-  },
-  "include": [
-    "src/**/*"
-  ]
-}