@charzhu/openjaw-agent 0.2.0

package/skills/refresh-token.md

@@ -0,0 +1,161 @@
+---
+name: refresh-token
+description: "Refreshes Microsoft Graph API tokens used by OpenJaw for Teams and Outlook."
+whenToUse: "Graph API tokens are expired or need refreshing for Teams/Outlook automation"
+---
+
+# Skill: Refresh Graph Token
+
+## Description
+Refreshes Microsoft Graph API tokens (graph-chat + outlook-mail) used by OpenJaw for Teams and Outlook automation.
+
+## Prerequisites
+- Edge running with `--remote-debugging-port=9222 --remote-allow-origins=*`
+- Logged into outlook.office.com in Edge
+- Node.js 22+ with `ws` package (`npm i -g ws` if not installed)
+
+## How to Execute
+
+Write the following script to a temp file and run it. The script is fully self-contained.
+
+```javascript
+// Save this as a temp .mjs file and run with: node <tempfile>.mjs
+import { WebSocket } from 'ws';
+import { writeFileSync, readFileSync, mkdirSync, existsSync } from 'fs';
+import { join } from 'path';
+import { homedir } from 'os';
+
+const CDP_PORT = 9222;
+const CLIENT_ID = '9199bf20-a13f-4107-85dc-02114787ef48';
+const TOKEN_DIR = join(homedir(), '.graph-token', 'tokens');
+
+const AUDIENCES = [
+  { name: 'graph-chat', audience: 'https://graph.microsoft.com' },
+  { name: 'outlook-mail', audience: 'https://outlook.office.com' },
+];
+
+function decodeJwt(jwt) {
+  try { return JSON.parse(Buffer.from(jwt.split('.')[1], 'base64url').toString()); }
+  catch { return null; }
+}
+
+async function listPages() {
+  return await (await fetch(`http://localhost:${CDP_PORT}/json`)).json();
+}
+
+async function evalInTab(wsUrl, expr) {
+  return new Promise(resolve => {
+    const ws = new WebSocket(wsUrl);
+    const timer = setTimeout(() => { ws.close(); resolve(null); }, 15000);
+    ws.on('open', () => ws.send(JSON.stringify({ id: 1, method: 'Runtime.evaluate', params: { expression: expr, returnByValue: true } })));
+    ws.on('message', d => { const r = JSON.parse(d.toString()); if (r.id === 1) { clearTimeout(timer); ws.close(); resolve(r.result?.result?.value ?? null); } });
+    ws.on('error', () => { clearTimeout(timer); resolve(null); });
+  });
+}
+
+async function openTab(url) {
+  const ver = await (await fetch(`http://localhost:${CDP_PORT}/json/version`)).json();
+  return new Promise(resolve => {
+    const ws = new WebSocket(ver.webSocketDebuggerUrl);
+    const timer = setTimeout(() => { ws.close(); resolve(null); }, 15000);
+    ws.on('open', () => ws.send(JSON.stringify({ id: 1, method: 'Target.createTarget', params: { url } })));
+    ws.on('message', d => { const r = JSON.parse(d.toString()); if (r.id === 1) { clearTimeout(timer); ws.close(); resolve(r.result?.targetId); } });
+    ws.on('error', () => { clearTimeout(timer); resolve(null); });
+  });
+}
+
+const EXTRACT_RT = `(function(){
+  var rtKeys=Object.keys(localStorage).filter(k=>k.includes('refreshtoken'));
+  if(!rtKeys.length) return JSON.stringify({error:'no_rt'});
+  var rtKey=rtKeys.find(k=>k.includes('|refreshtoken|${CLIENT_ID}|'))||rtKeys[0];
+  var rt=JSON.parse(localStorage.getItem(rtKey));
+  var acctKeys=JSON.parse(localStorage.getItem('msal.2.account.keys')||'[]');
+  if(!acctKeys.length) return JSON.stringify({error:'no_account'});
+  var acct=JSON.parse(localStorage.getItem(acctKeys[0]));
+  var tid=acct.realm||acct.tenantId||acct.homeAccountId?.split('.')[1]||'';
+  return JSON.stringify({refreshToken:rt.data||rt.secret||'',tenantId:tid});
+})()`;
+
+async function main() {
+  // Check CDP
+  try { await fetch(`http://localhost:${CDP_PORT}/json/version`); }
+  catch { console.error('❌ CDP not available. Start Edge with --remote-debugging-port=9222'); process.exit(1); }
+
+  // Find Outlook tab
+  let pages = await listPages();
+  let tab = pages.find(p => (p.url?.includes('outlook.office.com') || p.url?.includes('outlook.cloud.microsoft')) && p.webSocketDebuggerUrl && p.type === 'page');
+
+  if (!tab) {
+    console.log('⏳ Opening Outlook...');
+    await openTab('https://outlook.office.com/mail/');
+    for (let i = 0; i < 20; i++) {
+      await new Promise(r => setTimeout(r, 2000));
+      pages = await listPages();
+      tab = pages.find(p => p.url?.includes('outlook.office') && p.webSocketDebuggerUrl && p.type === 'page');
+      if (tab) break;
+    }
+    if (!tab) { console.error('❌ Outlook did not load'); process.exit(1); }
+    await new Promise(r => setTimeout(r, 8000)); // Wait for MSAL
+    pages = await listPages();
+    tab = pages.find(p => p.url?.includes('outlook.office') && p.webSocketDebuggerUrl && p.type === 'page');
+  }
+
+  console.log('✅ Outlook tab found');
+
+  // Extract RT
+  const raw = await evalInTab(tab.webSocketDebuggerUrl, EXTRACT_RT);
+  if (!raw) { console.error('❌ CDP eval failed'); process.exit(1); }
+  const info = JSON.parse(raw);
+  if (info.error) { console.error('❌ ' + info.error); process.exit(1); }
+  console.log('✅ RT extracted (tenant: ' + info.tenantId.slice(0, 8) + '...)');
+
+  // Exchange for access tokens
+  mkdirSync(TOKEN_DIR, { recursive: true });
+  for (const { name, audience } of AUDIENCES) {
+    const body = new URLSearchParams({ client_id: CLIENT_ID, grant_type: 'refresh_token', refresh_token: info.refreshToken, scope: audience + '/.default offline_access' });
+    const resp = await fetch(`https://login.microsoftonline.com/${info.tenantId}/oauth2/v2.0/token`, {
+      method: 'POST', headers: { 'Content-Type': 'application/x-www-form-urlencoded', Origin: 'https://outlook.office.com' }, body: body.toString()
+    });
+    const result = await resp.json();
+    if (result.access_token) {
+      const exp = decodeJwt(result.access_token)?.exp || 0;
+      const mins = Math.floor((exp - Date.now() / 1000) / 60);
+      writeFileSync(join(TOKEN_DIR, name + '.json'), JSON.stringify({ access_token: result.access_token, token_type: 'Bearer', saved_at: new Date().toISOString(), source: 'refresh-skill' }, null, 2));
+      console.log('✅ ' + name + ': refreshed (' + mins + 'm validity)');
+    } else {
+      console.error('❌ ' + name + ': ' + (result.error_description || result.error || 'unknown'));
+    }
+  }
+}
+
+main().catch(e => { console.error('❌ ' + e.message); process.exit(1); });
+```
+
+## How to Run
+
+The agent should:
+1. Write the above script to a temp file: `file_write({ path: "<temp>/refresh-graph.mjs", content: <script> })`
+2. Execute: `system_run({ command: "node <temp>/refresh-graph.mjs", timeout: 60000 })`
+3. Verify: `outlook_switch_channel("graph")` → `outlook_go_to_inbox()`
+
+## Token File Locations
+```
+~/.graph-token/tokens/graph-chat.json     — Teams Graph channel
+~/.graph-token/tokens/outlook-mail.json   — Outlook Graph channel
+```
+
+## Troubleshooting
+
+| Problem | Fix |
+|---------|-----|
+| CDP not available | Restart Edge with `--remote-debugging-port=9222 --remote-allow-origins=*` |
+| `no_rt` error | Outlook Web session expired — log in manually |
+| RT exchange failed | Refresh token revoked — close Edge, reopen, log in fresh |
+| Tokens expire in ~80 min | Run this skill periodically |
+
+## Verification
+After refresh, test with:
+```
+outlook_switch_channel("graph") → outlook_go_to_inbox()
+teams_switch_channel("graph") → teams_read_messages()
+```

package/skills/skill-creator.md

@@ -0,0 +1,122 @@
+---
+name: skill-creator
+description: "Create new skills, modify existing skills, and improve skill quality."
+whenToUse: "Jon identifies a new capability gap that should be systematized"
+---
+
+# Skill: Skill Creator (Meta-Skill)
+
+## Description
+Create new skills for Jon, modify existing skills, and improve skill quality. This is the meta-skill — the skill that makes other skills. Based on Anthropic's skill-creator but adapted for OpenJaw Agent.
+
+## When to Use
+- Jon identifies a new capability gap that should be systematized
+- User asks to "teach Jon something new" or "add a new skill"
+- After completing a novel task that should be repeatable
+- When an existing skill needs improvement based on real usage
+
+## Skill Creation Process
+
+### 1. Capture Intent
+Understand what the skill should do:
+- What task does this skill enable?
+- When should it trigger? (what user phrases/contexts)
+- What's the expected output?
+- What tools/APIs does it need?
+- What are the common failure modes?
+
+### 2. Research & Reference
+Before writing, gather context:
+- Check existing skills for overlap: `file_list("~/.openjaw-agent/skills")` and `file_list("<package>/skills")`
+- Search GitHub for similar skills: `web_search("SKILL.md [topic] agent")`
+- Check Anthropic's official skills: `web_fetch("https://raw.githubusercontent.com/anthropics/skills/main/skills/[name]/SKILL.md")`
+- Review memory for past experiences: `memory_search("[topic]")`
+
+### 3. Write the SKILL.md
+
+#### Required Structure
+```markdown
+# Skill: [Name]
+
+## Description
+[1-2 sentences: What it does. Be "pushy" — list all trigger phrases and contexts
+so the skill doesn't under-trigger.]
+
+## When to Use
+- [Trigger condition 1]
+- [Trigger condition 2]
+- [Chinese trigger phrase]
+- [English trigger phrase]
+
+## Prerequisites
+- [Required tools, libraries, APIs]
+
+## Workflow / Steps
+[The core instructions — step by step]
+
+## Important Notes
+[Gotchas, edge cases, lessons learned from real usage]
+
+## Output & Delivery
+[How to deliver the result to the user]
+```
+
+#### Writing Guidelines
+- **Be specific, not generic** — include actual code snippets, file paths, API endpoints
+- **Include failure modes** — what goes wrong and how to fix it
+- **Use real examples** from actual usage with CharZ
+- **Include Chinese trigger phrases** — CharZ communicates in both languages
+- **Reference other skills** — skills should compose together (e.g., "use email-with-attachment skill to send")
+- **Keep it actionable** — every section should help complete the task
+- **"Pushy" descriptions** — list many trigger conditions to prevent under-triggering
+
+#### Anti-Patterns to Avoid
+- ❌ Generic advice without specific implementation
+- ❌ Listing tools without showing how to use them
+- ❌ Ignoring the actual environment (Windows, Chinese fonts, Outlook REST API)
+- ❌ Not referencing other skills that should compose together
+- ❌ Missing error handling / troubleshooting section
+
+### 4. Save & Register
+```python
+# Save to user skills directory (NOT the bundled skills dir)
+file_write("~/.openjaw-agent/skills/{skill-name}.md", content)
+
+# Update memory
+memory_append("Added new skill: {name} — {description}")
+```
+
+### 5. Test
+After creating a skill, ideally test it:
+- Try triggering it with a realistic user request
+- Verify the steps actually work in the current environment
+- Check that referenced tools/APIs are available
+
+### 6. Iterate
+Skills should improve based on real usage:
+- When a skill fails or produces suboptimal results → update it
+- When new tools become available → enhance the skill
+- When user gives feedback → incorporate it
+- Periodically review skills for staleness
+
+## Skill Quality Checklist
+- [ ] Has clear trigger conditions (English + Chinese)
+- [ ] Has specific, actionable steps (not just advice)
+- [ ] Includes code snippets with real paths/APIs
+- [ ] References other composable skills
+- [ ] Has troubleshooting / error handling section
+- [ ] Has been tested at least once
+- [ ] Includes lessons from real usage
+
+## Current Skills Directory
+Path: `~/.openjaw-agent/skills/` (user skills — agent-created, persists across updates)
+
+Skills compose together — for example:
+- doc-coauthoring → create-pdf-report → email-with-attachment
+- deep-research → summarization → internal-comms → email-drafting
+- meeting-summarizer → translation → proofreading
+
+## Skill Naming Convention
+- Lowercase with hyphens: `skill-name.md`
+- Descriptive but concise: `create-pdf-report.md`, not `pdf.md`
+- Action-oriented when possible: `email-drafting.md`, not `emails.md`

package/skills/summarization.md

@@ -0,0 +1,110 @@
+---
+name: summarization
+description: "Summarize long content into concise, structured summaries."
+whenToUse: "User pastes long text and asks for a summary"
+---
+
+# Skill: Summarization
+
+## Description
+Summarize long content (emails, documents, chat threads, articles) into concise, structured summaries. Supports extractive (key sentences), abstractive (rewritten), and hierarchical (multi-level) approaches.
+
+## When to Use
+- User pastes long text and asks for a summary
+- User asks to summarize emails, Teams chats, or documents
+- User says "太长了帮我总结" or "TL;DR" or "summarize this"
+- After reading a long email thread or chat history
+
+## Approach Selection
+
+| Content Type | Best Approach | Output Length |
+|-------------|--------------|---------------|
+| Single email | Extractive (key points) | 2-3 bullets |
+| Email thread (5+ msgs) | Abstractive + timeline | 5-10 bullets |
+| Meeting transcript | Hierarchical (decisions > discussion > details) | ~1 page |
+| Technical document | Abstractive + key terms | Paragraph + bullet points |
+| Chat thread (50+ msgs) | Thematic grouping | Grouped bullets by topic |
+| News article | Extractive headline + key points | 3-5 bullets |
+
+## Workflow
+
+### 1. Assess the Content
+- Length: How long is the source?
+- Type: Email? Chat? Document? Article?
+- Purpose: Why does the user want a summary? (Decision? Catch up? Share?)
+
+### 2. Apply the Right Technique
+
+#### Extractive (Pull key sentences)
+Best for: Short-medium content where exact wording matters
+```
+- Identify the most important 3-5 sentences
+- Preserve original phrasing
+- Bold key terms
+```
+
+#### Abstractive (Rewrite concisely)
+Best for: Long content that needs simplification
+```
+- Understand the overall message
+- Rewrite in fewer words without losing meaning
+- Use simpler language
+```
+
+#### Hierarchical (Multi-level)
+Best for: Complex content with multiple topics
+```
+Level 1: One-line summary (< 20 words)
+Level 2: Key points (3-5 bullets)
+Level 3: Detailed summary (paragraph per topic)
+```
+
+#### Thematic (Group by topic)
+Best for: Long chat threads with multiple interleaved discussions
+```
+Group messages by topic:
+- Topic A: [Summary of all messages about topic A]
+- Topic B: [Summary of all messages about topic B]
+- Action items: [Extracted from all topics]
+```
+
+### 3. Format Output
+
+#### Quick Summary (default)
+```
+**TL;DR:** [One sentence summary]
+
+Key points:
+• [Point 1]
+• [Point 2]
+• [Point 3]
+
+Action needed: [If any]
+```
+
+#### Detailed Summary
+```
+## Summary: [Title/Subject]
+
+**Context:** [Why this matters]
+
+### Main Points
+1. [Point with detail]
+2. [Point with detail]
+
+### Decisions Made
+- [Decision 1]
+
+### Action Items
+- [Owner]: [Action] by [Date]
+
+### What's Still Open
+- [Unresolved question]
+```
+
+### 4. Rules
+- **Match the language** of the source content
+- **Never add information** not in the source
+- **Preserve nuance** — don't oversimplify disagreements
+- **Front-load the most important info** — if user only reads first 2 lines, they get the gist
+- **For sensitive content** — follow the confidentiality rules (no salary/review info)

package/skills/translation.md

@@ -0,0 +1,94 @@
+---
+name: translation
+description: "Translate text between Chinese and English with cultural adaptation and natural tone."
+whenToUse: "User asks to translate text between Chinese and English"
+---
+
+# Skill: Translation (Chinese-English)
+
+## Description
+Translate text between Chinese and English with cultural adaptation, natural tone, and technical term consistency. Optimized for Microsoft PM work context.
+
+## When to Use
+- User asks to translate text between Chinese and English
+- User says "翻译一下" or "translate this"
+- User needs to convert Chinese notes to English email or vice versa
+- User needs help polishing English/Chinese writing
+
+## Translation Principles
+
+### 1. Meaning Over Literal
+- Don't translate word-by-word — translate the meaning
+- Chinese idioms → English equivalents (not literal)
+- English jargon → Natural Chinese (not transliteration)
+
+### 2. Tone Matching
+| Source Tone | Translation Approach |
+|------------|---------------------|
+| Formal business email | Maintain formality level |
+| Casual team chat | Keep it casual and natural |
+| Technical document | Precise terminology, clear structure |
+| Leadership update | Confident, data-driven, concise |
+
+### 3. Technical Term Consistency
+Keep these in English (don't translate):
+- Product names: Copilot, BizChat, Teams, Outlook
+- Technical terms: token, cache, latency, API, LLM, prompt
+- Metrics: CIE, DAU, MAU, P95, SLA
+- Methodologies: Agile, Scrum, sprint, standup
+
+### 4. Chinese → English
+```
+Approach:
+1. Understand the full meaning in Chinese
+2. Restructure for English grammar (SVO, shorter sentences)
+3. Make it sound native — not "translated from Chinese"
+4. Keep technical terms in English
+5. Adjust formality for Western business culture
+```
+
+Common patterns:
+- 关于...的问题 → "Regarding..." or just state the issue directly
+- 请问一下 → Remove (just ask the question directly)
+- 辛苦了 → "Thanks for your help" / "Appreciate the effort"
+- 麻烦你了 → "Would you mind..." / "Could you please..."
+
+### 5. English → Chinese
+```
+Approach:
+1. Understand the full meaning in English
+2. Restructure for Chinese flow (topic-comment, longer compound sentences OK)
+3. Make it sound natural Chinese — not "翻译腔"
+4. Keep technical terms in English (don't force-translate)
+5. Adjust for Chinese business culture (more polite hedging)
+```
+
+Common patterns:
+- "I'd like to..." → 我想...
+- "Could you..." → 麻烦你.../能不能帮忙...
+- "FYI" → 供参考
+- "Heads up" → 提前知会一下
+- "Action needed" → 需要你的action
+
+### 6. Quality Checks
+- Read the translation out loud — does it sound natural?
+- Would a native speaker write it this way?
+- Are all technical terms consistent?
+- Is the tone appropriate for the audience?
+- No "翻译腔" (translationese)
+
+## Example
+
+### Chinese → English
+```
+Chinese: 这个feature的latency有点高，P95到了2秒，我们需要跟engine team对齐一下优化方案，争取下个sprint能降到1.5秒以下。
+
+English: The latency for this feature is higher than expected — P95 is at 2 seconds. We need to sync with the engine team on an optimization plan, targeting sub-1.5s by next sprint.
+```
+
+### English → Chinese
+```
+English: We're seeing a regression in cache hit rate after the last deployment. The impact is ~5% increase in token consumption. I've filed a bug and the team is investigating.
+
+Chinese: 上次部署后cache hit rate出现了回退，token消耗大概增加了5%。Bug已经提了，团队在排查中。
+```

package/skills/web-research.md

@@ -0,0 +1,93 @@
+---
+name: web-research
+description: "Conduct structured web research on topics, competitors, or technologies."
+whenToUse: "User asks to research a topic, product, or competitor"
+---
+
+# Skill: Web Research & Competitor Analysis
+
+## Description
+Conduct structured web research on topics, competitors, or technologies. Compile findings into organized reports. Useful for PM work like compete analysis, market research, and technology scouting.
+
+## When to Use
+- User asks to research a topic, product, or competitor
+- User asks to compare products or technologies
+- User asks "帮我调研一下" or "看看竞品怎么做的"
+- Need to gather external information for decision-making
+
+## Steps
+
+### 1. Define Research Scope
+Before searching, clarify:
+- What specific questions need answers?
+- What competitors/products to cover?
+- What time frame is relevant?
+- What format for the output?
+
+### 2. Multi-Source Research
+```
+# Search with multiple angles
+web_search("topic + specific question 1")
+web_search("topic + competitor name")
+web_search("topic + latest news 2026")
+web_search("topic + comparison OR vs OR alternative")
+```
+
+### 3. Deep Dive on Key Sources
+```
+# Fetch full content from promising results
+web_fetch(url, max_length=8000)
+```
+
+### 4. Structured Output Template
+
+```markdown
+## [Topic] Research Report — [Date]
+
+### Executive Summary
+[2-3 sentence overview of key findings]
+
+### Key Findings
+
+#### 1. [Finding Area 1]
+- **What**: Description
+- **So what**: Why this matters
+- **Source**: [URL]
+
+#### 2. [Finding Area 2]
+...
+
+### Competitor Comparison
+| Feature | Product A | Product B | Our Product |
+|---------|-----------|-----------|-------------|
+| Feature 1 | ✅ | ❌ | ✅ |
+| Feature 2 | ❌ | ✅ | 🟡 |
+
+### Implications for Us
+1. [Actionable insight 1]
+2. [Actionable insight 2]
+
+### Sources
+1. [Title](URL) — accessed [date]
+```
+
+### 5. Quality Checks
+- Cross-reference claims across multiple sources
+- Check source dates — prefer recent information
+- Distinguish facts from opinions
+- Note any gaps in available information
+
+## Compete Analysis Framework (for PM work)
+1. **Product capabilities**: Feature comparison matrix
+2. **User experience**: UX/UI differences
+3. **Performance**: Speed, accuracy, reliability
+4. **Pricing**: Cost comparison
+5. **Market position**: User base, growth trends
+6. **Strengths to learn from**: What they do better
+7. **Weaknesses to exploit**: Where we can win
+
+## Important Notes
+- Always cite sources with URLs
+- Clearly mark speculation vs confirmed facts
+- For sensitive compete data, check if it's public before sharing
+- Save research output as PDF for easy sharing (use create-pdf-report skill)