packdog 0.1.0

package/dist/api.js

@@ -0,0 +1,39 @@
+function getBaseUrl() {
+    return process.env.PACKDOG_URL ?? "https://packdog.dev";
+}
+export async function fetchPackageName(packageId, token) {
+    const data = await fetchJson(`/packages/${packageId}`, token);
+    return data.name;
+}
+export async function fetchApi(path, token, options = {}) {
+    const url = `${getBaseUrl()}${path}`;
+    const headers = {
+        Authorization: `Bearer ${token}`,
+        ...(options.headers ?? {})
+    };
+    try {
+        return await fetch(url, { ...options, headers });
+    }
+    catch (err) {
+        const msg = err instanceof Error ? err.message : "Unknown error";
+        console.error(`Network error: ${msg}`);
+        process.exit(1);
+    }
+}
+export async function fetchJson(path, token, options = {}) {
+    const res = await fetchApi(path, token, options);
+    let data;
+    try {
+        data = await res.json();
+    }
+    catch {
+        console.error(`Request failed (${res.status})`);
+        process.exit(1);
+    }
+    if (!res.ok) {
+        const msg = data.error ?? `Request failed (${res.status})`;
+        console.error(msg);
+        process.exit(1);
+    }
+    return data;
+}

package/dist/commands/channels.js

@@ -0,0 +1,17 @@
+import { getToken, getPackConfig } from "../config.js";
+import { fetchJson, fetchPackageName } from "../api.js";
+export async function channels() {
+    const token = getToken();
+    const config = await getPackConfig();
+    const data = await fetchJson(`/packages/${config.packageId}/channels`, token);
+    const name = await fetchPackageName(config.packageId, token);
+    console.log(`Package: ${name}\n`);
+    if (data.length === 0) {
+        console.log("  No channels yet");
+        return;
+    }
+    for (const ch of data) {
+        const date = new Date(ch.updated_at).toISOString().slice(0, 19).replace("T", " ");
+        console.log(`  ${ch.channel.padEnd(15)} ${ch.version_id}  ${date}`);
+    }
+}

package/dist/commands/info.js

@@ -0,0 +1,15 @@
+import { getToken, getPackConfig } from "../config.js";
+import { fetchJson, fetchPackageName } from "../api.js";
+export async function info() {
+    const token = getToken();
+    const config = await getPackConfig();
+    const [name, versions, channels] = await Promise.all([
+        fetchPackageName(config.packageId, token),
+        fetchJson(`/packages/${config.packageId}/versions`, token),
+        fetchJson(`/packages/${config.packageId}/channels`, token),
+    ]);
+    console.log(`Package: ${name}`);
+    console.log(`  ID:       ${config.packageId}`);
+    console.log(`  Versions: ${versions.length}`);
+    console.log(`  Channels: ${channels.length === 0 ? "none" : channels.map((c) => c.channel).join(", ")}`);
+}

package/dist/commands/init.js

@@ -0,0 +1,23 @@
+import { writeFile } from "node:fs/promises";
+import { join } from "node:path";
+import { getToken } from "../config.js";
+import { fetchJson } from "../api.js";
+export async function init(name) {
+    if (!name) {
+        console.error("Missing --name argument");
+        console.error("Usage: packdog init --name=my-pack");
+        process.exit(1);
+    }
+    const token = getToken();
+    console.log(`Registering pack: ${name}`);
+    const result = await fetchJson("/packages", token, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({ name })
+    });
+    const config = { packageId: result.packageId };
+    const configPath = join(process.cwd(), "packdog.json");
+    await writeFile(configPath, JSON.stringify(config, null, 2) + "\n");
+    console.log(`Pack registered: ${result.packageId}`);
+    console.log(`Created packdog.json`);
+}

package/dist/commands/publish.js

@@ -0,0 +1,25 @@
+import { getToken, getPackConfig } from "../config.js";
+import { fetchJson, fetchPackageName } from "../api.js";
+export async function publish(channel, versionId) {
+    const token = getToken();
+    const config = await getPackConfig();
+    const ch = channel ?? "stable";
+    if (!versionId) {
+        const versions = await fetchJson(`/packages/${config.packageId}/versions`, token);
+        if (versions.length === 0) {
+            console.error("No versions found. Upload first: packdog upload");
+            process.exit(1);
+        }
+        versionId = versions[0].id;
+    }
+    const name = await fetchPackageName(config.packageId, token);
+    console.log(`Package: ${name}`);
+    console.log(`  Version: ${versionId}`);
+    console.log(`  Channel: ${ch}`);
+    const result = await fetchJson(`/packages/${config.packageId}/channels/${ch}`, token, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({ versionId })
+    });
+    console.log(`\nPublished to ${result.channel}: ${result.versionId}`);
+}

package/dist/commands/rollback.js

@@ -0,0 +1,12 @@
+import { getToken, getPackConfig } from "../config.js";
+import { fetchJson, fetchPackageName } from "../api.js";
+export async function rollback(channel) {
+    const token = getToken();
+    const config = await getPackConfig();
+    const ch = channel ?? "stable";
+    const name = await fetchPackageName(config.packageId, token);
+    console.log(`Package: ${name}`);
+    console.log(`  Channel: ${ch}`);
+    const result = await fetchJson(`/packages/${config.packageId}/channels/${ch}/rollback`, token, { method: "POST" });
+    console.log(`Rolled back to: ${result.versionId}`);
+}

package/dist/commands/upload.js

@@ -0,0 +1,64 @@
+import { readdir, readFile, stat } from "node:fs/promises";
+import { join, relative } from "node:path";
+import { getToken, getPackConfig } from "../config.js";
+import { fetchApi, fetchPackageName } from "../api.js";
+async function getAllFiles(dir, baseDir = dir) {
+    const files = [];
+    const entries = await readdir(dir, { withFileTypes: true });
+    for (const entry of entries) {
+        const fullPath = join(dir, entry.name);
+        if (entry.isDirectory()) {
+            files.push(...await getAllFiles(fullPath, baseDir));
+        }
+        else if (entry.isFile()) {
+            files.push({
+                path: relative(baseDir, fullPath),
+                content: await readFile(fullPath)
+            });
+        }
+    }
+    return files;
+}
+export async function upload() {
+    const token = getToken();
+    const config = await getPackConfig();
+    const distPath = join(process.cwd(), "dist");
+    try {
+        await stat(distPath);
+    }
+    catch {
+        console.error("dist/ folder not found. Build your pack first.");
+        process.exit(1);
+    }
+    const files = await getAllFiles(distPath);
+    if (files.length === 0) {
+        console.error("No files found in dist/");
+        process.exit(1);
+    }
+    const name = await fetchPackageName(config.packageId, token);
+    console.log(`Package: ${name}`);
+    files.forEach((f) => console.log(`  ${f.path} (${(f.content.length / 1024).toFixed(2)} KB)`));
+    const formData = new FormData();
+    for (const f of files) {
+        formData.append(f.path, new Blob([new Uint8Array(f.content)]), f.path);
+    }
+    const res = await fetchApi(`/packages/${config.packageId}/upload`, token, {
+        method: "POST",
+        body: formData
+    });
+    let result;
+    try {
+        result = await res.json();
+    }
+    catch {
+        console.error(`Upload failed (${res.status})`);
+        process.exit(1);
+    }
+    if (!res.ok) {
+        console.error(result.error ?? "Upload failed");
+        process.exit(1);
+    }
+    const data = result;
+    console.log(`\nUploaded: ${data.versionId}`);
+    console.log(`Files: ${data.filesUploaded}, Size: ${(data.totalSize / 1024).toFixed(2)} KB`);
+}

package/dist/commands/versions.js

@@ -0,0 +1,18 @@
+import { getToken, getPackConfig } from "../config.js";
+import { fetchJson, fetchPackageName } from "../api.js";
+export async function versions() {
+    const token = getToken();
+    const config = await getPackConfig();
+    const data = await fetchJson(`/packages/${config.packageId}/versions`, token);
+    const name = await fetchPackageName(config.packageId, token);
+    console.log(`Package: ${name}\n`);
+    if (data.length === 0) {
+        console.log("  No versions yet");
+        return;
+    }
+    for (const v of data) {
+        const date = new Date(v.created_at).toISOString().slice(0, 19).replace("T", " ");
+        const size = (v.total_size / 1024).toFixed(1);
+        console.log(`  ${v.id}  ${v.file_count} files  ${size} KB  ${date}`);
+    }
+}

package/dist/config.js

@@ -0,0 +1,63 @@
+import { readFileSync } from "node:fs";
+import { readFile } from "node:fs/promises";
+import { join } from "node:path";
+function loadEnv() {
+    const cwd = process.cwd();
+    let raw;
+    for (const file of [".env", ".env.development"]) {
+        try {
+            raw = readFileSync(join(cwd, file), "utf8");
+            break;
+        }
+        catch {
+            continue;
+        }
+    }
+    if (!raw)
+        return;
+    for (const line of raw.split("\n")) {
+        const trimmed = line.trim();
+        if (!trimmed || trimmed.startsWith("#"))
+            continue;
+        const eq = trimmed.indexOf("=");
+        if (eq === -1)
+            continue;
+        const key = trimmed.slice(0, eq).trim();
+        let value = trimmed.slice(eq + 1).trim();
+        // Strip surrounding quotes
+        if ((value.startsWith('"') && value.endsWith('"')) ||
+            (value.startsWith("'") && value.endsWith("'"))) {
+            value = value.slice(1, -1);
+        }
+        if (!process.env[key]) {
+            process.env[key] = value;
+        }
+    }
+}
+export function getToken() {
+    loadEnv();
+    const token = process.env.PACKDOG_TOKEN;
+    if (!token) {
+        console.error("Missing PACKDOG_TOKEN");
+        console.error("Set it in .env (PACKDOG_TOKEN=...) or as an environment variable");
+        process.exit(1);
+    }
+    return token;
+}
+export async function getPackConfig() {
+    const configPath = join(process.cwd(), "packdog.json");
+    try {
+        const raw = await readFile(configPath, "utf8");
+        const config = JSON.parse(raw);
+        if (!config.packageId) {
+            console.error("packdog.json missing packageId");
+            process.exit(1);
+        }
+        return config;
+    }
+    catch {
+        console.error("packdog.json not found in current directory");
+        console.error("Run 'packdog init' to create one");
+        process.exit(1);
+    }
+}

package/dist/index.js

@@ -0,0 +1,69 @@
+#!/usr/bin/env node
+import { init } from "./commands/init.js";
+import { upload } from "./commands/upload.js";
+import { publish } from "./commands/publish.js";
+import { rollback } from "./commands/rollback.js";
+import { versions } from "./commands/versions.js";
+import { channels } from "./commands/channels.js";
+import { info } from "./commands/info.js";
+const command = process.argv[2];
+function getArg(name) {
+    const prefix = `--${name}=`;
+    const arg = process.argv.find((a) => a.startsWith(prefix));
+    return arg?.slice(prefix.length);
+}
+const HELP = `packdog — CLI for the Packdog package registry
+
+Commands:
+  init                     Register a new pack and create packdog.json
+  info                     Show pack name, versions and channels
+  upload                   Upload dist/ as a new version
+  publish                  Publish latest version to a channel
+  rollback                 Roll back a channel to its previous version
+  versions                 List all versions
+  channels                 List all channels
+
+Options:
+  --channel=<name>         Channel name (default: stable)
+  --version=<id>           Specific version ID (for publish)
+  --name=<name>            Pack name (for init)
+
+Environment (set in .env or .env.development):
+  PACKDOG_TOKEN            API token (required)
+  PACKDOG_URL              API URL (default: https://packdog.dev)
+`;
+async function main() {
+    switch (command) {
+        case "init":
+            await init(getArg("name"));
+            break;
+        case "upload":
+            await upload();
+            break;
+        case "publish":
+            await publish(getArg("channel"), getArg("version"));
+            break;
+        case "rollback":
+            await rollback(getArg("channel"));
+            break;
+        case "versions":
+            await versions();
+            break;
+        case "channels":
+            await channels();
+            break;
+        case "info":
+            await info();
+            break;
+        case "--help":
+        case "-h":
+        case undefined:
+            console.log(HELP);
+            break;
+        default:
+            console.error(`Unknown command: ${command}`);
+            console.log(HELP);
+            process.exit(1);
+    }
+}
+main();

package/package.json

@@ -0,0 +1,20 @@
+{
+  "name": "packdog",
+  "version": "0.1.0",
+  "description": "CLI for the Packdog package registry",
+  "license": "UNLICENSED",
+  "private": false,
+  "files": ["dist"],
+  "type": "module",
+  "bin": {
+    "packdog": "./dist/index.js"
+  },
+  "scripts": {
+    "build": "tsc",
+    "dev": "tsc --watch"
+  },
+  "devDependencies": {
+    "@types/node": "^25.3.5",
+    "typescript": "^5.9.3"
+  }
+}