stageflow 0.33.0 → 0.36.0

package/dist/config/draftPackage.js

@@ -1,4 +1,4 @@
-import { access, mkdir, mkdtemp, rm, writeFile } from "node:fs/promises";
+import { access, mkdir, mkdtemp, readFile, rm, writeFile } from "node:fs/promises";
 import { tmpdir } from "node:os";
 import path from "node:path";
 import { loadPipelineOutcome } from "./loadPipeline.js";
@@ -6,6 +6,8 @@ import { parseTaskFile } from "./loadTask.js";
 import { stringifyTargetYaml } from "./printTargetYaml.js";
 import { readYamlObject } from "./readYamlObject.js";
 import { buildValidationResult, findingsFromLoadIssues, loadPipelineValidated, validatePipeline, } from "./validateCatalog.js";
+import { normalizeDraftCatalogFilenames, taskIdFromDraftTask, } from "./workshopCatalogFilenames.js";
+import { reconcileWorkshopCatalogPackageDir } from "./workshopCatalogRepair.js";
 function isPlainObject(value) {
     return value !== null && typeof value === "object" && !Array.isArray(value);
 }
@@ -15,10 +17,57 @@ function normalizeStageRelPath(stagePath) {
 function pipelineHasExternalUses(pipeline) {
     return pipeline.stages.some((stage) => typeof stage.uses === "string" && stage.uses.trim().length > 0);
 }
+function stripUsesWrapperSkill(stages) {
+    return stages.map((stage) => {
+        if (typeof stage.uses !== "string" || stage.skill === undefined)
+            return stage;
+        const { skill: _skill, ...rest } = stage;
+        return rest;
+    });
+}
+/** Move uses-wrapper skill: onto the matching stage artifact body, then clear the wrapper. */
+export function hoistUsesWrapperSkills(draft) {
+    const artifacts = draft.stages ? [...draft.stages] : [];
+    const byPath = new Map(artifacts.map((artifact, index) => [
+        normalizeStageRelPath(artifact.path),
+        index,
+    ]));
+    const stages = draft.pipeline.stages.map((stage) => {
+        if (typeof stage.uses !== "string" || stage.skill === undefined)
+            return stage;
+        const skill = typeof stage.skill === "string" && stage.skill.trim()
+            ? stage.skill.trim()
+            : undefined;
+        if (skill === undefined) {
+            const { skill: _skill, ...rest } = stage;
+            return rest;
+        }
+        const key = normalizeStageRelPath(stage.uses);
+        const index = byPath.get(key);
+        if (index !== undefined) {
+            const current = artifacts[index];
+            const bodySkill = current.body.skill;
+            const bodyHasSkill = typeof bodySkill === "string" && bodySkill.trim().length > 0;
+            if (!bodyHasSkill) {
+                artifacts[index] = {
+                    ...current,
+                    body: { ...current.body, skill },
+                };
+            }
+        }
+        const { skill: _skill, ...rest } = stage;
+        return rest;
+    });
+    return {
+        ...draft,
+        pipeline: { ...draft.pipeline, stages },
+        ...(artifacts.length > 0 ? { stages: artifacts } : {}),
+    };
+}
 function pipelineDocument(pipeline) {
     const doc = {
         id: pipeline.id,
-        stages: pipeline.stages,
+        stages: stripUsesWrapperSkill(pipeline.stages),
     };
     if (pipeline.agent !== undefined)
         doc.agent = pipeline.agent;
@@ -28,6 +77,8 @@ function pipelineDocument(pipeline) {
         doc.schemas = pipeline.schemas;
     if (pipeline.requires !== undefined)
         doc.requires = pipeline.requires;
+    if (pipeline.channels !== undefined)
+        doc.channels = pipeline.channels;
     return doc;
 }
 function resolveDirectory(projectRoot, directory) {
@@ -48,9 +99,10 @@ async function fileExists(filePath) {
     }
 }
 async function materializeDraft(draft, dir, pipelineFilename) {
+    const migrated = hoistUsesWrapperSkills(draft);
     await mkdir(dir, { recursive: true });
-    await writeFile(path.join(dir, pipelineFilename), stringifyTargetYaml(pipelineDocument(draft.pipeline)), "utf8");
-    for (const stage of draft.stages ?? []) {
+    await writeFile(path.join(dir, pipelineFilename), stringifyTargetYaml(pipelineDocument(migrated.pipeline)), "utf8");
+    for (const stage of migrated.stages ?? []) {
         const rel = normalizeStageRelPath(stage.path);
         const stagePath = path.join(dir, rel);
         await mkdir(path.dirname(stagePath), { recursive: true });
@@ -114,6 +166,7 @@ export async function validateDraftPackage(draft, options = {}) {
             ...(draft.pipeline.requires !== undefined
                 ? { requires: draft.pipeline.requires }
                 : {}),
+            ...(draft.pipeline.channels !== undefined ? { channels: draft.pipeline.channels } : {}),
         };
         const result = await loadPipelineValidated(inline, {
             cwd,
@@ -185,11 +238,13 @@ function resolveDraftWriteTarget(projectRoot, input) {
             error: "directory must be inside the project root",
         };
     }
-    const draft = input.draft;
-    if (!isPlainObject(draft?.pipeline) || typeof draft.pipeline.id !== "string") {
+    const rawDraft = input.draft;
+    if (!isPlainObject(rawDraft?.pipeline) || typeof rawDraft.pipeline.id !== "string") {
         return { ok: false, status: 400, error: "draft.pipeline.id is required" };
     }
-    const pipelineFilename = input.pipelineFilename?.trim() || `${draft.pipeline.id}.pipeline.yaml`;
+    const normalized = normalizeDraftCatalogFilenames(rawDraft, input.pipelineFilename?.trim());
+    const draft = hoistUsesWrapperSkills(normalized.draft);
+    const pipelineFilename = normalized.pipelineFilename;
     const pipelineAbsPath = path.join(packageDirectory, path.basename(pipelineFilename));
     const pipelineRelPath = path
         .relative(projectRoot, pipelineAbsPath)
@@ -223,9 +278,17 @@ async function gateDraftWrite(projectRoot, draft, allowInvalid) {
         findings: validation.findings,
     };
 }
-async function writeDraftPackageFiles(projectRoot, target, allowInvalid) {
+function resolveDraftWriteFiles(projectRoot, target) {
     const { packageDirectory, draft, pipelineAbsPath, pipelineRelPath } = target;
-    const stagePaths = [];
+    const toRel = (abs) => path.relative(projectRoot, abs).replace(/\\/g, "/");
+    const files = [
+        {
+            kind: "pipeline",
+            absPath: pipelineAbsPath,
+            relPath: pipelineRelPath,
+            content: stringifyTargetYaml(pipelineDocument(draft.pipeline)),
+        },
+    ];
     for (const stage of draft.stages ?? []) {
         const rel = normalizeStageRelPath(stage.path);
         if (!rel || path.isAbsolute(rel) || rel.split(/[/\\]/).includes("..")) {
@@ -244,23 +307,39 @@ async function writeDraftPackageFiles(projectRoot, target, allowInvalid) {
                 error: `Stage path escapes package directory (${stage.path})`,
             };
         }
+        files.push({
+            kind: "stage",
+            absPath: stageAbs,
+            relPath: toRel(stageAbs),
+            content: stringifyTargetYaml(stage.body),
+        });
     }
+    if (draft.task) {
+        const taskAbs = path.join(packageDirectory, path.basename(draft.task.filename));
+        files.push({
+            kind: "task",
+            absPath: taskAbs,
+            relPath: toRel(taskAbs),
+            content: stringifyTargetYaml(draft.task.body),
+        });
+    }
+    return { ok: true, files };
+}
+async function writeDraftPackageFiles(projectRoot, target, allowInvalid) {
+    const { packageDirectory, draft, pipelineRelPath } = target;
+    const resolved = resolveDraftWriteFiles(projectRoot, target);
+    if (!resolved.ok)
+        return resolved;
     try {
         await mkdir(packageDirectory, { recursive: true });
-        await writeFile(pipelineAbsPath, stringifyTargetYaml(pipelineDocument(draft.pipeline)), "utf8");
-        for (const stage of draft.stages ?? []) {
-            const rel = normalizeStageRelPath(stage.path);
-            const stageAbs = path.resolve(packageDirectory, rel);
-            await mkdir(path.dirname(stageAbs), { recursive: true });
-            await writeFile(stageAbs, stringifyTargetYaml(stage.body), "utf8");
-            stagePaths.push(path.relative(projectRoot, stageAbs).replace(/\\/g, "/"));
-        }
-        let taskPath;
-        if (draft.task) {
-            const taskAbs = path.join(packageDirectory, path.basename(draft.task.filename));
-            await writeFile(taskAbs, stringifyTargetYaml(draft.task.body), "utf8");
-            taskPath = path.relative(projectRoot, taskAbs).replace(/\\/g, "/");
+        for (const file of resolved.files) {
+            await mkdir(path.dirname(file.absPath), { recursive: true });
+            await writeFile(file.absPath, file.content, "utf8");
         }
+        const stagePaths = resolved.files
+            .filter((file) => file.kind === "stage")
+            .map((file) => file.relPath);
+        const taskPath = resolved.files.find((file) => file.kind === "task")?.relPath;
         const loadOutcome = await loadPipelineOutcome(pipelineRelPath, {
             cwd: projectRoot,
         });
@@ -274,6 +353,11 @@ async function writeDraftPackageFiles(projectRoot, target, allowInvalid) {
                 error: loadOutcome.issues[0]?.message ?? "Failed to load written pipeline",
             };
         }
+        const taskId = draft.task ? taskIdFromDraftTask(draft.task) : null;
+        await reconcileWorkshopCatalogPackageDir(packageDirectory, draft.pipeline.id, taskId, {
+            pipelineBasename: path.basename(target.pipelineAbsPath),
+            taskBasename: draft.task ? path.basename(draft.task.filename) : null,
+        });
         return {
             ok: true,
             pipeline,
@@ -287,10 +371,22 @@ async function writeDraftPackageFiles(projectRoot, target, allowInvalid) {
         return { ok: false, status: 500, error: message };
     }
 }
+async function prepareDraftPackageDirectory(target) {
+    const taskId = target.draft.task
+        ? taskIdFromDraftTask(target.draft.task)
+        : null;
+    await reconcileWorkshopCatalogPackageDir(target.packageDirectory, target.draft.pipeline.id, taskId, {
+        pipelineBasename: path.basename(target.pipelineAbsPath),
+        taskBasename: target.draft.task
+            ? path.basename(path.join(target.packageDirectory, path.basename(target.draft.task.filename)))
+            : null,
+    });
+}
 export async function overwriteDraftPackage(projectRoot, input) {
     const resolved = resolveDraftWriteTarget(projectRoot, input);
     if (!resolved.ok)
         return resolved;
+    await prepareDraftPackageDirectory(resolved.value);
     if (!(await fileExists(resolved.value.pipelineAbsPath))) {
         return {
             ok: false,
@@ -307,6 +403,7 @@ export async function createDraftPackage(projectRoot, input) {
     const resolved = resolveDraftWriteTarget(projectRoot, input);
     if (!resolved.ok)
         return resolved;
+    await prepareDraftPackageDirectory(resolved.value);
     if (await fileExists(resolved.value.pipelineAbsPath)) {
         return {
             ok: false,
@@ -319,6 +416,104 @@ export async function createDraftPackage(projectRoot, input) {
         return blocked;
     return writeDraftPackageFiles(projectRoot, resolved.value, input.allowInvalid);
 }
+function splitLines(text) {
+    if (!text)
+        return [];
+    return (text.endsWith("\n") ? text.slice(0, -1) : text).split("\n");
+}
+export function countLineChanges(before, after) {
+    const a = splitLines(before);
+    const b = splitLines(after);
+    let start = 0;
+    while (start < a.length && start < b.length && a[start] === b[start])
+        start += 1;
+    let endA = a.length;
+    let endB = b.length;
+    while (endA > start && endB > start && a[endA - 1] === b[endB - 1]) {
+        endA -= 1;
+        endB -= 1;
+    }
+    const midA = a.slice(start, endA);
+    const midB = b.slice(start, endB);
+    let prev = new Uint32Array(midB.length + 1);
+    let curr = new Uint32Array(midB.length + 1);
+    for (const lineA of midA) {
+        for (let j = 1; j <= midB.length; j += 1) {
+            curr[j] =
+                lineA === midB[j - 1] ? prev[j - 1] + 1 : Math.max(prev[j], curr[j - 1]);
+        }
+        [prev, curr] = [curr, prev];
+    }
+    const common = prev[midB.length];
+    return { added: midB.length - common, removed: midA.length - common };
+}
+async function readExisting(filePath) {
+    try {
+        return await readFile(filePath, "utf8");
+    }
+    catch {
+        return null;
+    }
+}
+export async function planDraftPackage(projectRoot, input, options = {}) {
+    const resolved = resolveDraftWriteTarget(projectRoot, input);
+    if (!resolved.ok)
+        return resolved;
+    const writeFiles = resolveDraftWriteFiles(projectRoot, resolved.value);
+    if (!writeFiles.ok)
+        return writeFiles;
+    const files = [];
+    for (const file of writeFiles.files) {
+        const existing = await readExisting(file.absPath);
+        if (existing === null) {
+            files.push({
+                path: file.relPath,
+                kind: file.kind,
+                action: "new",
+                added: splitLines(file.content).length,
+                removed: 0,
+            });
+        }
+        else if (existing === file.content) {
+            files.push({
+                path: file.relPath,
+                kind: file.kind,
+                action: "unchanged",
+                added: 0,
+                removed: 0,
+            });
+        }
+        else {
+            files.push({
+                path: file.relPath,
+                kind: file.kind,
+                action: "overwrite",
+                ...countLineChanges(existing, file.content),
+            });
+        }
+    }
+    const { pipelineRelPath, packageDirectory, draft } = resolved.value;
+    const pipelineIdTaken = (options.mode ?? "create") === "create" &&
+        (options.catalogPipelines ?? []).some((listing) => listing.id === draft.pipeline.id &&
+            listing.path.replace(/\\/g, "/") !== pipelineRelPath);
+    return {
+        ok: true,
+        pipelinePath: pipelineRelPath,
+        directory: path.relative(projectRoot, packageDirectory).replace(/\\/g, "/") || ".",
+        files,
+        pipelineIdTaken,
+    };
+}
+export function parsePlanDraftPackageBody(body) {
+    const parsed = parseCreateDraftPackageBody(body);
+    if ("ok" in parsed)
+        return parsed;
+    const mode = isPlainObject(body) ? body.mode : undefined;
+    if (mode !== undefined && mode !== "create" && mode !== "overwrite") {
+        return { ok: false, status: 400, error: 'mode must be "create" or "overwrite"' };
+    }
+    return { ...parsed, mode: mode ?? "create" };
+}
 export function parseDraftPackageBody(body) {
     if (!isPlainObject(body)) {
         return { ok: false, status: 400, error: "JSON object body required" };
@@ -524,6 +719,7 @@ export async function loadDraftPackage(projectRoot, pipelineRelPath, options = {
             ...(raw.model !== undefined ? { model: raw.model } : {}),
             ...(raw.schemas !== undefined ? { schemas: raw.schemas } : {}),
             ...(raw.requires !== undefined ? { requires: raw.requires } : {}),
+            ...(raw.channels !== undefined ? { channels: raw.channels } : {}),
         },
         ...(stageArtifacts.length > 0 ? { stages: stageArtifacts } : {}),
     };
@@ -540,9 +736,10 @@ export async function loadDraftPackage(projectRoot, pipelineRelPath, options = {
         draft.task = loaded.task;
         attachedTaskPath = loaded.taskPath;
     }
+    const migrated = hoistUsesWrapperSkills(draft);
     return {
         ok: true,
-        draft,
+        draft: migrated,
         destination: { directory, pipelineFilename },
         pipelinePath,
         ...(attachedTaskPath !== undefined ? { taskPath: attachedTaskPath } : {}),

package/dist/config/ensureCatalogScanRoot.d.ts

@@ -1,8 +1,9 @@
+import type { CatalogRootKind } from "./resolveCatalogRoots.js";
 /** Directory scanned for workshop-authored pipelines and tasks. */
 export declare const WORKSHOP_PACKAGE_ROOT = "workshop";
 export declare function normalizeCatalogDir(directory: string): string;
 /** Untitled workshop saves land here so Run can see them without a new catalog edit. */
-export declare function defaultWorkshopPackageDirectory(pipelineId: string | undefined): string;
+export declare function defaultWorkshopPackageDirectory(pipelineId: string | undefined, catalogRootKind?: CatalogRootKind): string;
 /**
  * Catalog root that covers this package directory.
  * Packages under `workshop/` share one root. Any other folder is listed itself

package/dist/config/ensureCatalogScanRoot.js

@@ -7,13 +7,17 @@ export function normalizeCatalogDir(directory) {
     return directory.replace(/\\/g, "/").replace(/^\.\/+/, "").replace(/\/+$/, "");
 }
 /** Untitled workshop saves land here so Run can see them without a new catalog edit. */
-export function defaultWorkshopPackageDirectory(pipelineId) {
+export function defaultWorkshopPackageDirectory(pipelineId, catalogRootKind) {
     const slug = (pipelineId ?? "")
         .toLowerCase()
         .replace(/[^a-z0-9]+/g, "-")
         .replace(/^-+|-+$/g, "")
         .slice(0, 40);
-    return `${WORKSHOP_PACKAGE_ROOT}/${slug || "untitled"}`;
+    const id = slug || "untitled";
+    if (catalogRootKind === "workspace") {
+        return id;
+    }
+    return `${WORKSHOP_PACKAGE_ROOT}/${id}`;
 }
 /**
  * Catalog root that covers this package directory.

package/dist/config/findTaskInCatalog.d.ts

@@ -0,0 +1,33 @@
+import type { TaskFile } from "../types/task.js";
+import { type ResolveCatalogRootsOptions } from "./resolveCatalogRoots.js";
+export type TaskDetail = TaskFile & {
+    path: string;
+};
+export type TaskDetailWithRoot = TaskDetail & {
+    project_root: string;
+};
+export type FindTaskInCatalogMultiResult = {
+    ok: true;
+    task: TaskDetailWithRoot;
+} | {
+    ok: false;
+    status: 404;
+    error: string;
+} | {
+    ok: false;
+    status: 400;
+    error: string;
+    code: "unknown_project_root";
+} | {
+    ok: false;
+    status: 409;
+    error: string;
+    code: "ambiguous_task";
+    project_roots: string[];
+};
+export declare function findTaskInProjectRoot(projectRoot: string, taskId: string): Promise<TaskDetail | null>;
+export declare function findTaskInCatalogMulti(options: ResolveCatalogRootsOptions & {
+    taskId: string;
+    projectRootFilter?: string;
+}): Promise<FindTaskInCatalogMultiResult>;
+export declare function findTaskInCatalog(cwd: string, taskId: string): Promise<TaskDetail | null>;

package/dist/config/findTaskInCatalog.js

@@ -0,0 +1,69 @@
+import path from "node:path";
+import { getCatalogScanPaths } from "./browseCatalog.js";
+import { loadTaskOutcome } from "./loadTask.js";
+import { listTasksMultiProject } from "./multiProjectCatalog.js";
+import { catalogContextFromStageflow } from "./resolveCatalogContext.js";
+import { findCatalogRoot, } from "./resolveCatalogRoots.js";
+import { resolveStageflowContext } from "../project/resolveStageflowContext.js";
+export async function findTaskInProjectRoot(projectRoot, taskId) {
+    const ctx = catalogContextFromStageflow(await resolveStageflowContext(projectRoot));
+    const scanPaths = await getCatalogScanPaths(ctx);
+    if (!scanPaths || ctx.projectRoot === null) {
+        return null;
+    }
+    const root = ctx.projectRoot;
+    for (const filePath of scanPaths.taskPaths) {
+        const outcome = await loadTaskOutcome(filePath);
+        if (!outcome.ok || outcome.value.id !== taskId) {
+            continue;
+        }
+        return {
+            ...outcome.value,
+            path: path.relative(root, filePath).replace(/\\/g, "/"),
+        };
+    }
+    return null;
+}
+export async function findTaskInCatalogMulti(options) {
+    const { taskId, projectRootFilter, ...rootOptions } = options;
+    const listed = await listTasksMultiProject({
+        ...rootOptions,
+        projectRootFilter,
+    });
+    if (projectRootFilter !== undefined &&
+        listed.root_errors.some((e) => e.code === "unknown_project_root")) {
+        return {
+            ok: false,
+            status: 400,
+            error: listed.root_errors[0].message,
+            code: "unknown_project_root",
+        };
+    }
+    const matches = listed.items.filter((t) => t.id === taskId);
+    if (matches.length === 0) {
+        return { ok: false, status: 404, error: `Task not found: ${taskId}` };
+    }
+    const projectRoots = [...new Set(matches.map((m) => m.project_root))];
+    if (projectRoots.length > 1) {
+        return {
+            ok: false,
+            status: 409,
+            error: `Task id is ambiguous across catalog roots: ${taskId}`,
+            code: "ambiguous_task",
+            project_roots: projectRoots.sort((a, b) => a.localeCompare(b)),
+        };
+    }
+    const wireRoot = projectRoots[0];
+    const catalogRoot = findCatalogRoot(listed.roots, wireRoot);
+    if (catalogRoot === undefined) {
+        return { ok: false, status: 404, error: `Task not found: ${taskId}` };
+    }
+    const detail = await findTaskInProjectRoot(catalogRoot.path, taskId);
+    if (!detail) {
+        return { ok: false, status: 404, error: `Task not found: ${taskId}` };
+    }
+    return { ok: true, task: { ...detail, project_root: wireRoot } };
+}
+export async function findTaskInCatalog(cwd, taskId) {
+    return findTaskInProjectRoot(cwd, taskId);
+}

package/dist/config/hostConfig.d.ts

@@ -9,6 +9,14 @@ export declare const KNOWN_STAGEFLOW_ENV_KEYS: Set<string>;
 export type CallerQuotaConfig = {
     maxConcurrent: number;
 };
+export declare const DEFAULT_BROWSER_DIALOG_TIMEOUT_SECONDS = 60;
+export type BrowserContainerConfig = {
+    image: string;
+    shmSize: string;
+    memory: string;
+    pidsLimit: number;
+};
+export declare const DEFAULT_BROWSER_CONTAINER_IMAGE = "stageflow-browser-sandbox:local";
 export type HostConfig = {
     maxConcurrentRuns: number;
     maxConcurrentRunsPerProject: number | undefined;
@@ -22,6 +30,18 @@ export type HostConfig = {
     callers: Record<string, CallerQuotaConfig>;
     /** Domains no browser stage may use (`browser.blocked_sites` in config.yaml). */
     browserBlockedSites: string[];
+    /** Chrome launch arguments (`browser.launch_args`); empty when unset. */
+    browserLaunchArgs: string[];
+    /** Explicit Chrome path (`browser.executable_path`); undefined when unset. */
+    browserExecutablePath: string | undefined;
+    /** Seconds an unanswered live view page dialog waits before the Host dismisses it (`browser.dialog_timeout_seconds`). */
+    browserDialogTimeoutSeconds: number;
+    /** Where shared profile browsers run (`browser.host`): this machine, or one container per run. */
+    browserHost: "local" | "container";
+    /** Per-owner adapter override (`browser.owner_hosts`, owner scope to host); scopes absent here use `browserHost`. */
+    browserOwnerHosts: Record<string, "local" | "container">;
+    /** Container host settings (`browser.container`); defaults apply when unset. */
+    browserContainer: BrowserContainerConfig;
     /** Absolute path of config.yaml when loaded; undefined if absent. */
     configFilePath: string | undefined;
     warnings: string[];
@@ -45,6 +65,7 @@ export type HostConfigPublicEcho = {
     callers: Record<string, CallerQuotaConfig>;
     secrets: HostConfigSecretsEcho;
 };
+export declare function browserHostForOwner(config: Pick<HostConfig, "browserHost" | "browserOwnerHosts">, scope: string): "local" | "container";
 /**
  * Assemble HostConfig once at boot. Precedence: overrides (CLI flags) > env > file > default.
  */