@wji.ai/cli 0.4.0 → 0.5.0

package/dist/commands/canvas.js

@@ -1,8 +1,9 @@
 import { Command } from 'commander';
 import { WjiClient } from '../core/client.js';
 import { confirm, parseKeyValues, readValue } from '../core/prompt.js';
-import { color, detail, info, isJsonMode, printJson, render, success, table, truncate, warn } from '../core/output.js';
+import { color, detail, info, isJsonMode, printJson, relativeTime, render, success, table, truncate, warn } from '../core/output.js';
 import { pollHistory, reportHistory, resolveAssets } from './gen.js';
+import { loadMembers, memberLabel, resolveMember } from '../core/members.js';
 import { fetchModels } from './model.js';
 /**
  * Infinite Canvas over the plain fsnode API.
@@ -21,7 +22,7 @@ import { fetchModels } from './model.js';
  */
 const NODE_PREFIX = 'canvas/node/';
 const EDGE_MIMETYPE = 'canvas/edge';
-const CANVAS_MIMETYPE = 'workspace-v2/canvas';
+export const CANVAS_MIMETYPE = 'workspace-v2/canvas';
 const CANVASES_MIMETYPE = 'workspace-v2/canvases';
 const DATASET_MIMETYPE = 'workspace/dataset';
 const CREATABLE_KINDS = ['text', 'title', 'comment', 'image', 'video', 'audio', 'dataset'];
@@ -38,7 +39,7 @@ const DEFAULT_NAMES = {
     dataset: '数据集',
 };
 /** What the web writes into a brand-new canvas folder (CanvasAppFileSystem.createCanvas). */
-const INITIAL_CANVAS_CONTENT = {
+export const INITIAL_CANVAS_CONTENT = {
     data: { viewport: { x: 0, y: 0, zoom: 1 }, backgroundMode: 'dots' },
     metadata: {},
 };
@@ -52,7 +53,7 @@ const PENDING = 0;
  * folder as `content.colorTagNames {<colorId>: label}`. `alias` is the plain
  * color name the tag reads as, so `--tag red` finds `rose`.
  */
-const COLOR_TAGS = [
+export const COLOR_TAGS = [
     { id: 'rose', alias: 'red', hex: '#f43f5e' },
     { id: 'orange', alias: 'orange', hex: '#f97316' },
     { id: 'amber', alias: 'yellow', hex: '#eab308' },
@@ -62,17 +63,17 @@ const COLOR_TAGS = [
     { id: 'violet', alias: 'purple', hex: '#8b5cf6' },
     { id: 'fuchsia', alias: 'pink', hex: '#d946ef' },
 ];
-const idOf = (value) => value == null ? undefined : typeof value === 'string' ? value : value.id;
+export const idOf = (value) => value == null ? undefined : typeof value === 'string' ? value : value.id;
 function toList(result) {
     return Array.isArray(result) ? result : result?.data || [];
 }
 // ── loading ─────────────────────────────────────────────────────────────────
-async function linkedState(client) {
+export async function linkedState(client) {
     const res = await client.get('/canvas-link');
     return res?.linked ? res.state : null;
 }
 /** `--canvas` wins; otherwise the canvas linked from the browser. */
-async function resolveCanvasId(client, explicit) {
+export async function resolveCanvasId(client, explicit) {
     if (explicit)
         return explicit;
     const state = await linkedState(client);
@@ -80,7 +81,7 @@ async function resolveCanvasId(client, explicit) {
         return String(state.canvasId);
     throw new Error('No canvas. Pass --canvas <id>, or open the canvas in the browser and press the link button in its top bar.');
 }
-async function loadCanvas(client, canvasId) {
+export async function loadCanvas(client, canvasId) {
     // getFresh: read-merge-write must not see the 10s server cache
     const folder = await client.getFresh(`/fsnode/list/${canvasId}`);
     if (folder?.mimetype !== CANVAS_MIMETYPE) {
@@ -122,13 +123,81 @@ async function loadCanvas(client, canvasId) {
         id: folder.id,
         name: folder.name,
         workspaceId: idOf(folder.workspace) || idOf(folder.root) || '',
+        folder,
+        access: canvasAccessOf(folder.content),
         nodes,
         edges,
         byId: new Map(nodes.map((n) => [n.id, n])),
         assets,
-        tagNames: parseTagNames(folder.content?.colorTagNames),
+        tagNames: parseTagNames(canvasEnvelope(folder.content).data.colorTagNames),
     };
 }
+// ── canvas folder: content envelope and ownership ──────────────────────────
+/**
+ * A canvas folder stores `content {data, metadata}`: `data` is the board
+ * (viewport, colorTagNames, generateDefaults…), `metadata` its access
+ * `{ownerUserId, visibility}`. Legacy canvases hold `data` flat in `content`
+ * (the backend then reads access from the top level too).
+ */
+export function canvasEnvelope(content) {
+    const c = content && typeof content === 'object' ? content : {};
+    const hasEnvelope = c.data && typeof c.data === 'object' && !Array.isArray(c.data);
+    if (hasEnvelope) {
+        return { data: c.data, metadata: c.metadata && typeof c.metadata === 'object' ? c.metadata : {}, legacy: false };
+    }
+    const { metadata, ownerUserId, visibility, ...data } = c;
+    const meta = metadata && typeof metadata === 'object' ? metadata : { ...(ownerUserId ? { ownerUserId } : {}), ...(visibility ? { visibility } : {}) };
+    return { data, metadata: meta, legacy: true };
+}
+/** Same reading as the backend's readCanvasFolderAccess: only exactly 'owner' hides a canvas. */
+export function canvasAccessOf(content) {
+    const meta = canvasEnvelope(content).metadata;
+    return {
+        ownerUserId: typeof meta.ownerUserId === 'string' ? meta.ownerUserId : '',
+        visibility: meta.visibility === 'owner' ? 'owner' : 'members',
+    };
+}
+/**
+ * Write a canvas folder's `data` and/or `metadata`, always as the whole
+ * envelope (dropping `metadata` would reset the owner). Versioned with
+ * `baseUpdatedAt` and retried on a conflict so a browser saving the board at
+ * the same moment is not overwritten.
+ */
+export async function updateCanvasFolder(client, canvasId, change) {
+    for (let attempt = 0;; attempt++) {
+        const folder = await client.getFresh(`/fsnode/list/${canvasId}`);
+        if (folder?.mimetype !== CANVAS_MIMETYPE)
+            throw new Error(`${canvasId} is not a canvas`);
+        const env = canvasEnvelope(folder.content);
+        const next = { data: { ...env.data }, metadata: { ...env.metadata } };
+        change(next);
+        try {
+            return await client.patch(`/fsnode/list/${canvasId}`, {
+                content: next,
+                ...(folder.updatedAt ? { baseUpdatedAt: folder.updatedAt } : {}),
+            });
+        }
+        catch (err) {
+            if (err?.status === 409 && attempt < 3)
+                continue;
+            if (err?.status === 403) {
+                throw new Error(`${err.message} — only the workspace owner can change who owns a canvas`);
+            }
+            throw err;
+        }
+    }
+}
+/** Every canvas in the workspace you can see (owner-only canvases of others are hidden unless you own the workspace). */
+export async function listCanvases(client, wsId) {
+    const rows = [];
+    for (const { appId, folderId } of await canvasesFolders(client, wsId)) {
+        const canvases = toList(await client.getFresh(`/fsnode/list/${folderId}/children`, { limit: -1 }));
+        for (const it of canvases.filter((n) => n.mimetype === CANVAS_MIMETYPE)) {
+            rows.push({ id: it.id, name: it.name, appId, ...canvasAccessOf(it.content), updatedAt: it.updatedAt, folder: it });
+        }
+    }
+    return rows;
+}
 // ── color tags ──────────────────────────────────────────────────────────────
 function parseTagNames(raw) {
     const out = {};
@@ -142,7 +211,7 @@ function parseTagNames(raw) {
     return out;
 }
 /** The node's tag with the canvas label (never the node's own legacy `name`, as on the web). */
-function tagOf(canvas, node) {
+export function tagOf(canvas, node) {
     const colorId = node.content.colorTag?.colorId;
     const tag = COLOR_TAGS.find((t) => t.id === colorId);
     if (!tag)
@@ -153,7 +222,7 @@ function tagOf(canvas, node) {
  * Colors a `--tag` value means: a color id (`rose`), its plain name (`red`),
  * or a label (`C01`, case-insensitive), so several colors can match one label.
  */
-function resolveTagFilter(canvas, values) {
+export function resolveTagFilter(canvas, values) {
     const colors = new Set();
     for (const value of values) {
         const v = value.trim().toLowerCase();
@@ -168,7 +237,7 @@ function resolveTagFilter(canvas, values) {
     return colors;
 }
 /** `C0[1-3]` is case-insensitive; `/C0[1-3]$/` keeps exactly the flags given. */
-function parseRegex(value, flag) {
+export function parseRegex(value, flag) {
     const slashed = /^\/(.*)\/([a-z]*)$/s.exec(value);
     try {
         return slashed ? new RegExp(slashed[1], slashed[2].replace(/[gy]/g, '')) : new RegExp(value, 'i');
@@ -177,13 +246,13 @@ function parseRegex(value, flag) {
         throw new Error(`${flag}: invalid regex ${value} — ${err.message}`);
     }
 }
-function tagText(tag) {
+export function tagText(tag) {
     if (!tag)
         return '';
     return tag.label ? `${tag.alias} "${tag.label}"` : tag.alias;
 }
 /** The `canvases` folder of every InfiniteCanvas app in a workspace. */
-async function canvasesFolders(client, wsId) {
+export async function canvasesFolders(client, wsId) {
     const ws = await client.get(`/workspace/list/${wsId}`);
     const apps = (ws.apps || []).filter((a) => a.app === 'InfiniteCanvas' || a.type === 'INFINITE_CANVAS');
     const out = [];
@@ -195,7 +264,7 @@ async function canvasesFolders(client, wsId) {
     }
     return out;
 }
-function requireNode(canvas, id) {
+export function requireNode(canvas, id) {
     const node = canvas.byId.get(id);
     if (!node)
         throw new Error(`Node ${id} is not on canvas "${canvas.name}" (${canvas.id})`);
@@ -220,7 +289,7 @@ function referencesOf(canvas, node) {
         };
     });
 }
-function describe(canvas, node) {
+export function describe(canvas, node) {
     const asset = node.file ? canvas.assets.get(node.file) : undefined;
     const generate = node.content.generate;
     const pending = asset && asset.status === PENDING && !asset.error;
@@ -341,7 +410,7 @@ function applyModelDefaults(model, kind, generate, opts) {
 }
 // ── writes ──────────────────────────────────────────────────────────────────
 /** Short side 250, like the canvas; text-ish nodes use a typical card size. */
-function estimateSize(canvas, node) {
+export function estimateSize(canvas, node) {
     const w = Number(node.content.width);
     const h = Number(node.content.height);
     if (w > 0 && h > 0)
@@ -411,6 +480,7 @@ async function createEdge(client, canvas, fromId, toId, opts = {}) {
         toNodeId: to.id,
         sourceHandle: 'right',
         targetHandle: 'left',
+        ...(opts.content || {}),
     };
     // First/last-frame video models take connected images as frame slots, in order.
     if (opts.frameModel && to.kind === 'video' && from.kind === 'image') {
@@ -433,8 +503,37 @@ async function createEdge(client, canvas, fromId, toId, opts = {}) {
     canvas.edges.push(edge);
     return edge;
 }
-async function patchNode(client, node, body) {
-    return client.patch(`/fsnode/list/${node.id}`, body);
+/**
+ * Write only the top-level content keys that changed (`contentPatch`), so an
+ * edit here does not overwrite what someone else changed in another key at
+ * the same moment in the browser. A backend without `contentPatch` strips it
+ * silently; the response then lacks the change and we write the whole content.
+ */
+async function patchNode(client, node, change) {
+    const { content, ...rest } = change;
+    const contentPatch = {};
+    const contentUnset = [];
+    if (content) {
+        for (const key of new Set([...Object.keys(node.content), ...Object.keys(content)])) {
+            if (!(key in content))
+                contentUnset.push(key);
+            else if (JSON.stringify(content[key]) !== JSON.stringify(node.content[key]))
+                contentPatch[key] = content[key];
+        }
+    }
+    const body = { ...rest };
+    if (Object.keys(contentPatch).length)
+        body.contentPatch = contentPatch;
+    if (contentUnset.length)
+        body.contentUnset = contentUnset;
+    if (!Object.keys(body).length)
+        return node.raw;
+    const res = await client.patch(`/fsnode/list/${node.id}`, body);
+    const landed = Object.entries(contentPatch).every(([k, v]) => JSON.stringify(res?.content?.[k]) === JSON.stringify(v)) &&
+        contentUnset.every((k) => !(k in (res?.content || {})));
+    if (content && !landed)
+        return client.patch(`/fsnode/list/${node.id}`, { ...rest, content });
+    return res;
 }
 // ── output ──────────────────────────────────────────────────────────────────
 function summary(n) {
@@ -451,7 +550,7 @@ function summary(n) {
     }
     return n.url || n.assetId || '';
 }
-function nodeTable(rows) {
+export function nodeTable(rows) {
     table(rows, [
         { header: 'id', value: (n) => n.id },
         { header: 'kind', value: (n) => (n.mode === 'generate' ? `${n.kind}*` : n.kind) },
@@ -584,6 +683,43 @@ function withGenerateOptions(cmd) {
 }
 // ── generation ──────────────────────────────────────────────────────────────
 const UNSUPPORTED_REF_KINDS = new Set(['table', 'youtube', 'dataset', 'bundle', 'sprite', 'layer', 'panorama']);
+// Seedance 2.5 draft mode (frontend shared/func/seedanceDraft.ts): 2.5 + 480p is a draft, and a draft
+// becomes the finished 1080p clip only through its BytePlus task id (draftTaskId), within 7 days.
+const SEEDANCE_25_MODELS = new Set(['seedance-2.5', 'seedance-2.5-uncensored', 'seedance-2.5-ref', 'seedance-2.5-ref-uncensored']);
+const SEEDANCE_DRAFT_TTL_MS = 7 * 24 * 60 * 60 * 1000;
+function isSeedance25(model) {
+    return !!model && SEEDANCE_25_MODELS.has(model);
+}
+/** The flag the web form sets before submitting (syncSeedanceDraftFlag) — every 2.5 + 480p generation is a draft. */
+function syncSeedanceDraftFlag(model, values) {
+    if (isSeedance25(model) && String(values.resolution || '') === '480p')
+        values.draft = true;
+    else
+        delete values.draft;
+    return values;
+}
+function draftTaskIdOf(values) {
+    const raw = values?.draftTaskId;
+    return typeof raw === 'string' ? raw.trim() : '';
+}
+/**
+ * What a finished clip can be upscaled from — like the web's canSeedanceDraftUpscale: flagged as a
+ * draft (config.values.draft), carrying its BytePlus task id (the draft id), and not past 7 days.
+ */
+function seedanceDraftSource(asset) {
+    const taskId = String(asset?.extra?.byteplus?.taskId || '').trim();
+    const model = String(asset?.config?.model || '');
+    const created = asset?.createdAt ? Date.parse(asset.createdAt) : Number.NaN;
+    const expiresAt = Number.isFinite(created) ? new Date(created + SEEDANCE_DRAFT_TTL_MS) : undefined;
+    return {
+        taskId,
+        model,
+        flagged: asset?.config?.values?.draft === true,
+        resolution: String(asset?.config?.values?.resolution || ''),
+        expiresAt,
+        expired: !expiresAt || Date.now() > expiresAt.getTime(),
+    };
+}
 /**
  * Build the same request the canvas generate button sends
  * (shared/generate/buildSubmitPayload.ts): references in edge order, text
@@ -592,6 +728,32 @@ const UNSUPPORTED_REF_KINDS = new Set(['table', 'youtube', 'dataset', 'bundle',
 function buildSubmit(canvas, node, model) {
     const kind = node.kind;
     const g = node.content.generate || {};
+    // Draft → 1080p upscale (buildCanvasVideoSubmitPayload): only the draft task id counts — no
+    // prompt, no references; the edge from the draft clip is there for people reading the canvas.
+    const draftTaskId = kind === 'video' ? draftTaskIdOf(g.values) : '';
+    if (draftTaskId) {
+        const duration = typeof g.duration === 'number' && Number.isFinite(g.duration) ? g.duration : undefined;
+        return {
+            originalPrompt: g.prompt || 'N/A',
+            prompt: g.prompt || 'N/A',
+            model: g.model,
+            aspectRatio: g.ratio,
+            n: 1,
+            workspace: canvas.workspaceId,
+            fsnode: node.id,
+            scope: 'canvas',
+            scopeId: canvas.id,
+            duration,
+            values: {
+                ...(g.values || {}),
+                mode: 'video',
+                resolution: '1080p',
+                draft: false,
+                draftTaskId,
+                ...(duration !== undefined ? { duration } : {}),
+            },
+        };
+    }
     const userPrompt = String(g.prompt || '').trim();
     const form = model.form || {};
     const frames = usesFrameSlots(model);
@@ -681,6 +843,8 @@ function buildSubmit(canvas, node, model) {
             ...(kind !== 'audio' && g.resolution ? { resolution: g.resolution } : {}),
         },
     };
+    if (kind === 'video')
+        syncSeedanceDraftFlag(g.model, body.values);
     if (imageRefs.length)
         body.referenceImages = imageRefs;
     if (kind === 'video') {
@@ -696,6 +860,141 @@ function buildSubmit(canvas, node, model) {
         body.referenceAudios = audios;
     return body;
 }
+// ── ownership, tags and copy helpers ───────────────────────────────────────
+export function parseVisibility(value) {
+    const v = value.toLowerCase();
+    if (v === 'owner' || v === 'private')
+        return 'owner';
+    if (v === 'members' || v === 'member' || v === 'workspace')
+        return 'members';
+    throw new Error(`--visibility must be owner or members (got ${value})`);
+}
+/** A new canvas folder the way the web creates one, with its access in the metadata envelope. */
+export async function createCanvasFolder(client, canvasesFolderId, name, access) {
+    const metadata = {};
+    if (access?.ownerUserId)
+        metadata.ownerUserId = access.ownerUserId;
+    if (access?.visibility)
+        metadata.visibility = access.visibility;
+    return client.post('/fsnode/create', {
+        name,
+        type: 'folder',
+        mimetype: CANVAS_MIMETYPE,
+        parent: canvasesFolderId,
+        content: { ...INITIAL_CANVAS_CONTENT, metadata },
+    });
+}
+/** One color id from a color name, id or this canvas's label. */
+export function colorOfTag(canvas, tag) {
+    const colors = [...resolveTagFilter(canvas, [tag])];
+    if (colors.length > 1)
+        throw new Error(`Label "${tag}" is on several colors (${colors.join(', ')}) — name the color`);
+    return colors[0];
+}
+/** The source canvas and the nodes to copy: ids given, and/or the linked selection. */
+export async function copySource(c, ids, opts) {
+    const linked = opts.selected || !ids.length ? await linkedState(c) : null;
+    const useSelection = opts.selected || !ids.length;
+    if (useSelection && !linked?.selectedNodeIds?.length) {
+        throw new Error('Nothing to copy: pass node ids, or select nodes in the browser canvas and press link');
+    }
+    const sourceId = opts.canvas || (useSelection ? linked.canvasId : await resolveCanvasId(c));
+    if (useSelection && opts.canvas && opts.canvas !== linked.canvasId) {
+        throw new Error(`The selection is on canvas ${linked.canvasId}, not ${opts.canvas}`);
+    }
+    const source = await loadCanvas(c, sourceId);
+    const nodeIds = [...new Set([...ids, ...(useSelection ? linked.selectedNodeIds : [])])];
+    return { source, nodes: nodeIds.map((id) => requireNode(source, id)) };
+}
+export function copyPlacement(opts) {
+    return { at: opts.at ? parsePoint(opts.at, '--at') : undefined, samePosition: !!opts.samePosition };
+}
+/** The canvas's own copy rule (cloneContentForDuplicate): no position, no generation run, finished media shared. */
+function copyableFile(canvas, node) {
+    const asset = node.file ? canvas.assets.get(node.file) : undefined;
+    return asset?.url && asset.status !== PENDING && !asset.error ? node.file : undefined;
+}
+/**
+ * Copy nodes from one canvas into another, like the canvas's copy-paste:
+ * new nodes, connections among them re-created in reference order, color
+ * tags kept (and their label carried over when the target has none).
+ */
+export async function copyNodes(c, source, nodes, target, placement = {}) {
+    const pos = (n) => ({ x: Number(n.content.position?.x) || 0, y: Number(n.content.position?.y) || 0 });
+    const minX = Math.min(...nodes.map((n) => pos(n).x));
+    const minY = Math.min(...nodes.map((n) => pos(n).y));
+    let origin = placement.at;
+    if (!origin && !placement.samePosition && target.nodes.length) {
+        const right = Math.max(...target.nodes.map((n) => pos(n).x + estimateSize(target, n).width));
+        const top = Math.min(...target.nodes.map((n) => pos(n).y));
+        origin = { x: Math.round(right + PLACE_GAP * 2), y: Math.round(top) };
+    }
+    if (!origin)
+        origin = { x: minX, y: minY };
+    // Labels travel with the tag when the target has no label for that color yet.
+    const labels = {};
+    for (const n of nodes) {
+        const colorId = n.content.colorTag?.colorId;
+        const label = colorId && source.tagNames[colorId];
+        if (!label)
+            continue;
+        if (!target.tagNames[colorId])
+            labels[colorId] = label;
+        else if (target.tagNames[colorId] !== label) {
+            warn(`${target.name}: ${colorId} is labelled "${target.tagNames[colorId]}" there, not "${label}" — kept theirs`);
+        }
+    }
+    if (Object.keys(labels).length) {
+        await updateCanvasFolder(c, target.id, (env) => {
+            env.data.colorTagNames = { ...labels, ...(env.data.colorTagNames || {}) };
+        });
+        Object.assign(target.tagNames, labels);
+    }
+    const idMap = new Map();
+    const created = [];
+    for (const n of nodes) {
+        const content = JSON.parse(JSON.stringify(n.content || {}));
+        if (content.generate) {
+            delete content.generate.historyId;
+            delete content.generate.pendingAssetId;
+        }
+        const p = pos(n);
+        content.position = { x: Math.round(origin.x + p.x - minX), y: Math.round(origin.y + p.y - minY) };
+        const file = copyableFile(source, n);
+        const raw = await c.post('/fsnode/create', {
+            name: n.name || DEFAULT_NAMES[n.kind] || n.kind,
+            type: 'file',
+            mimetype: `${NODE_PREFIX}${n.kind}`,
+            parent: target.id,
+            sort: 0,
+            content,
+            ...(file ? { file } : {}),
+        });
+        idMap.set(n.id, raw.id);
+        const node = { id: raw.id, kind: n.kind, name: raw.name, sort: 0, file, content, raw };
+        created.push(node);
+        target.nodes.push(node);
+        target.byId.set(node.id, node);
+        if (file && source.assets.has(file))
+            target.assets.set(file, source.assets.get(file));
+    }
+    // Oldest edge first, so the new ids keep the same @image1/@image2 numbering.
+    const inside = source.edges
+        .filter((e) => idMap.has(e.fromNodeId) && idMap.has(e.toNodeId))
+        .sort((a, b) => a.sort - b.sort || a.id.localeCompare(b.id));
+    const skippedEdges = source.edges.filter((e) => idMap.has(e.toNodeId) && !idMap.has(e.fromNodeId)).length;
+    for (const e of inside) {
+        const { fromNodeId, toNodeId, ...rest } = e.content;
+        await createEdge(c, target, idMap.get(e.fromNodeId), idMap.get(e.toNodeId), { content: rest });
+    }
+    return {
+        canvasId: target.id,
+        canvasName: target.name,
+        nodes: created.map((n) => ({ id: n.id, from: [...idMap].find(([, v]) => v === n.id)?.[0], kind: n.kind, name: n.name })),
+        edges: inside.length,
+        skippedEdges,
+    };
+}
 // ── commands ────────────────────────────────────────────────────────────────
 export function canvasCommand(globals) {
     const canvas = new Command('canvas').description('Read and edit Infinite Canvas nodes (defaults to the canvas linked from the browser)');
@@ -748,24 +1047,32 @@ export function canvasCommand(globals) {
     });
     canvas
         .command('list')
-        .description('Canvases in a workspace')
+        .description('Canvases in a workspace, with owner and visibility')
         .option('-w, --workspace <id>', 'workspace (defaults to the linked one, then the profile default)')
+        .option('-o, --owner <member>', 'only canvases this member owns (name, email or user id; "none" = unowned)')
         .action(async (opts) => {
         const c = client();
         const linked = opts.workspace ? null : await linkedState(c);
         const wsId = opts.workspace || linked?.workspaceId || c.requireWorkspace();
-        const rows = [];
-        for (const { appId, folderId } of await canvasesFolders(c, wsId)) {
-            const canvases = toList(await c.getFresh(`/fsnode/list/${folderId}/children`, { limit: -1 }));
-            for (const it of canvases.filter((n) => n.mimetype === CANVAS_MIMETYPE)) {
-                rows.push({ id: it.id, name: it.name, app: appId, linked: it.id === linked?.canvasId, updatedAt: it.updatedAt });
-            }
+        const [canvases, { members }] = await Promise.all([listCanvases(c, wsId), loadMembers(c, wsId)]);
+        const byUser = new Map(members.map((m) => [m.userId, m]));
+        let filtered = canvases;
+        if (opts.owner !== undefined) {
+            const ownerId = opts.owner === 'none' ? '' : resolveMember(members, opts.owner).userId;
+            filtered = canvases.filter((r) => r.ownerUserId === ownerId);
         }
+        const rows = filtered.map(({ folder, ...r }) => ({
+            ...r,
+            ownerName: r.ownerUserId ? (byUser.get(r.ownerUserId) ? memberLabel(byUser.get(r.ownerUserId)) : '(not a member)') : '',
+            linked: r.id === linked?.canvasId,
+        }));
         render(rows, () => table(rows, [
             { header: '', value: (r) => (r.linked ? color.green('●') : '') },
             { header: 'id', value: (r) => r.id },
             { header: 'name', value: (r) => r.name },
-            { header: 'app', value: (r) => r.app },
+            { header: 'owner', value: (r) => r.ownerName },
+            { header: 'visibility', value: (r) => (r.visibility === 'owner' ? 'owner only' : 'members') },
+            { header: 'updated', value: (r) => relativeTime(r.updatedAt) },
         ]));
     });
     canvas
@@ -773,6 +1080,8 @@ export function canvasCommand(globals) {
         .description('Create an empty canvas in a workspace (its InfiniteCanvas app)')
         .option('-w, --workspace <id>', 'workspace (defaults to the linked one, then the profile default)')
         .option('--app <appId>', 'InfiniteCanvas app when the workspace has several')
+        .option('-o, --owner <member>', 'owner (name, email or user id); only the workspace owner can set it')
+        .option('--visibility <v>', 'owner (only the owner and the workspace owner see it) | members', 'members')
         .action(async (name, opts) => {
         const c = client();
         const linked = opts.workspace ? null : await linkedState(c);
@@ -785,19 +1094,141 @@ export function canvasCommand(globals) {
             throw new Error(`No InfiniteCanvas app ${opts.app} in workspace ${wsId}`);
         if (!opts.app && folders.length > 1)
             warn(`Several InfiniteCanvas apps — using ${target.appId}; pass --app to choose`);
-        const raw = await c.post('/fsnode/create', {
-            name,
-            type: 'folder',
-            mimetype: CANVAS_MIMETYPE,
-            parent: target.folderId,
-            content: INITIAL_CANVAS_CONTENT,
-        });
-        const out = { id: raw.id, name: raw.name, app: target.appId, workspaceId: wsId };
+        const visibility = parseVisibility(opts.visibility);
+        const ownerUserId = opts.owner ? resolveMember((await loadMembers(c, wsId)).members, opts.owner).userId : '';
+        const raw = await createCanvasFolder(c, target.folderId, name, { ownerUserId, visibility });
+        const out = { id: raw.id, name: raw.name, app: target.appId, workspaceId: wsId, ownerUserId, visibility };
         render(out, () => {
             success(`Created canvas "${out.name}" ${color.dim(out.id)}`);
             info(color.dim(`Target it with --canvas ${out.id}, or open it in the browser and press link.`));
         });
     });
+    canvas
+        .command('owner <canvasId> [member]')
+        .description('Show or set who owns a canvas and who can see it (setting needs the workspace owner)')
+        .option('--visibility <v>', 'owner (only the owner and the workspace owner see it) | members (everyone in the workspace)')
+        .option('--none', 'clear the owner')
+        .action(async (canvasId, token, opts) => {
+        const c = client();
+        const folder = await c.getFresh(`/fsnode/list/${canvasId}`);
+        if (folder?.mimetype !== CANVAS_MIMETYPE)
+            throw new Error(`${canvasId} is not a canvas`);
+        const wsId = idOf(folder.workspace) || idOf(folder.root) || '';
+        const { members } = await loadMembers(c, wsId);
+        if (token && opts.none)
+            throw new Error('Pass a member or --none, not both');
+        const show = (access) => {
+            const owner = members.find((m) => m.userId === access.ownerUserId);
+            const out = { id: canvasId, name: folder.name, ...access, ownerName: owner ? memberLabel(owner) : undefined };
+            render(out, () => detail([
+                ['canvas', `${folder.name} ${color.dim(canvasId)}`],
+                ['owner', access.ownerUserId ? `${owner ? memberLabel(owner) : '(not a member)'} ${color.dim(access.ownerUserId)}` : '(none)'],
+                ['visibility', access.visibility === 'owner' ? 'owner only' : 'all members'],
+            ]));
+        };
+        if (!token && !opts.none && !opts.visibility)
+            return show(canvasAccessOf(folder.content));
+        const ownerUserId = opts.none ? '' : token ? resolveMember(members, token).userId : undefined;
+        const visibility = opts.visibility ? parseVisibility(opts.visibility) : undefined;
+        const res = await updateCanvasFolder(c, canvasId, (env) => {
+            if (ownerUserId !== undefined)
+                env.metadata.ownerUserId = ownerUserId;
+            if (visibility)
+                env.metadata.visibility = visibility;
+            else if (!env.metadata.visibility)
+                env.metadata.visibility = 'members';
+        });
+        if (!isJsonMode())
+            success('Updated');
+        show(canvasAccessOf(res?.content));
+    });
+    canvas
+        .command('tag <tag> [nodeIds...]')
+        .description('Color-tag nodes: a color (red, rose…) or an existing label; "none" removes the tag. ' +
+        '--label names that color on this canvas (one label per color, shared by its nodes).')
+        .option('-c, --canvas <id>', 'canvas id (defaults to the linked canvas)')
+        .option('-l, --label <text>', 'set the label of this color on the canvas ("" clears it)')
+        .option('--selected', 'tag the nodes selected in the linked browser canvas')
+        .action(async (tag, ids, opts) => {
+        const c = client();
+        const linked = opts.selected ? await linkedState(c) : null;
+        if (opts.selected && !linked)
+            throw new Error('--selected needs a linked canvas (press link in the browser)');
+        const cv = await loadCanvas(c, opts.canvas || linked?.canvasId || (await resolveCanvasId(c)));
+        const nodeIds = [...ids, ...(opts.selected ? linked.selectedNodeIds || [] : [])];
+        const nodes = nodeIds.map((id) => requireNode(cv, id));
+        const clear = tag.toLowerCase() === 'none';
+        if (clear && opts.label !== undefined)
+            throw new Error('--label needs a color, not "none"');
+        const colorId = clear ? undefined : colorOfTag(cv, tag);
+        if (!nodes.length && opts.label === undefined)
+            throw new Error('Pass node ids (or --selected), and/or --label');
+        if (opts.label !== undefined) {
+            const label = opts.label.trim();
+            await updateCanvasFolder(c, cv.id, (env) => {
+                const names = { ...(env.data.colorTagNames || {}) };
+                if (label)
+                    names[colorId] = label;
+                else
+                    delete names[colorId];
+                env.data.colorTagNames = Object.keys(names).length ? names : null;
+            });
+            if (label)
+                cv.tagNames[colorId] = label;
+            else
+                delete cv.tagNames[colorId];
+        }
+        for (const node of nodes) {
+            const content = { ...node.content };
+            if (clear)
+                delete content.colorTag;
+            else
+                content.colorTag = { colorId };
+            await patchNode(c, node, { content });
+            node.content = content;
+        }
+        const out = { canvas: cv.id, tag: clear ? null : { color: colorId, label: cv.tagNames[colorId] }, nodes: nodes.map((n) => n.id) };
+        render(out, () => {
+            const what = clear ? 'untagged' : `tagged ${tagText(tagOf(cv, { ...nodes[0], content: { colorTag: { colorId } } }))}`;
+            if (nodes.length)
+                success(`${nodes.length} node(s) ${what}`);
+            if (opts.label !== undefined)
+                success(`Label of ${colorId}: ${cv.tagNames[colorId] || '(none)'}`);
+        });
+    });
+    canvas
+        .command('copy [nodeIds...]')
+        .description('Copy nodes (with the connections between them) into other canvases. Finished media is shared, not re-generated; ' +
+        'generate nodes keep their prompt and settings.')
+        .option('-c, --canvas <id>', 'source canvas (defaults to the linked canvas)')
+        .option('--selected', 'copy the nodes selected in the linked browser canvas')
+        .requiredOption('--to <canvasIds...>', 'target canvases')
+        .option('--at <x,y>', 'top-left of the copied group; default is right of what is already there')
+        .option('--same-position', 'keep the original coordinates')
+        .option('-y, --yes', 'skip confirmation')
+        .action(async (ids, opts) => {
+        const c = client();
+        const { source, nodes } = await copySource(c, ids, opts);
+        const targets = opts.to.filter((id) => id !== source.id);
+        if (!targets.length)
+            throw new Error('--to must name at least one canvas other than the source');
+        const names = await Promise.all(targets.map(async (id) => (await c.getFresh(`/fsnode/list/${id}`))?.name ?? id));
+        const question = `Copy ${nodes.length} node(s) from "${source.name}" into ${targets.length} canvas(es): ${names.join(', ')}?`;
+        if (!(await confirm(question, opts.yes)))
+            return info('Aborted');
+        const results = [];
+        for (const id of targets) {
+            const target = await loadCanvas(c, id);
+            results.push(await copyNodes(c, source, nodes, target, copyPlacement(opts)));
+        }
+        render(results, () => {
+            for (const r of results)
+                success(`${r.canvasName}: ${r.nodes.length} node(s), ${r.edges} connection(s)`);
+            const skipped = results[0]?.skippedEdges ?? 0;
+            if (skipped)
+                info(color.dim(`${skipped} connection(s) from nodes outside the copy were left out`));
+        });
+    });
     canvas
         .command('nodes')
         .description('Nodes with references and a content summary (* = generate node)')
@@ -1102,58 +1533,127 @@ export function canvasCommand(globals) {
         .action(async (id, opts) => {
         const c = client();
         const cv = await loadCanvas(c, await resolveCanvasId(c, opts.canvas));
-        const node = requireNode(cv, id);
-        if (!MEDIA_KINDS.has(node.kind) || node.content.mode !== 'generate') {
-            throw new Error(`${id} is not a generate node. Create one with \`wji canvas add ${MEDIA_KINDS.has(node.kind) ? node.kind : 'image'} -m … -p …\`.`);
-        }
-        if (describe(cv, node).status === 'generating')
-            throw new Error(`${id} is already generating`);
-        const g = node.content.generate || {};
-        if (!g.model)
-            throw new Error(`${id} has no model — set one with \`wji canvas set ${id} -m …\``);
-        const model = await findModel(c, node.kind, g.model, cv.workspaceId);
-        const body = buildSubmit(cv, node, model);
-        const cost = await c.post('/ai/assets/preComputeCost', {
-            type: node.kind,
-            model: body.model,
-            n: body.n,
-            prompt: body.prompt,
-            // Auto-duration submits -1; price the node's configured length instead.
-            duration: body.duration && body.duration > 0 ? body.duration : g.duration,
-            aspectRatio: body.aspectRatio,
-            referenceImageCount: body.referenceImages?.length,
-            values: body.values,
-        });
-        const credits = typeof cost === 'object' ? cost?.cost ?? cost?.credits ?? cost?.total : cost;
-        const refs = referencesOf(cv, node).map((r) => r.label).join(', ') || 'none';
-        const auto = body.duration === -1 ? ` (auto duration — estimated for ${g.duration ?? '?'}s, final cost follows the real length)` : '';
-        const question = `Generate ${node.kind} "${node.name}" with ${body.model} (refs: ${refs}) for ${credits ?? '?'} credits${auto}?`;
-        if (!(await confirm(question, opts.yes)))
-            return info('Aborted');
-        const history = await c.post(`/ai/assets/history/${node.kind}/generations`, body);
-        const assetId = idOf((history?.images || [])[0]);
-        const nextGenerate = { ...g, historyId: String(history.id), pendingAssetId: assetId };
-        await patchNode(c, node, {
-            ...(assetId ? { file: assetId } : {}),
-            content: { ...node.content, generate: nextGenerate },
-        });
-        if (!opts.wait) {
-            if (isJsonMode())
-                return printJson(history);
-            success(`Submitted ${node.kind} generation for node ${id}`);
-            reportHistory(history, await resolveAssets(c, history));
-            info(color.dim(`The canvas shows progress. Poll with: wji canvas get ${id}  or  wji history get ${history.id} --wait`));
-            return;
-        }
-        info(color.dim(`Submitted ${history.id}, waiting…`));
-        const done = await pollHistory(c, history.id, {
-            timeoutMs: Number(opts.timeout) * 1000,
-            intervalMs: Number(opts.interval) * 1000,
-        });
-        if (isJsonMode())
-            return printJson({ ...done.history, images: done.assets });
-        success(`Node ${id} generated`);
-        reportHistory(done.history, done.assets);
+        await submitGenerate(c, cv, requireNode(cv, id), opts);
+    });
+    canvas
+        .command('upscale <nodeId>')
+        .description('Upscale a Seedance 2.5 draft clip (480p) to the finished 1080p video — adds an upscale node beside it and generates it (costs credits)')
+        .option('-c, --canvas <id>', 'canvas id (defaults to the linked canvas)')
+        .option('-n, --name <name>', 'name of the upscale node (default: "<source name>-1080p")')
+        .option('--at <x,y>', 'position of the upscale node; default is right of the draft clip')
+        .option('--no-gen', 'only create the upscale node; generate it later with `wji canvas gen`')
+        .option('-y, --yes', 'skip the cost confirmation')
+        .option('-w, --wait', 'wait for the result')
+        .option('--timeout <sec>', 'with --wait, give up after this many seconds', '1200')
+        .option('--interval <sec>', 'with --wait, poll every N seconds', '5')
+        .action(async (id, opts) => {
+        const c = client();
+        const cv = await loadCanvas(c, await resolveCanvasId(c, opts.canvas));
+        const source = requireNode(cv, id);
+        const asset = source.file ? cv.assets.get(source.file) : undefined;
+        if (source.kind !== 'video' || !asset?.url)
+            throw new Error(`${id} is not a video node with a finished clip`);
+        const draft = seedanceDraftSource(asset);
+        if (!isSeedance25(draft.model))
+            throw new Error(`${id} was generated with ${draft.model || 'an unknown model'} — only Seedance 2.5 drafts can be upscaled`);
+        if (!draft.taskId)
+            throw new Error(`${id} has no draft task id (asset ${asset.id} carries no BytePlus task) — it cannot be upscaled`);
+        if (draft.expired)
+            throw new Error(`The draft task of ${id} expired ${draft.expiresAt ? `on ${draft.expiresAt.toISOString().slice(0, 10)}` : ''} (drafts last 7 days) — regenerate the clip instead`);
+        if (!draft.flagged)
+            throw new Error(`${id} is not a Seedance draft (asset ${asset.id} has no config.values.draft) — only draft clips can be upscaled`);
+        const model = await findModel(c, 'video', draft.model, cv.workspaceId);
+        const configDuration = Number(asset.config?.duration);
+        const duration = configDuration > 0 ? configDuration : Number(asset.duration) > 0 ? Math.round(Number(asset.duration)) : undefined;
+        const ratio = String(asset.config?.aspectRatio || '').includes(':') ? asset.config.aspectRatio : asset.aspectRatio;
+        const content = {
+            mode: 'generate',
+            generate: {
+                prompt: 'N/A',
+                model: model.nickname || model.name,
+                resolution: '1080p',
+                ratio,
+                duration,
+                values: { mode: 'video', resolution: '1080p', draft: false, draftTaskId: draft.taskId },
+            },
+        };
+        const body = {
+            name: opts.name || `${source.name || 'video'}-1080p`,
+            type: 'file',
+            mimetype: `${NODE_PREFIX}video`,
+            parent: cv.id,
+            sort: 0,
+        };
+        if (source.content.width)
+            Object.assign(content, { width: source.content.width, height: source.content.height });
+        content.position = opts.at
+            ? parsePoint(opts.at, '--at')
+            : placeNear(cv, [source], estimateSize(cv, { id: '', kind: 'video', name: '', sort: 0, file: undefined, content, raw: null }));
+        const raw = await c.post('/fsnode/create', { ...body, content });
+        const node = { id: raw.id, kind: 'video', name: raw.name, sort: 0, file: idOf(raw.file), content, raw };
+        cv.nodes.push(node);
+        cv.byId.set(node.id, node);
+        // The web draws this edge so the panel shows the draft; the submit itself reads only draftTaskId.
+        await createEdge(c, cv, source.id, node.id, { content: { referenceRole: 'video', referenceLabel: 'video1' } });
+        success(`Created upscale node ${node.id} from ${id} (draft task ${draft.taskId})`);
+        if (!opts.gen)
+            return info(color.dim(`Generate it with: wji canvas gen ${node.id} -c ${cv.id}`));
+        await submitGenerate(c, cv, node, opts);
     });
     return canvas;
 }
+/** Price, confirm and submit one generate node — what the canvas Generate button does. */
+async function submitGenerate(c, cv, node, opts) {
+    const id = node.id;
+    if (!MEDIA_KINDS.has(node.kind) || node.content.mode !== 'generate') {
+        throw new Error(`${id} is not a generate node. Create one with \`wji canvas add ${MEDIA_KINDS.has(node.kind) ? node.kind : 'image'} -m … -p …\`.`);
+    }
+    if (describe(cv, node).status === 'generating')
+        throw new Error(`${id} is already generating`);
+    const g = node.content.generate || {};
+    if (!g.model)
+        throw new Error(`${id} has no model — set one with \`wji canvas set ${id} -m …\``);
+    const model = await findModel(c, node.kind, g.model, cv.workspaceId);
+    const body = buildSubmit(cv, node, model);
+    const cost = await c.post('/ai/assets/preComputeCost', {
+        type: node.kind,
+        model: body.model,
+        n: body.n,
+        prompt: body.prompt,
+        // Auto-duration submits -1; price the node's configured length instead.
+        duration: body.duration && body.duration > 0 ? body.duration : g.duration,
+        aspectRatio: body.aspectRatio,
+        referenceImageCount: body.referenceImages?.length,
+        values: body.values,
+    });
+    const credits = typeof cost === 'object' ? cost?.cost ?? cost?.credits ?? cost?.total : cost;
+    const refs = referencesOf(cv, node).map((r) => r.label).join(', ') || 'none';
+    const auto = body.duration === -1 ? ` (auto duration — estimated for ${g.duration ?? '?'}s, final cost follows the real length)` : '';
+    const question = `Generate ${node.kind} "${node.name}" with ${body.model} (refs: ${refs}) for ${credits ?? '?'} credits${auto}?`;
+    if (!(await confirm(question, opts.yes)))
+        return info('Aborted');
+    const history = await c.post(`/ai/assets/history/${node.kind}/generations`, body);
+    const assetId = idOf((history?.images || [])[0]);
+    const nextGenerate = { ...g, historyId: String(history.id), pendingAssetId: assetId };
+    await patchNode(c, node, {
+        ...(assetId ? { file: assetId } : {}),
+        content: { ...node.content, generate: nextGenerate },
+    });
+    if (!opts.wait) {
+        if (isJsonMode())
+            return printJson(history);
+        success(`Submitted ${node.kind} generation for node ${id}`);
+        reportHistory(history, await resolveAssets(c, history));
+        info(color.dim(`The canvas shows progress. Poll with: wji canvas get ${id}  or  wji history get ${history.id} --wait`));
+        return;
+    }
+    info(color.dim(`Submitted ${history.id}, waiting…`));
+    const done = await pollHistory(c, history.id, {
+        timeoutMs: Number(opts.timeout) * 1000,
+        intervalMs: Number(opts.interval) * 1000,
+    });
+    if (isJsonMode())
+        return printJson({ ...done.history, images: done.assets });
+    success(`Node ${id} generated`);
+    reportHistory(done.history, done.assets);
+}