@ekairos/domain 1.22.36-beta.development.0 → 1.22.36

package/README.md

@@ -7,32 +7,38 @@ Operate it through a CLI.
 
 ## What you get
 
-- Composed domain graphs with `domain(...).schema(...)`
+- Composed domain graphs with `domain(...).withSchema(...)`
 - Explicit runtimes with `EkairosRuntime`
-- Step-safe write boundaries with `defineDomainAction(...)`
+- Step-safe write boundaries with `defineAction(...)`
 - Workflow-ready action execution with `executeRuntimeAction(...)`
-- A built-in CLI for `create-app`, `inspect`, `action`, and `query`
+- A companion CLI through `@ekairos/cli` for `create-app`, `inspect`, `action`, and `query`
 
 ## Start Fast
 
 Scaffold a Next app that already exposes the Ekairos domain endpoint:
 
 ```bash
-npx @ekairos/domain create-app my-app --next
+ekairos create-app my-app --next
+```
+
+Run the full supply-chain demo cycle:
+
+```bash
+ekairos create-app --demo
 ```
 
 If you already have an Instant platform token, provision the app and write `.env.local` in one pass:
 
 ```bash
-npx @ekairos/domain create-app my-app --next --instantToken=$INSTANT_PERSONAL_ACCESS_TOKEN
+ekairos create-app my-app --next --instantToken=$INSTANT_PERSONAL_ACCESS_TOKEN
 ```
 
 Then run it and inspect it:
 
 ```bash
-npx @ekairos/domain inspect --baseUrl=http://localhost:3000 --admin --pretty
-npx @ekairos/domain seedDemo --baseUrl=http://localhost:3000 --admin --pretty
-npx @ekairos/domain query "{ app_tasks: { comments: {} } }" --baseUrl=http://localhost:3000 --admin --pretty
+ekairos domain inspect --baseUrl=http://localhost:3000 --admin --pretty
+ekairos domain "supplyChain.order.launch" "{ reference: 'PO-7842', supplierName: 'Marula Components', sku: 'DRV-2048' }" --baseUrl=http://localhost:3000 --admin --pretty
+ekairos domain query "{ procurement_order: { supplier: {}, stockItems: {}, shipments: { inspections: {} } } }" --baseUrl=http://localhost:3000 --admin --pretty
 ```
 
 ## Next.js Route
@@ -65,19 +71,18 @@ const nextConfig: NextConfig = {
 export default withWorkflow(nextConfig) as NextConfig;
 ```
 
-The CLI uses `/api/ekairos/domain` by default and falls back to the legacy
-`/.well-known/ekairos/v1/domain` endpoint for older apps.
+The CLI uses `/api/ekairos/domain`.
 
 ## Core Pattern
 
 ```ts
-import { defineDomainAction, domain } from "@ekairos/domain";
+import { defineAction, domain } from "@ekairos/domain";
 import { EkairosRuntime } from "@ekairos/domain/runtime-handle";
 import { executeRuntimeAction } from "@ekairos/domain/runtime";
 import { init } from "@instantdb/admin";
 import { i } from "@instantdb/core";
 
-const baseDomain = domain("tasks").schema({
+const baseDomain = domain("tasks").withSchema({
   entities: {
     tasks: i.entity({
       title: i.string().indexed(),
@@ -88,7 +93,7 @@ const baseDomain = domain("tasks").schema({
   rooms: {},
 });
 
-export const createTaskAction = defineDomainAction({
+export const createTaskAction = defineAction({
   name: "tasks.create",
   async execute({ runtime, input }) {
     "use step";
@@ -98,10 +103,13 @@ export const createTaskAction = defineDomainAction({
   },
 });
 
-export const appDomain = baseDomain.actions({
+export const appDomain = baseDomain.withActions({
   createTask: createTaskAction,
 });
 
+// Raw definitions stay available for reflection and adapters:
+appDomain.actions.createTask;
+
 export class AppRuntime extends EkairosRuntime<{
   appId?: string;
   adminToken?: string;
@@ -114,7 +122,7 @@ export class AppRuntime extends EkairosRuntime<{
     return init({
       appId: env.appId!,
       adminToken: env.adminToken!,
-      schema: appDomain.toInstantSchema(),
+      schema: appDomain.instantSchema(),
       useDateObjects: true,
     } as any);
   }
@@ -147,14 +155,93 @@ export async function runWorkflow() {
 - Keep workflow orchestration above actions.
 - Use `DOMAIN.md` plus `domain.contextString()` when an AI agent needs the model explained.
 
+## Public And Full Domains
+
+Use normal domain composition to split browser-visible schema from server/runtime
+capabilities. The public domain is a smaller domain. The full domain imports and
+extends it.
+
+```ts
+// @acme/sandbox/public
+export const sandboxDomain = domain("sandbox").withSchema({
+  entities: {
+    sandbox_sandboxes: i.entity({
+      provider: i.string().indexed(),
+      status: i.string().indexed(),
+      createdAt: i.number().indexed(),
+    }),
+  },
+  links: {},
+  rooms: {},
+});
+```
+
+```ts
+// @acme/sandbox
+import { sandboxDomain as publicSandboxDomain } from "@acme/sandbox/public";
+
+export const sandboxDomain = domain("sandbox")
+  .includes(publicSandboxDomain)
+  .withSchema({
+    entities: {
+      sandbox_processes: i.entity({
+        kind: i.string().indexed(),
+        status: i.string().indexed(),
+        command: i.string(),
+        startedAt: i.number().indexed(),
+      }),
+    },
+    links: {
+      sandboxProcessSandbox: {
+        forward: { on: "sandbox_processes", has: "one", label: "sandbox" },
+        reverse: { on: "sandbox_sandboxes", has: "many", label: "processes" },
+      },
+    },
+    rooms: {},
+  })
+  .withActions({
+    runCommand: defineAction({
+      name: "sandbox.runCommand",
+      async execute({ runtime, input }) {
+        "use step";
+        // server/provider work
+      },
+    }),
+  });
+```
+
+Client schema composition imports public domains:
+
+```ts
+import { sandboxDomain } from "@acme/sandbox/public";
+
+export const appDomain = domain("app")
+  .includes(sandboxDomain)
+  .withSchema({ entities: {}, links: {}, rooms: {} });
+
+export default appDomain.instantSchema();
+```
+
+Server runtime imports full domains:
+
+```ts
+import { sandboxDomain } from "@acme/sandbox";
+
+const sandbox = await runtime.use(sandboxDomain);
+await sandbox.actions.runCommand({ sandboxId, command: "pnpm", args: ["test"] });
+```
+
+This pattern controls schema visibility only. It is not an authorization model:
+configure Instant permissions for actual data access.
+
 ## CLI Input Quality Of Life
 
 The CLI accepts JSON5, `@file`, and stdin:
 
 ```bash
-npx @ekairos/domain query "{ tasks: { $: { limit: 5 } } }" --admin
-npx @ekairos/domain query @query.json5 --admin
-cat query.json5 | npx @ekairos/domain query - --admin
+ekairos domain query "{ tasks: { $: { limit: 5 } } }" --admin
+ekairos domain query @query.json5 --admin
+cat query.json5 | ekairos domain query - --admin
 ```
 
 Add `--meta` when you need to know whether a query used the local client runtime path or the server route.
@@ -166,3 +253,75 @@ pnpm --filter @ekairos/domain test
 pnpm --filter @ekairos/domain test:cli
 pnpm --filter @ekairos/domain test:workflow
 ```
+
+## Type And DX Notes
+
+`@ekairos/domain` intentionally encapsulates InstantDB at the domain boundary, but
+the schema returned by a domain must remain usable anywhere an InstantDB schema is
+expected.
+
+Use `instantSchema()` when provisioning or passing a runtime schema to InstantDB:
+
+```ts
+const db = init({
+  appId,
+  adminToken,
+  schema: appDomain.instantSchema(),
+});
+```
+
+Use `DomainInstantSchema<typeof domain>` when you need the schema type for
+`db.query`, `InstaQLParams`, `InstaQLResult`, or service constructors:
+
+```ts
+import type { DomainInstantSchema } from "@ekairos/domain";
+import type { InstantAdminDatabase } from "@instantdb/admin";
+
+type AppSchema = DomainInstantSchema<typeof appDomain>;
+
+function createService(db: InstantAdminDatabase<AppSchema, true>) {
+  return db.query({
+    tasks: {
+      owner: {},
+    },
+  });
+}
+```
+
+Prefer exported domain values without widening their type:
+
+```ts
+export const tasksDomain = domain("tasks").withSchema({
+  entities: { tasks: i.entity({ title: i.string() }) },
+  links: {},
+  rooms: {},
+});
+```
+
+Avoid annotating exported domains as plain `DomainSchemaResult` unless you need to
+hide their concrete shape. That annotation widens the domain name and schema, so
+TypeScript loses some compile-time checks for `runtime.use(...)`, `RuntimeForDomain`,
+and composed queries.
+
+```ts
+// Avoid for runtime/domain composition:
+export const tasksDomain: DomainSchemaResult = domain("tasks").withSchema(...);
+```
+
+Type tests under `src/__type_tests__` are intentionally split by use case:
+
+- `domain.schema-*.typecheck.ts`: schema extraction, entity/link visibility, and query shape.
+- `domain.includes-*.typecheck.ts`: composed entities, transitive links, and traversal direction.
+- `domain.instaql-fetch.typecheck.ts`: namespaces, associations, deferred query shapes, and `queryOnce`.
+- `domain.instaql-filters.typecheck.ts`: dotted relation filters and advanced where operators.
+- `domain.instaql-options.typecheck.ts`: pagination, ordering, selected fields, and page info.
+- `domain.instantdb-*.typecheck.ts`: InstantDB query, entity, and result helpers.
+- `domain.query-negative-*.typecheck.ts`: invalid entities and relation labels stay rejected.
+- `domain.dx-*.typecheck.ts`: public helper aliases, literal names, and schema helpers.
+- `runtime.domain-names-*.typecheck.ts`: `RuntimeForDomain` validates name plus schema.
+- `workflow-output-*.typecheck.ts`: workflow serde output contracts.
+
+When a type regression appears, add one small file or one focused case to the
+matching file. Avoid broad "kitchen sink" type tests; they make IntelliSense and
+compiler failures hard to read.
+

package/SKILL.md

@@ -0,0 +1,56 @@
+# Skill: ekairos-domain
+
+Use this skill when creating, editing, reviewing, or operating Ekairos domain code.
+
+## Core Contract
+
+- Model knowledge boundaries as domains first. A domain owns one coherent concept.
+- Domain names are camelCase, for example `supplierNetwork`, `procurement`, `qualityControl`.
+- Entity names must follow `<domainName>_<entityName>`, for example `supplierNetwork_supplier`.
+- Put writes behind `defineDomainAction(...)`.
+- Keep action bodies step-safe:
+  `async execute({ runtime, input }) { "use step"; const scoped = await runtime.use(appDomain); ... }`
+- Prefer typed action calls in app-owned code:
+  `const scoped = await runtime.use(appDomain); await scoped.actions.launchOrder(input);`
+- Use string action names only for dynamic runtime/HTTP/CLI execution.
+- Use explicit runtime classes that extend `EkairosRuntime`.
+- New Next.js apps expose `/api/ekairos/domain` through `createRuntimeRouteHandler({ createRuntime })`.
+- Do not use or reintroduce `withRuntime(...)`.
+
+## Domain Design Workflow
+
+1. Identify the knowledge domains before writing schema.
+2. Name every entity with its owning domain prefix.
+3. Use `domain(...).includes(...)` only when one domain needs another domain's entities or links.
+4. Keep root app domains thin. The root should usually include domains and register actions.
+5. Write actions around business use cases, not CRUD verbs.
+6. Verify the graph with a nested query that crosses at least two domains.
+
+## Schema Rules
+
+- Prefer operational names over abstract names.
+- Avoid generic `app_*` entities in new examples unless the domain itself is `app`.
+- Do not duplicate entity names across domains.
+- Links should describe the business relationship, not implementation plumbing.
+- Use optional attributes when migrating an existing app with data.
+
+## Runtime And Actions
+
+- Dynamic endpoints may call `executeRuntimeAction({ action: "domain.action", input })`.
+- Workflows and app code should use typed scoped actions.
+- Action outputs should return durable ids needed by callers.
+- Keep actions idempotent where possible when they will be used by smoke tests or agents.
+
+## Verification
+
+For a generated or edited app:
+
+1. Run `pnpm typecheck`.
+2. Start the app locally.
+3. Verify `GET /api/ekairos/domain`.
+4. Execute at least one domain action.
+5. Query the linked graph produced by that action.
+
+## Related Skills
+
+- CLI/application workflow skill: `../cli/SKILL.md`

package/dist/cli/bin.d.ts

@@ -4,6 +4,6 @@ type CliContext = {
     stdout: Pick<typeof output, "write">;
     stderr: Pick<typeof output, "write">;
 };
-export declare function runCli(argv: string[], ctx?: CliContext): Promise<1 | 0>;
+export declare function runCli(argv: string[], ctx?: CliContext): Promise<0 | 1>;
 export {};
 //# sourceMappingURL=bin.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"bin.d.ts","sourceRoot":"","sources":["../../src/cli/bin.ts"],"names":[],"mappings":";AAEA,OAAO,EAAkB,MAAM,IAAI,MAAM,EAAE,MAAM,cAAc,CAAA;AAgB/D,KAAK,UAAU,GAAG;IAChB,MAAM,EAAE,IAAI,CAAC,OAAO,MAAM,EAAE,OAAO,CAAC,CAAA;IACpC,MAAM,EAAE,IAAI,CAAC,OAAO,MAAM,EAAE,OAAO,CAAC,CAAA;CACrC,CAAA;AAkiBD,wBAAsB,MAAM,CAC1B,IAAI,EAAE,MAAM,EAAE,EACd,GAAG,GAAE,UAA+C,kBAkDrD"}
+{"version":3,"file":"bin.d.ts","sourceRoot":"","sources":["../../src/cli/bin.ts"],"names":[],"mappings":";AAGA,OAAO,EAAkB,MAAM,IAAI,MAAM,EAAE,MAAM,cAAc,CAAA;AAkB/D,KAAK,UAAU,GAAG;IAChB,MAAM,EAAE,IAAI,CAAC,OAAO,MAAM,EAAE,OAAO,CAAC,CAAA;IACpC,MAAM,EAAE,IAAI,CAAC,OAAO,MAAM,EAAE,OAAO,CAAC,CAAA;CACrC,CAAA;AAgqBD,wBAAsB,MAAM,CAC1B,IAAI,EAAE,MAAM,EAAE,EACd,GAAG,GAAE,UAA+C,kBAuDrD"}

package/dist/cli/bin.js

@@ -1,14 +1,19 @@
 #!/usr/bin/env node
 import { readFile } from "node:fs/promises";
+import { fileURLToPath } from "node:url";
 import { stdin as input, stdout as output } from "node:process";
 import readline from "node:readline/promises";
 import JSON5 from "json5";
 import { clearCliSession, fetchDomainManifest, normalizeBaseUrl, postDomainAction, postDomainQuery, readCliSession, writeCliSession, ClientRuntime, } from "./index.js";
-import { createDomainApp } from "./create-app.js";
+import { createDomainApp, normalizeCreateAppTemplate } from "./create-app.js";
 import { runCreateAppInk } from "./ui.js";
+const DOMAIN_SKILL_PATH = fileURLToPath(new URL("../../SKILL.md", import.meta.url));
 function printHelp(ctx) {
     ctx.stdout.write([
-        "ekairos-domain",
+        "ekairos domain",
+        "",
+        "This programmatic CLI is executed by @ekairos/cli.",
+        `Skill: ${DOMAIN_SKILL_PATH}`,
         "",
         "Commands:",
         "  login <baseUrl> [--refreshToken=<token>] [--appId=<appId>]",
@@ -24,17 +29,51 @@ function printHelp(ctx) {
         "  -         Read JSON5 from stdin",
         "",
         "Shorthand:",
-        "  ekairos-domain <actionKey> <json5|@file|-> [--env=<json5>]",
+        "  ekairos domain <actionKey> <json5|@file|-> [--env=<json5>]",
         "",
         "Output:",
         "  Stable JSON by default. Add --pretty for indented JSON.",
-        "  In interactive terminals, create-app shows a live React/Ink UI unless you pass --json.",
+        "  create-app uses an interactive UI in TTY terminals.",
+        "  Non-interactive create-app runs only when you pass --json, --plain, or --no-ui.",
         "",
         "Scaffold flags:",
-        "  --workspace <path>  Use the local workspace package instead of a published version",
-        "  --instantToken      Provision an Instant app and write .env.local",
-        "  --appId/--adminToken  Reuse an existing Instant app",
-        "  --json              Force plain JSON output and disable the interactive UI",
+        "  Run `ekairos create-app --help` for create-app flags.",
+        "",
+    ].join("\n"));
+}
+function printCreateAppHelp(ctx) {
+    ctx.stdout.write([
+        "ekairos create-app",
+        "",
+        `Skill: ${DOMAIN_SKILL_PATH}`,
+        "",
+        "Usage:",
+        "  ekairos create-app [dir] --next [options]",
+        "  ekairos create-app [dir] --framework=next [options]",
+        "",
+        "Interactive mode:",
+        "  In a TTY, omit --next/--framework and the CLI asks which framework to use.",
+        "",
+        "Non-interactive mode:",
+        "  Pass --json, --plain, or --no-ui explicitly.",
+        "  Non-interactive runs must pass --next or --framework=next.",
+        "",
+        "Options:",
+        "  --next, --framework=next       Scaffold a Next.js app",
+        "  --template=<name>              Template: empty, supply-chain, or agent",
+        "  --install / --no-install       Install dependencies after writing files",
+        "  --package-manager=<name>       npm, pnpm, yarn, or bun",
+        "  --instantToken=<token>         Provision an Instant app and write .env.local",
+        "  --appId=<id>                   Reuse an existing Instant app",
+        "  --adminToken=<token>           Reuse an existing Instant admin token",
+        "  --orgId=<id>                   Provision under an Instant org",
+        "  --workspace=<path>             Use a local Ekairos workspace package",
+        "  --force                        Replace a non-empty target directory",
+        "  --demo                         Run the full supply-chain demo cycle",
+        "  --smoke                        Typecheck, start Next, seed, and query the app",
+        "  --keep-server                  With --smoke, leave the review server running",
+        "  --json                         Print stable JSON and disable the interactive UI",
+        "  --print-secrets                Include secrets in JSON output; off by default",
         "",
     ].join("\n"));
 }
@@ -93,9 +132,49 @@ function shouldUseInteractiveCli(flags, ctx) {
         Boolean(output.isTTY) &&
         !hasFlag(flags, ["json", "plain", "no-ui"]));
 }
+function hasHelpArg(args) {
+    return args.some((arg) => arg === "--help" || arg === "-h" || arg === "help");
+}
+function isExplicitNonInteractive(flags) {
+    return hasFlag(flags, ["json", "plain", "no-ui", "demo"]);
+}
 function asTrimmedString(value) {
     return typeof value === "string" ? value.trim() : "";
 }
+function normalizeFramework(value) {
+    const normalized = value.trim().toLowerCase();
+    if (!normalized)
+        return "";
+    if (["next", "nextjs", "next.js"].includes(normalized))
+        return "next";
+    throw new Error(`Unsupported framework: ${value}. Supported framework: next.`);
+}
+function resolveFrameworkFlag(flags) {
+    if (hasFlag(flags, ["next"]))
+        return "next";
+    const framework = asTrimmedString(flagValue(flags, ["framework"]));
+    return normalizeFramework(framework);
+}
+async function promptCreateAppFramework() {
+    const rl = readline.createInterface({ input, output });
+    try {
+        const answer = await rl.question("Framework [Next.js]: ");
+        const framework = normalizeFramework(String(answer ?? "").trim() || "next");
+        if (framework !== "next") {
+            throw new Error(`Unsupported framework: ${framework}`);
+        }
+        return "next";
+    }
+    finally {
+        rl.close();
+    }
+}
+function createAppOutputData(result, flags) {
+    if (hasFlag(flags, ["print-secrets", "printSecrets"]))
+        return result;
+    const { adminToken: _adminToken, ...safeResult } = result;
+    return safeResult;
+}
 async function promptRefreshToken() {
     const rl = readline.createInterface({ input, output });
     try {
@@ -127,6 +206,13 @@ function toJsonText(value, flags) {
 function writeJson(stream, value, flags) {
     stream.write(toJsonText(value, flags));
 }
+async function flushCliOutput(stream) {
+    if (stream !== output)
+        return;
+    await new Promise((resolveFlush) => {
+        output.write("", () => resolveFlush());
+    });
+}
 async function readStdinText() {
     let data = "";
     for await (const chunk of input) {
@@ -292,18 +378,40 @@ async function commandInspect(args, ctx) {
     }, flags);
 }
 async function commandCreateApp(args, ctx) {
+    if (hasHelpArg(args)) {
+        printCreateAppHelp(ctx);
+        return;
+    }
     const { positionals, flags } = parseFlags(args);
-    if (!hasFlag(flags, ["next"])) {
-        throw new Error("create-app currently requires --next");
+    const interactive = shouldUseInteractiveCli(flags, ctx);
+    const demo = hasFlag(flags, ["demo"]);
+    if (!interactive && !isExplicitNonInteractive(flags)) {
+        throw new Error("create-app non-interactive mode is explicit. Pass --json, --plain, or --no-ui.");
+    }
+    let framework = resolveFrameworkFlag(flags);
+    if (!framework && demo) {
+        framework = "next";
+    }
+    if (!framework && interactive) {
+        framework = await promptCreateAppFramework();
     }
-    const directory = String(positionals[0] ?? ".").trim() || ".";
+    if (!framework) {
+        throw new Error("framework is required. Pass --next or --framework=next.");
+    }
+    const directory = String(positionals[0] ?? (demo ? "ekairos-supply-chain-demo" : ".")).trim() ||
+        (demo ? "ekairos-supply-chain-demo" : ".");
+    const template = normalizeCreateAppTemplate(flagValue(flags, ["template"]));
     const install = flagValue(flags, ["install"]) !== false;
+    const keptServers = [];
     const params = {
         directory,
-        framework: "next",
+        framework,
         install,
+        template: template ?? undefined,
+        demo,
         force: hasFlag(flags, ["force"]),
-        packageManager: asTrimmedString(flagValue(flags, ["packageManager", "package-manager"])),
+        packageManager: asTrimmedString(flagValue(flags, ["packageManager", "package-manager"])) ||
+            (demo ? "pnpm" : ""),
         workspacePath: asTrimmedString(flagValue(flags, ["workspace"])),
         instantToken: asTrimmedString(flagValue(flags, ["instantToken", "instant-token"])) ||
             asTrimmedString(process.env.INSTANT_PERSONAL_ACCESS_TOKEN) ||
@@ -312,19 +420,28 @@ async function commandCreateApp(args, ctx) {
         orgId: asTrimmedString(flagValue(flags, ["orgId", "org-id"])),
         appId: asTrimmedString(flagValue(flags, ["appId", "app-id"])),
         adminToken: asTrimmedString(flagValue(flags, ["adminToken", "admin-token"])),
+        smoke: demo || hasFlag(flags, ["smoke"]),
+        keepServer: demo || hasFlag(flags, ["keep-server", "keepServer"]),
+        onKeepServer(server) {
+            keptServers.push(server.unref);
+        },
     };
-    const interactive = shouldUseInteractiveCli(flags, ctx);
     const result = interactive
         ? await runCreateAppInk(params)
         : await createDomainApp(params);
     if (interactive) {
+        for (const unref of keptServers)
+            unref();
         return;
     }
     writeJson(ctx.stdout, {
         ok: true,
         command: "create-app",
-        data: result,
+        data: createAppOutputData(result, flags),
     }, flags);
+    await flushCliOutput(ctx.stdout);
+    for (const unref of keptServers)
+        unref();
 }
 async function commandQuery(args, ctx) {
     const { positionals, flags } = parseFlags(args);
@@ -428,10 +545,17 @@ async function commandLogout(args, ctx) {
 export async function runCli(argv, ctx = { stdout: output, stderr: output }) {
     const [command, ...rest] = argv;
     try {
-        if (!command || command === "help" || command === "--help" || command === "-h") {
+        if (!command || command === "--help" || command === "-h") {
             printHelp(ctx);
             return 0;
         }
+        if (command === "help") {
+            if (rest[0] === "create-app")
+                printCreateAppHelp(ctx);
+            else
+                printHelp(ctx);
+            return 0;
+        }
         if (command === "login") {
             await commandLogin(rest, ctx);
             return 0;
@@ -475,10 +599,7 @@ const isDirectExecution = (() => {
     const normalized = current.replace(/\\/g, "/");
     const fileName = normalized.split("/").pop() ?? "";
     return (current.endsWith("bin.js") ||
-        current.endsWith("bin.ts") ||
-        fileName === "ekairos-domain" ||
-        fileName === "ekairos-domain.cmd" ||
-        fileName === "ekairos-domain.ps1");
+        current.endsWith("bin.ts"));
 })();
 if (isDirectExecution) {
     runCli(process.argv.slice(2)).then((code) => {