windmill-cli 1.589.3 → 1.590.0

package/esm/src/commands/app/dev.js

@@ -15,6 +15,7 @@ import { requireLogin } from "../../core/auth.js";
 import { GLOBAL_CONFIG_OPT } from "../../core/conf.js";
 import { replaceInlineScripts } from "./apps.js";
 import { APP_BACKEND_FOLDER, inferRunnableSchemaFromFile, } from "./app_metadata.js";
+import { loadRunnablesFromBackend } from "./raw_apps.js";
 const DEFAULT_PORT = 4000;
 const DEFAULT_HOST = "localhost";
 // HTML template with live reload
@@ -128,8 +129,12 @@ async function dev(opts) {
     const wmillPlugin = {
         name: "wmill-virtual",
         setup(build) {
-            // Intercept imports of /wmill.ts, /wmill, ./wmill.ts, or ./wmill
-            build.onResolve({ filter: /^(\.\/|\/)?wmill(\.ts)?$/ }, (args) => {
+            // Intercept imports of wmill with various path formats:
+            // - wmill, wmill.ts (bare import)
+            // - /wmill, /wmill.ts (absolute)
+            // - ./wmill, ./wmill.ts (same directory)
+            // - ../wmill, ../../wmill, etc. (parent directories)
+            build.onResolve({ filter: /^(\.\.\/)+wmill(\.ts)?$|^(\.\/|\/)?wmill(\.ts)?$/ }, (args) => {
                 log.info(colors.yellow(`[wmill-virtual] Intercepted: ${args.path}`));
                 return {
                     path: args.path,
@@ -469,16 +474,30 @@ const command = new Command()
 export default command;
 /**
  * Generates wmill.d.ts with type definitions for runnables.
- * Merges in-memory inferred schemas with runnables from raw_app.yaml.
+ * Loads runnables from separate YAML files in the backend folder (new format)
+ * or falls back to raw_app.yaml (old format).
+ * Merges in-memory inferred schemas with runnables.
  *
  * @param schemaOverrides - In-memory schema overrides (runnableId -> schema)
  */
 async function genRunnablesTs(schemaOverrides = {}) {
     log.info(colors.blue("🔄 Generating wmill.d.ts..."));
-    const rawApp = (await yamlParseFile(path.join(process.cwd(), "raw_app.yaml")));
-    const runnables = rawApp?.["runnables"];
+    const localPath = process.cwd();
+    const backendPath = path.join(localPath, APP_BACKEND_FOLDER);
+    // Load runnables from separate files (new format) or fall back to raw_app.yaml (old format)
+    let runnables = await loadRunnablesFromBackend(backendPath);
+    if (Object.keys(runnables).length === 0) {
+        // Fall back to old format
+        try {
+            const rawApp = (await yamlParseFile(path.join(localPath, "raw_app.yaml")));
+            runnables = rawApp?.["runnables"] ?? {};
+        }
+        catch {
+            runnables = {};
+        }
+    }
     // Apply schema overrides from in-memory cache
-    if (runnables && Object.keys(schemaOverrides).length > 0) {
+    if (Object.keys(schemaOverrides).length > 0) {
         for (const [runnableId, schema] of Object.entries(schemaOverrides)) {
             if (runnables[runnableId]?.inlineScript) {
                 runnables[runnableId].inlineScript.schema = schema;
@@ -497,9 +516,16 @@ async function genRunnablesTs(schemaOverrides = {}) {
 async function loadRunnables() {
     try {
         const localPath = process.cwd();
-        const rawApp = (await yamlParseFile(path.join(localPath, "raw_app.yaml")));
-        replaceInlineScripts(rawApp.runnables, path.join(localPath, APP_BACKEND_FOLDER) + SEP, true);
-        return rawApp?.runnables ?? {};
+        const backendPath = path.join(localPath, APP_BACKEND_FOLDER);
+        // Load runnables from separate files (new format) or fall back to raw_app.yaml (old format)
+        let runnables = await loadRunnablesFromBackend(backendPath);
+        if (Object.keys(runnables).length === 0) {
+            // Fall back to old format
+            const rawApp = (await yamlParseFile(path.join(localPath, "raw_app.yaml")));
+            runnables = rawApp?.runnables ?? {};
+        }
+        replaceInlineScripts(runnables, backendPath + SEP, true);
+        return runnables;
     }
     catch (error) {
         log.error(colors.red(`Failed to load runnables: ${error.message}`));
@@ -539,12 +565,12 @@ async function executeRunnable(runnable, workspace, appPath, runnableId, args) {
             cache_ttl: inlineScript.cache_ttl,
         };
     }
-    else if ((runnable.type === "path" || runnable.type === "runnableByPath") &&
-        runnable.path) {
-        const runType = runnable.runType ?? "script";
+    else if (runnable.type === "path" && runnable.runType && runnable.path) {
+        // Path-based runnables have type: "path" and runType: "script"|"hubscript"|"flow"
+        const prefix = runnable.runType;
         requestBody.path =
-            runType !== "hubscript"
-                ? `${runType}/${runnable.path}`
+            prefix !== "hubscript"
+                ? `${prefix}/${runnable.path}`
                 : `script/${runnable.path}`;
     }
     const uuid = await wmill.executeComponent({

package/esm/src/commands/app/lint.js

@@ -0,0 +1,159 @@
+// deno-lint-ignore-file no-explicit-any
+import * as dntShim from "../../../_dnt.shims.js";
+import * as fs from "node:fs";
+import * as path from "node:path";
+import process from "node:process";
+import { Command, colors, log, yamlParseFile } from "../../../deps.js";
+import { createBundle } from "./bundle.js";
+import { APP_BACKEND_FOLDER } from "./app_metadata.js";
+import { loadRunnablesFromBackend } from "./raw_apps.js";
+/**
+ * Validates the structure of raw_app.yaml
+ */
+function validateRawAppYaml(appData) {
+    const errors = [];
+    const warnings = [];
+    // Check required fields
+    if (!appData.summary) {
+        errors.push("Missing required field: 'summary'");
+    }
+    else if (typeof appData.summary !== "string") {
+        errors.push("Field 'summary' must be a string");
+    }
+    // Note: 'runnables' is no longer required in raw_app.yaml
+    // Runnables can be stored in separate files in the backend folder
+    return { errors, warnings };
+}
+/**
+ * Validates that runnables exist either in backend/*.yaml files or in raw_app.yaml
+ */
+async function validateRunnables(appDir, appData) {
+    const errors = [];
+    const warnings = [];
+    const backendPath = path.join(appDir, APP_BACKEND_FOLDER);
+    // Load runnables from separate files (new format)
+    const runnablesFromBackend = await loadRunnablesFromBackend(backendPath);
+    const hasBackendRunnables = Object.keys(runnablesFromBackend).length > 0;
+    // Check for runnables in raw_app.yaml (old format)
+    const hasYamlRunnables = appData.runnables &&
+        typeof appData.runnables === "object" &&
+        !Array.isArray(appData.runnables) &&
+        Object.keys(appData.runnables).length > 0;
+    if (!hasBackendRunnables && !hasYamlRunnables) {
+        errors.push("No runnables found. Expected either:\n" +
+            "  - Runnable YAML files in the 'backend/' folder (e.g., backend/myRunnable.yaml)\n" +
+            "  - Or a 'runnables' field in raw_app.yaml (legacy format)");
+    }
+    else if (hasBackendRunnables) {
+        log.info(colors.gray(`  Found ${Object.keys(runnablesFromBackend).length} runnable(s) in backend folder`));
+    }
+    else if (hasYamlRunnables) {
+        log.info(colors.gray(`  Found ${Object.keys(appData.runnables).length} runnable(s) in raw_app.yaml (legacy format)`));
+        warnings.push("Using legacy format with runnables in raw_app.yaml. Consider migrating to separate files in backend/");
+    }
+    return { errors, warnings };
+}
+/**
+ * Checks if the app can be built successfully
+ */
+async function validateBuild(appDir) {
+    const errors = [];
+    const warnings = [];
+    try {
+        log.info(colors.blue("🔨 Testing build..."));
+        // Try to create a bundle - this will validate that all dependencies are in place
+        await createBundle({
+            production: true,
+            minify: false,
+        });
+        log.info(colors.green("✅ Build successful"));
+    }
+    catch (error) {
+        errors.push(`Build failed: ${error.message}`);
+    }
+    return { errors, warnings };
+}
+/**
+ * Validates a raw app folder
+ */
+async function lintRawApp(appDir, opts) {
+    const errors = [];
+    const warnings = [];
+    // Check if we're in a .raw_app folder
+    const currentDirName = path.basename(appDir);
+    if (!currentDirName.endsWith(".raw_app")) {
+        errors.push(`Not a raw app folder: '${currentDirName}' does not end with '.raw_app'`);
+        return { valid: false, errors, warnings };
+    }
+    // Check if raw_app.yaml exists
+    const rawAppPath = path.join(appDir, "raw_app.yaml");
+    if (!fs.existsSync(rawAppPath)) {
+        errors.push("Missing raw_app.yaml file");
+        return { valid: false, errors, warnings };
+    }
+    log.info(colors.blue("📋 Validating raw_app.yaml structure..."));
+    // Parse and validate raw_app.yaml
+    let appData;
+    try {
+        appData = await yamlParseFile(rawAppPath);
+    }
+    catch (error) {
+        errors.push(`Failed to parse raw_app.yaml: ${error.message}`);
+        return { valid: false, errors, warnings };
+    }
+    const yamlValidation = validateRawAppYaml(appData);
+    errors.push(...yamlValidation.errors);
+    warnings.push(...yamlValidation.warnings);
+    if (errors.length > 0) {
+        return { valid: false, errors, warnings };
+    }
+    log.info(colors.green("✅ raw_app.yaml structure is valid"));
+    // Validate runnables (either in backend folder or in raw_app.yaml)
+    log.info(colors.blue("📋 Validating runnables..."));
+    const runnablesValidation = await validateRunnables(appDir, appData);
+    errors.push(...runnablesValidation.errors);
+    warnings.push(...runnablesValidation.warnings);
+    if (errors.length > 0) {
+        return { valid: false, errors, warnings };
+    }
+    log.info(colors.green("✅ Runnables are valid"));
+    // Validate build
+    const buildValidation = await validateBuild(appDir);
+    errors.push(...buildValidation.errors);
+    warnings.push(...buildValidation.warnings);
+    return {
+        valid: errors.length === 0,
+        errors,
+        warnings,
+    };
+}
+/**
+ * Main lint command
+ */
+async function lint(opts, appFolder) {
+    const targetDir = appFolder ?? process.cwd();
+    log.info(colors.bold.blue(`\n🔍 Linting raw app: ${targetDir}\n`));
+    const result = await lintRawApp(targetDir, opts);
+    // Display results
+    if (result.warnings.length > 0) {
+        log.info(colors.yellow("\n⚠️  Warnings:"));
+        result.warnings.forEach((warning) => {
+            log.info(colors.yellow(`  - ${warning}`));
+        });
+    }
+    if (result.errors.length > 0) {
+        log.info(colors.red("\n❌ Errors:"));
+        result.errors.forEach((error) => {
+            log.info(colors.red(`  - ${error}`));
+        });
+        log.info(colors.red("\n❌ Lint failed\n"));
+        dntShim.Deno.exit(1);
+    }
+    log.info(colors.green("\n✅ All checks passed\n"));
+}
+const command = new Command()
+    .description("Lint a raw app folder to validate structure and buildability")
+    .arguments("[app_folder:string]")
+    .option("--fix", "Attempt to fix common issues (not implemented yet)")
+    .action(lint);
+export default command;

package/esm/src/commands/app/raw_apps.js

@@ -2,12 +2,147 @@
 import * as dntShim from "../../../_dnt.shims.js";
 import { requireLogin } from "../../core/auth.js";
 import { resolveWorkspace, validatePath } from "../../core/context.js";
-import { colors, log, SEP, windmillUtils, yamlParseFile, } from "../../../deps.js";
+import { colors, log, SEP, windmillUtils, yamlParseFile, yamlStringify, } from "../../../deps.js";
 import * as wmill from "../../../gen/services.gen.js";
+import path from "node:path";
 import { isSuperset } from "../../types.js";
 import { replaceInlineScripts, repopulateFields } from "./apps.js";
 import { createBundle, detectFrameworks } from "./bundle.js";
 import { APP_BACKEND_FOLDER } from "./app_metadata.js";
+import { writeIfChanged } from "../../utils/utils.js";
+import { yamlOptions } from "../sync/sync.js";
+import { EXTENSION_TO_LANGUAGE, getLanguageFromExtension, } from "../../../windmill-utils-internal/src/path-utils/path-assigner.js";
+/**
+ * Finds the content file for a runnable by looking for files matching the runnableId.
+ * Returns the file extension and content, or undefined if not found.
+ */
+async function findRunnableContentFile(backendPath, runnableId, allFiles) {
+    // Look for files matching pattern: {runnableId}.{ext}
+    // where ext is a known language extension
+    for (const fileName of allFiles) {
+        // Skip yaml and lock files
+        if (fileName.endsWith(".yaml") || fileName.endsWith(".lock")) {
+            continue;
+        }
+        // Check if file starts with runnableId followed by a dot
+        if (!fileName.startsWith(runnableId + ".")) {
+            continue;
+        }
+        // Extract extension (everything after the first dot following runnableId)
+        const ext = fileName.substring(runnableId.length + 1);
+        // Check if this is a recognized extension
+        if (EXTENSION_TO_LANGUAGE[ext]) {
+            try {
+                const content = await dntShim.Deno.readTextFile(path.join(backendPath, fileName));
+                return { ext, content };
+            }
+            catch {
+                continue;
+            }
+        }
+    }
+    return undefined;
+}
+/**
+ * Loads all runnables from separate YAML files in the backend folder.
+ * Each runnable is stored in a file named `<runnableId>.yaml`.
+ *
+ * Converts from file format to API format:
+ * - For inline scripts (type: 'inline'): derives inlineScript from sibling files
+ * - For path-based runnables (type: 'script'|'hubscript'|'flow'): converts to API format
+ *   e.g., { type: "script" } -> { type: "path", runType: "script" }
+ *
+ * Returns an empty object if the backend folder doesn't exist.
+ *
+ * @param backendPath - Path to the backend folder
+ * @param defaultTs - Default TypeScript runtime ("bun" or "deno")
+ */
+export async function loadRunnablesFromBackend(backendPath, defaultTs = "bun") {
+    const runnables = {};
+    try {
+        // First, collect all files in the backend folder
+        const allFiles = [];
+        for await (const entry of dntShim.Deno.readDir(backendPath)) {
+            if (entry.isFile) {
+                allFiles.push(entry.name);
+            }
+        }
+        // Process YAML files (runnable metadata files)
+        for (const fileName of allFiles) {
+            if (!fileName.endsWith(".yaml")) {
+                continue;
+            }
+            const runnableId = fileName.replace(".yaml", "");
+            const filePath = path.join(backendPath, fileName);
+            const runnable = (await yamlParseFile(filePath));
+            // If this is an inline script (type: 'inline'), derive inlineScript from files
+            if (runnable?.type === "inline") {
+                const contentFile = await findRunnableContentFile(backendPath, runnableId, allFiles);
+                if (contentFile) {
+                    const language = getLanguageFromExtension(contentFile.ext, defaultTs);
+                    // Try to load lock file
+                    let lock;
+                    try {
+                        lock = await dntShim.Deno.readTextFile(path.join(backendPath, `${runnableId}.lock`));
+                    }
+                    catch {
+                        // No lock file, that's fine
+                    }
+                    // Reconstruct inlineScript object
+                    runnable.inlineScript = {
+                        content: contentFile.content,
+                        language,
+                        ...(lock ? { lock } : {}),
+                    };
+                }
+            }
+            else if (runnable?.type === "script" ||
+                runnable?.type === "hubscript" ||
+                runnable?.type === "flow") {
+                // For path-based runnables, convert from file format to API format
+                // { type: "script" } -> { type: "path", runType: "script" }
+                // { type: "hubscript" } -> { type: "path", runType: "hubscript" }
+                // { type: "flow" } -> { type: "path", runType: "flow" }
+                const { type, schema: _schema, ...rest } = runnable;
+                runnable.type = "path";
+                runnable.runType = type;
+                // Remove schema if present
+                delete runnable.schema;
+                Object.assign(runnable, rest);
+            }
+            runnables[runnableId] = runnable;
+        }
+    }
+    catch (error) {
+        if (error.name !== "NotFound") {
+            throw error;
+        }
+    }
+    return runnables;
+}
+/**
+ * Writes a single runnable to its YAML file in the backend folder.
+ * The file will be named `<runnableId>.yaml`.
+ *
+ * Converts from API format to file format:
+ * - For inline scripts: keeps type: "inline"
+ * - For path-based runnables: converts { type: "path", runType: "script" } to { type: "script" }
+ *   and removes schema field
+ */
+export function writeRunnableToBackend(backendPath, runnableId, runnable) {
+    let runnableToWrite = { ...runnable };
+    // Convert path-based runnables from API format to file format
+    if (runnable.type === "path" && runnable.runType) {
+        // { type: "path", runType: "script" } -> { type: "script" }
+        const { type: _type, runType, schema: _schema, ...rest } = runnable;
+        runnableToWrite = {
+            type: runType,
+            ...rest,
+        };
+    }
+    const filePath = path.join(backendPath, `${runnableId}.yaml`);
+    writeIfChanged(filePath, yamlStringify(runnableToWrite, yamlOptions));
+}
 const alreadySynced = [];
 async function collectAppFiles(localPath) {
     const files = {};
@@ -27,9 +162,9 @@ async function collectAppFiles(localPath) {
             }
             else if (entry.isFile) {
                 // Skip raw_app.yaml as it's metadata, not an app file
-                // Skip node_modules and package-lock.json as they are generated
-                if (relativePath === "raw_app.yaml" ||
-                    relativePath === "package-lock.json") {
+                // Skip package-lock.json as it's generated
+                if (entry.name === "raw_app.yaml" ||
+                    entry.name === "package-lock.json") {
                     continue;
                 }
                 const content = await dntShim.Deno.readTextFile(fullPath);
@@ -67,11 +202,31 @@ export async function pushRawApp(workspace, remotePath, localPath, message) {
     if (!localPath.endsWith(SEP)) {
         localPath += SEP;
     }
-    const path = localPath + "raw_app.yaml";
-    const localApp = (await yamlParseFile(path));
-    replaceInlineScripts(localApp.runnables, localPath + SEP + APP_BACKEND_FOLDER + SEP, true);
-    repopulateFields(localApp.runnables);
-    await generatingPolicy(localApp, remotePath, localApp?.["public"] ?? false);
+    const appFilePath = localPath + "raw_app.yaml";
+    const localApp = (await yamlParseFile(appFilePath));
+    // Load runnables from separate YAML files in the backend folder
+    // Falls back to reading from raw_app.yaml if no separate files exist (backward compat)
+    const backendPath = path.join(localPath, APP_BACKEND_FOLDER);
+    const runnablesFromBackend = await loadRunnablesFromBackend(backendPath);
+    let runnables;
+    if (Object.keys(runnablesFromBackend).length > 0) {
+        // Use runnables from separate files (new format)
+        runnables = runnablesFromBackend;
+        log.info(colors.gray(`Loaded ${Object.keys(runnables).length} runnables from backend folder`));
+    }
+    else if (localApp.runnables) {
+        // Fall back to runnables from raw_app.yaml (old format)
+        runnables = localApp.runnables;
+        log.info(colors.gray(`Loaded ${Object.keys(runnables).length} runnables from raw_app.yaml (legacy format)`));
+    }
+    else {
+        runnables = {};
+    }
+    replaceInlineScripts(runnables, backendPath + SEP, true);
+    repopulateFields(runnables);
+    // Create a temporary app object for policy generation
+    const appForPolicy = { ...localApp, runnables };
+    await generatingPolicy(appForPolicy, remotePath, localApp?.["public"] ?? false);
     const files = await collectAppFiles(localPath);
     async function createBundleRaw() {
         log.info(colors.yellow.bold(`Creating raw app ${remotePath} bundle...`));
@@ -86,7 +241,7 @@ export async function pushRawApp(workspace, remotePath, localPath, message) {
         });
     }
     if (app) {
-        if (isSuperset(localApp, app)) {
+        if (isSuperset({ ...localApp, runnables }, app)) {
             log.info(colors.green(`App ${remotePath} is up to date`));
             return;
         }
@@ -97,10 +252,10 @@ export async function pushRawApp(workspace, remotePath, localPath, message) {
             path: remotePath,
             formData: {
                 app: {
-                    value: { runnables: localApp.runnables, files },
+                    value: { runnables, files },
                     path: remotePath,
                     summary: localApp.summary,
-                    policy: localApp.policy,
+                    policy: appForPolicy.policy,
                     deployment_message: message,
                     custom_path: localApp.custom_path,
                 },
@@ -115,10 +270,10 @@ export async function pushRawApp(workspace, remotePath, localPath, message) {
             workspace,
             formData: {
                 app: {
-                    value: { runnables: localApp.runnables, files },
+                    value: { runnables, files },
                     path: remotePath,
                     summary: localApp.summary,
-                    policy: localApp.policy,
+                    policy: appForPolicy.policy,
                     deployment_message: message,
                     custom_path: localApp.custom_path,
                 },
@@ -126,16 +281,6 @@ export async function pushRawApp(workspace, remotePath, localPath, message) {
                 css,
             },
         });
-        // await wmill.createApp({
-        //   workspace,
-        //   requestBody: {
-        //     path: remotePath,
-        //     deployment_message: message,
-        //     value: { runnables: localApp.runnables, files },
-        //     summary: localApp.summary,
-        //     policy: localApp.policy,
-        //   },
-        // });
     }
 }
 export async function generatingPolicy(app, path, publicApp) {

package/esm/src/commands/init/init.js

@@ -4,6 +4,7 @@ import { readLockfile } from "../../utils/metadata.js";
 import { SCRIPT_GUIDANCE } from "../../guidance/script_guidance.js";
 import { FLOW_GUIDANCE } from "../../guidance/flow_guidance.js";
 import { getActiveWorkspaceOrFallback } from "../workspace/workspace.js";
+import { generateRTNamespace } from "../resource-type/resource-type.js";
 /**
  * Bootstrap a windmill project with a wmill.yaml file
  */
@@ -200,6 +201,13 @@ ${flowGuidanceContent}
             log.warn(`Could not create guidance files: ${error}`);
         }
     }
+    // Generate resource type namespace
+    try {
+        await generateRTNamespace(opts);
+    }
+    catch (error) {
+        log.warn(`Could not pull resource types and generate TypeScript namespace: ${error instanceof Error ? error.message : error}`);
+    }
 }
 const command = new Command()
     .description("Bootstrap a windmill project with a wmill.yaml file")

package/esm/src/commands/resource-type/resource-type.js

@@ -1,10 +1,15 @@
 // deno-lint-ignore-file no-explicit-any
 import * as dntShim from "../../../_dnt.shims.js";
+import { writeFileSync } from "node:fs";
+import path from "node:path";
+import process from "node:process";
 import { isSuperset, parseFromFile, removeType, } from "../../types.js";
 import { requireLogin } from "../../core/auth.js";
 import { resolveWorkspace } from "../../core/context.js";
 import { colors, Command, log, Table } from "../../../deps.js";
 import * as wmill from "../../../gen/services.gen.js";
+import { compileResourceTypeToTsType } from "../../utils/resource_types.js";
+import { capitalize, toCamel } from "../../utils/utils.js";
 export async function pushResourceType(workspace, remotePath, resource, localResource) {
     remotePath = removeType(remotePath, "resource-type");
     try {
@@ -61,7 +66,11 @@ async function list(opts) {
             .header(["Workspace", "Name", "Schema"])
             .padding(2)
             .border(true)
-            .body(res.map((x) => [x.workspace_id ?? "Global", x.name, JSON.stringify(x.schema, null, 2)]))
+            .body(res.map((x) => [
+            x.workspace_id ?? "Global",
+            x.name,
+            JSON.stringify(x.schema, null, 2),
+        ]))
             .render();
     }
     else {
@@ -73,6 +82,22 @@ async function list(opts) {
             .render();
     }
 }
+export async function generateRTNamespace(opts) {
+    const workspace = await resolveWorkspace(opts);
+    await requireLogin(opts);
+    const rts = await wmill.listResourceType({
+        workspace: workspace.workspaceId,
+    });
+    let namespaceContent = "declare namespace RT {\n";
+    namespaceContent += rts
+        .map((resourceType) => {
+        return `  type ${toCamel(capitalize(resourceType.name))} = ${compileResourceTypeToTsType(resourceType.schema).replaceAll("\n", "\n  ")}`;
+    })
+        .join("\n\n");
+    namespaceContent += "\n}";
+    writeFileSync(path.join(process.cwd(), "rt.d.ts"), namespaceContent);
+    log.info(colors.green("Created rt.d.ts with resource types namespace (RT) for TypeScript."));
+}
 const command = new Command()
     .description("resource type related commands")
     .action(() => log.info("2 actions available, list and push."))
@@ -81,5 +106,7 @@ const command = new Command()
     .action(list)
     .command("push", "push a local resource spec. This overrides any remote versions.")
     .arguments("<file_path:string> <name:string>")
-    .action(push);
+    .action(push)
+    .command("generate-namespace", "Create a TypeScript definition file with the RT namespace generated from the resource types")
+    .action(generateRTNamespace);
 export default command;

package/esm/src/commands/script/script.js

@@ -17,6 +17,16 @@ import { mergeConfigWithConfigFile, readConfigFile, } from "../../core/conf.js";
 import { listSyncCodebases } from "../../utils/codebase.js";
 import fs from "node:fs";
 import { execSync } from "node:child_process";
+/**
+ * Checks if a path is inside a raw app backend folder.
+ * Matches patterns like: .../myApp.raw_app/backend/...
+ */
+export function isRawAppBackendPath(filePath) {
+    // Normalize path separators for consistent matching
+    const normalizedPath = filePath.replaceAll(SEP, "/");
+    // Check if path contains pattern: *.raw_app/backend/
+    return /\.raw_app\/backend\//.test(normalizedPath);
+}
 async function push(opts, filePath) {
     opts = await mergeConfigWithConfigFile(opts);
     const workspace = await resolveWorkspace(opts);
@@ -80,6 +90,7 @@ export async function handleScriptMetadata(path, workspace, alreadySynced, messa
 }
 export async function handleFile(path, workspace, alreadySynced, message, opts, rawWorkspaceDependencies, codebases) {
     if (!path.includes(".inline_script.") &&
+        !isRawAppBackendPath(path) &&
         exts.some((exts) => path.endsWith(exts))) {
         if (alreadySynced.includes(path)) {
             return true;