@pragma-sh/claude-code-plugin 0.1.0-alpha.0

package/.claude-plugin/marketplace.json

@@ -0,0 +1,14 @@
+{
+  "name": "pragma",
+  "description": "Pragma's bundled Claude Code plugin that reports agent status to the Pragma desktop app.",
+  "owner": {
+    "name": "Pragma"
+  },
+  "plugins": [
+    {
+      "name": "pragma-claude-code",
+      "source": "./",
+      "description": "Reports Claude Code agent status (running / done / attention) to Pragma automatically."
+    }
+  ]
+}

package/.claude-plugin/plugin.json

@@ -0,0 +1,8 @@
+{
+  "name": "pragma-claude-code",
+  "version": "0.1.0-alpha.0",
+  "description": "Reports Claude Code agent status (running / done / attention) to Pragma automatically.",
+  "author": {
+    "name": "Pragma"
+  }
+}

package/assets/claude-code.svg

@@ -0,0 +1,7 @@
+<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24">
+  <title>Claude Code</title>
+  <path clip-rule="evenodd"
+        d="M20.998 10.949H24v3.102h-3v3.028h-1.487V20H18v-2.921h-1.487V20H15v-2.921H9V20H7.488v-2.921H6V20H4.487v-2.921H3V14.05H0V10.95h3V5h17.998v5.949zM6 10.949h1.488V8.102H6v2.847zm10.51 0H18V8.102h-1.49v2.847z"
+        fill="#D97757"
+        fill-rule="evenodd" />
+</svg>

package/dist/pragma-plugin.mjs

@@ -0,0 +1,476 @@
+// ../plugin/dist/shared/chunk-k5kqv14t.js
+var PLUGIN_API_VERSION = "0.0.0";
+
+// ../plugin/dist/shared/chunk-0rpz2gg0.js
+function defineAgent(input) {
+  return input;
+}
+function definePlugin(input) {
+  return { ...input, __apiVersion: PLUGIN_API_VERSION };
+}
+function defineUsageLimitProvider(input) {
+  return input;
+}
+
+// ../watcher-kit/src/index.ts
+var DEFAULT_APPROVE_KEYS = "\r";
+var RIGHT_ARROW = "\x1B[C";
+var DOWN_ARROW = "\x1B[B";
+var DEFAULT_DENY_KEYS = `${RIGHT_ARROW}${RIGHT_ARROW}\r`;
+var DEFAULT_SUBMIT_KEYS = "\r";
+var BRACKETED_PASTE_START = "\x1B[200~";
+var BRACKETED_PASTE_END = "\x1B[201~";
+var QUESTION_REJECT_KEYS = "\x1B";
+var QUESTION_DIGIT_MAX = 9;
+var QUESTION_PROMPT_MOUNT_DELAY_MS = 150;
+var QUESTION_OTHER_INPUT_DELAY_MS = 150;
+var QUESTION_NEXT_PROMPT_DELAY_MS = 500;
+var ANSWER_SEPARATOR = "\x1F";
+var RESUBSCRIBE_DELAY_MS = 500;
+var DEFAULT_INTERJECT_SUBMIT_DELAY_MS = 200;
+function createTuiWatcher(options) {
+  const {
+    agent,
+    handleDecisions,
+    handleQuestionAnswers = handleDecisions,
+    interjectSubmitDelayMs = DEFAULT_INTERJECT_SUBMIT_DELAY_MS,
+    interjectMode = "bracketed",
+    interjectSubmitKeys,
+    questionSelectMode = "digit",
+    questionOtherMode = "navigate-enter",
+    questionDismissKeys = QUESTION_REJECT_KEYS,
+    questionFinalizeKeys = ""
+  } = options;
+  return {
+    agent,
+    async watch(ctx) {
+      const watcherContext = ctx;
+      const runtime = {
+        keys: resolveKeys(watcherContext.config, interjectSubmitKeys),
+        handleDecisions,
+        handleQuestionAnswers,
+        interjectSubmitDelayMs,
+        interjectMode,
+        questionSelectMode,
+        questionOtherMode,
+        questionDismissKeys,
+        questionFinalizeKeys,
+        seenRequestIds: new Set,
+        questionsByRequestId: new Map,
+        outstandingCommandRequestId: null
+      };
+      let failures = 0;
+      while (!ctx.signal.aborted) {
+        try {
+          await consumeControlEvents(watcherContext, runtime);
+          failures = 0;
+        } catch (error) {
+          failures += 1;
+          reportStreamFailure(agent, failures, error);
+        }
+        if (ctx.signal.aborted) {
+          return;
+        }
+        await delay(RESUBSCRIBE_DELAY_MS, ctx.signal);
+      }
+    }
+  };
+}
+function reportStreamFailure(agent, consecutive, error) {
+  if (consecutive !== 1 && consecutive % STREAM_FAILURE_LOG_EVERY !== 0) {
+    return;
+  }
+  const message = error instanceof Error ? error.message : String(error);
+  console.warn(JSON.stringify({ type: "watcher.streamError", agent, consecutive, error: message }));
+}
+var STREAM_FAILURE_LOG_EVERY = 240;
+function resolveKeys(config, interjectSubmitKeys) {
+  const c = config ?? {};
+  return {
+    approveKeys: c.approveKeys ?? DEFAULT_APPROVE_KEYS,
+    denyKeys: c.denyKeys ?? DEFAULT_DENY_KEYS,
+    submitKeys: c.submitKeys ?? interjectSubmitKeys ?? DEFAULT_SUBMIT_KEYS
+  };
+}
+async function consumeControlEvents(ctx, runtime) {
+  const connection = await ctx.sdk.agents.connect({
+    agent: ctx.agentId,
+    tabId: ctx.session.tabId,
+    worktreeId: ctx.session.worktreeId,
+    signal: ctx.signal
+  });
+  for await (const event of connection) {
+    if (ctx.signal.aborted) {
+      return;
+    }
+    await handleControlEvent(ctx, runtime, event);
+  }
+}
+async function handleControlEvent(ctx, runtime, event) {
+  if (event.type === "agent") {
+    if (runtime.handleQuestionAnswers)
+      rememberQuestion(runtime.questionsByRequestId, event);
+    if (runtime.handleDecisions)
+      rememberCommandAttention(runtime, event);
+    return;
+  }
+  if (runtime.handleDecisions && await handleDecision(ctx, runtime, event)) {
+    return;
+  }
+  if (runtime.handleQuestionAnswers && await handleAnswer(ctx, runtime, event)) {
+    return;
+  }
+  if (event.type === "agentInput") {
+    await handleInterjection(ctx, runtime.keys.submitKeys, runtime.interjectSubmitDelayMs, runtime.interjectMode, event.input.text);
+  }
+}
+async function handleDecision(ctx, runtime, event) {
+  if (event.type !== "agentDecision")
+    return false;
+  if (runtime.seenRequestIds.has(event.decision.requestId))
+    return true;
+  runtime.seenRequestIds.add(event.decision.requestId);
+  if (runtime.outstandingCommandRequestId !== null && runtime.outstandingCommandRequestId !== event.decision.requestId) {
+    return true;
+  }
+  runtime.outstandingCommandRequestId = null;
+  await writeKeys(ctx, event.decision.approved ? runtime.keys.approveKeys : runtime.keys.denyKeys);
+  return true;
+}
+async function handleAnswer(ctx, runtime, event) {
+  if (event.type !== "agentAnswer")
+    return false;
+  const { answer } = event;
+  const cached = runtime.questionsByRequestId.get(answer.requestId);
+  if (!cached)
+    return true;
+  if (runtime.seenRequestIds.has(answer.requestId))
+    return true;
+  runtime.seenRequestIds.add(answer.requestId);
+  runtime.questionsByRequestId.delete(answer.requestId);
+  await delay(QUESTION_PROMPT_MOUNT_DELAY_MS, ctx.signal);
+  if (ctx.signal.aborted)
+    return true;
+  const reply = answer.answer?.trim() ?? null;
+  if (cached.questions.length > 1) {
+    if (!answer.dismissed && reply) {
+      await writeMultipleQuestionAnswers(ctx, runtime, cached.questions, reply);
+    } else if (answer.dismissed || !reply) {
+      await writeKeys(ctx, runtime.questionDismissKeys);
+    }
+    return true;
+  }
+  const single = cached.questions[0] ?? { question: "", options: [] };
+  await writeQuestionAnswer(ctx, runtime, single, reply, answer.dismissed);
+  if (!answer.dismissed && reply)
+    await finalizeQuestionAnswers(ctx, runtime);
+  return true;
+}
+async function writeQuestionAnswer(ctx, runtime, question, reply, dismissed) {
+  if (dismissed || !reply) {
+    await writeKeys(ctx, runtime.questionDismissKeys);
+    return;
+  }
+  if (!dismissed && reply && !question.options.includes(reply)) {
+    await writeFreeTextAnswer(ctx, question.options.length, reply, runtime.questionSelectMode, runtime.questionOtherMode);
+    return;
+  }
+  const strokes = questionAnswerKeys({
+    dismissed,
+    reply,
+    options: question.options,
+    selectMode: runtime.questionSelectMode
+  });
+  if (strokes)
+    await writeKeys(ctx, strokes);
+}
+async function writeFreeTextAnswer(ctx, optionCount, reply, selectMode, otherMode) {
+  await writeKeys(ctx, openOtherEditorKeys(optionCount, selectMode, otherMode));
+  await delay(QUESTION_OTHER_INPUT_DELAY_MS, ctx.signal);
+  if (!ctx.signal.aborted)
+    await writeKeys(ctx, `${reply}\r`);
+}
+async function writeMultipleQuestionAnswers(ctx, runtime, questions, combined) {
+  const replies = combined.split(ANSWER_SEPARATOR).map((reply) => reply.trim());
+  for (const [index, question] of questions.entries()) {
+    const reply = replies[index];
+    if (!reply || ctx.signal.aborted)
+      return;
+    await writeQuestionAnswer(ctx, runtime, question, reply, false);
+    if (index < questions.length - 1) {
+      await delay(QUESTION_NEXT_PROMPT_DELAY_MS, ctx.signal);
+    }
+  }
+  await finalizeQuestionAnswers(ctx, runtime);
+}
+async function finalizeQuestionAnswers(ctx, runtime) {
+  if (!runtime.questionFinalizeKeys || ctx.signal.aborted)
+    return;
+  await delay(QUESTION_NEXT_PROMPT_DELAY_MS, ctx.signal);
+  if (!ctx.signal.aborted)
+    await writeKeys(ctx, runtime.questionFinalizeKeys);
+}
+async function handleInterjection(ctx, submitKeys, submitDelayMs, mode, text) {
+  const input = mode === "plain" ? text : `${BRACKETED_PASTE_START}${text}${BRACKETED_PASTE_END}`;
+  await writeKeys(ctx, input);
+  if (!submitKeys) {
+    return;
+  }
+  await delay(submitDelayMs, ctx.signal);
+  if (!ctx.signal.aborted)
+    await writeKeys(ctx, submitKeys);
+}
+function rememberCommandAttention(runtime, event) {
+  if (event.status === "attention" && event.attentionKind === "command" && typeof event.requestId === "string" && event.requestId.length > 0) {
+    runtime.outstandingCommandRequestId = event.requestId;
+    return;
+  }
+  if (event.status !== "attention") {
+    runtime.outstandingCommandRequestId = null;
+  }
+}
+function rememberQuestion(cache, event) {
+  if (event.status === "attention" && event.attentionKind === "question" && typeof event.requestId === "string" && event.requestId.length > 0) {
+    const entries = (event.questions ?? []).flatMap(questionEntry);
+    if (entries.length > 0) {
+      cache.set(event.requestId, { questions: entries });
+      return;
+    }
+    const options = (event.options ?? []).map((option) => option.label).filter((option) => option.trim() !== "");
+    cache.set(event.requestId, {
+      questions: [{ question: event.question ?? "", options }]
+    });
+  }
+}
+function questionEntry(value) {
+  if (typeof value !== "object" || value === null || !("question" in value)) {
+    return [];
+  }
+  const record = value;
+  if (typeof record.question !== "string" || !record.question.trim()) {
+    return [];
+  }
+  const options = Array.isArray(record.options) ? record.options.filter((option) => Boolean(option) && typeof option === "object").map((option) => option.label).filter((label) => typeof label === "string" && label.trim() !== "") : [];
+  return [{ question: record.question, options }];
+}
+function questionAnswerKeys(input) {
+  if (input.dismissed || input.reply === null) {
+    return QUESTION_REJECT_KEYS;
+  }
+  const reply = input.reply.trim();
+  if (!reply) {
+    return QUESTION_REJECT_KEYS;
+  }
+  const options = input.options;
+  const selectMode = input.selectMode ?? "digit";
+  const matchIndex = options.findIndex((option) => option === reply);
+  if (matchIndex >= 0) {
+    return selectOptionKeys(matchIndex, options.length, selectMode);
+  }
+  return `${openOtherEditorKeys(options.length, selectMode, "navigate-enter")}${reply}\r`;
+}
+function openOtherEditorKeys(optionCount, selectMode, otherMode) {
+  if (otherMode === "shortcut-z")
+    return "z";
+  const navigate = DOWN_ARROW.repeat(optionCount);
+  return selectMode === "arrow-space" || otherMode === "navigate" ? navigate : `${navigate}\r`;
+}
+function selectOptionKeys(index, optionCount, selectMode) {
+  if (selectMode === "arrow-space") {
+    return `${DOWN_ARROW.repeat(index)} \r`;
+  }
+  const total = optionCount + 1;
+  if (index < QUESTION_DIGIT_MAX && index < total) {
+    return String(index + 1);
+  }
+  return `${DOWN_ARROW.repeat(index)}\r`;
+}
+async function writeKeys(ctx, data) {
+  try {
+    await ctx.sendKeys(data);
+  } catch {}
+}
+function delay(ms, signal) {
+  if (signal.aborted) {
+    return Promise.resolve();
+  }
+  return new Promise((resolve) => {
+    const finish = () => resolve();
+    const timer = setTimeout(finish, ms);
+    signal.addEventListener("abort", () => {
+      clearTimeout(timer);
+      finish();
+    }, { once: true });
+  });
+}
+
+// src/pragma-plugin.ts
+var INTERJECT_SUBMIT_DELAY_MS = 200;
+var USAGE_REQUEST = JSON.stringify({
+  type: "control_request",
+  request_id: "pragma-usage",
+  request: { subtype: "get_usage" }
+});
+var USAGE_COMMAND = `printf '%s\\n' '${USAGE_REQUEST}' | claude -p --safe-mode --input-format stream-json --output-format stream-json --verbose`;
+var reasoningFull = [
+  { id: "low", name: "Low" },
+  { id: "medium", name: "Medium" },
+  { id: "high", name: "High" },
+  { id: "xhigh", name: "Extra High" },
+  { id: "max", name: "Max" }
+];
+var reasoningStandard = reasoningFull.slice(0, 3);
+var claudeCodeAgentPlugin = definePlugin({
+  name: "Claude Code",
+  description: "Launch Claude Code from Pragma.",
+  usageLimits: [
+    defineUsageLimitProvider({
+      id: "claude-code",
+      title: "Claude Code",
+      dashboardUrl: "https://claude.ai/new#settings/usage",
+      iconPath: "assets/claude-code.svg",
+      primaryLimitId: "five-hour",
+      refreshIntervalMs: 300000,
+      load: loadClaudeUsageLimits
+    })
+  ],
+  watchers: [
+    createTuiWatcher({
+      agent: "claude-code",
+      handleDecisions: false,
+      interjectSubmitDelayMs: INTERJECT_SUBMIT_DELAY_MS
+    })
+  ],
+  agents: [
+    defineAgent({
+      id: "claude-code",
+      name: "Claude Code",
+      icon: () => null,
+      iconPath: "assets/claude-code.svg",
+      launch: { command: ["claude", "--permission-mode", "auto"] },
+      models: [
+        { id: "sonnet", name: "Sonnet", reasoning: reasoningFull },
+        { id: "opus", name: "Opus", reasoning: reasoningStandard },
+        { id: "fable", name: "Fable", reasoning: reasoningFull },
+        { id: "haiku", name: "Haiku", reasoning: reasoningStandard }
+      ],
+      permissionModes: [],
+      excludeFeatures: ["commandApproval"],
+      args: {
+        model: (modelId) => ["--model", modelId],
+        reasoning: (reasoningId) => ["--effort", reasoningId],
+        permissionMode: () => []
+      }
+    })
+  ]
+});
+var pragma_plugin_default = claudeCodeAgentPlugin;
+async function loadClaudeUsageLimits(ctx) {
+  const cwd = ctx.project?.path ?? "/tmp";
+  const [result] = await ctx.sdk.exec.run({ cwd, commands: [USAGE_COMMAND] });
+  if (!result || result.status !== 0) {
+    throw new Error(result?.stderr.trim() || "Claude Code usage request failed");
+  }
+  return extractUsageFromOutput(result.stdout);
+}
+function extractUsageFromOutput(stdout) {
+  for (const line of stdout.split(`
+`)) {
+    const response = tryParseUsageControlResponse(line);
+    if (response === undefined) {
+      continue;
+    }
+    if (response.subtype === "error") {
+      throw new Error(response.error || "Claude Code usage request failed");
+    }
+    return parseClaudeUsage(response.response, Date.now());
+  }
+  throw new Error("Claude Code did not return usage data");
+}
+function tryParseUsageControlResponse(line) {
+  try {
+    const value = JSON.parse(line);
+    return isUsageControlResponse(value) ? value.response : undefined;
+  } catch (cause) {
+    if (cause instanceof SyntaxError) {
+      return;
+    }
+    throw cause;
+  }
+}
+function parseClaudeUsage(value, observedAt) {
+  if (!isRecord(value)) {
+    throw new Error("Claude Code usage response was not an object");
+  }
+  if (value.rate_limits_available !== true) {
+    return {
+      status: "unavailable",
+      reason: "authentication-required",
+      message: "Sign in to Claude Code with a subscription to load usage limits."
+    };
+  }
+  if (!isRecord(value.rate_limits)) {
+    throw new Error("Claude Code usage data is temporarily unavailable (rate limited)");
+  }
+  const rateLimits = value.rate_limits;
+  const limits = [];
+  addWindow(limits, "five-hour", "5-hour limit", rateLimits.five_hour, observedAt);
+  addWindow(limits, "seven-day", "Weekly limit", rateLimits.seven_day, observedAt);
+  addWindow(limits, "seven-day-oauth-apps", "Weekly OAuth apps", rateLimits.seven_day_oauth_apps, observedAt);
+  addWindow(limits, "seven-day-opus", "Weekly Opus", rateLimits.seven_day_opus, observedAt);
+  addWindow(limits, "seven-day-sonnet", "Weekly Sonnet", rateLimits.seven_day_sonnet, observedAt);
+  if (Array.isArray(rateLimits.model_scoped)) {
+    for (const [index, scoped] of rateLimits.model_scoped.entries()) {
+      if (!isRecord(scoped) || typeof scoped.display_name !== "string") {
+        continue;
+      }
+      addWindow(limits, `model-${index}`, scoped.display_name, { utilization: scoped.utilization, resets_at: scoped.resets_at }, observedAt);
+    }
+  }
+  if (!limits.some((limit) => limit.id === "five-hour")) {
+    return {
+      status: "unavailable",
+      reason: "unsupported",
+      message: "Claude Code did not return its 5-hour usage limit."
+    };
+  }
+  return { status: "ready", observedAt, limits };
+}
+function addWindow(limits, id, title, value, observedAt) {
+  if (!isRecord(value) || !isFiniteNumber(value.utilization)) {
+    return;
+  }
+  const resetAt = parseDate(value.resets_at);
+  limits.push({
+    id,
+    title,
+    used: Math.min(100, Math.max(0, value.utilization)),
+    limit: 100,
+    ...resetAt === null ? {} : { resetsInMs: Math.max(0, resetAt - observedAt) }
+  });
+}
+function parseDate(value) {
+  if (typeof value !== "string") {
+    return null;
+  }
+  const parsed = Date.parse(value);
+  return Number.isFinite(parsed) ? parsed : null;
+}
+function isUsageControlResponse(value) {
+  if (!isRecord(value) || value.type !== "control_response" || !isRecord(value.response)) {
+    return false;
+  }
+  return value.response.subtype === "success" && "response" in value.response || value.response.subtype === "error";
+}
+function isFiniteNumber(value) {
+  return typeof value === "number" && Number.isFinite(value);
+}
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+export {
+  parseClaudeUsage,
+  loadClaudeUsageLimits,
+  pragma_plugin_default as default,
+  claudeCodeAgentPlugin
+};

package/hooks/hooks.json

@@ -0,0 +1,105 @@
+{
+  "hooks": {
+    "SessionStart": [
+      {
+        "hooks": [
+          {
+            "type": "command",
+            "command": "sh \"$CLAUDE_PLUGIN_ROOT/hooks/report.sh\" cleared"
+          }
+        ]
+      }
+    ],
+    "UserPromptSubmit": [
+      {
+        "hooks": [
+          {
+            "type": "command",
+            "command": "sh \"$CLAUDE_PLUGIN_ROOT/hooks/report.sh\" started"
+          }
+        ]
+      }
+    ],
+    "Stop": [
+      {
+        "hooks": [
+          {
+            "type": "command",
+            "command": "sh \"$CLAUDE_PLUGIN_ROOT/hooks/report.sh\" stopped"
+          }
+        ]
+      }
+    ],
+    "SubagentStart": [
+      {
+        "hooks": [
+          {
+            "type": "command",
+            "command": "sh \"$CLAUDE_PLUGIN_ROOT/hooks/report.sh\" subagent-start"
+          }
+        ]
+      }
+    ],
+    "SubagentStop": [
+      {
+        "hooks": [
+          {
+            "type": "command",
+            "command": "sh \"$CLAUDE_PLUGIN_ROOT/hooks/report.sh\" subagent-stop"
+          }
+        ]
+      }
+    ],
+    "PostToolUse": [
+      {
+        "hooks": [
+          {
+            "type": "command",
+            "command": "sh \"$CLAUDE_PLUGIN_ROOT/hooks/report.sh\" running"
+          }
+        ]
+      }
+    ],
+    "PermissionRequest": [
+      {
+        "hooks": [
+          {
+            "type": "command",
+            "command": "sh \"$CLAUDE_PLUGIN_ROOT/hooks/report.sh\" permission"
+          }
+        ]
+      }
+    ],
+    "Elicitation": [
+      {
+        "hooks": [
+          {
+            "type": "command",
+            "command": "sh \"$CLAUDE_PLUGIN_ROOT/hooks/report.sh\" attention"
+          }
+        ]
+      }
+    ],
+    "SessionEnd": [
+      {
+        "hooks": [
+          {
+            "type": "command",
+            "command": "sh \"$CLAUDE_PLUGIN_ROOT/hooks/report.sh\" cleared"
+          }
+        ]
+      }
+    ],
+    "Notification": [
+      {
+        "matcher": "idle_prompt",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "sh \"$CLAUDE_PLUGIN_ROOT/hooks/report.sh\" idle"
+          }
+        ]
+      }
+    ]
+  }
+}