charleszhou 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Anwith Telluri
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,75 @@
+# charleszhou
+
+Open Charles Zhou whenever Claude Code or Codex receives a new prompt.
+
+## Install
+
+```sh
+bun add -g charleszhou
+```
+
+Or run it directly:
+
+```sh
+bunx charleszhou show
+```
+
+## Usage
+
+Open the picture once:
+
+```sh
+charleszhou show
+```
+
+Install prompt-submit hooks for both Claude Code and Codex:
+
+```sh
+charleszhou install
+```
+
+Install only one integration:
+
+```sh
+charleszhou install --claude
+charleszhou install --codex
+```
+
+Remove the hooks:
+
+```sh
+charleszhou uninstall
+```
+
+## What It Changes
+
+`charleszhou install` adds a `UserPromptSubmit` command hook that runs:
+
+```sh
+charleszhou show --quiet
+```
+
+For Claude Code, it updates:
+
+```text
+~/.claude/settings.json
+```
+
+For Codex, it updates:
+
+```text
+~/.codex/hooks.json
+~/.codex/config.toml
+```
+
+Codex may ask you to review and trust the hook with `/hooks` the next time it starts. That is expected for new or changed Codex hooks.
+
+## Publish
+
+From this directory:
+
+```sh
+bun publish
+```
+
+The package includes the bundled image at `assets/charleszhou.png`.

package/bin/charleszhou.js

@@ -0,0 +1,302 @@
+#!/usr/bin/env node
+import { spawn } from "node:child_process";
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { homedir, platform } from "node:os";
+import { dirname, join, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+
+const packageRoot = resolve(dirname(fileURLToPath(import.meta.url)), "..");
+const imagePath = join(packageRoot, "assets", "charleszhou.png");
+const hookEvent = "UserPromptSubmit";
+
+const usage = `charleszhou
+
+Usage:
+  charleszhou show [--quiet]       Open the Charles Zhou image
+  charleszhou path                 Print the bundled image path
+  charleszhou install [targets]    Install Claude/Codex prompt hooks
+  charleszhou uninstall [targets]  Remove Claude/Codex prompt hooks
+
+Targets:
+  --claude                         Only update ~/.claude/settings.json
+  --codex                          Only update ~/.codex/hooks.json
+
+Examples:
+  bunx charleszhou show
+  bunx charleszhou install
+  bunx charleszhou uninstall --codex
+`;
+
+function quoteShell(value) {
+  return `"${value.replaceAll("\\", "\\\\").replaceAll('"', '\\"')}"`;
+}
+
+function hookCommand() {
+  return `${quoteShell(process.execPath)} ${quoteShell(fileURLToPath(import.meta.url))} show --quiet`;
+}
+
+function readJsonFile(filePath) {
+  if (!existsSync(filePath)) {
+    return {};
+  }
+
+  const source = readFileSync(filePath, "utf8").trim();
+
+  if (!source) {
+    return {};
+  }
+
+  return JSON.parse(source);
+}
+
+function writeJsonFile(filePath, value) {
+  mkdirSync(dirname(filePath), { recursive: true });
+  writeFileSync(filePath, `${JSON.stringify(value, null, 2)}\n`);
+}
+
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+function withCharlesHook(config, command) {
+  const next = isRecord(config) ? config : {};
+
+  if (!isRecord(next.hooks)) {
+    next.hooks = {};
+  }
+
+  const groups = Array.isArray(next.hooks[hookEvent]) ? next.hooks[hookEvent] : [];
+  next.hooks[hookEvent] = groups;
+
+  const alreadyInstalled = groups.some(
+    (group) =>
+      isRecord(group) &&
+      Array.isArray(group.hooks) &&
+      group.hooks.some(
+        (hook) =>
+          isRecord(hook) &&
+          typeof hook.command === "string" &&
+          hook.command.includes("charleszhou")
+      )
+  );
+
+  if (alreadyInstalled) {
+    return { changed: false, config: next };
+  }
+
+  groups.push({
+    hooks: [
+      {
+        type: "command",
+        command,
+        timeout: 5,
+      },
+    ],
+  });
+
+  return { changed: true, config: next };
+}
+
+function withoutCharlesHook(config) {
+  const next = isRecord(config) ? config : {};
+
+  if (!isRecord(next.hooks) || !Array.isArray(next.hooks[hookEvent])) {
+    return { changed: false, config: next };
+  }
+
+  const previousLength = next.hooks[hookEvent].length;
+  next.hooks[hookEvent] = next.hooks[hookEvent]
+    .map((group) => {
+      if (!isRecord(group) || !Array.isArray(group.hooks)) {
+        return group;
+      }
+
+      return {
+        ...group,
+        hooks: group.hooks.filter(
+          (hook) =>
+            !(
+              isRecord(hook) &&
+              typeof hook.command === "string" &&
+              hook.command.includes("charleszhou")
+            )
+        ),
+      };
+    })
+    .filter(
+      (group) =>
+        !(isRecord(group) && Array.isArray(group.hooks) && group.hooks.length === 0)
+    );
+
+  return {
+    changed: previousLength !== next.hooks[hookEvent].length,
+    config: next,
+  };
+}
+
+function enableCodexHooksFeature(configPath) {
+  const existing = existsSync(configPath) ? readFileSync(configPath, "utf8") : "";
+  const eol = existing.includes("\r\n") ? "\r\n" : "\n";
+  const lines = existing ? existing.split(/\r?\n/) : [];
+  const featureIndex = lines.findIndex((line) => /^\s*\[features\]\s*$/.test(line));
+
+  if (featureIndex === -1) {
+    const prefix = existing && !existing.endsWith(eol) ? eol : "";
+    const next = `${existing}${prefix}[features]${eol}hooks = true${eol}`;
+    mkdirSync(dirname(configPath), { recursive: true });
+    writeFileSync(configPath, next);
+    return true;
+  }
+
+  const nextSectionIndex = lines.findIndex(
+    (line, index) => index > featureIndex && /^\s*\[[^\]]+\]\s*$/.test(line)
+  );
+  const endIndex = nextSectionIndex === -1 ? lines.length : nextSectionIndex;
+  const hooksIndex = lines.findIndex(
+    (line, index) =>
+      index > featureIndex && index < endIndex && /^\s*hooks\s*=/.test(line)
+  );
+
+  if (hooksIndex !== -1) {
+    if (/^\s*hooks\s*=\s*true\s*$/.test(lines[hooksIndex])) {
+      return false;
+    }
+
+    lines[hooksIndex] = "hooks = true";
+  } else {
+    lines.splice(featureIndex + 1, 0, "hooks = true");
+  }
+
+  mkdirSync(dirname(configPath), { recursive: true });
+  writeFileSync(configPath, lines.join(eol));
+  return true;
+}
+
+function selectedTargets(args) {
+  const wantsClaude = args.includes("--claude");
+  const wantsCodex = args.includes("--codex");
+
+  if (!(wantsClaude || wantsCodex)) {
+    return { claude: true, codex: true };
+  }
+
+  return { claude: wantsClaude, codex: wantsCodex };
+}
+
+function updateHookFile(filePath, updater) {
+  const config = readJsonFile(filePath);
+  const result = updater(config);
+
+  if (result.changed) {
+    writeJsonFile(filePath, result.config);
+  }
+
+  return result.changed;
+}
+
+function install(args) {
+  const targets = selectedTargets(args);
+  const command = hookCommand();
+  const results = [];
+
+  if (targets.claude) {
+    const path = join(homedir(), ".claude", "settings.json");
+    const changed = updateHookFile(path, (config) => withCharlesHook(config, command));
+    results.push(`Claude: ${changed ? "installed" : "already installed"} (${path})`);
+  }
+
+  if (targets.codex) {
+    const hooksPath = join(homedir(), ".codex", "hooks.json");
+    const configPath = join(homedir(), ".codex", "config.toml");
+    const hooksChanged = updateHookFile(hooksPath, (config) =>
+      withCharlesHook(config, command)
+    );
+    const featureChanged = enableCodexHooksFeature(configPath);
+    results.push(
+      `Codex: ${hooksChanged ? "installed" : "already installed"} (${hooksPath})`
+    );
+    results.push(
+      `Codex hooks feature: ${featureChanged ? "enabled" : "already enabled"} (${configPath})`
+    );
+  }
+
+  console.log(results.join("\n"));
+}
+
+function uninstall(args) {
+  const targets = selectedTargets(args);
+  const results = [];
+
+  if (targets.claude) {
+    const path = join(homedir(), ".claude", "settings.json");
+    const changed = updateHookFile(path, withoutCharlesHook);
+    results.push(`Claude: ${changed ? "removed" : "not installed"} (${path})`);
+  }
+
+  if (targets.codex) {
+    const path = join(homedir(), ".codex", "hooks.json");
+    const changed = updateHookFile(path, withoutCharlesHook);
+    results.push(`Codex: ${changed ? "removed" : "not installed"} (${path})`);
+  }
+
+  console.log(results.join("\n"));
+}
+
+function showImage(args) {
+  if (!existsSync(imagePath)) {
+    throw new Error(`Could not find bundled image at ${imagePath}`);
+  }
+
+  const currentPlatform = platform();
+  const opener =
+    currentPlatform === "darwin"
+      ? { command: "open", args: [imagePath] }
+      : currentPlatform === "win32"
+        ? { command: "cmd", args: ["/c", "start", "", imagePath] }
+        : { command: "xdg-open", args: [imagePath] };
+
+  const child = spawn(opener.command, opener.args, {
+    detached: true,
+    stdio: "ignore",
+  });
+  child.unref();
+
+  if (!args.includes("--quiet")) {
+    console.log(`Opened ${imagePath}`);
+  }
+}
+
+function main() {
+  const [command = "help", ...args] = process.argv.slice(2);
+
+  switch (command) {
+    case "show":
+      showImage(args);
+      break;
+    case "path":
+      console.log(imagePath);
+      break;
+    case "install":
+      install(args);
+      break;
+    case "uninstall":
+      uninstall(args);
+      break;
+    case "help":
+    case "--help":
+    case "-h":
+      console.log(usage);
+      break;
+    default:
+      console.error(`Unknown command: ${command}\n`);
+      console.error(usage);
+      process.exitCode = 1;
+  }
+}
+
+try {
+  main();
+} catch (error) {
+  console.error(error instanceof Error ? error.message : String(error));
+  process.exitCode = 1;
+}

package/package.json

@@ -0,0 +1,33 @@
+{
+  "name": "charleszhou",
+  "version": "0.1.0",
+  "description": "Open Charles Zhou whenever Claude Code or Codex receives a prompt.",
+  "type": "module",
+  "bin": {
+    "charleszhou": "./bin/charleszhou.js"
+  },
+  "files": [
+    "assets/charleszhou.png",
+    "bin/charleszhou.js",
+    "README.md",
+    "LICENSE"
+  ],
+  "scripts": {
+    "check": "bun run bin/charleszhou.js --help && bun run bin/charleszhou.js path",
+    "prepublishOnly": "bun run check"
+  },
+  "keywords": [
+    "claude",
+    "codex",
+    "hooks",
+    "charles",
+    "zhou"
+  ],
+  "license": "MIT",
+  "publishConfig": {
+    "access": "public"
+  },
+  "engines": {
+    "node": ">=20"
+  }
+}