@andreprado/agentkit 0.1.0-alpha.4 → 0.1.0-alpha.5

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@andreprado/agentkit",
-  "version": "0.1.0-alpha.4",
+  "version": "0.1.0-alpha.5",
   "private": false,
   "type": "module",
   "repository": {

package/src/cli/args.ts

@@ -0,0 +1,36 @@
+export type ParsedArgs = {
+  command?: string;
+  positional: string[];
+  flags: Record<string, string | boolean>;
+};
+
+export function parseArgs(argv: string[]): ParsedArgs {
+  const [command, ...rest] = argv;
+  const positional: string[] = [];
+  const flags: Record<string, string | boolean> = {};
+
+  for (let index = 0; index < rest.length; index += 1) {
+    const value = rest[index];
+
+    if (!value.startsWith("--")) {
+      positional.push(value);
+      continue;
+    }
+
+    const name = value.slice(2);
+    const next = rest[index + 1];
+
+    if (next && !next.startsWith("--")) {
+      flags[name] = next;
+      index += 1;
+    } else {
+      flags[name] = true;
+    }
+  }
+
+  return { command, positional, flags };
+}
+
+export function isHelpRequested(args: ParsedArgs): boolean {
+  return args.flags.help === true || args.flags.h === true || args.positional.includes("--help") || args.positional.includes("-h");
+}

package/src/cli/cloud-client.ts

@@ -0,0 +1,257 @@
+import { mkdir, readFile, rm, writeFile } from "node:fs/promises";
+import { homedir } from "node:os";
+import { join } from "node:path";
+
+import { AgentKitError } from "../runtime/errors";
+import { defaultAgentKitCloudApiUrl } from "./constants";
+import { parseCloudApiUrl } from "./flags";
+
+export type CloudAuthConfig = {
+  apiUrl: string;
+  token: string;
+  source?: "environment" | "file";
+};
+
+export type CloudMeResponse = {
+  account?: {
+    email?: string;
+    status?: string;
+  };
+};
+
+export type CloudCapabilitiesResponse = {
+  capabilities?: Array<{
+    name?: string;
+    status?: string;
+  }>;
+};
+
+export type CloudLimitsResponse = {
+  online_agents?: {
+    account?: {
+      used?: number | null;
+      limit?: number | null;
+    };
+    global?: {
+      used?: number | null;
+      limit?: number | null;
+    };
+  };
+};
+
+export type DeployAccessTokenCreateResponse = {
+  access_token?: {
+    id?: string;
+    deploy_id?: string;
+    name?: string;
+    token?: string;
+  };
+};
+
+export type DeployAccessTokenListResponse = {
+  access_tokens?: Array<{
+    id?: string;
+    deploy_id?: string;
+    name?: string;
+  }>;
+};
+
+export type CloudSecretsResponse = {
+  secrets?: Array<{
+    name?: string;
+    status?: string;
+    updated_at?: string;
+  }>;
+};
+
+export function cloudAuthPath(): string {
+  return join(homedir(), ".agentkit", "cloud.json");
+}
+
+export async function readCloudAuth(): Promise<CloudAuthConfig | null> {
+  if (process.env.AGENTKIT_CLOUD_API_TOKEN) {
+    return {
+      apiUrl: process.env.AGENTKIT_CLOUD_API_URL ?? defaultAgentKitCloudApiUrl,
+      token: process.env.AGENTKIT_CLOUD_API_TOKEN,
+      source: "environment",
+    };
+  }
+
+  try {
+    const parsed = JSON.parse(await readFile(cloudAuthPath(), "utf8"));
+
+    if (parsed && typeof parsed === "object" && typeof parsed.token === "string") {
+      return {
+        apiUrl: typeof parsed.apiUrl === "string" ? parsed.apiUrl : defaultAgentKitCloudApiUrl,
+        token: parsed.token,
+        source: "file",
+      };
+    }
+  } catch {
+    return null;
+  }
+
+  return null;
+}
+
+export async function writeCloudAuth(config: CloudAuthConfig): Promise<void> {
+  await mkdir(join(homedir(), ".agentkit"), { recursive: true });
+  await writeFile(cloudAuthPath(), `${JSON.stringify(config, null, 2)}\n`, { mode: 0o600 });
+}
+
+export async function clearCloudAuth(): Promise<void> {
+  await rm(cloudAuthPath(), { force: true });
+}
+
+export async function resolveCloudApiUrl(flag: string | boolean | undefined): Promise<string> {
+  if (flag !== undefined) {
+    return parseCloudApiUrl(flag);
+  }
+
+  const auth = await readCloudAuth();
+  return auth?.apiUrl ?? parseCloudApiUrl(undefined);
+}
+
+export async function verifyCloudLogin(
+  apiUrl: string,
+  token: string,
+): Promise<{ me: CloudMeResponse; capabilities: CloudCapabilitiesResponse }> {
+  const me = await cloudApiRequestWithToken<CloudMeResponse>(apiUrl, "/v1/me", token, { method: "GET" });
+  const capabilities = await cloudApiRequestWithToken<CloudCapabilitiesResponse>(
+    apiUrl,
+    "/v1/me/capabilities",
+    token,
+    { method: "GET" },
+  );
+
+  return { me, capabilities };
+}
+
+export async function cloudGet<T>(apiUrl: string, path: string): Promise<T> {
+  const response = await cloudFetch(apiUrl, path);
+  const payload = await response.json();
+
+  if (!response.ok) {
+    throw new Error(readCloudError(payload, response.status));
+  }
+
+  return payload as T;
+}
+
+export async function cloudPost<T>(apiUrl: string, path: string, body: unknown): Promise<T> {
+  const response = await cloudFetch(apiUrl, path, {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify(body),
+  });
+  const payload = await response.json();
+
+  if (!response.ok) {
+    throw new Error(readCloudError(payload, response.status));
+  }
+
+  return payload as T;
+}
+
+export function cloudFetch(apiUrl: string, path: string, init: RequestInit = {}): Promise<Response> {
+  const headers = new Headers(init.headers);
+  const apiToken = process.env.AGENTKIT_CLOUD_API_TOKEN;
+
+  if (apiToken && !headers.has("Authorization")) {
+    headers.set("Authorization", `Bearer ${apiToken}`);
+  }
+
+  return fetch(new URL(path, parseCloudApiUrl(apiUrl)).href, {
+    ...init,
+    headers,
+  });
+}
+
+export async function cloudApiRequest(apiUrl: string, path: string, init: RequestInit): Promise<unknown> {
+  const auth = await readCloudAuth();
+  const headers = new Headers(init.headers);
+
+  if (!headers.has("Content-Type") && init.body !== undefined) {
+    headers.set("Content-Type", "application/json");
+  }
+
+  if (auth?.token && !headers.has("Authorization")) {
+    headers.set("Authorization", `Bearer ${auth.token}`);
+  }
+
+  const response = await fetch(new URL(path, parseCloudApiUrl(apiUrl)).href, {
+    ...init,
+    headers,
+  });
+  const payload = await response.json().catch(() => null);
+
+  if (!response.ok) {
+    const code =
+      payload && typeof payload === "object" && "error" in payload
+        ? String((payload as { error?: { code?: unknown } }).error?.code ?? "cloud_request_failed")
+        : "cloud_request_failed";
+    let message = readCloudError(payload, response.status);
+
+    if (code === "auth_token_invalid") {
+      message = `${message} Token source: ${auth ? formatCloudAuthSource(auth) : "none"}. Run: agentkit login --token <token>`;
+    }
+
+    throw new AgentKitError(code, message);
+  }
+
+  return payload;
+}
+
+export async function cloudApiRequestWithToken<T>(
+  apiUrl: string,
+  path: string,
+  token: string,
+  init: RequestInit,
+): Promise<T> {
+  const headers = new Headers(init.headers);
+
+  if (!headers.has("Content-Type") && init.body !== undefined) {
+    headers.set("Content-Type", "application/json");
+  }
+
+  headers.set("Authorization", `Bearer ${token}`);
+
+  const response = await fetch(new URL(path, parseCloudApiUrl(apiUrl)).href, {
+    ...init,
+    headers,
+  });
+  const payload = await response.json().catch(() => null);
+
+  if (!response.ok) {
+    const code =
+      payload && typeof payload === "object" && "error" in payload
+        ? String((payload as { error?: { code?: unknown } }).error?.code ?? "cloud_request_failed")
+        : "cloud_request_failed";
+    throw new AgentKitError(code, readCloudError(payload, response.status));
+  }
+
+  return payload as T;
+}
+
+export function readCloudError(payload: unknown, status: number): string {
+  if (payload && typeof payload === "object" && "error" in payload) {
+    const error = (payload as { error?: { message?: unknown } }).error;
+    if (typeof error?.message === "string") {
+      return error.message;
+    }
+  }
+
+  return `AgentKit Cloud request failed with HTTP ${status}.`;
+}
+
+export function formatCloudAuthSource(auth: CloudAuthConfig): string {
+  if (auth.source === "environment") {
+    return "AGENTKIT_CLOUD_API_TOKEN";
+  }
+
+  if (auth.source === "file") {
+    return cloudAuthPath();
+  }
+
+  return "AgentKit Cloud auth";
+}