@zokizuan/satori-cli 0.1.1

package/dist/install.js

@@ -0,0 +1,333 @@
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import { CliError } from "./errors.js";
+import { resolveManagedPackageSpecifier } from "./managed-package.js";
+const MANAGED_BLOCK_START = "# >>> satori-cli managed satori start >>>";
+const MANAGED_BLOCK_END = "# <<< satori-cli managed satori end <<<";
+const OWNED_SKILL_DIRS = ["satori-search", "satori-navigation", "satori-indexing"];
+const MANAGED_TIMEOUT_MS = 180000;
+function resolveDefaultSkillAssetRoot() {
+    const currentFile = fileURLToPath(import.meta.url);
+    return path.resolve(path.dirname(currentFile), "..", "assets", "skills");
+}
+function resolveDefaultPackageSpecifier() {
+    try {
+        return resolveManagedPackageSpecifier();
+    }
+    catch {
+        // Fall through to hard failure below.
+    }
+    throw new CliError("E_USAGE", "Unable to resolve the installed Satori package version for CLI install.", 2);
+}
+function resolveClientTargets(homeDir) {
+    return [
+        {
+            client: "codex",
+            configPath: path.join(homeDir, ".codex", "config.toml"),
+            skillsPath: path.join(homeDir, ".codex", "skills"),
+        },
+        {
+            client: "claude",
+            configPath: path.join(homeDir, ".claude", "settings.json"),
+            skillsPath: path.join(homeDir, ".claude", "skills"),
+        },
+    ];
+}
+function selectTargets(homeDir, client) {
+    const targets = resolveClientTargets(homeDir);
+    if (client === "all") {
+        return targets;
+    }
+    return targets.filter((target) => target.client === client);
+}
+function ensureParentDir(filePath) {
+    fs.mkdirSync(path.dirname(filePath), { recursive: true });
+}
+function ensureDir(dirPath) {
+    fs.mkdirSync(dirPath, { recursive: true });
+}
+function readTextIfExists(filePath) {
+    if (!fs.existsSync(filePath)) {
+        return null;
+    }
+    return fs.readFileSync(filePath, "utf8");
+}
+function normalizeTrailingNewline(value) {
+    return value.endsWith("\n") ? value : `${value}\n`;
+}
+function escapeRegExp(value) {
+    return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function buildCodexManagedBlock(packageSpecifier) {
+    return [
+        MANAGED_BLOCK_START,
+        "[mcp_servers.satori]",
+        'command = "npx"',
+        `args = ["-y", "${packageSpecifier}"]`,
+        `startup_timeout_ms = ${MANAGED_TIMEOUT_MS}`,
+        MANAGED_BLOCK_END,
+        "",
+    ].join("\n");
+}
+function codexHasUnmanagedSatoriSection(content) {
+    if (!content.includes("[mcp_servers.satori]")) {
+        return false;
+    }
+    return !(content.includes(MANAGED_BLOCK_START) && content.includes(MANAGED_BLOCK_END));
+}
+function prepareCodexInstall(filePath, packageSpecifier) {
+    const current = readTextIfExists(filePath) ?? "";
+    if (codexHasUnmanagedSatoriSection(current)) {
+        throw new CliError("E_USAGE", `Refusing to overwrite unmanaged Satori config in ${filePath}. Remove [mcp_servers.satori] manually or convert it to the managed block first.`, 2);
+    }
+    const managedBlock = buildCodexManagedBlock(packageSpecifier);
+    let next = current;
+    if (current.includes(MANAGED_BLOCK_START) && current.includes(MANAGED_BLOCK_END)) {
+        next = current.replace(new RegExp(`${escapeRegExp(MANAGED_BLOCK_START)}[\\s\\S]*?${escapeRegExp(MANAGED_BLOCK_END)}\\n?`, "m"), managedBlock);
+    }
+    else if (current.trim().length === 0) {
+        next = managedBlock;
+    }
+    else {
+        next = `${normalizeTrailingNewline(current)}\n${managedBlock}`;
+    }
+    return {
+        changed: next !== current,
+        apply: () => {
+            if (next === current) {
+                return;
+            }
+            ensureParentDir(filePath);
+            fs.writeFileSync(filePath, next, "utf8");
+        },
+    };
+}
+function prepareCodexUninstall(filePath) {
+    const current = readTextIfExists(filePath);
+    if (!current) {
+        return { changed: false, apply: () => { } };
+    }
+    if (codexHasUnmanagedSatoriSection(current)) {
+        throw new CliError("E_USAGE", `Refusing to remove unmanaged Satori config in ${filePath}. Remove [mcp_servers.satori] manually instead.`, 2);
+    }
+    if (!current.includes(MANAGED_BLOCK_START) || !current.includes(MANAGED_BLOCK_END)) {
+        return { changed: false, apply: () => { } };
+    }
+    const next = current
+        .replace(new RegExp(`\\n?${escapeRegExp(MANAGED_BLOCK_START)}[\\s\\S]*?${escapeRegExp(MANAGED_BLOCK_END)}\\n?`, "m"), "\n")
+        .replace(/\n{3,}/g, "\n\n")
+        .replace(/^\n+/, "");
+    return {
+        changed: next !== current,
+        apply: () => {
+            if (next === current) {
+                return;
+            }
+            fs.writeFileSync(filePath, next, "utf8");
+        },
+    };
+}
+function parseJsonObject(filePath) {
+    const current = readTextIfExists(filePath);
+    if (!current) {
+        return {};
+    }
+    let parsed;
+    try {
+        parsed = JSON.parse(current);
+    }
+    catch (error) {
+        throw new CliError("E_USAGE", `Failed to parse JSON config at ${filePath}: ${error.message}`, 2);
+    }
+    if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+        throw new CliError("E_USAGE", `Expected top-level JSON object in ${filePath}.`, 2);
+    }
+    return parsed;
+}
+function buildClaudeServerConfig(packageSpecifier) {
+    return {
+        command: "npx",
+        args: ["-y", packageSpecifier],
+        timeout: MANAGED_TIMEOUT_MS,
+    };
+}
+function isManagedPackageSpecifier(value) {
+    return typeof value === "string" && /^@zokizuan\/satori-mcp@.+$/.test(value);
+}
+function isManagedClaudeEntry(value) {
+    if (!value || typeof value !== "object" || Array.isArray(value)) {
+        return false;
+    }
+    const entry = value;
+    if (entry.command !== "npx") {
+        return false;
+    }
+    if (entry.timeout !== MANAGED_TIMEOUT_MS) {
+        return false;
+    }
+    if (!Array.isArray(entry.args)) {
+        return false;
+    }
+    if (entry.args.length === 2) {
+        return entry.args[0] === "-y" && isManagedPackageSpecifier(entry.args[1]);
+    }
+    if (entry.args.length === 4) {
+        return entry.args[0] === "-y"
+            && entry.args[1] === "--package"
+            && isManagedPackageSpecifier(entry.args[2])
+            && entry.args[3] === "satori";
+    }
+    return false;
+}
+function prepareClaudeInstall(filePath, packageSpecifier) {
+    const currentObject = parseJsonObject(filePath);
+    const currentSerialized = JSON.stringify(currentObject);
+    const desiredServer = buildClaudeServerConfig(packageSpecifier);
+    const mcpServersValue = currentObject.mcpServers;
+    let mcpServers;
+    if (mcpServersValue === undefined) {
+        mcpServers = {};
+    }
+    else if (mcpServersValue && typeof mcpServersValue === "object" && !Array.isArray(mcpServersValue)) {
+        mcpServers = { ...mcpServersValue };
+    }
+    else {
+        throw new CliError("E_USAGE", `Expected mcpServers to be an object in ${filePath}.`, 2);
+    }
+    const existingSatori = mcpServers.satori;
+    if (existingSatori !== undefined && !isManagedClaudeEntry(existingSatori)) {
+        throw new CliError("E_USAGE", `Refusing to overwrite unmanaged Satori config in ${filePath}. Remove mcpServers.satori manually or align it to the managed npx form first.`, 2);
+    }
+    mcpServers.satori = {
+        ...existingSatori,
+        ...desiredServer,
+    };
+    currentObject.mcpServers = mcpServers;
+    const next = `${JSON.stringify(currentObject, null, 2)}\n`;
+    return {
+        changed: JSON.stringify(currentObject) !== currentSerialized,
+        apply: () => {
+            if (JSON.stringify(currentObject) === currentSerialized) {
+                return;
+            }
+            ensureParentDir(filePath);
+            fs.writeFileSync(filePath, next, "utf8");
+        },
+    };
+}
+function prepareClaudeUninstall(filePath) {
+    const currentObject = parseJsonObject(filePath);
+    const mcpServersValue = currentObject.mcpServers;
+    if (!mcpServersValue || typeof mcpServersValue !== "object" || Array.isArray(mcpServersValue)) {
+        return { changed: false, apply: () => { } };
+    }
+    const mcpServers = { ...mcpServersValue };
+    if (!Object.prototype.hasOwnProperty.call(mcpServers, "satori")) {
+        return { changed: false, apply: () => { } };
+    }
+    if (!isManagedClaudeEntry(mcpServers.satori)) {
+        throw new CliError("E_USAGE", `Refusing to remove unmanaged Satori config in ${filePath}. Remove mcpServers.satori manually instead.`, 2);
+    }
+    delete mcpServers.satori;
+    if (Object.keys(mcpServers).length === 0) {
+        delete currentObject.mcpServers;
+    }
+    else {
+        currentObject.mcpServers = mcpServers;
+    }
+    const next = `${JSON.stringify(currentObject, null, 2)}\n`;
+    return {
+        changed: true,
+        apply: () => {
+            fs.writeFileSync(filePath, next, "utf8");
+        },
+    };
+}
+function prepareSkillInstall(skillsPath, skillAssetRoot) {
+    const writes = [];
+    let changed = false;
+    for (const skillDirName of OWNED_SKILL_DIRS) {
+        const sourceFile = path.join(skillAssetRoot, skillDirName, "SKILL.md");
+        if (!fs.existsSync(sourceFile)) {
+            throw new CliError("E_USAGE", `Missing packaged skill asset: ${sourceFile}`, 2);
+        }
+        const content = fs.readFileSync(sourceFile, "utf8");
+        const destinationDir = path.join(skillsPath, skillDirName);
+        const destinationFile = path.join(destinationDir, "SKILL.md");
+        if (readTextIfExists(destinationFile) !== content) {
+            changed = true;
+            writes.push({ destinationDir, destinationFile, content });
+        }
+    }
+    return {
+        changed,
+        apply: () => {
+            for (const write of writes) {
+                ensureDir(write.destinationDir);
+                fs.writeFileSync(write.destinationFile, write.content, "utf8");
+            }
+        },
+    };
+}
+function prepareSkillRemoval(skillsPath) {
+    const removals = OWNED_SKILL_DIRS
+        .map((skillDirName) => path.join(skillsPath, skillDirName))
+        .filter((destinationDir) => fs.existsSync(destinationDir));
+    return {
+        changed: removals.length > 0,
+        apply: () => {
+            for (const destinationDir of removals) {
+                fs.rmSync(destinationDir, { recursive: true, force: true });
+            }
+        },
+    };
+}
+function prepareMutation(target, command, packageSpecifier, skillAssetRoot) {
+    const configMutation = command.kind === "install"
+        ? target.client === "codex"
+            ? prepareCodexInstall(target.configPath, packageSpecifier)
+            : prepareClaudeInstall(target.configPath, packageSpecifier)
+        : target.client === "codex"
+            ? prepareCodexUninstall(target.configPath)
+            : prepareClaudeUninstall(target.configPath);
+    const skillsMutation = command.kind === "install"
+        ? prepareSkillInstall(target.skillsPath, skillAssetRoot)
+        : prepareSkillRemoval(target.skillsPath);
+    return {
+        target,
+        configChanged: configMutation.changed,
+        skillsChanged: skillsMutation.changed,
+        apply: () => {
+            configMutation.apply();
+            skillsMutation.apply();
+        },
+    };
+}
+export function executeInstallCommand(command, options = {}) {
+    const homeDir = options.homeDir ?? os.homedir();
+    const packageSpecifier = options.packageSpecifier ?? resolveDefaultPackageSpecifier();
+    const skillAssetRoot = options.skillAssetRoot ?? resolveDefaultSkillAssetRoot();
+    const prepared = selectTargets(homeDir, command.client).map((target) => (prepareMutation(target, command, packageSpecifier, skillAssetRoot)));
+    if (!command.dryRun) {
+        for (const mutation of prepared) {
+            mutation.apply();
+        }
+    }
+    return {
+        action: command.kind,
+        client: command.client,
+        dryRun: command.dryRun,
+        results: prepared.map((mutation) => ({
+            client: mutation.target.client,
+            configPath: mutation.target.configPath,
+            skillsPath: mutation.target.skillsPath,
+            configChanged: mutation.configChanged,
+            skillsChanged: mutation.skillsChanged,
+            status: mutation.configChanged || mutation.skillsChanged ? "updated" : "unchanged",
+            dryRun: command.dryRun,
+        })),
+    };
+}
+//# sourceMappingURL=install.js.map

package/dist/managed-package.d.ts

@@ -0,0 +1,11 @@
+interface ManagedPackageJsonShape {
+    name?: unknown;
+    version?: unknown;
+    main?: unknown;
+}
+export declare function resolveManagedPackageJsonPath(): string;
+export declare function resolveManagedPackageRoot(): string;
+export declare function readManagedPackageJson(): Required<Pick<ManagedPackageJsonShape, "name" | "version">> & ManagedPackageJsonShape;
+export declare function resolveManagedPackageSpecifier(): string;
+export {};
+//# sourceMappingURL=managed-package.d.ts.map

package/dist/managed-package.js

@@ -0,0 +1,39 @@
+import fs from "node:fs";
+import path from "node:path";
+import { createRequire } from "node:module";
+import { fileURLToPath } from "node:url";
+import { CliError } from "./errors.js";
+const MANAGED_PACKAGE_NAME = "@zokizuan/satori-mcp";
+const require = createRequire(import.meta.url);
+function fallbackManagedPackageJsonPath() {
+    const currentFile = fileURLToPath(import.meta.url);
+    return path.resolve(path.dirname(currentFile), "..", "..", "mcp", "package.json");
+}
+export function resolveManagedPackageJsonPath() {
+    try {
+        return require.resolve(`${MANAGED_PACKAGE_NAME}/package.json`);
+    }
+    catch {
+        const fallbackPath = fallbackManagedPackageJsonPath();
+        if (fs.existsSync(fallbackPath)) {
+            return fallbackPath;
+        }
+        throw new CliError("E_USAGE", `Unable to resolve installed package metadata for ${MANAGED_PACKAGE_NAME}. Install ${MANAGED_PACKAGE_NAME} or use a local dev server config instead.`, 2);
+    }
+}
+export function resolveManagedPackageRoot() {
+    return path.dirname(resolveManagedPackageJsonPath());
+}
+export function readManagedPackageJson() {
+    const packageJsonPath = resolveManagedPackageJsonPath();
+    const parsed = JSON.parse(fs.readFileSync(packageJsonPath, "utf8"));
+    if (typeof parsed.name !== "string" || typeof parsed.version !== "string") {
+        throw new CliError("E_USAGE", `Unable to read valid package metadata from ${packageJsonPath}.`, 2);
+    }
+    return parsed;
+}
+export function resolveManagedPackageSpecifier() {
+    const pkg = readManagedPackageJson();
+    return `${pkg.name}@${pkg.version}`;
+}
+//# sourceMappingURL=managed-package.js.map

package/dist/package-installability.d.ts

@@ -0,0 +1,14 @@
+import { execFileSync } from "node:child_process";
+type ExecFileSyncLike = typeof execFileSync;
+export interface PackageInstallabilityOptions {
+    packageJsonPath?: string;
+    execFileSyncImpl?: ExecFileSyncLike;
+}
+export interface ReleaseSmokeOptions extends PackageInstallabilityOptions {
+    packageRoot?: string;
+    tempDir?: string;
+}
+export declare function verifyManagedPackageInstallability(options?: PackageInstallabilityOptions): string;
+export declare function runPublishedPackageReleaseSmoke(options?: ReleaseSmokeOptions): void;
+export {};
+//# sourceMappingURL=package-installability.d.ts.map

package/dist/package-installability.js

@@ -0,0 +1,123 @@
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { execFileSync } from "node:child_process";
+import { CliError } from "./errors.js";
+import { resolveManagedPackageJsonPath } from "./managed-package.js";
+function resolveDefaultPackageJsonPath() {
+    return resolveManagedPackageJsonPath();
+}
+function readPackageJson(packageJsonPath) {
+    return JSON.parse(fs.readFileSync(packageJsonPath, "utf8"));
+}
+function looksLikeExactVersion(value) {
+    return /^\d+\.\d+\.\d+(?:[-+][0-9A-Za-z.-]+)?$/.test(value);
+}
+function npmOutput(error) {
+    if (!(error instanceof Error)) {
+        return String(error);
+    }
+    const stdout = "stdout" in error && typeof error.stdout === "string"
+        ? error.stdout
+        : "";
+    const stderr = "stderr" in error && typeof error.stderr === "string"
+        ? error.stderr
+        : "";
+    return `${stdout}\n${stderr}\n${error.message}`.trim();
+}
+function resolveWorkspaceDependencyVersion(packageJsonPath, dependencyName) {
+    const packageRoot = path.dirname(packageJsonPath);
+    const repoRoot = path.resolve(packageRoot, "..", "..");
+    const packagesRoot = path.join(repoRoot, "packages");
+    if (!fs.existsSync(packagesRoot)) {
+        return null;
+    }
+    for (const entry of fs.readdirSync(packagesRoot, { withFileTypes: true })) {
+        if (!entry.isDirectory()) {
+            continue;
+        }
+        const candidatePath = path.join(packagesRoot, entry.name, "package.json");
+        if (!fs.existsSync(candidatePath)) {
+            continue;
+        }
+        const candidate = readPackageJson(candidatePath);
+        if (candidate.name === dependencyName && looksLikeExactVersion(candidate.version)) {
+            return candidate.version;
+        }
+    }
+    return null;
+}
+function assertPublishedVersion(packageName, version, ownerPackageName, ownerPackageVersion, execImpl, relation) {
+    try {
+        execImpl("npm", ["view", `${packageName}@${version}`, "version", "--json"], {
+            encoding: "utf8",
+            stdio: ["ignore", "pipe", "pipe"],
+        });
+    }
+    catch (error) {
+        if (relation === "self") {
+            throw new CliError("E_USAGE", `Cannot install ${ownerPackageName}@${ownerPackageVersion} because that package version is not published on npm. Publish ${ownerPackageName}@${ownerPackageVersion} first or use a local dev server config instead.`, 2);
+        }
+        throw new CliError("E_USAGE", `Cannot install ${ownerPackageName}@${ownerPackageVersion} because required dependency ${packageName}@${version} is not published on npm. Publish ${packageName}@${version} first, then rerun satori-cli install.`, 2);
+    }
+}
+export function verifyManagedPackageInstallability(options = {}) {
+    const packageJsonPath = options.packageJsonPath ?? resolveDefaultPackageJsonPath();
+    const execImpl = options.execFileSyncImpl ?? execFileSync;
+    const pkg = readPackageJson(packageJsonPath);
+    const packageSpecifier = `${pkg.name}@${pkg.version}`;
+    assertPublishedVersion(pkg.name, pkg.version, pkg.name, pkg.version, execImpl, "self");
+    for (const [dependencyName, rawDependencyVersion] of Object.entries(pkg.dependencies ?? {})) {
+        const dependencyVersion = looksLikeExactVersion(rawDependencyVersion)
+            ? rawDependencyVersion
+            : rawDependencyVersion.startsWith("workspace:")
+                ? resolveWorkspaceDependencyVersion(packageJsonPath, dependencyName)
+                : null;
+        if (!dependencyVersion) {
+            continue;
+        }
+        assertPublishedVersion(dependencyName, dependencyVersion, pkg.name, pkg.version, execImpl, "dependency");
+    }
+    return packageSpecifier;
+}
+export function runPublishedPackageReleaseSmoke(options = {}) {
+    const packageJsonPath = options.packageJsonPath ?? resolveDefaultPackageJsonPath();
+    const packageRoot = options.packageRoot ?? path.dirname(packageJsonPath);
+    const tempDir = options.tempDir ?? os.tmpdir();
+    const execImpl = options.execFileSyncImpl ?? execFileSync;
+    verifyManagedPackageInstallability({ packageJsonPath, execFileSyncImpl: execImpl });
+    const smokePackDir = fs.mkdtempSync(path.join(tempDir, "satori-release-smoke-"));
+    const smokeExecDir = fs.mkdtempSync(path.join(tempDir, "satori-release-exec-"));
+    const beforeFiles = new Set(fs.readdirSync(smokePackDir));
+    execImpl("pnpm", ["pack", "--pack-destination", smokePackDir], {
+        cwd: packageRoot,
+        encoding: "utf8",
+        stdio: ["ignore", "pipe", "pipe"],
+    });
+    const tarballName = fs.readdirSync(smokePackDir).find((entry) => entry.endsWith(".tgz") && !beforeFiles.has(entry));
+    if (!tarballName) {
+        throw new CliError("E_USAGE", "Release smoke failed: pnpm pack did not produce a tarball.", 2);
+    }
+    const tarballPath = path.join(smokePackDir, tarballName);
+    try {
+        execImpl("npm", ["exec", "--yes", "--package", tarballPath, "--", "satori", "--help"], {
+            cwd: smokeExecDir,
+            encoding: "utf8",
+            env: {
+                ...process.env,
+                npm_config_package_lock: "false",
+            },
+            stdio: ["ignore", "pipe", "pipe"],
+        });
+    }
+    catch (error) {
+        const output = npmOutput(error);
+        const pkg = readPackageJson(packageJsonPath);
+        throw new CliError("E_USAGE", `Release smoke failed for ${pkg.name}@${pkg.version}. The packed tarball did not start via 'npm exec --yes --package <tarball> -- satori --help'. ${output}`, 2);
+    }
+    finally {
+        fs.rmSync(smokePackDir, { recursive: true, force: true });
+        fs.rmSync(smokeExecDir, { recursive: true, force: true });
+    }
+}
+//# sourceMappingURL=package-installability.js.map

package/dist/resolve-server-entry.d.ts

@@ -0,0 +1,2 @@
+export declare function resolveServerEntryPath(): string;
+//# sourceMappingURL=resolve-server-entry.d.ts.map

package/dist/resolve-server-entry.js

@@ -0,0 +1,17 @@
+import fs from "node:fs";
+import path from "node:path";
+import { readManagedPackageJson, resolveManagedPackageRoot } from "./managed-package.js";
+export function resolveServerEntryPath() {
+    const packageRoot = resolveManagedPackageRoot();
+    const pkg = readManagedPackageJson();
+    const jsEntry = path.resolve(packageRoot, typeof pkg.main === "string" ? pkg.main : "dist/index.js");
+    if (fs.existsSync(jsEntry)) {
+        return jsEntry;
+    }
+    const tsEntry = path.resolve(packageRoot, "src", "index.ts");
+    if (fs.existsSync(tsEntry)) {
+        return tsEntry;
+    }
+    return jsEntry;
+}
+//# sourceMappingURL=resolve-server-entry.js.map

package/package.json

@@ -0,0 +1,52 @@
+{
+  "name": "@zokizuan/satori-cli",
+  "version": "0.1.1",
+  "description": "Shell CLI for Satori MCP installation and skill-based workflows",
+  "type": "module",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "bin": {
+    "satori-cli": "dist/index.js"
+  },
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.12.1",
+    "@zokizuan/satori-mcp": "4.4.1"
+  },
+  "devDependencies": {
+    "@types/node": "^20.0.0",
+    "tsx": "^4.19.4",
+    "typescript": "^5.0.0"
+  },
+  "files": [
+    "dist/**/*.js",
+    "dist/**/*.d.ts",
+    "assets/skills/**/*.md",
+    "README.md"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/ham-zax/satori.git",
+    "directory": "packages/cli"
+  },
+  "homepage": "https://github.com/ham-zax/satori",
+  "bugs": {
+    "url": "https://github.com/ham-zax/satori/issues"
+  },
+  "author": "Hamza (@ham-zax)",
+  "license": "MIT",
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "build": "pnpm clean && tsc --build --force && pnpm fix:bin-perms",
+    "dev": "tsx --watch src/index.ts",
+    "clean": "rimraf dist",
+    "lint": "eslint src --ext .ts",
+    "lint:fix": "eslint src --ext .ts --fix",
+    "typecheck": "tsc --noEmit",
+    "start": "tsx src/index.ts",
+    "release:smoke": "tsx scripts/release-smoke.ts",
+    "fix:bin-perms": "node -e \"const fs=require('fs');try{fs.chmodSync('dist/index.js',0o755);}catch(e){console.error(e);process.exit(1);}\"",
+    "test": "pnpm --filter @zokizuan/satori-mcp build:runtime && node --import tsx --test --test-concurrency=1 src/**/*.test.ts"
+  }
+}