@alphacoder-v0/pi-loops 0.22.0 → 0.22.1

package/CHANGELOG.md

@@ -5,6 +5,19 @@ All notable changes to pi-loops are documented here. The format follows
 
 ## [Unreleased]
 
+## [0.22.1] - 2026-09-16
+
+### Fixed
+- **The launcher survives the package being installed by the other route.** The `sh` script
+  `install-launcher` writes named one entry file and nothing else, so `pi install npm:…` over a
+  `git:` copy — or the reverse — left every `pi-loops` ending in Node's `Cannot find module
+  …/src/cli-entry.mjs` stack trace, `pi-loops upgrade` included; the comment claiming it "survives
+  the package moving" was the only thing that did. It now carries both places pi installs this
+  package to (`npm/node_modules/<name>` and `git/<host>/<owner>/<repo>`, under the agent directory
+  it was written with) as literal paths and runs the first one that is there, falls back to the
+  `node` on `PATH` when the node it recorded has gone too, and when no copy is in any of them says
+  so in one line — write the launcher again with `install-launcher` — instead of a stack trace.
+
 ## [0.22.0] - 2026-09-16
 
 ### Added

package/README.md

@@ -38,7 +38,7 @@ the first sign of credentials that do not work should not be an empty inbox tomo
 
 ```bash
 pi install npm:@alphacoder-v0/pi-loops                      # from npm, following new releases
-pi install git:github.com/alphacoder-v0/pi-loops@v0.22.0    # or from GitHub, at a pinned tag
+pi install git:github.com/alphacoder-v0/pi-loops@v0.22.1    # or from GitHub, at a pinned tag
 pi install /path/to/pi-loops                                # or a local checkout — `pi install .` in this repo
 pi -e /path/to/pi-loops                                     # or none of them: try it for one run, installing nothing
 ```

package/README.zh-CN.md

@@ -45,7 +45,7 @@ pi-loops 自己没有任何运行时依赖。
 
 ```bash
 pi install npm:@alphacoder-v0/pi-loops                      # 从 npm 装，跟着新版本走
-pi install git:github.com/alphacoder-v0/pi-loops@v0.22.0    # 或者从 GitHub 装，钉住一个 tag
+pi install git:github.com/alphacoder-v0/pi-loops@v0.22.1    # 或者从 GitHub 装，钉住一个 tag
 pi install /path/to/pi-loops                                # 或者本地检出；本仓库里就是 pi install .
 ```
 

package/docs/cli.md

@@ -169,8 +169,13 @@ node src/cli-entry.mjs install-launcher
 node src/cli-entry.mjs install-launcher --dir ~/bin
 ```
 
-It writes a two-line `sh` script that names the node you ran it with and the package it lives in —
-a launcher rather than a symlink, so it keeps working if either moves for the other's reason.
+It writes a small `sh` script that names the node you ran it with and the package it lives in — a
+launcher rather than a symlink. Neither path is trusted for ever: if the package is not where it
+was, the launcher looks in both of the directories above (the ones pi installs into, under the agent
+directory this was written with), so installing again by the other route does not break it, and if
+that node has gone it falls back to the `node` on your `PATH`. When no copy is in any of them it
+prints one line saying to run `install-launcher` again — from inside pi, or from wherever pi has put
+the package now — instead of a Node stack trace about a missing file.
 
 ## Upgrading
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@alphacoder-v0/pi-loops",
-  "version": "0.22.0",
+  "version": "0.22.1",
   "description": "An automation layer for pi: cron + stateful loops with a triage inbox, maker/checker verification, dynamic triggers, MCP notifications and tools, lifecycle hooks, session archives. A non-invasive pi extension.",
   "type": "module",
   "license": "MIT",

package/src/cli.ts

@@ -579,12 +579,21 @@ function packageRoot(): string {
 	return path.join(path.dirname(fileURLToPath(import.meta.url)), "..");
 }
 
-/** Where this copy came from and what it is called, so an upgrade goes back to the same place. */
-function manifest(): { name?: string; repositoryUrl?: string } {
+/**
+ * Where this copy came from and what it is called, so an upgrade goes back to the same place —
+ * plus the `host/owner/repo` inside that URL, which is how pi spells the same repository in a
+ * `git:` spec and on disk. The URL is read here and nowhere else, so the two cannot drift apart.
+ */
+function manifest(): { name?: string; repositoryUrl?: string; repoPath?: string } {
 	try {
 		const pkg = JSON.parse(fs.readFileSync(path.join(packageRoot(), "package.json"), "utf8"));
 		const url = String(pkg?.repository?.url ?? "").replace(/^git\+/, "").replace(/\.git$/, "");
-		return { name: typeof pkg?.name === "string" ? pkg.name : undefined, repositoryUrl: url || undefined };
+		const at = /(?:^|@|\/\/)([^/@\s]+\.[a-z]{2,})[/:]([^/\s]+)\/([^/\s]+)$/.exec(url);
+		return {
+			name: typeof pkg?.name === "string" ? pkg.name : undefined,
+			repositoryUrl: url || undefined,
+			repoPath: at ? `${at[1]}/${at[2]}/${at[3]}` : undefined,
+		};
 	} catch {
 		return {}; // installed without its package.json: nothing to ask
 	}
@@ -774,17 +783,41 @@ export async function installLauncherWithConfirm(args: string[], confirm: (title
 	const target = launcherTarget(dir);
 	if (!target) return installLauncher(undefined, out);
 	const reach = isOnPath(target) ? ["Afterwards `pi-loops` starts a session from any directory."] : [`${target} is not on your PATH, so \`pi-loops\` will not be found until it is.`];
-	const ok = await confirm("Put `pi-loops` on your PATH?", [`This writes a launcher into ${target}.`, "", "It is a two-line shell script that runs this package with this node.", ...reach].join("\n"));
+	const ok = await confirm("Put `pi-loops` on your PATH?", [`This writes a launcher into ${target}.`, "", "It is a small shell script that runs this package with this node.", ...reach].join("\n"));
 	if (!ok) return undefined;
 	// The absolute directory the question named, not the flag again: resolving a relative --dir a
 	// second time, after the dialog, would follow a working directory that may have moved meanwhile.
 	return installLauncher(target, out);
 }
 
+/**
+ * What a launcher says when no copy of this package is at any of the paths it knows. One line and
+ * an exit code, because the alternative a person actually saw was Node's `Cannot find module` stack
+ * trace, which names a file that is gone and nothing they can do about it. It is written into the
+ * script inside single quotes, so it must contain none.
+ */
+const LAUNCHER_LOST =
+	"pi-loops: the package this launcher was written for is not where it was — write the launcher again with `/pi-loops install-launcher` in pi, or `node <the directory pi installed it into>/src/cli-entry.mjs install-launcher`";
+
+/**
+ * The other places this package can be, for a launcher whose recorded entry has gone: the two
+ * directories `pi install` puts it in, under the agent directory the launcher is written with. They
+ * are baked into the script as literal paths — the launcher looks, it does not work anything out.
+ */
+function piInstallEntries(agentDir: string): string[] {
+	const { name, repoPath } = manifest();
+	const entries: string[] = [];
+	// `<agent dir>/npm/node_modules/<name>` and `<agent dir>/git/<host>/<owner>/<repo>`: the same two
+	// layouts `upgradeSpec` reads backwards to work out which route this copy came down.
+	if (name) entries.push(path.join(agentDir, "npm", "node_modules", ...name.split("/"), "src", "cli-entry.mjs"));
+	if (repoPath) entries.push(path.join(agentDir, "git", ...repoPath.split("/"), "src", "cli-entry.mjs"));
+	return entries;
+}
+
 /**
  * `pi install` puts this package under pi's managed directory rather than on your PATH, so the
  * command that is supposed to start your sessions is reachable only by absolute path. This writes
- * a two-line launcher into a directory that is already on your PATH, which is the smallest thing
+ * a small launcher into a directory that is already on your PATH, which is the smallest thing
  * that fixes it without asking you to publish or install anything else.
  */
 export async function installLauncher(dir: string | undefined, out: (line: string) => void): Promise<number> {
@@ -797,9 +830,25 @@ export async function installLauncher(dir: string | undefined, out: (line: strin
 	if (dir && !isOnPath(target)) out(`note: ${target} is not on your PATH, so the command will not be found there yet`);
 	const entry = path.join(path.dirname(fileURLToPath(import.meta.url)), "cli-entry.mjs");
 	const file = path.join(target, "pi-loops");
-	// A launcher rather than a symlink: it survives the package moving, and it names the node that
-	// is running now, which is the one known to be new enough for this code.
-	const script = `#!/bin/sh\n# pi-loops launcher, written by \`pi-loops install-launcher\`.\nexec ${JSON.stringify(process.execPath)} ${JSON.stringify(entry)} "$@"\n`;
+	// A launcher rather than a symlink: it names the node that is running now, which is the one known
+	// to be new enough for this code. What it survives is this package being installed again by the
+	// other route — `pi install npm:` over a `git:` copy moves it, and a launcher that knew only where
+	// it used to be died in Node's `Cannot find module`. So the entry it recorded is the first place
+	// it looks and not the only one, and the recorded node is a path it checks rather than trusts.
+	const candidates = [entry, ...piInstallEntries(getAgentDir())].map((e) => JSON.stringify(e)).join(" ");
+	const script = [
+		"#!/bin/sh",
+		"# pi-loops launcher, written by `pi-loops install-launcher`.",
+		`node=${JSON.stringify(process.execPath)}`,
+		'[ -x "$node" ] || node=$(command -v node) || node=node',
+		`for entry in ${candidates}; do`,
+		'\t[ -f "$entry" ] || continue',
+		'\texec "$node" "$entry" "$@"',
+		"done",
+		`echo '${LAUNCHER_LOST}' >&2`,
+		"exit 1",
+		"",
+	].join("\n");
 	try {
 		fs.mkdirSync(target, { recursive: true });
 		fs.writeFileSync(file, script, { mode: 0o755 });