@fungi.computer/trellis 0.0.0-stage → 0.0.1

package/dist/backend/schedule-methods.js

@@ -0,0 +1,90 @@
+import { triggerTargetSchema, scheduleArmReplySchema, triggerDisarmReplySchema, schedulesReplySchema, scheduleDisarmInputSchema, eventDisarmInputSchema, triggerListInputSchema, eventArmReplySchema, eventTriggersReplySchema, } from "@fungi.computer/workflows-wire";
+import { defineAppMethod } from "@fungi.computer/agar/backend-definition";
+import { createWorkflowLibrary } from "./library.js";
+import { readWorkflowCatalog } from "./catalog.js";
+const granted = (context) => {
+    if (!context.env.WORKFLOWS)
+        throw new Error("Workflow access is not granted");
+    return context.env.WORKFLOWS;
+};
+/** Read only this App's immutable publication rows; no Git repair occurs in arming. */
+function publication(context, target) {
+    if (context.indexes === undefined)
+        return null;
+    return createWorkflowLibrary({
+        index: context.indexes,
+        author: { name: "Trellis", email: "trellis@app.local" },
+        catalog: async (appIds) => {
+            const catalog = await readWorkflowCatalog(context.env.WORKFLOWS, appIds);
+            if (catalog === null)
+                throw new Error("Workflow catalog unavailable");
+            return catalog;
+        },
+    }).publishedRow(target.workflowId, { commit: target.commit });
+}
+const unavailablePublication = {
+    kind: "refused",
+    reason: "Workflow publication is unavailable; re-arm after publishing",
+};
+export const scheduleMethods = {
+    arm: defineAppMethod({
+        description: "Arm a published Workflow schedule as you on the pinned Computer. An optional delivery chat receives every run's ending.",
+        effect: "write",
+        requires: ["workflow.run", "workflow.arm"],
+        input: triggerTargetSchema,
+        output: scheduleArmReplySchema,
+        handler: async (input, context) => {
+            const workflows = granted(context);
+            const stored = publication(context, input);
+            if (stored === null)
+                return unavailablePublication;
+            return scheduleArmReplySchema.parse(await workflows.armSchedule({ ...input, digest: stored.digest }));
+        },
+    }),
+    disarm: defineAppMethod({
+        description: "Cancel an armed Workflow schedule.",
+        effect: "write",
+        requires: ["workflow.run", "workflow.arm"],
+        input: scheduleDisarmInputSchema,
+        output: triggerDisarmReplySchema,
+        handler: async (input, context) => triggerDisarmReplySchema.parse(await granted(context).disarmSchedule(input)),
+    }),
+    listTriggers: defineAppMethod({
+        description: "List this installation's schedules, next run times and paused reasons.",
+        effect: "read",
+        requires: ["workflow.run"],
+        input: triggerListInputSchema,
+        output: schedulesReplySchema,
+        handler: async (_input, context) => schedulesReplySchema.parse(await granted(context).schedules({})),
+    }),
+    armEventTrigger: defineAppMethod({
+        description: "Arm a published Workflow App-event trigger as you on the pinned Computer. An optional delivery chat receives every run's ending.",
+        effect: "write",
+        requires: ["workflow.run", "workflow.arm"],
+        input: triggerTargetSchema,
+        output: eventArmReplySchema,
+        handler: async (input, context) => {
+            const workflows = granted(context);
+            const stored = publication(context, input);
+            if (stored === null)
+                return unavailablePublication;
+            return eventArmReplySchema.parse(await workflows.armEventTrigger({ ...input, digest: stored.digest }));
+        },
+    }),
+    disarmEventTrigger: defineAppMethod({
+        description: "Disarm this installation's App-event trigger.",
+        effect: "write",
+        requires: ["workflow.run", "workflow.arm"],
+        input: eventDisarmInputSchema,
+        output: triggerDisarmReplySchema,
+        handler: async (input, context) => triggerDisarmReplySchema.parse(await granted(context).disarmEventTrigger(input)),
+    }),
+    eventTriggers: defineAppMethod({
+        description: "List this installation's App-event triggers and paused reasons.",
+        effect: "read",
+        requires: ["workflow.run"],
+        input: triggerListInputSchema,
+        output: eventTriggersReplySchema,
+        handler: async (_input, context) => eventTriggersReplySchema.parse(await granted(context).eventTriggers({})),
+    }),
+};

package/dist/backend/share.js

@@ -0,0 +1,140 @@
+import { workflowIdSchema } from "@fungi.computer/braid";
+import * as S from "effect/Schema";
+import * as Result from "effect/Result";
+import { gitSha1Schema } from "@fungi.computer/puffball/git-representation";
+import { sha256DigestSchema } from "@fungi.computer/puffball/effect";
+import { workflowDefinitionSchema, validate, } from "@fungi.computer/braid";
+import { provenanceSchema, shareReview, shareCopyReply, } from "@fungi.computer/workflows-wire";
+const workflowId = S.declare((value) => workflowIdSchema.safeParse(value).success);
+const commit = S.declare((value) => gitSha1Schema.safeParse(value).success);
+export const shareBundleSchema = S.Struct({
+    format: S.Literal("fungi.workflow-share/v1"),
+    definition: workflowDefinitionSchema,
+    layout: S.Record(S.String, S.Struct({ x: S.Finite, y: S.Finite })),
+    source: S.Struct({
+        workflowId,
+        version: S.Number.pipe(S.check(S.isInt()), S.check(S.isGreaterThan(0))),
+        commit,
+        origin: S.optionalKey(S.String.pipe(S.check(S.isMaxLength(256)))),
+    }),
+});
+const maxShareBytes = 512 * 1024;
+function review(definition, catalog) {
+    const graphs = [
+        { id: "root", graph: definition },
+        ...Object.entries(definition.subgraphs ?? {}).map(([id, graph]) => ({
+            id,
+            graph,
+        })),
+    ];
+    return shareReview.parse({
+        gitAccess: graphs.flatMap(({ id, graph }) => graph.nodes.flatMap((node) => node.kind === "app" && node.gitAccess
+            ? [{ graph: id, node: node.id, ...node.gitAccess }]
+            : [])),
+        writeNodes: graphs.flatMap(({ id, graph }) => graph.nodes.flatMap((node) => {
+            if (node.kind !== "app")
+                return [];
+            const appId = definition.apps[node.app]?.appId;
+            const method = appId === undefined
+                ? undefined
+                : catalog[appId]?.methods[node.method];
+            return method?.effect === "write" || method?.effect === "external"
+                ? [
+                    {
+                        graph: id,
+                        node: node.id,
+                        appId,
+                        method: node.method,
+                        effect: method.effect,
+                    },
+                ]
+                : [];
+        })),
+        triggers: definition.triggers ?? [],
+    });
+}
+/** A copy is named after its source; an over-long title keeps the source's. */
+function copyTitled(definition) {
+    const named = { ...definition, title: `${definition.title} (copy)` };
+    return S.is(workflowDefinitionSchema)(named) ? named : definition;
+}
+async function digest(bytes) {
+    const hash = new Uint8Array(await crypto.subtle.digest("SHA-256", Uint8Array.from(bytes)));
+    return S.decodeUnknownSync(sha256DigestSchema)(`sha256:${Array.from(hash, (byte) => byte.toString(16).padStart(2, "0")).join("")}`);
+}
+/** Copies published content into a new draft; provenance is a claim, never authority. */
+export function createWorkflowShare({ library, catalog, origin, }) {
+    async function save(workflowId, draft, provenance) {
+        const wanted = [
+            ...new Set(Object.values(draft.definition.apps).map((app) => app.appId)),
+        ];
+        const available = await catalog(wanted);
+        const appIds = wanted.filter((appId) => !Object.hasOwn(available, appId));
+        if (appIds.length)
+            return shareCopyReply.parse({ kind: "missing_apps", appIds });
+        const issues = validate(draft.definition, available);
+        if (issues.length)
+            return shareCopyReply.parse({ kind: "invalid", issues });
+        const result = await library.saveDraft(workflowId, { definition: draft.definition, layout: draft.layout, provenance }, 0);
+        return shareCopyReply.parse(result.kind === "saved"
+            ? {
+                ...result,
+                title: draft.definition.title,
+                review: review(draft.definition, available),
+            }
+            : result);
+    }
+    return {
+        async exportWorkflow(input) {
+            const document = await library.published(input.workflowId, {
+                version: input.version,
+            });
+            if (!document)
+                return { kind: "not_found" };
+            let source = { ...input, commit: document.commit };
+            if (origin !== undefined)
+                source = { ...source, origin };
+            const bundle = S.decodeUnknownSync(shareBundleSchema)({
+                format: "fungi.workflow-share/v1",
+                definition: document.definition,
+                layout: document.layout,
+                source,
+            }, { onExcessProperty: "error" });
+            const bytes = JSON.stringify(bundle);
+            const encoded = new TextEncoder().encode(bytes);
+            if (encoded.byteLength > maxShareBytes)
+                return { kind: "too_large" };
+            return { bytes, sha256: await digest(encoded) };
+        },
+        async importWorkflow(input) {
+            const bytes = new TextEncoder().encode(input.bytes);
+            if (bytes.byteLength > maxShareBytes)
+                return { kind: "too_large" };
+            if (!S.is(sha256DigestSchema)(input.sha256) ||
+                (await digest(bytes)) !== input.sha256)
+                return { kind: "digest_mismatch" };
+            const parsed = S.decodeUnknownResult(S.fromJsonString(shareBundleSchema))(input.bytes, { onExcessProperty: "error" });
+            if (Result.isFailure(parsed))
+                return { kind: "invalid_bundle" };
+            const bundle = parsed.success;
+            return save(input.workflowId, { definition: copyTitled(bundle.definition), layout: bundle.layout }, provenanceSchema.parse({
+                kind: "import",
+                ...bundle.source,
+                sha256: input.sha256,
+            }));
+        },
+        async forkPublishedWorkflow(input) {
+            const document = await library.published(input.sourceWorkflowId, input.at);
+            if (!document)
+                return { kind: "not_found" };
+            return save(input.workflowId, {
+                definition: copyTitled(document.definition),
+                layout: document.layout,
+            }, provenanceSchema.parse({
+                kind: "fork",
+                workflowId: input.sourceWorkflowId,
+                commit: document.commit,
+            }));
+        },
+    };
+}

package/dist/backend/tool-family.js

@@ -0,0 +1,98 @@
+import * as z from "zod";
+import { defineAppMethod } from "@fungi.computer/agar/backend-definition";
+import { catalogReplySchema } from "@fungi.computer/workflows-wire";
+import { runReply } from "@fungi.computer/workflows-wire";
+import { workflowToolListing } from "../shared/tool-contracts.js";
+const output = z.toJSONSchema(runReply, { io: "output" });
+// Workflow ids have no underscores or upper-case letters. Preserve dash cases
+// that cannot become camel case, so distinct ids cannot alias the same tool.
+function toolName(workflowId) {
+    const camel = workflowId.replace(/-([a-z])|-/g, (_, letter) => letter === undefined ? "_" : letter.toUpperCase());
+    return /^[0-9]/.test(camel) ? `Workflow_${camel}` : camel;
+}
+/** A Workflow's own declared App roles: `{ alias: { appId, role? } }`. */
+const appRoleSchema = z.record(z.string(), z.object({ appId: z.string(), role: z.string().optional() }));
+/**
+ * Resolve each declared App role to exactly one installed App: the same
+ * unambiguous match the Run dialog's own default picks for a person. A role
+ * with zero or more than one installed candidate has no single correct
+ * answer without a person choosing, so the caller withholds the whole row
+ * rather than guessing a binding.
+ */
+function resolveBindings(apps, installed) {
+    const bindings = {};
+    for (const [alias, spec] of Object.entries(apps)) {
+        const matches = installed.filter((app) => app.appId === spec.appId);
+        const [match] = matches;
+        if (matches.length !== 1 || match === undefined)
+            return null;
+        bindings[alias] = match.installationId;
+    }
+    return bindings;
+}
+async function listTools(indexes, workflows) {
+    const library = indexes?.libraryList();
+    if (!indexes || library?.kind !== "ready")
+        return { kind: "unindexed" };
+    // Read the Team's installed Apps once for every row, not once per row.
+    const catalog = workflows
+        ? catalogReplySchema.parse(await workflows.catalog({}))
+        : { error: "not_granted" };
+    const installed = "apps" in catalog
+        ? catalog.apps.map((app) => ({
+            installationId: app.installationId,
+            appId: app.appId,
+        }))
+        : [];
+    const tools = [];
+    for (const item of [...library.value.items].sort((a, b) => a.workflowId.localeCompare(b.workflowId))) {
+        const published = item.published;
+        if (published?.version == null)
+            continue;
+        // The immutable publication row written at publish; no Git is read here.
+        const row = indexes.publications.read(`${item.workflowId}:v${String(published.version)}`);
+        if (row.kind !== "ready" ||
+            row.value.workflowId !== item.workflowId ||
+            row.value.version !== published.version ||
+            row.value.commit !== published.commit)
+            return { kind: "unindexed" };
+        const definition = row.value.definition;
+        const apps = appRoleSchema.safeParse(definition.apps);
+        if (!apps.success)
+            continue;
+        const bindings = resolveBindings(apps.data, installed);
+        // No single correct binding today (a role is unmet or ambiguous): never
+        // guess one, so withhold this one Workflow's tool, not the whole family.
+        if (bindings === null)
+            continue;
+        tools.push({
+            workflowId: item.workflowId,
+            tool: toolName(item.workflowId),
+            title: definition.title,
+            description: definition.description ?? "",
+            version: published.version,
+            commit: published.commit,
+            input: definition.input,
+            output,
+            // The exact extra arguments a generic tool-family host merges with the
+            // caller's own `input` when it calls `runWorkflow`; see tool-contracts.
+            call: {
+                workflowId: item.workflowId,
+                version: published.version,
+                bindings,
+            },
+        });
+    }
+    return workflowToolListing.parse({ kind: "ready", tools });
+}
+export const toolFamilyMethods = {
+    listWorkflowTools: defineAppMethod({
+        description: "List typed tools from saved published Workflow versions; drafts are excluded.",
+        hidden: true,
+        effect: "read",
+        requires: ["workflow.run"],
+        input: z.strictObject({}),
+        output: workflowToolListing,
+        handler: (_input, context) => listTools(context.indexes, context.env.WORKFLOWS),
+    }),
+};

package/dist/shared/tool-contracts.js

@@ -0,0 +1,32 @@
+import * as z from "zod";
+import { gitSha1Schema } from "@fungi.computer/puffball/git-representation";
+import { workflowIdSchema } from "@fungi.computer/workflows-wire";
+/** Published inventory describes discovery, never grants authority to start a run. */
+export const workflowToolListing = z.union([
+    z.strictObject({ kind: z.literal("unindexed") }),
+    z.strictObject({
+        kind: z.literal("ready"),
+        tools: z
+            .array(z.strictObject({
+            workflowId: workflowIdSchema,
+            tool: z
+                .string()
+                .min(1)
+                .max(80)
+                .regex(/^[A-Za-z][A-Za-z0-9_]*$/),
+            title: z.string().max(120),
+            description: z.string().max(1000),
+            version: z.number().int().positive(),
+            commit: gitSha1Schema,
+            input: z.record(z.string(), z.json()),
+            output: z.record(z.string(), z.json()),
+            // Opaque to every generic tool-family host: the exact extra
+            // arguments this App wants merged with the caller's `input` when
+            // it dispatches to `runWorkflow` (its pinned workflowId, version
+            // and the App bindings resolved for this published version). A
+            // host spreads this verbatim; it never invents or defaults it.
+            call: z.record(z.string(), z.json()),
+        }))
+            .max(100),
+    }),
+]);

package/package.json

@@ -1,6 +1,169 @@
 {
   "name": "@fungi.computer/trellis",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
+  "description": "Trellis: build and run workflows of App methods, an App for Oyster",
+  "version": "0.0.1",
+  "author": "Levi <levi@technomancy.dev>",
+  "type": "module",
+  "exports": {
+    "./backend": "./backend/index.ts",
+    "./library": {
+      "types": "./backend/library.ts",
+      "import": "./dist/backend/library.js"
+    }
+  },
+  "dependencies": {
+    "@fungi.computer/puffball": "0.0.2",
+    "@cfworker/json-schema": "4.1.1",
+    "@fungi.computer/agar": "0.1.0",
+    "@fungi.computer/caps": "0.0.2",
+    "@fungi.computer/stipe": "0.0.1",
+    "@xyflow/react": "12.12.0",
+    "react": "18.3.1",
+    "react-dom": "18.3.1",
+    "@fungi.computer/braid": "0.0.1",
+    "effect": "4.0.2",
+    "@fungi.computer/sigils": "0.0.1",
+    "lucide-react": "0.460.0",
+    "zod": "4.4.3",
+    "@fungi.computer/workflows-wire": "0.0.1",
+    "@fungi.computer/cairn": "0.0.1",
+    "@fungi.computer/watchdog": "0.0.1",
+    "@fungi.computer/maosaico": "0.0.1"
+  },
+  "devDependencies": {
+    "@cloudflare/workers-types": "5.20260828.1",
+    "@ladle/react": "5.1.1",
+    "@tailwindcss/vite": "4.2.1",
+    "@types/react": "18.3.3",
+    "@types/react-dom": "18.3.0",
+    "@vitejs/plugin-react": "6.1.1",
+    "playwright": "1.62.1",
+    "typescript": "5.9.3",
+    "vite": "8.2.2",
+    "vite-plugin-singlefile": "2.3.3",
+    "vitest": "4.1.11",
+    "eslint": "10.9.1",
+    "tsx": "4.23.12",
+    "jsdom": "29.0.1",
+    "@types/node": "24.13.3"
+  },
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/fungi-computer/trellis.git"
+  },
+  "botanical": {
+    "role": "app",
+    "operations": {
+      "lint": "required",
+      "typecheck": "required",
+      "build": "required",
+      "test": "required",
+      "docs": {
+        "status": "not-applicable",
+        "reason": "Private first-party App"
+      },
+      "pack": {
+        "status": "not-applicable",
+        "reason": "Delivered as captured HTML"
+      },
+      "smoke": {
+        "status": "not-applicable",
+        "reason": "Browser proof exercises the App"
+      },
+      "stranger": {
+        "status": "not-applicable",
+        "reason": "Private first-party App"
+      }
+    }
+  },
+  "fungi": {
+    "backendDefinition": "backend/methods.ts",
+    "app": {
+      "displayName": "Trellis",
+      "icon": "run",
+      "capabilities": [
+        "computer.list",
+        "computer.readFile",
+        "computer.writeFile",
+        "media.generation",
+        "workflow.run",
+        "workflow.publish",
+        "workflow.arm",
+        "git.repository",
+        "agent.read"
+      ],
+      "handlers": [],
+      "roles": [],
+      "backend": {
+        "bindings": [
+          {
+            "name": "GIT",
+            "operations": [
+              "read",
+              "write",
+              "create",
+              "exchange"
+            ]
+          },
+          {
+            "name": "WORKFLOWS",
+            "operations": [
+              "catalog",
+              "runGraph",
+              "graphStatus",
+              "cancel",
+              "answerReview",
+              "armSchedule",
+              "disarmSchedule",
+              "schedules",
+              "armEventTrigger",
+              "disarmEventTrigger",
+              "eventTriggers",
+              "runs"
+            ]
+          },
+          {
+            "name": "INBOX",
+            "operations": [
+              "page"
+            ]
+          }
+        ]
+      }
+    },
+    "build": {
+      "react": true,
+      "stylesheets": [
+        "src/trellis.css"
+      ]
+    }
+  },
+  "files": [
+    "dist/backend",
+    "dist/shared",
+    "backend",
+    "shared",
+    "README.md",
+    "LICENSE"
+  ],
+  "scripts": {
+    "build": "vite build && tsc -p backend/tsconfig.build.json",
+    "typecheck": "tsc -p tsconfig.json --noEmit && tsc -p backend/tsconfig.json --noEmit",
+    "lint": "eslint src test backend --max-warnings=0",
+    "rebuild-copies": "node --import tsx scripts/rebuild-copies.mjs",
+    "test": "node --import tsx --test test/*.test.ts test/storyboard-method-pins.test.mjs && vitest run --config vitest.config.mjs test/main.test.tsx test/inspector.test.tsx test/use-draft.test.tsx test/review-card.test.tsx test/runs.test.tsx test/version-history.test.tsx test/portable-share.test.tsx test/review-output.test.tsx test/publish-controls.test.tsx",
+    "test:readiness:browser": "node test/editor-w4.browser.mjs && node test/readiness.browser.mjs",
+    "test:browser": "node test/workflows.browser.mjs",
+    "test:storyboard:browser": "node test/storyboard.browser.mjs",
+    "format:check": "node ../../tooling/repository/scripts/format-package-check.mjs",
+    "lint:anti-slop": "node ../../tooling/repository/scripts/lint-package-anti-slop.mjs",
+    "test:nightly": "WORKFLOW_EVIDENCE=.botanical/workflows bash ../../.agents/skills/orchestrate-multi-lane-work/scripts/run-proof.sh node test/workflows.browser.mjs && pnpm run test:history:browser",
+    "test:editor:browser": "node test/editor.browser.mjs && node test/editor-w4.browser.mjs",
+    "test:generic:browser": "node test/workflows-generic.browser.mjs",
+    "test:nested:browser": "node test/nested-fields.browser.mjs",
+    "test:graph:browser": "node test/graph-story.browser.mjs",
+    "test:history:browser": "node --import tsx test/history.browser.mjs",
+    "test:layout:browser": "node test/layout.browser.mjs"
+  }
 }

package/shared/tool-contracts.ts

@@ -0,0 +1,35 @@
+import * as z from "zod";
+import { gitSha1Schema } from "@fungi.computer/puffball/git-representation";
+import { workflowIdSchema } from "@fungi.computer/workflows-wire";
+
+/** Published inventory describes discovery, never grants authority to start a run. */
+export const workflowToolListing = z.union([
+  z.strictObject({ kind: z.literal("unindexed") }),
+  z.strictObject({
+    kind: z.literal("ready"),
+    tools: z
+      .array(
+        z.strictObject({
+          workflowId: workflowIdSchema,
+          tool: z
+            .string()
+            .min(1)
+            .max(80)
+            .regex(/^[A-Za-z][A-Za-z0-9_]*$/),
+          title: z.string().max(120),
+          description: z.string().max(1000),
+          version: z.number().int().positive(),
+          commit: gitSha1Schema,
+          input: z.record(z.string(), z.json()),
+          output: z.record(z.string(), z.json()),
+          // Opaque to every generic tool-family host: the exact extra
+          // arguments this App wants merged with the caller's `input` when
+          // it dispatches to `runWorkflow` (its pinned workflowId, version
+          // and the App bindings resolved for this published version). A
+          // host spreads this verbatim; it never invents or defaults it.
+          call: z.record(z.string(), z.json()),
+        }),
+      )
+      .max(100),
+  }),
+]);