@nyxa/automation 0.1.1 → 0.1.2

package/README.md

@@ -17,52 +17,75 @@ Their authentication, subscriptions, and quotas remain the user's
 responsibility; Automation does not manage provider accounts, credentials,
 billing, or limits.
 
-## Install
+## Initialize a project
+
+Run `init` from any project directory. The host project does not need to be a
+Node.js package and its root files are not modified. Automation creates a
+private environment under `.automation/` and refuses to overwrite an existing
+Workflow:
 
 ```sh
-npm install --save-dev @nyxa/automation
+npx @nyxa/automation init first.ts
 ```
 
-The package includes its TypeScript runtime loader. A project does not need a
-global TypeScript or `tsx` installation to run a Workflow.
-
-## Initialize an existing project
-
-Run `init` from a project that already has a `package.json`. It refuses to
-overwrite the requested Workflow and detects npm, pnpm, or Yarn from the
-project lockfile before offering to add Automation as a development dependency:
+The generated layout is:
 
-```sh
-npx @nyxa/automation init workflows/first.ts
+```text
+.automation/
+├── .gitignore
+├── package.json
+├── tsconfig.json
+└── workflows/
+    └── first.ts
 ```
 
-Choose the Harness explicitly for non-interactive use. `--no-install` only
-generates the Workflow; `--yes` accepts installation and, when `--harness` is
+The private package declares `@nyxa/automation`, TypeScript, and the Node.js
+types. Together with the generated `tsconfig.json`, this lets editors resolve
+Workflow imports and provide completion and inferred types without turning the
+host project into a Node.js package. Automation always uses npm inside this
+private environment, independently of any npm, pnpm, Yarn, or workspace
+configuration in the host project. Dependencies and `package-lock.json` stay
+inside `.automation/`; its `.gitignore` keeps `node_modules/` out of the host
+repository.
+
+Choose the Harness explicitly for non-interactive use. `--no-install` generates
+the private package, TypeScript configuration, and Workflow without installing
+their dependencies. `--yes` accepts installation and, when `--harness` is
 omitted, selects a Harness only if exactly one local Harness is operational.
 
 ```sh
-npx @nyxa/automation init workflows/codex.ts --harness codex --yes
-npx @nyxa/automation init workflows/claude.ts --harness claude-code --no-install
-npx @nyxa/automation init workflows/kimi.ts --harness kimi-code --no-install
-npx @nyxa/automation init workflows/opencode.ts --harness opencode --no-install
+npx @nyxa/automation init codex.ts --harness codex --yes
+npx @nyxa/automation init claude.ts --harness claude-code --no-install
+npx @nyxa/automation init kimi.ts --harness kimi-code --no-install
+npx @nyxa/automation init opencode.ts --harness opencode --no-install
 ```
 
 The generated Workflow imports only the selected Harness, requests a documented
 structured result, and handles a `needs_input` result with ordinary TypeScript
-control flow.
+control flow. The package includes its TypeScript runtime loader, so no global
+TypeScript or `tsx` installation is required to run a Workflow.
+
+The Automation Environment pins the exact Automation version that created it.
+Later `init` commands delegate to that installed version instead of silently
+changing ownership. Upgrade the environment explicitly before using a newer
+`init` contract:
+
+```sh
+npm --prefix .automation install --save-dev --save-exact @nyxa/automation@latest
+```
 
 ## Diagnose the local environment
 
-Run `doctor` before a Workflow to check Node.js, the project-local Automation
-package, and the installed Codex, Claude Code, Kimi Code, and OpenCode
-Harnesses:
+Run `doctor` before a Workflow to check Node.js, the Automation package installed
+inside `.automation/`, and the installed Codex, Claude Code, Kimi Code, and
+OpenCode Harnesses:
 
 ```sh
-npx automation doctor
-npx automation doctor --harness codex
-npx automation doctor --harness claude-code
-npx automation doctor --harness kimi-code
-npx automation doctor --harness opencode
+npx @nyxa/automation doctor
+npx @nyxa/automation doctor --harness codex
+npx @nyxa/automation doctor --harness claude-code
+npx @nyxa/automation doctor --harness kimi-code
+npx @nyxa/automation doctor --harness opencode
 ```
 
 The command checks Harness versions and verifies authentication headlessly.
@@ -75,10 +98,20 @@ Without a filter, one fully operational Harness is sufficient and missing
 Harnesses are reported as warnings. With `--harness`, the requested Harness
 must be fully operational.
 
+## Install in a Node.js package
+
+The isolated Automation Environment is sufficient for CLI Workflows. Install
+the package in the host project as well only when that project's own Node.js
+modules import the programmatic interface directly:
+
+```sh
+npm install --save-dev @nyxa/automation
+```
+
 ## Define a Workflow
 
 ```ts
-// workflow.ts
+// .automation/workflows/first.ts
 import { defineWorkflow } from "@nyxa/automation";
 
 const workflow = defineWorkflow({
@@ -95,7 +128,7 @@ always explicit:
 
 ```ts
 import { executeWorkflow } from "@nyxa/automation";
-import workflow from "./workflow.js";
+import workflow from "./.automation/workflows/first.js";
 
 const result = await executeWorkflow(workflow);
 // result is inferred as { status: string; count: number }
@@ -311,7 +344,7 @@ await executeWorkflow(workflow, { concurrency: 2 });
 ```
 
 ```sh
-npx automation workflow.ts --concurrency 2
+npx @nyxa/automation first.ts --concurrency 2
 ```
 
 Several `read` Runs can share a Workspace within that limit. A
@@ -466,7 +499,7 @@ await executeWorkflow(workflow, { record: false });
 ```
 
 ```sh
-npx automation workflow.ts --no-record
+npx @nyxa/automation first.ts --no-record
 ```
 
 On Linux, journals use `$XDG_STATE_HOME/automation/run-journals` when that
@@ -504,27 +537,31 @@ const result = await executeWorkflow(workflow, {
 
 ## Run from the CLI
 
-The direct and explicit forms are equivalent:
+The direct and explicit forms are equivalent. `npx @nyxa/automation` bootstraps
+the command and delegates Workflow execution to the version installed inside
+`.automation/`. A simple name resolves from `.automation/workflows/`; an
+existing explicit path remains usable:
 
 ```sh
-npx automation workflow.ts
-npx automation run workflow.ts
+npx @nyxa/automation first.ts
+npx @nyxa/automation run first.ts
+npx @nyxa/automation .automation/workflows/first.ts
 ```
 
 Provide a declared Workflow Input as inline JSON, from a file, or from standard
 input. These sources are mutually exclusive.
 
 ```sh
-npx automation workflow.ts --input '{"name":"Nyxa"}'
-npx automation workflow.ts --input-file input.json
-printf '%s' '{"name":"Nyxa"}' | npx automation workflow.ts --input -
+npx @nyxa/automation first.ts --input '{"name":"Nyxa"}'
+npx @nyxa/automation first.ts --input-file input.json
+printf '%s' '{"name":"Nyxa"}' | npx @nyxa/automation first.ts --input -
 ```
 
 Use `--json` for a JSONL stream containing only Automation Events on `stdout`.
 The terminal `workflow.completed` event carries the Workflow Result.
 
 ```sh
-npx automation workflow.ts --json
+npx @nyxa/automation first.ts --json
 ```
 
 Strings are written to `stdout` as-is, other JSON values are serialized, and

package/dist/cli.js

@@ -22,12 +22,12 @@ const HELP = `Usage: automation <workflow> [options]
        automation <command>
 
 Commands:
-  init                 Initialize Automation in an existing npm project
+  init                 Initialize a project-local .automation environment
   doctor               Diagnose the local Automation environment
 
 Options:
   --harness <name>     Select codex, claude-code, kimi-code, or opencode for init or doctor
-  --no-install         Generate a Workflow without installing the package
+  --no-install         Generate the environment without installing dependencies
   --yes                Accept init installation and auto-select one ready Harness
   --input <json|->     Read Workflow Input from inline JSON or stdin
   --input-file <path>  Read Workflow Input from a JSON file
@@ -39,6 +39,8 @@ Options:
 `;
 async function main(arguments_) {
     const invocation = classifyInvocation(arguments_);
+    let parsedArguments;
+    let resolvedWorkflowPath;
     if (invocation === "help") {
         writeSync(process.stdout.fd, HELP);
         return SUCCESS;
@@ -56,7 +58,7 @@ async function main(arguments_) {
     if (invocation === "doctor") {
         try {
             const harness = parseDoctorArguments(arguments_.slice(1));
-            const localPackage = resolveProjectLocalPackage(process.cwd());
+            const localPackage = resolveProjectLocalPackage(path.join(process.cwd(), ".automation"));
             const result = await diagnoseEnvironment({
                 environment: process.env,
                 ...(harness === undefined ? {} : { harness }),
@@ -79,6 +81,15 @@ async function main(arguments_) {
     }
     if (invocation === "init") {
         try {
+            const localPackage = resolveProjectLocalPackage(path.join(process.cwd(), ".automation"));
+            if (localPackage !== undefined) {
+                if (!localPackage.binaryAvailable) {
+                    throw new Error(`The project-local ${PACKAGE_NAME} package is missing its automation binary. Reinstall the .automation environment before running init.`);
+                }
+                if (!isCurrentCli(localPackage.cliPath)) {
+                    return await delegateToLocalCli(localPackage.cliPath, arguments_);
+                }
+            }
             const output = await initializeProject(arguments_.slice(1));
             writeSync(process.stdout.fd, output);
             return SUCCESS;
@@ -90,9 +101,11 @@ async function main(arguments_) {
     }
     if (invocation === "workflow") {
         try {
-            const localPackage = resolveProjectLocalPackage(process.cwd());
+            parsedArguments = parseArguments(arguments_);
+            resolvedWorkflowPath = resolveWorkflowModulePath(process.cwd(), parsedArguments.workflowPath);
+            const localPackage = resolveProjectLocalPackage(path.dirname(resolvedWorkflowPath));
             if (localPackage === undefined) {
-                throw new Error(`A project-local installation of ${PACKAGE_NAME} is required to execute a Workflow. Install it as a development dependency before running this command.`);
+                throw new Error(`A project-local installation of ${PACKAGE_NAME} is required to execute a Workflow. Run npx @nyxa/automation init <workflow> and install the .automation environment dependencies first.`);
             }
             if (!localPackage.binaryAvailable) {
                 throw new Error(`The project-local ${PACKAGE_NAME} package is missing its automation binary. Reinstall it before running a Workflow.`);
@@ -106,10 +119,9 @@ async function main(arguments_) {
             return PRE_EXECUTION_ERROR;
         }
     }
-    let parsedArguments;
     let loadedInput;
     try {
-        parsedArguments = parseArguments(arguments_);
+        parsedArguments ??= parseArguments(arguments_);
         loadedInput = await loadWorkflowInput(parsedArguments.inputSource);
     }
     catch (error) {
@@ -118,7 +130,8 @@ async function main(arguments_) {
     }
     let workflowModule;
     try {
-        const workflowUrl = pathToFileURL(path.resolve(process.cwd(), parsedArguments.workflowPath));
+        const workflowUrl = pathToFileURL(resolvedWorkflowPath ??
+            resolveWorkflowModulePath(process.cwd(), parsedArguments.workflowPath));
         workflowModule = (await tsImport(workflowUrl.href, import.meta.url));
     }
     catch (cause) {
@@ -235,20 +248,26 @@ function ownPackageVersion() {
 }
 function resolveProjectLocalPackage(invocationDirectory) {
     let directory = path.resolve(invocationDirectory);
-    let dependencyDeclared = false;
     while (true) {
         const projectManifestPath = path.join(directory, "package.json");
+        let projectManifest;
         try {
-            const projectManifest = readPackageManifest(projectManifestPath);
-            dependencyDeclared ||= hasAutomationDevelopmentDependency(projectManifest);
+            projectManifest = readPackageManifest(projectManifestPath);
         }
         catch (error) {
             if (!isMissingFileError(error)) {
                 throw error;
             }
         }
-        const manifestPath = path.join(directory, "node_modules", "@nyxa", "automation", "package.json");
-        if (dependencyDeclared) {
+        const declaredVersion = projectManifest?.devDependencies?.[PACKAGE_NAME];
+        const isAutomationEnvironment = path.basename(directory) === ".automation";
+        if (projectManifest !== undefined &&
+            isAutomationEnvironment &&
+            typeof declaredVersion !== "string") {
+            throw new Error(`The Automation Environment at ${projectManifestPath} does not declare ${PACKAGE_NAME} as a development dependency.`);
+        }
+        if (typeof declaredVersion === "string") {
+            const manifestPath = path.join(directory, "node_modules", "@nyxa", "automation", "package.json");
             let manifest;
             try {
                 manifest = readPackageManifest(manifestPath);
@@ -258,26 +277,31 @@ function resolveProjectLocalPackage(invocationDirectory) {
                     throw error;
                 }
             }
-            if (manifest !== undefined) {
-                if (manifest.name !== PACKAGE_NAME) {
-                    throw new Error(`The project-local package at ${manifestPath} is not ${PACKAGE_NAME}.`);
-                }
-                const binary = typeof manifest.bin === "string"
-                    ? manifest.bin
-                    : manifest.bin?.automation;
-                if (typeof binary !== "string") {
-                    throw new Error(`The project-local ${PACKAGE_NAME} package does not expose the automation binary.`);
-                }
-                if (typeof manifest.version !== "string") {
-                    throw new Error(`The project-local ${PACKAGE_NAME} package has no valid version.`);
-                }
-                const cliPath = path.resolve(path.dirname(manifestPath), binary);
-                return {
-                    binaryAvailable: isRegularFile(cliPath),
-                    cliPath,
-                    version: manifest.version,
-                };
+            if (manifest === undefined) {
+                return undefined;
+            }
+            if (manifest.name !== PACKAGE_NAME) {
+                throw new Error(`The project-local package at ${manifestPath} is not ${PACKAGE_NAME}.`);
+            }
+            const binary = typeof manifest.bin === "string"
+                ? manifest.bin
+                : manifest.bin?.automation;
+            if (typeof binary !== "string") {
+                throw new Error(`The project-local ${PACKAGE_NAME} package does not expose the automation binary.`);
+            }
+            if (typeof manifest.version !== "string") {
+                throw new Error(`The project-local ${PACKAGE_NAME} package has no valid version.`);
             }
+            if (isAutomationEnvironment &&
+                manifest.version !== declaredVersion) {
+                throw new Error(`The Automation Environment declares ${PACKAGE_NAME} ${declaredVersion}, but its installed package is ${manifest.version}. Run npm install inside .automation before continuing.`);
+            }
+            const cliPath = path.resolve(path.dirname(manifestPath), binary);
+            return {
+                binaryAvailable: isRegularFile(cliPath),
+                cliPath,
+                version: manifest.version,
+            };
         }
         const parent = path.dirname(directory);
         if (parent === directory) {
@@ -286,6 +310,19 @@ function resolveProjectLocalPackage(invocationDirectory) {
         directory = parent;
     }
 }
+function resolveWorkflowModulePath(invocationDirectory, requestedPath) {
+    const explicitPath = path.resolve(invocationDirectory, requestedPath);
+    if (isRegularFile(explicitPath)) {
+        return explicitPath;
+    }
+    const environmentDirectory = path.join(invocationDirectory, ".automation");
+    const environmentWorkflowPath = path.resolve(environmentDirectory, "workflows", requestedPath);
+    if (isRegularFile(environmentWorkflowPath) ||
+        isRegularFile(path.join(environmentDirectory, "package.json"))) {
+        return environmentWorkflowPath;
+    }
+    return explicitPath;
+}
 function isRegularFile(filePath) {
     try {
         return statSync(filePath).isFile();
@@ -297,9 +334,6 @@ function isRegularFile(filePath) {
         throw error;
     }
 }
-function hasAutomationDevelopmentDependency(manifest) {
-    return typeof manifest.devDependencies?.[PACKAGE_NAME] === "string";
-}
 function readPackageManifest(manifestPath) {
     const serialized = readFileSync(manifestPath, "utf8");
     try {

package/dist/init.js

@@ -1,35 +1,29 @@
 import { access, mkdir, readFile, writeFile } from "node:fs/promises";
 import path from "node:path";
+import { fileURLToPath } from "node:url";
 import { diagnoseEnvironment } from "./doctor.js";
 import { isMissingFileError } from "./filesystem.js";
 import { readStandardInput } from "./standard-input.js";
+const AUTOMATION_DIRECTORY = ".automation";
+const WORKFLOW_DIRECTORY = "workflows";
 export async function initializeProject(arguments_, invocationDirectory = process.cwd()) {
     const parsed = parseInitArguments(arguments_);
     const prompt = !parsed.yes && (parsed.harness === undefined || parsed.install)
         ? await createPrompt()
         : undefined;
-    const manifestPath = path.join(invocationDirectory, "package.json");
     try {
-        try {
-            JSON.parse(await readFile(manifestPath, "utf8"));
-        }
-        catch (error) {
-            if (isMissingFileError(error)) {
-                throw new Error("init requires a package.json from an existing npm project.");
-            }
-            throw error;
-        }
         const harness = await resolveHarness(parsed, invocationDirectory, prompt);
         const install = await resolveInstall(parsed, prompt);
-        const workflowPath = path.resolve(invocationDirectory, parsed.workflowPath);
+        const environmentDirectory = path.join(invocationDirectory, AUTOMATION_DIRECTORY);
+        const workflowRoot = path.join(environmentDirectory, WORKFLOW_DIRECTORY);
+        const workflowPath = resolveWorkflowPath(workflowRoot, parsed.workflowPath);
         if (await pathExists(workflowPath)) {
             throw workflowExistsError(parsed.workflowPath);
         }
-        const packageManager = install
-            ? await detectPackageManager(invocationDirectory)
-            : undefined;
+        await initializeAutomationEnvironment(environmentDirectory);
+        const packageManager = install ? PACKAGE_MANAGER : undefined;
         if (packageManager !== undefined) {
-            await installAutomationDependency(packageManager, invocationDirectory);
+            await installAutomationDependencies(packageManager, environmentDirectory);
         }
         await mkdir(path.dirname(workflowPath), { recursive: true });
         try {
@@ -44,9 +38,10 @@ export async function initializeProject(arguments_, invocationDirectory = proces
             }
             throw error;
         }
-        let output = `Created ${parsed.workflowPath}.\n`;
+        const displayedWorkflowPath = path.relative(invocationDirectory, workflowPath);
+        let output = `Created ${displayedWorkflowPath}.\n`;
         if (packageManager !== undefined) {
-            output += `Installed @nyxa/automation with ${packageManager.displayName}.\n`;
+            output += `Installed the Automation environment with ${packageManager.displayName}.\n`;
         }
         return output;
     }
@@ -101,7 +96,7 @@ async function resolveInstall(arguments_, prompt) {
     if (!arguments_.install || arguments_.yes) {
         return arguments_.install;
     }
-    const answer = await requirePrompt(prompt).question("Install @nyxa/automation as a development dependency? [Y/n] ");
+    const answer = await requirePrompt(prompt).question("Install the Automation environment dependencies? [Y/n] ");
     if (answer === "" || answer === "y" || answer === "yes") {
         return true;
     }
@@ -145,39 +140,16 @@ function requirePrompt(prompt) {
     }
     return prompt;
 }
-const PACKAGE_MANAGERS = [
-    {
-        displayName: "npm",
-        executable: "npm",
-        installArguments: ["install", "--save-dev", "@nyxa/automation"],
-        lockfile: "package-lock.json",
-    },
-    {
-        displayName: "pnpm",
-        executable: "pnpm",
-        installArguments: ["add", "--save-dev", "@nyxa/automation"],
-        lockfile: "pnpm-lock.yaml",
-    },
-    {
-        displayName: "Yarn",
-        executable: "yarn",
-        installArguments: ["add", "--dev", "@nyxa/automation"],
-        lockfile: "yarn.lock",
-    },
-];
-async function detectPackageManager(invocationDirectory) {
-    for (const packageManager of PACKAGE_MANAGERS) {
-        if (await pathExists(path.join(invocationDirectory, packageManager.lockfile))) {
-            return packageManager;
-        }
-    }
-    throw new Error("Could not detect npm, pnpm, or Yarn. Add the package manager lockfile first.");
-}
-async function installAutomationDependency(packageManager, invocationDirectory) {
+const PACKAGE_MANAGER = {
+    displayName: "npm",
+    executable: "npm",
+    installArguments: ["install"],
+};
+async function installAutomationDependencies(packageManager, environmentDirectory) {
     const { spawn } = await import("node:child_process");
     const exitCode = await new Promise((resolve, reject) => {
         const child = spawn(packageManager.executable, packageManager.installArguments, {
-            cwd: invocationDirectory,
+            cwd: environmentDirectory,
             env: process.env,
             stdio: "inherit",
         });
@@ -185,8 +157,93 @@ async function installAutomationDependency(packageManager, invocationDirectory)
         child.once("exit", (code) => resolve(code ?? 1));
     });
     if (exitCode !== 0) {
-        throw new Error(`${packageManager.displayName} could not install @nyxa/automation (exit ${String(exitCode)}).`);
+        throw new Error(`${packageManager.displayName} could not install the Automation environment (exit ${String(exitCode)}).`);
+    }
+}
+async function initializeAutomationEnvironment(environmentDirectory) {
+    await mkdir(path.join(environmentDirectory, WORKFLOW_DIRECTORY), {
+        recursive: true,
+    });
+    const manifestPath = path.join(environmentDirectory, "package.json");
+    const ownManifestPath = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "../package.json");
+    const ownManifest = parsePackageManifest(await readFile(ownManifestPath, "utf8"), ownManifestPath);
+    if (typeof ownManifest.version !== "string") {
+        throw new Error("The installed @nyxa/automation package has no version.");
+    }
+    if (await pathExists(manifestPath)) {
+        const manifest = parsePackageManifest(await readFile(manifestPath, "utf8"), manifestPath);
+        const declaredVersion = manifest.devDependencies?.["@nyxa/automation"];
+        if (typeof declaredVersion !== "string") {
+            throw new Error(`${manifestPath} does not declare @nyxa/automation as a development dependency.`);
+        }
+        if (declaredVersion !== ownManifest.version) {
+            throw new Error(`The Automation Environment is owned by @nyxa/automation ${declaredVersion}, but init is running ${ownManifest.version}. Install the environment dependencies or update its @nyxa/automation version explicitly before running init again.`);
+        }
+    }
+    else {
+        await writeFile(manifestPath, `${JSON.stringify({
+            name: "automation-workflows",
+            private: true,
+            type: "module",
+            devDependencies: {
+                "@nyxa/automation": ownManifest.version,
+                "@types/node": dependencyVersion(ownManifest, "@types/node"),
+                typescript: dependencyVersion(ownManifest, "typescript"),
+            },
+        }, null, 2)}\n`, { encoding: "utf8", flag: "wx" });
+    }
+    const tsconfigPath = path.join(environmentDirectory, "tsconfig.json");
+    if (!(await pathExists(tsconfigPath))) {
+        await writeFile(tsconfigPath, `${JSON.stringify({
+            compilerOptions: {
+                target: "ES2023",
+                module: "NodeNext",
+                moduleResolution: "NodeNext",
+                types: ["node"],
+                strict: true,
+                exactOptionalPropertyTypes: true,
+                noUncheckedIndexedAccess: true,
+                noEmit: true,
+                skipLibCheck: true,
+            },
+            include: ["workflows/**/*.ts"],
+        }, null, 2)}\n`, { encoding: "utf8", flag: "wx" });
+    }
+    const gitignorePath = path.join(environmentDirectory, ".gitignore");
+    if (!(await pathExists(gitignorePath))) {
+        await writeFile(gitignorePath, "node_modules/\n", {
+            encoding: "utf8",
+            flag: "wx",
+        });
+    }
+}
+function parsePackageManifest(serialized, manifestPath) {
+    try {
+        return JSON.parse(serialized);
+    }
+    catch (cause) {
+        throw new Error(`Could not parse package manifest at ${manifestPath}.`, {
+            cause,
+        });
+    }
+}
+function dependencyVersion(manifest, dependency) {
+    const version = manifest.devDependencies?.[dependency];
+    if (typeof version !== "string") {
+        throw new Error(`The installed @nyxa/automation package does not declare ${dependency}.`);
+    }
+    return version;
+}
+function resolveWorkflowPath(workflowRoot, requestedPath) {
+    const workflowPath = path.resolve(workflowRoot, requestedPath);
+    const relativePath = path.relative(workflowRoot, workflowPath);
+    if (relativePath === "" ||
+        relativePath === ".." ||
+        relativePath.startsWith(`..${path.sep}`) ||
+        path.isAbsolute(relativePath)) {
+        throw new Error("The Workflow path must stay inside .automation/workflows.");
     }
+    return workflowPath;
 }
 async function pathExists(filePath) {
     try {

package/dist/kimi-code.js

@@ -188,7 +188,7 @@ function createKimiConnection(input, output, options) {
 async function initializeAndAuthenticate(connection) {
     const initialized = await connection.initialize({
         clientCapabilities: {},
-        clientInfo: { name: "@nyxa/automation", version: "0.1.1" },
+        clientInfo: { name: "@nyxa/automation", version: "0.1.2" },
         protocolVersion: PROTOCOL_VERSION,
     });
     if (initialized.protocolVersion !== PROTOCOL_VERSION) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nyxa/automation",
-  "version": "0.1.1",
+  "version": "0.1.2",
   "description": "Execute trusted TypeScript Workflows with local Harness CLIs.",
   "repository": {
     "type": "git",