@getjack/jack 0.1.28 → 0.1.30

package/src/commands/skills.ts

@@ -0,0 +1,335 @@
+/**
+ * jack skills - Manage agent skills for project-specific knowledge
+ *
+ * Skills are capability chips that teach AI agents Jack Cloud-specific patterns.
+ * Uses skills.sh (npx skills add) for installation.
+ */
+
+import { existsSync } from "node:fs";
+import { readdir, rm } from "node:fs/promises";
+import { join } from "node:path";
+import { type AgentLaunchConfig, getPreferredLaunchAgent, launchAgent } from "../lib/agents.ts";
+import { error, info, item, success } from "../lib/output.ts";
+
+const SKILLS_REPO = "getjack-org/skills";
+const SKILLS_API_URL = `https://api.github.com/repos/${SKILLS_REPO}/contents/skills`;
+const SUPPORTED_AGENTS = ["claude-code", "codex"];
+
+// Cache for fetched skills (per process)
+let cachedSkills: { name: string; description: string }[] | null = null;
+let fetchError: string | null = null;
+
+const FETCH_TIMEOUT_MS = 5000;
+
+interface GitHubContent {
+	name: string;
+	type: string;
+	download_url: string | null;
+}
+
+async function fetchWithTimeout(url: string, timeoutMs: number): Promise<Response> {
+	const controller = new AbortController();
+	const timeout = setTimeout(() => controller.abort(), timeoutMs);
+	try {
+		return await fetch(url, {
+			headers: { "User-Agent": "jack-cli" },
+			signal: controller.signal,
+		});
+	} finally {
+		clearTimeout(timeout);
+	}
+}
+
+async function fetchAvailableSkills(): Promise<{ name: string; description: string }[]> {
+	if (cachedSkills) return cachedSkills;
+	if (fetchError) return []; // Don't retry on same process
+
+	try {
+		const res = await fetchWithTimeout(SKILLS_API_URL, FETCH_TIMEOUT_MS);
+
+		if (res.status === 403) {
+			fetchError = "GitHub API rate limit exceeded. Try again later.";
+			return [];
+		}
+
+		if (!res.ok) {
+			fetchError = `GitHub API error: ${res.status}`;
+			return [];
+		}
+
+		const contents: GitHubContent[] = await res.json();
+		const skillDirs = contents.filter((c) => c.type === "dir");
+
+		// Fetch descriptions from SKILL.md in parallel (with timeout each)
+		const skills = await Promise.all(
+			skillDirs.map(async (dir) => {
+				const description = await fetchSkillDescription(dir.name);
+				return { name: dir.name, description };
+			}),
+		);
+
+		cachedSkills = skills;
+		return skills;
+	} catch (err) {
+		if (err instanceof Error && err.name === "AbortError") {
+			fetchError = "Request timed out. Check your internet connection.";
+		} else {
+			fetchError = "Could not fetch skills catalog.";
+		}
+		return [];
+	}
+}
+
+function getFetchError(): string | null {
+	return fetchError;
+}
+
+async function fetchSkillDescription(skillName: string): Promise<string> {
+	try {
+		const url = `https://raw.githubusercontent.com/${SKILLS_REPO}/main/skills/${skillName}/SKILL.md`;
+		const res = await fetch(url, {
+			headers: { "User-Agent": "jack-cli" },
+		});
+
+		if (!res.ok) return "";
+
+		const content = await res.text();
+		// Parse YAML frontmatter for description
+		const match = content.match(/^---\n([\s\S]*?)\n---/);
+		if (match) {
+			const frontmatter = match[1];
+			const descMatch = frontmatter.match(/description:\s*>?\s*\n?\s*(.+?)(?:\n\s{2,}|$)/s);
+			if (descMatch) {
+				// Get first line of description
+				return descMatch[1].split("\n")[0].trim();
+			}
+		}
+		return "";
+	} catch {
+		return "";
+	}
+}
+
+export default async function skills(subcommand?: string, args: string[] = []): Promise<void> {
+	if (!subcommand) {
+		return showHelp();
+	}
+
+	switch (subcommand) {
+		case "run":
+			return await runSkill(args[0]);
+		case "list":
+		case "ls":
+			return await listSkills();
+		case "remove":
+		case "rm":
+			return await removeSkill(args[0]);
+		default:
+			error(`Unknown subcommand: ${subcommand}`);
+			info("Available: run, list, remove");
+			process.exit(1);
+	}
+}
+
+async function showHelp(): Promise<void> {
+	console.log("");
+	info("jack skills - Manage agent skills");
+	console.log("");
+	console.log("Commands:");
+	console.log("  run <name>          Install (if needed) and launch agent with skill");
+	console.log("  list                List installed skills in current project");
+	console.log("  remove <name>       Remove a skill from project");
+	console.log("");
+	const skills = await fetchAvailableSkills();
+	if (skills.length > 0) {
+		console.log("Available skills:");
+		for (const skill of skills) {
+			console.log(`  ${skill.name.padEnd(16)} ${skill.description}`);
+		}
+		console.log("");
+	} else {
+		const err = getFetchError();
+		if (err) {
+			info(`Could not load skills catalog: ${err}`);
+			info("You can still run: jack skills run <skill-name>");
+			console.log("");
+		}
+	}
+}
+
+async function runSkill(skillName?: string): Promise<void> {
+	const availableSkills = await fetchAvailableSkills();
+
+	if (!skillName) {
+		error("Missing skill name");
+		info("Usage: jack skills run <name>");
+		if (availableSkills.length > 0) {
+			console.log("");
+			console.log("Available skills:");
+			for (const skill of availableSkills) {
+				console.log(`  ${skill.name.padEnd(16)} ${skill.description}`);
+			}
+		} else {
+			const err = getFetchError();
+			if (err) {
+				console.log("");
+				info(`Could not load skills catalog: ${err}`);
+			}
+		}
+		process.exit(1);
+	}
+
+	const projectDir = process.cwd();
+
+	// 1. Validate skill exists in catalog (if we could fetch it)
+	if (availableSkills.length > 0) {
+		const skill = availableSkills.find((s) => s.name === skillName);
+		if (!skill) {
+			error(`Skill not found: ${skillName}`);
+			console.log("");
+			console.log("Available skills:");
+			for (const s of availableSkills) {
+				console.log(`  ${s.name.padEnd(16)} ${s.description}`);
+			}
+			process.exit(1);
+		}
+	}
+	// If fetch failed, let skills.sh handle validation
+
+	// 2. Check if already installed
+	const skillPath = join(projectDir, ".claude/skills", skillName);
+	if (!existsSync(skillPath)) {
+		info(`Installing ${skillName}...`);
+
+		const agentFlags = SUPPORTED_AGENTS.flatMap((a) => ["--agent", a]);
+		const proc = Bun.spawn(
+			["npx", "skills", "add", SKILLS_REPO, "--skill", skillName, ...agentFlags, "--yes"],
+			{
+				cwd: projectDir,
+				stdout: "pipe",
+				stderr: "pipe",
+			},
+		);
+
+		// Collect output for error reporting
+		const stdout = await new Response(proc.stdout).text();
+		const stderr = await new Response(proc.stderr).text();
+
+		await proc.exited;
+
+		if (proc.exitCode !== 0) {
+			error(`Failed to install skill: ${skillName}`);
+			// Show stderr on failure for debugging
+			if (stderr.trim()) {
+				console.error(stderr);
+			}
+			process.exit(1);
+		}
+
+		success(`Installed ${skillName}`);
+	} else {
+		info(`Skill ${skillName} already installed`);
+	}
+
+	// 3. Get preferred agent
+	const preferred = await getPreferredLaunchAgent();
+	if (!preferred) {
+		error("No agent configured");
+		info("Run: jack init");
+		process.exit(1);
+	}
+
+	// 4. Launch agent with skill command
+	const agentName = preferred.definition.name;
+	console.log("");
+	info(`Launching ${agentName} with /${skillName}...`);
+
+	const launchWithSkill: AgentLaunchConfig = {
+		...preferred.launch,
+		args: [...(preferred.launch.args || []), `/${skillName}`],
+	};
+
+	const result = await launchAgent(launchWithSkill, projectDir);
+
+	if (!result.success) {
+		error(`Failed to launch ${agentName}`);
+		if (result.error) {
+			info(result.error);
+		}
+		process.exit(1);
+	}
+}
+
+async function listSkills(): Promise<void> {
+	const projectDir = process.cwd();
+	const skillsDir = join(projectDir, ".claude/skills");
+	const availableSkills = await fetchAvailableSkills();
+
+	if (!existsSync(skillsDir)) {
+		info("No skills installed in this project.");
+		console.log("");
+		info("Run 'jack skills run <name>' to install and use a skill.");
+		if (availableSkills.length > 0) {
+			console.log("");
+			console.log("Available skills:");
+			for (const skill of availableSkills) {
+				console.log(`  ${skill.name.padEnd(16)} ${skill.description}`);
+			}
+		} else {
+			const err = getFetchError();
+			if (err) {
+				console.log("");
+				info(`Could not load skills catalog: ${err}`);
+			}
+		}
+		return;
+	}
+
+	// List directories in .claude/skills/
+	const entries = await readdir(skillsDir, { withFileTypes: true });
+	const installedSkills = entries.filter((e) => e.isSymbolicLink() || e.isDirectory());
+
+	if (installedSkills.length === 0) {
+		info("No skills installed in this project.");
+		console.log("");
+		info("Run 'jack skills run <name>' to install and use a skill.");
+		return;
+	}
+
+	console.log("");
+	info("Installed skills (project):");
+	for (const skill of installedSkills) {
+		const desc = availableSkills.find((s) => s.name === skill.name)?.description ?? "";
+		item(`${skill.name.padEnd(16)} ${desc}`);
+	}
+	console.log("");
+	info("Run 'jack skills run <name>' to use a skill.");
+}
+
+async function removeSkill(skillName?: string): Promise<void> {
+	if (!skillName) {
+		error("Missing skill name");
+		info("Usage: jack skills remove <name>");
+		process.exit(1);
+	}
+
+	const projectDir = process.cwd();
+
+	// Remove from all agent directories
+	const dirs = [".agents/skills", ".claude/skills", ".codex/skills", ".cursor/skills"];
+	let removed = false;
+
+	for (const dir of dirs) {
+		const path = join(projectDir, dir, skillName);
+		if (existsSync(path)) {
+			await rm(path, { recursive: true, force: true });
+			removed = true;
+		}
+	}
+
+	if (removed) {
+		success(`Removed ${skillName}`);
+	} else {
+		info(`Skill ${skillName} not found in project`);
+	}
+}

package/src/commands/update.ts

@@ -3,7 +3,14 @@
  */
 
 import { debug } from "../lib/debug.ts";
+import { installMcpConfigsToAllApps } from "../lib/mcp-config.ts";
 import { error, info, success, warn } from "../lib/output.ts";
+import {
+	detectShell,
+	getRcFilePath,
+	isInstalled as isShellIntegrationInstalled,
+	update as updateShellIntegration,
+} from "../lib/shell-integration.ts";
 import {
 	checkForUpdate,
 	getCurrentVersion,
@@ -52,6 +59,30 @@ export default async function update(): Promise<void> {
 
 	if (result.success) {
 		success(`Updated to v${result.version ?? latestVersion}`);
+
+		// Repair MCP config on successful update (ensures new features work)
+		try {
+			const installedApps = await installMcpConfigsToAllApps();
+			if (installedApps.length > 0) {
+				info(`MCP config updated for: ${installedApps.join(", ")}`);
+			}
+		} catch {
+			// Non-critical - don't fail update if MCP repair fails
+			debug("MCP config repair failed (non-critical)");
+		}
+
+		try {
+			const shell = detectShell();
+			const rcFile = getRcFilePath(shell);
+			if (rcFile && isShellIntegrationInstalled(rcFile)) {
+				updateShellIntegration();
+				info("Shell integration updated");
+			} else if (rcFile && shell !== "unknown") {
+				info("Tip: 'jack init' enables auto-cd for jack new/cd");
+			}
+		} catch {
+			debug("Shell integration update failed");
+		}
 	} else {
 		error("Update failed");
 		if (result.error) {

package/src/commands/upgrade.ts

@@ -0,0 +1,14 @@
+/**
+ * jack upgrade - Show billing dashboard URL to upgrade plan
+ */
+
+import { info } from "../lib/output.ts";
+
+const BILLING_URL = "https://dash.getjack.org";
+
+export default async function upgrade(): Promise<void> {
+	console.error("");
+	info("Upgrade your plan at:");
+	console.error(`  ${BILLING_URL}`);
+	console.error("");
+}

package/src/index.ts

@@ -4,7 +4,7 @@ import pkg from "../package.json";
 import { enableDebug } from "./lib/debug.ts";
 import { isJackError } from "./lib/errors.ts";
 import { info, error as printError } from "./lib/output.ts";
-import { getEnvironmentProps, identify, shutdown, withTelemetry } from "./lib/telemetry.ts";
+import { identify, shutdown, withTelemetry } from "./lib/telemetry.ts";
 
 const cli = meow(
 	`
@@ -15,7 +15,7 @@ const cli = meow(
 
   Getting Started
     init                Set up jack (run once)
-    new [name]          Create and deploy a project
+    new <name> [path]   Create and deploy a project
     vibe "<phrase>"     Create from an idea
     ship                Push changes to production
 
@@ -45,6 +45,8 @@ const cli = meow(
   Advanced
     agents              Manage AI agent configs
     secrets             Manage project secrets
+    domain              Manage custom domains
+    skills              Install and run agent skills
     services            Manage databases
     mcp                 MCP server for AI agents
     telemetry           Usage data settings
@@ -176,6 +178,9 @@ const cli = meow(
 			db: {
 				type: "string",
 			},
+			sort: {
+				type: "string",
+			},
 		},
 	},
 );
@@ -187,15 +192,37 @@ if (cli.flags.debug) {
 
 const [command, ...args] = cli.input;
 
-// Identify user properties for telemetry
-identify({
-	jack_version: pkg.version,
-	os: process.platform,
-	arch: process.arch,
-	node_version: process.version,
-	is_ci: !!process.env.CI,
-	...getEnvironmentProps(),
-});
+// Identify user properties for telemetry (dedupe to once per day)
+(async () => {
+	try {
+		const { getTelemetryConfig, saveTelemetryConfig } = await import("./lib/telemetry-config.ts");
+		const config = await getTelemetryConfig();
+		const today = new Date().toISOString().split("T")[0]; // "YYYY-MM-DD"
+
+		if (config.lastIdentifyDate === today) {
+			return; // Already identified today
+		}
+
+		identify({
+			jack_version: pkg.version,
+			os: process.platform,
+			arch: process.arch,
+			node_version: process.version,
+		});
+
+		// Update lastIdentifyDate
+		config.lastIdentifyDate = today;
+		await saveTelemetryConfig(config);
+	} catch {
+		// Fallback: just call identify without deduping
+		identify({
+			jack_version: pkg.version,
+			os: process.platform,
+			arch: process.arch,
+			node_version: process.version,
+		});
+	}
+})();
 
 // Start non-blocking version check (skip for update command, CI, and help)
 const skipVersionCheck =
@@ -221,7 +248,7 @@ try {
 		case "new":
 		case "in": {
 			const { default: newProject } = await import("./commands/new.ts");
-			await withTelemetry("new", newProject)(args[0], {
+			await withTelemetry("new", newProject)(args[0], args[1], {
 				template: cli.flags.template,
 				intent: cli.flags.message,
 				managed: cli.flags.managed,
@@ -235,7 +262,7 @@ try {
 		case "vibe": {
 			const { default: newProject } = await import("./commands/new.ts");
 			// vibe always treats first arg as intent phrase
-			await withTelemetry("vibe", newProject)(undefined, {
+			await withTelemetry("vibe", newProject)(undefined, undefined, {
 				template: cli.flags.template,
 				intent: args[0],
 			});
@@ -269,14 +296,14 @@ try {
 		}
 		case "agents": {
 			const { default: agents } = await import("./commands/agents.ts");
-			await withTelemetry("agents", agents)(args[0], args.slice(1), {
+			await withTelemetry("agents", agents, { subcommand: args[0] })(args[0], args.slice(1), {
 				project: cli.flags.project,
 			});
 			break;
 		}
 		case "tag": {
 			const { default: tag } = await import("./commands/tag.ts");
-			await withTelemetry("tag", tag)(args[0], args.slice(1));
+			await withTelemetry("tag", tag, { subcommand: args[0] })(args[0], args.slice(1));
 			break;
 		}
 		case "sync": {
@@ -296,6 +323,16 @@ try {
 			await withTelemetry("clone", clone)(args[0], { as: cli.flags.as });
 			break;
 		}
+		case "cd": {
+			const { default: cd } = await import("./commands/cd.ts");
+			await withTelemetry("cd", cd)(args[0]);
+			break;
+		}
+		case "shell-init": {
+			const { default: shellInit } = await import("./commands/shell-init.ts");
+			await shellInit();
+			break;
+		}
 		case "telemetry": {
 			const { default: telemetry } = await import("./commands/telemetry.ts");
 			await telemetry(args[0]);
@@ -337,7 +374,7 @@ try {
 			if (cli.flags.cloud) projectArgs.push("--cloud");
 			if (cli.flags.yes) projectArgs.push("--yes");
 			if (cli.flags.force) projectArgs.push("--force");
-			await withTelemetry("projects", projects)(args[0], projectArgs);
+			await withTelemetry("projects", projects, { subcommand: args[0] })(args[0], projectArgs);
 			break;
 		}
 		case "services": {
@@ -346,18 +383,32 @@ try {
 			if (cli.flags.write) serviceArgs.push("--write");
 			if (cli.flags.file) serviceArgs.push("--file", cli.flags.file);
 			if (cli.flags.db) serviceArgs.push("--db", cli.flags.db);
-			await withTelemetry("services", services)(args[0], serviceArgs, {
+
+			// Build subcommand: "db create", "storage list", or just "db"
+			const subcommand = args[0] ? (args[1] ? `${args[0]} ${args[1]}` : args[0]) : undefined;
+
+			await withTelemetry("services", services, { subcommand })(args[0], serviceArgs, {
 				project: cli.flags.project,
 			});
 			break;
 		}
 		case "secrets": {
 			const { default: secrets } = await import("./commands/secrets.ts");
-			await withTelemetry("secrets", secrets)(args[0], args.slice(1), {
+			await withTelemetry("secrets", secrets, { subcommand: args[0] })(args[0], args.slice(1), {
 				project: cli.flags.project,
 			});
 			break;
 		}
+		case "domain": {
+			const { default: domain } = await import("./commands/domain.ts");
+			await withTelemetry("domain", domain, { subcommand: args[0] })(args[0], args.slice(1));
+			break;
+		}
+		case "domains": {
+			const { default: domains } = await import("./commands/domains.ts");
+			await withTelemetry("domains", domains)({ json: cli.flags.json });
+			break;
+		}
 		case "mcp": {
 			const { default: mcp } = await import("./commands/mcp.ts");
 			// Note: Don't use withTelemetry wrapper for MCP serve - it runs indefinitely
@@ -367,23 +418,28 @@ try {
 		case "ls": {
 			const { default: projects } = await import("./commands/projects.ts");
 			const lsArgs: string[] = [];
+			// First positional arg after 'ls' is the optional filter
+			if (args[0] && !args[0].startsWith("--")) {
+				lsArgs.push(args[0]);
+			}
 			if (cli.flags.local) lsArgs.push("--local");
 			if (cli.flags.deployed) lsArgs.push("--deployed");
 			if (cli.flags.cloud) lsArgs.push("--cloud");
 			if (cli.flags.all) lsArgs.push("--all");
 			if (cli.flags.json) lsArgs.push("--json");
 			if (cli.flags.status) lsArgs.push("--status", cli.flags.status);
+			if (cli.flags.sort) lsArgs.push("--sort", cli.flags.sort);
 			if (cli.flags.tag) {
 				for (const t of cli.flags.tag) {
 					lsArgs.push("--tag", t);
 				}
 			}
-			await withTelemetry("projects", projects)("list", lsArgs);
+			await withTelemetry("projects", projects, { subcommand: "list" })("list", lsArgs);
 			break;
 		}
 		case "info": {
 			const { default: projects } = await import("./commands/projects.ts");
-			await withTelemetry("projects", projects)("info", args);
+			await withTelemetry("projects", projects, { subcommand: "info" })("info", args);
 			break;
 		}
 		case "login": {
@@ -401,12 +457,16 @@ try {
 			await withTelemetry("whoami", whoami)();
 			break;
 		}
-		case "update":
-		case "upgrade": {
+		case "update": {
 			const { default: update } = await import("./commands/update.ts");
 			await withTelemetry("update", update)();
 			break;
 		}
+		case "upgrade": {
+			const { default: upgrade } = await import("./commands/upgrade.ts");
+			await withTelemetry("upgrade", upgrade)();
+			break;
+		}
 		case "feedback": {
 			const { default: feedback } = await import("./commands/feedback.ts");
 			await withTelemetry("feedback", feedback)();
@@ -428,8 +488,40 @@ try {
 			await withTelemetry("unlink", unlink)();
 			break;
 		}
-		default:
-			cli.showHelp(command ? 1 : 0);
+		case "skillz":
+		case "skills": {
+			const { default: skills } = await import("./commands/skills.ts");
+			await withTelemetry("skills", skills, { subcommand: args[0] })(args[0], args.slice(1));
+			break;
+		}
+		default: {
+			// No command provided - show interactive picker if TTY, else help
+			if (!command) {
+				const { isTTY, requireTTY, pickProject } = await import("./lib/picker.ts");
+
+				if (!isTTY()) {
+					// Non-interactive: show help
+					cli.showHelp(0);
+					break;
+				}
+
+				requireTTY();
+
+				const result = await pickProject();
+
+				if (result.action === "cancel") {
+					break;
+				}
+
+				// User selected a project - run cd command
+				const { default: cd } = await import("./commands/cd.ts");
+				await withTelemetry("cd", cd)(result.project.name);
+			} else {
+				// Unknown command
+				cli.showHelp(1);
+			}
+			break;
+		}
 	}
 
 	// Show update notification if available (non-blocking check completed)

package/src/lib/agent-integration.ts

@@ -147,8 +147,7 @@ async function appendJackMdReferences(projectPath: string): Promise<string[]> {
 
 			if (headingMatch && headingMatch.index !== undefined) {
 				const insertPos = headingMatch.index + headingMatch[0].length;
-				newContent =
-					content.slice(0, insertPos) + "\n" + referenceBlock + content.slice(insertPos);
+				newContent = content.slice(0, insertPos) + "\n" + referenceBlock + content.slice(insertPos);
 			} else {
 				newContent = referenceBlock + content;
 			}

package/src/lib/agents.ts

@@ -6,8 +6,8 @@ import { type AgentConfig, type AgentLaunchConfig, readConfig, writeConfig } fro
 import { debug, isDebug } from "./debug.ts";
 import { restoreTty } from "./tty";
 
-// Re-export AgentConfig for consumers
-export type { AgentConfig } from "./config.ts";
+// Re-export types for consumers
+export type { AgentConfig, AgentLaunchConfig } from "./config.ts";
 
 /**
  * Project file to generate for an agent

package/src/lib/auth/login-flow.ts

@@ -2,13 +2,13 @@
  * Shared login flow for CLI and programmatic use
  */
 import { text } from "@clack/prompts";
-import { isCancel } from "../hooks.ts";
 import {
 	checkUsernameAvailable,
 	getCurrentUserProfile,
 	registerUser,
 	setUsername,
 } from "../control-plane.ts";
+import { isCancel } from "../hooks.ts";
 import { promptSelect } from "../hooks.ts";
 import { celebrate, error, info, spinner, success, warn } from "../output.ts";
 import { identifyUser } from "../telemetry.ts";