@agfs/cli 0.1.0

package/dist/index.d.ts

@@ -0,0 +1 @@
+#!/usr/bin/env node

package/dist/index.js

@@ -0,0 +1,576 @@
+#!/usr/bin/env node
+
+// src/index.ts
+import { Command } from "commander";
+
+// src/lib/client.ts
+import { createReadStream, createWriteStream } from "fs";
+import { mkdir as mkdir2, stat } from "fs/promises";
+import path3 from "path";
+import { 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";
+
+// src/lib/config.ts
+import { chmod, mkdir, readFile, writeFile } from "fs/promises";
+import os from "os";
+import path from "path";
+function getConfigDir() {
+  return process.env.XDG_CONFIG_HOME ? path.join(process.env.XDG_CONFIG_HOME, "agfs") : path.join(os.homedir(), ".config", "agfs");
+}
+function getConfigPath() {
+  return path.join(getConfigDir(), "config.json");
+}
+async function readConfig() {
+  try {
+    const content = await readFile(getConfigPath(), "utf8");
+    return JSON.parse(content);
+  } catch {
+    return {};
+  }
+}
+async function writeConfig(config) {
+  const filePath = getConfigPath();
+  await mkdir(path.dirname(filePath), { recursive: true });
+  await writeFile(filePath, JSON.stringify(config, null, 2), "utf8");
+  await chmod(filePath, 384);
+}
+function getResolvedBaseUrl(config) {
+  return (process.env.AGFS_BASE_URL ?? config.baseUrl ?? "https://agfs.dev").replace(/\/+$/, "");
+}
+function getResolvedToken(config) {
+  return process.env.AGFS_TOKEN ?? config.token ?? null;
+}
+
+// src/lib/download.ts
+import path2 from "path";
+function getRemoteLeafName(remotePath) {
+  const normalized = remotePath.replace(/\/+$/, "");
+  if (!normalized || normalized === "/") {
+    return "agfs-root";
+  }
+  return normalized.split("/").filter(Boolean).at(-1) ?? "agfs-root";
+}
+function flattenTree(nodes) {
+  const directories = [];
+  const files = [];
+  function walk(items, parentSegments) {
+    for (const item of items) {
+      const segments = [...parentSegments, item.name];
+      const relativePath = segments.join("/");
+      if (item.kind === "folder") {
+        directories.push(relativePath);
+        walk(item.children ?? [], segments);
+        continue;
+      }
+      files.push({
+        path: item.path,
+        relativePath
+      });
+    }
+  }
+  walk(nodes, []);
+  return { directories, files };
+}
+function resolveFolderDestination(remotePath, localPath) {
+  return localPath ?? getRemoteLeafName(remotePath);
+}
+function resolveFileDestination(remotePath, localPath) {
+  return localPath ?? getRemoteLeafName(remotePath);
+}
+function joinRelativeDestination(root, relativePath) {
+  return path2.join(root, ...relativePath.split("/"));
+}
+
+// src/lib/progress.ts
+import readline from "readline";
+function formatBytes(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 formatDuration(ms) {
+  if (ms < 1e3) {
+    return "<1s";
+  }
+  const seconds = Math.round(ms / 1e3);
+  if (seconds < 60) {
+    return `${seconds}s`;
+  }
+  const minutes = Math.floor(seconds / 60);
+  const remainingSeconds = seconds % 60;
+  return `${minutes}m${remainingSeconds}s`;
+}
+function trimLabel(label, maxLength = 26) {
+  if (label.length <= maxLength) {
+    return label;
+  }
+  return `${label.slice(0, maxLength - 1)}\u2026`;
+}
+var TransferProgress = class {
+  constructor(label, totalBytes) {
+    this.label = label;
+    this.totalBytes = totalBytes;
+  }
+  current = 0;
+  startedAt = Date.now();
+  lastRenderAt = 0;
+  isInteractive = Boolean(process.stderr.isTTY);
+  update(currentBytes) {
+    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");
+    }
+  }
+  render(done = false) {
+    const elapsed = Math.max(Date.now() - this.startedAt, 1);
+    const rate = this.current / (elapsed / 1e3);
+    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 * 1e3 : 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}
+`);
+    }
+  }
+};
+function summarizeFolderDownload(fileCount, destination) {
+  const noun = fileCount === 1 ? "file" : "files";
+  return `Downloaded ${fileCount} ${noun} into ${destination}`;
+}
+
+// src/lib/client.ts
+async function parseError(response) {
+  try {
+    const payload = await response.json();
+    return payload.error ?? response.statusText;
+  } catch {
+    return response.statusText;
+  }
+}
+var AgfsClient = class _AgfsClient {
+  constructor(baseUrl, token) {
+    this.baseUrl = baseUrl;
+    this.token = token;
+  }
+  static async fromConfig() {
+    const config = await readConfig();
+    return new _AgfsClient(getResolvedBaseUrl(config), getResolvedToken(config));
+  }
+  async request(pathname, init) {
+    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) {
+    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) {
+    const response = await this.request(`/api/v1/fs/list?path=${encodeURIComponent(pathname)}`);
+    return listEntriesResponseSchema.parse(await response.json());
+  }
+  async tree(pathname) {
+    const response = await this.request(`/api/v1/fs/tree?path=${encodeURIComponent(pathname)}`);
+    return treeEntriesResponseSchema.parse(await response.json());
+  }
+  async mkdir(pathname) {
+    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, to) {
+    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, 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, remotePath) {
+    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 ${path3.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;
+    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();
+  }
+  async writeRemoteFile(remotePath, localPath) {
+    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 = path3.join(localPath, getRemoteLeafName(remotePath));
+        }
+      } catch {
+      }
+    }
+    await mkdir2(path3.dirname(destination), { recursive: true });
+    const totalBytes = Number(response.headers.get("content-length") ?? 0);
+    const progress = new TransferProgress(`Download ${path3.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((resolve, reject) => {
+          writer.write(Buffer.from(value), (error) => {
+            if (error) {
+              reject(error);
+              return;
+            }
+            resolve();
+          });
+        });
+      }
+      await new Promise((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, localPath) {
+    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 mkdir2(destinationRoot, { recursive: true });
+    const tree = await this.tree(remotePath);
+    const flattened = flattenTree(tree.tree);
+    for (const directory of flattened.directories) {
+      await mkdir2(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, 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, ttl) {
+    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());
+  }
+};
+
+// src/commands/auth.ts
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+function registerAuthCommands(program2) {
+  program2.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) => {
+    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 * 1e3);
+    }
+  });
+  program2.command("logout").description("Clear the locally stored AGFS token").action(async () => {
+    const config = await readConfig();
+    await writeConfig({
+      ...config,
+      token: void 0
+    });
+    console.log("Removed local AGFS token.");
+  });
+  program2.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})`);
+  });
+}
+
+// src/lib/format.ts
+function renderEntries(entries) {
+  if (entries.length === 0) {
+    return "(empty)";
+  }
+  return entries.map((entry) => {
+    const size = entry.size == null ? "folder" : `${entry.size} bytes`;
+    return `${entry.path}	${entry.kind}	${size}`;
+  }).join("\n");
+}
+function renderTreeNode(node, prefix, isLast) {
+  const branch = prefix ? `${prefix}${isLast ? "\u2514\u2500 " : "\u251C\u2500 "}` : "";
+  const lines = [`${branch}${node.name}${node.kind === "folder" ? "/" : ""}`];
+  const nextPrefix = prefix ? `${prefix}${isLast ? "   " : "\u2502  "}` : "";
+  const children = node.children ?? [];
+  children.forEach((child, index) => {
+    lines.push(...renderTreeNode(child, nextPrefix, index === children.length - 1));
+  });
+  return lines;
+}
+function renderTree(nodes) {
+  if (nodes.length === 0) {
+    return "(empty)";
+  }
+  return nodes.flatMap((node, index) => renderTreeNode(node, "", index === nodes.length - 1)).join("\n");
+}
+
+// src/commands/fs.ts
+function registerFsCommands(program2) {
+  program2.command("ls").description("List the direct children at a remote path").argument("[path]", "Remote path", "/").action(async (pathname) => {
+    const client = await AgfsClient.fromConfig();
+    const result = await client.list(pathname);
+    console.log(renderEntries(result.entries));
+  });
+  program2.command("tree").description("Render a tree view of a remote folder").argument("[path]", "Remote path", "/").action(async (pathname) => {
+    const client = await AgfsClient.fromConfig();
+    const result = await client.tree(pathname);
+    console.log(renderTree(result.tree));
+  });
+  program2.command("mkdir").description("Create a folder path").argument("<path>", "Remote path").action(async (pathname) => {
+    const client = await AgfsClient.fromConfig();
+    await client.mkdir(pathname);
+    console.log(`Created ${pathname}`);
+  });
+  program2.command("mv").description("Move or rename a file or folder").argument("<from>", "Current path").argument("<to>", "Destination path").action(async (from, to) => {
+    const client = await AgfsClient.fromConfig();
+    await client.move(from, to);
+    console.log(`Moved ${from} -> ${to}`);
+  });
+  program2.command("rm").description("Delete a file or folder").argument("<path>", "Remote path").option("--recursive", "Delete folders recursively").action(async (pathname, options) => {
+    const client = await AgfsClient.fromConfig();
+    await client.remove(pathname, Boolean(options.recursive));
+    console.log(`Removed ${pathname}`);
+  });
+  program2.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, remotePath, options) => {
+    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}`);
+    }
+  });
+  program2.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, localPath) => {
+    const client = await AgfsClient.fromConfig();
+    const destination = await client.download(remotePath, localPath);
+    console.log(`Saved ${destination}`);
+  });
+  program2.command("share").description("Generate a preview URL for a file").argument("<remotePath>", "Remote file path").option("--ttl <ttl>", "Link lifetime", "15m").action(async (remotePath, options) => {
+    const client = await AgfsClient.fromConfig();
+    const result = await client.share(remotePath, options.ttl);
+    console.log(result.share.url);
+  });
+}
+
+// src/index.ts
+var program = new Command().name("agfs").description("AgentFilesystem CLI").version("0.1.0");
+registerAuthCommands(program);
+registerFsCommands(program);
+program.parseAsync(process.argv).catch((error) => {
+  console.error(error instanceof Error ? error.message : "Command failed");
+  process.exitCode = 1;
+});

package/package.json

@@ -0,0 +1,24 @@
+{
+  "name": "@agfs/cli",
+  "version": "0.1.0",
+  "type": "module",
+  "bin": {
+    "agfs": "./dist/index.js"
+  },
+  "scripts": {
+    "build": "tsup src/index.ts --format esm --dts --clean",
+    "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": {
+    "@types/mime-types": "^3.0.1",
+    "tsup": "^8.5.0",
+    "typescript": "^5.8.3"
+  }
+}

package/src/commands/auth.ts

@@ -0,0 +1,73 @@
+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})`);
+    });
+}