@gobi-ai/cli 2.0.24 → 2.0.25

package/dist/commands/artifact.js

@@ -0,0 +1,472 @@
+import { existsSync, readFileSync, statSync, } from "fs";
+import { basename, extname, isAbsolute, resolve } from "path";
+import { apiDelete, apiGet, apiPatch, apiPost } from "../client.js";
+import { isJsonMode, jsonOut, readStdin, unwrapResp } from "./utils.js";
+import { extractWikiLinks, uploadAttachments } from "../attachments.js";
+import { getValidToken } from "../auth/manager.js";
+// Artifact kinds, mirrored from the backend (entities/artifact.entity.ts).
+const MARKDOWN_KINDS = ["markdown", "meeting_summary"];
+const MEDIA_KINDS = ["image", "video", "gif"];
+const ALL_KINDS = [...MEDIA_KINDS, ...MARKDOWN_KINDS];
+function isMarkdownKind(kind) {
+    return MARKDOWN_KINDS.includes(kind);
+}
+function isMediaKind(kind) {
+    return MEDIA_KINDS.includes(kind);
+}
+// Best-effort extension → MIME mapping for artifact media uploads. Mirrors the
+// post-attachment map in attachments.ts; the backend derives the per-tier size
+// ceiling (5MB photos / 15MB GIFs / 512MB video) from the content type.
+const ARTIFACT_MIME_MAP = {
+    ".jpg": "image/jpeg",
+    ".jpeg": "image/jpeg",
+    ".png": "image/png",
+    ".gif": "image/gif",
+    ".webp": "image/webp",
+    ".heic": "image/heic",
+    ".heif": "image/heif",
+    ".avif": "image/avif",
+    ".svg": "image/svg+xml",
+    ".bmp": "image/bmp",
+    ".tiff": "image/tiff",
+    ".mp4": "video/mp4",
+    ".mov": "video/quicktime",
+    ".webm": "video/webm",
+    ".m4v": "video/x-m4v",
+};
+function readContent(value) {
+    if (value === "-")
+        return readStdin();
+    return value;
+}
+// Resolve the markdown body for create/revise from --file | --content | stdin.
+// Returns undefined when none is given (revise may carry media instead).
+function resolveBody(opts) {
+    if (opts.file && opts.content) {
+        throw new Error("--file and --content are mutually exclusive.");
+    }
+    if (opts.file) {
+        const abs = isAbsolute(opts.file) ? opts.file : resolve(process.cwd(), opts.file);
+        if (!existsSync(abs))
+            throw new Error(`File not found: ${opts.file}`);
+        return readFileSync(abs, "utf8");
+    }
+    if (opts.content != null)
+        return readContent(opts.content);
+    return undefined;
+}
+// Upload a local media file via POST /artifacts/upload-url → PUT to S3 →
+// return { mediaUrl, mediaKey } for the artifact create/revise body. Mirrors
+// uploadPostAttachment in attachments.ts but against the artifact endpoint.
+async function uploadArtifactMedia(filePath) {
+    const abs = isAbsolute(filePath) ? filePath : resolve(process.cwd(), filePath);
+    if (!existsSync(abs))
+        throw new Error(`File not found: ${filePath}`);
+    const ext = extname(abs).toLowerCase();
+    const contentType = ARTIFACT_MIME_MAP[ext] || "application/octet-stream";
+    const fileSize = statSync(abs).size;
+    const initResp = (await apiPost("/artifacts/upload-url", {
+        fileName: basename(abs),
+        contentType,
+        fileSize,
+    }));
+    const data = unwrapResp(initResp);
+    const uploadUrl = data.uploadUrl;
+    const mediaUrl = data.mediaUrl;
+    const mediaKey = data.mediaKey;
+    if (!uploadUrl || !mediaUrl || !mediaKey) {
+        throw new Error("Upload init returned an incomplete payload");
+    }
+    const putRes = await fetch(uploadUrl, {
+        method: "PUT",
+        headers: { "Content-Type": contentType },
+        body: readFileSync(abs),
+    });
+    if (!putRes.ok) {
+        throw new Error(`Failed to PUT ${filePath} to S3: HTTP ${putRes.status}`);
+    }
+    return { mediaUrl, mediaKey };
+}
+// Append an artifact to a post without clobbering its existing artifacts. The
+// post edit endpoint treats `artifactIds` as a full replacement of the post's
+// artifact attachments, so we read the post's current artifact attachments,
+// append the new id, and write the merged set.
+async function attachArtifactToPost(postId, artifactId) {
+    const resp = (await apiGet(`/posts/${postId}`));
+    const data = unwrapResp(resp);
+    const post = (data.update || data.post || data);
+    const attachments = (post.attachments || []);
+    const existing = attachments
+        .map((a) => a.artifact?.artifactId)
+        .filter((x) => typeof x === "string");
+    const merged = existing.includes(artifactId)
+        ? existing
+        : [...existing, artifactId];
+    await apiPatch(`/posts/${postId}`, { artifactIds: merged });
+}
+function formatRevisionLine(r) {
+    const marker = r.state === "published" ? "✓ published" : "  draft";
+    const note = r.changeNote ? ` — ${r.changeNote}` : "";
+    const parent = r.parentRevisionId != null ? ` (from ${r.parentRevisionId.slice(0, 8)})` : "";
+    return `  seq ${r.seq} [${marker}] ${r.revisionId.slice(0, 8)} by user ${r.authorUserId}${parent}${note}  ${r.createdAt}`;
+}
+function printArtifact(a) {
+    console.log(`Artifact ${a.artifactId}`);
+    console.log(`  kind:      ${a.kind}`);
+    if (a.title)
+        console.log(`  title:     ${a.title}`);
+    console.log(`  owner:     user ${a.ownerUserId}`);
+    if (a.ownerVault) {
+        console.log(`  vault:     ${a.ownerVault.slug} (${a.ownerVault.public ? "public" : "private"})`);
+    }
+    console.log(`  published: ${a.isPublished ? "yes" : "no"}`);
+    console.log(`  canWrite:  ${a.canWrite ? "yes" : "no"}`);
+    console.log(`  created:   ${a.createdAt}`);
+    console.log(`  updated:   ${a.updatedAt}`);
+    const rev = a.revision;
+    if (rev) {
+        console.log("");
+        console.log(`Current revision (seq ${rev.seq}, ${rev.state}):`);
+        if (rev.content != null) {
+            console.log("");
+            console.log(rev.content);
+        }
+        if (rev.mediaUrl)
+            console.log(`  mediaUrl: ${rev.mediaUrl}`);
+    }
+}
+export function registerArtifactCommand(program) {
+    const artifact = program
+        .command("artifact")
+        .description("Versioned creations attached to posts. Kinds: image | video | gif | markdown | meeting_summary. " +
+        "Always human-owned; revisions form a draft/published tree (at most one published per artifact).");
+    // ── Create ──
+    artifact
+        .command("create")
+        .description("Create an artifact. markdown/meeting_summary kinds take a body via --file, --content, or stdin (\"-\"). image/gif/video kinds upload --file. Pass --post-id to attach the new artifact to a post.")
+        .requiredOption("--kind <kind>", `Artifact kind: ${ALL_KINDS.join(" | ")}`)
+        .option("--file <path>", "Local file: markdown body (markdown kinds) or media file (media kinds)")
+        .option("--content <md>", "Markdown body inline (markdown kinds; pass \"-\" for stdin)")
+        .option("--title <t>", "Display title")
+        .option("--vault-slug <slug>", "Anchor vault for [[wikilink]] resolution (markdown kinds). Stored in metadata.vaultSlug.")
+        .option("--post-id <id>", "Attach the created artifact to this post afterward")
+        .option("--auto-attachments", "Upload wiki-linked [[files]] to webdrive before creating (markdown kinds; uses --vault-slug)")
+        .option("--change-note <note>", "Note describing this revision")
+        .action(async (opts) => {
+        const kind = opts.kind;
+        if (!ALL_KINDS.includes(kind)) {
+            throw new Error(`--kind must be one of: ${ALL_KINDS.join(", ")}`);
+        }
+        const body = { kind };
+        if (opts.title != null)
+            body.title = opts.title;
+        if (opts.vaultSlug)
+            body.vaultSlug = opts.vaultSlug;
+        if (opts.changeNote != null)
+            body.changeNote = opts.changeNote;
+        if (isMarkdownKind(kind)) {
+            const content = resolveBody(opts);
+            if (content == null) {
+                throw new Error("markdown/meeting_summary kinds require a body via --file, --content, or stdin.");
+            }
+            if (opts.autoAttachments) {
+                if (!opts.vaultSlug) {
+                    throw new Error("--auto-attachments requires --vault-slug.");
+                }
+                const token = await getValidToken();
+                const links = extractWikiLinks(content);
+                await uploadAttachments(opts.vaultSlug, links, token, {
+                    addToSyncfiles: true,
+                });
+            }
+            body.content = content;
+        }
+        else if (isMediaKind(kind)) {
+            if (!opts.file)
+                throw new Error(`${kind} kind requires --file.`);
+            if (opts.content != null) {
+                throw new Error("--content is only valid for markdown kinds.");
+            }
+            if (opts.autoAttachments) {
+                throw new Error("--auto-attachments is only valid for markdown kinds.");
+            }
+            const { mediaUrl, mediaKey } = await uploadArtifactMedia(opts.file);
+            body.mediaUrl = mediaUrl;
+            body.mediaKey = mediaKey;
+        }
+        const resp = (await apiPost("/artifacts", body));
+        const a = unwrapResp(resp);
+        if (opts.postId) {
+            await attachArtifactToPost(opts.postId, a.artifactId);
+        }
+        if (isJsonMode(artifact)) {
+            jsonOut(a);
+            return;
+        }
+        console.log(`Artifact created!\n` +
+            `  ID:   ${a.artifactId}\n` +
+            `  Kind: ${a.kind}` +
+            (a.title ? `\n  Title: ${a.title}` : "") +
+            (opts.postId ? `\n  Attached to post: ${opts.postId}` : ""));
+    });
+    // ── Revise ──
+    artifact
+        .command("revise <artifactId>")
+        .description("Add a draft revision to an artifact. New body via --file, --content, or stdin (markdown), or --file (media). Use --from to branch off a specific revision.")
+        .option("--file <path>", "Local file: markdown body (markdown kinds) or media file (media kinds)")
+        .option("--content <md>", "Markdown body inline (markdown kinds; pass \"-\" for stdin)")
+        .option("--change-note <note>", "Note describing this revision")
+        .option("--from <revisionId>", "Branch the new draft off this revision (defaults to the latest)")
+        .option("--auto-attachments", "Upload wiki-linked [[files]] to webdrive before revising (markdown kinds; uses the artifact's stored metadata.vaultSlug)")
+        .action(async (artifactId, opts) => {
+        // Fetch the artifact first to learn its kind — that determines how
+        // --file is handled (markdown body text vs binary media upload). Also
+        // carries metadata.vaultSlug for --auto-attachments. Branching on kind
+        // (like `create`) is REQUIRED: resolveBody() reads --file as UTF-8, so
+        // calling it for a media kind would corrupt the binary into `content`.
+        const getResp = (await apiGet(`/artifacts/${artifactId}`));
+        const existing = unwrapResp(getResp);
+        const kind = existing.kind;
+        const body = {};
+        if (opts.changeNote != null)
+            body.changeNote = opts.changeNote;
+        if (opts.from)
+            body.fromRevisionId = opts.from;
+        if (isMarkdownKind(kind)) {
+            const content = resolveBody(opts);
+            if (content == null) {
+                throw new Error("markdown/meeting_summary kinds require a new body via --file, --content, or stdin.");
+            }
+            if (opts.autoAttachments) {
+                const vaultSlug = existing.metadata?.vaultSlug;
+                if (!vaultSlug) {
+                    throw new Error("--auto-attachments needs the artifact's metadata.vaultSlug, which is not set.");
+                }
+                const token = await getValidToken();
+                const links = extractWikiLinks(content);
+                await uploadAttachments(vaultSlug, links, token, {
+                    addToSyncfiles: true,
+                });
+            }
+            body.content = content;
+        }
+        else if (isMediaKind(kind)) {
+            if (!opts.file)
+                throw new Error(`${kind} kind requires --file.`);
+            if (opts.content != null) {
+                throw new Error("--content is only valid for markdown kinds.");
+            }
+            if (opts.autoAttachments) {
+                throw new Error("--auto-attachments is only valid for markdown kinds.");
+            }
+            const { mediaUrl, mediaKey } = await uploadArtifactMedia(opts.file);
+            body.mediaUrl = mediaUrl;
+            body.mediaKey = mediaKey;
+        }
+        const resp = (await apiPost(`/artifacts/${artifactId}/revisions`, body));
+        const rev = unwrapResp(resp);
+        if (isJsonMode(artifact)) {
+            jsonOut(rev);
+            return;
+        }
+        console.log(`Draft revision added!\n` +
+            `  Revision: ${rev.revisionId}\n` +
+            `  Seq:      ${rev.seq}\n` +
+            `  State:    ${rev.state}`);
+    });
+    // ── Publish ──
+    artifact
+        .command("publish <artifactId>")
+        .description("Publish a revision (becomes the artifact's single published revision).")
+        .requiredOption("--revision <revisionId>", "Revision to publish")
+        .action(async (artifactId, opts) => {
+        const resp = (await apiPost(`/artifacts/${artifactId}/publish`, {
+            revisionId: opts.revision,
+        }));
+        const a = unwrapResp(resp);
+        if (isJsonMode(artifact)) {
+            jsonOut(a);
+            return;
+        }
+        console.log(`Published!\n  Artifact: ${a.artifactId}\n  Revision: ${opts.revision}`);
+    });
+    // ── Revert ──
+    artifact
+        .command("revert <artifactId>")
+        .description("Revert the artifact's published pointer to an earlier revision.")
+        .requiredOption("--to <revisionId>", "Revision to revert to")
+        .action(async (artifactId, opts) => {
+        const resp = (await apiPost(`/artifacts/${artifactId}/revert`, {
+            toRevisionId: opts.to,
+        }));
+        const a = unwrapResp(resp);
+        if (isJsonMode(artifact)) {
+            jsonOut(a);
+            return;
+        }
+        console.log(`Reverted!\n  Artifact: ${a.artifactId}\n  Now published: ${opts.to}`);
+    });
+    // ── History ──
+    artifact
+        .command("history <artifactId>")
+        .description("List the artifact's full revision tree (owner only).")
+        .action(async (artifactId) => {
+        const resp = (await apiGet(`/artifacts/${artifactId}/revisions`));
+        const revisions = unwrapResp(resp) || [];
+        if (isJsonMode(artifact)) {
+            jsonOut(revisions);
+            return;
+        }
+        if (!revisions.length) {
+            console.log("No revisions.");
+            return;
+        }
+        console.log(`Revision history (${revisions.length}):`);
+        for (const r of revisions)
+            console.log(formatRevisionLine(r));
+    });
+    // ── Download ──
+    artifact
+        .command("download <artifactId>")
+        .description("Download an artifact's content. markdown → write the body; media → fetch the bytes. Defaults to the published/latest revision; pass --revision to pick one. Writes to --out or stdout (markdown).")
+        .option("--revision <revisionId>", "Specific revision (defaults to the artifact's current revision)")
+        .option("--out <path>", "Write to this file (markdown defaults to stdout)")
+        .action(async (artifactId, opts) => {
+        // Resolve the target revision. Without --revision, use the artifact's
+        // current (published/latest) revision from GET /artifacts/:id.
+        let kind;
+        let rev;
+        if (opts.revision) {
+            const aResp = (await apiGet(`/artifacts/${artifactId}`));
+            kind = unwrapResp(aResp).kind;
+            const rResp = (await apiGet(`/artifacts/${artifactId}/revisions/${opts.revision}`));
+            rev = unwrapResp(rResp);
+        }
+        else {
+            const aResp = (await apiGet(`/artifacts/${artifactId}`));
+            const a = unwrapResp(aResp);
+            if (!a.revision) {
+                throw new Error("Artifact has no current revision to download.");
+            }
+            kind = a.kind;
+            rev = a.revision;
+        }
+        if (isMarkdownKind(kind)) {
+            const content = rev.content ?? "";
+            if (opts.out) {
+                const { writeFile, mkdir } = await import("fs/promises");
+                const { dirname } = await import("path");
+                await mkdir(dirname(opts.out), { recursive: true });
+                await writeFile(opts.out, content, "utf8");
+                if (isJsonMode(artifact)) {
+                    jsonOut({ artifactId, revisionId: rev.revisionId, filename: opts.out, size: Buffer.byteLength(content) });
+                    return;
+                }
+                console.log(`Wrote ${opts.out} (${Buffer.byteLength(content)} bytes)`);
+                return;
+            }
+            if (isJsonMode(artifact)) {
+                jsonOut({ artifactId, revisionId: rev.revisionId, content });
+                return;
+            }
+            process.stdout.write(content.endsWith("\n") ? content : content + "\n");
+            return;
+        }
+        // Media kind — fetch the mediaUrl bytes.
+        if (!rev.mediaUrl) {
+            throw new Error("Revision has no media URL to download.");
+        }
+        const res = await fetch(rev.mediaUrl);
+        if (!res.ok) {
+            throw new Error(`Failed to fetch media from ${rev.mediaUrl}: HTTP ${res.status}`);
+        }
+        const buffer = Buffer.from(await res.arrayBuffer());
+        const contentType = res.headers.get("content-type") || "application/octet-stream";
+        const out = opts.out || `${artifactId}${extForContentType(contentType)}`;
+        const { writeFile, mkdir } = await import("fs/promises");
+        const { dirname } = await import("path");
+        await mkdir(dirname(out), { recursive: true });
+        await writeFile(out, buffer);
+        if (isJsonMode(artifact)) {
+            jsonOut({ artifactId, revisionId: rev.revisionId, filename: out, contentType, size: buffer.length });
+            return;
+        }
+        console.log(`Saved media to ${out} (${buffer.length} bytes)`);
+    });
+    // ── Delete ──
+    artifact
+        .command("delete <artifactId>")
+        .description("Delete an artifact (and its revision tree).")
+        .action(async (artifactId) => {
+        await apiDelete(`/artifacts/${artifactId}`);
+        if (isJsonMode(artifact)) {
+            jsonOut({ artifactId, ok: true });
+            return;
+        }
+        console.log(`Deleted ${artifactId}.`);
+    });
+    // ── Get ──
+    artifact
+        .command("get <artifactId>")
+        .description("Get one artifact with its current revision.")
+        .action(async (artifactId) => {
+        const resp = (await apiGet(`/artifacts/${artifactId}`));
+        const a = unwrapResp(resp);
+        if (isJsonMode(artifact)) {
+            jsonOut(a);
+            return;
+        }
+        printArtifact(a);
+    });
+    // ── List ──
+    artifact
+        .command("list")
+        .description("List your artifacts (newest first).")
+        .option("--kind <kind>", `Filter by kind: ${ALL_KINDS.join(" | ")}`)
+        .option("--limit <n>", "Max items to return")
+        .action(async (opts) => {
+        const params = {};
+        if (opts.kind) {
+            if (!ALL_KINDS.includes(opts.kind)) {
+                throw new Error(`--kind must be one of: ${ALL_KINDS.join(", ")}`);
+            }
+            params.kind = opts.kind;
+        }
+        if (opts.limit)
+            params.limit = parseInt(opts.limit, 10);
+        const resp = (await apiGet("/artifacts", params));
+        const items = unwrapResp(resp) || [];
+        if (isJsonMode(artifact)) {
+            jsonOut(items);
+            return;
+        }
+        if (!items.length) {
+            console.log("No artifacts.");
+            return;
+        }
+        console.log(`Artifacts (${items.length}):`);
+        for (const a of items) {
+            const pub = a.isPublished ? "published" : "draft";
+            console.log(`- [${a.kind}] ${a.artifactId.slice(0, 8)} ${a.title ?? "(untitled)"} (${pub}, ${a.updatedAt})`);
+        }
+    });
+}
+// Pick a file extension for a downloaded media artifact from its content type.
+function extForContentType(contentType) {
+    const ct = contentType.toLowerCase();
+    if (ct.includes("png"))
+        return ".png";
+    if (ct.includes("jpeg") || ct.includes("jpg"))
+        return ".jpg";
+    if (ct.includes("webp"))
+        return ".webp";
+    if (ct.includes("gif"))
+        return ".gif";
+    if (ct.includes("mp4"))
+        return ".mp4";
+    if (ct.includes("quicktime"))
+        return ".mov";
+    if (ct.includes("webm"))
+        return ".webm";
+    return "";
+}

package/dist/commands/global.js

@@ -1,8 +1,7 @@
 import { WEB_BASE_URL } from "../constants.js";
 import { apiGet, apiPost, apiPatch, apiDelete } from "../client.js";
-import { fetchDraftSummary, isJsonMode, jsonOut, readStdin, resolveVaultSlug, unwrapResp, } from "./utils.js";
-import { extractWikiLinks, uploadAttachments, uploadPostAttachments, assertPostAttachmentMix, } from "../attachments.js";
-import { getValidToken } from "../auth/manager.js";
+import { isJsonMode, jsonOut, readStdin, resolveVaultSlug, unwrapResp, } from "./utils.js";
+import { uploadPostAttachments, assertPostAttachmentMix, } from "../attachments.js";
 function readContent(value) {
     if (value === "-")
         return readStdin();
@@ -188,48 +187,29 @@ export function registerGlobalCommand(program) {
     // ── Create post ──
     global
         .command("create-post")
-        .description("Create a post in the global feed. --vault-slug attributes it to a vault you own. With no --vault-slug and no --auto-attachments, the post is created without an authorVaultSlug (vault-less personal post).")
+        .description("Create a post in the global feed. --vault-slug attributes it to a vault you own. With no --vault-slug, the post is created without an authorVaultSlug (vault-less personal post).")
         .option("--title <title>", "Title of the post")
         .option("--content <content>", "Post content (markdown supported, use \"-\" for stdin)")
         .option("--rich-text <richText>", "Rich-text JSON array (mutually exclusive with --content)")
         .option("--vault-slug <vaultSlug>", "Attribute the post to this vault (sets authorVaultSlug). Caller must own the vault.")
-        .option("--auto-attachments", "Upload wiki-linked [[files]] to webdrive before posting (also sets authorVaultSlug to that vault)")
-        .option("--draft-id <draftId>", "Use this draft as the source of title and content (mutually exclusive with --title/--content/--rich-text). On success, links the post back by recording postId on draft.metadata so the client can render an 'Open post' button. The draft's vaultSlug seeds --vault-slug when not given explicitly.")
         .option("--attach <file>", "Local media file to attach. Repeatable. X-style mix rule: up to 4 photos OR 1 GIF OR 1 video. Size ceilings: 5MB photos / 15MB GIFs / 512MB video.", (value, prev = []) => [...prev, value], [])
         .option("--repost-post-id <postId>", "Wrap an existing top-level post as the embedded card on this new post. Composes with --content / --rich-text / --attach (the wrapping author's text + media render above the embedded card). Reposts-of-reposts are collapsed to the transitive root server-side. The referenced post must exist, not be deleted, and not itself be a reply.")
         .action(async (opts) => {
-        if (opts.draftId) {
-            if (opts.title || opts.content || opts.richText) {
-                throw new Error("--draft-id sources title and content from the draft; --title, --content, and --rich-text are not allowed alongside it.");
-            }
+        if (!opts.content && !opts.richText) {
+            throw new Error("Provide either --content or --rich-text.");
         }
-        else {
-            if (!opts.content && !opts.richText) {
-                throw new Error("Provide either --content or --rich-text (or --draft-id).");
-            }
-            if (opts.content && opts.richText) {
-                throw new Error("--content and --rich-text are mutually exclusive.");
-            }
+        if (opts.content && opts.richText) {
+            throw new Error("--content and --rich-text are mutually exclusive.");
         }
-        const draft = opts.draftId ? await fetchDraftSummary(opts.draftId) : null;
-        const effectiveTitle = draft ? draft.title : opts.title;
-        const effectiveContent = draft ? draft.content : opts.content;
-        const effectiveVaultSlugOpt = opts.vaultSlug ?? draft?.vaultSlug ?? undefined;
         let authorVaultSlug;
-        if (effectiveVaultSlugOpt || opts.autoAttachments) {
-            authorVaultSlug = resolveVaultSlug({ vaultSlug: effectiveVaultSlugOpt });
+        if (opts.vaultSlug) {
+            authorVaultSlug = resolveVaultSlug({ vaultSlug: opts.vaultSlug });
         }
         const body = {};
-        if (effectiveTitle != null)
-            body.title = effectiveTitle;
-        if (effectiveContent != null) {
-            const content = draft ? effectiveContent : readContent(effectiveContent);
-            if (opts.autoAttachments && authorVaultSlug) {
-                const token = await getValidToken();
-                const links = extractWikiLinks(content);
-                await uploadAttachments(authorVaultSlug, links, token, { addToSyncfiles: true });
-            }
-            body.content = content;
+        if (opts.title != null)
+            body.title = opts.title;
+        if (opts.content != null) {
+            body.content = readContent(opts.content);
         }
         if (opts.richText != null) {
             let parsed;
@@ -256,19 +236,6 @@ export function registerGlobalCommand(program) {
         }
         const resp = (await apiPost(`/posts`, body));
         const post = unwrapResp(resp);
-        if (opts.draftId && post.id != null) {
-            try {
-                await apiPatch(`/app/drafts/${opts.draftId}/metadata`, {
-                    postId: typeof post.id === "number" ? post.id : Number(post.id),
-                    spaceSlug: null,
-                });
-            }
-            catch (e) {
-                // Don't fail the create if linking fails — the post is live; just
-                // surface a warning so the agent can mention it.
-                console.error(`Warning: failed to link post to draft ${opts.draftId}: ${e.message}`);
-            }
-        }
         const shareUrl = buildPersonalPostUrl(post);
         if (isJsonMode(global)) {
             jsonOut({ ...post, shareUrl });
@@ -278,8 +245,7 @@ export function registerGlobalCommand(program) {
             `  ID: ${post.id}\n` +
             (post.title ? `  Title: ${post.title}\n` : "") +
             `  Created: ${post.createdAt}\n` +
-            `  URL: ${shareUrl}` +
-            (opts.draftId ? `\n  Linked to draft: ${opts.draftId}` : ""));
+            `  URL: ${shareUrl}`);
     });
     // ── Edit post ──
     global
@@ -289,10 +255,9 @@ export function registerGlobalCommand(program) {
         .option("--content <content>", "New content (markdown supported, use \"-\" for stdin)")
         .option("--rich-text <richText>", "Rich-text JSON array (mutually exclusive with --content)")
         .option("--vault-slug <vaultSlug>", "Attribute the post to this vault (sets authorVaultSlug).")
-        .option("--auto-attachments", "Upload wiki-linked [[files]] to webdrive before editing (uses --vault-slug or .gobi vault)")
         .option("--attach <file>", "Replace the post's media attachments with the given files (existing attachments are removed). Repeatable. X-style mix rule: up to 4 photos OR 1 GIF OR 1 video. Size ceilings: 5MB photos / 15MB GIFs / 512MB video. Omit to leave attachments unchanged.", (value, prev = []) => [...prev, value], [])
         .action(async (postId, opts) => {
-        const wantsVaultChange = !!(opts.vaultSlug || opts.autoAttachments);
+        const wantsVaultChange = !!opts.vaultSlug;
         const wantsAttachChange = !!(opts.attach && opts.attach.length > 0);
         if (opts.title == null &&
             opts.content == null &&
@@ -305,20 +270,14 @@ export function registerGlobalCommand(program) {
             throw new Error("--content and --rich-text are mutually exclusive.");
         }
         let authorVaultSlug;
-        if (opts.vaultSlug || opts.autoAttachments) {
+        if (opts.vaultSlug) {
             authorVaultSlug = resolveVaultSlug(opts);
         }
         const body = {};
         if (opts.title != null)
             body.title = opts.title;
         if (opts.content != null) {
-            const content = readContent(opts.content);
-            if (opts.autoAttachments && authorVaultSlug) {
-                const token = await getValidToken();
-                const links = extractWikiLinks(content);
-                await uploadAttachments(authorVaultSlug, links, token, { addToSyncfiles: true });
-            }
-            body.content = content;
+            body.content = readContent(opts.content);
         }
         if (opts.richText != null) {
             let parsed;
@@ -362,8 +321,7 @@ export function registerGlobalCommand(program) {
         .description("Create a reply to a post in the global feed.")
         .option("--content <content>", "Reply content (markdown supported, use \"-\" for stdin)")
         .option("--rich-text <richText>", "Rich-text JSON array (mutually exclusive with --content)")
-        .option("--vault-slug <vaultSlug>", "Attribute the reply to this vault (sets authorVaultSlug). Also used as upload destination for --auto-attachments.")
-        .option("--auto-attachments", "Upload wiki-linked [[files]] to webdrive before posting (also attributes the reply to that vault)")
+        .option("--vault-slug <vaultSlug>", "Attribute the reply to this vault (sets authorVaultSlug).")
         .option("--attach <file>", "Local media file to attach to this reply. Repeatable. X-style mix rule: up to 4 photos OR 1 GIF OR 1 video. Size ceilings: 5MB photos / 15MB GIFs / 512MB video.", (value, prev = []) => [...prev, value], [])
         .action(async (postId, opts) => {
         if (!opts.content && !opts.richText) {
@@ -373,18 +331,12 @@ export function registerGlobalCommand(program) {
             throw new Error("--content and --rich-text are mutually exclusive.");
         }
         let authorVaultSlug;
-        if (opts.vaultSlug || opts.autoAttachments) {
+        if (opts.vaultSlug) {
             authorVaultSlug = resolveVaultSlug(opts);
         }
         const body = {};
         if (opts.content != null) {
-            const content = readContent(opts.content);
-            if (opts.autoAttachments && authorVaultSlug) {
-                const token = await getValidToken();
-                const links = extractWikiLinks(content);
-                await uploadAttachments(authorVaultSlug, links, token, { addToSyncfiles: true });
-            }
-            body.content = content;
+            body.content = readContent(opts.content);
         }
         if (opts.richText != null) {
             let parsed;
@@ -415,10 +367,9 @@ export function registerGlobalCommand(program) {
         .description("Edit a reply you authored in the global feed.")
         .option("--content <content>", "New reply content (markdown supported, use \"-\" for stdin)")
         .option("--rich-text <richText>", "Rich-text JSON array (mutually exclusive with --content)")
-        .option("--vault-slug <vaultSlug>", "Attribute the reply to this vault (sets authorVaultSlug). Also used as upload destination for --auto-attachments.")
-        .option("--auto-attachments", "Upload wiki-linked [[files]] to webdrive before editing (also attributes the reply to that vault)")
+        .option("--vault-slug <vaultSlug>", "Attribute the reply to this vault (sets authorVaultSlug).")
         .action(async (replyId, opts) => {
-        const wantsVaultChange = !!(opts.vaultSlug || opts.autoAttachments);
+        const wantsVaultChange = !!opts.vaultSlug;
         if (opts.content == null && opts.richText == null && !wantsVaultChange) {
             throw new Error("Provide at least --content, --rich-text, or --vault-slug to update.");
         }
@@ -426,18 +377,12 @@ export function registerGlobalCommand(program) {
             throw new Error("--content and --rich-text are mutually exclusive.");
         }
         let authorVaultSlug;
-        if (opts.vaultSlug || opts.autoAttachments) {
+        if (opts.vaultSlug) {
             authorVaultSlug = resolveVaultSlug(opts);
         }
         const body = {};
         if (opts.content != null) {
-            const content = readContent(opts.content);
-            if (opts.autoAttachments && authorVaultSlug) {
-                const token = await getValidToken();
-                const links = extractWikiLinks(content);
-                await uploadAttachments(authorVaultSlug, links, token, { addToSyncfiles: true });
-            }
-            body.content = content;
+            body.content = readContent(opts.content);
         }
         if (opts.richText != null) {
             let parsed;