hostctl 0.1.45 → 0.1.48

package/README.md

@@ -93,12 +93,14 @@ npx hostctl run core.echo message:hello
   ```
   Local directories are executed directly and are not installable via `hostctl pkg install`.
 - **Remote orchestration**
+
   ```bash
   hostctl run -r -t ubuntu core.net.interfaces --json
   ```
 
   - `-r/--remote` targets hosts selected by tags via SSH.
   - `-t/--tag` is greedy; use `--` before positional args when needed.
+
 - **From npm or git**
   ```bash
   hostctl run hostctl-hello greet name:Phil
@@ -204,7 +206,6 @@ Key `TaskContext` capabilities (see [`docs/task-api.md`](docs/task-api.md) for d
 - **Version mismatch**: keep `package.json`, `src/version.ts`, and `jsr.json` in sync before releasing.
 - **SSH failures**: verify inventory entries (hostname, user, auth) and only pass `-r` when you intend remote execution.
 - **Secrets**: when inventories are encrypted, ensure `AGE_IDS` includes the private keys so `hostctl` can decrypt secrets.
-- **Environment drift**: run `hostctl runtime` to inspect prerequisites or `hostctl runtime install` to bootstrap them.
 
 ## Developer workflow
 

package/dist/bin/hostctl.js

@@ -3886,11 +3886,168 @@ var LocalRuntime = class {
   }
 };
 
+// src/zip.ts
+import AdmZip from "adm-zip";
+
+// src/hash.ts
+import { createHash } from "crypto";
+
+// src/param-map.ts
+import { match as match2 } from "ts-pattern";
+var ParamMap = class _ParamMap {
+  /**
+   * Parses CLI arguments of the form key:value, only supporting top-level keys.
+   * Only the first colon is treated as a key/value separator; all subsequent colons are part of the value.
+   * This means nested keys are not supported, but values can contain colons (e.g., URLs, JSON, etc.).
+   */
+  static parse(cliArguments) {
+    const root = new _ParamMap();
+    A2(cliArguments).each((arg) => {
+      const idx = arg.indexOf(":");
+      if (idx === -1) {
+        root.set([arg], "true");
+        return;
+      }
+      const key = arg.slice(0, idx);
+      const value = arg.slice(idx + 1);
+      root.set([key], value);
+    });
+    return root;
+  }
+  map;
+  constructor() {
+    this.map = /* @__PURE__ */ new Map();
+  }
+  get(keyPath) {
+    const keys3 = keyPath.split(":");
+    let node = this;
+    for (let i = 0; i < keys3.length; i++) {
+      if (!(node instanceof _ParamMap)) return void 0;
+      node = node.map.get(keys3[i]);
+      if (node === void 0) return void 0;
+    }
+    if (node instanceof _ParamMap) {
+      return node.toObject();
+    }
+    return this.stringToJsonObj(node);
+  }
+  set(keyPath, value) {
+    const keyParts = Array.isArray(keyPath) ? keyPath : keyPath.split(":");
+    let node = this;
+    for (let i = 0; i < keyParts.length - 1; i++) {
+      const key = keyParts[i];
+      let nextNode = node.map.get(key);
+      if (!(nextNode instanceof _ParamMap)) {
+        nextNode = new _ParamMap();
+        node.map.set(key, nextNode);
+      }
+      node = nextNode;
+    }
+    const lastKey = keyParts[keyParts.length - 1];
+    node.map.set(lastKey, value);
+  }
+  toObject() {
+    let obj = {};
+    M(this.map).each(([k, v]) => {
+      obj[k] = v instanceof _ParamMap ? v.toObject() : this.stringToJsonObj(v);
+    });
+    return obj;
+  }
+  stringToJsonObj(str) {
+    if (typeof str !== "string") return str;
+    const trimmed = str.trim();
+    if (trimmed.startsWith("{") && trimmed.endsWith("}") || trimmed.startsWith("[") && trimmed.endsWith("]")) {
+      try {
+        return JSON.parse(trimmed);
+      } catch {
+      }
+    }
+    return match2(str).when(matches(/,/), (s) => {
+      return VP(s.split(",")).map((v) => v.trim()).compact([""]).map((v) => this.stringToJsonObj(v)).value;
+    }).when(isNumeric, (s) => parseFloat(s)).when(
+      (s) => s.trim() === "",
+      () => ""
+    ).otherwise(() => str);
+  }
+};
+
+// src/runtime.ts
+import * as z from "zod";
+
+// src/version.ts
+var version = "0.1.48";
+
+// src/app.ts
+import { retryUntilDefined } from "ts-retry";
+import { Mutex as Mutex3 } from "async-mutex";
+import { match as match5 } from "ts-pattern";
+
+// src/core/remote/runAllRemote.ts
+var RunParamsSchema = z.object({
+  taskFn: z.custom((value) => typeof value === "function", {
+    message: "taskFn must be a function"
+  }),
+  params: z.any()
+});
+var RunResultSchema = z.record(z.string(), z.any());
+function serializeError(value) {
+  if (value instanceof Error) {
+    const err = value;
+    return {
+      error: err.message,
+      name: err.name,
+      code: err.code,
+      stack: err.stack
+    };
+  }
+  if (value && typeof value === "object") {
+    return { error: JSON.stringify(value) };
+  }
+  return { error: String(value) };
+}
+async function run(context) {
+  const { params, ssh } = context;
+  const { taskFn, params: taskParams } = params;
+  const remoteResults = await ssh([], async (remoteContext) => {
+    const hostIdentifier = remoteContext.host?.alias || remoteContext.host?.shortName || "unknown_remote_host";
+    remoteContext.debug(`[${hostIdentifier}] Connected via SSH.`);
+    try {
+      const result = await remoteContext.run(taskFn(taskParams));
+      remoteContext.debug(`[${hostIdentifier}] Remote task result:`, JSON.stringify(result));
+      if (result instanceof Error) {
+        remoteContext.warn?.(
+          `[${hostIdentifier}] Remote task returned an Error instance. Converting to serializable object.`
+        );
+        return serializeError(result);
+      }
+      return result;
+    } catch (e) {
+      remoteContext.debug(`[${hostIdentifier}] Failed to run remote task:`, e.message);
+      return serializeError(e);
+    }
+  });
+  const normalizedEntries = Object.entries(remoteResults ?? {}).map(([hostAlias, value]) => {
+    if (value instanceof Error) {
+      return [hostAlias, serializeError(value)];
+    }
+    return [hostAlias, value];
+  });
+  return Object.fromEntries(normalizedEntries);
+}
+var runAllRemote_default = task(run, {
+  description: "run a task on all selected hosts",
+  inputSchema: RunParamsSchema,
+  outputSchema: RunResultSchema
+});
+
+// src/commands/pkg/package-manager.ts
+import { promises as fs6 } from "fs";
+
 // src/node-runtime.ts
 import os3 from "os";
 import axios2 from "axios";
 import * as cheerio from "cheerio";
-import { match as match3 } from "ts-pattern";
+import { match as match4 } from "ts-pattern";
 import which from "which";
 
 // src/http.ts
@@ -3935,14 +4092,14 @@ async function downloadFile(url, dest) {
 import decompress from "decompress";
 import decompressTarGzPlugin from "decompress-targz";
 import decompressZipPlugin from "decompress-unzip";
-import { match as match2, P as P2 } from "ts-pattern";
+import { match as match3, P as P2 } from "ts-pattern";
 import decompressTarPlugin from "decompress-tar";
 import { fileTypeFromBuffer } from "file-type";
 import { getStreamAsBuffer } from "get-stream";
 import xzdecompress from "xz-decompress";
 async function unarchive(inputPath, outputPath) {
   const filename = File.basename(inputPath);
-  return await match2(filename).with(P2.string.regex(/.tar.xz$/), () => decompressTarXz(inputPath, outputPath)).with(P2.string.regex(/.tar.gz$/), () => decompressTarGz(inputPath, outputPath)).with(P2.string.regex(/.zip$/), () => decompressZip(inputPath, outputPath)).otherwise(() => {
+  return await match3(filename).with(P2.string.regex(/.tar.xz$/), () => decompressTarXz(inputPath, outputPath)).with(P2.string.regex(/.tar.gz$/), () => decompressTarGz(inputPath, outputPath)).with(P2.string.regex(/.zip$/), () => decompressZip(inputPath, outputPath)).otherwise(() => {
     throw new Error(`unable to decompress unknown file type: ${inputPath}`);
   });
 }
@@ -4057,8 +4214,8 @@ var NodeRuntime = class _NodeRuntime {
   }
   // returns the path to the downloaded zip file
   async downloadNodePackage(platform2, arch) {
-    const platformInFilename = match3(platform2).with("linux", () => "linux").with("win32", () => "win").with("darwin", () => "darwin").otherwise(() => "unknown-platform");
-    const archInFilename = match3(arch).with("x64", () => "x64").with("x86", () => "x86").with("arm", () => "armv7l").with("arm64", () => "arm64").otherwise(() => "unknown-arch");
+    const platformInFilename = match4(platform2).with("linux", () => "linux").with("win32", () => "win").with("darwin", () => "darwin").otherwise(() => "unknown-platform");
+    const archInFilename = match4(arch).with("x64", () => "x64").with("x86", () => "x86").with("arm", () => "armv7l").with("arm64", () => "arm64").otherwise(() => "unknown-arch");
     const packages = await this.listPackages();
     const url = A2(packages).find((url2) => url2.match(`node-v.*-${platformInFilename}-${archInFilename}`));
     if (V.isAbsent(url)) {
@@ -4122,162 +4279,7 @@ var NodeRuntime = class _NodeRuntime {
   }
 };
 
-// src/zip.ts
-import AdmZip from "adm-zip";
-
-// src/hash.ts
-import { createHash } from "crypto";
-
-// src/param-map.ts
-import { match as match4 } from "ts-pattern";
-var ParamMap = class _ParamMap {
-  /**
-   * Parses CLI arguments of the form key:value, only supporting top-level keys.
-   * Only the first colon is treated as a key/value separator; all subsequent colons are part of the value.
-   * This means nested keys are not supported, but values can contain colons (e.g., URLs, JSON, etc.).
-   */
-  static parse(cliArguments) {
-    const root = new _ParamMap();
-    A2(cliArguments).each((arg) => {
-      const idx = arg.indexOf(":");
-      if (idx === -1) {
-        root.set([arg], "true");
-        return;
-      }
-      const key = arg.slice(0, idx);
-      const value = arg.slice(idx + 1);
-      root.set([key], value);
-    });
-    return root;
-  }
-  map;
-  constructor() {
-    this.map = /* @__PURE__ */ new Map();
-  }
-  get(keyPath) {
-    const keys3 = keyPath.split(":");
-    let node = this;
-    for (let i = 0; i < keys3.length; i++) {
-      if (!(node instanceof _ParamMap)) return void 0;
-      node = node.map.get(keys3[i]);
-      if (node === void 0) return void 0;
-    }
-    if (node instanceof _ParamMap) {
-      return node.toObject();
-    }
-    return this.stringToJsonObj(node);
-  }
-  set(keyPath, value) {
-    const keyParts = Array.isArray(keyPath) ? keyPath : keyPath.split(":");
-    let node = this;
-    for (let i = 0; i < keyParts.length - 1; i++) {
-      const key = keyParts[i];
-      let nextNode = node.map.get(key);
-      if (!(nextNode instanceof _ParamMap)) {
-        nextNode = new _ParamMap();
-        node.map.set(key, nextNode);
-      }
-      node = nextNode;
-    }
-    const lastKey = keyParts[keyParts.length - 1];
-    node.map.set(lastKey, value);
-  }
-  toObject() {
-    let obj = {};
-    M(this.map).each(([k, v]) => {
-      obj[k] = v instanceof _ParamMap ? v.toObject() : this.stringToJsonObj(v);
-    });
-    return obj;
-  }
-  stringToJsonObj(str) {
-    if (typeof str !== "string") return str;
-    const trimmed = str.trim();
-    if (trimmed.startsWith("{") && trimmed.endsWith("}") || trimmed.startsWith("[") && trimmed.endsWith("]")) {
-      try {
-        return JSON.parse(trimmed);
-      } catch {
-      }
-    }
-    return match4(str).when(matches(/,/), (s) => {
-      return VP(s.split(",")).map((v) => v.trim()).compact([""]).map((v) => this.stringToJsonObj(v)).value;
-    }).when(isNumeric, (s) => parseFloat(s)).when(
-      (s) => s.trim() === "",
-      () => ""
-    ).otherwise(() => str);
-  }
-};
-
-// src/runtime.ts
-import * as z from "zod";
-
-// src/version.ts
-var version = "0.1.45";
-
-// src/app.ts
-import { retryUntilDefined } from "ts-retry";
-import { Mutex as Mutex3 } from "async-mutex";
-import { match as match5 } from "ts-pattern";
-
-// src/core/remote/runAllRemote.ts
-var RunParamsSchema = z.object({
-  taskFn: z.custom((value) => typeof value === "function", {
-    message: "taskFn must be a function"
-  }),
-  params: z.any()
-});
-var RunResultSchema = z.record(z.string(), z.any());
-function serializeError(value) {
-  if (value instanceof Error) {
-    const err = value;
-    return {
-      error: err.message,
-      name: err.name,
-      code: err.code,
-      stack: err.stack
-    };
-  }
-  if (value && typeof value === "object") {
-    return { error: JSON.stringify(value) };
-  }
-  return { error: String(value) };
-}
-async function run(context) {
-  const { params, ssh } = context;
-  const { taskFn, params: taskParams } = params;
-  const remoteResults = await ssh([], async (remoteContext) => {
-    const hostIdentifier = remoteContext.host?.alias || remoteContext.host?.shortName || "unknown_remote_host";
-    remoteContext.debug(`[${hostIdentifier}] Connected via SSH.`);
-    try {
-      const result = await remoteContext.run(taskFn(taskParams));
-      remoteContext.debug(`[${hostIdentifier}] Remote task result:`, JSON.stringify(result));
-      if (result instanceof Error) {
-        remoteContext.warn?.(
-          `[${hostIdentifier}] Remote task returned an Error instance. Converting to serializable object.`
-        );
-        return serializeError(result);
-      }
-      return result;
-    } catch (e) {
-      remoteContext.debug(`[${hostIdentifier}] Failed to run remote task:`, e.message);
-      return serializeError(e);
-    }
-  });
-  const normalizedEntries = Object.entries(remoteResults ?? {}).map(([hostAlias, value]) => {
-    if (value instanceof Error) {
-      return [hostAlias, serializeError(value)];
-    }
-    return [hostAlias, value];
-  });
-  return Object.fromEntries(normalizedEntries);
-}
-var runAllRemote_default = task(run, {
-  description: "run a task on all selected hosts",
-  inputSchema: RunParamsSchema,
-  outputSchema: RunResultSchema
-});
-
 // src/commands/pkg/package-manager.ts
-import { promises as fs6 } from "fs";
 import filenamify from "filenamify";
 var PackageManager = class {
   constructor(app) {
@@ -4628,15 +4630,24 @@ var PackageManager = class {
   }
   async ensurePackagesDirHasPackageJson(packagesDir) {
     const packageJsonPath = packagesDir.join("package.json");
-    if (!await packageJsonPath.exists()) {
-      const packageJson = {
+    const hostctlOverride = process.env.HOSTCTL_PKG_HOSTCTL_OVERRIDE;
+    const overrideValue = hostctlOverride ? hostctlOverride.startsWith("file:") ? hostctlOverride : `file:${Path.new(hostctlOverride).absolute().toString()}` : void 0;
+    let packageJson;
+    if (await packageJsonPath.exists()) {
+      const raw = await fs6.readFile(packageJsonPath.toString(), "utf-8");
+      packageJson = JSON.parse(raw);
+    } else {
+      packageJson = {
         name: "hostctl-packages",
         version: "1.0.0",
         description: "Hostctl package management directory",
         private: true
       };
-      await fs6.writeFile(packageJsonPath.toString(), JSON.stringify(packageJson, null, 2));
     }
+    if (overrideValue) {
+      packageJson.overrides = { ...packageJson.overrides ?? {}, hostctl: overrideValue };
+    }
+    await fs6.writeFile(packageJsonPath.toString(), JSON.stringify(packageJson, null, 2));
   }
   // Scan node_modules for the real installed package (by name or repo match)
   async findRealInstalledNpmPackagePath(packagesDir, source) {
@@ -6014,15 +6025,6 @@ ${successfullyUsedIdentityPaths}`);
       p = p.parent();
     }
   }
-  async printRuntimeReport() {
-    const nodeRuntime = new NodeRuntime(this.tmpDir);
-    const reportObj = {
-      nodePath: await nodeRuntime.nodePath(),
-      npmPath: await nodeRuntime.npmPath()
-      // summary: report?.getReport(),
-    };
-    this.info(reportObj);
-  }
   async promptPasswordInteractively(message = "Enter your password") {
     if (this.providedPassword !== void 0) {
       return this.providedPassword;
@@ -6041,11 +6043,6 @@ ${successfullyUsedIdentityPaths}`);
     this.providedPassword = await promptPassword({ message });
     return this.providedPassword;
   }
-  async installRuntime() {
-    this.info(`creating node runtime with ${this.tmpDir.toString()}`);
-    const nodeRuntime = new NodeRuntime(this.tmpDir);
-    await nodeRuntime.installIfNeeded();
-  }
   /**
    * Executes a command on the selected hosts
    *
@@ -6122,8 +6119,7 @@ var packageJsonTsTemplate = (packageName) => `{
   "author": "",
   "license": "MIT",
   "dependencies": {
-    "hostctl": "^0.1.42",
-    "zod": "^4.1.13"
+    "hostctl": "^0.1.42"
   },
   "devDependencies": {
     "typescript": "^5.8.3",
@@ -6156,8 +6152,7 @@ var packageJsonJsTemplate = (packageName) => `{
   "author": "",
   "license": "MIT",
   "dependencies": {
-    "hostctl": "^0.1.42",
-    "zod": "^4.1.13"
+    "hostctl": "^0.1.42"
   },
   "engines": {
     "node": ">=24"
@@ -6192,157 +6187,21 @@ function registryPrefixFromPackageName(packageName) {
   const normalized = withoutPrefix.replace(/[^a-zA-Z0-9]+/g, ".").replace(/^\.|\.$/g, "");
   return normalized || "example";
 }
-var indexTsTemplate = (registryPrefix) => `import { createRegistry } from './registry.js';
+var indexTsTemplate = (registryPrefix) => `import { createRegistry } from 'hostctl';
 import hello from './tasks/hello.js';
 
 export { hello };
 
 export const registry = createRegistry().register('${registryPrefix}.hello', hello);
 `;
-var indexJsTemplate = (registryPrefix) => `import { createRegistry } from './registry.js';
+var indexJsTemplate = (registryPrefix) => `import { createRegistry } from 'hostctl';
 import hello from './tasks/hello.js';
 
 export { hello };
 
 export const registry = createRegistry().register('${registryPrefix}.hello', hello);
 `;
-var registryTsTemplate = `import type { TaskFn } from 'hostctl';
-
-export type TaskRegistry = {
-  register: (name: string, task: TaskFn) => TaskRegistry;
-  get: (name: string) => TaskFn | undefined;
-  tasks: () => Array<[string, TaskFn]>;
-  has: (name: string) => boolean;
-  names: () => string[];
-  size: () => number;
-};
-
-function isTaskFnLike(candidate: unknown): candidate is TaskFn {
-  return (
-    typeof candidate === 'function' &&
-    !!candidate &&
-    'task' in (candidate as Record<string, unknown>) &&
-    typeof (candidate as { task?: unknown }).task === 'object'
-  );
-}
-
-export function createRegistry(): TaskRegistry {
-  const entries = new Map<string, TaskFn>();
-
-  const registry: TaskRegistry = {
-    register(name: string, task: TaskFn) {
-      if (!name || typeof name !== 'string') {
-        throw new Error('Registry task name must be a non-empty string.');
-      }
-      if (!isTaskFnLike(task)) {
-        throw new Error(\`Registry task '\${name}' must be a TaskFn.\`);
-      }
-      if (entries.has(name)) {
-        throw new Error(\`Registry already has a task named '\${name}'.\`);
-      }
-      if (task.task) {
-        task.task.name = name;
-      }
-      entries.set(name, task);
-      return registry;
-    },
-    get(name: string) {
-      return entries.get(name);
-    },
-    tasks() {
-      return Array.from(entries.entries()).sort(([a], [b]) => a.localeCompare(b));
-    },
-    has(name: string) {
-      return entries.has(name);
-    },
-    names() {
-      return Array.from(entries.keys()).sort((a, b) => a.localeCompare(b));
-    },
-    size() {
-      return entries.size;
-    },
-  };
-
-  return registry;
-}
-`;
-var registryJsTemplate = `export function createRegistry() {
-  const entries = new Map();
-
-  const registry = {
-    register(name, task) {
-      if (!name || typeof name !== 'string') {
-        throw new Error('Registry task name must be a non-empty string.');
-      }
-      if (!task || typeof task !== 'function' || !task.task) {
-        throw new Error(\`Registry task '\${name}' must be a TaskFn.\`);
-      }
-      if (entries.has(name)) {
-        throw new Error(\`Registry already has a task named '\${name}'.\`);
-      }
-      if (task.task) {
-        task.task.name = name;
-      }
-      entries.set(name, task);
-      return registry;
-    },
-    get(name) {
-      return entries.get(name);
-    },
-    tasks() {
-      return Array.from(entries.entries()).sort(([a], [b]) => a.localeCompare(b));
-    },
-    has(name) {
-      return entries.has(name);
-    },
-    names() {
-      return Array.from(entries.keys()).sort((a, b) => a.localeCompare(b));
-    },
-    size() {
-      return entries.size;
-    },
-  };
-
-  return registry;
-}
-`;
-var taskWrapperTsTemplate = `import { task as baseTask, type RunFn, type RunFnReturnValue, type TaskFn, type TaskOptions, type TaskParams } from 'hostctl';
-import type { ZodTypeAny } from 'zod';
-
-export type TaskOptionsWithSchema = TaskOptions & {
-  inputSchema?: ZodTypeAny;
-  outputSchema?: ZodTypeAny;
-};
-
-export function task<TParams extends TaskParams, TReturn extends RunFnReturnValue>(
-  runFn: RunFn<TParams, TReturn>,
-  options?: TaskOptionsWithSchema,
-): TaskFn<TParams, TReturn> {
-  const taskFn = baseTask(runFn, options as TaskOptions);
-  if (options?.inputSchema) {
-    (taskFn.task as any).inputSchema = options.inputSchema;
-  }
-  if (options?.outputSchema) {
-    (taskFn.task as any).outputSchema = options.outputSchema;
-  }
-  return taskFn;
-}
-`;
-var taskWrapperJsTemplate = `import { task as baseTask } from 'hostctl';
-
-export function task(runFn, options) {
-  const taskFn = baseTask(runFn, options);
-  if (options?.inputSchema) {
-    taskFn.task.inputSchema = options.inputSchema;
-  }
-  if (options?.outputSchema) {
-    taskFn.task.outputSchema = options.outputSchema;
-  }
-  return taskFn;
-}
-`;
-var sampleTaskTsTemplate = `import { task, type TaskContext } from '../task.js';
-import { z } from 'zod';
+var sampleTaskTsTemplate = `import { task, type TaskContext, z } from 'hostctl';
 
 const HelloInputSchema = z.object({
   name: z.string().optional(),
@@ -6375,8 +6234,7 @@ export default task(run, {
   outputSchema: HelloOutputSchema,
 });
 `;
-var sampleTaskJsTemplate = `import { task } from '../task.js';
-import { z } from 'zod';
+var sampleTaskJsTemplate = `import { task, z } from 'hostctl';
 
 const HelloInputSchema = z.object({
   name: z.string().optional(),
@@ -6422,7 +6280,7 @@ hostctl run . ${registryPrefix}.hello name:Hostctl excited:true
 - Tasks live under \`src/\` and export a default \`task(...)\`.
 - \`src/index.(ts|js)\` re-exports tasks and publishes a registry for discovery.
 - Task names are unqualified; the registry assigns qualified names.
-- Schema helpers come from \`zod\` and are attached to tasks for discovery.
+- Schema helpers come from \`hostctl\` (re-exported \`zod\`) and are attached to tasks for discovery.
 
 ## Publish
 
@@ -6460,8 +6318,6 @@ async function createPackage(packageName, options) {
     await fs9.writeFile(path5.join(packageDir, "tsconfig.json"), tsconfigTemplate);
     await fs9.mkdir(path5.join(packageDir, "src", "tasks"), { recursive: true });
     await fs9.writeFile(path5.join(packageDir, "src", "index.ts"), indexTsTemplate(registryPrefix));
-    await fs9.writeFile(path5.join(packageDir, "src", "registry.ts"), registryTsTemplate);
-    await fs9.writeFile(path5.join(packageDir, "src", "task.ts"), taskWrapperTsTemplate);
     await fs9.writeFile(path5.join(packageDir, "src", "tasks", "hello.ts"), sampleTaskTsTemplate);
     await fs9.writeFile(path5.join(packageDir, "README.md"), readmeTemplate(packageJsonName, registryPrefix, true));
     await fs9.writeFile(path5.join(packageDir, ".gitignore"), gitignoreTemplate);
@@ -6469,8 +6325,6 @@ async function createPackage(packageName, options) {
     await fs9.writeFile(path5.join(packageDir, "package.json"), packageJsonJsTemplate(packageJsonName));
     await fs9.mkdir(path5.join(packageDir, "src", "tasks"), { recursive: true });
     await fs9.writeFile(path5.join(packageDir, "src", "index.js"), indexJsTemplate(registryPrefix));
-    await fs9.writeFile(path5.join(packageDir, "src", "registry.js"), registryJsTemplate);
-    await fs9.writeFile(path5.join(packageDir, "src", "task.js"), taskWrapperJsTemplate);
     await fs9.writeFile(path5.join(packageDir, "src", "tasks", "hello.js"), sampleTaskJsTemplate);
     await fs9.writeFile(path5.join(packageDir, "README.md"), readmeTemplate(packageJsonName, registryPrefix, false));
     await fs9.writeFile(path5.join(packageDir, ".gitignore"), gitignoreTemplate);
@@ -6913,8 +6767,6 @@ var Cli = class {
       '-p, --params "<json object>"',
       "runtime parameters supplied as a string to be parsed as a json object representing params to supply to the script"
     ).option("-r, --remote", "run the script on remote hosts specified by tags via SSH orchestration").action(this.handleRun.bind(this));
-    const runtimeCmd = this.program.command("runtime").alias("rt").description("print out a report of the runtime environment").action(this.handleRuntime.bind(this));
-    runtimeCmd.command("install").alias("i").description("install a temporary runtime environment on the local host if needed").action(this.handleRuntimeInstall.bind(this));
     this.program.command("tasks").description("list tasks available in a package or path").argument("[package-or-path...]", "npm package spec, installed package name, or local path").option("--task <name>", "filter to a specific task name").option("--json", "output should be json formatted").action(this.handleTasksList.bind(this));
   }
   async handleInventory(options, cmd) {
@@ -7094,16 +6946,6 @@ var Cli = class {
       logError("hostctl error:", e);
     }
   }
-  async handleRuntime(options, cmd) {
-    const opts = cmd.optsWithGlobals();
-    await this.loadApp(opts);
-    await this.app.printRuntimeReport();
-  }
-  async handleRuntimeInstall(options, cmd) {
-    const opts = cmd.optsWithGlobals();
-    await this.loadApp(opts);
-    await this.app.installRuntime();
-  }
   async handlePkgCreate(packageName, options) {
     await createPackage(packageName, options);
   }