@kosha-ai/cli 0.0.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Codemancers
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,11 @@
+# cli
+
+This library was generated with [Nx](https://nx.dev).
+
+## Building
+
+Run `nx build cli` to build the library.
+
+## Running unit tests
+
+Run `nx test cli` to execute the unit tests via [Jest](https://jestjs.io).

package/bin/kosha.js

@@ -0,0 +1,12 @@
+#!/usr/bin/env node
+import { run } from '../dist/lib/cli.js';
+
+run(process.argv.slice(2))
+  .then(({ exitCode }) => {
+    // A running server keeps the event loop alive; only exit on a real code.
+    if (exitCode !== 0) process.exit(exitCode);
+  })
+  .catch((error) => {
+    process.stderr.write(`${error instanceof Error ? error.message : error}\n`);
+    process.exit(1);
+  });

package/dist/index.d.ts

@@ -0,0 +1,10 @@
+export { run, USAGE, redactUrl, type RunResult } from './lib/cli.js';
+export { loadConfig, findConfigPath, CONFIG_FILENAMES, ConfigNotFoundError, } from './lib/load-config.js';
+export { loadEnv, ENV_FILENAMES } from './lib/load-env.js';
+export { start, type StartOptions } from './lib/commands/start.js';
+export { migrate, resolvePrismaBin, type MigrateOptions, type MigrateSubcommand, } from './lib/commands/migrate.js';
+export { addIntegrations, listIntegrations, applyConfigEdit, detectPackageManager, installedIntegrationKeys, packageNameFor, type AddIntegrationOptions, type AddIntegrationResult, type IntegrationListEntry, } from './lib/commands/integration.js';
+export { findInstalledIntegrations, type InstalledIntegration, } from './lib/commands/installed.js';
+export { resolveServerPackageDir, resolveSchemaPath, resolveMigrationsDir, } from './lib/paths.js';
+export { runNodeScript, runShellCommand, type RunCommandOptions, } from './lib/spawn.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,GAAG,EAAE,KAAK,EAAE,SAAS,EAAE,KAAK,SAAS,EAAE,MAAM,cAAc,CAAC;AACrE,OAAO,EACL,UAAU,EACV,cAAc,EACd,gBAAgB,EAChB,mBAAmB,GACpB,MAAM,sBAAsB,CAAC;AAC9B,OAAO,EAAE,OAAO,EAAE,aAAa,EAAE,MAAM,mBAAmB,CAAC;AAC3D,OAAO,EAAE,KAAK,EAAE,KAAK,YAAY,EAAE,MAAM,yBAAyB,CAAC;AACnE,OAAO,EACL,OAAO,EACP,gBAAgB,EAChB,KAAK,cAAc,EACnB,KAAK,iBAAiB,GACvB,MAAM,2BAA2B,CAAC;AACnC,OAAO,EACL,eAAe,EACf,gBAAgB,EAChB,eAAe,EACf,oBAAoB,EACpB,wBAAwB,EACxB,cAAc,EACd,KAAK,qBAAqB,EAC1B,KAAK,oBAAoB,EACzB,KAAK,oBAAoB,GAC1B,MAAM,+BAA+B,CAAC;AACvC,OAAO,EACL,yBAAyB,EACzB,KAAK,oBAAoB,GAC1B,MAAM,6BAA6B,CAAC;AACrC,OAAO,EACL,uBAAuB,EACvB,iBAAiB,EACjB,oBAAoB,GACrB,MAAM,gBAAgB,CAAC;AACxB,OAAO,EACL,aAAa,EACb,eAAe,EACf,KAAK,iBAAiB,GACvB,MAAM,gBAAgB,CAAC"}

package/dist/index.js

@@ -0,0 +1,9 @@
+export { run, USAGE, redactUrl } from './lib/cli.js';
+export { loadConfig, findConfigPath, CONFIG_FILENAMES, ConfigNotFoundError, } from './lib/load-config.js';
+export { loadEnv, ENV_FILENAMES } from './lib/load-env.js';
+export { start } from './lib/commands/start.js';
+export { migrate, resolvePrismaBin, } from './lib/commands/migrate.js';
+export { addIntegrations, listIntegrations, applyConfigEdit, detectPackageManager, installedIntegrationKeys, packageNameFor, } from './lib/commands/integration.js';
+export { findInstalledIntegrations, } from './lib/commands/installed.js';
+export { resolveServerPackageDir, resolveSchemaPath, resolveMigrationsDir, } from './lib/paths.js';
+export { runNodeScript, runShellCommand, } from './lib/spawn.js';

package/dist/lib/cli.d.ts

@@ -0,0 +1,8 @@
+export declare const USAGE = "kosha \u2014 the Kosha integration platform CLI\n\nUsage\n  kosha start                       Boot the server from kosha.config.ts\n  kosha migrate [deploy|dev|status|reset]\n                                    Run Prisma against the packaged schema\n  kosha integration list            Show installed vs configured integrations\n  kosha integration add <key...>    Install integrations and register them\n  kosha info                        Print the resolved config summary\n\nOptions\n  --config <path>   Path to the config file (default: ./kosha.config.ts)\n  --port <number>   Override server.port for this run\n  --name <name>     Migration name, for `migrate dev`\n  --skip-install    `integration add` edits the config without installing\n  -h, --help        Show this help\n  -v, --version     Show the CLI version\n";
+export interface RunResult {
+    exitCode: number;
+}
+export declare function run(argv: string[]): Promise<RunResult>;
+/** Never print credentials, even to a local terminal. */
+export declare function redactUrl(url?: string): string;
+//# sourceMappingURL=cli.d.ts.map

package/dist/lib/cli.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cli.d.ts","sourceRoot":"","sources":["../../src/lib/cli.ts"],"names":[],"mappings":"AAKA,eAAO,MAAM,KAAK,8zBAiBjB,CAAC;AAEF,MAAM,WAAW,SAAS;IACxB,QAAQ,EAAE,MAAM,CAAC;CAClB;AAED,wBAAsB,GAAG,CAAC,IAAI,EAAE,MAAM,EAAE,GAAG,OAAO,CAAC,SAAS,CAAC,CAqH5D;AAED,yDAAyD;AACzD,wBAAgB,SAAS,CAAC,GAAG,CAAC,EAAE,MAAM,GAAG,MAAM,CAU9C"}

package/dist/lib/cli.js

@@ -0,0 +1,136 @@
+import { parseArgs } from 'node:util';
+import { addIntegrations, listIntegrations } from './commands/integration.js';
+import { migrate } from './commands/migrate.js';
+import { start } from './commands/start.js';
+export const USAGE = `kosha — the Kosha integration platform CLI
+
+Usage
+  kosha start                       Boot the server from kosha.config.ts
+  kosha migrate [deploy|dev|status|reset]
+                                    Run Prisma against the packaged schema
+  kosha integration list            Show installed vs configured integrations
+  kosha integration add <key...>    Install integrations and register them
+  kosha info                        Print the resolved config summary
+
+Options
+  --config <path>   Path to the config file (default: ./kosha.config.ts)
+  --port <number>   Override server.port for this run
+  --name <name>     Migration name, for \`migrate dev\`
+  --skip-install    \`integration add\` edits the config without installing
+  -h, --help        Show this help
+  -v, --version     Show the CLI version
+`;
+export async function run(argv) {
+    const { values, positionals } = parseArgs({
+        args: argv,
+        allowPositionals: true,
+        options: {
+            config: { type: 'string' },
+            port: { type: 'string' },
+            name: { type: 'string' },
+            'skip-install': { type: 'boolean' },
+            help: { type: 'boolean', short: 'h' },
+            version: { type: 'boolean', short: 'v' },
+        },
+    });
+    const [command, ...rest] = positionals;
+    if (values.help || !command) {
+        process.stdout.write(USAGE);
+        return { exitCode: command ? 0 : values.help ? 0 : 1 };
+    }
+    const common = {
+        cwd: process.cwd(),
+        config: values.config,
+    };
+    switch (command) {
+        case 'start': {
+            await start({
+                ...common,
+                port: values.port ? Number(values.port) : undefined,
+            });
+            // startKoshaServer keeps the process alive.
+            return { exitCode: 0 };
+        }
+        case 'migrate': {
+            const exitCode = await migrate({
+                ...common,
+                subcommand: rest[0],
+                name: values.name,
+            });
+            return { exitCode };
+        }
+        case 'integration': {
+            const [subcommand, ...keys] = rest;
+            if (subcommand === 'list' || subcommand === undefined) {
+                const entries = await listIntegrations(common);
+                if (entries.length === 0) {
+                    process.stdout.write('No integrations installed. Try `kosha integration add github`.\n');
+                    return { exitCode: 0 };
+                }
+                for (const entry of entries) {
+                    const state = !entry.installed
+                        ? 'configured but NOT installed'
+                        : !entry.configured
+                            ? 'installed but NOT in kosha.config.ts'
+                            : 'ready';
+                    process.stdout.write(`${entry.key.padEnd(16)} ${state}\n`);
+                }
+                return {
+                    exitCode: entries.every((e) => e.installed && e.configured) ? 0 : 1,
+                };
+            }
+            if (subcommand === 'add') {
+                const result = await addIntegrations({
+                    ...common,
+                    keys,
+                    skipInstall: values['skip-install'],
+                });
+                process.stdout.write(result.installed
+                    ? `Installed ${result.packages.join(', ')}\n`
+                    : `Registered ${result.packages.join(', ')} (install skipped)\n`);
+                if (result.configUpdated) {
+                    process.stdout.write('Updated kosha.config.ts\n');
+                }
+                else {
+                    process.stdout.write(`Could not edit the config automatically. Add this yourself:\n\n${result.manualSnippet}\n\n`);
+                }
+                return { exitCode: result.configUpdated ? 0 : 1 };
+            }
+            process.stderr.write(`Unknown integration subcommand "${subcommand}". Expected list or add.\n`);
+            return { exitCode: 1 };
+        }
+        case 'info': {
+            const { loadConfig } = await import('./load-config.js');
+            const { config, path } = await loadConfig(common);
+            process.stdout.write([
+                `config        ${path}`,
+                `database      ${redactUrl(config.database?.url)}`,
+                `port          ${config.server?.port ?? 3333}`,
+                `prefix        ${config.server?.globalPrefix ?? 'api'}`,
+                `integrations  ${(config.integrations ?? []).map((i) => i.key).join(', ') || '(none)'}`,
+                '',
+            ].join('\n'));
+            return { exitCode: 0 };
+        }
+        default: {
+            process.stderr.write(`Unknown command "${command}".\n\n${USAGE}`);
+            return { exitCode: 1 };
+        }
+    }
+}
+/** Never print credentials, even to a local terminal. */
+export function redactUrl(url) {
+    if (!url)
+        return '(not set)';
+    try {
+        const parsed = new URL(url);
+        if (parsed.password)
+            parsed.password = '***';
+        if (parsed.username)
+            parsed.username = '***';
+        return parsed.toString();
+    }
+    catch {
+        return '(unparseable)';
+    }
+}

package/dist/lib/commands/installed.d.ts

@@ -0,0 +1,14 @@
+export interface InstalledIntegration {
+    key: string;
+    packageName: string;
+}
+/**
+ * Finds installed integration packages by reading each dependency's
+ * `kosha.kind`.
+ *
+ * Not a name-prefix match: `@kosha-ai/integration-sdk` shares the prefix but is
+ * the authoring toolkit, not an integration, and a third-party package under
+ * any name should be able to register itself.
+ */
+export declare function findInstalledIntegrations(cwd: string): InstalledIntegration[];
+//# sourceMappingURL=installed.d.ts.map

package/dist/lib/commands/installed.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"installed.d.ts","sourceRoot":"","sources":["../../../src/lib/commands/installed.ts"],"names":[],"mappings":"AAIA,MAAM,WAAW,oBAAoB;IACnC,GAAG,EAAE,MAAM,CAAC;IACZ,WAAW,EAAE,MAAM,CAAC;CACrB;AAOD;;;;;;;GAOG;AACH,wBAAgB,yBAAyB,CAAC,GAAG,EAAE,MAAM,GAAG,oBAAoB,EAAE,CA0B7E"}

package/dist/lib/commands/installed.js

@@ -0,0 +1,46 @@
+import { existsSync, readFileSync } from 'node:fs';
+import { createRequire } from 'node:module';
+import { join, resolve } from 'node:path';
+/**
+ * Finds installed integration packages by reading each dependency's
+ * `kosha.kind`.
+ *
+ * Not a name-prefix match: `@kosha-ai/integration-sdk` shares the prefix but is
+ * the authoring toolkit, not an integration, and a third-party package under
+ * any name should be able to register itself.
+ */
+export function findInstalledIntegrations(cwd) {
+    const appManifestPath = join(resolve(cwd), 'package.json');
+    if (!existsSync(appManifestPath))
+        return [];
+    const appManifest = JSON.parse(readFileSync(appManifestPath, 'utf8'));
+    const require = createRequire(join(resolve(cwd), 'noop.js'));
+    const found = [];
+    for (const packageName of Object.keys({
+        ...appManifest.dependencies,
+        ...appManifest.devDependencies,
+    })) {
+        const kosha = readKoshaField(require, packageName);
+        if (kosha?.kind !== 'integration')
+            continue;
+        found.push({
+            packageName,
+            key: kosha.key ?? keyFromPackageName(packageName),
+        });
+    }
+    return found;
+}
+function readKoshaField(require, packageName) {
+    try {
+        const manifest = JSON.parse(readFileSync(require.resolve(`${packageName}/package.json`), 'utf8'));
+        return manifest.kosha;
+    }
+    catch {
+        // Not installed, or ships no package.json export map — either way, not
+        // something we can treat as an integration.
+        return undefined;
+    }
+}
+function keyFromPackageName(packageName) {
+    return packageName.replace(/^@[^/]+\//, '').replace(/^integration-/, '');
+}

package/dist/lib/commands/integration.d.ts

@@ -0,0 +1,52 @@
+export interface IntegrationListEntry {
+    key: string;
+    packageName: string;
+    installed: boolean;
+    configured: boolean;
+}
+export declare function packageNameFor(key: string): string;
+/**
+ * Reports installed vs configured integrations.
+ *
+ * The two can disagree — a package installed but not added to the config does
+ * nothing, and a configured package that was uninstalled breaks boot — so
+ * drift is worth surfacing explicitly rather than inferring.
+ */
+export declare function listIntegrations(options?: {
+    cwd?: string;
+    config?: string;
+}): Promise<IntegrationListEntry[]>;
+/** Integration keys the app actually has installed. */
+export declare function installedIntegrationKeys(cwd: string): string[];
+export interface AddIntegrationOptions {
+    cwd?: string;
+    config?: string;
+    keys: string[];
+    packageManager?: string;
+    skipInstall?: boolean;
+    run?: (commandLine: string, options: {
+        cwd?: string;
+    }) => Promise<number>;
+}
+export interface AddIntegrationResult {
+    packages: string[];
+    installed: boolean;
+    configUpdated: boolean;
+    /** Set when the config could not be edited automatically. */
+    manualSnippet?: string;
+}
+export declare function addIntegrations(options: AddIntegrationOptions): Promise<AddIntegrationResult>;
+/**
+ * Adds the import and the `integrations` entry for each key.
+ *
+ * Deliberately conservative string editing rather than a TypeScript codemod:
+ * the config file is small and hand-written, and when the shape is not what we
+ * expect the command prints the snippet instead of mangling the file.
+ */
+export declare function applyConfigEdit(source: string, keys: string[]): {
+    updated: boolean;
+    source: string;
+    snippet: string;
+};
+export declare function detectPackageManager(cwd: string): string;
+//# sourceMappingURL=integration.d.ts.map

package/dist/lib/commands/integration.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"integration.d.ts","sourceRoot":"","sources":["../../../src/lib/commands/integration.ts"],"names":[],"mappings":"AAMA,MAAM,WAAW,oBAAoB;IACnC,GAAG,EAAE,MAAM,CAAC;IACZ,WAAW,EAAE,MAAM,CAAC;IACpB,SAAS,EAAE,OAAO,CAAC;IACnB,UAAU,EAAE,OAAO,CAAC;CACrB;AAID,wBAAgB,cAAc,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAElD;AAED;;;;;;GAMG;AACH,wBAAsB,gBAAgB,CACpC,OAAO,GAAE;IAAE,GAAG,CAAC,EAAE,MAAM,CAAC;IAAC,MAAM,CAAC,EAAE,MAAM,CAAA;CAAO,GAC9C,OAAO,CAAC,oBAAoB,EAAE,CAAC,CAajC;AAED,uDAAuD;AACvD,wBAAgB,wBAAwB,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,EAAE,CAE9D;AAED,MAAM,WAAW,qBAAqB;IACpC,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,IAAI,EAAE,MAAM,EAAE,CAAC;IACf,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,WAAW,CAAC,EAAE,OAAO,CAAC;IACtB,GAAG,CAAC,EAAE,CAAC,WAAW,EAAE,MAAM,EAAE,OAAO,EAAE;QAAE,GAAG,CAAC,EAAE,MAAM,CAAA;KAAE,KAAK,OAAO,CAAC,MAAM,CAAC,CAAC;CAC3E;AAED,MAAM,WAAW,oBAAoB;IACnC,QAAQ,EAAE,MAAM,EAAE,CAAC;IACnB,SAAS,EAAE,OAAO,CAAC;IACnB,aAAa,EAAE,OAAO,CAAC;IACvB,6DAA6D;IAC7D,aAAa,CAAC,EAAE,MAAM,CAAC;CACxB;AAED,wBAAsB,eAAe,CACnC,OAAO,EAAE,qBAAqB,GAC7B,OAAO,CAAC,oBAAoB,CAAC,CAuC/B;AAED;;;;;;GAMG;AACH,wBAAgB,eAAe,CAC7B,MAAM,EAAE,MAAM,EACd,IAAI,EAAE,MAAM,EAAE,GACb;IAAE,OAAO,EAAE,OAAO,CAAC;IAAC,MAAM,EAAE,MAAM,CAAC;IAAC,OAAO,EAAE,MAAM,CAAA;CAAE,CAyCvD;AAED,wBAAgB,oBAAoB,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAKxD"}

package/dist/lib/commands/integration.js

@@ -0,0 +1,112 @@
+import { existsSync, readFileSync, writeFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { findConfigPath, loadConfig } from '../load-config.js';
+import { runShellCommand } from '../spawn.js';
+import { findInstalledIntegrations } from './installed.js';
+const PACKAGE_PREFIX = '@kosha-ai/integration-';
+export function packageNameFor(key) {
+    return `${PACKAGE_PREFIX}${key}`;
+}
+/**
+ * Reports installed vs configured integrations.
+ *
+ * The two can disagree — a package installed but not added to the config does
+ * nothing, and a configured package that was uninstalled breaks boot — so
+ * drift is worth surfacing explicitly rather than inferring.
+ */
+export async function listIntegrations(options = {}) {
+    const cwd = options.cwd ?? process.cwd();
+    const { config } = await loadConfig({ cwd, config: options.config });
+    const configured = new Set((config.integrations ?? []).map((i) => i.key));
+    const installed = new Set(installedIntegrationKeys(cwd));
+    return [...new Set([...configured, ...installed])].sort().map((key) => ({
+        key,
+        packageName: packageNameFor(key),
+        installed: installed.has(key),
+        configured: configured.has(key),
+    }));
+}
+/** Integration keys the app actually has installed. */
+export function installedIntegrationKeys(cwd) {
+    return findInstalledIntegrations(cwd).map((entry) => entry.key);
+}
+export async function addIntegrations(options) {
+    const cwd = options.cwd ?? process.cwd();
+    const keys = options.keys.filter(Boolean);
+    if (keys.length === 0) {
+        throw new Error('Specify at least one integration, e.g. `kosha integration add github`.');
+    }
+    const packages = keys.map(packageNameFor);
+    if (!options.skipInstall) {
+        const packageManager = options.packageManager ?? detectPackageManager(cwd);
+        const run = options.run ?? runShellCommand;
+        const code = await run(`${packageManager} add ${packages.join(' ')}`, {
+            cwd,
+        });
+        if (code !== 0) {
+            throw new Error(`${packageManager} add ${packages.join(' ')} failed with exit code ${code}.`);
+        }
+    }
+    const configPath = findConfigPath(cwd, options.config);
+    const edit = applyConfigEdit(readFileSync(configPath, 'utf8'), keys);
+    if (edit.updated) {
+        writeFileSync(configPath, edit.source);
+        return { packages, installed: !options.skipInstall, configUpdated: true };
+    }
+    return {
+        packages,
+        installed: !options.skipInstall,
+        configUpdated: false,
+        manualSnippet: edit.snippet,
+    };
+}
+/**
+ * Adds the import and the `integrations` entry for each key.
+ *
+ * Deliberately conservative string editing rather than a TypeScript codemod:
+ * the config file is small and hand-written, and when the shape is not what we
+ * expect the command prints the snippet instead of mangling the file.
+ */
+export function applyConfigEdit(source, keys) {
+    const snippet = [
+        ...keys.map((key) => `import ${camelCase(key)} from '${packageNameFor(key)}';`),
+        '',
+        `  integrations: [${keys.map((key) => `${camelCase(key)}()`).join(', ')}],`,
+    ].join('\n');
+    const integrationsMatch = source.match(/integrations\s*:\s*\[([\s\S]*?)\]/);
+    if (!integrationsMatch) {
+        return { updated: false, source, snippet };
+    }
+    let updated = source;
+    for (const key of keys) {
+        const identifier = camelCase(key);
+        const packageName = packageNameFor(key);
+        if (!updated.includes(`from '${packageName}'`)) {
+            updated = `import ${identifier} from '${packageName}';\n${updated}`;
+        }
+        const currentMatch = updated.match(/integrations\s*:\s*\[([\s\S]*?)\]/);
+        if (!currentMatch)
+            return { updated: false, source, snippet };
+        const entries = currentMatch[1];
+        if (new RegExp(`\\b${identifier}\\s*\\(`).test(entries))
+            continue;
+        const existing = entries.trim().replace(/,$/, '');
+        const nextEntries = existing
+            ? `${existing}, ${identifier}()`
+            : `${identifier}()`;
+        updated = updated.replace(currentMatch[0], `integrations: [${nextEntries}]`);
+    }
+    return { updated: updated !== source, source: updated, snippet };
+}
+export function detectPackageManager(cwd) {
+    if (existsSync(join(cwd, 'pnpm-lock.yaml')))
+        return 'pnpm';
+    if (existsSync(join(cwd, 'yarn.lock')))
+        return 'yarn';
+    if (existsSync(join(cwd, 'bun.lockb')))
+        return 'bun';
+    return 'npm';
+}
+function camelCase(key) {
+    return key.replace(/-([a-z0-9])/g, (_, char) => char.toUpperCase());
+}

package/dist/lib/commands/migrate.d.ts

@@ -0,0 +1,28 @@
+import { type RunCommandOptions } from '../spawn.js';
+export type MigrateSubcommand = 'deploy' | 'dev' | 'status' | 'reset';
+export interface MigrateOptions {
+    cwd?: string;
+    config?: string;
+    subcommand?: string;
+    name?: string;
+    /** Injected in tests. */
+    run?: (script: string, args: string[], options: RunCommandOptions) => Promise<number>;
+}
+/**
+ * Runs Prisma against the schema shipped inside `@kosha-ai/server`.
+ *
+ * Prisma 7 takes the datasource URL from a config file rather than the schema,
+ * so a throwaway config is written per invocation pointing at the packaged
+ * schema and the app's own DATABASE_URL. This is why apps never carry a
+ * `prisma.config.ts` of their own.
+ */
+export declare function migrate(options?: MigrateOptions): Promise<number>;
+/**
+ * Locates Prisma's CLI entry script.
+ *
+ * `prisma` is a dependency of this package rather than of `@kosha-ai/server`:
+ * generated apps need migrations but never need to generate a client, since
+ * `@kosha-ai/server` ships one.
+ */
+export declare function resolvePrismaBin(): string;
+//# sourceMappingURL=migrate.d.ts.map

package/dist/lib/commands/migrate.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"migrate.d.ts","sourceRoot":"","sources":["../../../src/lib/commands/migrate.ts"],"names":[],"mappings":"AAMA,OAAO,EAAiB,KAAK,iBAAiB,EAAE,MAAM,aAAa,CAAC;AAEpE,MAAM,MAAM,iBAAiB,GAAG,QAAQ,GAAG,KAAK,GAAG,QAAQ,GAAG,OAAO,CAAC;AAItE,MAAM,WAAW,cAAc;IAC7B,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,yBAAyB;IACzB,GAAG,CAAC,EAAE,CACJ,MAAM,EAAE,MAAM,EACd,IAAI,EAAE,MAAM,EAAE,EACd,OAAO,EAAE,iBAAiB,KACvB,OAAO,CAAC,MAAM,CAAC,CAAC;CACtB;AAED;;;;;;;GAOG;AACH,wBAAsB,OAAO,CAAC,OAAO,GAAE,cAAmB,GAAG,OAAO,CAAC,MAAM,CAAC,CAgC3E;AAED;;;;;;GAMG;AACH,wBAAgB,gBAAgB,IAAI,MAAM,CAuBzC"}

package/dist/lib/commands/migrate.js

@@ -0,0 +1,83 @@
+import { mkdtempSync, readFileSync, writeFileSync } from 'node:fs';
+import { createRequire } from 'node:module';
+import { tmpdir } from 'node:os';
+import { dirname, join } from 'node:path';
+import { loadConfig } from '../load-config.js';
+import { resolveMigrationsDir, resolveSchemaPath } from '../paths.js';
+import { runNodeScript } from '../spawn.js';
+const SUBCOMMANDS = ['deploy', 'dev', 'status', 'reset'];
+/**
+ * Runs Prisma against the schema shipped inside `@kosha-ai/server`.
+ *
+ * Prisma 7 takes the datasource URL from a config file rather than the schema,
+ * so a throwaway config is written per invocation pointing at the packaged
+ * schema and the app's own DATABASE_URL. This is why apps never carry a
+ * `prisma.config.ts` of their own.
+ */
+export async function migrate(options = {}) {
+    const cwd = options.cwd ?? process.cwd();
+    const subcommand = (options.subcommand ?? 'deploy');
+    if (!SUBCOMMANDS.includes(subcommand)) {
+        throw new Error(`Unknown migrate subcommand "${subcommand}". Expected one of: ${SUBCOMMANDS.join(', ')}`);
+    }
+    const { config } = await loadConfig({ cwd, config: options.config });
+    if (!config.database?.url) {
+        throw new Error('kosha.config.ts has no database.url, so there is nothing to migrate against.');
+    }
+    const configPath = writePrismaConfig({
+        schema: resolveSchemaPath(cwd),
+        migrations: resolveMigrationsDir(cwd),
+    });
+    const args = ['migrate', subcommand, '--config', configPath];
+    if (subcommand === 'dev' && options.name) {
+        args.push('--name', options.name);
+    }
+    const run = options.run ?? runNodeScript;
+    return run(resolvePrismaBin(), args, {
+        cwd,
+        env: { ...process.env, DATABASE_URL: config.database.url },
+    });
+}
+/**
+ * Locates Prisma's CLI entry script.
+ *
+ * `prisma` is a dependency of this package rather than of `@kosha-ai/server`:
+ * generated apps need migrations but never need to generate a client, since
+ * `@kosha-ai/server` ships one.
+ */
+export function resolvePrismaBin() {
+    const require = createRequire(import.meta.url);
+    let manifestPath;
+    try {
+        manifestPath = require.resolve('prisma/package.json');
+    }
+    catch {
+        throw new Error('Could not resolve the prisma CLI. Reinstall @kosha-ai/cli so its dependencies are present.');
+    }
+    const manifest = JSON.parse(readFileSync(manifestPath, 'utf8'));
+    const bin = typeof manifest.bin === 'string' ? manifest.bin : manifest.bin?.['prisma'];
+    if (!bin) {
+        throw new Error(`The installed prisma package declares no "prisma" bin.`);
+    }
+    return join(dirname(manifestPath), bin);
+}
+function writePrismaConfig(paths) {
+    const dir = mkdtempSync(join(tmpdir(), 'kosha-prisma-'));
+    const path = join(dir, 'prisma.config.mjs');
+    // A plain object rather than `defineConfig(...)`: the file lives outside the
+    // app, where `prisma/config` is not resolvable. `defineConfig` is only a
+    // types helper, so the shape is what matters.
+    writeFileSync(path, [
+        'export default {',
+        `  schema: ${JSON.stringify(paths.schema)},`,
+        '  migrations: {',
+        `    path: ${JSON.stringify(paths.migrations)},`,
+        '  },',
+        '  datasource: {',
+        '    url: process.env.DATABASE_URL,',
+        '  },',
+        '};',
+        '',
+    ].join('\n'));
+    return path;
+}

package/dist/lib/commands/start.d.ts

@@ -0,0 +1,13 @@
+export interface StartOptions {
+    cwd?: string;
+    config?: string;
+    port?: number;
+}
+/**
+ * Boots the server and the admin UI from the app's config.
+ *
+ * `@kosha-ai/server` is imported lazily so that `kosha --help` and `kosha info`
+ * stay instant and do not need a database or a valid config.
+ */
+export declare function start(options?: StartOptions): Promise<void>;
+//# sourceMappingURL=start.d.ts.map

package/dist/lib/commands/start.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"start.d.ts","sourceRoot":"","sources":["../../../src/lib/commands/start.ts"],"names":[],"mappings":"AAKA,MAAM,WAAW,YAAY;IAC3B,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,IAAI,CAAC,EAAE,MAAM,CAAC;CACf;AAED;;;;;GAKG;AACH,wBAAsB,KAAK,CAAC,OAAO,GAAE,YAAiB,GAAG,OAAO,CAAC,IAAI,CAAC,CA8BrE"}

package/dist/lib/commands/start.js

@@ -0,0 +1,33 @@
+import { dirname } from 'node:path';
+import { loadConfig } from '../load-config.js';
+import { resolveAdminServerEntry } from '../paths.js';
+import { spawnNodeScript } from '../spawn.js';
+/**
+ * Boots the server and the admin UI from the app's config.
+ *
+ * `@kosha-ai/server` is imported lazily so that `kosha --help` and `kosha info`
+ * stay instant and do not need a database or a valid config.
+ */
+export async function start(options = {}) {
+    const cwd = options.cwd ?? process.cwd();
+    const { config, path } = await loadConfig({
+        cwd: options.cwd,
+        config: options.config,
+    });
+    const { startKoshaServer, resolveConfig } = await import('@kosha-ai/server');
+    process.stdout.write(`Kosha config: ${path}\n`);
+    const resolved = resolveConfig(options.port
+        ? { ...config, server: { ...config.server, port: options.port } }
+        : config);
+    await startKoshaServer(resolved);
+    const adminEntry = resolveAdminServerEntry(cwd);
+    const admin = spawnNodeScript(adminEntry, [], {
+        cwd: dirname(adminEntry),
+        env: { ...process.env, PORT: String(resolved.admin.port) },
+    });
+    // Ctrl+C in a terminal already reaches this child (same process group);
+    // this covers being sent a lone SIGTERM/SIGINT, e.g. under a process manager.
+    for (const signal of ['SIGINT', 'SIGTERM']) {
+        process.once(signal, () => admin.kill(signal));
+    }
+}

package/dist/lib/load-config.d.ts

@@ -0,0 +1,20 @@
+import type { KoshaConfig } from '@kosha-ai/server';
+export declare const CONFIG_FILENAMES: string[];
+export declare class ConfigNotFoundError extends Error {
+    constructor(cwd: string);
+}
+export declare function findConfigPath(cwd: string, explicit?: string): string;
+/**
+ * Loads `kosha.config.ts` without the app needing a build step.
+ *
+ * jiti transpiles on the fly, which is what keeps a generated app thin: it has
+ * a config file and a `package.json`, no bundler and no `tsconfig` of its own.
+ */
+export declare function loadConfig(options?: {
+    cwd?: string;
+    config?: string;
+}): Promise<{
+    config: KoshaConfig;
+    path: string;
+}>;
+//# sourceMappingURL=load-config.d.ts.map

package/dist/lib/load-config.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"load-config.d.ts","sourceRoot":"","sources":["../../src/lib/load-config.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,kBAAkB,CAAC;AAGpD,eAAO,MAAM,gBAAgB,UAK5B,CAAC;AAEF,qBAAa,mBAAoB,SAAQ,KAAK;gBAChC,GAAG,EAAE,MAAM;CAMxB;AAED,wBAAgB,cAAc,CAAC,GAAG,EAAE,MAAM,EAAE,QAAQ,CAAC,EAAE,MAAM,GAAG,MAAM,CAerE;AAED;;;;;GAKG;AACH,wBAAsB,UAAU,CAC9B,OAAO,GAAE;IACP,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,MAAM,CAAC,EAAE,MAAM,CAAC;CACZ,GACL,OAAO,CAAC;IAAE,MAAM,EAAE,WAAW,CAAC;IAAC,IAAI,EAAE,MAAM,CAAA;CAAE,CAAC,CA2BhD"}

package/dist/lib/load-config.js

@@ -0,0 +1,56 @@
+import { existsSync } from 'node:fs';
+import { resolve } from 'node:path';
+import { pathToFileURL } from 'node:url';
+import { createJiti } from 'jiti';
+import { loadEnv } from './load-env.js';
+export const CONFIG_FILENAMES = [
+    'kosha.config.ts',
+    'kosha.config.mts',
+    'kosha.config.js',
+    'kosha.config.mjs',
+];
+export class ConfigNotFoundError extends Error {
+    constructor(cwd) {
+        super(`No Kosha config found in ${cwd}. Expected one of: ${CONFIG_FILENAMES.join(', ')}`);
+        this.name = 'ConfigNotFoundError';
+    }
+}
+export function findConfigPath(cwd, explicit) {
+    if (explicit) {
+        const path = resolve(cwd, explicit);
+        if (!existsSync(path)) {
+            throw new ConfigNotFoundError(path);
+        }
+        return path;
+    }
+    for (const filename of CONFIG_FILENAMES) {
+        const path = resolve(cwd, filename);
+        if (existsSync(path))
+            return path;
+    }
+    throw new ConfigNotFoundError(cwd);
+}
+/**
+ * Loads `kosha.config.ts` without the app needing a build step.
+ *
+ * jiti transpiles on the fly, which is what keeps a generated app thin: it has
+ * a config file and a `package.json`, no bundler and no `tsconfig` of its own.
+ */
+export async function loadConfig(options = {}) {
+    const cwd = options.cwd ?? process.cwd();
+    const path = findConfigPath(cwd, options.config);
+    // The config reads process.env, so the app's env files come first.
+    loadEnv(cwd);
+    // interopDefault stays off so that a config file with no default export is
+    // an error rather than silently yielding the module namespace as the config.
+    const jiti = createJiti(pathToFileURL(`${cwd}/`).href, {
+        interopDefault: false,
+        fsCache: false,
+    });
+    const loaded = await jiti.import(pathToFileURL(path).href);
+    const config = loaded?.default;
+    if (!config || typeof config !== 'object') {
+        throw new Error(`${path} must export a Kosha config as its default export (see defineConfig from @kosha-ai/server).`);
+    }
+    return { config, path };
+}

package/dist/lib/load-env.d.ts

@@ -0,0 +1,19 @@
+export declare const ENV_FILENAMES: string[];
+export interface LoadEnvOptions {
+    /**
+     * Injected in tests. Node's loader writes to the real process environment,
+     * which Jest's sandboxed `process.env` does not reflect, so the seam exists
+     * to assert which files get loaded and in what order.
+     */
+    load?: (path: string) => void;
+}
+/**
+ * Loads the app's env files before the config is evaluated.
+ *
+ * `kosha.config.ts` reads `process.env`, so this has to happen first. Node's
+ * built-in loader — like `--env-file` — never overwrites a variable that is
+ * already set, so a shell override or a container's injected secrets beat a
+ * checked-in file. `.env.local` is read first for the same reason.
+ */
+export declare function loadEnv(cwd: string, options?: LoadEnvOptions): string[];
+//# sourceMappingURL=load-env.d.ts.map

package/dist/lib/load-env.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"load-env.d.ts","sourceRoot":"","sources":["../../src/lib/load-env.ts"],"names":[],"mappings":"AAGA,eAAO,MAAM,aAAa,UAAyB,CAAC;AAEpD,MAAM,WAAW,cAAc;IAC7B;;;;OAIG;IACH,IAAI,CAAC,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,IAAI,CAAC;CAC/B;AAED;;;;;;;GAOG;AACH,wBAAgB,OAAO,CAAC,GAAG,EAAE,MAAM,EAAE,OAAO,GAAE,cAAmB,GAAG,MAAM,EAAE,CAa3E"}

package/dist/lib/load-env.js

@@ -0,0 +1,29 @@
+import { existsSync } from 'node:fs';
+import { join } from 'node:path';
+export const ENV_FILENAMES = ['.env.local', '.env'];
+/**
+ * Loads the app's env files before the config is evaluated.
+ *
+ * `kosha.config.ts` reads `process.env`, so this has to happen first. Node's
+ * built-in loader — like `--env-file` — never overwrites a variable that is
+ * already set, so a shell override or a container's injected secrets beat a
+ * checked-in file. `.env.local` is read first for the same reason.
+ */
+export function loadEnv(cwd, options = {}) {
+    const load = options.load ?? nodeLoadEnvFile;
+    const loaded = [];
+    for (const filename of ENV_FILENAMES) {
+        const path = join(cwd, filename);
+        if (!existsSync(path))
+            continue;
+        load(path);
+        loaded.push(path);
+    }
+    return loaded;
+}
+function nodeLoadEnvFile(path) {
+    if (typeof process.loadEnvFile !== 'function') {
+        throw new Error('Kosha needs Node 20.12 or newer (process.loadEnvFile is unavailable).');
+    }
+    process.loadEnvFile(path);
+}

package/dist/lib/paths.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Locates the installed `@kosha-ai/server` package from the app's directory.
+ *
+ * The Prisma schema and migrations ship inside that package — the app never
+ * owns them — so every database command has to resolve it first.
+ */
+export declare function resolveServerPackageDir(cwd: string): string;
+export declare function resolveSchemaPath(cwd: string): string;
+export declare function resolveMigrationsDir(cwd: string): string;
+export declare function resolveAdminPackageDir(cwd: string): string;
+/**
+ * Finds the standalone `server.js` Next.js ships inside `@kosha-ai/admin`.
+ *
+ * The published package mirrors this monorepo's `packages/admin/` path
+ * inside `.next/standalone` (Next has to trace outside the package for its
+ * workspace deps), so the depth isn't fixed — walk for the one `server.js`
+ * standalone output produces rather than assume a shape.
+ */
+export declare function resolveAdminServerEntry(cwd: string): string;
+//# sourceMappingURL=paths.d.ts.map

package/dist/lib/paths.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"paths.d.ts","sourceRoot":"","sources":["../../src/lib/paths.ts"],"names":[],"mappings":"AAIA;;;;;GAKG;AACH,wBAAgB,uBAAuB,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAU3D;AAED,wBAAgB,iBAAiB,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAQrD;AAED,wBAAgB,oBAAoB,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAExD;AASD,wBAAgB,sBAAsB,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAU1D;AAED;;;;;;;GAOG;AACH,wBAAgB,uBAAuB,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAc3D"}

package/dist/lib/paths.js

@@ -0,0 +1,74 @@
+import { existsSync, readdirSync } from 'node:fs';
+import { createRequire } from 'node:module';
+import { dirname, join, resolve } from 'node:path';
+/**
+ * Locates the installed `@kosha-ai/server` package from the app's directory.
+ *
+ * The Prisma schema and migrations ship inside that package — the app never
+ * owns them — so every database command has to resolve it first.
+ */
+export function resolveServerPackageDir(cwd) {
+    const require = createRequire(join(resolve(cwd), 'noop.js'));
+    try {
+        return dirname(require.resolve('@kosha-ai/server/package.json'));
+    }
+    catch {
+        throw new Error(`Could not resolve @kosha-ai/server from ${cwd}. Run your package manager's install first.`);
+    }
+}
+export function resolveSchemaPath(cwd) {
+    const schema = join(resolveServerPackageDir(cwd), 'prisma', 'schema.prisma');
+    if (!existsSync(schema)) {
+        throw new Error(`@kosha-ai/server is installed but ships no Prisma schema at ${schema}.`);
+    }
+    return schema;
+}
+export function resolveMigrationsDir(cwd) {
+    return join(resolveServerPackageDir(cwd), 'prisma', 'migrations');
+}
+// Built from parts rather than a literal `require.resolve('@kosha-ai/admin/...')`:
+// Nx's TS project graph treats that literal shape as a static import and
+// wires a project reference to it, which breaks the build since @kosha-ai/admin
+// is a Next app (noEmit) and isn't actually a TS-level dependency of the cli
+// — only a runtime path lookup.
+const ADMIN_PACKAGE_JSON = ['@kosha', 'admin', 'package.json'].join('/');
+export function resolveAdminPackageDir(cwd) {
+    const require = createRequire(join(resolve(cwd), 'noop.js'));
+    try {
+        return dirname(require.resolve(ADMIN_PACKAGE_JSON));
+    }
+    catch {
+        throw new Error(`Could not resolve @kosha-ai/admin from ${cwd}. Run your package manager's install first.`);
+    }
+}
+/**
+ * Finds the standalone `server.js` Next.js ships inside `@kosha-ai/admin`.
+ *
+ * The published package mirrors this monorepo's `packages/admin/` path
+ * inside `.next/standalone` (Next has to trace outside the package for its
+ * workspace deps), so the depth isn't fixed — walk for the one `server.js`
+ * standalone output produces rather than assume a shape.
+ */
+export function resolveAdminServerEntry(cwd) {
+    const standaloneDir = join(resolveAdminPackageDir(cwd), '.next', 'standalone');
+    const entry = findServerEntry(standaloneDir);
+    if (!entry) {
+        throw new Error(`@kosha-ai/admin is installed but ships no standalone server at ${standaloneDir}.`);
+    }
+    return entry;
+}
+function findServerEntry(dir) {
+    if (!existsSync(dir))
+        return null;
+    for (const entry of readdirSync(dir, { withFileTypes: true })) {
+        const full = join(dir, entry.name);
+        if (entry.isFile() && entry.name === 'server.js')
+            return full;
+        if (entry.isDirectory() && entry.name !== 'node_modules') {
+            const found = findServerEntry(full);
+            if (found)
+                return found;
+        }
+    }
+    return null;
+}

package/dist/lib/spawn.d.ts

@@ -0,0 +1,29 @@
+import { type ChildProcess } from 'node:child_process';
+export interface RunCommandOptions {
+    cwd?: string;
+    env?: NodeJS.ProcessEnv;
+}
+/**
+ * Starts a Node script without waiting for it to exit — for a process meant
+ * to keep running alongside the caller, like the admin UI next to the API
+ * server. Same shim-avoidance rationale as {@link runNodeScript}.
+ */
+export declare function spawnNodeScript(script: string, args: string[], options?: RunCommandOptions): ChildProcess;
+/**
+ * Runs a Node script with the current interpreter.
+ *
+ * Preferred over invoking a package's bin name: Node refuses to spawn the
+ * `.cmd` shims that npm installs on Windows unless a shell is involved
+ * (spawn EINVAL), and a shell brings its own quoting problems.
+ */
+export declare function runNodeScript(script: string, args: string[], options?: RunCommandOptions): Promise<number>;
+/**
+ * Runs a package manager command through the platform shell.
+ *
+ * Package managers only exist as shell shims on Windows, so there is no
+ * script to hand to {@link runNodeScript}. The command is passed as a single
+ * string — Node deprecates arrays combined with `shell: true` (DEP0190) — and
+ * every interpolated value is validated before it gets here.
+ */
+export declare function runShellCommand(commandLine: string, options?: RunCommandOptions): Promise<number>;
+//# sourceMappingURL=spawn.d.ts.map

package/dist/lib/spawn.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"spawn.d.ts","sourceRoot":"","sources":["../../src/lib/spawn.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,YAAY,EAAS,MAAM,oBAAoB,CAAC;AAE9D,MAAM,WAAW,iBAAiB;IAChC,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,GAAG,CAAC,EAAE,MAAM,CAAC,UAAU,CAAC;CACzB;AAED;;;;GAIG;AACH,wBAAgB,eAAe,CAC7B,MAAM,EAAE,MAAM,EACd,IAAI,EAAE,MAAM,EAAE,EACd,OAAO,GAAE,iBAAsB,GAC9B,YAAY,CAMd;AAED;;;;;;GAMG;AACH,wBAAgB,aAAa,CAC3B,MAAM,EAAE,MAAM,EACd,IAAI,EAAE,MAAM,EAAE,EACd,OAAO,GAAE,iBAAsB,GAC9B,OAAO,CAAC,MAAM,CAAC,CAUjB;AAED;;;;;;;GAOG;AACH,wBAAgB,eAAe,CAC7B,WAAW,EAAE,MAAM,EACnB,OAAO,GAAE,iBAAsB,GAC9B,OAAO,CAAC,MAAM,CAAC,CAWjB"}

package/dist/lib/spawn.js

@@ -0,0 +1,51 @@
+import { spawn } from 'node:child_process';
+/**
+ * Starts a Node script without waiting for it to exit — for a process meant
+ * to keep running alongside the caller, like the admin UI next to the API
+ * server. Same shim-avoidance rationale as {@link runNodeScript}.
+ */
+export function spawnNodeScript(script, args, options = {}) {
+    return spawn(process.execPath, [script, ...args], {
+        cwd: options.cwd,
+        env: options.env ?? process.env,
+        stdio: 'inherit',
+    });
+}
+/**
+ * Runs a Node script with the current interpreter.
+ *
+ * Preferred over invoking a package's bin name: Node refuses to spawn the
+ * `.cmd` shims that npm installs on Windows unless a shell is involved
+ * (spawn EINVAL), and a shell brings its own quoting problems.
+ */
+export function runNodeScript(script, args, options = {}) {
+    return new Promise((resolve, reject) => {
+        const child = spawn(process.execPath, [script, ...args], {
+            cwd: options.cwd,
+            env: options.env ?? process.env,
+            stdio: 'inherit',
+        });
+        child.on('error', reject);
+        child.on('close', (code) => resolve(code ?? 1));
+    });
+}
+/**
+ * Runs a package manager command through the platform shell.
+ *
+ * Package managers only exist as shell shims on Windows, so there is no
+ * script to hand to {@link runNodeScript}. The command is passed as a single
+ * string — Node deprecates arrays combined with `shell: true` (DEP0190) — and
+ * every interpolated value is validated before it gets here.
+ */
+export function runShellCommand(commandLine, options = {}) {
+    return new Promise((resolve, reject) => {
+        const child = spawn(commandLine, {
+            cwd: options.cwd,
+            env: options.env ?? process.env,
+            stdio: 'inherit',
+            shell: true,
+        });
+        child.on('error', reject);
+        child.on('close', (code) => resolve(code ?? 1));
+    });
+}

package/package.json

@@ -0,0 +1,56 @@
+{
+  "name": "@kosha-ai/cli",
+  "version": "0.0.1",
+  "description": "Kosha CLI: migrate, start, and manage a Kosha app",
+  "keywords": [
+    "kosha",
+    "cli",
+    "integrations"
+  ],
+  "license": "MIT",
+  "homepage": "https://github.com/codemancers/kosha#readme",
+  "bugs": {
+    "url": "https://github.com/codemancers/kosha/issues"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/codemancers/kosha.git",
+    "directory": "packages/cli"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "type": "module",
+  "main": "./dist/index.js",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    "./package.json": "./package.json",
+    ".": {
+      "@org/source": "./src/index.ts",
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "default": "./dist/index.js"
+    }
+  },
+  "files": [
+    "dist",
+    "bin",
+    "!**/*.tsbuildinfo"
+  ],
+  "dependencies": {
+    "jiti": "^2.7.0",
+    "prisma": "^7.10.0",
+    "tslib": "^2.3.0",
+    "@kosha-ai/server": "0.0.1"
+  },
+  "kosha": {
+    "kind": "cli"
+  },
+  "bin": {
+    "kosha": "./bin/kosha.js"
+  },
+  "engines": {
+    "node": ">=20.12"
+  }
+}