hostctl 0.1.36 → 0.1.39

package/dist/bin/hostctl.js

@@ -1096,15 +1096,15 @@ var Equal = class extends Protocol {
 
 // src/flex/path.ts
 var Path = class _Path {
-  constructor(path3, isWindowsPath = isWindows()) {
-    this.path = path3;
+  constructor(path4, isWindowsPath = isWindows()) {
+    this.path = path4;
     this.isWindowsPath = isWindowsPath;
   }
-  static new(path3, isWindowsPath = isWindows()) {
-    if (path3 instanceof _Path) {
-      return path3;
+  static new(path4, isWindowsPath = isWindows()) {
+    if (path4 instanceof _Path) {
+      return path4;
     }
-    return new _Path(path3, isWindowsPath);
+    return new _Path(path4, isWindowsPath);
   }
   static cwd() {
     return _Path.new(process.cwd());
@@ -1144,8 +1144,8 @@ var Path = class _Path {
       return this.build(posix.basename(this.path, suffix));
     }
   }
-  build(path3) {
-    return new _Path(path3, this.isWindowsPath);
+  build(path4) {
+    return new _Path(path4, this.isWindowsPath);
   }
   // returns the path to the destination on success; null otherwise
   async copy(destPath, mode) {
@@ -1193,7 +1193,7 @@ var Path = class _Path {
   }
   glob(pattern) {
     const cwd = this.absolute().toString();
-    return globSync(pattern, { cwd }).map((path3) => this.build(path3));
+    return globSync(pattern, { cwd }).map((path4) => this.build(path4));
   }
   isAbsolute() {
     if (this.isWindowsPath) {
@@ -1232,11 +1232,11 @@ var Path = class _Path {
     }
   }
   parent(count = 1) {
-    let path3 = this.absolute();
+    let path4 = this.absolute();
     Range.new(1, count).each((i) => {
-      path3 = path3.resolve("..");
+      path4 = path4.resolve("..");
     });
-    return path3;
+    return path4;
   }
   // returns an object of the form: { root, dir, base, ext, name }
   //
@@ -1774,8 +1774,8 @@ import process2 from "process";
 import { readFile as readFile2 } from "fs/promises";
 import { existsSync as existsSync2, readFileSync as readFileSync2 } from "fs";
 import { win32 as win322, posix as posix2 } from "path";
-function exists(path3) {
-  return existsSync2(path3);
+function exists(path4) {
+  return existsSync2(path4);
 }
 var File = class {
   static absolutePath(...paths) {
@@ -1787,15 +1787,15 @@ var File = class {
   }
   // basename("c:\\foo\\bar\\baz.txt") => "baz.txt"
   // basename("/tmp/myfile.html") => "myfile.html"
-  static basename(path3, suffix) {
+  static basename(path4, suffix) {
     if (isWindows()) {
-      return win322.basename(path3, suffix);
+      return win322.basename(path4, suffix);
     } else {
-      return posix2.basename(path3, suffix);
+      return posix2.basename(path4, suffix);
     }
   }
-  static exists(path3) {
-    return exists(path3);
+  static exists(path4) {
+    return exists(path4);
   }
   static join(...paths) {
     if (isWindows()) {
@@ -1804,13 +1804,13 @@ var File = class {
       return posix2.join(...paths);
     }
   }
-  static readSync(path3) {
-    return readFileSync2(path3, {
+  static readSync(path4) {
+    return readFileSync2(path4, {
       encoding: "utf8"
     });
   }
-  static async readAsync(path3) {
-    return await readFile2(path3, {
+  static async readAsync(path4) {
+    return await readFile2(path4, {
       encoding: "utf8"
     });
   }
@@ -1820,8 +1820,8 @@ var File = class {
 var TmpFileRegistry = class _TmpFileRegistry {
   static _instance;
   static get instance() {
-    const path3 = File.join(osHomeDir(), ".hostctl", "tmpstatic");
-    this._instance ??= new _TmpFileRegistry(path3);
+    const path4 = File.join(osHomeDir(), ".hostctl", "tmpstatic");
+    this._instance ??= new _TmpFileRegistry(path4);
     return this._instance;
   }
   rootPath;
@@ -1840,33 +1840,33 @@ var TmpFileRegistry = class _TmpFileRegistry {
   }
   // this directory will be automatically cleaned up at program exit
   createNamedTmpDir(subDirName) {
-    const path3 = this.tmpPath(subDirName);
-    fs.mkdirSync(path3.toString(), { recursive: true });
-    this.registerTempFileOrDir(path3.toString());
-    return path3;
+    const path4 = this.tmpPath(subDirName);
+    fs.mkdirSync(path4.toString(), { recursive: true });
+    this.registerTempFileOrDir(path4.toString());
+    return path4;
   }
   // this file will be automatically cleaned up at program exit
   writeTmpFile(fileContent) {
-    const path3 = this.tmpPath();
-    fs.writeFileSync(path3.toString(), fileContent);
-    this.registerTempFileOrDir(path3.toString());
-    return path3;
+    const path4 = this.tmpPath();
+    fs.writeFileSync(path4.toString(), fileContent);
+    this.registerTempFileOrDir(path4.toString());
+    return path4;
   }
   exitCallback() {
     this.cleanupTempFiles();
   }
-  registerTempFileOrDir(path3) {
-    this.tempFilePaths.push(path3);
+  registerTempFileOrDir(path4) {
+    this.tempFilePaths.push(path4);
   }
   cleanupTempFiles() {
-    this.tempFilePaths.forEach((path3) => {
-      this.rmFile(path3);
+    this.tempFilePaths.forEach((path4) => {
+      this.rmFile(path4);
     });
     this.tempFilePaths = [];
   }
-  rmFile(path3) {
+  rmFile(path4) {
     try {
-      fs.rmSync(path3, { force: true, recursive: true });
+      fs.rmSync(path4, { force: true, recursive: true });
     } catch (e) {
     }
   }
@@ -1892,8 +1892,9 @@ var Host = class {
     this.tagSet = new Set(this.tags);
   }
   hostname;
-  // The network hostname or IP address, from the YAML hosts map key
+  // The network hostname or IP address, from the YAML hosts map host field
   alias;
+  // Required alias for the host
   port;
   user;
   password;
@@ -1927,7 +1928,8 @@ var Host = class {
       sshKeyForYaml = this.sshKey.toYAML();
     }
     return {
-      alias: this.alias,
+      host: this.hostname,
+      // Always include the host field
       user: this.user,
       port: this.port === 22 ? void 0 : this.port,
       // Only include port if not default
@@ -1938,13 +1940,13 @@ var Host = class {
   }
   // domain logic
   get shortName() {
-    return this.alias || this.hostname;
+    return this.alias;
   }
   isLocal() {
     return this.hostname === "localhost" || this.hostname === "127.0.0.1";
   }
   get uri() {
-    return this.hostname;
+    return this.port === 22 ? this.hostname : `${this.hostname}:${this.port}`;
   }
   // returns the temporary path to the decrypted ssh key
   async writeTmpDecryptedSshKey() {
@@ -2015,12 +2017,12 @@ import * as age from "age-encryption";
 import spawnAsync from "@expo/spawn-async";
 
 // src/age-encryption.ts
-function readIdentityStringFromFile(path3) {
-  const contents = fs2.readFileSync(path3, {
+function readIdentityStringFromFile(path4) {
+  const contents = fs2.readFileSync(path4, {
     encoding: "utf8"
   });
   const identityString = contents.split(/\r?\n|\r|\n/g).map((line) => line.trim()).find((line) => line.startsWith("AGE-SECRET-KEY-1"));
-  if (!identityString) throw new Error(`Unable to read identity from file: ${path3}`);
+  if (!identityString) throw new Error(`Unable to read identity from file: ${path4}`);
   return identityString;
 }
 var LibraryDriver = class {
@@ -2036,13 +2038,13 @@ var LibraryDriver = class {
     }
     const d = new age.Decrypter();
     let identitiesAdded = 0;
-    for (const path3 of privateKeyFilePaths) {
+    for (const path4 of privateKeyFilePaths) {
       try {
-        const identityString = readIdentityStringFromFile(path3);
+        const identityString = readIdentityStringFromFile(path4);
         d.addIdentity(identityString);
         identitiesAdded++;
       } catch (err) {
-        console.warn(`Failed to read or parse identity file ${path3}, skipping: ${err.message}`);
+        console.warn(`Failed to read or parse identity file ${path4}, skipping: ${err.message}`);
       }
     }
     if (identitiesAdded === 0) {
@@ -2061,13 +2063,13 @@ var Identity = class {
   identityFilePath;
   identity;
   // either the path to an identity file or an identity string must be supplied
-  constructor({ path: path3, identity: identity2 }) {
+  constructor({ path: path4, identity: identity2 }) {
     if (identity2) {
       this.identity = identity2;
       this.identityFilePath = this.writeTmpIdentityFile(identity2);
-    } else if (path3) {
-      this.identity = this.readIdentityFromFile(path3);
-      this.identityFilePath = path3;
+    } else if (path4) {
+      this.identity = this.readIdentityFromFile(path4);
+      this.identityFilePath = path4;
     } else {
       throw "Either an identity string or an identity file path must be supplied to create an Age Encryption identity";
     }
@@ -2079,12 +2081,12 @@ var Identity = class {
   writeTmpIdentityFile(identity2) {
     return writeTmpFile(identity2).toString();
   }
-  readIdentityFromFile(path3) {
-    const contents = fs2.readFileSync(path3, {
+  readIdentityFromFile(path4) {
+    const contents = fs2.readFileSync(path4, {
       encoding: "utf8"
     });
     const identityString = contents.split(/\r?\n|\r|\n/g).map((line) => line.trim()).find((line) => line.startsWith("AGE-SECRET-KEY-1"));
-    if (!identityString) throw new Error(`Unable to read identity file: ${path3}`);
+    if (!identityString) throw new Error(`Unable to read identity file: ${path4}`);
     return identityString;
   }
   get privateKey() {
@@ -2234,8 +2236,8 @@ var SecretRefYamlType = new yaml.Type("!secret", {
 });
 var HOSTCTL_CONFIG_SCHEMA = yaml.DEFAULT_SCHEMA.extend([SecretRefYamlType]);
 var ConfigFile2 = class {
-  constructor(path3) {
-    this.path = path3;
+  constructor(path4) {
+    this.path = path4;
     this._hosts = /* @__PURE__ */ new Map();
     this._ids = /* @__PURE__ */ new Map();
     this._secrets = /* @__PURE__ */ new Map();
@@ -2276,19 +2278,25 @@ var ConfigFile2 = class {
   }
   // yamlHosts is an object
   parseHosts(yamlHosts) {
-    const hosts = Object.entries(yamlHosts).reduce((hostMap, [hostUri, hostObj]) => {
+    const hosts = Object.entries(yamlHosts).reduce((hostMap, [alias, hostObj]) => {
       hostObj ||= {};
       const password = this.parseSecretValue(hostObj.password);
       const sshKey = this.parseSecretValue(hostObj["ssh-key"]);
+      const hostname = hostObj.host || alias;
       hostMap.set(
-        hostUri,
+        alias,
+        // Use the key as the alias
         new Host(this, {
-          ...hostObj,
-          // Use 'as any' to allow spread of hostObj properties
-          hostname: hostUri,
-          // The YAML map key is always the hostname
+          hostname,
+          // Use the resolved hostname
+          alias,
+          // The key becomes the alias
+          port: hostObj.port,
+          // SSH port (defaults to 22 in Host constructor)
+          user: hostObj.user,
           password,
-          sshKey
+          sshKey,
+          tags: hostObj.tags
         })
       );
       return hostMap;
@@ -2367,7 +2375,7 @@ var ConfigFile2 = class {
     const ageIds = process.env.AGE_IDS;
     if (ageIds) {
       const paths = globSync2(ageIds);
-      const ids = paths.map((path3) => new Identity({ path: path3 }));
+      const ids = paths.map((path4) => new Identity({ path: path4 }));
       return ids;
     }
     return [];
@@ -2569,6 +2577,9 @@ import { Mutex as Mutex2 } from "async-mutex";
 // src/command.ts
 import "shell-quote";
 import Shellwords from "shellwords-ts";
+function processEnvVars() {
+  return O(process.env).map(([key, value]) => [key, String(value)]);
+}
 var CommandResult = class {
   constructor(stdout, stderr, exitCode, signal) {
     this.stdout = stdout;
@@ -2870,20 +2881,20 @@ var LocalInvocation = class _LocalInvocation extends Invocation {
     )(params);
     this.config = this.runtime.app.config;
     this.file = {
-      read: async (path3) => fs5.promises.readFile(path3, "utf-8"),
-      write: async (path3, content, options) => fs5.promises.writeFile(path3, content, { mode: options?.mode }),
-      exists: async (path3) => {
+      read: async (path4) => fs5.promises.readFile(path4, "utf-8"),
+      write: async (path4, content, options) => fs5.promises.writeFile(path4, content, { mode: options?.mode }),
+      exists: async (path4) => {
         try {
-          await fs5.promises.access(path3);
+          await fs5.promises.access(path4);
           return true;
         } catch {
           return false;
         }
       },
-      mkdir: async (path3, options) => {
-        await fs5.promises.mkdir(path3, options);
+      mkdir: async (path4, options) => {
+        await fs5.promises.mkdir(path4, options);
       },
-      rm: async (path3, options) => fs5.promises.rm(path3, options)
+      rm: async (path4, options) => fs5.promises.rm(path4, options)
     };
   }
   config;
@@ -2942,7 +2953,7 @@ var LocalInvocation = class _LocalInvocation extends Invocation {
     }
     const entryPromises = VP(targetHosts).map(async (host) => {
       const result = await this.runRemoteTaskOnHost(host, remoteTaskFn);
-      return [host.hostname, result];
+      return [host.alias, result];
     }).value;
     const entries = await Promise.all(entryPromises);
     const record = Object.fromEntries(entries);
@@ -3048,7 +3059,7 @@ var LocalRuntime = class {
     this.interactionHandler = interactionHandler;
     const appConfigInstance = this.app.config;
     if (appConfigInstance instanceof ConfigFile2) {
-      this.host = new Host(appConfigInstance, { hostname: "localhost" });
+      this.host = new Host(appConfigInstance, { hostname: "localhost", alias: "localhost" });
     } else {
       const configType = appConfigInstance?.constructor?.name || typeof appConfigInstance;
       this.app.error(
@@ -3609,38 +3620,6 @@ async function downloadFile(url, dest) {
   });
 }
 
-// src/shell-command.ts
-import spawnAsync2 from "@expo/spawn-async";
-import { signalsByName as signalsByName2 } from "human-signals";
-var ShellCommand = class _ShellCommand extends Command {
-  static fromString(command, env, cwd) {
-    const { cmd, args } = this.parse(command, env);
-    return new _ShellCommand({ cmd, args, cwd, env });
-  }
-  async run() {
-    try {
-      const resultPromise = spawnAsync2(this.cmd, this.args, {
-        cwd: this.cwd,
-        env: this.env
-        // shell: true
-      });
-      let { pid, stdout, stderr, status, signal } = await resultPromise;
-      const signalObj = signal && signalsByName2[signal] || void 0;
-      const commandResult = new CommandResult(stdout || "", stderr || "", status || 0, signalObj);
-      this.result = commandResult;
-    } catch (e) {
-      const error = e;
-      if (error.message) console.error(error.message);
-      if (error.stack) console.error(error.stack);
-      let { pid, stdout, stderr, status, signal } = error;
-      const signalObj = signal && signalsByName2[signal] || void 0;
-      const commandResult = new CommandResult(stdout || "", stderr || "", status || 1, signalObj);
-      this.result = commandResult;
-    }
-    return this.result;
-  }
-};
-
 // src/unarchive.ts
 import decompress from "decompress";
 import decompressTarGzPlugin from "decompress-targz";
@@ -3703,19 +3682,19 @@ var NodeRuntime = class _NodeRuntime {
   localNode;
   localNpm;
   async isNodeInstalledGlobally() {
-    const result = await ShellCommand.fromString(`node --version`).run();
+    const result = await RusPtyCommand.fromString(`node --version`, processEnvVars()).run();
     return result.success;
   }
   async isNodeInstalledLocally() {
-    const result = await ShellCommand.fromString(`${this.localNode} --version`).run();
+    const result = await RusPtyCommand.fromString(`${this.localNode} --version`, processEnvVars()).run();
     return result.success;
   }
   async isNpmInstalledGlobally() {
-    const result = await ShellCommand.fromString(`npm --version`).run();
+    const result = await RusPtyCommand.fromString(`npm --version`, processEnvVars()).run();
     return result.success;
   }
   async isNpmInstalledLocally() {
-    const result = await ShellCommand.fromString(`${this.localNpm} --version`).run();
+    const result = await RusPtyCommand.fromString(`${this.localNpm} --version`, processEnvVars()).run();
     return result.success;
   }
   async nodeCmd() {
@@ -3775,9 +3754,9 @@ var NodeRuntime = class _NodeRuntime {
       throw new Error(`Unable to download node for ${os2}/${arch} OS/architecture`);
     }
     const filename = File.basename(url);
-    const path3 = this.tmpDir.join(filename);
-    if (path3.exists()) return path3.toString();
-    return await downloadFile(url, path3.toString());
+    const path4 = this.tmpDir.join(filename);
+    if (path4.exists()) return path4.toString();
+    return await downloadFile(url, path4.toString());
   }
   // returns the path to the unzipped package directory
   async unzipPackage(packagePath) {
@@ -3786,33 +3765,29 @@ var NodeRuntime = class _NodeRuntime {
     await unarchive(packagePath, dir.toString());
     return dir.toString();
   }
-  async npmInstall(omitDev = true, cwd) {
+  async npmInstall(options = {}) {
+    const { omitDev = true, cwd, installedPackagesDir } = options;
+    const args = ["install"];
     if (omitDev) {
-      return this.npm("install --omit=dev", cwd);
-    } else {
-      return this.npm("install", cwd);
+      args.push("--omit=dev");
+    }
+    if (installedPackagesDir) {
+      args.push("--prefix", installedPackagesDir);
     }
+    return this.npm(args.join(" "), cwd);
   }
   async npm(npmArgs, cwd) {
     const npmCmd = await this.npmCmd();
-    const env = O(process.env).select(([_, v]) => !!v);
-    return ShellCommand.fromString(`${npmCmd} ${npmArgs}`.trim(), env, cwd).run();
+    return RusPtyCommand.fromString(`${npmCmd} ${npmArgs}`.trim(), processEnvVars(), cwd).run();
   }
   async node(nodeArgs, cwd) {
     const nodeCmd = await this.nodeCmd();
-    const env = O(process.env).select(([_, v]) => !!v);
-    return ShellCommand.fromString(`${nodeCmd} ${nodeArgs}`.trim(), env, cwd).run();
+    return RusPtyCommand.fromString(`${nodeCmd} ${nodeArgs}`.trim(), processEnvVars(), cwd).run();
   }
 };
 
 // src/zip.ts
 import AdmZip from "adm-zip";
-async function zipDirectory(sourceDir, outputFilePath) {
-  const zip2 = new AdmZip();
-  zip2.addLocalFolder(sourceDir);
-  await zip2.writeZipPromise(outputFilePath);
-  return outputFilePath;
-}
 async function unzipDirectory(inputFilePath, outputDirectory) {
   const zip2 = new AdmZip(inputFilePath);
   return new Promise((resolve, reject) => {
@@ -3828,9 +3803,6 @@ async function unzipDirectory(inputFilePath, outputDirectory) {
 
 // src/hash.ts
 import { createHash } from "crypto";
-function sha256(str) {
-  return createHash("sha256").update(str).digest("hex");
-}
 
 // src/param-map.ts
 import { match as match4 } from "ts-pattern";
@@ -3892,7 +3864,7 @@ var ParamMap = class _ParamMap {
 };
 
 // src/version.ts
-var version = "0.1.36";
+var version = "0.1.39";
 
 // src/app.ts
 import { retryUntilDefined } from "ts-retry";
@@ -3953,7 +3925,7 @@ var TaskTree = class {
       this.nodes.set(id, newNode);
       this.listr.add({
         title: newNode.name,
-        task: async (ctx, task3) => {
+        task: async (ctx, task2) => {
           await result;
         }
       });
@@ -4060,6 +4032,13 @@ var App = class {
   hostctlTmpDir() {
     return this.hostctlDir().join("tmp");
   }
+  packagesDir() {
+    const envPkgDir = process3.env.HOSTCTL_PKG_DIR;
+    if (envPkgDir) {
+      return Path.new(envPkgDir);
+    }
+    return this.hostctlDir().join("packages");
+  }
   randName() {
     return Math.random().toString(36).slice(-5) + Math.random().toString(36).slice(-5);
   }
@@ -4150,7 +4129,8 @@ ${cmdRes.stderr.trim()}`));
     try {
       const hostPassword = await host.decryptedPassword();
       const sshConnection = {
-        host: host.uri,
+        host: host.hostname,
+        port: host.port,
         username: host.user,
         password: hostPassword,
         privateKeyPath: await host.plaintextSshKeyPath()
@@ -4582,48 +4562,10 @@ ${successfullyUsedIdentityPaths}`);
   parseParams(scriptArgs) {
     return ParamMap.parse(scriptArgs).toObject();
   }
-  // this function creates a bundle of a given directory
-  async bundleProject(entrypointPath) {
-    const nodeRuntime = new NodeRuntime(this.tmpDir);
-    const entrypointDir = this.pathOfPackageJsonFile(entrypointPath);
-    if (!entrypointDir) {
-      console.error(
-        chalk4.red(`Bundle failure. "${entrypointPath}" nor any ancestor directory contains a package.json file.`)
-      );
-      return;
-    }
-    const tasks = new Listr([], {
-      exitOnError: false,
-      concurrent: true
-    });
-    tasks.add([
-      {
-        title: `Bundling ${entrypointDir.toString()}`,
-        task: async (ctx) => {
-          await this.generateBundle(nodeRuntime, entrypointDir);
-        }
-      }
-    ]);
-    try {
-      await tasks.run();
-    } catch (e) {
-      console.error(e);
-    }
-  }
-  async generateBundle(nodeRuntime, packageFileDir) {
-    await nodeRuntime.installIfNeeded();
-    const result = await nodeRuntime.npmInstall(true, packageFileDir.toString());
-    if (result.failure) throw new Error(result.err);
-    const absoluteDirPath = packageFileDir.toString();
-    const dirNameHash = sha256(absoluteDirPath).slice(0, 10);
-    const bundleZipFile = this.tmpDir.join(`bundle${dirNameHash}.zip`);
-    const zipPath = await zipDirectory(packageFileDir.toString(), bundleZipFile.toString());
-    return Path.new(zipPath);
-  }
   // walks the directory tree that contains the given path from leaf to root searching for the deepest directory
   // containing a package.json file and returns the absolute path of that directory
-  pathOfPackageJsonFile(path3) {
-    let p = Path.new(path3);
+  pathOfPackageJsonFile(path4) {
+    let p = Path.new(path4);
     while (true) {
       if (p.dirContains("package.json")) {
         return p.absolute();
@@ -4655,73 +4597,805 @@ ${successfullyUsedIdentityPaths}`);
   }
 };
 
+// src/commands/pkg/create.ts
+import { promises as fs7 } from "fs";
+import path3 from "path";
+var packageJsonTsTemplate = (packageName) => `{
+  "name": "${packageName}",
+  "version": "1.0.0",
+  "description": "A hostctl task",
+  "main": "index.ts",
+  "scripts": {
+    "build": "tsc"
+  },
+  "keywords": ["hostctl-task"],
+  "author": "",
+  "license": "ISC",
+  "dependencies": {
+    "hostctl": "latest"
+  },
+  "devDependencies": {
+    "typescript": "^5.0.0",
+    "@types/node": "latest"
+  }
+}
+`;
+var packageJsonJsTemplate = (packageName) => `{
+  "name": "${packageName}",
+  "version": "1.0.0",
+  "description": "A hostctl task",
+  "type": "module",
+  "main": "index.js",
+  "scripts": {},
+  "keywords": ["hostctl-task"],
+  "author": "",
+  "license": "ISC",
+  "dependencies": {
+    "hostctl": "latest"
+  }
+}
+`;
+var tsconfigTemplate = `{
+  "compilerOptions": {
+    "target": "es2020",
+    "module": "commonjs",
+    "strict": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "forceConsistentCasingInFileNames": true,
+    "outDir": "./dist"
+  },
+  "include": ["*.ts"],
+  "exclude": ["node_modules", "dist"]
+}
+`;
+var indexTsTemplate = (packageName) => {
+  const sanitizedName = packageName.replace(/[^a-zA-Z0-9]/g, "").replace(/^[0-9]/, "_$&");
+  const interfaceName = sanitizedName.charAt(0).toUpperCase() + sanitizedName.slice(1);
+  return `import { task, type TaskContext } from 'hostctl';
+
+export interface ${interfaceName}Params {
+  // Define your parameters here
+  message?: string;
+}
+
+export interface ${interfaceName}Result {
+  success: boolean;
+  message: string;
+}
+
+async function run(context: TaskContext<${interfaceName}Params>): Promise<${interfaceName}Result> {
+  const { params, log } = context;
+
+  const message = params.message || 'Hello from your new hostctl task!';
+  log('info', message);
+
+  return {
+    success: true,
+    message: message
+  };
+}
+
+export default task(run, 'A sample hostctl task');
+`;
+};
+var indexJsTemplate = `import { task } from 'hostctl';
+
+async function run(context) {
+  const { params, log } = context;
+
+  const message = params.message || 'Hello from your new hostctl task!';
+  log('info', message);
+
+  return {
+    success: true,
+    message: message
+  };
+}
+
+export default task(run, 'A sample hostctl task');
+`;
+var sampleTaskTsTemplate = (packageName) => {
+  const sanitizedName = packageName.replace(/[^a-zA-Z0-9]/g, "").replace(/^[0-9]/, "_$&");
+  const taskName = sanitizedName.charAt(0).toUpperCase() + sanitizedName.slice(1);
+  return `import { task, type TaskContext } from 'hostctl';
+
+export interface ${taskName}SampleParams {
+  name: string;
+  greeting?: string;
+}
+
+export interface ${taskName}SampleResult {
+  success: boolean;
+  greeting: string;
+}
+
+async function run(context: TaskContext<${taskName}SampleParams>): Promise<${taskName}SampleResult> {
+  const { params, log } = context;
+
+  const greeting = params.greeting || 'Hello';
+  const message = \`\${greeting}, \${params.name}!\`;
+
+  log('info', message);
+
+  return {
+    success: true,
+    greeting: message
+  };
+}
+
+export default task(run, 'Greets {{name}} with {{greeting}}');
+`;
+};
+var sampleTaskJsTemplate = `import { task } from 'hostctl';
+
+async function run(context) {
+  const { params, log } = context;
+
+  const greeting = params.greeting || 'Hello';
+  const message = \`\${greeting}, \${params.name}!\`;
+
+  log('info', message);
+
+  return {
+    success: true,
+    greeting: message
+  };
+}
+
+export default task(run, 'Greets {{name}} with {{greeting}}');
+`;
+var readmeTemplate = (packageName) => `# ${packageName}
+
+This is a hostctl task package.
+
+## Usage
+
+### Run without installing
+
+\`\`\`
+\u276F npx hostctl run https://github.com/yourusername/${packageName} message:Hello
+\`\`\`
+
+### Explicitly install and run
+
+\`\`\`
+\u276F npx hostctl install https://github.com/yourusername/${packageName}
+\u276F npx hostctl run ${packageName} message:Hello
+\`\`\`
+
+## About
+
+This is a hostctl task package that demonstrates the basic structure for creating reusable tasks.
+`;
+var gitignoreTemplate = `node_modules/
+dist/
+*.log
+.DS_Store
+.env
+`;
+async function createPackage(packageName, options) {
+  const packageDir = path3.join(process.cwd(), packageName);
+  await fs7.mkdir(packageDir, { recursive: true });
+  if (options.lang === "typescript") {
+    await fs7.writeFile(path3.join(packageDir, "package.json"), packageJsonTsTemplate(packageName));
+    await fs7.writeFile(path3.join(packageDir, "tsconfig.json"), tsconfigTemplate);
+    await fs7.writeFile(path3.join(packageDir, "index.ts"), indexTsTemplate(packageName));
+    await fs7.writeFile(path3.join(packageDir, "sample-task.ts"), sampleTaskTsTemplate(packageName));
+    await fs7.writeFile(path3.join(packageDir, "README.md"), readmeTemplate(packageName));
+    await fs7.writeFile(path3.join(packageDir, ".gitignore"), gitignoreTemplate);
+  } else {
+    await fs7.writeFile(path3.join(packageDir, "package.json"), packageJsonJsTemplate(packageName));
+    await fs7.writeFile(path3.join(packageDir, "index.js"), indexJsTemplate);
+    await fs7.writeFile(path3.join(packageDir, "sample-task.js"), sampleTaskJsTemplate);
+    await fs7.writeFile(path3.join(packageDir, "README.md"), readmeTemplate(packageName));
+    await fs7.writeFile(path3.join(packageDir, ".gitignore"), gitignoreTemplate);
+  }
+  console.log(`Created new hostctl package '${packageName}' at ${packageDir}`);
+  console.log(`
+Next steps:`);
+  console.log(`1. cd ${packageName}`);
+  console.log(`2. npm install`);
+  if (options.lang === "typescript") {
+    console.log(`3. Edit index.ts and sample-task.ts to implement your tasks`);
+  } else {
+    console.log(`3. Edit index.js and sample-task.js to implement your tasks`);
+  }
+  console.log(`4. Test your package with: npx hostctl run .`);
+}
+
+// src/commands/pkg/package-manager.ts
+import { promises as fs8 } from "fs";
+import { simpleGit } from "simple-git";
+import filenamify from "filenamify";
+var PackageManager = class {
+  constructor(app) {
+    this.app = app;
+    this.manifestPath = this.app.packagesDir().join("manifest.json");
+    this.manifest = { packages: {}, version: "1.0" };
+  }
+  manifestPath;
+  manifest;
+  async loadManifest() {
+    try {
+      if (await this.manifestPath.exists()) {
+        const content = await fs8.readFile(this.manifestPath.toString(), "utf-8");
+        this.manifest = JSON.parse(content);
+      }
+    } catch (error) {
+      this.manifest = { packages: {}, version: "1.0" };
+    }
+  }
+  async saveManifest() {
+    await fs8.writeFile(this.manifestPath.toString(), JSON.stringify(this.manifest, null, 2));
+  }
+  // Normalize partial git URLs to full https URLs
+  normalizeGitUrl(source) {
+    if ((source.includes("github.com") || source.includes("gitlab.com") || source.includes("bitbucket.org")) && source.startsWith("http://") && !source.startsWith("git@") && !source.startsWith("git+ssh://") && !source.startsWith("git+https://")) {
+      return source.replace("http://", "https://");
+    }
+    if ((source.includes("github.com") || source.includes("gitlab.com") || source.includes("bitbucket.org")) && !/^\w+:\/\//.test(source) && !source.startsWith("git@") && !source.startsWith("git+ssh://") && !source.startsWith("git+https://")) {
+      return "https://" + source;
+    }
+    return source;
+  }
+  detectSourceType(source) {
+    const normalized = this.normalizeGitUrl(source);
+    if (normalized.startsWith("git@") || normalized.startsWith("http://") || normalized.startsWith("https://") || normalized.startsWith("git+ssh://") || normalized.startsWith("git+https://") || normalized.includes("github.com") || normalized.includes("gitlab.com") || normalized.includes("bitbucket.org")) {
+      return "git";
+    }
+    if (source.startsWith(".") || source.startsWith("/")) {
+      return "local";
+    }
+    return "npm";
+  }
+  async listPackages() {
+    await this.loadManifest();
+    return Object.values(this.manifest.packages);
+  }
+  async discoverTasks(packagePath) {
+    const tasks = [];
+    try {
+      const entries = await fs8.readdir(packagePath.toString(), { withFileTypes: true });
+      for (const entry of entries) {
+        if (entry.isFile() && (entry.name.endsWith(".ts") || entry.name.endsWith(".js"))) {
+          if (entry.name === "index.ts" || entry.name === "index.js") {
+            continue;
+          }
+          const taskPath = packagePath.join(entry.name);
+          const taskName = entry.name.replace(/\.(ts|js)$/, "");
+          tasks.push({
+            name: taskName,
+            path: taskPath.toString()
+          });
+        }
+      }
+      const subdirs = ["tasks", "src"];
+      for (const subdir of subdirs) {
+        const subdirPath = packagePath.join(subdir);
+        if (await subdirPath.exists()) {
+          const subEntries = await fs8.readdir(subdirPath.toString(), { withFileTypes: true });
+          for (const entry of subEntries) {
+            if (entry.isFile() && (entry.name.endsWith(".ts") || entry.name.endsWith(".js"))) {
+              const taskPath = subdirPath.join(entry.name);
+              const taskName = entry.name.replace(/\.(ts|js)$/, "");
+              tasks.push({
+                name: taskName,
+                path: taskPath.toString()
+              });
+            }
+          }
+        }
+      }
+    } catch (error) {
+    }
+    return tasks.sort((a, b) => a.name.localeCompare(b.name));
+  }
+  /**
+   * Enhanced task resolution that supports dotted notation and npm packages
+   */
+  async resolveTaskPath(packageOrTask, taskName) {
+    await this.loadManifest();
+    const normalizedPackageOrTask = this.normalizeGitUrl(packageOrTask);
+    let packageInfo = this.manifest.packages[packageOrTask] || this.manifest.packages[normalizedPackageOrTask];
+    if (!packageInfo) {
+      const packagesWithName = Object.values(this.manifest.packages).filter(
+        (pkg) => pkg.name === packageOrTask || pkg.name === normalizedPackageOrTask
+      );
+      if (packagesWithName.length === 1) {
+        packageInfo = packagesWithName[0];
+      } else if (packagesWithName.length > 1) {
+        throw new Error(
+          `Multiple packages found with name '${packageOrTask}'. Please use the full source URL to specify which package to run:
+` + packagesWithName.map((pkg) => `  - ${pkg.source}`).join("\n")
+        );
+      }
+    }
+    if (packageInfo) {
+      const packagePath = this.app.packagesDir().join(packageInfo.directory);
+      if (taskName) {
+        const taskPath = await this.resolveDottedTask(packagePath, taskName);
+        if (taskPath) {
+          return { packagePath: packagePath.toString(), taskPath };
+        }
+      } else {
+        const defaultTask = await this.findDefaultTask(packagePath);
+        if (defaultTask) {
+          return { packagePath: packagePath.toString(), taskPath: defaultTask };
+        }
+      }
+    }
+    const sourceType = this.detectSourceType(packageOrTask);
+    if (sourceType === "git" || sourceType === "npm") {
+      const packageInfo2 = this.manifest.packages[packageOrTask] || this.manifest.packages[normalizedPackageOrTask];
+      if (packageInfo2) {
+        const packagePath = this.app.packagesDir().join(packageInfo2.directory);
+        if (taskName) {
+          const taskPath = await this.resolveDottedTask(packagePath, taskName);
+          if (taskPath) {
+            return { packagePath: packagePath.toString(), taskPath };
+          }
+        } else {
+          const defaultTask = await this.findDefaultTask(packagePath);
+          if (defaultTask) {
+            return { packagePath: packagePath.toString(), taskPath: defaultTask };
+          }
+        }
+      }
+    }
+    return null;
+  }
+  /**
+   * Resolve a dotted task notation to a file path
+   * e.g., "os.harden.debian" -> "os/harden/debian.ts" or "os/harden/debian.js"
+   */
+  async resolveDottedTask(packagePath, dottedTask) {
+    const taskParts = dottedTask.split(".");
+    const taskFileName = taskParts.pop();
+    const taskDir = taskParts.length > 0 ? taskParts.join("/") : "";
+    const tsPath = taskDir ? packagePath.join(taskDir, `${taskFileName}.ts`) : packagePath.join(`${taskFileName}.ts`);
+    const jsPath = taskDir ? packagePath.join(taskDir, `${taskFileName}.js`) : packagePath.join(`${taskFileName}.js`);
+    if (await tsPath.exists()) {
+      return tsPath.toString();
+    }
+    if (await jsPath.exists()) {
+      return jsPath.toString();
+    }
+    return null;
+  }
+  /**
+   * Check if a package is installed (by name, source, or directory)
+   */
+  async isPackageInstalled(identifier) {
+    await this.loadManifest();
+    const normalizedIdentifier = this.normalizeGitUrl(identifier);
+    return Object.values(this.manifest.packages).some(
+      (pkg) => pkg.name === identifier || pkg.name === normalizedIdentifier || pkg.source === identifier || pkg.source === normalizedIdentifier || pkg.directory === identifier || pkg.directory === normalizedIdentifier
+    );
+  }
+  /**
+   * Get package info by any identifier (name, source, or directory)
+   */
+  async getPackageByIdentifier(identifier) {
+    await this.loadManifest();
+    const normalizedIdentifier = this.normalizeGitUrl(identifier);
+    return Object.values(this.manifest.packages).find(
+      (pkg) => pkg.name === identifier || pkg.name === normalizedIdentifier || pkg.source === identifier || pkg.source === normalizedIdentifier || pkg.directory === identifier || pkg.directory === normalizedIdentifier
+    ) || null;
+  }
+  async findDefaultTask(packagePath) {
+    const defaultFiles = ["index.ts", "index.js", "main.ts", "main.js"];
+    for (const file of defaultFiles) {
+      const filePath = packagePath.join(file);
+      if (await filePath.exists()) {
+        return filePath.toString();
+      }
+    }
+    return null;
+  }
+  async removePackage(packageIdentifier) {
+    try {
+      await this.loadManifest();
+      const normalizedIdentifier = this.normalizeGitUrl(packageIdentifier);
+      const packageToRemove = Object.values(this.manifest.packages).find(
+        (pkg) => pkg.name === packageIdentifier || pkg.name === normalizedIdentifier || pkg.source === packageIdentifier || pkg.source === normalizedIdentifier || pkg.directory === packageIdentifier || pkg.directory === normalizedIdentifier
+      );
+      if (!packageToRemove) {
+        return {
+          success: false,
+          error: `Package '${packageIdentifier}' not found. Use 'hostctl pkg list' to see installed packages.`
+        };
+      }
+      const packagePath = this.app.packagesDir().join(packageToRemove.directory);
+      await fs8.rm(packagePath.toString(), { recursive: true });
+      delete this.manifest.packages[packageToRemove.source];
+      await this.saveManifest();
+      return {
+        success: true,
+        packageInfo: packageToRemove
+      };
+    } catch (error) {
+      return {
+        success: false,
+        error: error instanceof Error ? error.message : String(error)
+      };
+    }
+  }
+  /**
+   * Check if a package name already exists in the manifest
+   */
+  hasPackageWithName(packageName) {
+    return Object.values(this.manifest.packages).some((pkg) => pkg.name === packageName);
+  }
+  /**
+   * Get all packages with the same name
+   */
+  getPackagesWithName(packageName) {
+    return Object.values(this.manifest.packages).filter((pkg) => pkg.name === packageName);
+  }
+  async installPackage(source) {
+    try {
+      await this.loadManifest();
+      const normalizedSource = this.normalizeGitUrl(source);
+      const type = this.detectSourceType(source);
+      const packagesDir = this.app.packagesDir();
+      await fs8.mkdir(packagesDir.toString(), { recursive: true });
+      const packageName = filenamify(normalizedSource, { replacement: "_" });
+      const installDir = packagesDir.join(packageName);
+      const existingPackage = this.manifest.packages[normalizedSource];
+      if (existingPackage) {
+        console.log(`Package '${existingPackage.name}' is already installed from ${normalizedSource}`);
+        return {
+          success: true,
+          packageInfo: existingPackage,
+          installPath: this.app.packagesDir().join(existingPackage.directory).toString()
+        };
+      }
+      switch (type) {
+        case "local": {
+          const sourcePath = Path.new(source);
+          if (!await sourcePath.exists()) {
+            return {
+              success: false,
+              error: `Local path not found: ${source}`,
+              packageInfo: { name: packageName, directory: packageName },
+              installPath: installDir.toString()
+            };
+          }
+          await sourcePath.copy(installDir.toString());
+          break;
+        }
+        case "git": {
+          const git = simpleGit();
+          if (await installDir.exists()) {
+            await fs8.rm(installDir.toString(), { recursive: true, force: true });
+          }
+          await git.clone(normalizedSource, installDir.toString());
+          const nodeRuntime = new NodeRuntime(this.app.tmpDir);
+          await nodeRuntime.npmInstall({ cwd: installDir.toString() });
+          break;
+        }
+        case "npm": {
+          const nodeRuntime = new NodeRuntime(this.app.tmpDir);
+          await nodeRuntime.npm(`install ${source}`, packagesDir.toString());
+          break;
+        }
+      }
+      const packageInfo = await this.getPackageInfo(installDir);
+      const tasks = await this.discoverTasks(installDir);
+      const finalPackageInfo = {
+        ...packageInfo || { name: packageName, directory: packageName },
+        source: normalizedSource,
+        tasks
+      };
+      const actualPackageName = finalPackageInfo.name;
+      if (this.hasPackageWithName(actualPackageName)) {
+        const existingPackages = this.getPackagesWithName(actualPackageName);
+        console.warn(`\u26A0\uFE0F  Warning: Package name '${actualPackageName}' already exists.`);
+        console.warn(`   Existing packages:`);
+        existingPackages.forEach((pkg) => {
+          console.warn(`   - ${pkg.source} (${pkg.directory})`);
+        });
+        console.warn(`   You will need to use the full source URL to run tasks from this package.`);
+      }
+      this.manifest.packages[normalizedSource] = finalPackageInfo;
+      await this.saveManifest();
+      return {
+        success: true,
+        packageInfo: finalPackageInfo,
+        installPath: installDir.toString()
+      };
+    } catch (error) {
+      const normalizedSource = this.normalizeGitUrl(source);
+      const packageName = filenamify(normalizedSource, { replacement: "_" });
+      return {
+        success: false,
+        error: error instanceof Error ? error.message : String(error),
+        packageInfo: { name: packageName, directory: packageName },
+        installPath: this.app.packagesDir().join(packageName).toString()
+      };
+    }
+  }
+  async getPackageInfo(packagePath) {
+    try {
+      const packageJsonPath = packagePath.join("package.json");
+      if (await packageJsonPath.exists()) {
+        const packageJsonContent = await fs8.readFile(packageJsonPath.toString(), "utf-8");
+        const packageJson = JSON.parse(packageJsonContent);
+        return {
+          name: packageJson.name || packagePath.basename().toString(),
+          version: packageJson.version,
+          description: packageJson.description,
+          directory: packagePath.basename().toString()
+        };
+      }
+    } catch (error) {
+    }
+    return null;
+  }
+};
+
+// src/commands/pkg/install.ts
+async function installPackage(source, app) {
+  const packageManager = new PackageManager(app);
+  const result = await packageManager.installPackage(source);
+  if (result.success) {
+    console.log(`Installed package '${result.packageInfo.name}' from ${source} to ${result.installPath}`);
+  } else {
+    console.error(`Failed to install package from ${source}: ${result.error}`);
+    throw new Error(result.error);
+  }
+}
+
+// src/commands/pkg/list.ts
+import chalk5 from "chalk";
+async function listPackages(app) {
+  const packageManager = new PackageManager(app);
+  try {
+    const packages = await packageManager.listPackages();
+    if (packages.length === 0) {
+      console.log("No packages installed.");
+      return;
+    }
+    const packagesByName = /* @__PURE__ */ new Map();
+    packages.forEach((pkg) => {
+      if (!packagesByName.has(pkg.name)) {
+        packagesByName.set(pkg.name, []);
+      }
+      packagesByName.get(pkg.name).push(pkg);
+    });
+    console.log(`Found ${packages.length} package(s):
+`);
+    packages.forEach((pkg) => {
+      const packagesWithSameName = packagesByName.get(pkg.name);
+      const hasDuplicates = packagesWithSameName.length > 1;
+      let output = `\u2022 ${pkg.name}`;
+      if (pkg.version) {
+        output += ` (v${pkg.version})`;
+      }
+      if (pkg.description) {
+        output += ` - ${pkg.description}`;
+      }
+      if (hasDuplicates) {
+        output = chalk5.yellow(output);
+        output += chalk5.yellow(" \u26A0\uFE0F  (duplicate name)");
+      }
+      if (pkg.source) {
+        if (pkg.source.startsWith("http") || pkg.source.startsWith("git@")) {
+          output += `
+  \u{1F4E6} Source: ${pkg.source}`;
+        } else if (!pkg.source.startsWith(".") && !pkg.source.startsWith("/")) {
+          output += `
+  \u{1F4E6} Source: https://www.npmjs.com/package/${pkg.source}`;
+        } else {
+          output += `
+  \u{1F4E6} Source: ${pkg.source}`;
+        }
+      }
+      console.log(output);
+      if (pkg.tasks && pkg.tasks.length > 0) {
+        pkg.tasks.forEach((task2) => {
+          console.log(`  \u2514\u2500 ${task2.name}`);
+        });
+      } else {
+        console.log(`  \u2514\u2500 (no tasks discovered)`);
+      }
+      console.log("");
+    });
+    const duplicateNames = Array.from(packagesByName.entries()).filter(([_, pkgs]) => pkgs.length > 1).map(([name, _]) => name);
+    if (duplicateNames.length > 0) {
+      console.log(chalk5.yellow("\u26A0\uFE0F  Warning: The following package names have duplicates:"));
+      duplicateNames.forEach((name) => {
+        console.log(chalk5.yellow(`   - ${name}`));
+      });
+      console.log(chalk5.yellow("   Use the full source URL to run tasks from these packages."));
+      console.log("");
+    }
+  } catch (error) {
+    console.error("Error listing packages:", error);
+    throw error;
+  }
+}
+
+// src/commands/pkg/remove.ts
+async function removePackage(packageIdentifier, app) {
+  const packageManager = new PackageManager(app);
+  const result = await packageManager.removePackage(packageIdentifier);
+  if (result.success && result.packageInfo) {
+    console.log(`Successfully removed package '${result.packageInfo.name}' (${result.packageInfo.directory})`);
+  } else {
+    console.error(`Failed to remove package: ${result.error}`);
+    return;
+  }
+}
+
 // src/cli.ts
 import JSON5 from "json5";
 
 // src/cli/run-resolver.ts
-import { simpleGit } from "simple-git";
-import filenamify from "filenamify";
-import { match as match6 } from "ts-pattern";
+import { simpleGit as simpleGit2 } from "simple-git";
+import filenamify2 from "filenamify";
+import "ts-pattern";
 import { dirname } from "path";
 import { fileURLToPath } from "url";
-async function resolveScriptPath(app, packageOrBundle, scriptRef, scriptArgs) {
-  if (packageOrBundle && packageOrBundle.startsWith("core.") || !packageOrBundle && scriptRef && scriptRef.startsWith("core.")) {
-    const name = packageOrBundle?.startsWith("core.") ? packageOrBundle : scriptRef;
-    const relPath = name.replace(/^core\./, "").split(".").join(Path.sep());
-    const moduleDir = Path.new(dirname(fileURLToPath(import.meta.url)));
-    const coreRoot = moduleDir.parent().join("core");
-    const candidate = coreRoot.join(`${relPath}.ts`);
-    if (!candidate.isFile()) {
-      throw new Error(`Core task script not found: ${candidate}`);
-    }
-    if (packageOrBundle?.startsWith("core.") && scriptRef) {
-      scriptArgs = [scriptRef, ...scriptArgs];
-    }
-    return { scriptRef: candidate.toString(), scriptArgs };
-  }
-  if (!packageOrBundle) {
-    throw new Error("No bundle or package specified.");
-  }
-  const currentPackageOrBundle = packageOrBundle;
-  let resolvedScriptRef = scriptRef ?? "";
-  await match6(currentPackageOrBundle).when(
-    (path3) => Path.new(path3).isFile() && Path.new(path3).ext() === ".zip",
-    async () => {
-      const tmpName = filenamify(currentPackageOrBundle);
-      const destPath = app.tmpDir.join(tmpName);
-      await unzipDirectory(currentPackageOrBundle, destPath.toString());
-      resolvedScriptRef = destPath.resolve(resolvedScriptRef).toString();
-    }
-  ).when(
-    (path3) => Path.new(path3).isDirectory(),
-    async () => {
-      const tmpName = filenamify(currentPackageOrBundle);
-      const destPath = app.tmpDir.join(tmpName);
-      const pkgPath = Path.new(currentPackageOrBundle);
-      await pkgPath.copy(destPath.toString());
-      resolvedScriptRef = destPath.resolve(resolvedScriptRef).toString();
-    }
-  ).when(isValidUrl, async () => {
-    const tmpName = filenamify(currentPackageOrBundle);
-    const destPath = app.tmpDir.join(tmpName);
-    const git = simpleGit();
-    await git.clone(currentPackageOrBundle, destPath.toString());
-    resolvedScriptRef = destPath.resolve(resolvedScriptRef).toString();
-  }).otherwise(async () => {
-    if (resolvedScriptRef) {
-      A2(scriptArgs).prepend(resolvedScriptRef);
-    }
-    resolvedScriptRef = currentPackageOrBundle;
-  });
-  return { scriptRef: resolvedScriptRef, scriptArgs };
+async function resolveTaskPathAndArgs(app, packageRef, scriptRef, scriptArgs) {
+  app.debug("resolveTaskPathAndArgs", packageRef, scriptRef, scriptArgs);
+  if (scriptRef && scriptRef.includes(":")) {
+    scriptArgs.unshift(scriptRef);
+    scriptRef = void 0;
+  }
+  if (!packageRef) {
+    if (!scriptRef) {
+      throw new Error("No task specified. Please provide a task reference.");
+    }
+    packageRef = scriptRef;
+    scriptRef = void 0;
+  }
+  if (packageRef.startsWith("core.")) {
+    return await resolveCoreTask(packageRef, scriptRef, scriptArgs);
+  }
+  const localResult = await resolveLocalTask(app, packageRef, scriptRef, scriptArgs);
+  if (localResult) {
+    return localResult;
+  }
+  const packageManager = new PackageManager(app);
+  const packageResult = await resolvePackageTask(packageManager, packageRef, scriptRef, scriptArgs);
+  if (packageResult) {
+    return packageResult;
+  }
+  const remoteResult = await resolveRemoteTask(app, packageManager, packageRef, scriptRef, scriptArgs);
+  if (remoteResult) {
+    return remoteResult;
+  }
+  throw new Error(`Could not resolve task: ${packageRef}${scriptRef ? `:${scriptRef}` : ""}`);
 }
-function isValidUrl(url) {
-  try {
-    new URL(url);
-    return true;
-  } catch {
+async function resolveCoreTask(coreTask, scriptRef, scriptArgs) {
+  const relPath = coreTask.replace(/^core\./, "").split(".").join(Path.sep());
+  const moduleDir = Path.new(dirname(fileURLToPath(import.meta.url)));
+  const coreRoot = moduleDir.parent().join("core");
+  const candidate = coreRoot.join(`${relPath}.ts`);
+  if (!candidate.isFile()) {
+    throw new Error(`Core task script not found: ${candidate}`);
+  }
+  if (scriptRef) {
+    A2(scriptArgs).prepend(scriptRef);
+  }
+  return { scriptRef: candidate.toString(), scriptArgs };
+}
+async function resolveLocalTask(app, path4, scriptRef, scriptArgs) {
+  if (isGitUrl(path4) || isNpmPackageName(path4)) {
+    return null;
+  }
+  const pathObj = Path.new(path4);
+  if (!pathObj.exists()) {
+    return null;
+  }
+  if (pathObj.isFile() && pathObj.ext() === ".zip") {
+    return await handleZipFile(app, path4, scriptRef, scriptArgs);
+  }
+  if (pathObj.ext() === ".git") {
+    return await handleGitRepo(app, path4, scriptRef, scriptArgs);
+  }
+  if (pathObj.isDirectory()) {
+    return await handleDirectory(pathObj, scriptRef, scriptArgs);
+  }
+  if (pathObj.isFile() && (pathObj.ext() === ".ts" || pathObj.ext() === ".js")) {
+    if (scriptRef) {
+      A2(scriptArgs).prepend(scriptRef);
+    }
+    return { scriptRef: pathObj.toString(), scriptArgs };
+  }
+  return null;
+}
+function isGitUrl(str) {
+  return str.startsWith("git@") || str.startsWith("http://") || str.startsWith("https://") || str.includes("github.com") || str.includes("gitlab.com") || str.includes("bitbucket.org");
+}
+function isNpmPackageName(str) {
+  if (isGitUrl(str)) {
+    return false;
+  }
+  if (str.startsWith("/") || str.startsWith("\\")) {
+    return false;
+  }
+  if (str.includes("\\")) {
     return false;
   }
+  if (str.includes("/")) {
+    return str.startsWith("@") && str.split("/").length === 2;
+  }
+  return true;
+}
+async function resolvePackageTask(packageManager, packageRef, scriptRef, scriptArgs) {
+  const result = await packageManager.resolveTaskPath(packageRef, scriptRef);
+  if (result) {
+    return { scriptRef: result.taskPath, scriptArgs };
+  }
+  return null;
+}
+async function resolveRemoteTask(app, packageManager, packageRef, scriptRef, scriptArgs) {
+  const isInstalled = await packageManager.isPackageInstalled(packageRef);
+  if (!isInstalled) {
+    const installResult = await packageManager.installPackage(packageRef);
+    if (!installResult.success) {
+      return null;
+    }
+  }
+  const result = await packageManager.resolveTaskPath(packageRef, scriptRef);
+  if (result) {
+    return { scriptRef: result.taskPath, scriptArgs };
+  }
+  return null;
+}
+async function handleZipFile(app, zipPath, scriptRef, scriptArgs) {
+  const tmpName = filenamify2(zipPath, { replacement: "_" });
+  const destPath = app.tmpDir.join(tmpName);
+  await unzipDirectory(zipPath, destPath.toString());
+  if (scriptRef) {
+    const resolvedPath = destPath.resolve(scriptRef);
+    return { scriptRef: resolvedPath.toString(), scriptArgs };
+  }
+  return { scriptRef: destPath.toString(), scriptArgs };
+}
+async function handleGitRepo(app, gitUrl, scriptRef, scriptArgs) {
+  const tmpName = filenamify2(gitUrl, { replacement: "_" });
+  const destPath = app.tmpDir.join(tmpName);
+  const git = simpleGit2();
+  await git.clone(gitUrl, destPath.toString());
+  const packageJsonPath = destPath.join("package.json");
+  if (packageJsonPath.exists()) {
+    const nodeRuntime = new NodeRuntime(app.tmpDir);
+    await nodeRuntime.npmInstall({ cwd: destPath.toString() });
+  }
+  if (scriptRef) {
+    const resolvedPath = destPath.resolve(scriptRef);
+    return { scriptRef: resolvedPath.toString(), scriptArgs };
+  }
+  return { scriptRef: destPath.toString(), scriptArgs };
+}
+async function handleDirectory(dirPath, scriptRef, scriptArgs) {
+  if (scriptRef) {
+    const taskParts = scriptRef.split(".");
+    const taskFileName = taskParts.pop();
+    const taskDir = taskParts.length > 0 ? taskParts.join("/") : "";
+    const tsPath = taskDir ? dirPath.join(taskDir, `${taskFileName}.ts`) : dirPath.join(`${taskFileName}.ts`);
+    const jsPath = taskDir ? dirPath.join(taskDir, `${taskFileName}.js`) : dirPath.join(`${taskFileName}.js`);
+    if (tsPath.exists()) {
+      return { scriptRef: tsPath.toString(), scriptArgs };
+    }
+    if (jsPath.exists()) {
+      return { scriptRef: jsPath.toString(), scriptArgs };
+    }
+    const resolvedPath = dirPath.resolve(scriptRef);
+    return { scriptRef: resolvedPath.toString(), scriptArgs };
+  }
+  const defaultFiles = ["index.ts", "index.js", "main.ts", "main.js"];
+  for (const file of defaultFiles) {
+    const filePath = dirPath.join(file);
+    if (filePath.exists()) {
+      return { scriptRef: filePath.toString(), scriptArgs };
+    }
+  }
+  throw new Error(`No default entry point found in directory: ${dirPath}`);
 }
 
 // src/cli.ts
@@ -4741,7 +5415,7 @@ var logError = (message, error) => {
     }
   }
 };
-function isValidUrl2(url) {
+function isValidUrl(url) {
   try {
     new URL(url);
     return true;
@@ -4767,7 +5441,6 @@ var Cli = class {
       increaseVerbosity,
       Verbosity.WARN
     ).option("-c, --config <file path>", "config file path or http endpoint").option("--json", "output should be json formatted").option("-p, --password", "should prompt for sudo password?", false).option("-t, --tag <tags...>", "specify a tag (repeat for multiple tags)");
-    this.program.command("bundle").alias("b").argument("[path]", `the path to bundle (e.g. hostctl bundle .)`, ".").description("bundle the given path as an npm project").action(this.handleBundle.bind(this));
     this.program.command("exec").alias("e").argument(
       "<command...>",
       `the command string to run, with optional arguments (e.g. hostctl exec sudo sh -c 'echo "$(whoami)"')`
@@ -4777,21 +5450,35 @@ var Cli = class {
     inventoryCmd.command("encrypt").alias("e").description("encrypt the inventory file").action(this.handleInventoryEncrypt.bind(this));
     inventoryCmd.command("decrypt").alias("d").description("decrypt the inventory file").action(this.handleInventoryDecrypt.bind(this));
     inventoryCmd.command("list").alias("ls").description("list the hosts in the inventory file").action(this.handleInventoryList.bind(this));
+    const pkgCmd = this.program.command("pkg").description("manage hostctl packages");
+    pkgCmd.command("create <package-name>").description("create a new hostctl package").option("--lang <language>", "the language for the package (typescript or javascript)", "typescript").hook("preAction", (thisCommand, actionCommand) => {
+      const options = actionCommand.opts();
+      const supportedLanguages = ["typescript", "javascript"];
+      if (!supportedLanguages.includes(options.lang)) {
+        console.error(
+          `Error: Unsupported language '${options.lang}'. Supported languages are: ${supportedLanguages.join(", ")}`
+        );
+        process4.exit(1);
+      }
+    }).action(this.handlePkgCreate.bind(this));
+    pkgCmd.command("install <package-source>").description("install a hostctl package").action(this.handlePkgInstall.bind(this));
+    pkgCmd.command("list").alias("ls").description("list installed hostctl packages").action(this.handlePkgList.bind(this));
+    pkgCmd.command("remove <package-identifier>").alias("rm").description("remove an installed hostctl package").action(this.handlePkgRemove.bind(this));
     this.program.command("run").alias("r").argument(
-      "[package_or_bundle]",
-      `the package or bundle to run the specified <script> from.
-          The package or bundle may be either:
+      "[package]",
+      `the package to run the specified <script> from.
+          The package may be either:
           - a directory in the local filesystem, e.g. /my/package/foo
           - a git repository, e.g. https://github.com/hostctl/core
-          - a zipped package (a bundle), e.g. packagebundle123.zip
+          - an npm package name, e.g. hostctl-hello
         `
     ).argument(
       "[script]",
-      `the hostctl script to run (e.g. hostctl run myscript OR hostctl run mypackage myscript).
-          The script may be specified as either:
+      `the hostctl task script to run (e.g. hostctl run myscript OR hostctl run mypackage myscript).
+          The task script may be specified as either:
           - a package followed by the script, e.g. hostctl run github.com/hostctl/core echo args:hello,world
-          - a script, e.g. hostctl run main.ts
-          - a zipped package (a bundle), e.g. hostctl run packagebundle.zip echo args:hello,world`
+          - a task script, e.g. hostctl run main.ts
+          - an npm package followed by a task script, e.g. hostctl run hostctl-hello goodbye name:Phil`
     ).argument("[script arguments...]", "the runtime arguments to the script.").description("run a hostctl script (default)").option(
       "-f, --file <path>",
       "runtime parameters should be read from file at <path> containing json object representing params to supply to the script"
@@ -4802,11 +5489,6 @@ var Cli = class {
     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));
   }
-  async handleBundle(path3, options, cmd) {
-    const opts = cmd.optsWithGlobals();
-    await this.loadApp(opts);
-    this.app.bundleProject(path3);
-  }
   async handleInventory(options, cmd) {
     const opts = cmd.optsWithGlobals();
     await this.loadApp(opts);
@@ -4862,11 +5544,24 @@ var Cli = class {
       process4.exitCode = 1;
     }
   }
-  async handleRun(packageOrBundle, scriptRef, scriptArgs, options, cmd) {
+  async handleRun(packageRef, scriptRef, scriptArgs, options, cmd) {
     const opts = cmd.optsWithGlobals();
     await this.loadApp(opts);
     this.app.debug(`tags: ${opts.tag}, remote: ${opts.remote}`);
-    const resolved = await resolveScriptPath(this.app, packageOrBundle, scriptRef, scriptArgs);
+    let resolved;
+    try {
+      resolved = await resolveTaskPathAndArgs(this.app, packageRef, scriptRef, scriptArgs);
+    } catch (error) {
+      if (error instanceof Error && error.message.includes("Multiple packages found with name")) {
+        console.error("Error:", error.message);
+        console.error("\nTo resolve this, use the full source URL instead of just the package name.");
+        console.error("For example:");
+        console.error("  ./hostctl run <full-source-url> <task-name>");
+        process4.exitCode = 1;
+        return;
+      }
+      throw error;
+    }
     scriptRef = resolved.scriptRef;
     scriptArgs = resolved.scriptArgs;
     let params = {};
@@ -4909,7 +5604,7 @@ var Cli = class {
     if (homeConfigPath.isFile()) {
       return homeConfigPath.toString();
     }
-    if (suppliedConfigRef && isValidUrl2(suppliedConfigRef)) {
+    if (suppliedConfigRef && isValidUrl(suppliedConfigRef)) {
       return suppliedConfigRef;
     }
     throw new Error(
@@ -4951,6 +5646,21 @@ var Cli = class {
     await this.loadApp(opts);
     await this.app.installRuntime();
   }
+  async handlePkgCreate(packageName, options) {
+    await createPackage(packageName, options);
+  }
+  async handlePkgInstall(source) {
+    await this.loadApp(this.program.opts());
+    await installPackage(source, this.app);
+  }
+  async handlePkgList() {
+    await this.loadApp(this.program.opts());
+    await listPackages(this.app);
+  }
+  async handlePkgRemove(packageIdentifier) {
+    await this.loadApp(this.program.opts());
+    await removePackage(packageIdentifier, this.app);
+  }
 };
 
 // src/bin/hostctl.ts