supipowers 1.5.3 → 2.0.0

package/src/visual/scripts/index.js

@@ -30,6 +30,53 @@ function wrapInFrame(content) {
   return frameTemplate.replace('<!-- CONTENT -->', content);
 }
 
+function injectHelper(html) {
+  if (html.includes('</body>')) {
+    return html.replace('</body>', `${helperInjection}\n</body>`);
+  }
+  return html + helperInjection;
+}
+
+function renderHtml(raw) {
+  const html = isFullDocument(raw) ? raw : wrapInFrame(raw);
+  return injectHelper(html);
+}
+
+function resolveArtifactPath(requestPath) {
+  if (!requestPath || requestPath.startsWith('.')) return null;
+
+  let decodedPath;
+  try {
+    decodedPath = decodeURIComponent(requestPath);
+  } catch {
+    return null;
+  }
+
+  const normalizedPath = path.normalize(decodedPath).replace(/^([/\\])+/, '');
+  if (!normalizedPath || normalizedPath.startsWith('..') || path.isAbsolute(normalizedPath)) {
+    return null;
+  }
+
+  const artifactPath = path.resolve(SCREEN_DIR, normalizedPath);
+  const relative = path.relative(SCREEN_DIR, artifactPath);
+  if (relative.startsWith('..') || path.isAbsolute(relative) || !fs.existsSync(artifactPath)) {
+    return null;
+  }
+
+  return artifactPath;
+}
+
+function serveArtifact(res, artifactPath) {
+  if (artifactPath.endsWith('.html')) {
+    const raw = fs.readFileSync(artifactPath, 'utf-8');
+    res.type('html').send(renderHtml(raw));
+    return;
+  }
+
+  res.sendFile(artifactPath);
+}
+
+
 // Find the newest .html file in the directory by mtime
 function getNewestScreen() {
   const files = fs.readdirSync(SCREEN_DIR)
@@ -86,26 +133,25 @@ wss.on('connection', (ws) => {
   });
 });
 
-// Serve newest screen with helper.js injected
+// Serve newest screen at the root, and session artifacts on direct paths
 app.get('/', (req, res) => {
   const screenFile = getNewestScreen();
-  let html;
-
   if (!screenFile) {
-    html = WAITING_PAGE;
-  } else {
-    const raw = fs.readFileSync(screenFile, 'utf-8');
-    html = isFullDocument(raw) ? raw : wrapInFrame(raw);
+    res.type('html').send(renderHtml(WAITING_PAGE));
+    return;
   }
 
-  // Inject helper script
-  if (html.includes('</body>')) {
-    html = html.replace('</body>', `${helperInjection}\n</body>`);
-  } else {
-    html += helperInjection;
+  serveArtifact(res, screenFile);
+});
+
+app.get(/^\/(.+)$/, (req, res) => {
+  const artifactPath = resolveArtifactPath(req.params[0]);
+  if (!artifactPath) {
+    res.status(404).type('text').send(`Cannot GET ${req.path}`);
+    return;
   }
 
-  res.type('html').send(html);
+  serveArtifact(res, artifactPath);
 });
 
 // Watch for new or changed .html files

package/src/visual/scripts/package.json

@@ -6,5 +6,8 @@
     "express": "^4.21.0",
     "ws": "^8.18.0",
     "chokidar": "^4.0.0"
+  },
+  "overrides": {
+    "path-to-regexp": "0.1.13"
   }
 }

package/src/visual/start-server.ts

@@ -10,10 +10,10 @@ const POLL_INTERVAL_MS = 100;
 
 interface StartServerOptions {
   sessionDir: string;
+  port?: number;
   host?: string;
   urlHost?: string;
 }
-
 /** Start the visual companion server and wait for its connection info. */
 export async function startVisualServer(opts: StartServerOptions): Promise<VisualServerInfo | null> {
   const host = opts.host ?? DEFAULT_HOST;
@@ -31,6 +31,7 @@ export async function startVisualServer(opts: StartServerOptions): Promise<Visua
       env: {
         ...process.env,
         SUPI_VISUAL_DIR: opts.sessionDir,
+        SUPI_VISUAL_PORT: opts.port !== undefined ? String(opts.port) : undefined,
         SUPI_VISUAL_HOST: host,
         SUPI_VISUAL_URL_HOST: urlHost,
       },

package/src/workspace/git-scope.ts

@@ -0,0 +1,64 @@
+import { normalizeLineEndings } from "../text.js";
+import type { WorkspaceTarget } from "../types.js";
+import { filterPathsForWorkspaceTarget, normalizeRepoPath } from "./path-mapping.js";
+
+const GIT_LOG_RECORD_SEPARATOR = "\u001e";
+const GIT_LOG_FIELD_SEPARATOR = "\u001f";
+
+export interface GitCommitWithFiles {
+  hash: string;
+  message: string;
+  files: string[];
+}
+
+export function parseGitLogWithFiles(gitLog: string): GitCommitWithFiles[] {
+  return normalizeLineEndings(gitLog)
+    .split(GIT_LOG_RECORD_SEPARATOR)
+    .map((record) => record.trim())
+    .filter(Boolean)
+    .flatMap((record) => {
+      const lines = record
+        .split("\n")
+        .map((line) => line.trim())
+        .filter(Boolean);
+
+      const header = lines.shift();
+      if (!header) {
+        return [];
+      }
+
+      const [hash, message] = header.split(GIT_LOG_FIELD_SEPARATOR);
+      if (!hash || !message) {
+        return [];
+      }
+
+      return [{
+        hash: hash.trim(),
+        message: message.trim(),
+        files: lines.map(normalizeRepoPath).filter(Boolean),
+      }];
+    });
+}
+
+export function filterGitLogWithFilesToWorkspaceTarget<TTarget extends WorkspaceTarget>(
+  gitLog: string,
+  targets: TTarget[],
+  target: TTarget,
+): GitCommitWithFiles[] {
+  return parseGitLogWithFiles(gitLog)
+    .map((commit) => ({
+      ...commit,
+      files: filterPathsForWorkspaceTarget(targets, target, commit.files),
+    }))
+    .filter((commit) => commit.files.length > 0);
+}
+
+export function filterGitLogOnelineToWorkspaceTarget<TTarget extends WorkspaceTarget>(
+  gitLog: string,
+  targets: TTarget[],
+  target: TTarget,
+): string {
+  return filterGitLogWithFilesToWorkspaceTarget(gitLog, targets, target)
+    .map((commit) => `${commit.hash.slice(0, 7)} ${commit.message}`)
+    .join("\n");
+}

package/src/workspace/locks.ts

@@ -0,0 +1,23 @@
+function getWorkspaceTargetLockKey(commandName: string, targetId: string): string {
+  return `${commandName}:${targetId}`;
+}
+
+const activeWorkspaceTargetLocks = new Set<string>();
+
+export function tryAcquireWorkspaceTargetLock(commandName: string, targetId: string): boolean {
+  const key = getWorkspaceTargetLockKey(commandName, targetId);
+  if (activeWorkspaceTargetLocks.has(key)) {
+    return false;
+  }
+
+  activeWorkspaceTargetLocks.add(key);
+  return true;
+}
+
+export function releaseWorkspaceTargetLock(commandName: string, targetId: string): void {
+  activeWorkspaceTargetLocks.delete(getWorkspaceTargetLockKey(commandName, targetId));
+}
+
+export function isWorkspaceTargetLocked(commandName: string, targetId: string): boolean {
+  return activeWorkspaceTargetLocks.has(getWorkspaceTargetLockKey(commandName, targetId));
+}

package/src/workspace/package-manager.ts

@@ -0,0 +1,117 @@
+import fs from "node:fs";
+import path from "node:path";
+import type { PackageManagerId } from "../types.js";
+
+interface RootManifest {
+  packageManager?: string;
+  workspaces?: unknown;
+}
+
+export interface PackageManagerCommand {
+  command: string;
+  args: string[];
+}
+
+export interface ResolvedPackageManager {
+  id: PackageManagerId;
+  runScript(scriptName: string): PackageManagerCommand;
+  buildCommand: PackageManagerCommand;
+}
+
+const LOCKFILE_ORDER: Array<{ file: string; manager: PackageManagerId }> = [
+  { file: "bun.lock", manager: "bun" },
+  { file: "bun.lockb", manager: "bun" },
+  { file: "pnpm-lock.yaml", manager: "pnpm" },
+  { file: "yarn.lock", manager: "yarn" },
+  { file: "package-lock.json", manager: "npm" },
+  { file: "npm-shrinkwrap.json", manager: "npm" },
+];
+
+function readRootManifest(repoRoot: string): RootManifest | null {
+  try {
+    return JSON.parse(fs.readFileSync(path.join(repoRoot, "package.json"), "utf-8")) as RootManifest;
+  } catch {
+    return null;
+  }
+}
+
+function parsePackageManagerField(value: string | undefined): PackageManagerId | null {
+  if (!value) {
+    return null;
+  }
+
+  const normalized = value.trim();
+  if (normalized === "bun" || normalized.startsWith("bun@")) return "bun";
+  if (normalized === "npm" || normalized.startsWith("npm@")) return "npm";
+  if (normalized === "pnpm" || normalized.startsWith("pnpm@")) return "pnpm";
+  if (normalized === "yarn" || normalized.startsWith("yarn@")) return "yarn";
+  return null;
+}
+
+function hasPackageJsonWorkspaces(manifest: RootManifest | null): boolean {
+  if (!manifest) {
+    return false;
+  }
+
+  if (Array.isArray(manifest.workspaces)) {
+    return manifest.workspaces.some((entry) => typeof entry === "string" && entry.length > 0);
+  }
+
+  if (manifest.workspaces && typeof manifest.workspaces === "object" && !Array.isArray(manifest.workspaces)) {
+    const packages = (manifest.workspaces as { packages?: unknown }).packages;
+    return Array.isArray(packages) && packages.some((entry) => typeof entry === "string" && entry.length > 0);
+  }
+
+  return false;
+}
+
+export function getRunScriptCommand(
+  packageManager: PackageManagerId,
+  scriptName: string,
+): PackageManagerCommand {
+  switch (packageManager) {
+    case "bun":
+      return { command: "bun", args: ["run", scriptName] };
+    case "npm":
+      return { command: "npm", args: ["run", scriptName] };
+    case "pnpm":
+      return { command: "pnpm", args: ["run", scriptName] };
+    case "yarn":
+      return { command: "yarn", args: [scriptName] };
+  }
+}
+
+export function detectPackageManager(repoRoot: string): PackageManagerId {
+  const manifest = readRootManifest(repoRoot);
+  const manifestManager = parsePackageManagerField(manifest?.packageManager);
+  if (manifestManager) {
+    return manifestManager;
+  }
+
+  for (const lockfile of LOCKFILE_ORDER) {
+    if (fs.existsSync(path.join(repoRoot, lockfile.file))) {
+      return lockfile.manager;
+    }
+  }
+
+  if (fs.existsSync(path.join(repoRoot, "pnpm-workspace.yaml"))) {
+    return "pnpm";
+  }
+
+  if (hasPackageJsonWorkspaces(manifest)) {
+    return "npm";
+  }
+
+  return "bun";
+}
+
+export function resolvePackageManager(repoRoot: string): ResolvedPackageManager {
+  const id = detectPackageManager(repoRoot);
+  return {
+    id,
+    runScript(scriptName: string) {
+      return getRunScriptCommand(id, scriptName);
+    },
+    buildCommand: getRunScriptCommand(id, "build"),
+  };
+}

package/src/workspace/path-mapping.ts

@@ -0,0 +1,75 @@
+import type { WorkspaceTarget } from "../types.js";
+import { ROOT_WORKSPACE_RELATIVE_DIR, normalizeWorkspaceRelativePath } from "./targets.js";
+
+export function normalizeRepoPath(value: string): string {
+  return normalizeWorkspaceRelativePath(value);
+}
+
+export function findWorkspaceTargetForPath<TTarget extends WorkspaceTarget>(
+  targets: TTarget[],
+  repoRelativePath: string,
+): TTarget | null {
+  const normalizedPath = normalizeRepoPath(repoRelativePath);
+  let bestMatch: TTarget | null = null;
+  let bestSpecificity = -1;
+
+  for (const target of targets) {
+    const scope = normalizeRepoPath(target.relativeDir);
+    const isMatch = scope === ROOT_WORKSPACE_RELATIVE_DIR
+      ? true
+      : normalizedPath === scope || normalizedPath.startsWith(`${scope}/`);
+
+    if (!isMatch) {
+      continue;
+    }
+
+    const specificity = scope === ROOT_WORKSPACE_RELATIVE_DIR ? 0 : scope.length;
+    if (specificity > bestSpecificity) {
+      bestMatch = target;
+      bestSpecificity = specificity;
+    }
+  }
+
+  return bestMatch;
+}
+
+export function filterPathsForWorkspaceTarget<TTarget extends WorkspaceTarget>(
+  targets: TTarget[],
+  target: TTarget,
+  repoRelativePaths: string[],
+): string[] {
+  return repoRelativePaths.filter((repoRelativePath) =>
+    findWorkspaceTargetForPath(targets, repoRelativePath)?.id === target.id,
+  );
+}
+
+export function partitionPathsByWorkspaceTarget<TTarget extends WorkspaceTarget>(
+  targets: TTarget[],
+  repoRelativePaths: string[],
+): Map<string, string[]> {
+  const partitions = new Map<string, string[]>();
+
+  for (const repoRelativePath of repoRelativePaths) {
+    const owner = findWorkspaceTargetForPath(targets, repoRelativePath);
+    if (!owner) {
+      continue;
+    }
+
+    const existing = partitions.get(owner.id);
+    if (existing) {
+      existing.push(repoRelativePath);
+    } else {
+      partitions.set(owner.id, [repoRelativePath]);
+    }
+  }
+
+  return partitions;
+}
+
+export function getChangedWorkspaceTargets<TTarget extends WorkspaceTarget>(
+  targets: TTarget[],
+  repoRelativePaths: string[],
+): TTarget[] {
+  const changedIds = new Set(partitionPathsByWorkspaceTarget(targets, repoRelativePaths).keys());
+  return targets.filter((target) => changedIds.has(target.id));
+}

package/src/workspace/project-slug.ts

@@ -0,0 +1,92 @@
+import { createHash } from "node:crypto";
+import path from "node:path";
+
+/**
+ * Version of the slug derivation scheme. Bumping this is a breaking change: every user's
+ * global state directories become orphaned because their previously derived slugs no longer
+ * match what {@link projectSlugFromRepoRoot} produces. Do not bump without a migration plan.
+ */
+export const SLUG_SCHEMA_VERSION = 1;
+
+/**
+ * Fixed length of the hex hash suffix that appears after the human-readable basename portion.
+ * 16 hex chars = 64 bits, which makes accidental collisions vanishingly unlikely while keeping
+ * slugs readable on disk.
+ */
+const HASH_HEX_LEN = 16;
+
+/**
+ * Maximum length of the basename portion. Keeps slugs filesystem-safe on Windows where
+ * total path budget can be tight, while still preserving enough context for humans to
+ * recognize which repo owns a given global session directory.
+ */
+const MAX_BASENAME_PORTION_LEN = 40;
+
+function sanitizeBasename(raw: string): string {
+  // Lowercase, collapse anything that is not alphanumeric to a single hyphen, and trim hyphens.
+  const lowered = raw.toLowerCase();
+  const replaced = lowered.replace(/[^a-z0-9]+/g, "-");
+  const trimmed = replaced.replace(/^-+|-+$/g, "");
+  // Fall back to a stable placeholder when the basename is entirely non-alphanumeric
+  // (e.g. `/` or a directory named `___`). The hash portion still disambiguates.
+  const base = trimmed.length > 0 ? trimmed : "project";
+  return base.length > MAX_BASENAME_PORTION_LEN
+    ? base.slice(0, MAX_BASENAME_PORTION_LEN)
+    : base;
+}
+
+/**
+ * Derive a deterministic project slug from the absolute repo root path.
+ *
+ * Guarantees:
+ * - Stable for the same absolute input across calls and platforms.
+ * - Two distinct absolute inputs never produce the same slug (up to SHA-256 collision bounds).
+ * - Two inputs that differ only in case still produce distinct slugs on case-sensitive filesystems.
+ * - Normalization-stable: trailing slashes and redundant separators do not change the slug.
+ *
+ * Fail-closed:
+ * - Throws on non-absolute, empty, or whitespace-only input. The delta spec requires fail-closed
+ *   behavior so migration and runtime truth never silently merge distinct projects.
+ */
+export function projectSlugFromRepoRoot(repoRoot: string): string {
+  if (typeof repoRoot !== "string") {
+    throw new TypeError("projectSlugFromRepoRoot: repoRoot must be a string");
+  }
+
+  const trimmed = repoRoot.trim();
+  if (trimmed.length === 0) {
+    throw new Error("projectSlugFromRepoRoot: repoRoot must not be empty");
+  }
+
+  if (!path.isAbsolute(trimmed)) {
+    throw new Error(
+      `projectSlugFromRepoRoot: repoRoot must be an absolute path, received: ${repoRoot}`,
+    );
+  }
+
+  // path.normalize collapses redundant separators but preserves trailing slashes; strip them
+  // so "/foo/" and "/foo" produce the same slug. Preserve filesystem root "/".
+  const normalized = stripTrailingSeparators(path.normalize(trimmed));
+
+  // Always hash the normalized absolute path so the slug is a pure function of filesystem
+  // identity. The hash portion disambiguates across projects that share a basename.
+  const hash = createHash("sha256").update(normalized).digest("hex").slice(0, HASH_HEX_LEN);
+
+  const basenamePortion = sanitizeBasename(path.basename(normalized));
+
+  return `${basenamePortion}-${hash}`;
+}
+
+function stripTrailingSeparators(value: string): string {
+  // Never strip the filesystem root ("/" on POSIX, "C:\\" on Windows).
+  if (value.length <= 1) return value;
+  let end = value.length;
+  while (end > 1 && (value[end - 1] === "/" || value[end - 1] === "\\")) {
+    end--;
+  }
+  // Preserve Windows drive roots like "C:\\" (length 3) — stripping would yield "C:" which is not absolute.
+  if (/^[A-Za-z]:[\/\\]?$/.test(value.slice(0, Math.min(3, value.length)))) {
+    return value.slice(0, Math.max(end, 3));
+  }
+  return value.slice(0, end);
+}

package/src/workspace/repo-root.ts

@@ -0,0 +1,137 @@
+import fs from "node:fs";
+import path from "node:path";
+import type { Platform } from "../platform/types.js";
+
+interface RootManifest {
+  workspaces?: unknown;
+}
+
+function hasWorkspaceManifest(repoRoot: string): boolean {
+  if (fs.existsSync(path.join(repoRoot, "pnpm-workspace.yaml"))) {
+    return true;
+  }
+
+  try {
+    const manifest = JSON.parse(fs.readFileSync(path.join(repoRoot, "package.json"), "utf-8")) as RootManifest;
+    if (Array.isArray(manifest.workspaces)) {
+      return manifest.workspaces.some((entry) => typeof entry === "string" && entry.length > 0);
+    }
+
+    const workspaces = manifest.workspaces;
+    if (!workspaces || typeof workspaces !== "object" || Array.isArray(workspaces)) {
+      return false;
+    }
+
+    const packages = (workspaces as { packages?: unknown }).packages;
+    return Array.isArray(packages) && packages.some((entry) => typeof entry === "string" && entry.length > 0);
+  } catch {
+    return false;
+  }
+}
+
+export function resolveRepoRootFromFs(cwd: string): string {
+  let current = path.resolve(cwd);
+  let packageRoot: string | null = null;
+
+  while (true) {
+    if (fs.existsSync(path.join(current, "package.json"))) {
+      packageRoot ??= current;
+      if (hasWorkspaceManifest(current)) {
+        return current;
+      }
+    }
+
+    const parent = path.dirname(current);
+    if (parent === current) {
+      return packageRoot ?? path.resolve(cwd);
+    }
+    current = parent;
+  }
+}
+
+function resolveGitDirForRepoRoot(repoRoot: string): string | null {
+  const dotGitPath = path.join(repoRoot, ".git");
+  if (!fs.existsSync(dotGitPath)) {
+    return null;
+  }
+
+  const dotGitStats = fs.statSync(dotGitPath);
+  if (dotGitStats.isDirectory()) {
+    return path.resolve(dotGitPath);
+  }
+
+  if (!dotGitStats.isFile()) {
+    throw new Error(`Unable to resolve repo identity from ${repoRoot}: .git is neither a file nor directory`);
+  }
+
+  const rawPointer = fs.readFileSync(dotGitPath, "utf-8").trim();
+  const match = /^gitdir:\s*(.+)$/i.exec(rawPointer);
+  if (!match) {
+    throw new Error(`Unable to resolve repo identity from ${repoRoot}: invalid .git gitdir pointer`);
+  }
+
+  return path.resolve(repoRoot, match[1].trim());
+}
+
+function resolveCommonGitDir(gitDir: string): string {
+  if (!fs.existsSync(gitDir)) {
+    throw new Error(`Unable to resolve repo identity: gitdir does not exist at ${gitDir}`);
+  }
+
+  const commondirPath = path.join(gitDir, "commondir");
+  if (!fs.existsSync(commondirPath)) {
+    return gitDir;
+  }
+
+  const commondirValue = fs.readFileSync(commondirPath, "utf-8").trim();
+  if (commondirValue.length === 0) {
+    throw new Error(`Unable to resolve repo identity: empty commondir file at ${commondirPath}`);
+  }
+
+  const commonDir = path.resolve(gitDir, commondirValue);
+  if (!fs.existsSync(commonDir)) {
+    throw new Error(`Unable to resolve repo identity: common git dir does not exist at ${commonDir}`);
+  }
+
+  return commonDir;
+}
+
+export function resolveRepoIdentityRootFromFs(cwd: string): string {
+  const repoRoot = resolveRepoRootFromFs(cwd);
+  const gitDir = resolveGitDirForRepoRoot(repoRoot);
+  if (gitDir === null) {
+    return repoRoot;
+  }
+
+  const resolvedGitDir = path.resolve(gitDir);
+  const commonDir = path.resolve(resolveCommonGitDir(resolvedGitDir));
+  if (path.basename(commonDir) !== ".git") {
+    if (commonDir === resolvedGitDir) {
+      return repoRoot;
+    }
+    throw new Error(`Unable to resolve repo identity from ${repoRoot}: expected common git dir ending in .git, received ${commonDir}`);
+  }
+
+  const identityRoot = path.dirname(commonDir);
+  if (!path.isAbsolute(identityRoot) || identityRoot === commonDir) {
+    throw new Error(`Unable to resolve repo identity from ${repoRoot}: invalid identity root ${identityRoot}`);
+  }
+
+  return identityRoot;
+}
+
+export async function resolveRepoRoot(platform: Pick<Platform, "exec">, cwd: string): Promise<string> {
+  try {
+    const result = await platform.exec("git", ["rev-parse", "--show-toplevel"], { cwd });
+    if (result.code === 0) {
+      const repoRoot = result.stdout.trim();
+      if (repoRoot.length > 0) {
+        return repoRoot;
+      }
+    }
+  } catch {
+    // Fall back to filesystem-based workspace detection when git is unavailable.
+  }
+
+  return resolveRepoRootFromFs(cwd);
+}