@tuongaz/seeflow 0.1.41 → 0.1.47

package/src/registry.ts

@@ -1,6 +1,7 @@
 import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs';
 import { dirname, join } from 'node:path';
 import { seeflowHome } from './paths.ts';
+import { shortId } from './short-id.ts';
 
 export interface FlowEntry {
   id: string;
@@ -121,7 +122,7 @@ export function createRegistry(options: { path?: string } = {}): Registry {
         persist();
         return updated;
       }
-      const id = crypto.randomUUID();
+      const id = shortId();
       const slug = uniqueSlug(slugify(input.name));
       const entry: FlowEntry = {
         id,

package/src/schema.ts

@@ -71,13 +71,13 @@ const ScriptActionSchema = z.object({
   interpreter: z.string().min(1),
   args: z.array(z.string()).optional(),
   scriptPath: z.string().min(1).refine(isCleanRelativePath, {
-    message: 'scriptPath must be a relative path under .seeflow/ (no absolute / traversal)',
+    message: 'scriptPath must be a relative path under the node folder (no absolute / traversal)',
   }),
   input: z.unknown().optional(),
   timeoutMs: z.number().int().positive().max(600_000).optional(),
 });
 
-const PlayActionSchema = ScriptActionSchema;
+export const PlayActionSchema = ScriptActionSchema;
 
 // US-008: resetAction is a one-shot script action — same shape as a play
 // script (interpreter + args + scriptPath + optional input/timeoutMs) but
@@ -89,12 +89,12 @@ const ResetActionSchema = ScriptActionSchema;
 // Long-running status script. Same spawn shape as ScriptAction (interpreter +
 // args + scriptPath) but no stdin payload and a much longer max lifetime since
 // these processes tick continuously and stream StatusReports to stdout.
-const StatusActionSchema = z.object({
+export const StatusActionSchema = z.object({
   kind: z.literal('script'),
   interpreter: z.string().min(1),
   args: z.array(z.string()).optional(),
   scriptPath: z.string().min(1).refine(isCleanRelativePath, {
-    message: 'scriptPath must be a relative path under .seeflow/ (no absolute / traversal)',
+    message: 'scriptPath must be a relative path under the node folder (no absolute / traversal)',
   }),
   maxLifetimeMs: z.number().int().positive().max(3_600_000).optional(),
 });
@@ -110,7 +110,7 @@ export const StatusReportSchema = z.object({
   ts: z.number().int().positive().optional(),
 });
 
-const StateSourceSchema = z.discriminatedUnion('kind', [
+export const StateSourceSchema = z.discriminatedUnion('kind', [
   z.object({ kind: z.literal('request') }),
   z.object({ kind: z.literal('event') }),
 ]);
@@ -163,7 +163,7 @@ const StateNodeSchema = z.object({
 // via inline SVG inside shape-node.tsx). Illustrative shapes share the same
 // shapeNode wrapper and color/border fields but own their own visuals via a
 // per-shape component under `apps/web/src/components/nodes/shapes/`.
-const ShapeKindSchema = z.enum([
+export const ShapeKindSchema = z.enum([
   'rectangle',
   'ellipse',
   'sticky',
@@ -190,7 +190,7 @@ const ShapeNodeSchema = z.object({
 
 // Decorative image node — references a file under `<project>/.seeflow/` by
 // relative path (US-004 hard-cut from base64 data URLs to path-backed files).
-// `path` is the same kind of relative path as `htmlPath` on htmlNode: rooted
+// `path` is a relative path under `<project>/.seeflow/` for imageNode uploads: rooted
 // at `.seeflow/`, no leading slash, no `..` segments. The renderer fetches via
 // `GET /api/projects/:id/files/:path`.
 const ImageNodeDataSchema = z.object({
@@ -210,23 +210,16 @@ const ImageNodeSchema = z.object({
 });
 
 // US-011 (illustrative-shapes-htmlnode): htmlNode is the escape-hatch node type
-// for content the curated nodes don't cover — references author-written HTML at
-// `<project>/.seeflow/<htmlPath>`. The renderer fetches via the file-serving
-// endpoint and sanitizes before injecting (US-013/US-014). `htmlPath` uses the
-// same path-safety refine as imageNode.path: relative under `.seeflow/`, no
-// absolute root, no `..` traversal. Spreads NodeVisualBaseShape so authors can
-// theme the wrapper (border / background / radius / font) with the same fields
+// for content the curated nodes don't cover — carries author-written HTML
+// inline via `data.html`. The studio externalizes the content to
+// `<project>/.seeflow/nodes/<id>/view.html` and stores a `file://` ref in
+// flow.json; the resolver inlines the content back on read so consumers see
+// the resolved HTML string. The renderer sanitizes before injection
+// (US-013/US-014). Spreads NodeVisualBaseShape so authors can theme the
+// wrapper (border / background / radius / font) with the same fields
 // available on every other visual node.
-//
-// File existence is INTENTIONALLY not validated at the schema level. Missing
-// files are a normal authoring state (author drops a node, file hasn't been
-// written yet) and would otherwise reject the whole demo. The US-014 renderer
-// renders a `PlaceholderCard` instead — so a missing htmlPath WARNS (via the
-// placeholder visual) without ERRORING (without failing demo parse).
 export const HtmlNodeDataSchema = z.object({
-  htmlPath: z.string().min(1).refine(isCleanRelativePath, {
-    message: 'htmlPath must be a relative path under .seeflow/ (no absolute / traversal)',
-  }),
+  html: z.string().optional(),
   name: z.string().optional(),
   // Decorative caption glyph. Lucide icon name (kebab-case) resolved by the
   // canvas <Icon> primitive; rendered inline with the caption when set.
@@ -418,6 +411,21 @@ export const ResolvedFlowSchema = z
         });
       }
     });
+    // imageNode upload paths must live under the node's own
+    // `nodes/<id>/` folder so delete_node's removeNodeDir cascade is the
+    // single source of cleanup.
+    resolved.nodes.forEach((node, idx) => {
+      if (node.type !== 'imageNode') return;
+      const path = (node.data as { path?: string }).path;
+      const expected = `nodes/${node.id}/`;
+      if (typeof path === 'string' && !path.startsWith(expected)) {
+        ctx.addIssue({
+          code: z.ZodIssueCode.custom,
+          path: ['nodes', idx, 'data', 'path'],
+          message: `imageNode path must start with "${expected}"`,
+        });
+      }
+    });
   });
 
 export type ResolvedFlow = z.infer<typeof ResolvedFlowSchema>;
@@ -504,9 +512,7 @@ const FlowIconNodeDataSchema = z
 
 const FlowHtmlNodeDataSchema = z
   .object({
-    htmlPath: z.string().min(1).refine(isCleanRelativePath, {
-      message: 'htmlPath must be a relative path under .seeflow/ (no absolute / traversal)',
-    }),
+    html: z.string().optional(),
     name: z.string().optional(),
     icon: z.string().optional(),
     ...NodeDescriptionBaseShape,

package/src/short-id.ts

@@ -0,0 +1,24 @@
+// Short unique identifier for nodes, connectors, flow registry entries, and
+// runIds. 10 base62 chars (62^10 ≈ 8.4e17 combos) is plenty for our scale and
+// keeps URLs / file paths (e.g. `blocks/<id>.html`) readable.
+//
+// Rejection sampling avoids the modulo bias of `byte % 62`: 256 % 62 = 8, so
+// bytes 0..247 map evenly across the 62-char alphabet and 248..255 are
+// re-rolled. The oversample factor (×2) makes a second round almost never
+// needed in practice.
+
+const ALPHABET = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789';
+const UNBIASED_MAX = 248; // floor(256 / 62) * 62
+
+export function shortId(len = 10): string {
+  let out = '';
+  const buf = new Uint8Array(len * 2);
+  while (out.length < len) {
+    crypto.getRandomValues(buf);
+    for (let i = 0; i < buf.length && out.length < len; i++) {
+      const b = buf[i] as number;
+      if (b < UNBIASED_MAX) out += ALPHABET[b % 62];
+    }
+  }
+  return out;
+}

package/src/status-runner.ts

@@ -16,8 +16,8 @@
  * report. A solicited kill (restart / stop / maxLifetimeMs) is silent on exit.
  *
  * Defense-in-depth on scriptPath mirrors proxy.ts:`resolveScript` — realpath
- * the resolved file against `<repoPath>/.seeflow/` so a symlink-escape can't
- * spawn arbitrary scripts outside the project.
+ * the resolved file against `<repoPath>/.seeflow/nodes/<nodeId>/` so a
+ * symlink-escape can't spawn arbitrary scripts outside the node folder.
  */
 
 import { existsSync, realpathSync } from 'node:fs';
@@ -26,6 +26,7 @@ import type { EventBus } from './events.ts';
 import { type ProcessSpawner, type SpawnHandle, defaultProcessSpawner } from './process-spawner.ts';
 import type { FlowEntry, Registry } from './registry.ts';
 import { type ResolvedFlow, type StatusAction, StatusReportSchema } from './schema.ts';
+import { shortId } from './short-id.ts';
 import { readMergedFlow } from './watcher.ts';
 
 export interface StatusRunner {
@@ -61,15 +62,15 @@ interface TrackedHandle {
 
 type ResolvedScript = { ok: true; absPath: string } | { ok: false };
 
-function resolveScript(repoPath: string, scriptPath: string): ResolvedScript {
-  const seeflowRoot = join(repoPath, '.seeflow');
+function resolveScript(repoPath: string, nodeId: string, scriptPath: string): ResolvedScript {
+  const nodeRoot = join(repoPath, '.seeflow', 'nodes', nodeId);
   let realRoot: string;
   try {
-    realRoot = realpathSync(seeflowRoot);
+    realRoot = realpathSync(nodeRoot);
   } catch {
     return { ok: false };
   }
-  const target = resolve(seeflowRoot, scriptPath);
+  const target = resolve(nodeRoot, scriptPath);
   let realTarget: string;
   try {
     realTarget = realpathSync(target);
@@ -178,7 +179,7 @@ export function createStatusRunner(options: CreateStatusRunnerOptions): StatusRu
   ): TrackedHandle | undefined {
     const { nodeId, action } = sn;
 
-    const resolved = resolveScript(repoPath, action.scriptPath);
+    const resolved = resolveScript(repoPath, nodeId, action.scriptPath);
     if (!resolved.ok) {
       events.broadcast({
         type: 'node:status',
@@ -193,7 +194,7 @@ export function createStatusRunner(options: CreateStatusRunnerOptions): StatusRu
       return undefined;
     }
 
-    const runId = crypto.randomUUID();
+    const runId = shortId();
     const env = buildChildEnv({
       SEEFLOW_DEMO_ID: flowId,
       SEEFLOW_NODE_ID: nodeId,

package/src/watcher.ts

@@ -71,7 +71,8 @@ export interface FlowWatcher {
   ): void;
   /**
    * Relative paths (under `<project>/.seeflow/`) currently being watched
-   * because they're referenced by a node's `data.htmlPath` or `data.path`.
+   * because they're referenced by a node's `data.path` (imageNode). htmlNode
+   * content rides on the file:// resolver via `data.html`, not this list.
    * Sorted for stable assertion order. Used by tests.
    */
   referencedPaths(flowId: string): string[];
@@ -91,7 +92,7 @@ interface WatchHandle {
   filePath: string;
   /**
    * Per-directory file watchers for files referenced by node data
-   * (`htmlPath`, imageNode `path`). Each directory watcher dispatches to
+   * (imageNode `path`). Each directory watcher dispatches to
    * specific basenames in its `files` map.
    */
   fileWatchers: Map<string, FileWatchEntry>;
@@ -129,10 +130,11 @@ const isCleanRelativePath = (p: string): boolean => {
 };
 
 /**
- * Walk raw flow JSON (pre-schema-parse) collecting referenced file
- * paths: `nodes[].data.htmlPath` (htmlNode) and `nodes[].data.path`
- * (imageNode). Operates on the raw JSON so the watcher works before those
- * fields are formally validated.
+ * Walk raw flow JSON (pre-schema-parse) collecting referenced file paths:
+ * `nodes[].data.path` (imageNode). htmlNode content now flows through the
+ * `file://nodes/<id>/view.html` ref handled by the file-ref resolver, so it
+ * does NOT need a separate fs.watch entry here. Operates on the raw JSON so
+ * the watcher works before those fields are formally validated.
  */
 const collectReferencedPaths = (raw: unknown): string[] => {
   if (!raw || typeof raw !== 'object') return [];
@@ -143,12 +145,10 @@ const collectReferencedPaths = (raw: unknown): string[] => {
     if (!node || typeof node !== 'object') continue;
     const data = (node as { data?: unknown }).data;
     if (!data || typeof data !== 'object') continue;
-    const d = data as { htmlPath?: unknown; path?: unknown };
-    for (const candidate of [d.htmlPath, d.path]) {
-      if (typeof candidate !== 'string') continue;
-      if (!isCleanRelativePath(candidate)) continue;
-      out.add(candidate);
-    }
+    const d = data as { path?: unknown };
+    if (typeof d.path !== 'string') continue;
+    if (!isCleanRelativePath(d.path)) continue;
+    out.add(d.path);
   }
   return [...out];
 };
@@ -164,7 +164,7 @@ export interface ReadMergedFlowResult {
   error: string | null;
   /** Sorted relative paths under `<seeflowRoot>` resolved via file://. */
   fileRefs: string[];
-  /** Flow file paths referenced via htmlPath / imageNode.path. */
+  /** Flow file paths referenced via imageNode.path. */
   staticRefs: string[];
 }
 
@@ -394,7 +394,7 @@ export function createWatcher(deps: WatcherDeps): FlowWatcher {
 
     snapshots.set(flowId, next);
 
-    // Reconcile the referenced-file watch set: htmlPath/imageNode.path from
+    // Reconcile the referenced-file watch set: imageNode.path from
     // flow + any file:// targets that resolved cleanly. Schema errors
     // shouldn't drop the watch set — the user is mid-edit and the referenced
     // files are still valid targets, so this reconciles whenever the JSON