@higherdev/cli 0.36.0 → 0.38.0

package/dist/attachments.js

@@ -1,5 +1,5 @@
-import { readFile, stat } from "node:fs/promises";
-import { isAbsolute, basename, extname } from "node:path";
+import { readFile, readdir, stat } from "node:fs/promises";
+import { isAbsolute, basename, extname, join } from "node:path";
 import { loadConfig } from "./config.js";
 const MIME = {
     ".avif": "image/avif", ".bmp": "image/bmp", ".gif": "image/gif", ".heic": "image/heic",
@@ -8,6 +8,9 @@ const MIME = {
     ".text": "text/plain", ".md": "text/markdown", ".markdown": "text/markdown",
     ".json": "application/json", ".csv": "text/csv",
 };
+export const MAX_ATTACHMENTS_PER_DROP = 20;
+export const PATH_DOES_NOT_EXIST = "That path does not exist";
+const MAX_ATTACHMENT_BYTES = 20 * 1024 * 1024;
 export function formatAttachmentBytes(size) {
     if (size < 1024)
         return `${size} B`;
@@ -82,38 +85,127 @@ export function parseAttachArgs(argv) {
         }
         rest.push(arg);
     }
-    if (rest.length !== 1 || Boolean(ticketKey) === Boolean(to)) {
-        throw new Error("usage: hd attach PATH --ticket KEY | --to architect|orchestrator");
+    if (!rest.length || Boolean(ticketKey) === Boolean(to)) {
+        throw new Error("usage: hd attach PATH [PATH...] --ticket KEY | --to architect|orchestrator");
     }
     if (ticketKey && !/^HD-[1-9][0-9]*$/i.test(ticketKey))
         throw new Error("--ticket must be an HD-N key.");
-    return { path: rest[0], ...(ticketKey ? { ticketKey } : {}), ...(to ? { to } : {}) };
+    return { paths: rest, ...(ticketKey ? { ticketKey } : {}), ...(to ? { to } : {}) };
 }
 export function parseTuiAttach(text) {
     const words = shellWords(text.trim());
     if (!words?.length)
         return null;
-    const key = words.at(-1)?.match(/^HD-[1-9][0-9]*$/i)?.[0].toUpperCase();
-    const paths = key ? words.slice(0, -1) : words;
-    return paths.length === 1 ? { path: paths[0], ...(key ? { ticketKey: key } : {}) } : null;
+    const rest = [];
+    let to;
+    for (let at = 0; at < words.length; at += 1) {
+        if (words[at] !== "--to") {
+            rest.push(words[at]);
+            continue;
+        }
+        const role = words[++at];
+        if (role !== "architect" && role !== "orchestrator")
+            return null;
+        to = role;
+    }
+    const key = rest.at(-1)?.match(/^HD-[1-9][0-9]*$/i)?.[0].toUpperCase();
+    const paths = key ? rest.slice(0, -1) : rest;
+    if (!paths.length || (key && to))
+        return null;
+    return { paths, ...(key ? { ticketKey: key } : {}), ...(to ? { to } : {}) };
+}
+export function absolutePathInput(text) {
+    const words = shellWords(text.trim());
+    return words?.length && words.every(isAbsolute) ? words : [];
+}
+/**
+ * Text that a Finder drop produces: one or more absolute paths, plain, quoted, or with
+ * escaped spaces. Terminal.app inserts a drop as typed text rather than a bracketed
+ * paste, so the input component and the Enter handler both check this before treating
+ * a line starting with "/" as a slash command.
+ */
+export function looksLikeDroppedPaths(text) {
+    const trimmed = text.trim();
+    if (!/^(?:\/|'\/|"\/)/.test(trimmed))
+        return false;
+    // A slash command is one word without a second "/" (e.g. /architect, /ticket HD-1).
+    const firstWord = trimmed.split(/\s+/)[0].replace(/^['"]/, "");
+    return firstWord.slice(1).includes("/") || /^['"]/.test(trimmed);
+}
+async function collectFiles(input, files) {
+    const info = await stat(input);
+    if (info.isFile()) {
+        files.push(input);
+        return;
+    }
+    if (!info.isDirectory())
+        return;
+    const entries = await readdir(input, { withFileTypes: true });
+    entries.sort((left, right) => left.name.localeCompare(right.name));
+    for (const entry of entries) {
+        const child = join(input, entry.name);
+        if (entry.isDirectory())
+            await collectFiles(child, files);
+        else if (entry.isFile())
+            files.push(child);
+    }
+}
+export async function expandAttachmentPaths(inputs, limit = MAX_ATTACHMENTS_PER_DROP) {
+    const files = [];
+    const missing = [];
+    let existingInputs = 0;
+    for (const input of inputs) {
+        try {
+            await collectFiles(input, files);
+            existingInputs += 1;
+        }
+        catch (error) {
+            if (["ENOENT", "ENOTDIR"].includes(error.code ?? ""))
+                missing.push(input);
+            else
+                throw error;
+        }
+    }
+    const unique = [...new Set(files)].sort((left, right) => left.localeCompare(right));
+    const skipped = { unsupported: 0, tooLarge: 0, limit: 0 };
+    const allowed = [];
+    for (const file of unique) {
+        if (!MIME[extname(file).toLowerCase()]) {
+            skipped.unsupported += 1;
+            continue;
+        }
+        if ((await stat(file)).size > MAX_ATTACHMENT_BYTES) {
+            skipped.tooLarge += 1;
+            continue;
+        }
+        if (allowed.length >= limit) {
+            skipped.limit += 1;
+            continue;
+        }
+        allowed.push(file);
+    }
+    return { paths: allowed, missing, existingInputs, skipped };
+}
+export function attachmentSkipNote(expansion) {
+    const reasons = [];
+    if (expansion.skipped.unsupported)
+        reasons.push(`${expansion.skipped.unsupported} unsupported type${expansion.skipped.unsupported === 1 ? "" : "s"}`);
+    if (expansion.skipped.tooLarge)
+        reasons.push(`${expansion.skipped.tooLarge} over 20 MB`);
+    if (expansion.skipped.limit)
+        reasons.push(`${expansion.skipped.limit} beyond the 20-file limit`);
+    const count = expansion.skipped.unsupported + expansion.skipped.tooLarge + expansion.skipped.limit;
+    return count ? `Skipped ${count} file${count === 1 ? "" : "s"}: ${reasons.join(", ")}.` : null;
 }
-export async function detectDroppedPaths(pasted, isFile = async (path) => (await stat(path)).isFile()) {
-    const text = pasted.trim();
-    if (!text)
-        return [];
-    if (isAbsolute(text) && await isFile(text).catch(() => false))
-        return [text];
-    const words = shellWords(text);
-    if (!words?.length || words.some((path) => !isAbsolute(path)))
-        return [];
-    const checks = await Promise.all(words.map((path) => isFile(path).catch(() => false)));
-    return checks.every(Boolean) ? words : [];
+export async function detectDroppedPaths(pasted) {
+    const paths = absolutePathInput(pasted);
+    return paths.length ? (await expandAttachmentPaths(paths)).paths : [];
 }
 export async function uploadAttachment(path, target = {}, config = loadConfig(), fetchImpl = fetch) {
     const info = await stat(path);
     if (!info.isFile())
         throw new Error(`${path} is not a file.`);
-    if (info.size > 20 * 1024 * 1024)
+    if (info.size > MAX_ATTACHMENT_BYTES)
         throw new Error("Attachments must be 20 MB or smaller.");
     const mime = MIME[extname(path).toLowerCase()];
     if (!mime)

package/dist/index.js

@@ -13,7 +13,7 @@ import { banner, c, statusChip, table, truncate, usage } from "./out.js";
 import { ticketNew } from "./ticket-commands.js";
 import { ticketViewLines } from "./tui/ticket-view.js";
 import { agentAdd, AGENT_ADD_USAGE } from "./agent-commands.js";
-import { attachmentChip, parseAttachArgs, uploadAttachment } from "./attachments.js";
+import { attachmentChip, attachmentSkipNote, expandAttachmentPaths, parseAttachArgs, PATH_DOES_NOT_EXIST, uploadAttachment } from "./attachments.js";
 import { WORKSPACE_USAGE, workspaceGrantRunnerAccess, workspaceNew, workspaceRotateKey, workspaceSet, workspaceUse } from "./workspace-commands.js";
 import { defaultGh, hasWriteRepoPermission, HDX_RUNNER_GH_USER, requireAdminRepo, runnerRepoPermission } from "./workspace-preflight.js";
 function fail(message) {
@@ -309,14 +309,26 @@ async function cmdMsg(argv) {
     });
     console.log(`sent ${message.id}`);
 }
-export async function cmdAttach(argv) {
+export async function cmdAttach(argv, deps = {}) {
     const parsed = parseAttachArgs(argv);
-    const attachment = await uploadAttachment(parsed.path, parsed.ticketKey ? { ticketKey: parsed.ticketKey } : {});
-    if (parsed.to) {
-        await postMessage({ body_md: `Attached ${attachment.name}.`, to_role: parsed.to, delivery: "queue",
-            attachment_ids: [attachment.id] });
-    }
-    console.log(`${attachmentChip(attachment)}${parsed.ticketKey ? ` attached to ${parsed.ticketKey}` : ` sent to ${parsed.to}`}`);
+    const expansion = await expandAttachmentPaths(parsed.paths);
+    if (expansion.missing.length)
+        throw new Error(PATH_DOES_NOT_EXIST);
+    const note = attachmentSkipNote(expansion);
+    if (!expansion.paths.length)
+        throw new Error(["No supported files found.", note].filter(Boolean).join(" "));
+    const config = deps.config ?? loadConfig();
+    const attachments = [];
+    for (const path of expansion.paths)
+        attachments.push(await uploadAttachment(path, {}, config, deps.fetch));
+    await (deps.postMessage ?? postMessage)({ body_md: `Attached ${attachments.length} files`,
+        to_role: parsed.to ?? "builder", delivery: "queue", ...(parsed.ticketKey ? { ticket_key: parsed.ticketKey } : {}),
+        attachment_ids: attachments.map((item) => item.id) }, config);
+    for (const attachment of attachments)
+        console.log(attachmentChip(attachment));
+    console.log(`Attached ${attachments.length} files${parsed.ticketKey ? ` to ${parsed.ticketKey}` : ` to ${parsed.to}`}.`);
+    if (note)
+        console.log(note);
 }
 async function cmdInbox(argv) {
     const { rest, opts, bools } = flags(argv);

package/dist/out.js

@@ -76,7 +76,7 @@ export function usage() {
         `  ${c.blue("hd host runner-install | roll | env")} install CI, roll, or edit host env`,
         `  ${c.blue("hd logs KEY [-f]")}                  run events`,
         `  ${c.blue("hd msg KEY TEXT")}                   message a builder`,
-        `  ${c.blue("hd attach PATH --ticket KEY | --to ROLE")} attach a file`,
+        `  ${c.blue("hd attach PATH... --ticket KEY | --to ROLE")} attach files or a folder`,
         `  ${c.blue("hd inbox [--all] [--limit N] [--json]")} inbox messages`,
         `  ${c.blue("hd decide [ID --answer TEXT]")}      decisions`,
         `  ${c.blue("hd on | hd off")}                    workspace switch`,

package/dist/tui/App.js

@@ -33,7 +33,7 @@ import { editFor, editableKeys, nextValue, seedFor, settingsRows } from "./setti
 import { appendLines, runLabels, toStreamLines } from "./stream.js";
 import { UI } from "./theme.js";
 import { WorkspaceLoads } from "./workspace-load.js";
-import { attachmentChip, detectDroppedPaths, uploadAttachment } from "../attachments.js";
+import { absolutePathInput, attachmentChip, attachmentSkipNote, expandAttachmentPaths, looksLikeDroppedPaths, MAX_ATTACHMENTS_PER_DROP, PATH_DOES_NOT_EXIST, uploadAttachment } from "../attachments.js";
 let messageSeq = 0;
 const nextId = () => `m${messageSeq++}`;
 const tuiPrompt = (question) => promptOnStdin(question, true);
@@ -456,31 +456,43 @@ export function App({ initial, availableUpdate: initialUpdate = null, updateDeps
             }
         })();
     }, [agentName, config, pendingAttachments, setThread, workspace.id]);
+    const uploadExpanded = useCallback(async (inputs, target = {}, prepared, limit = MAX_ATTACHMENTS_PER_DROP) => {
+        const expansion = prepared ?? await expandAttachmentPaths(inputs, limit);
+        if (expansion.missing.length)
+            throw new Error(PATH_DOES_NOT_EXIST);
+        const note = attachmentSkipNote(expansion);
+        if (!expansion.paths.length)
+            throw new Error(["No supported files found.", note].filter(Boolean).join(" "));
+        const uploaded = [];
+        for (const path of expansion.paths) {
+            try {
+                uploaded.push(await uploadAttachment(path, { ...target, onProgress: (progress) => setAttachmentUploads((current) => ({ ...current, [path]: progress })) }, config));
+            }
+            finally {
+                setAttachmentUploads((current) => {
+                    const next = { ...current };
+                    delete next[path];
+                    return next;
+                });
+            }
+        }
+        return { uploaded, note };
+    }, [config, pendingAttachments.length]);
     const receiveDrop = useCallback((pasted) => {
-        if (!/^(?:\/|'\/|"\/)/.test(pasted.trim()))
+        if (!looksLikeDroppedPaths(pasted))
             return false;
         void (async () => {
-            const paths = await detectDroppedPaths(pasted);
-            if (!paths.length) {
+            const inputs = absolutePathInput(pasted);
+            if (!inputs.length) {
                 setDraft((current) => current + pasted.replace(/[\r\n]+/g, " "));
                 return;
             }
             setBusy(true);
             try {
-                const uploaded = [];
-                for (const path of paths) {
-                    try {
-                        uploaded.push(await uploadAttachment(path, { onProgress: (progress) => setAttachmentUploads((current) => ({ ...current, [path]: progress })) }, config));
-                    }
-                    finally {
-                        setAttachmentUploads((current) => {
-                            const next = { ...current };
-                            delete next[path];
-                            return next;
-                        });
-                    }
-                }
+                const { uploaded, note } = await uploadExpanded(inputs, {}, undefined, Math.max(0, MAX_ATTACHMENTS_PER_DROP - pendingAttachments.length));
                 setPendingAttachments((current) => [...current, ...uploaded]);
+                if (note)
+                    setNotice(note);
             }
             catch (error) {
                 setNotice(error instanceof Error ? error.message : String(error));
@@ -490,7 +502,7 @@ export function App({ initial, availableUpdate: initialUpdate = null, updateDeps
             }
         })();
         return true;
-    }, [config]);
+    }, [uploadExpanded]);
     const openTicket = useCallback(async (key) => {
         setTicketKey(key);
         setView("ticket");
@@ -520,6 +532,28 @@ export function App({ initial, availableUpdate: initialUpdate = null, updateDeps
     }, [view, ticketKey, visibleStory?.latest_headline, visibleStory?.timeline, config]);
     const run = useCallback(async (raw) => {
         const text = raw.trim();
+        // An existing absolute path always wins over slash-command parsing in every view.
+        const absolutePaths = absolutePathInput(text);
+        if (absolutePaths.length) {
+            const expansion = await expandAttachmentPaths(absolutePaths, Math.max(0, 20 - pendingAttachments.length));
+            if (expansion.existingInputs) {
+                setDraft("");
+                setBusy(true);
+                try {
+                    const { uploaded, note } = await uploadExpanded(absolutePaths, {}, expansion);
+                    setPendingAttachments((current) => [...current, ...uploaded]);
+                    if (note)
+                        setNotice(note);
+                }
+                catch (error) {
+                    setNotice(error instanceof Error ? error.message : String(error));
+                }
+                finally {
+                    setBusy(false);
+                }
+                return;
+            }
+        }
         if (view === "settings") {
             const open = editingRef.current;
             if (open) {
@@ -582,6 +616,10 @@ export function App({ initial, availableUpdate: initialUpdate = null, updateDeps
         setDraft("");
         setNotice(null);
         const action = parseLine(text);
+        if (absolutePaths.length && action.kind === "unknown") {
+            setNotice(PATH_DOES_NOT_EXIST);
+            return;
+        }
         if (action.kind === "say") {
             if (mode !== "browse")
                 askAgent(mode, text);
@@ -880,12 +918,26 @@ export function App({ initial, availableUpdate: initialUpdate = null, updateDeps
             case "attach":
                 setBusy(true);
                 try {
-                    const key = action.key ?? ticketKey;
-                    if (!key)
-                        throw new Error("Open a ticket or include its HD-N key.");
-                    const attachment = await uploadAttachment(action.path, { ticketKey: key }, config);
-                    say("system", `${attachmentChip(attachment)} attached to ${key}.`);
-                    await refresh();
+                    const key = action.key ?? (view === "ticket" ? ticketKey : null);
+                    if (!key && !action.to && view !== "chat") {
+                        throw new Error("Choose a target: open a ticket, add HD-N, or use --to architect|orchestrator.");
+                    }
+                    const queuesForChat = !key && !action.to;
+                    const { uploaded, note } = await uploadExpanded(action.paths, key ? { ticketKey: key } : {}, undefined, queuesForChat ? Math.max(0, MAX_ATTACHMENTS_PER_DROP - pendingAttachments.length) : MAX_ATTACHMENTS_PER_DROP);
+                    if (action.to) {
+                        await postAgentMessage(action.to, `Attached ${uploaded.length} files`, config, uploaded.map((attachment) => attachment.id));
+                        say("system", `Attached ${uploaded.length} files to ${action.to}.`);
+                    }
+                    else if (key) {
+                        say("system", `Attached ${uploaded.length} files to ${key}.`);
+                        await refresh();
+                    }
+                    else {
+                        setPendingAttachments((current) => [...current, ...uploaded]);
+                        say("system", `Attached ${uploaded.length} files to your next ${mode} message.`);
+                    }
+                    if (note)
+                        setNotice(note);
                 }
                 catch (error) {
                     setNotice(error instanceof Error ? error.message : String(error));
@@ -950,7 +1002,8 @@ export function App({ initial, availableUpdate: initialUpdate = null, updateDeps
         }
     }, [view, settings, applyEdit, board, browsing, mode, say, askAgent, openAgentChat, order, settingsOrder,
         changeWorkspace, config, refresh, suspendTerminal, exit, inbox, inboxFocus, openTicket, answering,
-        selectedDecisionId, submitDecision, ticketKey, ticketCollapsed, ticketOffset, width, pendingAttachments]);
+        selectedDecisionId, submitDecision, ticketKey, ticketCollapsed, ticketOffset, width, pendingAttachments,
+        uploadExpanded]);
     useInput((input, key) => {
         if (key.ctrl && input === "c") {
             exit();

package/dist/tui/Help.js

@@ -13,7 +13,7 @@ export const COMMANDS = [
     { name: "/cancel", args: "HD-12 | RUN-ID", help: "cancel a ticket or run" },
     { name: "/merge", args: "HD-12", help: "approve a reviewed PR over the reviewer's objections" },
     { name: "/msg", args: "HD-12 TEXT", help: "message a ticket's builder" },
-    { name: "/attach", args: "PATH [HD-12]", help: "attach a file to the open or named ticket" },
+    { name: "/attach", args: "PATH... [HD-12 | --to ROLE]", help: "attach files, or queue them for this chat" },
     { name: "/logs", args: "[raw] [HD-12]", help: "filter activity; raw reveals event JSON" },
     { name: "/epic", args: "new PATH [--draft] | approve ID | rm ID", help: "create, approve, or remove an epic" },
     { name: "/epics", help: "list epics and ticket progress" },

package/dist/tui/TextInput.js

@@ -73,6 +73,11 @@ export default function TextInput({ value, onChange, onSubmit, onCancel, onUp, o
         // most of them. Ink reports that as ordinary input with key.return
         // false, so without this the Enter is filtered out with the other
         // control bytes and the line just sits at the prompt unsent.
+        // A Finder drop in Terminal.app arrives as one multi-character chunk of
+        // typed text, not a bracketed paste, so it is offered to the paste
+        // handler first.
+        if (input.length > 1 && onPasteText?.(input))
+            return;
         if (input.length > 1 && /[\r\n]/.test(input)) {
             const parts = input.split(/\r\n|\r|\n/);
             const submits = parts.length === 2 && parts[1] === "";

package/dist/tui/parse.js

@@ -105,8 +105,8 @@ export function parseLine(raw) {
                 : { kind: "unknown", command: "msg needs KEY TEXT" };
         case "attach": {
             const parsed = parseTuiAttach(argument);
-            return parsed ? { kind: "attach", path: parsed.path, key: parsed.ticketKey ?? null }
-                : { kind: "unknown", command: "attach needs PATH and an optional HD-N key" };
+            return parsed ? { kind: "attach", paths: parsed.paths, key: parsed.ticketKey ?? null, to: parsed.to ?? null }
+                : { kind: "unknown", command: "attach needs PATH [PATH...] and HD-N or --to architect|orchestrator" };
         }
         case "logs":
             if (rest[0]?.toLowerCase() === "raw" && rest.length <= 2) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@higherdev/cli",
-  "version": "0.36.0",
+  "version": "0.38.0",
   "type": "module",
   "repository": {
     "type": "git",