← Back to Skills Marketplace
vincentchan

Linear Autopilot

by vincentchan · GitHub ↗ · v1.0.2
cross-platform ⚠ suspicious
1928
Downloads
0
Stars
0
Active Installs
4
Versions
Install in OpenClaw
/install linear-autopilot
Description
Automate Linear task processing with Discord notifications and git sync. Use when setting up a kanban-to-agent workflow where Linear tasks trigger Clawdbot a...
README (SKILL.md)

Linear Autopilot

🔒 Security Note: This skill mentions API keys, tokens, and webhook URLs because it teaches you how to set up integrations with Linear, Discord, and automation services (Make.com, Pipedream, Zapier). These are necessary for the tutorial — the skill does NOT collect or transmit your credentials. All setup happens on your local machine and the services you configure.

Automated pipeline: Linear → Webhook Service → Discord → Clawdbot → Git

Tasks created in Linear automatically trigger Clawdbot processing with real-time notifications and git sync for Obsidian/local access.

Free Tier Limitations

Before setup, be aware of free plan limits:

Service Free Tier Limits Recommendation
Linear 250 issues, unlimited members Sufficient for most personal/small team use
Make.com 1,000 ops/month, 2 scenarios, 15-min interval Best free option — generous limits
Pipedream ~100 credits (unclear reset), instant triggers Good if you need real-time, burns credits fast
Zapier 100 tasks/month, 5 zaps, 15-min polling, no webhooks ⚠️ Paid plan required for this workflow

Important notes:

  • Make.com offers 1,000 ops/month free — our recommendation for free tier users
  • Pipedream has instant webhooks but limited free credits that deplete quickly
  • Zapier free plan does NOT support webhooks. You need a paid Zapier plan (Starter+)
  • For budget-conscious users: use Make.com

Setup

1. Configure Linear API

Run setup to store your Linear API key:

mkdir -p ~/.clawdbot
echo "LINEAR_API_KEY=lin_api_xxxxx" > ~/.clawdbot/linear.env

Get your API key from: Linear → Settings → API → Personal API keys

2. Get Linear IDs

Find your team and state IDs:

./scripts/linear-api.sh teams    # Get team ID
./scripts/linear-api.sh states   # Get state IDs (Todo, In Progress, Done)

Update ~/.clawdbot/linear-config.json:

{
  "teamId": "your-team-id",
  "states": {
    "todo": "state-id-for-todo",
    "inProgress": "state-id-for-in-progress",
    "done": "state-id-for-done"
  },
  "discord": {
    "notifyUserId": "your-discord-user-id",
    "taskChannelId": "your-linear-tasks-channel-id"
  },
  "git": {
    "autoPush": true,
    "commitPrefix": "task:"
  }
}

3. Set Up Webhook Service

Choose your preferred automation platform:

Option A: Make.com (Recommended for free tier)

  • 1,000 operations/month free
  • 15-minute minimum interval on free tier
  • See references/make-setup.md for step-by-step guide

Quick setup:

  1. Create scenario at make.com
  2. Add Linear "Watch Issues" trigger
  3. Add filter: state.name = "Todo"
  4. Add Discord webhook action
  5. Activate scenario

Option B: Pipedream (If you need instant triggers)

  • Instant webhook triggers
  • Limited free credits (deplete fast)
  • See references/pipedream-setup.md for step-by-step guide

Quick setup:

  1. Create workflow at pipedream.com with HTTP webhook trigger
  2. Add Linear webhook pointing to your Pipedream URL
  3. Add Discord "Send Message" step with Clawdbot bot token
  4. Message template:
    \x3C@BOT_ID>
    📋 New task: {{steps.trigger.event.data.title}}
      Status: {{steps.trigger.event.data.state.name}}
      ID: {{steps.trigger.event.data.identifier}}
    

Option B: Zapier (If you have a paid account)

  • 100 tasks/month on free (very limited)
  • Native Linear + Discord integrations
  • See references/zapier-setup.md for step-by-step guide

Quick setup:

  1. Create Zap: Linear (New Issue) → Discord (Send Channel Message)
  2. Use webhook or bot integration for Discord
  3. Map Linear fields to message template

4. Configure Discord Channel

Ensure Clawdbot listens to your task channel. In clawdbot.json:

{
  "channels": {
    "discord": {
      "guilds": {
        "YOUR_GUILD_ID": {
          "channels": {
            "YOUR_TASK_CHANNEL_ID": {
              "allow": true,
              "requireMention": false
            }
          }
        }
      }
    }
  }
}

Task Processing Workflow

When a task arrives in the Discord channel:

1. Acknowledge

  • Reply in channel confirming receipt

2. Notify User via DM

Use message tool:
- action: send
- target: [user ID from config]
- message: "📋 New task: [ID] - [title]. Starting now..."

3. Process Task

  • Update Linear status → "In Progress" via ./scripts/linear-api.sh start [task-id]
  • Execute the task (spawn sub-agent if complex)
  • Save outputs to appropriate location (research/, content/, etc.)

4. Complete

  • Update Linear status → "Done" via ./scripts/linear-api.sh done [task-id]
  • Add comment with results via ./scripts/linear-api.sh comment [task-id] "[summary]"
  • Send completion DM to user

5. Git Sync (if enabled)

git add [output files]
git commit -m "task: [ID] - [title]"
git push

Script Reference

scripts/linear-api.sh commands:

Command Description
teams List teams and IDs
states List workflow states
get [id] Get task details
pending List pending tasks
start [id] Mark as In Progress
done [id] Mark as Done
comment [id] "text" Add comment to task

Example Task Types

This workflow handles any task type:

  • Research: Spawn sub-agent, save to research/[topic].md
  • Content creation: Generate drafts, save to content/
  • Code tasks: Write/modify code, commit changes
  • Data processing: Run scripts, output results
  • Custom: Define your own output patterns

Troubleshooting

Tasks not triggering?

  • Check Pipedream workflow is enabled
  • Verify Discord channel is in Clawdbot config
  • Ensure allowBots: true if using webhook

Linear API errors?

  • Verify API key in ~/.clawdbot/linear.env
  • Check team/state IDs are correct

Git push failing?

  • Ensure git remote is configured
  • Check SSH key or credentials
Usage Guidance
This skill appears to implement the advertised Linear → Discord → git workflow, but there are important mismatches and privacy considerations you should address before installing: - Metadata vs instructions: The registry declares no required env vars or binaries, but SKILL.md and scripts require a LINEAR_API_KEY and expect curl, jq, and git. Treat the script as requiring these tools and the API key even though the registry omits them. - Secrets handling: The instructions ask you to store your Linear API key in ~/.clawdbot/linear.env and to use Discord/Clawdbot tokens in automation services. Use a limited-scope Linear key if available, set file permissions (chmod 600 ~/.clawdbot/linear.env), and avoid pasting credentials into third-party paste sites. Consider creating service-specific or short-lived tokens. - Review the script before running: scripts/linear-api.sh performs GraphQL calls using your API key, parses JSON with jq, and can run git commit/push as part of the workflow. Inspect it locally and run it manually in a controlled environment first. Ensure you have jq/curl/git installed and understand how git push will authenticate (SSH key or credential helper). - External services and bot tokens: The guides recommend Make.com, Pipedream, or Zapier and instruct you to attach your Clawdbot Discord bot token to workflows. Grant the Discord bot the minimum permissions it needs and prefer webhooks where possible to avoid exposing bot tokens widely. - Autonomous scope: The SKILL.md mentions spawning sub-agents and automatically processing tasks. If you will allow autonomous agent invocation, be explicit about limits and where outputs are written (research/, content/, etc.). If you prefer manual control, run the workflow in a test environment first. If you want to proceed: (1) inspect the scripts and SKILL.md thoroughly, (2) create limited-scope API tokens, (3) set strict file permissions for stored secrets, (4) test in an isolated repo and Discord server, and (5) ensure your automation platform (Make/Pipedream/Zapier) does not expose tokens in logs you can't control.
Capability Analysis
Type: OpenClaw Skill Name: linear-autopilot Version: 1.0.2 The `scripts/linear-api.sh` file contains critical shell injection vulnerabilities. The `graphql` function directly embeds user-controlled variables (e.g., `$task_id`, `$identifier`, `$comment`, `$TEAM_ID`) into the `curl -d` argument without proper shell escaping. This flaw could allow an attacker to execute arbitrary commands on the system by crafting malicious input strings, leading to Remote Code Execution (RCE). While this is a severe vulnerability, there is no clear evidence of intentional malicious behavior such as data exfiltration or persistence mechanisms, classifying it as suspicious rather than malicious.
Capability Assessment
Purpose & Capability
The skill claims to automate Linear tasks with Discord notifications and git sync, which matches the provided scripts and guides. However, the registry metadata declares no required environment variables or binaries, while the SKILL.md and scripts require a LINEAR_API_KEY, and expect tools such as curl, jq and git. This mismatch is incoherent: a Linear integration legitimately needs an API key and network tools, so those should be declared.
Instruction Scope
The SKILL.md instructs creating ~/.clawdbot/linear.env and ~/.clawdbot/linear-config.json and to place API keys and Discord/Clawdbot tokens into automation services. It also tells the agent to 'spawn sub-agent if complex' and to run git commit/push. Those steps go beyond merely translating events and include file writes, network calls, and autonomous sub-agent spawning — all of which widen the operational scope and require explicit declaration and user attention.
Install Mechanism
There is no install spec (instruction-only), which is lower risk. The repo includes a shell script that will be run by the user. No remote downloads or extraction are present. Still, the script depends on curl, jq and git being available and will read/write files in the user's home directory; these runtime expectations should be documented in metadata.
Credentials
The registry lists no required env vars, but SKILL.md and scripts require LINEAR_API_KEY and the guides instruct using Clawdbot/Discord bot tokens in automation platforms. Those credentials are necessary for the functionality, so omitting them from declared requirements is an inconsistency. The skill asks users to store secrets in a plaintext file (~/.clawdbot/linear.env) without recommending permissions or limited-scope keys.
Persistence & Privilege
The skill is not always: true and does not request elevated platform privileges. It writes/reads its own config under ~/.clawdbot and references clawdbot.json (Clawdbot config), which is reasonable for this integration, but users should be aware the skill will create files in their home directory.
How to Use
  1. Make sure OpenClaw is installed (local or Docker)
  2. Run the install command in chat: /install linear-autopilot
  3. After installation, invoke the skill by name or use /linear-autopilot
  4. Provide required inputs per the skill's parameter spec and get structured output
Version History
v1.0.2
v1.0.2: Added security disclaimer explaining why the skill mentions API keys and credentials (required for integration setup tutorial)
v1.1.0
Add Make.com as recommended free tier option (1,000 ops/month vs Pipedream's limited credits)
v1.0.1
Clarify Zapier requires paid plan (no webhooks on free tier)
v1.0.0
Initial release: Linear → Pipedream/Zapier → Discord → Clawdbot → Git pipeline with free tier guidance
Metadata
Slug linear-autopilot
Version 1.0.2
License
All-time Installs 0
Active Installs 0
Total Versions 4
Frequently Asked Questions

What is Linear Autopilot?

Automate Linear task processing with Discord notifications and git sync. Use when setting up a kanban-to-agent workflow where Linear tasks trigger Clawdbot a... It is an AI Agent Skill for Claude Code / OpenClaw, with 1928 downloads so far.

How do I install Linear Autopilot?

Run "/install linear-autopilot" in the OpenClaw or Claude Code chat to install it in one step — no extra setup required.

Is Linear Autopilot free?

Yes, Linear Autopilot is completely free (open-source). You can download, install and use it at no cost.

Which platforms does Linear Autopilot support?

Linear Autopilot is cross-platform and runs anywhere OpenClaw / Claude Code is available (cross-platform).

Who created Linear Autopilot?

It is built and maintained by vincentchan (@vincentchan); the current version is v1.0.2.

💬 Comments