slskit-cli 1.0.0

package/dist/commands/rm/action.js

@@ -0,0 +1,89 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.rmAction = rmAction;
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_path_1 = __importDefault(require("node:path"));
+const errors_js_1 = require("../../core/errors.js");
+const is_ci_js_1 = require("../../core/is-ci.js");
+const environments_js_1 = require("../../core/environments.js");
+const logger_js_1 = require("../../core/logger.js");
+const templates_js_1 = require("../env/templates.js");
+const manifest_js_1 = require("../function/manifest.js");
+const manifest_js_2 = require("../init/manifest.js");
+const plan_js_1 = require("./plan.js");
+const prompts_js_1 = require("./prompts.js");
+const COMMAND = "slskit rm";
+function subject(plan) {
+    if (plan.kind === "service") {
+        const count = plan.functionsRemoved.length;
+        return `application "${plan.appName}" and its ${count} function${count === 1 ? "" : "s"}`;
+    }
+    return `function "${plan.functionName}" from application "${plan.appName}"`;
+}
+function describe(plan) {
+    logger_js_1.logger.info(`\nAbout to remove ${subject(plan)}.`);
+    for (const target of plan.paths) {
+        logger_js_1.logger.info(`  delete     ${target}`);
+    }
+    for (const route of plan.routes) {
+        logger_js_1.logger.info(`  drop route ${route}`);
+    }
+    logger_js_1.logger.info("  update     slskit.json and every template that referenced it");
+    if (plan.cascadesToService) {
+        logger_js_1.logger.info(`\nNote: "${plan.functionName}" is the last function in "${plan.appName}", so the application goes with it — a service template with no functions is not valid CloudFormation.`);
+    }
+}
+async function rmAction(options) {
+    const root = process.cwd();
+    const manifest = (0, manifest_js_1.readProjectManifest)(root, COMMAND);
+    const answers = (0, manifest_js_1.toInitAnswers)(manifest);
+    const apps = (0, manifest_js_1.toServiceDefs)(manifest);
+    const target = await (0, prompts_js_1.resolveRemovalTarget)(manifest, options);
+    const plan = (0, plan_js_1.planRemoval)(answers, apps, target);
+    describe(plan);
+    if (!options.yes) {
+        if (!(0, is_ci_js_1.isInteractive)()) {
+            throw new errors_js_1.CliError(`Removing code cannot be undone. Re-run with --yes to remove ${subject(plan)}.`);
+        }
+        const { confirm } = await import("@inquirer/prompts");
+        const proceed = await confirm({
+            message: `Remove ${subject(plan)}?`,
+            default: false,
+        });
+        if (!proceed) {
+            logger_js_1.logger.info("\nNothing was removed.");
+            return;
+        }
+    }
+    const deleted = [];
+    for (const relative of plan.paths) {
+        const full = node_path_1.default.join(root, relative);
+        if (node_fs_1.default.existsSync(full)) {
+            node_fs_1.default.rmSync(full, { recursive: true, force: true });
+            deleted.push(relative);
+        }
+    }
+    // The manifest is rebuilt from the pruned application list rather than edited in
+    // place, so every derived section -- routes, services, directories, layer
+    // attachments, the per-service template lists -- is regenerated consistently.
+    const generatedFiles = (0, plan_js_1.pruneGeneratedFiles)(manifest.structure?.files ?? [], plan.paths);
+    (0, environments_js_1.writeManifest)(root, (0, manifest_js_2.buildProjectManifest)(answers, plan.apps, generatedFiles, {
+        version: manifest.version,
+        environments: manifest.environments,
+    }));
+    const written = (0, templates_js_1.regenerateTemplates)(root, (0, environments_js_1.readManifest)(root, COMMAND));
+    logger_js_1.logger.info(`\nRemoved ${subject(plan)}.`);
+    for (const relative of deleted) {
+        logger_js_1.logger.info(`  deleted    ${relative}`);
+    }
+    logger_js_1.logger.info("  updated    slskit.json");
+    if (written.length > 0) {
+        logger_js_1.logger.info(`  updated    ${written.length} template${written.length === 1 ? "" : "s"}`);
+    }
+    const remainingFunctions = plan.apps.reduce((count, app) => count + app.functions.length, 0);
+    logger_js_1.logger.info(`\n${plan.apps.length} application${plan.apps.length === 1 ? "" : "s"} and ${remainingFunctions} function${remainingFunctions === 1 ? "" : "s"} left.`);
+    logger_js_1.logger.info('Deployed resources are not touched — run "slskit deploy <environment> --all" to remove them from AWS.');
+}

package/dist/commands/rm/index.d.ts

@@ -0,0 +1,2 @@
+import { Command } from "commander";
+export declare function registerRmCommand(program: Command): void;

package/dist/commands/rm/index.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerRmCommand = registerRmCommand;
+const run_js_1 = require("../../core/run.js");
+function registerRmCommand(program) {
+    program
+        .command("rm")
+        .alias("remove")
+        .description("Remove a function or an application, and everything that referenced it")
+        .argument("[name]", "Function or application name")
+        .option("--function <name>", "Remove this function")
+        .option("--service <name>", "Remove this application and every function in it")
+        .option("--app <name>", "Same as --service")
+        .option("-y, --yes", "Skip the confirmation prompt", false)
+        .action((name, options) => (0, run_js_1.runCommand)(async () => {
+        const { rmAction } = await import("./action.js");
+        await rmAction({
+            name: name ?? options.name,
+            function: options.function,
+            service: options.service,
+            app: options.app,
+            yes: options.yes,
+        });
+    }));
+}

package/dist/commands/rm/plan.d.ts

@@ -0,0 +1,19 @@
+import type { InitAnswers, ServiceDef } from "../init/types.js";
+export type RemovalKind = "function" | "service";
+export interface RemovalTarget {
+    kind: RemovalKind;
+    appName: string;
+    functionName?: string;
+}
+export interface RemovalPlan {
+    kind: RemovalKind;
+    appName: string;
+    functionName?: string;
+    apps: ServiceDef[];
+    paths: string[];
+    functionsRemoved: string[];
+    routes: string[];
+    cascadesToService: boolean;
+}
+export declare function planRemoval(answers: InitAnswers, apps: ServiceDef[], target: RemovalTarget): RemovalPlan;
+export declare function pruneGeneratedFiles(files: string[], removed: string[]): string[];

package/dist/commands/rm/plan.js

@@ -0,0 +1,78 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.planRemoval = planRemoval;
+exports.pruneGeneratedFiles = pruneGeneratedFiles;
+const errors_js_1 = require("../../core/errors.js");
+const types_js_1 = require("../init/types.js");
+function functionPaths(answers, appName, fn) {
+    return [
+        `${types_js_1.SRC_DIR}/functions/${appName}/${fn.name}`,
+        `${types_js_1.SRC_DIR}/services/${appName}/${fn.name}.${(0, types_js_1.sourceExt)(fn.runtime ?? answers.runtime)}`,
+    ];
+}
+function servicePaths(appName) {
+    return [
+        `${types_js_1.SRC_DIR}/functions/${appName}`,
+        `${types_js_1.SRC_DIR}/services/${appName}`,
+        (0, types_js_1.serviceTemplatePath)(appName),
+    ];
+}
+function routeLabel(fn) {
+    return `${fn.method} ${fn.httpPath}`;
+}
+function totalFunctions(apps) {
+    return apps.reduce((count, app) => count + app.functions.length, 0);
+}
+// Works out everything a removal touches without writing anything, so the command
+// can describe the change before it is confirmed -- and so the whole decision is
+// testable without a filesystem.
+function planRemoval(answers, apps, target) {
+    const app = apps.find((each) => each.name === target.appName);
+    if (!app) {
+        const known = apps.map((each) => each.name).join(", ") || "(none)";
+        throw new errors_js_1.CliError(`Application "${target.appName}" was not found. Existing: ${known}.`);
+    }
+    if (target.kind === "service") {
+        const remaining = apps.filter((each) => each.name !== app.name);
+        if (totalFunctions(remaining) === 0) {
+            throw new errors_js_1.CliError(`Removing "${app.name}" would leave the project with no functions, and a stack with no resources cannot be deployed. Add another function first, or start over with "slskit init".`);
+        }
+        return {
+            kind: "service",
+            appName: app.name,
+            apps: remaining,
+            paths: servicePaths(app.name),
+            functionsRemoved: app.functions.map((fn) => fn.name),
+            routes: app.functions.map(routeLabel),
+            cascadesToService: false,
+        };
+    }
+    const fn = app.functions.find((each) => each.name === target.functionName);
+    if (!fn) {
+        const known = app.functions.map((each) => each.name).join(", ") || "(none)";
+        throw new errors_js_1.CliError(`Function "${target.functionName}" was not found in application "${app.name}". Existing: ${known}.`);
+    }
+    const keptFunctions = app.functions.filter((each) => each.name !== fn.name);
+    const cascadesToService = keptFunctions.length === 0;
+    const remaining = cascadesToService
+        ? apps.filter((each) => each.name !== app.name)
+        : apps.map((each) => each.name === app.name ? { ...each, functions: keptFunctions } : each);
+    if (totalFunctions(remaining) === 0) {
+        throw new errors_js_1.CliError(`"${fn.name}" is the only function in this project, and a stack with no resources cannot be deployed. Add another function first, or start over with "slskit init".`);
+    }
+    return {
+        kind: "function",
+        appName: app.name,
+        functionName: fn.name,
+        apps: remaining,
+        paths: cascadesToService ? servicePaths(app.name) : functionPaths(answers, app.name, fn),
+        functionsRemoved: [fn.name],
+        routes: [routeLabel(fn)],
+        cascadesToService,
+    };
+}
+// Drops every generated-file entry that the removal deletes, including anything
+// nested under a removed directory (a Python function's __init__.py, say).
+function pruneGeneratedFiles(files, removed) {
+    return files.filter((file) => !removed.some((path) => file === path || file.startsWith(`${path}/`)));
+}

package/dist/commands/rm/prompts.d.ts

@@ -0,0 +1,4 @@
+import type { ProjectManifest } from "../function/types.js";
+import type { RemovalTarget } from "./plan.js";
+import type { RmOptions } from "./types.js";
+export declare function resolveRemovalTarget(manifest: ProjectManifest, options: RmOptions): Promise<RemovalTarget>;

package/dist/commands/rm/prompts.js

@@ -0,0 +1,107 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveRemovalTarget = resolveRemovalTarget;
+const errors_js_1 = require("../../core/errors.js");
+// Function names are unique across the whole project, so a name is enough to find
+// one -- the same property "slskit function" enforces when it creates them.
+function findFunction(manifest, name) {
+    const wanted = name.trim().toLowerCase();
+    for (const app of manifest.applications) {
+        for (const fn of app.functions) {
+            if (fn.name.toLowerCase() === wanted) {
+                return { app: app.name, fn: fn.name };
+            }
+        }
+    }
+    return undefined;
+}
+function findService(manifest, name) {
+    const wanted = name.trim().toLowerCase();
+    return manifest.applications.find((app) => app.name.toLowerCase() === wanted)?.name;
+}
+function serviceNames(manifest) {
+    return manifest.applications.map((app) => app.name).join(", ") || "(none)";
+}
+function functionNames(manifest) {
+    return (manifest.applications.flatMap((app) => app.functions.map((fn) => fn.name)).join(", ") ||
+        "(none)");
+}
+function targetForFunction(manifest, name) {
+    const found = findFunction(manifest, name);
+    if (!found) {
+        throw new errors_js_1.CliError(`Function "${name}" was not found. Existing functions: ${functionNames(manifest)}.`);
+    }
+    return { kind: "function", appName: found.app, functionName: found.fn };
+}
+function targetForService(manifest, name) {
+    const found = findService(manifest, name);
+    if (!found) {
+        throw new errors_js_1.CliError(`Application "${name}" was not found. Existing applications: ${serviceNames(manifest)}.`);
+    }
+    return { kind: "service", appName: found };
+}
+// A bare name is resolved by looking it up. It is only ambiguous when a function and
+// an application share a name, and then the flag settles it rather than a guess.
+function targetForName(manifest, name) {
+    const asFunction = findFunction(manifest, name);
+    const asService = findService(manifest, name);
+    if (asFunction && asService) {
+        throw new errors_js_1.CliError(`"${name}" is both a function and an application. Pass --function ${name} or --service ${name} to say which.`);
+    }
+    if (asFunction) {
+        return { kind: "function", appName: asFunction.app, functionName: asFunction.fn };
+    }
+    if (asService) {
+        return { kind: "service", appName: asService };
+    }
+    throw new errors_js_1.CliError(`Nothing named "${name}" in this project.\n  functions:    ${functionNames(manifest)}\n  applications: ${serviceNames(manifest)}`);
+}
+async function resolveRemovalTarget(manifest, options) {
+    const service = options.service ?? options.app;
+    if (options.function && service) {
+        throw new errors_js_1.CliError('Pass either "--function" or "--service", not both.');
+    }
+    if (options.function) {
+        return targetForFunction(manifest, options.function);
+    }
+    if (service) {
+        return targetForService(manifest, service);
+    }
+    if (options.name) {
+        return targetForName(manifest, options.name);
+    }
+    if (!process.stdin.isTTY) {
+        throw new errors_js_1.CliError('Non-interactive mode needs a name, "--function <name>" or "--service <name>".');
+    }
+    const { select } = await import("@inquirer/prompts");
+    const kind = await select({
+        message: "What do you want to remove?",
+        choices: [
+            { name: "A function", value: "function" },
+            { name: "An application — and every function in it", value: "service" },
+        ],
+    });
+    if (manifest.applications.length === 0) {
+        throw new errors_js_1.CliError("This project has no applications to remove.");
+    }
+    if (kind === "service") {
+        const appName = await select({
+            message: "Application:",
+            choices: manifest.applications.map((app) => ({
+                name: `${app.name} (${app.functions.length} function${app.functions.length === 1 ? "" : "s"})`,
+                value: app.name,
+            })),
+        });
+        return { kind: "service", appName };
+    }
+    const choices = manifest.applications.flatMap((app) => app.functions.map((fn) => ({
+        name: `${app.name}/${fn.name}${fn.apiGateway.enabled ? `  ${fn.apiGateway.method ?? "GET"} ${fn.apiGateway.path ?? ""}` : ""}`,
+        value: `${app.name}.${fn.name}`,
+    })));
+    if (choices.length === 0) {
+        throw new errors_js_1.CliError("This project has no functions to remove.");
+    }
+    const picked = await select({ message: "Function:", choices });
+    const [appName, functionName] = picked.split(".");
+    return { kind: "function", appName, functionName };
+}

package/dist/commands/rm/types.d.ts

@@ -0,0 +1,7 @@
+export interface RmOptions {
+    name?: string;
+    function?: string;
+    service?: string;
+    app?: string;
+    yes?: boolean;
+}

package/dist/commands/rm/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/commands/run/action.d.ts

@@ -0,0 +1,2 @@
+import type { RunOptions } from "./types.js";
+export declare function runAction(options: RunOptions): Promise<void>;

package/dist/commands/run/action.js

@@ -0,0 +1,171 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runAction = runAction;
+const errors_js_1 = require("../../core/errors.js");
+const logger_js_1 = require("../../core/logger.js");
+const environments_js_1 = require("../../core/environments.js");
+const parameters_js_1 = require("../env/parameters.js");
+const templates_js_1 = require("../env/templates.js");
+const manifest_js_1 = require("./manifest.js");
+const sam_cli_js_1 = require("./sam-cli.js");
+const watch_js_1 = require("./watch.js");
+const local_template_js_1 = require("./local-template.js");
+const scope_js_1 = require("../../core/scope.js");
+const DEFAULT_PORT = 3000;
+function parsePort(value) {
+    if (value === undefined) {
+        return DEFAULT_PORT;
+    }
+    const parsed = Number(value);
+    if (!Number.isInteger(parsed) || parsed <= 0 || parsed > 65535) {
+        throw new errors_js_1.CliError(`Invalid port "${value}".`);
+    }
+    return parsed;
+}
+function applicationsOf(manifest) {
+    return manifest.applications ?? [];
+}
+async function resolveRunScope(manifest, options) {
+    const fromFlags = (0, scope_js_1.scopeFromFlags)(manifest, options);
+    if (fromFlags) {
+        return fromFlags;
+    }
+    if (!process.stdin.isTTY) {
+        return scope_js_1.allScope;
+    }
+    return (0, scope_js_1.promptForScope)(manifest, "run", "Everything — every service");
+}
+function syncAndResolve(cwd, environment) {
+    const project = (0, environments_js_1.readManifest)(cwd, "slskit run");
+    // A variable can appear just by being typed into a .env file, so the templates are
+    // brought back in step before sam reads them.
+    const rewritten = (0, templates_js_1.syncTemplates)(cwd, project);
+    if (rewritten.length > 0) {
+        logger_js_1.logger.info(`Updated ${rewritten.length} template(s) for the current variables.`);
+    }
+    return (0, parameters_js_1.toCliArguments)((0, parameters_js_1.parameterOverrides)(cwd, project, environment));
+}
+function exited(child) {
+    return new Promise((resolve) => {
+        child.once("close", (code, signal) => resolve({ code, signal }));
+    });
+}
+async function runAction(options) {
+    const cwd = process.cwd();
+    const manifest = (0, manifest_js_1.readManifest)(cwd);
+    const project = (0, environments_js_1.readManifest)(cwd, "slskit run");
+    const environment = (0, environments_js_1.resolveEnvironmentName)(project, options.env);
+    const port = parsePort(options.port);
+    // Resolved before sam runs so a missing secret fails fast rather than after a build.
+    let overrides = syncAndResolve(cwd, environment);
+    const scope = await resolveRunScope(project, options);
+    // Two reasons to serve a flattened copy rather than the real templates: a shared API
+    // Gateway lives in the root stack, which sam local cannot resolve from a nested one;
+    // and running part of the project means serving a template with only those functions
+    // in it, so sam builds only those.
+    const flattened = (0, local_template_js_1.needsLocalTemplate)(project) || scope.kind !== "all";
+    const buildTarget = flattened
+        ? { template: (0, local_template_js_1.writeLocalTemplate)(cwd, project, scope), buildDir: local_template_js_1.LOCAL_BUILD_DIR }
+        : {};
+    const servedTemplate = flattened ? (0, local_template_js_1.localBuiltTemplate)() : undefined;
+    await (0, sam_cli_js_1.ensureSamCliInstalled)();
+    if (options.build !== false) {
+        (0, sam_cli_js_1.samBuild)(cwd, buildTarget);
+    }
+    logger_js_1.logger.info(`\nRunning ${scope.label} of "${manifest.name}" locally on a single API Gateway port.`);
+    logger_js_1.logger.info(`  ${environments_js_1.APP_ENVIRONMENT_KEY}=${environment}`);
+    logger_js_1.logger.info(`Every application's routes are served from one local API at http://127.0.0.1:${port}`);
+    const watching = options.watch !== false;
+    if (watching) {
+        logger_js_1.logger.info("Watching src/ — save a file and only that function is rebuilt.");
+    }
+    logger_js_1.logger.info("Press Ctrl+C to stop.\n");
+    let child = (0, sam_cli_js_1.startLocalApi)(cwd, port, overrides, servedTemplate);
+    let stopping = false;
+    let restarting = false;
+    // Anything a save triggers has to survive a broken file: a rebuild that fails
+    // leaves the previous build serving and waits for the next save.
+    const rebuildFunctions = (resourceIds, labels) => {
+        logger_js_1.logger.info(`\n> ${(0, watch_js_1.describeChange)(labels)} changed — rebuilding`);
+        for (const resourceId of resourceIds) {
+            if (!(0, sam_cli_js_1.samBuildResource)(cwd, resourceId, buildTarget)) {
+                logger_js_1.logger.error(`Build failed for ${resourceId}. Fix it and save again.`);
+                return;
+            }
+        }
+        logger_js_1.logger.info("Rebuilt. The next request uses the new code.\n");
+    };
+    const rebuildAll = (labels) => {
+        logger_js_1.logger.info(`\n> ${(0, watch_js_1.describeChange)(labels)} changed — rebuilding everything`);
+        if (!(0, sam_cli_js_1.samRebuild)(cwd, buildTarget)) {
+            logger_js_1.logger.error("Build failed. Fix it and save again.");
+            return;
+        }
+        logger_js_1.logger.info("Rebuilt. The next request uses the new code.\n");
+    };
+    // Routes and parameter values are only read when sam starts, so these changes
+    // cannot be picked up by swapping an artifact.
+    const restart = (labels) => {
+        logger_js_1.logger.info(`\n> ${(0, watch_js_1.describeChange)(labels)} changed — restarting the local API`);
+        let next;
+        try {
+            next = syncAndResolve(cwd, environment);
+            if (flattened) {
+                (0, local_template_js_1.writeLocalTemplate)(cwd, (0, environments_js_1.readManifest)(cwd, "slskit run"), scope);
+            }
+        }
+        catch (error) {
+            logger_js_1.logger.error(error instanceof Error ? error.message : String(error));
+            return;
+        }
+        if (!(0, sam_cli_js_1.samRebuild)(cwd, buildTarget)) {
+            logger_js_1.logger.error("Build failed. Fix it and save again.");
+            return;
+        }
+        overrides = next;
+        restarting = true;
+        child.kill("SIGINT");
+    };
+    const watcher = watching
+        ? (0, watch_js_1.watchProject)(cwd, applicationsOf(project).filter((app) => scope.kind === "all" || app.name === scope.service), {
+            onFunctions: rebuildFunctions,
+            onFull: rebuildAll,
+            onRestart: restart,
+        }, flattened)
+        : undefined;
+    const stop = () => {
+        if (stopping) {
+            return;
+        }
+        stopping = true;
+        watcher?.close();
+        child.kill("SIGINT");
+    };
+    process.on("SIGINT", stop);
+    process.on("SIGTERM", stop);
+    try {
+        for (;;) {
+            const { code, signal } = await exited(child);
+            if (stopping) {
+                return;
+            }
+            if (restarting) {
+                restarting = false;
+                child = (0, sam_cli_js_1.startLocalApi)(cwd, port, overrides, servedTemplate);
+                continue;
+            }
+            if (signal) {
+                return;
+            }
+            if (code !== 0) {
+                throw new errors_js_1.CliError(`sam local start-api exited with code ${code ?? 1}`);
+            }
+            return;
+        }
+    }
+    finally {
+        watcher?.close();
+        process.removeListener("SIGINT", stop);
+        process.removeListener("SIGTERM", stop);
+    }
+}

package/dist/commands/run/index.d.ts

@@ -0,0 +1,2 @@
+import { Command } from "commander";
+export declare function registerRunCommand(program: Command): void;

package/dist/commands/run/index.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerRunCommand = registerRunCommand;
+const run_js_1 = require("../../core/run.js");
+function registerRunCommand(program) {
+    program
+        .command("run")
+        .description("Run the generated SAM project locally (every application served from one API Gateway port)")
+        .argument("[environment]", "Environment to run with (example: dev, staging) — defaults to the default environment")
+        .option("-p, --port <port>", "Local API Gateway port", "3000")
+        .option("-s, --service <name>", "Run every function in one service")
+        .option("--function <name>", "Run one function on its own")
+        .option("--all", "Run everything without being asked what to run", false)
+        .option("--no-build", 'Skip "sam build" before starting the local API')
+        .option("--no-watch", "Do not rebuild on file changes (stop and re-run to pick up edits)")
+        .option("-e, --env <name>", "Environment whose variables to run with (default: the default environment)")
+        .action((environment, options) => (0, run_js_1.runCommand)(async () => {
+        const { runAction } = await import("./action.js");
+        await runAction({ ...options, env: environment ?? options.env });
+    }));
+}

package/dist/commands/run/local-template.d.ts

@@ -0,0 +1,7 @@
+import type { ProjectManifest } from "../../core/environments.js";
+import type { Scope } from "../../core/scope.js";
+export declare const LOCAL_TEMPLATE_FILE = ".slskit-local.yaml";
+export declare const LOCAL_BUILD_DIR: string;
+export declare function needsLocalTemplate(manifest: ProjectManifest): boolean;
+export declare function writeLocalTemplate(cwd: string, manifest: ProjectManifest, scope?: Scope): string;
+export declare function localBuiltTemplate(): string;

package/dist/commands/run/local-template.js

@@ -0,0 +1,51 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LOCAL_BUILD_DIR = exports.LOCAL_TEMPLATE_FILE = void 0;
+exports.needsLocalTemplate = needsLocalTemplate;
+exports.writeLocalTemplate = writeLocalTemplate;
+exports.localBuiltTemplate = localBuiltTemplate;
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_path_1 = __importDefault(require("node:path"));
+const keys_js_1 = require("../env/keys.js");
+const manifest_js_1 = require("../function/manifest.js");
+const sam_js_1 = require("../init/templates/sam.js");
+const scope_js_1 = require("../../core/scope.js");
+// Written at the project root so the flat template's "CodeUri: ./" resolves the same
+// way the deployed templates' paths do.
+exports.LOCAL_TEMPLATE_FILE = ".slskit-local.yaml";
+exports.LOCAL_BUILD_DIR = node_path_1.default.join(".aws-sam", "local");
+// A shared API Gateway lives in the root stack, and SAM local cannot resolve an API
+// that a nested stack only holds an id for -- every route comes back 502. So local
+// runs get a flattened copy of the same project instead. It is generated from the
+// manifest on every run, so it can never drift from what gets deployed.
+function needsLocalTemplate(manifest) {
+    const api = manifest.apiGateway;
+    return Boolean(api?.enabled) && api?.perService === false;
+}
+// Narrowing the template to one service or one function is what makes a scoped run
+// fast: sam only builds the functions the template still contains.
+function narrow(apps, scope) {
+    if (scope.kind === "all") {
+        return apps;
+    }
+    return apps
+        .filter((app) => app.name === scope.service)
+        .map((app) => ({
+        ...app,
+        functions: app.functions.filter((fn) => scope.kind !== "function" || fn.name === scope.functionName),
+    }));
+}
+function writeLocalTemplate(cwd, manifest, scope = scope_js_1.allScope) {
+    const functionView = manifest;
+    const answers = (0, manifest_js_1.toInitAnswers)(functionView);
+    const apps = narrow((0, manifest_js_1.toServiceDefs)(functionView), scope);
+    node_fs_1.default.writeFileSync(node_path_1.default.join(cwd, exports.LOCAL_TEMPLATE_FILE), (0, sam_js_1.samFlatTemplate)(answers, apps, (0, keys_js_1.projectEnvKeys)(cwd, manifest)));
+    return exports.LOCAL_TEMPLATE_FILE;
+}
+// The built template sam local serves, rather than the source one.
+function localBuiltTemplate() {
+    return node_path_1.default.join(exports.LOCAL_BUILD_DIR, "template.yaml");
+}

package/dist/commands/run/manifest.d.ts

@@ -0,0 +1,2 @@
+import type { ProjectManifestFile } from "./types.js";
+export declare function readManifest(cwd: string): ProjectManifestFile;

package/dist/commands/run/manifest.js

@@ -0,0 +1,20 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.readManifest = readManifest;
+const node_fs_1 = __importDefault(require("node:fs"));
+const errors_js_1 = require("../../core/errors.js");
+const environments_js_1 = require("../../core/environments.js");
+function readManifest(cwd) {
+    const manifestPath = (0, environments_js_1.manifestPathFor)(cwd);
+    if (!manifestPath) {
+        throw new errors_js_1.CliError(`No slskit.json found in ${cwd}. Run "slskit init" first, or run "slskit run" from your project root.`);
+    }
+    const manifest = JSON.parse(node_fs_1.default.readFileSync(manifestPath, "utf8"));
+    if (manifest.framework?.id !== "sam") {
+        throw new errors_js_1.CliError(`"slskit run" supports AWS SAM projects only (this project uses "${manifest.framework?.id ?? "unknown"}").`);
+    }
+    return manifest;
+}

package/dist/commands/run/resources.d.ts

@@ -0,0 +1,20 @@
+export type ChangeKind = "function" | "full" | "restart";
+export interface Change {
+    kind: ChangeKind;
+    /** Set only for "function": the resource id sam build takes, e.g. AuthStack/LoginFunction. */
+    resourceId?: string;
+    label: string;
+}
+export interface ApplicationView {
+    name: string;
+    functions?: {
+        name: string;
+    }[];
+}
+export declare function resourceIdFor(appName: string, functionName: string, sharedApi?: boolean): string;
+export declare function classifyChange(applications: ApplicationView[], relativePath: string, sharedApi?: boolean): Change;
+export declare function planRebuild(changes: Change[]): {
+    kind: ChangeKind;
+    resourceIds: string[];
+    labels: string[];
+};