artidrop 0.1.0

package/dist/index.js

@@ -0,0 +1,444 @@
+#!/usr/bin/env node
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined") return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+
+// src/index.ts
+import { Command } from "commander";
+
+// src/commands/publish.ts
+import { readFileSync as readFileSync2 } from "fs";
+import { basename, extname } from "path";
+
+// src/lib/config.ts
+import { readFileSync, writeFileSync, mkdirSync, unlinkSync, existsSync } from "fs";
+import { join } from "path";
+import { homedir } from "os";
+var CONFIG_DIR = join(homedir(), ".config", "artidrop");
+var CONFIG_FILE = join(CONFIG_DIR, "config.json");
+function getConfig() {
+  try {
+    const data = readFileSync(CONFIG_FILE, "utf-8");
+    return JSON.parse(data);
+  } catch {
+    return null;
+  }
+}
+function saveConfig(config) {
+  mkdirSync(CONFIG_DIR, { recursive: true });
+  writeFileSync(CONFIG_FILE, JSON.stringify(config, null, 2) + "\n", "utf-8");
+}
+function deleteConfig() {
+  try {
+    unlinkSync(CONFIG_FILE);
+  } catch {
+  }
+}
+function configExists() {
+  return existsSync(CONFIG_FILE);
+}
+
+// src/lib/auth.ts
+var DEFAULT_API_URL = "https://api.artidrop.app";
+function getApiKey() {
+  const envKey = process.env.ARTIDROP_API_KEY;
+  if (envKey) return envKey;
+  const config = getConfig();
+  return config?.api_key ?? null;
+}
+function getApiUrl() {
+  const envUrl = process.env.ARTIDROP_API_URL;
+  if (envUrl) return envUrl;
+  const config = getConfig();
+  return config?.api_url ?? DEFAULT_API_URL;
+}
+function requireApiKey() {
+  const key = getApiKey();
+  if (!key) {
+    process.stderr.write(
+      "Error: Not authenticated. Run `artidrop login` or set ARTIDROP_API_KEY.\n"
+    );
+    process.exit(3);
+  }
+  return key;
+}
+
+// src/lib/api.ts
+async function apiRequest(path, options = {}) {
+  const { method = "GET", body, apiKey } = options;
+  const url = `${getApiUrl()}/v1${path}`;
+  const headers = {
+    "Content-Type": "application/json"
+  };
+  if (apiKey) {
+    headers["Authorization"] = `Bearer ${apiKey}`;
+  }
+  const res = await fetch(url, {
+    method,
+    headers,
+    body: body ? JSON.stringify(body) : void 0
+  });
+  if (res.status === 204) {
+    return void 0;
+  }
+  const data = await res.json();
+  if (!res.ok) {
+    const error = data.error;
+    const code = error?.code ?? "UNKNOWN";
+    const message = error?.message ?? `HTTP ${res.status}`;
+    process.stderr.write(`Error: ${message}
+`);
+    if (res.status === 401) process.exit(3);
+    if (res.status === 429) process.exit(4);
+    if (res.status === 400) process.exit(2);
+    process.exit(1);
+  }
+  return data;
+}
+
+// src/commands/publish.ts
+var FORMAT_MAP = {
+  ".html": "html",
+  ".htm": "html",
+  ".md": "markdown",
+  ".markdown": "markdown"
+};
+async function publish(pathOrStdin, options) {
+  const apiKey = requireApiKey();
+  let content;
+  let inferredFormat;
+  if (pathOrStdin === "-" || !process.stdin.isTTY) {
+    content = await readStdin();
+    if (!options.format) {
+      process.stderr.write("Error: --format is required when reading from stdin.\n");
+      process.exit(2);
+    }
+  } else {
+    try {
+      content = readFileSync2(pathOrStdin, "utf-8");
+    } catch (err) {
+      process.stderr.write(`Error: Cannot read file "${pathOrStdin}".
+`);
+      process.exit(2);
+      return;
+    }
+    const ext = extname(pathOrStdin).toLowerCase();
+    inferredFormat = FORMAT_MAP[ext];
+    if (!inferredFormat && !options.format) {
+      process.stderr.write(
+        "Error: Cannot infer format. Use --format html or --format markdown.\n"
+      );
+      process.exit(2);
+    }
+  }
+  const format = options.format ?? inferredFormat;
+  if (format !== "html" && format !== "markdown") {
+    process.stderr.write('Error: Format must be "html" or "markdown".\n');
+    process.exit(2);
+  }
+  const title = options.title ?? (pathOrStdin !== "-" ? basename(pathOrStdin, extname(pathOrStdin)) : "Untitled");
+  if (options.update) {
+    const result = await apiRequest(
+      `/artifacts/${options.update}`,
+      {
+        method: "PUT",
+        body: { content, title },
+        apiKey
+      }
+    );
+    outputResult(result, options);
+  } else {
+    const result = await apiRequest("/artifacts", {
+      method: "POST",
+      body: {
+        content,
+        format,
+        title,
+        visibility: options.visibility ?? "public"
+      },
+      apiKey
+    });
+    outputResult(result, options);
+  }
+}
+function outputResult(result, options) {
+  if (options.json) {
+    process.stdout.write(JSON.stringify(result, null, 2) + "\n");
+  } else {
+    process.stdout.write(result.url + "\n");
+  }
+  if (options.copy) {
+    const { execSync } = __require("child_process");
+    try {
+      execSync(`echo -n "${result.url}" | pbcopy`, { stdio: "ignore" });
+      process.stderr.write("URL copied to clipboard.\n");
+    } catch {
+      try {
+        execSync(`echo -n "${result.url}" | xclip -selection clipboard`, { stdio: "ignore" });
+        process.stderr.write("URL copied to clipboard.\n");
+      } catch {
+        process.stderr.write("Could not copy to clipboard.\n");
+      }
+    }
+  }
+  if (options.open) {
+    const { execSync } = __require("child_process");
+    try {
+      execSync(`open "${result.url}"`, { stdio: "ignore" });
+    } catch {
+      try {
+        execSync(`xdg-open "${result.url}"`, { stdio: "ignore" });
+      } catch {
+      }
+    }
+  }
+}
+function readStdin() {
+  return new Promise((resolve, reject) => {
+    let data = "";
+    process.stdin.setEncoding("utf-8");
+    process.stdin.on("data", (chunk) => data += chunk);
+    process.stdin.on("end", () => resolve(data));
+    process.stdin.on("error", reject);
+  });
+}
+
+// src/commands/list.ts
+async function list(options) {
+  const apiKey = requireApiKey();
+  const params = new URLSearchParams();
+  if (options.limit) params.set("limit", options.limit);
+  if (options.offset) params.set("offset", options.offset);
+  if (options.format) params.set("format", options.format);
+  const query = params.toString();
+  const result = await apiRequest(
+    `/artifacts${query ? `?${query}` : ""}`,
+    { apiKey }
+  );
+  if (options.json) {
+    process.stdout.write(JSON.stringify(result.items, null, 2) + "\n");
+    return;
+  }
+  if (result.items.length === 0) {
+    process.stderr.write("No artifacts found.\n");
+    return;
+  }
+  const header = "ID              TITLE                       FORMAT    VERSION  CREATED";
+  process.stdout.write(header + "\n");
+  for (const item of result.items) {
+    const id = item.id.padEnd(16);
+    const title = (item.title ?? "Untitled").slice(0, 27).padEnd(28);
+    const format = item.format.padEnd(10);
+    const version = String(item.version).padEnd(9);
+    const created = item.created_at.slice(0, 10);
+    process.stdout.write(`${id}${title}${format}${version}${created}
+`);
+  }
+}
+
+// src/commands/get.ts
+async function get(artifactId, options) {
+  const apiKey = requireApiKey();
+  const result = await apiRequest(`/artifacts/${artifactId}`, {
+    apiKey
+  });
+  if (options.json) {
+    process.stdout.write(JSON.stringify(result, null, 2) + "\n");
+    return;
+  }
+  const size = formatBytes(result.size_bytes);
+  process.stdout.write(
+    `Title:      ${result.title}
+URL:        ${result.url}
+Format:     ${result.format}
+Version:    ${result.version}
+Visibility: ${result.visibility}
+Size:       ${size}
+Created:    ${result.created_at}
+Updated:    ${result.updated_at}
+`
+  );
+}
+function formatBytes(bytes) {
+  if (bytes < 1024) return `${bytes} B`;
+  if (bytes < 1024 * 1024) return `${(bytes / 1024).toFixed(1)} KB`;
+  return `${(bytes / (1024 * 1024)).toFixed(1)} MB`;
+}
+
+// src/commands/delete.ts
+import { createInterface } from "readline";
+async function del(artifactId, options) {
+  const apiKey = requireApiKey();
+  if (!options.yes) {
+    const confirmed = await confirm(`Are you sure you want to delete "${artifactId}"? (y/N) `);
+    if (!confirmed) {
+      process.stderr.write("Cancelled.\n");
+      return;
+    }
+  }
+  await apiRequest(`/artifacts/${artifactId}`, {
+    method: "DELETE",
+    apiKey
+  });
+  process.stderr.write(`Deleted ${artifactId}
+`);
+}
+function confirm(prompt) {
+  return new Promise((resolve) => {
+    const rl = createInterface({ input: process.stdin, output: process.stderr });
+    rl.question(prompt, (answer) => {
+      rl.close();
+      resolve(answer.toLowerCase() === "y" || answer.toLowerCase() === "yes");
+    });
+  });
+}
+
+// src/commands/versions.ts
+async function versions(artifactId) {
+  const apiKey = requireApiKey();
+  const result = await apiRequest(
+    `/artifacts/${artifactId}/versions`,
+    { apiKey }
+  );
+  if (result.items.length === 0) {
+    process.stderr.write("No versions found.\n");
+    return;
+  }
+  const header = "VERSION  SIZE     CREATED";
+  process.stdout.write(header + "\n");
+  for (const v of result.items) {
+    const version = String(v.version).padEnd(9);
+    const size = formatBytes2(v.size_bytes).padEnd(9);
+    process.stdout.write(`${version}${size}${v.created_at}
+`);
+  }
+}
+function formatBytes2(bytes) {
+  if (bytes < 1024) return `${bytes} B`;
+  if (bytes < 1024 * 1024) return `${(bytes / 1024).toFixed(1)} KB`;
+  return `${(bytes / (1024 * 1024)).toFixed(1)} MB`;
+}
+
+// src/commands/login.ts
+import { createServer } from "http";
+import { createInterface as createInterface2 } from "readline";
+async function login() {
+  const apiUrl = getApiUrl();
+  const appUrl = apiUrl.replace("api.", "").replace("/v1", "");
+  if (process.stdin.isTTY) {
+    await browserLogin(appUrl);
+  } else {
+    await manualLogin(appUrl);
+  }
+}
+async function browserLogin(appUrl) {
+  return new Promise((resolve, reject) => {
+    const server = createServer((req, res) => {
+      const url = new URL(req.url, `http://localhost`);
+      if (url.pathname === "/callback") {
+        const key = url.searchParams.get("key");
+        if (key) {
+          saveConfig({ api_key: key });
+          res.writeHead(200, { "Content-Type": "text/html" });
+          res.end("<html><body><h2>Success! You can close this tab.</h2></body></html>");
+          process.stderr.write("Authenticated successfully.\n");
+          server.close();
+          resolve();
+        } else {
+          res.writeHead(400, { "Content-Type": "text/plain" });
+          res.end("Missing key parameter.");
+          server.close();
+          reject(new Error("No key received."));
+        }
+      }
+    });
+    server.listen(0, "127.0.0.1", () => {
+      const address = server.address();
+      if (!address || typeof address === "string") {
+        server.close();
+        reject(new Error("Could not start local server."));
+        return;
+      }
+      const port = address.port;
+      const loginUrl = `${appUrl}/v1/auth/cli-auth?port=${port}`;
+      process.stderr.write(`Opening browser to: ${loginUrl}
+`);
+      process.stderr.write("Waiting for authentication...\n");
+      import("child_process").then(({ execSync }) => {
+        try {
+          execSync(`open "${loginUrl}"`, { stdio: "ignore" });
+        } catch {
+          try {
+            execSync(`xdg-open "${loginUrl}"`, { stdio: "ignore" });
+          } catch {
+            process.stderr.write(`Could not open browser. Visit this URL manually:
+${loginUrl}
+`);
+          }
+        }
+      });
+    });
+    setTimeout(() => {
+      server.close();
+      reject(new Error("Login timed out. Try `artidrop login` again."));
+    }, 5 * 60 * 1e3);
+  });
+}
+async function manualLogin(appUrl) {
+  const loginUrl = `${appUrl}/v1/auth/cli-auth?manual=true`;
+  process.stderr.write(`Open this URL in your browser: ${loginUrl}
+`);
+  process.stderr.write("Then paste the API key here:\n");
+  const rl = createInterface2({ input: process.stdin, output: process.stderr });
+  const key = await new Promise((resolve) => {
+    rl.question("> ", (answer) => {
+      rl.close();
+      resolve(answer.trim());
+    });
+  });
+  if (!key.startsWith("sk-")) {
+    process.stderr.write("Error: Invalid API key format. Keys start with 'sk-'.\n");
+    process.exit(2);
+  }
+  saveConfig({ api_key: key });
+  process.stderr.write("Authenticated successfully.\n");
+}
+
+// src/commands/logout.ts
+function logout() {
+  if (!configExists()) {
+    process.stderr.write("Not logged in.\n");
+    return;
+  }
+  deleteConfig();
+  process.stderr.write("Logged out.\n");
+}
+
+// src/commands/whoami.ts
+async function whoami() {
+  const apiKey = requireApiKey();
+  const result = await apiRequest("/auth/me", { apiKey });
+  if (!result.user) {
+    process.stderr.write("Not authenticated.\n");
+    process.exit(3);
+  }
+  const name = result.user.displayName ?? result.user.username;
+  process.stdout.write(`Authenticated as ${name} (${result.user.email})
+`);
+}
+
+// src/index.ts
+var program = new Command();
+program.name("artidrop").description("Publish and share AI artifacts instantly").version("0.1.0");
+program.command("publish").description("Publish a file or stdin content").argument("<path>", 'File path to publish, or "-" for stdin').option("-t, --title <title>", "Artifact title").option("-f, --format <format>", "Content format: html or markdown").option("-v, --visibility <visibility>", "Visibility: public or unlisted", "public").option("-u, --update <id>", "Update existing artifact (creates new version)").option("-o, --open", "Open URL in browser after publishing").option("--json", "Output full JSON response").option("-c, --copy", "Copy URL to clipboard").action(publish);
+program.command("list").description("List your artifacts").option("-l, --limit <n>", "Number of items", "20").option("--offset <n>", "Pagination offset", "0").option("-f, --format <format>", "Filter by format: html or markdown").option("--json", "Output as JSON").action(list);
+program.command("get").description("Show artifact details").argument("<id>", "Artifact ID").option("--json", "Output as JSON").action(get);
+program.command("delete").description("Delete an artifact").argument("<id>", "Artifact ID").option("-y, --yes", "Skip confirmation").action(del);
+program.command("versions").description("Show version history").argument("<id>", "Artifact ID").action(versions);
+program.command("login").description("Sign in to artidrop").action(login);
+program.command("logout").description("Sign out of artidrop").action(logout);
+program.command("whoami").description("Show current user").action(whoami);
+program.parse();

package/package.json

@@ -0,0 +1,28 @@
+{
+  "name": "artidrop",
+  "version": "0.1.0",
+  "type": "module",
+  "bin": {
+    "artidrop": "./dist/index.js"
+  },
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "tsup",
+    "dev": "tsx src/index.ts",
+    "lint": "eslint src/",
+    "typecheck": "tsc --noEmit"
+  },
+  "dependencies": {
+    "chalk": "^5.6.2",
+    "commander": "^14.0.3",
+    "open-cli": "^8.0.0"
+  },
+  "devDependencies": {
+    "@types/node": "^25.5.0",
+    "tsup": "^8.5.1",
+    "tsx": "^4.21.0",
+    "typescript": "^5.9.3"
+  }
+}