slskit-cli 1.0.0

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

@@ -0,0 +1,21 @@
+export interface EnvAddOptions {
+    profile?: string;
+    region?: string;
+    stackName?: string;
+    skipVerify?: boolean;
+}
+export interface EnvRemoveOptions {
+    yes?: boolean;
+}
+export interface EnvSetOptions {
+    env?: string;
+    secret?: boolean;
+    ssm?: string;
+}
+export interface EnvUnsetOptions {
+    env?: string;
+}
+export interface EnvVarsOptions {
+    env?: string;
+    showSecrets?: boolean;
+}

package/dist/commands/env/types.js

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

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

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

package/dist/commands/function/action.js

@@ -0,0 +1,71 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.functionAction = functionAction;
+const node_child_process_1 = require("node:child_process");
+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 keys_js_1 = require("../env/keys.js");
+const logger_js_1 = require("../../core/logger.js");
+const types_js_1 = require("../init/types.js");
+const generator_js_1 = require("./generator.js");
+const manifest_js_1 = require("./manifest.js");
+const prompts_js_1 = require("./prompts.js");
+const tooling_js_1 = require("./tooling.js");
+function runNpmInstall(root) {
+    logger_js_1.logger.info("\nInstalling npm dependencies...");
+    const result = (0, node_child_process_1.spawnSync)("npm", ["install"], {
+        cwd: root,
+        stdio: "inherit",
+        shell: process.platform === "win32",
+    });
+    if (result.error) {
+        throw new errors_js_1.CliError(`Failed to run npm install: ${result.error.message}`);
+    }
+    if (result.status !== 0) {
+        throw new errors_js_1.CliError(`npm install exited with code ${result.status ?? 1}`);
+    }
+}
+async function functionAction(options) {
+    const root = process.cwd();
+    const manifest = (0, manifest_js_1.readProjectManifest)(root);
+    const answers = (0, manifest_js_1.toInitAnswers)(manifest);
+    const apps = (0, manifest_js_1.toServiceDefs)(manifest);
+    const picked = await (0, prompts_js_1.collectFunctionAnswers)(manifest, options);
+    const fn = {
+        name: picked.functionName,
+        httpPath: (0, prompts_js_1.functionHttpPath)(picked.appName, picked.functionName),
+        method: picked.method,
+        runtime: picked.runtime,
+        memorySize: picked.memorySize,
+    };
+    const sameFamily = (0, types_js_1.sameRuntimeFamily)(picked.runtime, answers.runtime);
+    const { files, appTemplatePath, rootTemplatePath } = (0, generator_js_1.generateFunction)(answers, apps, picked.appName, picked.isNewApp, fn, manifest.structure.files, (0, keys_js_1.projectEnvKeys)(root, manifest), { version: manifest.version, environments: manifest.environments });
+    for (const [relativePath, contents] of Object.entries(files)) {
+        const fullPath = node_path_1.default.join(root, relativePath);
+        node_fs_1.default.mkdirSync(node_path_1.default.dirname(fullPath), { recursive: true });
+        node_fs_1.default.writeFileSync(fullPath, contents);
+    }
+    if ((0, tooling_js_1.ensureToolingForRuntime)(root, answers, picked.runtime)) {
+        runNpmInstall(root);
+    }
+    logger_js_1.logger.info(`\nAdded "${picked.functionName}" to application "${picked.appName}"${picked.isNewApp ? " (new application)" : ""}.`);
+    logger_js_1.logger.info(`  language:  ${picked.runtime}`);
+    logger_js_1.logger.info(`  memory:    ${picked.memorySize} MB`);
+    if (manifest.apiGateway.enabled) {
+        logger_js_1.logger.info(`  route:     ${picked.method} ${fn.httpPath}`);
+    }
+    logger_js_1.logger.info(`  handler:   ${types_js_1.SRC_DIR}/functions/${picked.appName}/${picked.functionName}`);
+    logger_js_1.logger.info(`  service:   ${types_js_1.SRC_DIR}/services/${picked.appName}/${picked.functionName}`);
+    logger_js_1.logger.info(`  template:  ${appTemplatePath}`);
+    if (rootTemplatePath) {
+        logger_js_1.logger.info(`  template:  ${rootTemplatePath} (root stack updated)`);
+    }
+    if (!sameFamily) {
+        logger_js_1.logger.info(`\nNote: "${picked.functionName}" uses a different language family than the rest of the project, so it was generated standalone (no shared layer, no database wiring).`);
+    }
+    logger_js_1.logger.info('\nRun "slskit run" to try it locally.');
+}

package/dist/commands/function/generator.d.ts

@@ -0,0 +1,8 @@
+import type { InitAnswers, ServiceDef, ServiceFunction } from "../init/types.js";
+import type { PreservedState } from "../init/manifest.js";
+export interface GeneratedFunction {
+    files: Record<string, string>;
+    appTemplatePath: string;
+    rootTemplatePath?: string;
+}
+export declare function generateFunction(answers: InitAnswers, apps: ServiceDef[], appName: string, isNewApp: boolean, fn: ServiceFunction, existingGeneratedFiles: string[], envKeys?: string[], preserved?: PreservedState): GeneratedFunction;

package/dist/commands/function/generator.js

@@ -0,0 +1,58 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateFunction = generateFunction;
+const types_js_1 = require("../init/types.js");
+const manifest_js_1 = require("../init/manifest.js");
+const node_js_1 = require("../init/templates/node.js");
+const python_js_1 = require("../init/templates/python.js");
+const sam_js_1 = require("../init/templates/sam.js");
+function handlerSource(answers, appName, fn, fnRuntime) {
+    if (fnRuntime === "python") {
+        return (0, python_js_1.pythonHandler)(appName, fn);
+    }
+    return (0, node_js_1.nodeHandler)(answers, appName, fn, fnRuntime === "typescript");
+}
+function serviceSource(answers, fn, fnRuntime, sameFamily) {
+    if (fnRuntime === "python") {
+        return sameFamily ? (0, python_js_1.pythonService)(answers, fn) : (0, python_js_1.standalonePythonService)(fn);
+    }
+    return sameFamily
+        ? (0, node_js_1.nodeService)(answers, fn, fnRuntime === "typescript")
+        : (0, node_js_1.standaloneNodeService)(fn, fnRuntime === "typescript");
+}
+// Attaches `fn` to `appName` (existing or new) and regenerates every file that must
+// stay consistent with it: the handler, the service, that app's own infra template,
+// the root template.yaml when a SAM app is brand new, and slskit.json.
+function generateFunction(answers, apps, appName, isNewApp, fn, existingGeneratedFiles, envKeys = [], preserved = {}) {
+    const fnRuntime = fn.runtime ?? answers.runtime;
+    const sameFamily = (0, types_js_1.sameRuntimeFamily)(fnRuntime, answers.runtime);
+    const files = {};
+    if (fnRuntime === "python") {
+        files[`${types_js_1.SRC_DIR}/__init__.py`] = "";
+        files[`${types_js_1.SRC_DIR}/functions/__init__.py`] = "";
+        files[`${types_js_1.SRC_DIR}/services/__init__.py`] = "";
+        files[`${types_js_1.SRC_DIR}/functions/${appName}/__init__.py`] = "";
+        files[`${types_js_1.SRC_DIR}/services/${appName}/__init__.py`] = "";
+        files[`${types_js_1.SRC_DIR}/functions/${appName}/${fn.name}/__init__.py`] = "";
+    }
+    files[`${types_js_1.SRC_DIR}/functions/${appName}/${fn.name}/${(0, types_js_1.handlerFileName)(fnRuntime)}`] =
+        handlerSource(answers, appName, fn, fnRuntime);
+    files[`${types_js_1.SRC_DIR}/services/${appName}/${fn.name}.${(0, types_js_1.sourceExt)(fnRuntime)}`] = serviceSource(answers, fn, fnRuntime, sameFamily);
+    const targetApp = {
+        name: appName,
+        functions: [...(apps.find((app) => app.name === appName)?.functions ?? []), fn],
+    };
+    const updatedApps = isNewApp
+        ? [...apps, targetApp]
+        : apps.map((app) => (app.name === appName ? targetApp : app));
+    const appTemplatePath = (0, types_js_1.serviceTemplatePath)(appName);
+    files[appTemplatePath] = (0, sam_js_1.samServiceTemplate)(answers, targetApp, envKeys);
+    let rootTemplatePath;
+    if (isNewApp) {
+        rootTemplatePath = "template.yaml";
+        files[rootTemplatePath] = (0, sam_js_1.samRootTemplate)(answers, updatedApps, envKeys);
+    }
+    const generatedFiles = Array.from(new Set([...existingGeneratedFiles, ...Object.keys(files)])).sort();
+    files["slskit.json"] = `${JSON.stringify((0, manifest_js_1.buildProjectManifest)(answers, updatedApps, generatedFiles, preserved), null, 2)}\n`;
+    return { files, appTemplatePath, rootTemplatePath };
+}

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

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

package/dist/commands/function/index.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerFunctionCommand = registerFunctionCommand;
+const run_js_1 = require("../../core/run.js");
+function registerFunctionCommand(program) {
+    program
+        .command("function")
+        .description("Add a function to an existing or new application in this project")
+        .argument("[name]", "Function name")
+        .option("--app <name>", "Existing application to attach the function to")
+        .option("--new-app <name>", "Create a new application with this name")
+        .option("--method <method>", "GET | POST | PUT | DELETE | PATCH")
+        .option("--memory <mb>", "Function memory size: 128 | 256 | 512 | 1024 | 2048 | 3008 | 4096 | 10240")
+        .option("-r, --runtime <runtime>", "typescript | javascript | python")
+        .action((name, options) => (0, run_js_1.runCommand)(async () => {
+        const { functionAction } = await import("./action.js");
+        await functionAction({
+            name: name ?? options.name,
+            app: options.app,
+            newApp: options.newApp,
+            method: options.method,
+            memory: options.memory,
+            runtime: options.runtime,
+        });
+    }));
+}

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

@@ -0,0 +1,5 @@
+import type { InitAnswers, ServiceDef } from "../init/types.js";
+import type { ProjectManifest } from "./types.js";
+export declare function readProjectManifest(cwd: string, command?: string): ProjectManifest;
+export declare function toInitAnswers(manifest: ProjectManifest): InitAnswers;
+export declare function toServiceDefs(manifest: ProjectManifest): ServiceDef[];

package/dist/commands/function/manifest.js

@@ -0,0 +1,57 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.readProjectManifest = readProjectManifest;
+exports.toInitAnswers = toInitAnswers;
+exports.toServiceDefs = toServiceDefs;
+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 readProjectManifest(cwd, command = "slskit function") {
+    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 "${command}" 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(`"${command}" supports AWS SAM projects only (this project uses "${manifest.framework?.id ?? "unknown"}").`);
+    }
+    return manifest;
+}
+// The manifest stores the AWS Lambda runtime string (e.g. "nodejs20.x"), which loses
+// the TypeScript/JavaScript distinction; the generated handler's extension still has it.
+function runtimeFromHandlerFile(handlerFile) {
+    if (handlerFile.endsWith(".ts")) {
+        return "typescript";
+    }
+    if (handlerFile.endsWith(".py")) {
+        return "python";
+    }
+    return "javascript";
+}
+function toInitAnswers(manifest) {
+    return {
+        name: manifest.name,
+        runtime: manifest.runtime.id,
+        database: manifest.database.id,
+        apiGateway: manifest.apiGateway.enabled,
+        sharedApi: manifest.apiGateway.enabled && manifest.apiGateway.perService === false,
+        layer: manifest.layer.enabled,
+        memorySize: manifest.functions.memorySize,
+        force: false,
+    };
+}
+function toServiceDefs(manifest) {
+    return manifest.applications.map((app) => ({
+        name: app.name,
+        functions: app.functions.map((fn) => ({
+            name: fn.name,
+            httpPath: fn.apiGateway.path ?? `/${app.name}/${fn.name}`,
+            method: fn.apiGateway.method ?? "GET",
+            runtime: runtimeFromHandlerFile(fn.handlerFile),
+            memorySize: fn.memorySize,
+        })),
+    }));
+}

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

@@ -0,0 +1,18 @@
+import type { HttpMethod, MemorySize, RuntimeId } from "../init/types.js";
+import type { FunctionOptions, ProjectManifest } from "./types.js";
+export declare function functionHttpPath(appName: string, functionName: string): string;
+export declare function functionNameProblem(manifest: ProjectManifest, appName: string, value: string): string | undefined;
+export declare function applicationNameProblem(manifest: ProjectManifest, value: string): string | undefined;
+export interface ApplicationTarget {
+    appName: string;
+    isNewApp: boolean;
+}
+export interface FunctionAnswers {
+    appName: string;
+    isNewApp: boolean;
+    functionName: string;
+    method: HttpMethod;
+    memorySize: MemorySize;
+    runtime: RuntimeId;
+}
+export declare function collectFunctionAnswers(manifest: ProjectManifest, options: FunctionOptions): Promise<FunctionAnswers>;

package/dist/commands/function/prompts.js

@@ -0,0 +1,196 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.functionHttpPath = functionHttpPath;
+exports.functionNameProblem = functionNameProblem;
+exports.applicationNameProblem = applicationNameProblem;
+exports.collectFunctionAnswers = collectFunctionAnswers;
+const errors_js_1 = require("../../core/errors.js");
+const logger_js_1 = require("../../core/logger.js");
+const prompts_js_1 = require("../init/prompts.js");
+const types_js_1 = require("../init/types.js");
+const HTTP_METHODS = ["GET", "POST", "PUT", "DELETE", "PATCH"];
+const IDENTIFIER = /^[A-Za-z][A-Za-z0-9]*$/;
+function parseMethod(value) {
+    if (!value) {
+        return undefined;
+    }
+    const upper = value.trim().toUpperCase();
+    if (!HTTP_METHODS.includes(upper)) {
+        throw new errors_js_1.CliError(`Unknown HTTP method "${value}". Expected ${HTTP_METHODS.join(", ")}.`);
+    }
+    return upper;
+}
+// The route "slskit function" gives a new function. Kept here so the uniqueness
+// check and the generator can never disagree about what is being created.
+function functionHttpPath(appName, functionName) {
+    return `/${appName}/${functionName}`;
+}
+// A function name has to be unique across the whole project, not just its own
+// application: the Lambda is physically named <project>-<environment>-<function>,
+// and with one shared API Gateway the template's logical id is <Name>Function. Both
+// are project-scoped, so reusing a name in another application silently replaces the
+// first function instead of failing -- SAM validates and builds it without complaint.
+function findFunctionNamed(manifest, name) {
+    const wanted = name.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 findRoute(manifest, method, path) {
+    for (const app of manifest.applications) {
+        for (const fn of app.functions) {
+            if (fn.apiGateway.enabled &&
+                fn.apiGateway.path === path &&
+                (fn.apiGateway.method ?? "GET").toUpperCase() === method.toUpperCase()) {
+                return { app: app.name, fn: fn.name };
+            }
+        }
+    }
+    return undefined;
+}
+// Returns the reason this name cannot be used, or undefined when it is free.
+function functionNameProblem(manifest, appName, value) {
+    const trimmed = value.trim();
+    if (!IDENTIFIER.test(trimmed)) {
+        return `Function name must start with a letter and contain only letters and numbers (got "${value}").`;
+    }
+    const clash = findFunctionNamed(manifest, trimmed);
+    if (clash) {
+        return clash.app === appName
+            ? `Function "${clash.fn}" already exists in application "${appName}". Choose another name.`
+            : `Function "${clash.fn}" already exists in application "${clash.app}", and every function in a project needs its own name. Choose another name.`;
+    }
+    return undefined;
+}
+function applicationNameProblem(manifest, value) {
+    const trimmed = value.trim();
+    if (!IDENTIFIER.test(trimmed)) {
+        return `Application name must start with a letter and contain only letters and numbers (got "${value}").`;
+    }
+    if (manifest.applications.some((app) => app.name === trimmed)) {
+        return `Application "${trimmed}" already exists. Choose another name, or add to it with --app ${trimmed}.`;
+    }
+    return undefined;
+}
+async function resolveApplication(manifest, options) {
+    if (options.app && options.newApp) {
+        throw new errors_js_1.CliError('Pass either "--app" or "--new-app", not both.');
+    }
+    if (options.newApp) {
+        const problem = applicationNameProblem(manifest, options.newApp);
+        if (problem) {
+            throw new errors_js_1.CliError(problem);
+        }
+        return { appName: options.newApp.trim(), isNewApp: true };
+    }
+    if (options.app) {
+        const existing = manifest.applications.find((app) => app.name === options.app);
+        if (!existing) {
+            const known = manifest.applications.map((app) => app.name).join(", ") || "(none)";
+            throw new errors_js_1.CliError(`Application "${options.app}" was not found. Existing: ${known}.`);
+        }
+        return { appName: existing.name, isNewApp: false };
+    }
+    if (!process.stdin.isTTY) {
+        throw new errors_js_1.CliError('Non-interactive mode needs "--app <name>" or "--new-app <name>".');
+    }
+    const { select, input } = await import("@inquirer/prompts");
+    const target = await select({
+        message: "Add this function to:",
+        choices: [
+            { name: "An existing application", value: "existing" },
+            { name: "A new application", value: "new" },
+        ],
+    });
+    if (target === "new") {
+        // validate re-asks in place, so a name that is taken costs one keystroke
+        // rather than the whole command.
+        const name = await input({
+            message: "New application name:",
+            required: true,
+            validate: (value) => applicationNameProblem(manifest, value) ?? true,
+        });
+        return { appName: name.trim(), isNewApp: true };
+    }
+    if (manifest.applications.length === 0) {
+        throw new errors_js_1.CliError('This project has no applications yet. Choose "A new application" instead.');
+    }
+    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,
+        })),
+    });
+    const existingApp = manifest.applications.find((app) => app.name === appName);
+    if (existingApp && existingApp.functions.length > 0) {
+        logger_js_1.logger.info(`\nExisting functions in "${appName}": ${existingApp.functions.map((fn) => fn.name).join(", ")}`);
+    }
+    return { appName, isNewApp: false };
+}
+async function collectFunctionAnswers(manifest, options) {
+    const { appName, isNewApp } = await resolveApplication(manifest, options);
+    let functionName = options.name?.trim();
+    let method = parseMethod(options.method);
+    let memorySize = (0, prompts_js_1.parseMemory)(options.memory);
+    let runtime = (0, prompts_js_1.parseAlias)(options.runtime, prompts_js_1.RUNTIME_ALIASES, "runtime");
+    const needsPrompt = !functionName || (manifest.apiGateway.enabled && !method) || !memorySize || !runtime;
+    if (needsPrompt && !process.stdin.isTTY) {
+        throw new errors_js_1.CliError('Non-interactive mode needs a function name plus "--method", "--memory", and "--runtime".');
+    }
+    if (needsPrompt) {
+        const { input, select } = await import("@inquirer/prompts");
+        functionName ?? (functionName = await input({
+            message: "Function name:",
+            required: true,
+            validate: (value) => functionNameProblem(manifest, appName, value) ?? true,
+        }));
+        if (manifest.apiGateway.enabled) {
+            method ?? (method = await select({
+                message: "HTTP method:",
+                choices: HTTP_METHODS.map((value) => ({ name: value, value })),
+            }));
+        }
+        memorySize ?? (memorySize = await select({
+            message: "Function memory size:",
+            default: manifest.functions.memorySize,
+            choices: types_js_1.MEMORY_SIZES.map((size) => ({ name: (0, prompts_js_1.memoryLabel)(size), value: size })),
+        }));
+        runtime ?? (runtime = await select({
+            message: "Language:",
+            default: manifest.runtime.id,
+            choices: [
+                { name: "TypeScript (Node.js)", value: "typescript" },
+                { name: "JavaScript (Node.js)", value: "javascript" },
+                { name: "Python", value: "python" },
+            ],
+        }));
+    }
+    const name = (functionName ?? "").trim();
+    // Reached with --name on a non-interactive run, where there is nothing to re-ask.
+    const problem = functionNameProblem(manifest, appName, name);
+    if (problem) {
+        throw new errors_js_1.CliError(problem);
+    }
+    const path = functionHttpPath(appName, name);
+    const chosenMethod = method ?? "GET";
+    const routeClash = manifest.apiGateway.enabled
+        ? findRoute(manifest, chosenMethod, path)
+        : undefined;
+    if (routeClash) {
+        throw new errors_js_1.CliError(`${chosenMethod} ${path} is already served by "${routeClash.app}/${routeClash.fn}". Choose another name or method.`);
+    }
+    return {
+        appName,
+        isNewApp,
+        functionName: name,
+        method: chosenMethod,
+        memorySize: memorySize,
+        runtime: runtime,
+    };
+}

package/dist/commands/function/tooling.d.ts

@@ -0,0 +1,2 @@
+import type { InitAnswers, RuntimeId } from "../init/types.js";
+export declare function ensureToolingForRuntime(root: string, answers: InitAnswers, fnRuntime: RuntimeId): boolean;

package/dist/commands/function/tooling.js

@@ -0,0 +1,43 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ensureToolingForRuntime = ensureToolingForRuntime;
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_path_1 = __importDefault(require("node:path"));
+const project_js_1 = require("../init/templates/project.js");
+// A function whose language differs from the project's original runtime may need
+// tooling the project never installed (esbuild for a first node function in a
+// python project, or typescript for a first TS function in a plain JS project).
+// Returns true if package.json changed, so the caller knows to re-run npm install.
+function ensureToolingForRuntime(root, answers, fnRuntime) {
+    if (fnRuntime === "python") {
+        return false;
+    }
+    const pkgPath = node_path_1.default.join(root, "package.json");
+    const pkg = JSON.parse(node_fs_1.default.readFileSync(pkgPath, "utf8"));
+    pkg.dependencies ?? (pkg.dependencies = {});
+    pkg.devDependencies ?? (pkg.devDependencies = {});
+    let changed = false;
+    if (!pkg.dependencies.esbuild && !pkg.devDependencies.esbuild) {
+        // sam build stages the project with `npm install --omit=dev`, so esbuild must be a regular dependency.
+        pkg.dependencies.esbuild = "^0.25.0";
+        changed = true;
+    }
+    if (fnRuntime === "typescript" && !pkg.devDependencies.typescript) {
+        pkg.devDependencies.typescript = "^5.7.2";
+        pkg.devDependencies["@types/node"] = "^22.10.2";
+        pkg.devDependencies["@types/aws-lambda"] = "^8.10.145";
+        changed = true;
+    }
+    if (changed) {
+        node_fs_1.default.writeFileSync(pkgPath, `${JSON.stringify(pkg, null, 2)}\n`);
+    }
+    const tsconfigPath = node_path_1.default.join(root, "tsconfig.json");
+    if (fnRuntime === "typescript" && !node_fs_1.default.existsSync(tsconfigPath)) {
+        node_fs_1.default.writeFileSync(tsconfigPath, (0, project_js_1.tsconfig)(answers));
+        changed = true;
+    }
+    return changed;
+}

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

@@ -0,0 +1,52 @@
+import type { EnvironmentsConfig } from "../../core/environments.js";
+import type { DatabaseId, MemorySize, RuntimeId } from "../init/types.js";
+export interface FunctionOptions {
+    name?: string;
+    app?: string;
+    newApp?: string;
+    method?: string;
+    memory?: string | number;
+    runtime?: string;
+}
+export interface ManifestFunctionEntry {
+    name: string;
+    handlerFile: string;
+    memorySize: MemorySize;
+    apiGateway: {
+        enabled: boolean;
+        path?: string;
+        method?: string;
+    };
+}
+export interface ManifestApplication {
+    name: string;
+    functions: ManifestFunctionEntry[];
+}
+export interface ProjectManifest {
+    name: string;
+    runtime: {
+        id: RuntimeId;
+    };
+    framework: {
+        id: string;
+    };
+    database: {
+        id: DatabaseId;
+    };
+    apiGateway: {
+        enabled: boolean;
+        perService?: boolean;
+    };
+    layer: {
+        enabled: boolean;
+    };
+    functions: {
+        memorySize: MemorySize;
+    };
+    applications: ManifestApplication[];
+    structure: {
+        files: string[];
+    };
+    environments?: EnvironmentsConfig;
+    version?: string;
+}

package/dist/commands/function/types.js

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

package/dist/commands/index.d.ts

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

package/dist/commands/index.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerCommands = registerCommands;
+const index_js_1 = require("./configure/index.js");
+const index_js_2 = require("./deploy/index.js");
+const index_js_3 = require("./env/index.js");
+const index_js_4 = require("./function/index.js");
+const index_js_5 = require("./init/index.js");
+const index_js_6 = require("./rm/index.js");
+const index_js_7 = require("./run/index.js");
+function registerCommands(program) {
+    (0, index_js_5.registerInitCommand)(program);
+    (0, index_js_7.registerRunCommand)(program);
+    (0, index_js_4.registerFunctionCommand)(program);
+    (0, index_js_6.registerRmCommand)(program);
+    (0, index_js_1.registerConfigureCommand)(program);
+    (0, index_js_3.registerEnvCommand)(program);
+    (0, index_js_2.registerDeployCommand)(program);
+}

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

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

package/dist/commands/init/action.js

@@ -0,0 +1,36 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.initAction = initAction;
+const node_path_1 = __importDefault(require("node:path"));
+const logger_js_1 = require("../../core/logger.js");
+const prompts_js_1 = require("./prompts.js");
+const scaffold_js_1 = require("./scaffold.js");
+const types_js_1 = require("./types.js");
+async function initAction(options) {
+    const answers = await (0, prompts_js_1.collectAnswers)(options);
+    const root = await (0, scaffold_js_1.scaffoldProject)(answers);
+    const relative = node_path_1.default.relative(process.cwd(), root) || ".";
+    logger_js_1.logger.info(`\nInitialized slskit project "${answers.name}" in ${relative}`);
+    for (const app of types_js_1.LAMBDA_APPS) {
+        logger_js_1.logger.info(`  ${types_js_1.SRC_DIR}/functions/${app.name}   (handlers)`);
+    }
+    for (const app of types_js_1.LAMBDA_APPS) {
+        logger_js_1.logger.info(`  ${types_js_1.SRC_DIR}/services/${app.name}`);
+    }
+    logger_js_1.logger.info(answers.layer
+        ? `  ${types_js_1.SRC_DIR}/shared     (common Lambda layer)`
+        : `  ${types_js_1.SRC_DIR}/shared`);
+    // Every project is a root stack nesting one template per service; the API mode only
+    // decides whether that API lives in the root or in each service.
+    for (const app of types_js_1.LAMBDA_APPS) {
+        logger_js_1.logger.info(`  ${(0, types_js_1.serviceTemplatePath)(app.name)}   (${app.name} service stack)`);
+    }
+    logger_js_1.logger.info(answers.sharedApi
+        ? `  ${types_js_1.INFRA_FILE}     (root stack, owns the one API Gateway)`
+        : `  ${types_js_1.INFRA_FILE}     (root stack)`);
+    logger_js_1.logger.info(`  memory:    ${answers.memorySize} MB`);
+    logger_js_1.logger.info("  slskit.json");
+}

package/dist/commands/init/content.d.ts

@@ -0,0 +1,2 @@
+import type { InitAnswers } from "./types.js";
+export declare function buildFileMap(answers: InitAnswers, envKeys?: string[]): Record<string, string>;