@sweny-ai/core 0.1.54 → 0.1.56

package/dist/cli/config.test.js

@@ -1,5 +1,5 @@
 import { describe, it, expect } from "vitest";
-import { validateInputs } from "./config.js";
+import { validateInputs, parseCliInputs } from "./config.js";
 /**
  * Focused tests for validateInputs() — specifically the notification-provider
  * switch. Regressions here break every `swenyai/triage` action run because
@@ -65,6 +65,9 @@ function baseConfig(overrides = {}) {
         workspaceTools: [],
         rules: [],
         context: [],
+        offline: false,
+        fetchAuth: {},
+        cloudToken: "",
         ...overrides,
     };
 }
@@ -109,3 +112,64 @@ describe("validateInputs — notification provider", () => {
         expect(err).toContain("console");
     });
 });
+describe("fetch.auth + offline parsing", () => {
+    it("parses offline flag", () => {
+        const config = parseCliInputs({ offline: true }, {});
+        expect(config.offline).toBe(true);
+    });
+    it("defaults fetchAuth to {} and offline to false", () => {
+        const config = parseCliInputs({}, {});
+        expect(config.offline).toBe(false);
+        expect(config.fetchAuth).toEqual({});
+    });
+    it("parses fetch.auth from file config", () => {
+        const config = parseCliInputs({}, { "fetch.auth": { "api.example.com": "MY_TOKEN" } });
+        expect(config.fetchAuth).toEqual({ "api.example.com": "MY_TOKEN" });
+    });
+});
+describe("parseCliInputs — cloud token", () => {
+    it("reads SWENY_CLOUD_TOKEN from env", () => {
+        const original = process.env.SWENY_CLOUD_TOKEN;
+        process.env.SWENY_CLOUD_TOKEN = "sweny_pk_test123";
+        try {
+            const config = parseCliInputs({});
+            expect(config.cloudToken).toBe("sweny_pk_test123");
+        }
+        finally {
+            if (original === undefined)
+                delete process.env.SWENY_CLOUD_TOKEN;
+            else
+                process.env.SWENY_CLOUD_TOKEN = original;
+        }
+    });
+    it("reads cloud-token from config file", () => {
+        const config = parseCliInputs({}, { "cloud-token": "sweny_pk_fromfile" });
+        expect(config.cloudToken).toBe("sweny_pk_fromfile");
+    });
+    it("env var overrides config file", () => {
+        const original = process.env.SWENY_CLOUD_TOKEN;
+        process.env.SWENY_CLOUD_TOKEN = "sweny_pk_env";
+        try {
+            const config = parseCliInputs({}, { "cloud-token": "sweny_pk_file" });
+            expect(config.cloudToken).toBe("sweny_pk_env");
+        }
+        finally {
+            if (original === undefined)
+                delete process.env.SWENY_CLOUD_TOKEN;
+            else
+                process.env.SWENY_CLOUD_TOKEN = original;
+        }
+    });
+    it("defaults to empty string", () => {
+        const original = process.env.SWENY_CLOUD_TOKEN;
+        delete process.env.SWENY_CLOUD_TOKEN;
+        try {
+            const config = parseCliInputs({});
+            expect(config.cloudToken).toBe("");
+        }
+        finally {
+            if (original !== undefined)
+                process.env.SWENY_CLOUD_TOKEN = original;
+        }
+    });
+});

package/dist/cli/e2e.js

@@ -830,9 +830,11 @@ export async function runE2eRun(options) {
             runResults.push({ file: fileName, passed: false });
             continue;
         }
-        // Replace template vars in node instructions
+        // Replace template vars in node instructions (e2e workflows always use string instructions)
         for (const node of Object.values(workflow.nodes)) {
-            node.instruction = resolveTemplateVars(node.instruction, vars);
+            if (typeof node.instruction === "string") {
+                node.instruction = resolveTemplateVars(node.instruction, vars);
+            }
         }
         // Build skills + Claude client
         const skills = createSkillMap(configuredSkills(process.env, cwd));

package/dist/cli/e2e.test.js

@@ -247,7 +247,13 @@ describe("buildFlowNodes", () => {
                 const { nodes } = buildFlowNodes(flow);
                 for (const [id, node] of Object.entries(nodes)) {
                     expect(node.name, `${id}.name`).toBeTruthy();
-                    expect(node.instruction.length, `${id}.instruction`).toBeGreaterThan(0);
+                    const instr = node.instruction;
+                    if (typeof instr === "string") {
+                        expect(instr.length, `${id}.instruction`).toBeGreaterThan(0);
+                    }
+                    else {
+                        expect(instr, `${id}.instruction`).toBeTruthy();
+                    }
                     expect(Array.isArray(node.skills), `${id}.skills`).toBe(true);
                 }
             });
@@ -607,7 +613,8 @@ describe("template variable completeness — all {vars} in instructions are reso
         it(`${flow.type}: all template vars in instructions resolve to values`, () => {
             const wf = buildFlowWorkflow(flow, "http://localhost:3000");
             for (const [nodeId, node] of Object.entries(wf.nodes)) {
-                const resolved = resolveTemplateVars(node.instruction, vars);
+                const instrText = typeof node.instruction === "string" ? node.instruction : "";
+                const resolved = resolveTemplateVars(instrText, vars);
                 // After resolution, no {word} placeholders should remain
                 // (except for agent-browser refs like @<ref> which are not {vars})
                 const unresolvedVars = resolved.match(/\{(\w+)\}/g) || [];

package/dist/cli/main.js

@@ -29,6 +29,7 @@ import { c, formatBanner, getStepDetails, formatStepLine, formatDagResultHuman,
 import { checkProviderConnectivity } from "./check.js";
 import { registerSetupCommand } from "./setup.js";
 import { registerPublishCommand } from "./publish.js";
+import { reportToCloud } from "./cloud-report.js";
 // ── Stream observer (NDJSON) ────────────────────────────────────────
 /**
  * Create an observer that writes NDJSON ExecutionEvents to stdout.
@@ -133,7 +134,7 @@ function buildProviderCtx(config, mcpServers) {
 }
 /**
  * Resolve rules and context from config into structured workflow input fields.
- * Local files + inline text are resolved now; URLs are passed to the prepare node.
+ * All source kinds (inline, file, URL) are resolved eagerly.
  */
 async function resolveRulesAndContext(config) {
     const [rulesResult, contextResult] = await Promise.all([
@@ -143,8 +144,6 @@ async function resolveRulesAndContext(config) {
     return {
         rules: rulesResult.resolved,
         context: contextResult.resolved,
-        rulesUrls: rulesResult.urls,
-        contextUrls: contextResult.urls,
     };
 }
 // ── sweny triage ──────────────────────────────────────────────────────
@@ -297,7 +296,7 @@ triageCmd.action(async (options) => {
     const observer = composeObservers(progressObserver, config.stream ? createStreamObserver() : undefined);
     // ── Build workflow input from config ──────────────────────
     const providerCtx = buildProviderCtx(config, mcpServers);
-    const { rules, context, rulesUrls, contextUrls } = await resolveRulesAndContext(config);
+    const { rules, context } = await resolveRulesAndContext(config);
     // Combine provider context + additional instructions into the context field
     const contextParts = [providerCtx];
     if (config.additionalInstructions)
@@ -324,12 +323,9 @@ triageCmd.action(async (options) => {
         ...(config.observabilityCredentials.tableName && {
             betterstackTableName: config.observabilityCredentials.tableName,
         }),
-        // Structured rules/context for executor
+        // Structured rules/context for executor (URLs resolved eagerly by loadAdditionalContext)
         rules,
         context: fullContext,
-        // URLs for the prepare node to fetch at runtime
-        rulesUrls,
-        contextUrls,
     };
     try {
         const { results, trace } = await execute(triageWorkflow, workflowInput, {
@@ -337,6 +333,10 @@ triageCmd.action(async (options) => {
             claude,
             observer,
             logger: consoleLogger,
+            cwd: process.cwd(),
+            env: process.env,
+            fetchAuth: config.fetchAuth,
+            offline: config.offline,
         });
         const durationMs = Date.now() - runStart;
         // Output
@@ -360,6 +360,13 @@ triageCmd.action(async (options) => {
                 console.error(c.subtle(`  ⚠ could not write GITHUB_STEP_SUMMARY: ${err instanceof Error ? err.message : err}`));
             }
         }
+        // Report to SWEny Cloud (best-effort, never block the run)
+        try {
+            await reportToCloud(results, durationMs, config, "triage");
+        }
+        catch {
+            // silent — cloud reporting is optional
+        }
         // Terminal bell
         if (config.bell)
             process.stderr.write("\x07");
@@ -420,6 +427,7 @@ implementCmd.action(async (issueId, options) => {
         mcpServers,
     });
     console.log(chalk.cyan(`\n  sweny implement ${issueId}\n`));
+    const implRunStart = Date.now();
     const isTTY = process.stderr.isTTY ?? false;
     const implProgressObserver = (event) => {
         switch (event.type) {
@@ -451,7 +459,7 @@ implementCmd.action(async (issueId, options) => {
     const observer = composeObservers(implProgressObserver, Boolean(options.stream) ? createStreamObserver() : undefined);
     // Resolve rules/context from .sweny.yml (same as triage path)
     const providerCtx = buildProviderCtx(config, mcpServers);
-    const { rules, context, rulesUrls, contextUrls } = await resolveRulesAndContext(config);
+    const { rules, context } = await resolveRulesAndContext(config);
     const implContextParts = [providerCtx];
     if (config.additionalInstructions)
         implContextParts.push(config.additionalInstructions);
@@ -468,8 +476,6 @@ implementCmd.action(async (issueId, options) => {
         // Structured rules/context for executor
         rules,
         context: fullImplContext,
-        rulesUrls,
-        contextUrls,
     };
     try {
         const { results } = await execute(implementWorkflow, workflowInput, {
@@ -477,6 +483,10 @@ implementCmd.action(async (issueId, options) => {
             claude,
             observer,
             logger: consoleLogger,
+            cwd: process.cwd(),
+            env: process.env,
+            fetchAuth: config.fetchAuth,
+            offline: config.offline,
         });
         const hasFailed = [...results.values()].some((r) => r.status === "failed");
         if (hasFailed) {
@@ -491,6 +501,13 @@ implementCmd.action(async (issueId, options) => {
         else {
             console.log(chalk.green(`\n  Implement workflow completed\n`));
         }
+        // Report to SWEny Cloud (best-effort)
+        try {
+            await reportToCloud(results, Date.now() - implRunStart, config, "implement");
+        }
+        catch {
+            // silent
+        }
         process.exit(0);
     }
     catch (err) {
@@ -540,6 +557,7 @@ export async function workflowRunAction(file, options) {
         }
         process.exit(0);
     }
+    const runStart = Date.now();
     const fileConfig = loadConfigFile();
     const config = parseCliInputs(options, fileConfig);
     const isJson = Boolean(options.json);
@@ -659,6 +677,10 @@ export async function workflowRunAction(file, options) {
             claude,
             observer,
             logger: consoleLogger,
+            cwd: process.cwd(),
+            env: process.env,
+            fetchAuth: config.fetchAuth,
+            offline: config.offline,
         });
         if (isJson) {
             process.stdout.write(JSON.stringify(Object.fromEntries(results), null, 2) + "\n");
@@ -674,6 +696,13 @@ export async function workflowRunAction(file, options) {
             }
             process.stdout.write(toMermaidBlock(workflow, { state, trace, title: workflow.name }) + "\n");
         }
+        // Report to SWEny Cloud (best-effort)
+        try {
+            await reportToCloud(results, Date.now() - runStart, config, workflow.id);
+        }
+        catch {
+            // silent
+        }
         const hasFailed = [...results.values()].some((r) => r.status === "failed");
         if (hasFailed) {
             console.error(chalk.red(`  Workflow failed\n`));
@@ -804,9 +833,12 @@ workflowCmd
     .action(workflowExportAction);
 workflowCmd
     .command("create <description>")
-    .description("Generate a new workflow from a natural language description")
+    .description("[DEPRECATED] Use `sweny new` and pick 'Describe your own'")
     .option("--json", "Output workflow JSON to stdout (no interactive prompt)")
     .action(async (description, options) => {
+    if (!options.json) {
+        console.warn("\x1B[33m  ⚠  `sweny workflow create` is deprecated. Use `sweny new` instead.\x1B[0m\n");
+    }
     const skills = configuredSkills();
     const claude = new ClaudeClient({
         maxTurns: 3,

package/dist/cli/output.test.js

@@ -44,6 +44,7 @@ function fakeTrace(steps) {
             iteration: s.iteration ?? 1,
         })),
         edges: [],
+        sources: {},
     };
 }
 describe("formatDagResultMarkdown", () => {

package/dist/cli/publish.test.d.ts

@@ -0,0 +1 @@
+export {};