codiedev 0.10.0-beta.16 → 0.10.0-beta.17

package/dist/commands/pack.js

@@ -37,6 +37,7 @@ exports.PACK_HELP = exports.DEFAULT_BACKEND_URL = void 0;
 exports.resolvePackConfig = resolvePackConfig;
 exports.ciHarnesses = ciHarnesses;
 exports.parsePackArgs = parsePackArgs;
+exports.downloadPackFiles = downloadPackFiles;
 exports.runList = runList;
 exports.runInstall = runInstall;
 exports.runStatus = runStatus;
@@ -45,6 +46,9 @@ exports.commitExport = commitExport;
 exports.exportPluginFolder = exportPluginFolder;
 exports.runExport = runExport;
 exports.runApply = runApply;
+exports.runPublish = runPublish;
+exports.skillKeyFor = skillKeyFor;
+exports.pushLocalSkill = pushLocalSkill;
 const install_1 = require("../packs/install");
 const harnesses_1 = require("../packs/harnesses");
 const manifest_1 = require("../packs/manifest");
@@ -58,7 +62,12 @@ const sync_1 = require("../packs/sync");
 const harnesses_2 = require("../packs/harnesses");
 const os = __importStar(require("os"));
 const utils_1 = require("../utils");
+const push_1 = require("./push");
+const skillFiles_1 = require("../packs/skillFiles");
+const skillMarker_1 = require("../skillMarker");
+const localSkills_1 = require("../packs/localSkills");
 const shared_1 = require("./shared");
+const files_1 = require("../packs/files");
 exports.DEFAULT_BACKEND_URL = "https://cli.codiedev.com";
 function resolvePackConfig(env = process.env) {
     const token = env.CODIEDEV_TOKEN?.trim();
@@ -96,7 +105,27 @@ const USAGE = `Usage:
                                          .claude-plugin/marketplace.json (commit it for CI).
                                          --git inits the folder and commits; --manifest writes
                                          an editable <slug>.pack.md instead
-  codiedev pack apply <pack.md>          Create or update a pack from a pack.md
+  codiedev pack apply <pack.md> [--publish] [--channel stable|beta|alpha] [--dry-run]
+                                         Create or update a pack from a pack.md
+                                         (--publish then publishes it, see below)
+  codiedev pack publish <slug> [--channel stable|beta|alpha]
+                                         Publish the pack's draft to a channel (default
+                                         stable). Nothing happens when it hasn't changed.
+
+Files (scripts, PDFs, a runner folder): list them under "## Files" in pack.md,
+one "- <path in pack> <- <local path>" per line (local paths are relative to
+the pack.md; "." is the pack root):
+
+  ## Files
+
+  - runner <- ~/.claude/runner
+  - skills/healthcare-scan <- ~/.claude/skills/healthcare-scan
+
+\`pack apply\` uploads them (admins and team managers; 15MB per file, 50MB per
+pack; caches, .git and hidden files are skipped). Without a "## Files"
+section the pack's files are left alone. In skills, point at files relative to
+the skill's folder, or use \${CLAUDE_PLUGIN_ROOT}/runner/...: Codiedev swaps in the
+real path for Codex, Copilot, Cursor, pi and Codie.
 
 Cursor: packs are copied to ~/.cursor/plugins/local/codiedev-<slug>/. A Cursor
 team admin can disable "user local plugin imports"; then Cursor ignores them.
@@ -133,8 +162,25 @@ got the pack. Skills from a pack are /<pack-slug>:<skill> in Claude Code.
       env:
         ANTHROPIC_API_KEY: \${{ secrets.ANTHROPIC_API_KEY }}
 
+  Keep a pack up to date from its repo (GitLab; on merges to main). Use a
+  personal Codiedev token of a pack owner (portal → Integrations → CLI tokens) as a
+  masked CODIEDEV_TOKEN: pack CI keys can only install, not publish.
+    pack-release:
+      image: node:22
+      rules: [{ if: '$CI_COMMIT_BRANCH == "main"' }]
+      script:
+        - npm i -g codiedev
+        - codiedev pack apply packs/platform-starter.pack.md --publish
+  Skills listed in pack.md as local folders ("- ./skills/healthcare-scan") are
+  pushed when their SKILL.md changed, and the rest of each folder ships with it.
+
   Or vendor the plugin into the repo instead of installing at build time:
     codiedev pack export <slug> --out .codiedev/packs`;
+function parseChannel(value) {
+    if (value === "stable" || value === "beta" || value === "alpha")
+        return value;
+    throw new Error(`--channel must be stable, beta or alpha (got ${value})`);
+}
 function parsePackArgs(args) {
     const out = { dryRun: false, json: false };
     const positional = [];
@@ -152,6 +198,15 @@ function parsePackArgs(args) {
             out.git = true;
         else if (a === "--manifest")
             out.manifest = true;
+        else if (a === "--publish")
+            out.publish = true;
+        else if (a === "--channel") {
+            if (i + 1 >= args.length)
+                throw new Error("--channel needs stable, beta or alpha");
+            out.channel = parseChannel(args[++i]);
+        }
+        else if (a.startsWith("--channel="))
+            out.channel = parseChannel(a.slice("--channel=".length));
         else if (a === "--out" || a === "-o") {
             if (i + 1 >= args.length)
                 throw new Error("--out needs a directory");
@@ -183,6 +238,15 @@ async function fetchManifest(config, slug) {
     const raw = await (0, shared_1.apiRequest)("GET", "/api/cli/packs/manifest", { config, query: { slug } });
     return (0, manifest_1.parseManifest)(raw);
 }
+async function downloadPackFiles(config, slug, files, dir) {
+    if (!files.length)
+        return 0;
+    const { downloaded } = await (0, files_1.ensureBlobs)(dir, files, (file) => (0, shared_1.apiRequestBytes)("GET", "/api/cli/packs/file", { config, query: { slug, sha256: file.sha256 }, maxBytes: files_1.PACK_FILE_MAX_BYTES + 1 })
+        .catch((error) => {
+        throw new Error(`couldn't download ${file.path} (${error.message})`);
+    }));
+    return downloaded;
+}
 async function runList(config, json, overrides = {}) {
     const packs = await listPacks(config);
     const registry = (0, store_1.readRegistry)((0, paths_1.packsRoot)(overrides.env, overrides.home));
@@ -201,6 +265,7 @@ async function runList(config, json, overrides = {}) {
             `${p.itemCount ?? 0} skill${p.itemCount === 1 ? "" : "s"}`,
             `${p.agentCount ?? 0} agent${p.agentCount === 1 ? "" : "s"}`,
             ...(p.hasHooks ? ["hooks"] : []),
+            ...(p.fileCount ? [`${p.fileCount} file${p.fileCount === 1 ? "" : "s"}`] : []),
         ].join(", ");
         const channel = (0, manifest_2.cleanLabel)(p.channel, 16);
         console.log(`${p.slug}  v${p.version}${channel ? ` [${channel}]` : ""}  ${(0, manifest_2.displayName)(p)}  (${counts}) — ${state}`);
@@ -236,8 +301,25 @@ async function runInstall(config, args, overrides = {}) {
                 throw new Error(`Pack not found or not assigned to your team: ${slug}`);
         }
     }
-    let installed = manifests.length
-        ? (0, install_1.installPacks)({ ...overrides, manifests, harnesses, dryRun: args.dryRun })
+    const blobDir = overrides.blobDir ?? (0, files_1.blobsDir)(root);
+    const ready = [];
+    let downloadFailed = false;
+    for (const manifest of manifests) {
+        if (args.dryRun || !manifest.files?.length) {
+            ready.push(manifest);
+            continue;
+        }
+        try {
+            await downloadPackFiles(config, manifest.slug, manifest.files, blobDir);
+            ready.push(manifest);
+        }
+        catch (error) {
+            downloadFailed = true;
+            console.error(`✗ ${manifest.slug}: ${error.message}`);
+        }
+    }
+    let installed = ready.length
+        ? (0, install_1.installPacks)({ ...overrides, manifests: ready, harnesses, dryRun: args.dryRun, blobDir })
         : [];
     let removed = [];
     if (!args.dryRun && !ci) {
@@ -279,7 +361,7 @@ async function runInstall(config, args, overrides = {}) {
     const ciFailed = ci && !args.dryRun && (installed.length === 0 || installed.some((p) => p.results.some((r) => r.status !== "ok")));
     if (ci && !args.dryRun && installed.length === 0)
         console.error("No pack is visible to this key.");
-    if (failed || ciFailed || (args.slug && removed.length + revoked.length > 0))
+    if (failed || ciFailed || downloadFailed || (args.slug && removed.length + revoked.length > 0))
         process.exitCode = 1;
     return run;
 }
@@ -390,14 +472,14 @@ async function runPack(args) {
         console.error(USAGE);
         process.exit(1);
     }
-    if (!parsed.sub || !["list", "ls", "install", "status", "export", "apply"].includes(parsed.sub)) {
+    if (!parsed.sub || !["list", "ls", "install", "status", "export", "apply", "publish"].includes(parsed.sub)) {
         console.error(USAGE);
         process.exit(parsed.sub ? 1 : 0);
     }
     const config = resolvePackConfig() ?? (0, shared_1.requireConfig)();
     const ci = (0, sync_1.isPackCiMode)();
     const restore = parsed.quiet ? silenceConsole() : () => { };
-    const track = ci ? (_c, _t, fn) => fn() : shared_1.withTelemetry;
+    const track = ci || parsed.quiet ? (_c, _t, fn) => fn() : shared_1.withTelemetry;
     try {
         await track(config, `codiedev_pack_${parsed.sub === "ls" ? "list" : parsed.sub}`, async () => {
             if (parsed.sub === "list" || parsed.sub === "ls")
@@ -408,6 +490,8 @@ async function runPack(args) {
                 await runExport(config, parsed);
             else if (parsed.sub === "apply")
                 await runApply(config, parsed);
+            else if (parsed.sub === "publish")
+                await runPublish(config, parsed);
             else
                 await runStatus(config, parsed.json, {}, { prune: !parsed.noPrune });
         });
@@ -468,9 +552,9 @@ function readMarketplaceEntries(dir) {
         return [];
     }
 }
-function exportPluginFolder(out, manifest) {
+function exportPluginFolder(out, manifest, blobDir) {
     fs.mkdirSync(out, { recursive: true });
-    const dir = (0, store_1.writePluginDir)(out, manifest);
+    const dir = (0, store_1.writePluginDir)(out, manifest, { blobDir });
     const entries = readMarketplaceEntries(out).filter((e) => e.slug !== manifest.slug);
     entries.push({ slug: manifest.slug, description: manifest.description || manifest.name, version: manifest.version });
     (0, store_1.writeMarketplace)(out, entries);
@@ -497,7 +581,22 @@ async function runExport(config, args) {
             throw new Error("Server returned no markdown");
         fs.mkdirSync(out, { recursive: true });
         written = path.join(out, `${args.slug}.pack.md`);
-        (0, store_1.writeFileAtomic)(written, res.markdown.endsWith("\n") ? res.markdown : `${res.markdown}\n`);
+        let markdown = res.markdown.endsWith("\n") ? res.markdown : `${res.markdown}\n`;
+        const files = (0, manifest_1.parseManifest)({ slug: args.slug, version: 0, contentHash: "-", files: res.files }).files ?? [];
+        if (files.length) {
+            const blobDir = (0, files_1.blobsDir)((0, paths_1.packsRoot)());
+            await downloadPackFiles(config, args.slug, files, blobDir);
+            const filesDir = path.join(out, `${args.slug}.files`);
+            fs.rmSync(filesDir, { recursive: true, force: true });
+            for (const f of files) {
+                const target = path.join(filesDir, ...f.path.split("/"));
+                fs.mkdirSync(path.dirname(target), { recursive: true });
+                fs.copyFileSync((0, files_1.blobPath)(blobDir, f.sha256), target);
+                fs.chmodSync(target, f.executable ? 0o755 : 0o644);
+            }
+            markdown = `${markdown.trimEnd()}\n\n## Files\n\n- . <- ./${args.slug}.files\n`;
+        }
+        (0, store_1.writeFileAtomic)(written, markdown);
         message = `codiedev pack export ${args.slug} (${args.slug}.pack.md)`;
     }
     else {
@@ -512,7 +611,9 @@ async function runExport(config, args) {
                 throw new Error(`Refusing to export ${args.slug}: ${error.message}`);
             throw error;
         }
-        written = exportPluginFolder(out, manifest);
+        const blobDir = (0, files_1.blobsDir)((0, paths_1.packsRoot)());
+        await downloadPackFiles(config, manifest.slug, manifest.files ?? [], blobDir);
+        written = exportPluginFolder(out, manifest, blobDir);
         message = `codiedev pack export ${manifest.slug} v${manifest.version}`;
     }
     const commit = args.git ? commitExport(out, message) : undefined;
@@ -540,13 +641,53 @@ async function runApply(config, args) {
     }
     if (!markdown.trim())
         throw new Error(`${file} is empty`);
+    const baseDir = path.dirname(file);
+    const skills = (0, localSkills_1.findLocalSkills)(markdown, baseDir);
+    const entries = (0, files_1.parseFilesSection)(markdown);
+    const local = entries ? (0, files_1.collectLocalFiles)(entries, baseDir) : null;
+    for (const note of local?.notes ?? [])
+        console.log(`  · ${note}`);
     if (args.dryRun) {
-        console.log(`Dry run — would apply ${file} (${Buffer.byteLength(markdown)} bytes).`);
+        const extra = local ? `, ${local.files.length} file${local.files.length === 1 ? "" : "s"} (${formatBytes(local.files.reduce((n, f) => n + f.size, 0))})` : "";
+        console.log(`Dry run — would apply ${file} (${Buffer.byteLength(markdown)} bytes${extra}).`);
+        for (const skill of skills) {
+            const folder = skill.dir ? (0, skillFiles_1.skillFolderFiles)(skill.skillFile) : null;
+            const files = folder && "files" in folder ? folder : null;
+            const withFiles = files?.files.length ? `, with ${files.files.length} file${files.files.length === 1 ? "" : "s"} from its folder` : "";
+            console.log(`  skill ${skill.name} ← ${path.relative(baseDir, skill.skillFile) || skill.skillFile} (pushed if changed${withFiles})`);
+            if (folder && "skipped" in folder)
+                console.log(`    ! SKILL.md only: ${folder.skipped}`);
+            for (const note of files?.notes ?? [])
+                console.log(`    · ${note}`);
+            for (const f of files?.files ?? [])
+                console.log(`    ${skill.pluginDir}/${f.path}`);
+        }
+        for (const f of local?.files ?? [])
+            console.log(`  ${f.path}`);
         return {};
     }
+    const keys = new Map();
+    let pushedSkills = 0;
+    for (const skill of skills) {
+        const { key, pushed } = await pushLocalSkill(config, skill);
+        keys.set(skill.line, key);
+        if (pushed)
+            pushedSkills += 1;
+    }
+    if (keys.size)
+        markdown = (0, localSkills_1.rewriteLocalSkills)(markdown, keys);
+    let uploaded = 0;
+    if (local?.files.length)
+        uploaded = await uploadPackFiles(config, local.files);
     let res;
     try {
-        res = await (0, shared_1.apiRequest)("POST", "/api/cli/packs/apply", { config, body: { markdown } });
+        res = await (0, shared_1.apiRequest)("POST", "/api/cli/packs/apply", {
+            config,
+            body: {
+                markdown,
+                ...(local ? { files: local.files.map((f) => ({ path: f.path, sha256: f.sha256, ...(f.executable ? { executable: true } : {}) })) } : {}),
+            },
+        });
     }
     catch (error) {
         const e = error;
@@ -561,6 +702,10 @@ async function runApply(config, args) {
         const verb = res.created === true ? "Created" : res.changed === false ? "No changes to" : "Updated";
         const version = typeof res.version === "number" ? ` v${res.version}` : "";
         console.log(`✓ ${verb} ${slug}${version} from ${path.basename(file)}`);
+        if (skills.length)
+            console.log(`  skills: ${skills.length} local (${pushedSkills} pushed, ${skills.length - pushedSkills} unchanged)`);
+        if (local)
+            console.log(`  files: ${local.files.length} (${uploaded} uploaded, ${local.files.length - uploaded} already on Codiedev)`);
         if (Array.isArray(res.warnings)) {
             for (const w of res.warnings) {
                 const text = typeof w === "string" ? w : typeof w?.message === "string" ? `${w.agent ? `${w.agent}: ` : ""}${w.message}` : JSON.stringify(w);
@@ -568,6 +713,107 @@ async function runApply(config, args) {
             }
         }
     }
+    if (args.publish && typeof res.slug === "string") {
+        const published = await runPublish(config, { ...args, slug: res.slug, json: false });
+        if (args.json)
+            return { ...res, published };
+    }
     return res;
 }
+async function runPublish(config, args) {
+    if (!args.slug)
+        throw new Error("Usage: codiedev pack publish <slug> [--channel stable|beta|alpha]");
+    if (!(0, manifest_2.isSafeSegment)(args.slug))
+        throw new Error(`Not a pack slug: ${args.slug}`);
+    const channel = args.channel ?? "stable";
+    if (args.dryRun) {
+        console.log(`Dry run — would publish ${args.slug}'s draft to ${channel}.`);
+        return { slug: args.slug, channel, version: 0, unchanged: true };
+    }
+    let res;
+    try {
+        res = await (0, shared_1.apiRequest)("POST", "/api/cli/packs/publish", { config, body: { slug: args.slug, channel } });
+    }
+    catch (error) {
+        const e = error;
+        if (e.status === 404)
+            throw new Error(`Pack not found: ${args.slug}`);
+        if (e.status === 403)
+            throw new Error(`You can't publish ${args.slug} (only its owners and admins can)`);
+        throw new Error(e.message);
+    }
+    const out = {
+        slug: typeof res.slug === "string" ? res.slug : args.slug,
+        channel,
+        version: typeof res.version === "number" ? res.version : 0,
+        unchanged: res.unchanged === true,
+    };
+    if (args.json)
+        console.log(JSON.stringify(out));
+    else if (out.unchanged)
+        console.log(`· ${out.slug} v${out.version} is already on ${channel} (no changes to publish)`);
+    else
+        console.log(`✓ Published ${out.slug} v${out.version} to ${channel}. Teams on ${channel} get it at their next sync.`);
+    return out;
+}
+function skillKeyFor(name) {
+    const slug = name.trim().toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "").slice(0, 64).replace(/-+$/g, "");
+    return slug ? `${slug}.md` : name;
+}
+async function pushLocalSkill(config, skill) {
+    const local = (0, skillMarker_1.stripSkillMarker)(fs.readFileSync(skill.skillFile, "utf8"));
+    const found = skill.dir ? (0, skillFiles_1.skillFolderFiles)(skill.skillFile) : null;
+    if (found && "skipped" in found)
+        console.log(`  ! ${skill.name}: pushing SKILL.md only, ${found.skipped}. The skill keeps the files it had.`);
+    const folder = found && "files" in found ? found : null;
+    for (const note of folder?.notes ?? [])
+        console.log(`  · ${skill.name}: ${note}`);
+    const localRefs = folder ? folder.files.map(skillFiles_1.toRef) : undefined;
+    for (const key of [skillKeyFor(skill.name), skill.name]) {
+        try {
+            const current = await (0, shared_1.apiRequest)("GET", "/api/cli/pull", { config, query: { key } });
+            const remote = current.artifact?.markdown;
+            if (current.artifact?.kind === "skill" &&
+                typeof remote === "string" &&
+                (0, skillMarker_1.stripSkillMarker)(remote).trimEnd() === local.trimEnd() &&
+                (!localRefs || (0, skillFiles_1.sameFileRefs)(current.artifact.files, localRefs))) {
+                return { key: current.artifact.key ?? key, pushed: false };
+            }
+            break;
+        }
+        catch (error) {
+            if (error.status !== 404)
+                throw new Error(`couldn't check skill ${skill.name} (${error.message})`);
+        }
+    }
+    try {
+        if (folder)
+            await (0, skillFiles_1.uploadBlobs)(config, folder.files, "/api/cli/skills/files");
+        const res = await (0, push_1.pushFile)(config, {
+            absPath: skill.skillFile,
+            key: path.basename(skill.skillFile),
+            kind: "skill",
+            visibility: "team",
+            ...(localRefs ? { files: localRefs } : {}),
+        });
+        return { key: res.key ?? skill.name, pushed: true };
+    }
+    catch (error) {
+        throw new Error(`couldn't push skill ${skill.name} (${error.message})`);
+    }
+}
+function formatBytes(n) {
+    return n >= 1024 * 1024 ? `${(n / (1024 * 1024)).toFixed(1)}MB` : n >= 1024 ? `${Math.round(n / 1024)}KB` : `${n}B`;
+}
+async function uploadPackFiles(config, files) {
+    try {
+        return await (0, skillFiles_1.uploadBlobs)(config, files, "/api/cli/packs/files");
+    }
+    catch (error) {
+        const e = error;
+        if (e.status === 403)
+            throw new Error(`Only admins and team managers can add files to a pack (${e.message})`);
+        throw error;
+    }
+}
 exports.PACK_HELP = USAGE;

package/dist/commands/ping.js

@@ -1,14 +1,24 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.PING_USAGE = void 0;
+exports.parsePingArgs = parsePingArgs;
 exports.runPing = runPing;
 const shared_1 = require("./shared");
-function parseArgs(args) {
+const pingFiles_1 = require("./pingFiles");
+const share_1 = require("./share");
+exports.PING_USAGE = 'Usage: codiedev ping <user> ["<message>"] [--with <artifact-key>] [--edit] [--file <path>]';
+function parsePingArgs(allArgs) {
+    const { files, rest: args } = (0, pingFiles_1.takeFileArgs)(allArgs);
     let to;
     const positional = [];
     let subjectKey;
+    let edit = false;
     for (let i = 0; i < args.length; i++) {
         const a = args[i];
-        if ((a === "--with" || a === "-w") && i + 1 < args.length) {
+        if (a === "--edit") {
+            edit = true;
+        }
+        else if ((a === "--with" || a === "-w") && i + 1 < args.length) {
             subjectKey = args[++i];
         }
         else if (a.startsWith("--with=")) {
@@ -18,29 +28,44 @@ function parseArgs(args) {
             positional.push(a);
         }
     }
-    if (positional.length < 2) {
-        console.error("Usage: codiedev ping <user> \"<message>\" [--with <artifact-key>]");
+    if (positional.length < 2 && !(positional.length === 1 && (files.length > 0 || subjectKey))) {
+        console.error(exports.PING_USAGE);
+        process.exit(1);
+    }
+    if (edit && !subjectKey) {
+        console.error("--edit needs an artifact: --with <artifact-key>");
         process.exit(1);
     }
     to = positional[0];
     const body = (0, shared_1.stripQuotes)(positional.slice(1).join(" "));
-    return { to, body, subjectKey };
+    return { to, body: body || (files.length ? "Sent a file." : ""), subjectKey, edit, files };
 }
-async function runPing(args) {
-    const { to, body, subjectKey } = parseArgs(args);
-    const config = (0, shared_1.requireConfig)();
+async function runPing(args, configOverride) {
+    const { to, body, subjectKey, edit, files } = parsePingArgs(args);
+    if (!body && subjectKey) {
+        await (0, share_1.runShare)([subjectKey, to, "--role", edit ? "edit" : "read"], configOverride);
+        return;
+    }
+    const config = configOverride ?? (0, shared_1.requireConfig)();
     const start = Date.now();
     try {
+        const attachmentIds = await (0, pingFiles_1.uploadOrExit)(config, files);
         const res = await (0, shared_1.apiRequest)("POST", "/api/cli/ping", {
             config,
-            body: { to, body, subjectKey },
+            body: {
+                to,
+                body,
+                subjectKey,
+                ...(subjectKey ? { grant: edit ? "edit" : "read" } : {}),
+                ...(attachmentIds.length ? { attachmentIds } : {}),
+            },
         });
         (0, shared_1.recordAgentEvent)(config, {
             tool: "codiedev_ping",
             ok: true,
             latencyMs: Date.now() - start,
         });
-        console.log(`✓ Pinged ${res.recipient.name} <${res.recipient.email}>${subjectKey ? ` on ${subjectKey}` : ""}`);
+        console.log(`✓ Pinged ${res.recipient.name} <${res.recipient.email}>${subjectKey ? ` on ${subjectKey}` : ""}${files.length ? ` with ${files.length} file${files.length === 1 ? "" : "s"}` : ""}`);
     }
     catch (err) {
         const e = err;

package/dist/commands/pingFiles.js

@@ -0,0 +1,145 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MAX_PING_FILE_BYTES = exports.MAX_PING_FILES = void 0;
+exports.contentTypeFor = contentTypeFor;
+exports.formatBytes = formatBytes;
+exports.takeFileArgs = takeFileArgs;
+exports.checkFiles = checkFiles;
+exports.uploadPingFiles = uploadPingFiles;
+exports.uploadOrExit = uploadOrExit;
+const fs_1 = __importDefault(require("fs"));
+const http_1 = __importDefault(require("http"));
+const https_1 = __importDefault(require("https"));
+const path_1 = __importDefault(require("path"));
+const version_1 = require("../version");
+exports.MAX_PING_FILES = 10;
+exports.MAX_PING_FILE_BYTES = 20 * 1024 * 1024;
+const CONTENT_TYPES = {
+    csv: "text/csv",
+    tsv: "text/tab-separated-values",
+    txt: "text/plain",
+    log: "text/plain",
+    md: "text/markdown",
+    json: "application/json",
+    yaml: "text/plain",
+    yml: "text/plain",
+    diff: "text/plain",
+    patch: "text/plain",
+    png: "image/png",
+    jpg: "image/jpeg",
+    jpeg: "image/jpeg",
+    gif: "image/gif",
+    webp: "image/webp",
+    pdf: "application/pdf",
+    zip: "application/zip",
+};
+function contentTypeFor(fileName) {
+    const ext = path_1.default.extname(fileName).slice(1).toLowerCase();
+    return CONTENT_TYPES[ext] ?? "application/octet-stream";
+}
+function formatBytes(bytes) {
+    if (bytes < 1024)
+        return `${bytes} B`;
+    if (bytes < 1024 * 1024)
+        return `${Math.round(bytes / 1024)} KB`;
+    return `${(bytes / (1024 * 1024)).toFixed(1)} MB`;
+}
+function takeFileArgs(args) {
+    const files = [];
+    const rest = [];
+    for (let i = 0; i < args.length; i++) {
+        const a = args[i];
+        if ((a === "--file" || a === "-f") && i + 1 < args.length)
+            files.push(args[++i]);
+        else if (a.startsWith("--file="))
+            files.push(a.slice("--file=".length));
+        else
+            rest.push(a);
+    }
+    return { files, rest };
+}
+function checkFiles(paths) {
+    const problems = [];
+    if (paths.length > exports.MAX_PING_FILES) {
+        problems.push({ path: "--file", reason: `at most ${exports.MAX_PING_FILES} files per message` });
+    }
+    for (const p of paths) {
+        let stat;
+        try {
+            stat = fs_1.default.statSync(p);
+        }
+        catch {
+            problems.push({ path: p, reason: "file not found" });
+            continue;
+        }
+        if (!stat.isFile())
+            problems.push({ path: p, reason: "not a file" });
+        else if (stat.size === 0)
+            problems.push({ path: p, reason: "file is empty" });
+        else if (stat.size > exports.MAX_PING_FILE_BYTES) {
+            problems.push({ path: p, reason: `larger than 20 MB (${formatBytes(stat.size)})` });
+        }
+    }
+    return problems;
+}
+function uploadOne(config, filePath) {
+    return new Promise((resolve, reject) => {
+        const name = path_1.default.basename(filePath);
+        const data = fs_1.default.readFileSync(filePath);
+        const url = new URL("/api/cli/ping-attachment", config.backendUrl);
+        url.searchParams.set("name", name);
+        const lib = url.protocol === "https:" ? https_1.default : http_1.default;
+        const req = lib.request({
+            hostname: url.hostname,
+            port: url.port || (url.protocol === "https:" ? 443 : 80),
+            path: url.pathname + url.search,
+            method: "POST",
+            headers: {
+                Authorization: `Bearer ${config.token}`,
+                "X-Codiedev-Cli-Version": version_1.CLI_VERSION,
+                "Content-Type": contentTypeFor(name),
+                "Content-Length": data.length,
+            },
+        }, (res) => {
+            let chunks = "";
+            res.on("data", (c) => (chunks += c));
+            res.on("end", () => {
+                let parsed = {};
+                try {
+                    parsed = chunks ? JSON.parse(chunks) : {};
+                }
+                catch {
+                }
+                if (res.statusCode && res.statusCode >= 200 && res.statusCode < 300 && parsed.attachment?.id) {
+                    resolve(parsed.attachment.id);
+                }
+                else {
+                    reject(new Error(`${name}: ${parsed.error ?? `HTTP ${res.statusCode}`}`));
+                }
+            });
+        });
+        req.on("error", (err) => reject(new Error(`${name}: ${err.message}`)));
+        req.write(data);
+        req.end();
+    });
+}
+async function uploadPingFiles(config, paths) {
+    const ids = [];
+    for (const p of paths)
+        ids.push(await uploadOne(config, p));
+    return ids;
+}
+async function uploadOrExit(config, paths) {
+    if (paths.length === 0)
+        return [];
+    const problems = checkFiles(paths);
+    if (problems.length) {
+        for (const p of problems)
+            console.error(`Can't attach ${p.path}: ${p.reason}`);
+        process.exit(1);
+    }
+    return await uploadPingFiles(config, paths);
+}