libretto 0.6.30 → 0.6.32

package/dist/cli/commands/cloud-credentials.js

@@ -1,18 +1,7 @@
 import { SimpleCLI } from "affordance";
-import { orpcCall, resolveApiUrl } from "../core/auth-fetch.js";
+import { orpcCall } from "../core/auth-fetch.js";
+import { withCloudApiKey } from "./shared.js";
 const CLOUD_CREDENTIAL_ENV_PREFIX = "LIBRETTO_CLOUD_";
-function requireApiKeyCredential() {
-  const apiKey = process.env.LIBRETTO_API_KEY?.trim();
-  if (!apiKey) {
-    throw new Error(
-      "LIBRETTO_API_KEY is required to manage Libretto Cloud credentials. Issue one with `libretto cloud auth api-key issue --label <label>`."
-    );
-  }
-  return {
-    apiUrl: resolveApiUrl(null),
-    credential: { source: "env-api-key", apiKey }
-  };
-}
 function parseEnvCredentials(prefix) {
   const credentials = {};
   for (const [key, value] of Object.entries(process.env)) {
@@ -29,22 +18,21 @@ const pushCredentialCommand = SimpleCLI.command({
 }).input(SimpleCLI.input({
   positionals: [],
   named: {}
-})).handle(async () => {
+})).use(withCloudApiKey("manage Libretto Cloud credentials")).handle(async ({ ctx }) => {
   const credentials = parseEnvCredentials(CLOUD_CREDENTIAL_ENV_PREFIX);
   if (credentials.length === 0) {
     throw new Error(
       `No non-empty env vars found with prefix ${CLOUD_CREDENTIAL_ENV_PREFIX}.`
     );
   }
-  const { apiUrl, credential } = requireApiKeyCredential();
   let created = 0;
   let updated = 0;
   for (const item of credentials) {
     const response = await orpcCall({
-      apiUrl,
+      apiUrl: ctx.apiUrl,
       path: "/v1/credentials/upsert",
       input: item,
-      credential
+      credential: ctx.credential
     });
     if (response.overwritten) {
       updated += 1;

package/dist/cli/commands/cloud-jobs.js

@@ -0,0 +1,118 @@
+import { readFileSync } from "node:fs";
+import { z } from "zod";
+import { SimpleCLI } from "affordance";
+import { orpcCall } from "../core/auth-fetch.js";
+import { withCloudApiKey } from "./shared.js";
+const createJobUsage = "Usage: libretto cloud jobs create <workflow> [--params <json> | --params-file <path>]";
+function parseJsonObject(label, raw) {
+  let parsed;
+  try {
+    parsed = JSON.parse(raw);
+  } catch (error) {
+    throw new Error(
+      `Invalid JSON in ${label}: ${error instanceof Error ? error.message : String(error)}`
+    );
+  }
+  if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+    throw new Error(`${label} must be a JSON object.`);
+  }
+  return parsed;
+}
+function readJsonObjectFile(label, filePath) {
+  let content;
+  try {
+    content = readFileSync(filePath, "utf8");
+  } catch {
+    throw new Error(
+      `Could not read ${label} "${filePath}". Ensure the file exists and is readable.`
+    );
+  }
+  return parseJsonObject(label, content);
+}
+const createCloudJobInput = SimpleCLI.input({
+  positionals: [
+    SimpleCLI.positional("workflow", z.string().optional(), {
+      help: "Deployed workflow name to run"
+    })
+  ],
+  named: {
+    params: SimpleCLI.option(z.string().optional(), {
+      help: "Inline JSON params object"
+    }),
+    paramsFile: SimpleCLI.option(z.string().optional(), {
+      name: "params-file",
+      help: "Path to a JSON params file"
+    }),
+    credentialId: SimpleCLI.option(z.string().optional(), {
+      name: "credential-id",
+      help: "Stored cloud credential id to pass to the workflow"
+    }),
+    timeoutSeconds: SimpleCLI.option(z.coerce.number().int().min(1).optional(), {
+      name: "timeout-seconds",
+      help: "Job timeout in seconds"
+    }),
+    callbackUrl: SimpleCLI.option(z.string().optional(), {
+      name: "callback-url",
+      help: "Per-job callback URL"
+    }),
+    callbackSecret: SimpleCLI.option(z.string().optional(), {
+      name: "callback-secret",
+      help: "Secret used to sign the per-job callback"
+    }),
+    skipCallbacks: SimpleCLI.flag({
+      name: "skip-callbacks",
+      help: "Skip stored webhook callbacks for this job"
+    }),
+    residentialProxy: SimpleCLI.option(z.string().optional(), {
+      name: "residential-proxy",
+      help: "Residential proxy config as a JSON object"
+    })
+  }
+}).refine((input) => Boolean(input.workflow), createJobUsage).refine(
+  (input) => !(input.params && input.paramsFile),
+  "Pass either --params or --params-file, not both."
+).refine(
+  (input) => !input.callbackUrl && !input.callbackSecret || Boolean(input.callbackUrl && input.callbackSecret),
+  "Pass both --callback-url and --callback-secret, or omit both."
+);
+const createCloudJobCommand = SimpleCLI.command({
+  description: "Create a Libretto Cloud job for a deployed workflow"
+}).input(createCloudJobInput).use(withCloudApiKey("create Libretto Cloud jobs")).handle(async ({ input, ctx }) => {
+  const params = input.paramsFile ? readJsonObjectFile("--params-file", input.paramsFile) : input.params ? parseJsonObject("--params", input.params) : {};
+  const residentialProxy = input.residentialProxy ? parseJsonObject("--residential-proxy", input.residentialProxy) : void 0;
+  const payload = {
+    workflow: input.workflow,
+    params
+  };
+  if (input.credentialId) payload.credential_id = input.credentialId;
+  if (input.timeoutSeconds !== void 0) {
+    payload.timeout_seconds = input.timeoutSeconds;
+  }
+  if (input.callbackUrl) payload.callback_url = input.callbackUrl;
+  if (input.callbackSecret) payload.callback_secret = input.callbackSecret;
+  if (input.skipCallbacks) payload.skip_callbacks = true;
+  if (residentialProxy !== void 0) {
+    payload.residential_proxy = residentialProxy;
+  }
+  const response = await orpcCall({
+    apiUrl: ctx.apiUrl,
+    path: "/v1/jobs/create",
+    input: payload,
+    credential: ctx.credential
+  });
+  console.log(`Job created: ${response.job_id}`);
+  console.log(`Status: ${response.status}`);
+  console.log(response.message);
+  return response.job_id;
+});
+const cloudJobCommands = SimpleCLI.group({
+  description: "Create and manage hosted jobs",
+  routes: {
+    create: createCloudJobCommand
+  }
+});
+export {
+  cloudJobCommands,
+  createCloudJobCommand,
+  createCloudJobInput
+};

package/dist/cli/commands/cloud-schedules.js

@@ -0,0 +1,128 @@
+import { readFileSync } from "node:fs";
+import { z } from "zod";
+import { SimpleCLI } from "affordance";
+import { orpcCall } from "../core/auth-fetch.js";
+import { withCloudApiKey } from "./shared.js";
+const createScheduleUsage = "Usage: libretto cloud schedules create <workflow> --cron <expr> [--params <json> | --params-file <path>]";
+function parseJsonObject(label, raw) {
+  let parsed;
+  try {
+    parsed = JSON.parse(raw);
+  } catch (error) {
+    throw new Error(
+      `Invalid JSON in ${label}: ${error instanceof Error ? error.message : String(error)}`
+    );
+  }
+  if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+    throw new Error(`${label} must be a JSON object.`);
+  }
+  return parsed;
+}
+function readJsonObjectFile(label, filePath) {
+  let content;
+  try {
+    content = readFileSync(filePath, "utf8");
+  } catch {
+    throw new Error(
+      `Could not read ${label} "${filePath}". Ensure the file exists and is readable.`
+    );
+  }
+  return parseJsonObject(label, content);
+}
+const createCloudScheduleInput = SimpleCLI.input({
+  positionals: [
+    SimpleCLI.positional("workflow", z.string().optional(), {
+      help: "Deployed workflow name to schedule"
+    })
+  ],
+  named: {
+    cron: SimpleCLI.option(z.string().optional(), {
+      help: "Standard 5-field cron expression"
+    }),
+    timezone: SimpleCLI.option(z.string().optional(), {
+      help: "IANA timezone name (default: UTC)"
+    }),
+    params: SimpleCLI.option(z.string().optional(), {
+      help: "Inline JSON params object"
+    }),
+    paramsFile: SimpleCLI.option(z.string().optional(), {
+      name: "params-file",
+      help: "Path to a JSON params file"
+    }),
+    timeoutSeconds: SimpleCLI.option(z.coerce.number().int().min(1).optional(), {
+      name: "timeout-seconds",
+      help: "Job timeout in seconds for each schedule fire"
+    }),
+    callbackUrl: SimpleCLI.option(z.string().optional(), {
+      name: "callback-url",
+      help: "Per-schedule callback URL"
+    }),
+    callbackSecret: SimpleCLI.option(z.string().optional(), {
+      name: "callback-secret",
+      help: "Secret used to sign per-schedule callbacks"
+    }),
+    skipCallbacks: SimpleCLI.flag({
+      name: "skip-callbacks",
+      help: "Skip stored webhook callbacks for jobs created by this schedule"
+    }),
+    residentialProxy: SimpleCLI.option(z.string().optional(), {
+      name: "residential-proxy",
+      help: "Residential proxy config as a JSON object"
+    }),
+    disabled: SimpleCLI.flag({
+      help: "Create the schedule disabled"
+    })
+  }
+}).refine((input) => Boolean(input.workflow && input.cron), createScheduleUsage).refine(
+  (input) => !(input.params && input.paramsFile),
+  "Pass either --params or --params-file, not both."
+).refine(
+  (input) => !input.callbackUrl && !input.callbackSecret || Boolean(input.callbackUrl && input.callbackSecret),
+  "Pass both --callback-url and --callback-secret, or omit both."
+);
+const createCloudScheduleCommand = SimpleCLI.command({
+  description: "Create a recurring schedule for a deployed workflow"
+}).input(createCloudScheduleInput).use(withCloudApiKey("create Libretto Cloud schedules")).handle(async ({ input, ctx }) => {
+  const params = input.paramsFile ? readJsonObjectFile("--params-file", input.paramsFile) : input.params ? parseJsonObject("--params", input.params) : {};
+  const residentialProxy = input.residentialProxy ? parseJsonObject("--residential-proxy", input.residentialProxy) : void 0;
+  const payload = {
+    workflow: input.workflow,
+    cron_expr: input.cron,
+    timezone: input.timezone ?? "UTC",
+    params,
+    enabled: !input.disabled
+  };
+  if (input.timeoutSeconds !== void 0) {
+    payload.timeout_seconds = input.timeoutSeconds;
+  }
+  if (input.callbackUrl) payload.callback_url = input.callbackUrl;
+  if (input.callbackSecret) payload.callback_secret = input.callbackSecret;
+  if (input.skipCallbacks) payload.skip_callbacks = true;
+  if (residentialProxy !== void 0) {
+    payload.residential_proxy = residentialProxy;
+  }
+  const response = await orpcCall({
+    apiUrl: ctx.apiUrl,
+    path: "/v1/schedules/create",
+    input: payload,
+    credential: ctx.credential
+  });
+  const { schedule } = response;
+  console.log(`Schedule created: ${schedule.id}`);
+  console.log(`Workflow: ${schedule.workflow}`);
+  console.log(`Cron: ${schedule.cron_expr} (${schedule.timezone})`);
+  console.log(`Next fire: ${schedule.next_fire_at}`);
+  console.log(`Enabled: ${schedule.enabled ? "yes" : "no"}`);
+  return schedule.id;
+});
+const cloudScheduleCommands = SimpleCLI.group({
+  description: "Create and manage hosted schedules",
+  routes: {
+    create: createCloudScheduleCommand
+  }
+});
+export {
+  cloudScheduleCommands,
+  createCloudScheduleCommand,
+  createCloudScheduleInput
+};

package/dist/cli/commands/cloud-settings.js

@@ -0,0 +1,75 @@
+import { z } from "zod";
+import { SimpleCLI } from "affordance";
+import { orpcCall } from "../core/auth-fetch.js";
+import { withCloudApiKey } from "./shared.js";
+const settingState = z.enum(["enabled", "disabled"]);
+function toBoolean(state) {
+  return state === "enabled";
+}
+function printTenantSettings(settings) {
+  const notificationsEnabled = !settings.disable_job_failure_notifications;
+  console.log(
+    `Code sharing: ${settings.code_sharing_enabled ? "enabled" : "disabled"}`
+  );
+  console.log(
+    `Job failure notifications: ${notificationsEnabled ? "enabled" : "disabled"}`
+  );
+  console.log(
+    `Notification recipient: ${settings.debug_notification_email ?? "not configured"}`
+  );
+  return settings;
+}
+async function tenantSettings(ctx, input = {}) {
+  return orpcCall({
+    apiUrl: ctx.apiUrl,
+    path: "/v1/tenant/settings",
+    input,
+    credential: ctx.credential
+  });
+}
+const settingsStatusCommand = SimpleCLI.command({
+  description: "Show Libretto Cloud tenant settings"
+}).input(SimpleCLI.input({ positionals: [], named: {} })).use(withCloudApiKey("manage Libretto Cloud settings")).handle(async ({ ctx }) => printTenantSettings(await tenantSettings(ctx)));
+const setSettingsCommand = SimpleCLI.command({
+  description: "Update one or more Libretto Cloud tenant settings"
+}).input(
+  SimpleCLI.input({
+    positionals: [],
+    named: {
+      codeSharing: SimpleCLI.option(settingState.optional(), {
+        help: "Set tenant code sharing: enabled or disabled"
+      }),
+      jobFailureNotifications: SimpleCLI.option(settingState.optional(), {
+        help: "Set hosted job failure notification emails: enabled or disabled"
+      })
+    }
+  })
+).use(withCloudApiKey("manage Libretto Cloud settings")).handle(async ({ input, ctx }) => {
+  const updates = {};
+  if (input.codeSharing !== void 0) {
+    updates.code_sharing_enabled = toBoolean(input.codeSharing);
+  }
+  if (input.jobFailureNotifications !== void 0) {
+    updates.disable_job_failure_notifications = !toBoolean(
+      input.jobFailureNotifications
+    );
+  }
+  if (Object.keys(updates).length === 0) {
+    throw new Error(
+      "No settings provided. Use one or more flags, for example `libretto cloud settings set --code-sharing enabled --job-failure-notifications disabled`."
+    );
+  }
+  return printTenantSettings(await tenantSettings(ctx, updates));
+});
+const settingsCommands = SimpleCLI.group({
+  description: "Manage Libretto Cloud tenant settings",
+  routes: {
+    status: settingsStatusCommand,
+    set: setSettingsCommand
+  }
+});
+export {
+  setSettingsCommand,
+  settingsCommands,
+  settingsStatusCommand
+};

package/dist/cli/commands/cloud-sharing.js

@@ -1,18 +1,7 @@
 import { z } from "zod";
 import { SimpleCLI } from "affordance";
-import { orpcCall, resolveApiUrl } from "../core/auth-fetch.js";
-function requireCloudApiKey() {
-  const apiKey = process.env.LIBRETTO_API_KEY?.trim();
-  if (!apiKey) {
-    throw new Error(
-      "LIBRETTO_API_KEY is required to share Libretto Cloud workflow code. Issue one with `libretto cloud auth api-key issue --label <label>`."
-    );
-  }
-  return {
-    apiUrl: resolveApiUrl(null),
-    credential: { source: "env-api-key", apiKey }
-  };
-}
+import { orpcCall } from "../core/auth-fetch.js";
+import { withCloudApiKey } from "./shared.js";
 const shareWorkflowCommand = SimpleCLI.command({
   description: "Share one hosted workflow's code publicly"
 }).input(SimpleCLI.input({
@@ -26,13 +15,12 @@ const shareWorkflowCommand = SimpleCLI.command({
       help: "Refresh an existing share from the workflow's current deployment"
     })
   }
-})).handle(async ({ input }) => {
-  const { apiUrl, credential } = requireCloudApiKey();
+})).use(withCloudApiKey("share Libretto Cloud workflow code")).handle(async ({ input, ctx }) => {
   const response = await orpcCall({
-    apiUrl,
+    apiUrl: ctx.apiUrl,
     path: "/v1/workflows/share",
     input: { workflow: input.workflow, refresh: input.refresh },
-    credential
+    credential: ctx.credential
   });
   if (response.status === "existing") {
     console.log(`Workflow is already shared: ${response.workflow}`);
@@ -48,34 +36,32 @@ const shareWorkflowCommand = SimpleCLI.command({
 });
 const codeSharingStatusCommand = SimpleCLI.command({
   description: "Show whether tenant code sharing is enabled"
-}).input(SimpleCLI.input({ positionals: [], named: {} })).handle(async () => {
-  const { apiUrl, credential } = requireCloudApiKey();
+}).input(SimpleCLI.input({ positionals: [], named: {} })).use(withCloudApiKey("manage tenant workflow code sharing")).handle(async ({ ctx }) => {
   const response = await orpcCall({
-    apiUrl,
+    apiUrl: ctx.apiUrl,
     path: "/v1/tenant/codeSharing",
     input: {},
-    credential
+    credential: ctx.credential
   });
   console.log(`Code sharing: ${response.enabled ? "enabled" : "disabled"}`);
   return response.enabled;
 });
-async function updateCodeSharing(enabled) {
-  const { apiUrl, credential } = requireCloudApiKey();
+async function updateCodeSharing(enabled, ctx) {
   const response = await orpcCall({
-    apiUrl,
+    apiUrl: ctx.apiUrl,
     path: "/v1/tenant/updateCodeSharing",
     input: { enabled },
-    credential
+    credential: ctx.credential
   });
   console.log(`Code sharing: ${response.enabled ? "enabled" : "disabled"}`);
   return response.enabled;
 }
 const enableCodeSharingCommand = SimpleCLI.command({
   description: "Enable public workflow code sharing for this tenant"
-}).input(SimpleCLI.input({ positionals: [], named: {} })).handle(async () => updateCodeSharing(true));
+}).input(SimpleCLI.input({ positionals: [], named: {} })).use(withCloudApiKey("manage tenant workflow code sharing")).handle(async ({ ctx }) => updateCodeSharing(true, ctx));
 const disableCodeSharingCommand = SimpleCLI.command({
   description: "Disable public workflow code sharing for this tenant"
-}).input(SimpleCLI.input({ positionals: [], named: {} })).handle(async () => updateCodeSharing(false));
+}).input(SimpleCLI.input({ positionals: [], named: {} })).use(withCloudApiKey("manage tenant workflow code sharing")).handle(async ({ ctx }) => updateCodeSharing(false, ctx));
 const codeSharingCommands = SimpleCLI.group({
   description: "Manage tenant workflow code sharing",
   routes: {

package/dist/cli/commands/deploy.js

@@ -1,14 +1,12 @@
 import { randomBytes } from "node:crypto";
 import { z } from "zod";
-import {
-  orpcCall,
-  resolveApiUrl
-} from "../core/auth-fetch.js";
+import { orpcCall } from "../core/auth-fetch.js";
 import {
   buildHostedDeployTarball
 } from "../core/deploy-artifact.js";
 import { readAuthState } from "../core/auth-storage.js";
 import { SimpleCLI } from "affordance";
+import { withCloudApiKey } from "./shared.js";
 function generateDeploymentName() {
   return `deploy-${Date.now().toString(36)}-${randomBytes(4).toString("hex")}`;
 }
@@ -30,16 +28,6 @@ function deployApiKeyRequiredMessage(hasStoredSession) {
     "  \u2022 Add it to your project .env file: `LIBRETTO_API_KEY=<issued-key>`."
   ].join("\n");
 }
-async function requireDeployApiKey() {
-  const apiKey = process.env.LIBRETTO_API_KEY?.trim();
-  if (!apiKey) {
-    throw new Error(deployApiKeyRequiredMessage(await hasStoredCloudSession()));
-  }
-  return {
-    apiUrl: resolveApiUrl(null),
-    credential: { source: "env-api-key", apiKey }
-  };
-}
 async function hasStoredCloudSession() {
   try {
     return Boolean((await readAuthState())?.session);
@@ -130,8 +118,11 @@ const deployInput = SimpleCLI.input({
 });
 const deployCommand = SimpleCLI.command({
   description: "Deploy workflows to the hosted platform"
-}).input(deployInput).handle(async ({ input }) => {
-  const { apiUrl, credential } = await requireDeployApiKey();
+}).input(deployInput).use(withCloudApiKey(
+  "deploy to Libretto Cloud",
+  async () => deployApiKeyRequiredMessage(await hasStoredCloudSession())
+)).handle(async ({ input, ctx }) => {
+  const { apiUrl, credential } = ctx;
   const deploymentName = generateDeploymentName();
   console.log("Bundling hosted deployment artifact...");
   const { entryPoint, source, workflows } = await buildHostedDeployTarball({

package/dist/cli/commands/profiles.js

@@ -1,28 +1,16 @@
 import { z } from "zod";
 import { SimpleCLI } from "affordance";
-import { orpcCall, resolveApiUrl } from "../core/auth-fetch.js";
+import { orpcCall } from "../core/auth-fetch.js";
 import { normalizeProfileName } from "../core/profiles.js";
-function requireApiKeyCredential() {
-  const apiKey = process.env.LIBRETTO_API_KEY?.trim();
-  if (!apiKey) {
-    throw new Error(
-      "LIBRETTO_API_KEY is required to manage Libretto Cloud profiles. Issue one with `libretto cloud auth api-key issue --label <label>`."
-    );
-  }
-  return {
-    apiUrl: resolveApiUrl(null),
-    credential: { source: "env-api-key", apiKey }
-  };
-}
+import { withCloudApiKey } from "./shared.js";
 const listProfilesCommand = SimpleCLI.command({
   description: "List Libretto Cloud auth profiles"
-}).input(SimpleCLI.input({ positionals: [], named: {} })).handle(async () => {
-  const { apiUrl, credential } = requireApiKeyCredential();
+}).input(SimpleCLI.input({ positionals: [], named: {} })).use(withCloudApiKey("manage Libretto Cloud profiles")).handle(async ({ ctx }) => {
   const response = await orpcCall({
-    apiUrl,
+    apiUrl: ctx.apiUrl,
     path: "/v1/browserProfiles/list",
     input: {},
-    credential
+    credential: ctx.credential
   });
   if (response.profiles.length === 0) {
     console.log("No cloud profiles found.");
@@ -42,14 +30,13 @@ const deleteProfileCommand = SimpleCLI.command({
     })
   ],
   named: {}
-})).handle(async ({ input }) => {
+})).use(withCloudApiKey("manage Libretto Cloud profiles")).handle(async ({ input, ctx }) => {
   const profileName = normalizeProfileName(input.profileName);
-  const { apiUrl, credential } = requireApiKeyCredential();
   const response = await orpcCall({
-    apiUrl,
+    apiUrl: ctx.apiUrl,
     path: "/v1/browserProfiles/delete",
     input: { name: profileName },
-    credential
+    credential: ctx.credential
   });
   if (!response.success || response.deleted_count === 0) {
     console.log(`No cloud profile found for ${profileName}.`);

package/dist/cli/commands/shared.js

@@ -6,6 +6,7 @@ import {
   readSessionStateOrThrow,
   validateSessionName
 } from "../core/session.js";
+import { resolveApiUrl } from "../core/auth-fetch.js";
 import {
   SimpleCLI
 } from "affordance";
@@ -24,6 +25,21 @@ function withExperiments() {
     experiments: resolveExperiments()
   });
 }
+function withCloudApiKey(action, formatMissingMessage) {
+  return async ({ ctx }) => {
+    const apiKey = process.env.LIBRETTO_API_KEY?.trim();
+    if (!apiKey) {
+      throw new Error(
+        formatMissingMessage ? await formatMissingMessage() : `LIBRETTO_API_KEY is required to ${action}. Issue one with \`libretto cloud auth api-key issue --label <label>\`.`
+      );
+    }
+    return {
+      ...ctx,
+      apiUrl: resolveApiUrl(null),
+      credential: { source: "env-api-key", apiKey }
+    };
+  };
+}
 function withRequiredSession() {
   return async ({ input, ctx }) => {
     if (!input.session) {
@@ -54,6 +70,7 @@ export {
   pageOption,
   sessionOption,
   withAutoSession,
+  withCloudApiKey,
   withExperiments,
   withRequiredSession
 };

package/dist/cli/core/daemon/ipc.js

@@ -1,7 +1,7 @@
 import { createHash } from "node:crypto";
 import { spawn } from "node:child_process";
 import { openSync, closeSync } from "node:fs";
-import { createRequire } from "node:module";
+import * as moduleBuiltin from "node:module";
 import { homedir, userInfo } from "node:os";
 import { fileURLToPath } from "node:url";
 import { createIpcPeer } from "../../../shared/ipc/ipc.js";
@@ -72,22 +72,29 @@ class DaemonClient {
     const daemonEntryPath = fileURLToPath(
       new URL("./daemon.js", import.meta.url)
     );
-    const require2 = createRequire(import.meta.url);
-    const tsxCliPath = require2.resolve("tsx/cli");
-    const childStderrFd = openSync(logPath, "a");
-    const child = spawn(
-      process.execPath,
-      [
-        tsxCliPath,
-        ...config.workflow?.tsconfigPath ? ["--tsconfig", config.workflow.tsconfigPath] : [],
-        daemonEntryPath,
-        JSON.stringify(config)
-      ],
-      {
-        detached: true,
-        stdio: ["ignore", "ignore", childStderrFd, "ipc"]
+    const childArgs = [daemonEntryPath, JSON.stringify(config)];
+    const childEnv = { ...process.env };
+    if (config.workflow) {
+      const tsxPreflightPath = fileURLToPath(
+        import.meta.resolve("tsx/preflight")
+      );
+      const tsxLoaderFlag = typeof moduleBuiltin.register === "function" ? "--import" : "--loader";
+      childArgs.unshift(
+        "--require",
+        tsxPreflightPath,
+        tsxLoaderFlag,
+        import.meta.resolve("tsx")
+      );
+      if (config.workflow.tsconfigPath) {
+        childEnv.TSX_TSCONFIG_PATH = config.workflow.tsconfigPath;
       }
-    );
+    }
+    const childStderrFd = openSync(logPath, "a");
+    const child = spawn(process.execPath, childArgs, {
+      detached: true,
+      stdio: ["ignore", "ignore", childStderrFd, "ipc"],
+      env: childEnv
+    });
     closeSync(childStderrFd);
     const pid = child.pid;
     logger.info("daemon-spawned", { pid, session });

package/dist/cli/core/deploy-artifact.js

@@ -489,13 +489,16 @@ function toPortableRelativePath(args) {
   }
   return relPath;
 }
+function isShareableSourceRelPath(relPath) {
+  return !relPath.split("/").includes("node_modules");
+}
 function writeShareableSourceFiles(args) {
   const relPaths = [...new Set(args.absSourcePaths.map(
     (absPath) => toPortableRelativePath({
       absPath,
       absSourceDir: args.absSourceDir
     })
-  ))].sort();
+  ))].filter(isShareableSourceRelPath).sort();
   for (const relPath of relPaths) {
     const targetPath = join(args.outputDir, ".libretto-share", "source", relPath);
     mkdirSync(dirname(targetPath), { recursive: true });
@@ -888,7 +891,7 @@ async function writeBundledDeployEntrypoint(args) {
       (inputPath) => isAbsolute(inputPath) ? resolve(inputPath) : resolve(args.absSourceDir, inputPath)
     ).filter((absPath) => {
       const relPath = relative(args.absSourceDir, absPath);
-      return relPath !== "" && !relPath.startsWith("../") && relPath !== ".." && !isAbsolute(relPath);
+      return relPath !== "" && !relPath.startsWith("../") && relPath !== ".." && !isAbsolute(relPath) && isShareableSourceRelPath(relPath.replaceAll("\\", "/"));
     });
     return { shareableSourceFiles, workflows };
   } catch (error) {