TrackerHacker is an MCP server published by com.trackerhacker, hosted at trackerhacker.com. When last checked on 2026-11-22 it was working: it answers and lists its tools. It declares 68 tools, including read_guide, start_tracking, create_custom_track, list_tracks, check_tracks.
Spreadsheets that fill themselves from your emails and webhooks, the same way every time.
1 connections through 4 shared values. Tap any node.
Squares are this server's values; dots are other servers sharing them. A shared address or publisher is a lead, not proof of a common operator.
Inferred from the host name and headers: what a server runs on, not who runs it.
How TrackerHacker works and how to write hacks, mappings, rules, cards and questions, one page at a time. Pages: overview (Read first: the words (track, hack, mapping, Inbox) and the usual order of calls.); templates (Before writing or checking a text template: fields, types, date formats, skips, lists, and how to make one that lasts.); json (When messages arrive as JSON (a webhook, Zapier, a Shortcut).); mappings (Before save_hack with a mapping: field, const, the day it arrived, negate, cents, required columns, row keys.); rules (When the person wants some rows kept out (small amounts, another account, a sender).); actions (Before set_questions or answer_question: the To do tab, and how formulas ask the person things in To do.); glance (Before set_glance or reminders: the numbers a sheet shows in the app, and when the person is notified.); guard-rails (When the person wants to hold themselves to a plan (a budget, hours, a routine): how to build it from sheet formulas, cards, questions and lists.); sharing (Before building a hack (look for a shared one first), and before share_hack or share_template.); fixing (When a hack stopped matching, messages wait in the Inbox, or for a scheduled check.); privacy (What to keep out of templates and sheets, and what assistants can't do.). Leave out page for the list.
| Parameter | Type | Description |
|---|---|---|
| page | string | one of ["overview","templates","json","mappings","rules","actions","glance","guard-rails","sharing","fixing","privacy"] |
{
"name": "read_guide",
"title": "Read the guide",
"description": "How TrackerHacker works and how to write hacks, mappings, rules, cards and questions, one page at a time. Pages: overview (Read first: the words (track, hack, mapping, Inbox) and the usual order of calls.); templates (Before writing or checking a text template: fields, types, date formats, skips, lists, and how to make one that lasts.); json (When messages arrive as JSON (a webhook, Zapier, a Shortcut).); mappings (Before save_hack with a mapping: field, const, the day it arrived, negate, cents, required columns, row keys.); rules (When the person wants some rows kept out (small amounts, another account, a sender).); actions (Before set_questions or answer_question: the To do tab, and how formulas ask the person things in To do.); glance (Before set_glance or reminders: the numbers a sheet shows in the app, and when the person is notified.); guard-rails (When the person wants to hold themselves to a plan (a budget, hours, a routine): how to build it from sheet formulas, cards, questions and lists.); sharing (Before building a hack (look for a shared one first), and before share_hack or share_template.); fixing (When a hack stopped matching, messages wait in the Inbox, or for a scheduled check.); privacy (What to keep out of templates and sheets, and what assistants can't do.). Leave out page for the list.",
"inputSchema": {
"type": "object",
"properties": {
"page": {
"enum": [
"overview",
"templates",
"json",
"mappings",
"rules",
"actions",
"glance",
"guard-rails",
"sharing",
"fixing",
"privacy"
],
"type": "string"
}
},
"additionalProperties": false
},
"annotations": {
"title": "Read the guide",
"readOnlyHint": true,
"openWorldHint": false,
"destructiveHint": false
}
}Older way to start, kept for assistants that still use it: prefer find_templates and install_template, then find_hacks with the new trackId. Starts from the template the person's words match best ("track my Shopify orders"), or gives back their track on that topic when they have one (created is false). sources lists TrackerHacker's own sources the words named for it: turn one on with turn_on_ready_hack. With forSharing and a schemaId, it's how a template author starts a new, empty sheet to share. Tell the person every line of tell_the_person.
| Parameter | Type | Description |
|---|---|---|
| bare | boolean | With forSharing: only TrackerHacker's theme, without the starter's Start here, Settings and Glance tabs, for a minimal base. |
| text | string | What the person wants to track, in their words. |
| starter | string | A topic id (schemaId), for assistants that kept one: starts from the most copied template on that topic. |
| trackId | string | When the person has several tracks on the topic (otherTracks): the one to use. |
| schemaId | string | With forSharing: the topic of the template to make. |
| forSharing | boolean | true makes a new, empty sheet on schemaId, with no hacks or links, to share with share_template: nothing of the person's can reach it. |
Use this when the person wants something tracked over time and no shared template fits. Makes a new kind of sheet with the columns the person agreed to: show them the columns first and wait for a yes or their changes. Rows come from forwarded emails (source email, then a hack: test_hack and save_hack) or from an app or Shortcut posting JSON (source webhook). Tell the person every line of tell_the_person.
| Parameter | Type | Description |
|---|---|---|
| string | The person's mail app, for email sources. | |
| name * | string | The sheet's name, like "Utility bills". |
| fields * | array | The columns, 1 to 15. The first required one is usually a date. |
| notify | boolean | Whether to notify the person about new rows the sheet asks about. |
| source * | string | Where rows come from. |
| description | string | One line on what it tracks. |
{
"name": "create_custom_track",
"title": "Create a custom track",
"description": "Use this when the person wants something tracked over time and no shared template fits. Makes a new kind of sheet with the columns the person agreed to: show them the columns first and wait for a yes or their changes. Rows come from forwarded emails (source email, then a hack: test_hack and save_hack) or from an app or Shortcut posting JSON (source webhook). Tell the person every line of tell_the_person.",
"inputSchema": {
"type": "object",
"required": [
"name",
"fields",
"source"
],
"properties": {
"mail": {
"enum": [
"gmail",
"outlook",
"other",
"none"
],
"type": "string",
"description": "The person's mail app, for email sources."
},
"name": {
"type": "string",
"description": "The sheet's name, like \"Utility bills\"."
},
"fields": {
"type": "array",
"items": {
"type": "object",
"required": [
"label",
"type"
],
"properties": {
"type": {
"enum": [
"text",
"number",
"currency",
"date",
"datetime",
"boolean",
"enum",
"url"
],
"type": "string"
},
"label": {
"type": "string",
"description": "The column header, like \"Amount\"."
},
"choices": {
"type": "array",
"items": {
"type": "string"
},
"description": "The allowed values, for type enum."
},
"meaning": {
"type": "string",
"description": "What the value means: units, sign, what's included."
},
"required": {
"type": "boolean"
}
},
"additionalProperties": false
},
"description": "The columns, 1 to 15. The first required one is usually a date."
},
"notify": {
"type": "boolean",
"description": "Whether to notify the person about new rows the sheet asks about."
},
"source": {
"enum": [
"email",
"webhook"
],
"type": "string",
"description": "Where rows come from."
},
"description": {
"type": "string",
"description": "One line on what it tracks."
}
},
"additionalProperties": false
},
"annotations": {
"title": "Create a custom track",
"readOnlyHint": false,
"openWorldHint": false,
"idempotentHint": false,
"destructiveHint": false
}
}The person's tracks (sheets), each with its id, link, columns, the hacks that fill it (each with its state: On, Off, Stopped matching, or Paused when it's over the plan's limit, and its note, a line on what it catches and leaves out, when it has one) and this week's numbers, plus the Google account you're connected to (signedInAs) and their TrackerHacker email address for forwarding. Call this first.
No parameters.
{
"name": "list_tracks",
"title": "List the person's tracks",
"description": "The person's tracks (sheets), each with its id, link, columns, the hacks that fill it (each with its state: On, Off, Stopped matching, or Paused when it's over the plan's limit, and its note, a line on what it catches and leaves out, when it has one) and this week's numbers, plus the Google account you're connected to (signedInAs) and their TrackerHacker email address for forwarding. Call this first.",
"inputSchema": {
"type": "object",
"properties": {},
"additionalProperties": false
},
"annotations": {
"title": "List the person's tracks",
"readOnlyHint": true,
"openWorldHint": false,
"destructiveHint": false
}
}What needs attention across all the person's tracks: hacks that stopped matching their senders' messages (the sender probably changed its emails), messages waiting in each Inbox, sheets TrackerHacker lost access to, and this week's failures. Good for a scheduled check. Each problem says what to do next. suggestions, which aren't problems, name columns a hack could fill but leaves empty (often a column a new minor version of the schema added): offer them to the person.
No parameters.
{
"name": "check_tracks",
"title": "Check what needs fixing",
"description": "What needs attention across all the person's tracks: hacks that stopped matching their senders' messages (the sender probably changed its emails), messages waiting in each Inbox, sheets TrackerHacker lost access to, and this week's failures. Good for a scheduled check. Each problem says what to do next. suggestions, which aren't problems, name columns a hack could fill but leaves empty (often a column a new minor version of the schema added): offer them to the person.",
"inputSchema": {
"type": "object",
"properties": {},
"additionalProperties": false
},
"annotations": {
"title": "Check what needs fixing",
"readOnlyHint": true,
"openWorldHint": false,
"destructiveHint": false
}
}Reads one track's data tab and names rows its formulas would read wrong: the same key on two rows (an update finds only the first), a column every row needs left empty, and a date or number typed as text (totals and filters skip it). Each problem gives the column and the sheet's row numbers (the first 20, with count for all). edited counts rows someone changed by hand after TrackerHacker wrote them, when the sheet has the Sheets add-on's Edited by hand column; their cell history in Google Sheets says who. Tell the person what you found and where; fix a cell only when they ask (update_row).
| Parameter | Type | Description |
|---|---|---|
| trackId * | string | From list_tracks. |
{
"name": "check_data",
"title": "Check a sheet's rows",
"description": "Reads one track's data tab and names rows its formulas would read wrong: the same key on two rows (an update finds only the first), a column every row needs left empty, and a date or number typed as text (totals and filters skip it). Each problem gives the column and the sheet's row numbers (the first 20, with count for all). edited counts rows someone changed by hand after TrackerHacker wrote them, when the sheet has the Sheets add-on's Edited by hand column; their cell history in Google Sheets says who. Tell the person what you found and where; fix a cell only when they ask (update_row).",
"inputSchema": {
"type": "object",
"required": [
"trackId"
],
"properties": {
"trackId": {
"type": "string",
"description": "From list_tracks."
}
},
"additionalProperties": false
},
"annotations": {
"title": "Check a sheet's rows",
"readOnlyHint": true,
"openWorldHint": false,
"destructiveHint": false
}
}For one row of a track (its number from read_rows), a Gmail search for the email it was made from: from the senders of the hack that wrote it, around the day TrackerHacker received it, with the row's key when it has one. Gives the search (query), a link that opens it in Gmail (url) and the hack's name. TrackerHacker opens no mail for this. If you can search the person's Gmail yourself, run query there; otherwise give the person the link. A row someone added by hand, by a form or from a webhook has no email, and the answer says so.
| Parameter | Type | Description |
|---|---|---|
| row * | integer | The row's number from read_rows. |
| trackId * | string | From list_tracks. |
{
"name": "find_row_email",
"title": "Find the email a row came from",
"description": "For one row of a track (its number from read_rows), a Gmail search for the email it was made from: from the senders of the hack that wrote it, around the day TrackerHacker received it, with the row's key when it has one. Gives the search (query), a link that opens it in Gmail (url) and the hack's name. TrackerHacker opens no mail for this. If you can search the person's Gmail yourself, run query there; otherwise give the person the link. A row someone added by hand, by a form or from a webhook has no email, and the answer says so.",
"inputSchema": {
"type": "object",
"required": [
"trackId",
"row"
],
"properties": {
"row": {
"type": "integer",
"minimum": 2,
"description": "The row's number from read_rows."
},
"trackId": {
"type": "string",
"description": "From list_tracks."
}
},
"additionalProperties": false
},
"annotations": {
"title": "Find the email a row came from",
"readOnlyHint": true,
"openWorldHint": false,
"destructiveHint": false
}
}Suggests a hack (a template that reads one kind of message) from an example email or JSON body, for a track. It's checked against similar messages waiting in the track's Inbox. A fallback: write the template yourself first and check it with test_hack, and call this only after two tries fail. Each call uses one of the person's daily AI suggestions, and assistants get 3 a day. Check the answer with test_hack, then save it with save_hack.
| Parameter | Type | Description |
|---|---|---|
| hackId | string | To fix a hack that stopped matching: its id. Its fields and senders are kept, so its columns stay mapped. |
| answers | object | Answers to a suggestion's questions, by column key: the text the person picked for that column, copied from the example. Ask the person, don't pick for them. |
| example * | string | The whole message as received or forwarded, with its From and Subject lines if you have them. |
| senders | array | Addresses or domains this kind of message comes from, like "chase.com". |
| trackId * | string | From list_tracks. |
{
"name": "suggest_hack",
"title": "Suggest an email-reading rule (hack) from an example message",
"description": "Suggests a hack (a template that reads one kind of message) from an example email or JSON body, for a track. It's checked against similar messages waiting in the track's Inbox. A fallback: write the template yourself first and check it with test_hack, and call this only after two tries fail. Each call uses one of the person's daily AI suggestions, and assistants get 3 a day. Check the answer with test_hack, then save it with save_hack.",
"inputSchema": {
"type": "object",
"required": [
"trackId",
"example"
],
"properties": {
"hackId": {
"type": "string",
"description": "To fix a hack that stopped matching: its id. Its fields and senders are kept, so its columns stay mapped."
},
"answers": {
"type": "object",
"description": "Answers to a suggestion's questions, by column key: the text the person picked for that column, copied from the example. Ask the person, don't pick for them.",
"additionalProperties": {
"type": "string"
}
},
"example": {
"type": "string",
"description": "The whole message as received or forwarded, with its From and Subject lines if you have them."
},
"senders": {
"type": "array",
"items": {
"type": "string"
},
"description": "Addresses or domains this kind of message comes from, like \"chase.com\"."
},
"trackId": {
"type": "string",
"description": "From list_tracks."
}
},
"additionalProperties": false
},
"annotations": {
"title": "Suggest an email-reading rule (hack) from an example message",
"readOnlyHint": false,
"openWorldHint": false,
"destructiveHint": false
}
}Shows what a hack template reads from example messages, without saving anything. Templates are the message's fixed text with {{field:type}} where values go (types: text, number, currency, date, datetime, boolean, url), {{...}} for parts that change but aren't wanted, {{#each}}...{{/each}} around a repeating list, and {{or}} on its own line between wordings of the same kind of message. A json template is an example JSON body with values replaced by {{field:type}}.
| Parameter | Type | Description |
|---|---|---|
| parser | string | text for emails (the default), json for webhook bodies. |
| mapping | object | With trackId: column key to source, as in save_hack. Leave out to match fields to columns by name. |
| trackId | string | Optional: the track the hack is for. Then each example's row is shown column by column, with any problems found, so you can check every column holds what its header means before save_hack. |
| examples * | array | 1 to 10 example messages. |
| template * | string |
{
"name": "test_hack",
"title": "Test an email-reading rule (hack) on example messages",
"description": "Shows what a hack template reads from example messages, without saving anything. Templates are the message's fixed text with {{field:type}} where values go (types: text, number, currency, date, datetime, boolean, url), {{...}} for parts that change but aren't wanted, {{#each}}...{{/each}} around a repeating list, and {{or}} on its own line between wordings of the same kind of message. A json template is an example JSON body with values replaced by {{field:type}}.",
"inputSchema": {
"type": "object",
"required": [
"template",
"examples"
],
"properties": {
"parser": {
"enum": [
"text",
"json"
],
"type": "string",
"description": "text for emails (the default), json for webhook bodies."
},
"mapping": {
"type": "object",
"description": "With trackId: column key to source, as in save_hack. Leave out to match fields to columns by name."
},
"trackId": {
"type": "string",
"description": "Optional: the track the hack is for. Then each example's row is shown column by column, with any problems found, so you can check every column holds what its header means before save_hack."
},
"examples": {
"type": "array",
"items": {
"type": "string"
},
"description": "1 to 10 example messages."
},
"template": {
"type": "string"
}
},
"additionalProperties": false
},
"annotations": {
"title": "Test an email-reading rule (hack) on example messages",
"readOnlyHint": true,
"openWorldHint": false,
"destructiveHint": false
}
}Saves a hack and attaches it to a track, so matching messages become rows from now on, then runs the track's Inbox again so messages already waiting become rows too (inbox says how many). Give hackId to change one that exists: send only what changes, and its name, template, senders, subjects, mapping and whether it's on stay as they are. mapping says which hack field fills which column, as {"column_key": {"kind": "field", "key": "hack_field"}} or {"kind": "const", "value": "..."}, or {"kind": "received"} to fill a date column with when the message arrived; for a new hack, leave it out to match fields to columns by name; with hackId, the columns you send are changed and the rest keep their source. Set senders so only those senders' messages are read, and subjects when a sender also sends other mail (statements, offers) that isn't for this hack.
| Parameter | Type | Description |
|---|---|---|
| name | string | Like "Chase card alert". Needed for a new hack. |
| note | string | One plain line, up to 200 characters, on what this hack catches and what it leaves out, like "Withdrawal alerts only, not deposits" or "Card purchases, not refunds or statements". People and assistants read it beside the hack's name. It steers nothing: the hack runs on its template. Leave out to kee… |
| hackId | string | The hack to change, from list_tracks. Leave out for a new one. |
| parser | string | one of ["text","json"] |
| mapping | object | Column key to source, as in the description. |
| senders | array | Addresses or domains, like "chase.com". |
Messages that reached a track but didn't make a row (no hack read them, or a rule blocked them), newest first, with why: up to 20 of the newest 50. Give from to see only one sender's (when fixing its hack, so the person's other mail stays out of this chat), and before (olderBefore) for the 50 above. Use them as examples for a hack's template, or to see why a hack stopped matching. These are the person's own emails: use them only for setting up their hacks.
| Parameter | Type | Description |
|---|---|---|
| from | string | Only messages from this address or domain, like "chase.com". |
| before | integer | olderBefore from the last call, for older messages. |
| trackId * | string | From list_tracks. |
{
"name": "read_inbox",
"title": "Read a track's Inbox",
"description": "Messages that reached a track but didn't make a row (no hack read them, or a rule blocked them), newest first, with why: up to 20 of the newest 50. Give from to see only one sender's (when fixing its hack, so the person's other mail stays out of this chat), and before (olderBefore) for the 50 above. Use them as examples for a hack's template, or to see why a hack stopped matching. These are the person's own emails: use them only for setting up their hacks.",
"inputSchema": {
"type": "object",
"required": [
"trackId"
],
"properties": {
"from": {
"type": "string",
"description": "Only messages from this address or domain, like \"chase.com\"."
},
"before": {
"type": "integer",
"description": "olderBefore from the last call, for older messages."
},
"trackId": {
"type": "string",
"description": "From list_tracks."
}
},
"additionalProperties": false
},
"annotations": {
"title": "Read a track's Inbox",
"readOnlyHint": true,
"openWorldHint": false,
"destructiveHint": false
}
}Every version kept of a hack, newest first, with its template, senders and subject words. TrackerHacker numbers them itself: major when the template stopped reading the emails the one before read or dropped a field, minor when it reads them and more, patch when it reads the same. To go back to one, save_hack it with hackId: that's saved as the next version, so nothing is lost.
| Parameter | Type | Description |
|---|---|---|
| hackId * | string | From list_tracks. |
{
"name": "hack_versions",
"title": "List an email-reading rule's earlier versions",
"description": "Every version kept of a hack, newest first, with its template, senders and subject words. TrackerHacker numbers them itself: major when the template stopped reading the emails the one before read or dropped a field, minor when it reads them and more, patch when it reads the same. To go back to one, save_hack it with hackId: that's saved as the next version, so nothing is lost.",
"inputSchema": {
"type": "object",
"required": [
"hackId"
],
"properties": {
"hackId": {
"type": "string",
"description": "From list_tracks."
}
},
"additionalProperties": false
},
"annotations": {
"title": "List an email-reading rule's earlier versions",
"readOnlyHint": true,
"openWorldHint": false,
"destructiveHint": false
}
}Runs the track's hacks over its Inbox again, 50 messages at a time from the newest. Messages they now read become rows and leave the Inbox. save_hack, use_community_hack, update_hack_from_community and use_drafted_fix do this themselves; call it after set_rules, when a hack was changed in the app, or with before for older messages.
| Parameter | Type | Description |
|---|---|---|
| before | integer | olderBefore from the last call or from read_inbox, for the 50 messages above those. |
| trackId * | string | From list_tracks. |
{
"name": "rerun_inbox",
"title": "Re-read unmatched Inbox messages with the track's email rules",
"description": "Runs the track's hacks over its Inbox again, 50 messages at a time from the newest. Messages they now read become rows and leave the Inbox. save_hack, use_community_hack, update_hack_from_community and use_drafted_fix do this themselves; call it after set_rules, when a hack was changed in the app, or with before for older messages.",
"inputSchema": {
"type": "object",
"required": [
"trackId"
],
"properties": {
"before": {
"type": "integer",
"description": "olderBefore from the last call or from read_inbox, for the 50 messages above those."
},
"trackId": {
"type": "string",
"description": "From list_tracks."
}
},
"additionalProperties": false
},
"annotations": {
"title": "Re-read unmatched Inbox messages with the track's email rules",
"readOnlyHint": false,
"openWorldHint": false,
"idempotentHint": true,
"destructiveHint": true
}
}Adds rows the person tells you about to a track, like a purchase they made in cash. Each row is an object of columns to values, by column key (from list_tracks) or by the column's name as the sheet shows it; dates as YYYY-MM-DD. All rows are written, or none: a value that doesn't fit its column, or a row a blocking rule keeps out, is refused with the reason. On the person's own tracks, give the row key column (rowKey in list_tracks) to update the row with that key instead of adding one. For an email or webhook body, use send_message instead, so the track's hacks read it.
| Parameter | Type | Description |
|---|---|---|
| rows * | array | 1 to 50 rows. |
| example | boolean | true marks them as made-up example rows (Example in the Hack column), for a sheet you'll share as a template: they show it working, and the person removes them in one tap. |
| trackId * | string | From list_tracks. |
{
"name": "add_rows",
"title": "Add rows",
"description": "Adds rows the person tells you about to a track, like a purchase they made in cash. Each row is an object of columns to values, by column key (from list_tracks) or by the column's name as the sheet shows it; dates as YYYY-MM-DD. All rows are written, or none: a value that doesn't fit its column, or a row a blocking rule keeps out, is refused with the reason. On the person's own tracks, give the row key column (rowKey in list_tracks) to update the row with that key instead of adding one. For an email or webhook body, use send_message instead, so the track's hacks read it.",
"inputSchema": {
"type": "object",
"required": [
"trackId",
"rows"
],
"properties": {
"rows": {
"type": "array",
"items": {
"type": "object"
},
"description": "1 to 50 rows."
},
"example": {
"type": "boolean",
"description": "true marks them as made-up example rows (Example in the Hack column), for a sheet you'll share as a template: they show it working, and the person removes them in one tap."
},
"trackId": {
"type": "string",
"description": "From list_tracks."
}
},
"additionalProperties": false
},
"annotations": {
"title": "Add rows",
"readOnlyHint": false,
"openWorldHint": false,
"idempotentHint": false,
"destructiveHint": true
}
}Adds one line to another tab of the track's sheet, a list it keeps beside its rows (plans, money moved between budgets, chores, people on a rota), when the person tells you one. Not for the data tab: add_rows does that. Call it with trackId and tab alone to get the list's columns (fields: key, label, type, enumValues), which come from the tab's own headers; then with values, an object of column keys or header names to values (dates as YYYY-MM-DD). The line goes under the last one, columns a formula fills are left alone, and Added by and Added at columns are filled when the tab has them. get_glance with forEditing lists the sheet's tabs.
| Parameter | Type | Description |
|---|---|---|
| tab * | string | The tab's name, as the sheet shows it. |
| values | object | The line: each column's key or header to its value. Leave out to get the list's columns. |
| trackId * | string | From list_tracks. |
{
"name": "add_to_list",
"title": "Add a line to a list",
"description": "Adds one line to another tab of the track's sheet, a list it keeps beside its rows (plans, money moved between budgets, chores, people on a rota), when the person tells you one. Not for the data tab: add_rows does that. Call it with trackId and tab alone to get the list's columns (fields: key, label, type, enumValues), which come from the tab's own headers; then with values, an object of column keys or header names to values (dates as YYYY-MM-DD). The line goes under the last one, columns a formula fills are left alone, and Added by and Added at columns are filled when the tab has them. get_glance with forEditing lists the sheet's tabs.",
"inputSchema": {
"type": "object",
"required": [
"trackId",
"tab"
],
"properties": {
"tab": {
"type": "string",
"description": "The tab's name, as the sheet shows it."
},
"values": {
"type": "object",
"description": "The line: each column's key or header to its value. Leave out to get the list's columns."
},
"trackId": {
"type": "string",
"description": "From list_tracks."
}
},
"additionalProperties": false
},
"annotations": {
"title": "Add a line to a list",
"readOnlyHint": false,
"openWorldHint": false,
"idempotentHint": false,
"destructiveHint": false
}
}Reads, changes or removes lines of a list (another tab of the track's sheet, see add_to_list). With trackId and tab alone it gives the list's newest lines, each with its row, its print, what it shows, and mine (whether this person may change it). To change one, send its row and print with values: only the columns you name change, and an empty value empties that cell. To remove one, send its row and print with remove: true, after the person said to. A change lands only while the line still says what you read, so read again if it's refused as changed. Edited by and Edited at columns are filled when the tab has them.
| Parameter | Type | Description |
|---|---|---|
| row | number | The line's row, from the listing. |
| tab * | string | The tab's name, as the sheet shows it. |
| string | The line's print, from the listing. | |
| remove | boolean | true removes the line instead. |
| values | object | The columns to change: each key or header to its new value. |
| trackId * | string | From list_tracks. |
{
"name": "change_list_line",
"title": "Change or remove a line of a list",
"description": "Reads, changes or removes lines of a list (another tab of the track's sheet, see add_to_list). With trackId and tab alone it gives the list's newest lines, each with its row, its print, what it shows, and mine (whether this person may change it). To change one, send its row and print with values: only the columns you name change, and an empty value empties that cell. To remove one, send its row and print with remove: true, after the person said to. A change lands only while the line still says what you read, so read again if it's refused as changed. Edited by and Edited at columns are filled when the tab has them.",
"inputSchema": {
"type": "object",
"required": [
"trackId",
"tab"
],
"properties": {
"row": {
"type": "number",
"description": "The line's row, from the listing."
},
"tab": {
"type": "string",
"description": "The tab's name, as the sheet shows it."
},
"print": {
"type": "string",
"description": "The line's print, from the listing."
},
"remove": {
"type": "boolean",
"description": "true removes the line instead."
},
"values": {
"type": "object",
"description": "The columns to change: each key or header to its new value."
},
"trackId": {
"type": "string",
"description": "From list_tracks."
}
},
"additionalProperties": false
},
"annotations": {
"title": "Change or remove a line of a list",
"readOnlyHint": false,
"openWorldHint": false,
"idempotentHint": false,
"destructiveHint": true
}
}Changes cells of one row in the person's own track, when they correct something ("that burrito was 750 calories, not 600"): read_rows first for the row's number and values, then give values (each column to its new value) and was (each of those columns to the value read_rows showed), so a row that changed since isn't overwritten. Values are checked like added rows'. Only change what the person asked to; don't add a second row for a correction.
| Parameter | Type | Description |
|---|---|---|
| row * | integer | The row's number from read_rows. |
| was * | object | The same columns, to the values read_rows showed in them. |
| values * | object | Column name (as read_rows shows it) to its new value. |
| trackId * | string | From list_tracks. |
{
"name": "update_row",
"title": "Correct a row",
"description": "Changes cells of one row in the person's own track, when they correct something (\"that burrito was 750 calories, not 600\"): read_rows first for the row's number and values, then give values (each column to its new value) and was (each of those columns to the value read_rows showed), so a row that changed since isn't overwritten. Values are checked like added rows'. Only change what the person asked to; don't add a second row for a correction.",
"inputSchema": {
"type": "object",
"required": [
"trackId",
"row",
"values",
"was"
],
"properties": {
"row": {
"type": "integer",
"minimum": 2,
"description": "The row's number from read_rows."
},
"was": {
"type": "object",
"description": "The same columns, to the values read_rows showed in them."
},
"values": {
"type": "object",
"description": "Column name (as read_rows shows it) to its new value."
},
"trackId": {
"type": "string",
"description": "From list_tracks."
}
},
"additionalProperties": false
},
"annotations": {
"title": "Correct a row",
"readOnlyHint": false,
"openWorldHint": false,
"idempotentHint": true,
"destructiveHint": true
}
}Hands an email (its From address, subject and text) or a JSON body to one of the person's own tracks, to be read by its hacks exactly as if they had forwarded it: the hacks' fixed rules make the rows, and schema checks, row keys, blocking rules and the Inbox all apply. Use this rather than add_rows for messages, so every row comes out the same way. A message no hack reads waits in the Inbox: then build a hack for it (suggest_hack, test_hack, save_hack) and rerun_inbox. The same message sent twice makes its rows once.
| Parameter | Type | Description |
|---|---|---|
| from | string | The original sender's address, like alerts@chase.com. Hacks limited to senders read only their senders' messages. |
| text * | string | The message's text as received, or a JSON body. |
| subject | string | |
| trackId * | string | From list_tracks. |
| messageId | string | The email's Message-ID, if you have it. |
{
"name": "send_message",
"title": "Send a message to a track",
"description": "Hands an email (its From address, subject and text) or a JSON body to one of the person's own tracks, to be read by its hacks exactly as if they had forwarded it: the hacks' fixed rules make the rows, and schema checks, row keys, blocking rules and the Inbox all apply. Use this rather than add_rows for messages, so every row comes out the same way. A message no hack reads waits in the Inbox: then build a hack for it (suggest_hack, test_hack, save_hack) and rerun_inbox. The same message sent twice makes its rows once.",
"inputSchema": {
"type": "object",
"required": [
"trackId",
"text"
],
"properties": {
"from": {
"type": "string",
"description": "The original sender's address, like alerts@chase.com. Hacks limited to senders read only their senders' messages."
},
"text": {
"type": "string",
"description": "The message's text as received, or a JSON body."
},
"subject": {
"type": "string"
},
"trackId": {
"type": "string",
"description": "From list_tracks."
},
"messageId": {
"type": "string",
"description": "The email's Message-ID, if you have it."
}
},
"additionalProperties": false
},
"annotations": {
"title": "Send a message to a track",
"readOnlyHint": false,
"openWorldHint": false,
"idempotentHint": true,
"destructiveHint": true
}
}What the track's Glance cards show now (cards: label, value, detail, tone), and whether cards that turn warn or bad notify the person (alerts). This answers "am I over budget?". With forEditing: true it gives what set_glance needs instead: each card's cells as written, formulas included (cards), what they show (shown), the sheet's tabs and its data tab's columns (dataTabMissing, when there, says the data tab is gone and what the person can do).
| Parameter | Type | Description |
|---|---|---|
| trackId * | string | From list_tracks. |
| forEditing | boolean | true before set_glance: the cards' cells and formulas, the tabs and the data columns. |
{
"name": "get_glance",
"title": "Get a track's Glance cards",
"description": "What the track's Glance cards show now (cards: label, value, detail, tone), and whether cards that turn warn or bad notify the person (alerts). This answers \"am I over budget?\". With forEditing: true it gives what set_glance needs instead: each card's cells as written, formulas included (cards), what they show (shown), the sheet's tabs and its data tab's columns (dataTabMissing, when there, says the data tab is gone and what the person can do).",
"inputSchema": {
"type": "object",
"required": [
"trackId"
],
"properties": {
"trackId": {
"type": "string",
"description": "From list_tracks."
},
"forEditing": {
"type": "boolean",
"description": "true before set_glance: the cards' cells and formulas, the tabs and the data columns."
}
},
"additionalProperties": false
},
"annotations": {
"title": "Get a track's Glance cards",
"readOnlyHint": true,
"openWorldHint": false,
"destructiveHint": false
}
}How the track's sheet is meant to be used, in its author's words: the lines of its Start here tab (startHere), the lines its author headed For assistants (forAssistants: what you should do, or never do, in this sheet), its tabs, its data tab and its Settings (each setting with its value). TrackerHacker's guide says how TrackerHacker works; this says how one sheet works: which list to add to for what, which answers it expects, which columns its formulas fill. Read it before working in a sheet's own tabs (add_to_list, set_card_value, answering its questions, add_rows beyond a plain payment or entry), and follow its For assistants lines.
| Parameter | Type | Description |
|---|---|---|
| trackId * | string | From list_tracks. |
{
"name": "get_sheet_guide",
"title": "Read how a sheet is meant to be used",
"description": "How the track's sheet is meant to be used, in its author's words: the lines of its Start here tab (startHere), the lines its author headed For assistants (forAssistants: what you should do, or never do, in this sheet), its tabs, its data tab and its Settings (each setting with its value). TrackerHacker's guide says how TrackerHacker works; this says how one sheet works: which list to add to for what, which answers it expects, which columns its formulas fill. Read it before working in a sheet's own tabs (add_to_list, set_card_value, answering its questions, add_rows beyond a plain payment or entry), and follow its For assistants lines.",
"inputSchema": {
"type": "object",
"required": [
"trackId"
],
"properties": {
"trackId": {
"type": "string",
"description": "From list_tracks."
}
},
"additionalProperties": false
},
"annotations": {
"title": "Read how a sheet is meant to be used",
"readOnlyHint": true,
"openWorldHint": false,
"destructiveHint": false
}
}Changes the cell a Glance card names in its set column (get_glance shows it as set, like 'Goals'!B2), when the person tells you the new value: a goal, an amount per month, a balance. Only cells a card names can be changed, never a formula, and the value must fit the cell (its dropdown, a number, a date as YYYY-MM-DD). Called without value it says what the cell holds now and what it takes. Gives back what the cards show after.
| Parameter | Type | Description |
|---|---|---|
| cell * | string | The card's set cell, as get_glance gives it. |
| value | any | The new value: text, a number, true or false. Leave out to read the cell. |
| trackId * | string | From list_tracks. |
{
"name": "set_card_value",
"title": "Change a value a card lets the person set",
"description": "Changes the cell a Glance card names in its set column (get_glance shows it as set, like 'Goals'!B2), when the person tells you the new value: a goal, an amount per month, a balance. Only cells a card names can be changed, never a formula, and the value must fit the cell (its dropdown, a number, a date as YYYY-MM-DD). Called without value it says what the cell holds now and what it takes. Gives back what the cards show after.",
"inputSchema": {
"type": "object",
"required": [
"trackId",
"cell"
],
"properties": {
"cell": {
"type": "string",
"description": "The card's set cell, as get_glance gives it."
},
"value": {
"description": "The new value: text, a number, true or false. Leave out to read the cell."
},
"trackId": {
"type": "string",
"description": "From list_tracks."
}
},
"additionalProperties": false
},
"annotations": {
"title": "Change a value a card lets the person set",
"readOnlyHint": false,
"openWorldHint": false,
"idempotentHint": true,
"destructiveHint": true
}
}Replaces the cards the track's sheet shows in the app with this list (call get_glance with forEditing: true first, and send the ones it has along with yours). A list shorter than the one it has is refused unless replace is true. Each card is {label, value, detail, group, tone, link, trend, set}; any of them can be a sheet formula starting with =, so the sheet works out the number and whether it's good, warn or bad. A card that turns warn or bad notifies the person. Formulas can't use IMPORT functions, IMAGE, HYPERLINK or WEBSERVICE.
| Parameter | Type | Description |
|---|---|---|
| cards * | array | The whole list, 0 to 50 cards, in the order they show. An empty list removes them all. |
| replace | boolean | true when the person asked to remove some. Without it, a list shorter than the one the track has is refused, so nothing is dropped by mistake. |
| trackId * | string | From list_tracks. |
{
"name": "set_glance",
"title": "Set a track's Glance cards",
"description": "Replaces the cards the track's sheet shows in the app with this list (call get_glance with forEditing: true first, and send the ones it has along with yours). A list shorter than the one it has is refused unless replace is true. Each card is {label, value, detail, group, tone, link, trend, set}; any of them can be a sheet formula starting with =, so the sheet works out the number and whether it's good, warn or bad. A card that turns warn or bad notifies the person. Formulas can't use IMPORT functions, IMAGE, HYPERLINK or WEBSERVICE.",
"inputSchema": {
"type": "object",
"required": [
"trackId",
"cards"
],
"properties": {
"cards": {
"type": "array",
"items": {
"type": "object",
"properties": {
"set": {
"type": "string",
"description": "Optional. One cell with its tab, like Goals!B2, that the person can change from the card in the app (a goal, an amount per month, a balance): a typed cell the card's formulas read, never a formula."
},
"link": {
"type": "string",
"description": "add (the sheet's form, answers after ?, like add?category=Dining), list?tab=Name (a form that adds a line to that tab, answers after &, like list?tab=Moves&from=Dining), todo, sheet, or sheet?tab=Name."
},
"tone": {
"type": "string",
"description": "good, warn, bad or plain, or a formula giving one."
},
"group": {
"type": "string",
"description": "Cards with the same group show together under it."
},
"label": {
"type": "string",
"description": "What the number is, like \"Dining\"."
},
"trend": {
"type": "string",
"description": "Optional. The value over time, oldest first, drawn as a small line on the card: two or more numbers in one cell, usually a formula like =JOIN(\" \", Weeks!B2:B13). Say what the points are in detail (\"last 12 weeks\")."
},
"value": {
"type": "string",
"description": "The number, usually a formula, like =SUMIFS(Transactions!D:D, Transactions!C:C, \"Dining\")."
},
"detail": {
"type": "string",
"description": "One line under it, like \"left of $200\"."
}
},
"additionalProperties": false
},
"description": "The whole list, 0 to 50 cards, in the order they show. An empty list removes them all."
},
"replace": {
"type": "boolean",
"description": "true when the person asked to remove some. Without it, a list shorter than the one the track has is refused, so nothing is dropped by mistake."
},
"trackId": {
"type": "string",
"description": "From list_tracks."
}
},
"additionalProperties": false
},
"annotations": {
"title": "Set a track's Glance cards",
"readOnlyHint": false,
"openWorldHint": false,
"idempotentHint": true,
"destructiveHint": true
}
}Glance alerts: whether a Glance card turning warn or bad notifies the people on the track, once until it turns back. On by default. (To do alerts, whether a new question notifies them, are switched in the app or the sheet's TrackerHacker panel; list_todo says whether they're on.)
| Parameter | Type | Description |
|---|---|---|
| on * | boolean | |
| trackId * | string | From list_tracks. |
{
"name": "set_alerts",
"title": "Turn a track's Glance alerts on or off",
"description": "Glance alerts: whether a Glance card turning warn or bad notifies the people on the track, once until it turns back. On by default. (To do alerts, whether a new question notifies them, are switched in the app or the sheet's TrackerHacker panel; list_todo says whether they're on.)",
"inputSchema": {
"type": "object",
"required": [
"trackId",
"on"
],
"properties": {
"on": {
"type": "boolean"
},
"trackId": {
"type": "string",
"description": "From list_tracks."
}
},
"additionalProperties": false
},
"annotations": {
"title": "Turn a track's Glance alerts on or off",
"readOnlyHint": false,
"openWorldHint": false,
"idempotentHint": true,
"destructiveHint": false
}
}A reminder nudges the person on their phone or browser at a time of day, on some days of the week, to add a row ("Log your mileage"), with a button that opens the form with some answers filled in. action list shows a track's reminders; add makes one (label, days, time, and preset, skipIfLogged or summary); remove takes one away by its reminderId from list.
| Parameter | Type | Description |
|---|---|---|
| days | array | add: days of the week, 0 Sunday to 6 Saturday. |
| time | string | add: the time of day in the person's timezone, as HH:MM, like 08:30. |
| label | string | add: what it says, like "Log your mileage". |
| action * | string | one of ["list","add","remove"] |
| preset | object | add: answers to fill in, by column key. |
| summary | boolean | add: send a short summary of the sheet instead. |
| trackId | string | From list_tracks. |
| reminderId | string | remove: the reminder's id. |
| skipIfLogged | boolean | add: quiet on a day something was already added. |
The questions the track's sheet asks the person in To do (its To do tab): each row's cells as written, formulas included, and what it asks now (asking). Also the sheet's tabs and its data tab's columns, for writing formulas.
| Parameter | Type | Description |
|---|---|---|
| trackId * | string | From list_tracks. |
{
"name": "get_questions",
"title": "Get the questions a track's sheet asks",
"description": "The questions the track's sheet asks the person in To do (its To do tab): each row's cells as written, formulas included, and what it asks now (asking). Also the sheet's tabs and its data tab's columns, for writing formulas.",
"inputSchema": {
"type": "object",
"required": [
"trackId"
],
"properties": {
"trackId": {
"type": "string",
"description": "From list_tracks."
}
},
"additionalProperties": false
},
"annotations": {
"title": "Get the questions a track's sheet asks",
"readOnlyHint": true,
"openWorldHint": false,
"destructiveHint": false
}
}Replaces the questions in the track's To do tab with this list (call get_questions first, and send the ones it has along with yours). A list shorter than the one it has is refused unless replace is true. Each is {id, prompt, type, options, target, group, context, to, for}; any of them can be a sheet formula starting with =, so the sheet decides when to ask (a formula giving an empty prompt asks nothing) and where the answer goes. Answers already given stay in their rows, so keep a question's row when changing it. Formulas can't use IMPORT functions, IMAGE, HYPERLINK or WEBSERVICE.
| Parameter | Type | Description |
|---|---|---|
| replace | boolean | true when the person asked to remove some. Without it, a list shorter than the one the track has is refused, so nothing is dropped by mistake. |
| trackId * | string | From list_tracks. |
| questions * | array | The whole list, 0 to 100, one row each in order. An empty list removes them all. |
{
"name": "set_questions",
"title": "Set the questions a track's sheet asks",
"description": "Replaces the questions in the track's To do tab with this list (call get_questions first, and send the ones it has along with yours). A list shorter than the one it has is refused unless replace is true. Each is {id, prompt, type, options, target, group, context, to, for}; any of them can be a sheet formula starting with =, so the sheet decides when to ask (a formula giving an empty prompt asks nothing) and where the answer goes. Answers already given stay in their rows, so keep a question's row when changing it. Formulas can't use IMPORT functions, IMAGE, HYPERLINK or WEBSERVICE.",
"inputSchema": {
"type": "object",
"required": [
"trackId",
"questions"
],
"properties": {
"replace": {
"type": "boolean",
"description": "true when the person asked to remove some. Without it, a list shorter than the one the track has is refused, so nothing is dropped by mistake."
},
"trackId": {
"type": "string",
"description": "From list_tracks."
},
"questions": {
"type": "array",
"items": {
"type": "object",
"properties": {
"at": {
"type": "string",
"description": "Optional. A cell that gets when it was answered, like Changes!G5."
},
"by": {
"type": "string",
"description": "Optional. A cell that gets the name of whoever answers, like Changes!F5, written with the answer."
},
"id": {
"type": "string",
"description": "Stays the same while it's the same question, so an answer stays with it. Often a formula from the row it's about."
},
"to": {
"type": "string",
"description": "For reply: who it answers, an address or a cell holding one."
},
"for": {
"type": "string",
"description": "Who should answer it, names or roles comma separated. Empty: anyone on the sheet."
},
"type": {
"type": "string",
"description": "notice, confirm, choose, multi_choose, text, number, date or reply."
},
"group": {
"type": "string",
"description": "Questions with the same group show together."
},
"prompt": {
"type": "string",
"description": "What it asks, like =IF(Transactions!G5=\"\", \"Which category is \"&Transactions!C5&\"?\", \"\")."
},
"target": {
"type": "string",
"description": "The cell the answer goes in, like Transactions!G5. Empty: the row's own answer column."
},
"context": {
"type": "string",
"description": "Details shown with it: text, or a range."
},
"options": {
"type": "string",
"description": "The choices, comma separated, or a range like Categories!A2:A."
}
},
"additionalProperties": false
},
"description": "The whole list, 0 to 100, one row each in order. An empty list removes them all."
}
},
"additionalProperties": false
},
"annotations": {
"title": "Set the questions a track's sheet asks",
"readOnlyHint": false,
"openWorldHint": false,
"idempotentHint": true,
"destructiveHint": true
}
}What the person's tracks are asking them now (To do in the app), by track: each question's id, prompt, type and choices, and whether the track's To do alerts are on (todoAlerts: a new question then notifies them). hackQuestions are hacks TrackerHacker made for the person's emails that wait for them: needs are columns only the person knows (an account's name, a type: each one's meaning says what), the same on every row; pickSheet, when there, lists the sheets they choose among; finishOnHackPage means it can't be answered with fixed values, so the person edits the hack in the app. Answer with answer_question when the person tells you the answer. With nothing waiting, tell them they're all caught up. Approvals and repeat checks are theirs to answer in the app.
| Parameter | Type | Description |
|---|---|---|
| trackId | string | Only this track. Leave out for all of them. |
{
"name": "list_todo",
"title": "List what the person's sheets are asking",
"description": "What the person's tracks are asking them now (To do in the app), by track: each question's id, prompt, type and choices, and whether the track's To do alerts are on (todoAlerts: a new question then notifies them). hackQuestions are hacks TrackerHacker made for the person's emails that wait for them: needs are columns only the person knows (an account's name, a type: each one's meaning says what), the same on every row; pickSheet, when there, lists the sheets they choose among; finishOnHackPage means it can't be answered with fixed values, so the person edits the hack in the app. Answer with answer_question when the person tells you the answer. With nothing waiting, tell them they're all caught up. Approvals and repeat checks are theirs to answer in the app.",
"inputSchema": {
"type": "object",
"properties": {
"trackId": {
"type": "string",
"description": "Only this track. Leave out for all of them."
}
},
"additionalProperties": false
},
"annotations": {
"title": "List what the person's sheets are asking",
"readOnlyHint": true,
"openWorldHint": false,
"destructiveHint": false
}
}Writes the person's answer to one of their sheet's questions (from list_todo), as if they tapped it in To do. Only answer what the person told you. value is the choice's text, a list of choices for multi_choose, true or false for confirm, or the text, number or date (YYYY-MM-DD). When the person answered several at once, give them all in answers. The result says how many questions are left (left). Approvals and repeat checks can't be answered here. For one of list_todo's hackQuestions, give hack instead: the hack turns on with the answers on its sheets, and their waiting emails move in (moved).
| Parameter | Type | Description |
|---|---|---|
| id | string | The question's id from list_todo. |
| hack | object | Instead of the rest: one of list_todo's hackQuestions, answered. |
| value | any | The answer. |
| answers | array | Instead of trackId, id and value: 1 to 20 answers the person gave, each {trackId, id, value}. |
| trackId | string | From list_tracks. |
{
"name": "answer_question",
"title": "Answer a question a sheet asks",
"description": "Writes the person's answer to one of their sheet's questions (from list_todo), as if they tapped it in To do. Only answer what the person told you. value is the choice's text, a list of choices for multi_choose, true or false for confirm, or the text, number or date (YYYY-MM-DD). When the person answered several at once, give them all in answers. The result says how many questions are left (left). Approvals and repeat checks can't be answered here. For one of list_todo's hackQuestions, give hack instead: the hack turns on with the answers on its sheets, and their waiting emails move in (moved).",
"inputSchema": {
"type": "object",
"properties": {
"id": {
"type": "string",
"description": "The question's id from list_todo."
},
"hack": {
"type": "object",
"required": [
"hackId",
"schemaId",
"schemaVersion"
],
"properties": {
"hackId": {
"type": "string"
},
"sheets": {
"type": "array",
"items": {
"type": "string"
},
"description": "With pickSheet: the ids of the sheets the person picked."
},
"answers": {
"type": "object",
"description": "Each need's key to the person's answer: text, one of its enumValues, or true or false."
},
"schemaId": {
"type": "string"
},
"schemaVersion": {
"type": "number"
}
},
"description": "Instead of the rest: one of list_todo's hackQuestions, answered.",
"additionalProperties": false
},
"value": {
"description": "The answer."
},
"answers": {
"type": "array",
"items": {
"type": "object",
"required": [
"trackId",
"id"
],
"properties": {
"id": {
"type": "string"
},
"value": {
"description": "The answer."
},
"trackId": {
"type": "string",
"description": "From list_tracks."
}
},
"additionalProperties": false
},
"description": "Instead of trackId, id and value: 1 to 20 answers the person gave, each {trackId, id, value}."
},
"trackId": {
"type": "string",
"description": "From list_tracks."
}
},
"additionalProperties": false
},
"annotations": {
"title": "Answer a question a sheet asks",
"readOnlyHint": false,
"openWorldHint": false,
"destructiveHint": false
}
}Removes messages from the track's Inbox that will never be rows, like newsletters or one-off mails, so check_tracks stops counting them. This can't be undone, so first list for the person what you'd clear (sender and subject) and clear only what they agree to; in a scheduled or unattended run, only report them. Give each as read_inbox listed it (row, time, subject). Don't clear a message a hack should read: add a hack instead.
| Parameter | Type | Description |
|---|---|---|
| trackId * | string | From list_tracks. |
| messages * | array | 1 to 20 messages from read_inbox. |
{
"name": "dismiss_inbox",
"title": "Clear messages from a track's Inbox",
"description": "Removes messages from the track's Inbox that will never be rows, like newsletters or one-off mails, so check_tracks stops counting them. This can't be undone, so first list for the person what you'd clear (sender and subject) and clear only what they agree to; in a scheduled or unattended run, only report them. Give each as read_inbox listed it (row, time, subject). Don't clear a message a hack should read: add a hack instead.",
"inputSchema": {
"type": "object",
"required": [
"trackId",
"messages"
],
"properties": {
"trackId": {
"type": "string",
"description": "From list_tracks."
},
"messages": {
"type": "array",
"items": {
"type": "object",
"required": [
"row",
"time",
"subject"
],
"properties": {
"row": {
"type": "integer"
},
"time": {
"type": "string"
},
"subject": {
"type": "string"
}
}
},
"description": "1 to 20 messages from read_inbox."
}
},
"additionalProperties": false
},
"annotations": {
"title": "Clear messages from a track's Inbox",
"readOnlyHint": false,
"openWorldHint": false,
"destructiveHint": true
}
}When a hack stops matching, TrackerHacker works out an update for it (draftedFix in check_tracks) that waits for the person in To do, where the buttons are Update the hack and Not now. Only when the person tells you to, in this conversation: use it (draftedFix says how many of the waiting messages it reads), which also runs the Inbox again so they become rows (inbox says how many); or turn it down, keeping the hack as it is. Never in a scheduled or unattended run: report that it's waiting instead.
| Parameter | Type | Description |
|---|---|---|
| use * | boolean | true updates the hack, false turns the update down (Not now). |
| hackId * | string | The stopped hack, from check_tracks or list_tracks. |
{
"name": "use_drafted_fix",
"title": "Update a hack with the update TrackerHacker worked out, or turn it down",
"description": "When a hack stops matching, TrackerHacker works out an update for it (draftedFix in check_tracks) that waits for the person in To do, where the buttons are Update the hack and Not now. Only when the person tells you to, in this conversation: use it (draftedFix says how many of the waiting messages it reads), which also runs the Inbox again so they become rows (inbox says how many); or turn it down, keeping the hack as it is. Never in a scheduled or unattended run: report that it's waiting instead.",
"inputSchema": {
"type": "object",
"required": [
"hackId",
"use"
],
"properties": {
"use": {
"type": "boolean",
"description": "true updates the hack, false turns the update down (Not now)."
},
"hackId": {
"type": "string",
"description": "The stopped hack, from check_tracks or list_tracks."
}
},
"additionalProperties": false
},
"annotations": {
"title": "Update a hack with the update TrackerHacker worked out, or turn it down",
"readOnlyHint": false,
"openWorldHint": false,
"destructiveHint": true
}
}The private link other apps (Zapier, IFTTT, iOS Shortcuts, a script, a shop) post JSON or text to, to add rows through the track's hacks. Made the first time it's asked for. Treat it like a password: give it only to the person, for the app they're connecting, in a code block so it's copied whole.
| Parameter | Type | Description |
|---|---|---|
| trackId * | string | From list_tracks. |
{
"name": "get_webhook_link",
"title": "Get a track's webhook link",
"description": "The private link other apps (Zapier, IFTTT, iOS Shortcuts, a script, a shop) post JSON or text to, to add rows through the track's hacks. Made the first time it's asked for. Treat it like a password: give it only to the person, for the app they're connecting, in a code block so it's copied whole.",
"inputSchema": {
"type": "object",
"required": [
"trackId"
],
"properties": {
"trackId": {
"type": "string",
"description": "From list_tracks."
}
},
"additionalProperties": false
},
"annotations": {
"title": "Get a track's webhook link",
"readOnlyHint": false,
"openWorldHint": false,
"idempotentHint": true,
"destructiveHint": false
}
}For a service that has the data but never sends it (a social network's post stats, a shop's stock, an API with no webhooks): every 1, 3, 6, 12 or 24 hours TrackerHacker asks an address and the track's JSON or text hacks read the answer exactly like a webhook body, a list making one row per item. The same answer twice in a day writes nothing, so for a daily history give the schema's row key keyPer day (publish_schema). action list shows a track's fetches (never their address or tokens); add takes label, url (public https), everyHours and token, and runs it once before keeping it (a failing one isn't kept; its rows come back as rows); run runs one now; set_token replaces a token the service refused, which had paused it, or its refresh; remove takes one away. The token is sent as Authorization: Bearer. A fetch can be a POST with a JSON body (method, body) and send up to 6 headers of its own (an API version, say). The url and body can name days, filled in the person's timezone as YYYY-MM-DD: {today}, {yesterday}, {days_ago:7}. A token that runs out can be renewed by TrackerHacker (refresh): style oauth trades a refresh token at tokenUrl with the person's own app's clientId and clientSecret (clientIdName for a service that calls it something else, like client_key; clientAuth basic for one that wants them as Basic auth), with or without a token to start; style renew sends the current long-lived token to tokenUrl before it runs out. Take tokens and secrets only when the person gives them to you for this, treat them like passwords, and never repeat them back. Build the hack from what the first run put in the Inbox (read_inbox).
| Parameter | Type | Description |
|---|---|---|
| url | string | add: the https address to GET, with its query (fields, limit). An API key may ride in it, like YouTube's key=. |
| body | ["object","string"] | add: a POST's JSON body, as an object or JSON text. May name {today}, {yesterday} or {days_ago:N}. |
| label | string | add: what it fetches, like "Instagram posts". |
One service, several sheets: a track's webhook link, or one of its scheduled fetches, can also fill other tracks of the person's, each reading it with its own hacks, so the service is set up once (Stripe into a sales sheet and a budget, one Instagram token for two sheets). action list shows the track's connections, the other tracks each hacks, and the other tracks' connections that fill this one; add takes kind (webhook or fetch, with fetchId from scheduled_fetches) and alsoTrackId; remove takes the same. The other track only gets rows its own hacks read: turn one on there first (turn_on_ready_hack, use_community_hack or save_hack). What its hacks don't read isn't written to it; anything no sheet reads waits in the Inbox of the track the link or fetch is on. turn_on_ready_hack does this by itself when the service already posts to another of the person's sheets on another topic.
| Parameter | Type | Description |
|---|---|---|
| kind | string | add, remove: the track's webhook link, or one of its fetches. |
| action * | string | one of ["list","add","remove"] |
| fetchId | string | add, remove with kind fetch: from scheduled_fetches. |
| trackId * | string | The track the link or fetch is on. |
| alsoTrackId | string | add, remove: the other track, from list_tracks. |
{
"name": "also_fill",
"title": "Have one webhook link or fetch fill several sheets",
"description": "One service, several sheets: a track's webhook link, or one of its scheduled fetches, can also fill other tracks of the person's, each reading it with its own hacks, so the service is set up once (Stripe into a sales sheet and a budget, one Instagram token for two sheets). action list shows the track's connections, the other tracks each hacks, and the other tracks' connections that fill this one; add takes kind (webhook or fetch, with fetchId from scheduled_fetches) and alsoTrackId; remove takes the same. The other track only gets rows its own hacks read: turn one on there first (turn_on_ready_hack, use_community_hack or save_hack). What its hacks don't read isn't written to it; anything no sheet reads waits in the Inbox of the track the link or fetch is on. turn_on_ready_hack does this by itself when the service already posts to another of the person's sheets on another topic.",
"inputSchema": {
"type": "object",
"required": [
"action",
"trackId"
],
"properties": {
"kind": {
"enum": [
"webhook",
"fetch"
],
"type": "string",
"description": "add, remove: the track's webhook link, or one of its fetches."
},
"action": {
"enum": [
"list",
"add",
"remove"
],
"type": "string"
},
"fetchId": {
"type": "string",
"description": "add, remove with kind fetch: from scheduled_fetches."
},
"trackId": {
"type": "string",
"description": "The track the link or fetch is on."
},
"alsoTrackId": {
"type": "string",
"description": "add, remove: the other track, from list_tracks."
}
},
"additionalProperties": false
},
"annotations": {
"title": "Have one webhook link or fetch fill several sheets",
"readOnlyHint": false,
"openWorldHint": false,
"idempotentHint": true,
"destructiveHint": false
}
}The senders whose emails the person tracks, each for one or more topics (a track's schemaId; every track on a topic gets them). This is the usual way to track email: add the sender for the track's topic, have them forward one of its emails (or send_message one you can read), and TrackerHacker makes the hack from it by itself, from a community hack for the sender or drafted with AI, and tells the person when its row is in. When it isn't sure (or AI fixes are off in their Settings), the email waits in the Inbox: then write the hack yourself (save_hack). action list shows the routes and the topics the person has tracks on; add takes sender (an address or domain), optional subjects (words the subject must have, for one sender who sends several kinds) and topics, or trackId for that track's topic, and merges with the same sender and subjects; set_topics takes id and topics (at least one). Removing a sender is the person's, under Emails you track in the app. While automatic forwarding from Gmail is on, a new sender's last 30 days of mail are read in now.
| Parameter | Type | Description |
|---|---|---|
| id | string | set_topics: the route's id, from list. |
| action * | string | one of ["list","add","set_topics"] |
| sender | string | add: like alerts@chase.com or chase.com. |
| topics | array | Topic ids (a track's schemaId from list_tracks). |
| trackId | string | add: instead of topics, this track's topic. |
| subjects | array | add: words the subject must have; leave out for all of the sender's emails. |
Whether Forward from Gmail automatically is offered and on, and the link the person opens to turn it on with one Allow tap, on any device. Instead of a Gmail filter, TrackerHacker then picks up mail from the person's hacks' senders in their Gmail within seconds of it arriving (senderList), plus up to 25 such emails from the last 30 days. It opens only those messages and stores none; it is not a way to read their email (for that, use your own Gmail connection). Save the hack before giving the link, so the person sees their sheet fill. Only they can tap Allow. To turn it off, stop_gmail_forwarding.
No parameters.
{
"name": "gmail_forwarding",
"title": "Forward from Gmail automatically",
"description": "Whether Forward from Gmail automatically is offered and on, and the link the person opens to turn it on with one Allow tap, on any device. Instead of a Gmail filter, TrackerHacker then picks up mail from the person's hacks' senders in their Gmail within seconds of it arriving (senderList), plus up to 25 such emails from the last 30 days. It opens only those messages and stores none; it is not a way to read their email (for that, use your own Gmail connection). Save the hack before giving the link, so the person sees their sheet fill. Only they can tap Allow. To turn it off, stop_gmail_forwarding.",
"inputSchema": {
"type": "object",
"properties": {},
"additionalProperties": false
},
"annotations": {
"title": "Forward from Gmail automatically",
"readOnlyHint": true,
"openWorldHint": false,
"destructiveHint": false
}
}Turns off Forward from Gmail automatically and revokes Google's grant. Mail forwarded to their TrackerHacker address keeps working. Only when the person asks; turning it back on is their own Allow tap (the link from gmail_forwarding).
No parameters.
{
"name": "stop_gmail_forwarding",
"title": "Stop forwarding from Gmail",
"description": "Turns off Forward from Gmail automatically and revokes Google's grant. Mail forwarded to their TrackerHacker address keeps working. Only when the person asks; turning it back on is their own Allow tap (the link from gmail_forwarding).",
"inputSchema": {
"type": "object",
"properties": {},
"additionalProperties": false
},
"annotations": {
"title": "Stop forwarding from Gmail",
"readOnlyHint": false,
"openWorldHint": false,
"idempotentHint": true,
"destructiveHint": true
}
}Whether Google Drive tells TrackerHacker when the person's sheets change, so what a sheet asks in its To do tab reaches them with nothing installed in the sheet. It's on for everyone unless they turned it off. Leave out on to read how it stands: whether it's on and how many sheets are watched. Pass on true to turn it on and watch every Google sheet now (also restarts watches that haven't started yet), or false to turn it off and stop every watch. The Sheets add-on reports changes sooner than Drive does. Sheets shared by link aren't watched.
| Parameter | Type | Description |
|---|---|---|
| on | boolean | true turns it on and watches every sheet now; false turns it off, only when the person asks for that. Leave out to read how it stands. |
{
"name": "set_drive_watch",
"title": "Watch sheets through Google Drive",
"description": "Whether Google Drive tells TrackerHacker when the person's sheets change, so what a sheet asks in its To do tab reaches them with nothing installed in the sheet. It's on for everyone unless they turned it off. Leave out on to read how it stands: whether it's on and how many sheets are watched. Pass on true to turn it on and watch every Google sheet now (also restarts watches that haven't started yet), or false to turn it off and stop every watch. The Sheets add-on reports changes sooner than Drive does. Sheets shared by link aren't watched.",
"inputSchema": {
"type": "object",
"properties": {
"on": {
"type": "boolean",
"description": "true turns it on and watches every sheet now; false turns it off, only when the person asks for that. Leave out to read how it stands."
}
},
"additionalProperties": false
},
"annotations": {
"title": "Watch sheets through Google Drive",
"readOnlyHint": false,
"openWorldHint": false,
"idempotentHint": true,
"destructiveHint": true
}
}Quick adds: buttons on the app's Home, for something the person adds often ("Coffee $4", "Walked the dog"): each opens a track's form with answers filled in, or with instant adds its row in one tap, dated when tapped (then preset must fill every required column but the date). action list shows them all; add makes one for a track (label, preset, instant); remove takes one away by its quickAddId from list.
| Parameter | Type | Description |
|---|---|---|
| label | string | add: what the button says, under 60 characters. |
| action * | string | one of ["list","add","remove"] |
| preset | object | add: answers by column key, from list_tracks. |
| instant | boolean | |
| trackId | string | From list_tracks. |
| quickAddId | string | remove: the button's id. |
{
"name": "quick_adds",
"title": "List, add or remove Quick adds",
"description": "Quick adds: buttons on the app's Home, for something the person adds often (\"Coffee $4\", \"Walked the dog\"): each opens a track's form with answers filled in, or with instant adds its row in one tap, dated when tapped (then preset must fill every required column but the date). action list shows them all; add makes one for a track (label, preset, instant); remove takes one away by its quickAddId from list.",
"inputSchema": {
"type": "object",
"required": [
"action"
],
"properties": {
"label": {
"type": "string",
"description": "add: what the button says, under 60 characters."
},
"action": {
"enum": [
"list",
"add",
"remove"
],
"type": "string"
},
"preset": {
"type": "object",
"description": "add: answers by column key, from list_tracks."
},
"instant": {
"type": "boolean"
},
"trackId": {
"type": "string",
"description": "From list_tracks."
},
"quickAddId": {
"type": "string",
"description": "remove: the button's id."
}
},
"additionalProperties": false
},
"annotations": {
"title": "List, add or remove Quick adds",
"readOnlyHint": false,
"openWorldHint": false,
"idempotentHint": true,
"destructiveHint": true
}
}Reads the rows in a track's sheet, newest last, to answer the person's questions about them ("what did I spend on dining this month?") or to check that a hack wrote what it should. Each row has its number and its values by column name. Filter with where (each column name to text the value must contain). Up to 200 rows a call; pass olderBefore as before for the page above. These are the person's own rows: use them only to help them, and do the totals yourself or with set_glance, not by copying rows elsewhere.
| Parameter | Type | Description |
|---|---|---|
| limit | integer | How many of the newest rows to read. 50 if left out. |
| where | object | Column name to text its value must contain (any case), like {"Category": "Dining"}. |
| before | integer | olderBefore from the previous call, to read older rows. |
| trackId * | string | From list_tracks. |
{
"name": "read_rows",
"title": "Read a track's rows",
"description": "Reads the rows in a track's sheet, newest last, to answer the person's questions about them (\"what did I spend on dining this month?\") or to check that a hack wrote what it should. Each row has its number and its values by column name. Filter with where (each column name to text the value must contain). Up to 200 rows a call; pass olderBefore as before for the page above. These are the person's own rows: use them only to help them, and do the totals yourself or with set_glance, not by copying rows elsewhere.",
"inputSchema": {
"type": "object",
"required": [
"trackId"
],
"properties": {
"limit": {
"type": "integer",
"maximum": 200,
"minimum": 1,
"description": "How many of the newest rows to read. 50 if left out."
},
"where": {
"type": "object",
"description": "Column name to text its value must contain (any case), like {\"Category\": \"Dining\"}."
},
"before": {
"type": "integer",
"description": "olderBefore from the previous call, to read older rows."
},
"trackId": {
"type": "string",
"description": "From list_tracks."
}
},
"additionalProperties": false
},
"annotations": {
"title": "Read a track's rows",
"readOnlyHint": true,
"openWorldHint": false,
"destructiveHint": false
}
}Adds a column of the sheet's own after its last one, for the sheet's formulas or the answers to its questions to fill (a Category the sheet asks about, a Status). TrackerHacker leaves it alone: hacks don't write it. For a column hacks should fill, publish a new version of the track's schema instead (publish_schema).
| Parameter | Type | Description |
|---|---|---|
| header * | string | The column's name, under 60 characters. |
| trackId * | string | From list_tracks. |
{
"name": "add_column",
"title": "Add a column to a track's sheet",
"description": "Adds a column of the sheet's own after its last one, for the sheet's formulas or the answers to its questions to fill (a Category the sheet asks about, a Status). TrackerHacker leaves it alone: hacks don't write it. For a column hacks should fill, publish a new version of the track's schema instead (publish_schema).",
"inputSchema": {
"type": "object",
"required": [
"trackId",
"header"
],
"properties": {
"header": {
"type": "string",
"description": "The column's name, under 60 characters."
},
"trackId": {
"type": "string",
"description": "From list_tracks."
}
},
"additionalProperties": false
},
"annotations": {
"title": "Add a column to a track's sheet",
"readOnlyHint": false,
"openWorldHint": false,
"destructiveHint": false
}
}Gives each column of a track's sheet the date or number format its schema promises (dates as dates, money with two decimals), for the rows already there as well as new ones, and takes bold off the rows below the header. Use it when dates or times show as plain numbers like 46334 or 46334.43681, or after publish_schema changed a field's format. Values aren't changed. Google Sheets only.
| Parameter | Type | Description |
|---|---|---|
| trackId * | string | From list_tracks. |
{
"name": "format_sheet",
"title": "Format a track's sheet",
"description": "Gives each column of a track's sheet the date or number format its schema promises (dates as dates, money with two decimals), for the rows already there as well as new ones, and takes bold off the rows below the header. Use it when dates or times show as plain numbers like 46334 or 46334.43681, or after publish_schema changed a field's format. Values aren't changed. Google Sheets only.",
"inputSchema": {
"type": "object",
"required": [
"trackId"
],
"properties": {
"trackId": {
"type": "string",
"description": "From list_tracks."
}
},
"additionalProperties": false
},
"annotations": {
"title": "Format a track's sheet",
"readOnlyHint": false,
"openWorldHint": false,
"idempotentHint": true,
"destructiveHint": false
}
}Builds a track's sheet on the TrackerHacker starter, the base for a template instead of a blank sheet, or updates it to the newest starter. Adds only the tabs it lacks (a Start here cover the author writes, Settings with setting, value and what it does, Glance and To do), sets TrackerHacker's theme the first time only, and records the starter's version in the sheet. It never changes a tab the sheet has. start_tracking with forSharing already does this. Tell the author they brand it with Format > Theme in Google Sheets (their template's page takes its accent color) and by writing their own words on Start here. check: true only says which starter version the sheet is on and what updating would add. Google Sheets only.
| Parameter | Type | Description |
|---|---|---|
| check | boolean | true reads the version and the update without changing the sheet. |
| trackId * | string | From list_tracks. |
{
"name": "use_starter",
"title": "Build a sheet on the TrackerHacker starter",
"description": "Builds a track's sheet on the TrackerHacker starter, the base for a template instead of a blank sheet, or updates it to the newest starter. Adds only the tabs it lacks (a Start here cover the author writes, Settings with setting, value and what it does, Glance and To do), sets TrackerHacker's theme the first time only, and records the starter's version in the sheet. It never changes a tab the sheet has. start_tracking with forSharing already does this. Tell the author they brand it with Format > Theme in Google Sheets (their template's page takes its accent color) and by writing their own words on Start here. check: true only says which starter version the sheet is on and what updating would add. Google Sheets only.",
"inputSchema": {
"type": "object",
"required": [
"trackId"
],
"properties": {
"check": {
"type": "boolean",
"description": "true reads the version and the update without changing the sheet."
},
"trackId": {
"type": "string",
"description": "From list_tracks."
}
},
"additionalProperties": false
},
"annotations": {
"title": "Build a sheet on the TrackerHacker starter",
"readOnlyHint": false,
"openWorldHint": false,
"idempotentHint": true,
"destructiveHint": false
}
}A schema (the app shows it to the person as a topic) and its versions, newest last; retired when its owner took it out of search, with the successor to use instead, with every field (key, label, meaning, type, required, enumValues, auto, format, aliases). list_tracks gives each track's schemaId. Only its author can publish new versions: the person's own (mine) with publish_schema; anyone else's, TrackerHacker's included, can be forked under a new id.
| Parameter | Type | Description |
|---|---|---|
| schemaId * | string |
{
"name": "get_schema",
"title": "Get a schema",
"description": "A schema (the app shows it to the person as a topic) and its versions, newest last; retired when its owner took it out of search, with the successor to use instead, with every field (key, label, meaning, type, required, enumValues, auto, format, aliases). list_tracks gives each track's schemaId. Only its author can publish new versions: the person's own (mine) with publish_schema; anyone else's, TrackerHacker's included, can be forked under a new id.",
"inputSchema": {
"type": "object",
"required": [
"schemaId"
],
"properties": {
"schemaId": {
"type": "string"
}
},
"additionalProperties": false
},
"annotations": {
"title": "Get a schema",
"readOnlyHint": true,
"openWorldHint": false,
"destructiveHint": false
}
}Publishes the next version of one of the person's own schemas (from get_schema, where mine is true), kept private. Give the whole schema with its new version: the same major version with minor + 1 to add optional fields or loosen one, so every track on it keeps working; major + 1 for a change that breaks hacks or sheets (removing a field, making one required), then upgrade_track moves each track. TrackerHacker refuses a version that breaks its contract without a new major. To share it with everyone or the person's team afterwards, use share_schema.
| Parameter | Type | Description |
|---|---|---|
| schema * | object | The whole schema: id, name, description, version, minor, patch and fields. |
{
"name": "publish_schema",
"title": "Publish a new version of the person's schema",
"description": "Publishes the next version of one of the person's own schemas (from get_schema, where mine is true), kept private. Give the whole schema with its new version: the same major version with minor + 1 to add optional fields or loosen one, so every track on it keeps working; major + 1 for a change that breaks hacks or sheets (removing a field, making one required), then upgrade_track moves each track. TrackerHacker refuses a version that breaks its contract without a new major. To share it with everyone or the person's team afterwards, use share_schema.",
"inputSchema": {
"type": "object",
"required": [
"schema"
],
"properties": {
"schema": {
"type": "object",
"description": "The whole schema: id, name, description, version, minor, patch and fields."
}
},
"additionalProperties": false
},
"annotations": {
"title": "Publish a new version of the person's schema",
"readOnlyHint": false,
"openWorldHint": false,
"destructiveHint": false
}
}Shares one of the person's own schemas (mine in get_schema) with everyone (public, listed in the community, so other people's sheets and hacks can use it) or with their team (Teams). It can't be undone, since others' sheets and hacks may come to depend on it, so do it only when the person asks for it. Every version is shared, including later ones. Works only if the person turned on "Let my assistant share what it builds" in Settings; otherwise it answers needs_opt_in with where that is.
| Parameter | Type | Description |
|---|---|---|
| schemaId * | string | |
| visibility * | string | public lists it for everyone. |
{
"name": "share_schema",
"title": "Make one of the person's schemas public or shared with their team",
"description": "Shares one of the person's own schemas (mine in get_schema) with everyone (public, listed in the community, so other people's sheets and hacks can use it) or with their team (Teams). It can't be undone, since others' sheets and hacks may come to depend on it, so do it only when the person asks for it. Every version is shared, including later ones. Works only if the person turned on \"Let my assistant share what it builds\" in Settings; otherwise it answers needs_opt_in with where that is.",
"inputSchema": {
"type": "object",
"required": [
"schemaId",
"visibility"
],
"properties": {
"schemaId": {
"type": "string"
},
"visibility": {
"enum": [
"public",
"team"
],
"type": "string",
"description": "public lists it for everyone."
}
},
"additionalProperties": false
},
"annotations": {
"title": "Make one of the person's schemas public or shared with their team",
"readOnlyHint": false,
"openWorldHint": true,
"idempotentHint": true,
"destructiveHint": false
}
}Moves a track to the next major version of its schema: renames the sheet's headers the version renames and moves its hacks' mappings. Refused, with what to change, when a hack wouldn't fill the new version's required columns: fix those hacks first.
| Parameter | Type | Description |
|---|---|---|
| trackId * | string | From list_tracks. |
{
"name": "upgrade_track",
"title": "Move a track to its schema's next major version",
"description": "Moves a track to the next major version of its schema: renames the sheet's headers the version renames and moves its hacks' mappings. Refused, with what to change, when a hack wouldn't fill the new version's required columns: fix those hacks first.",
"inputSchema": {
"type": "object",
"required": [
"trackId"
],
"properties": {
"trackId": {
"type": "string",
"description": "From list_tracks."
}
},
"additionalProperties": false
},
"annotations": {
"title": "Move a track to its schema's next major version",
"readOnlyHint": false,
"openWorldHint": false,
"destructiveHint": true
}
}Moves a track to another layout for its schema (a ready-made template like a monthly budget, by its id), or to its template's newest version: adds the tabs it brings and sets each column's allowed values. The person's rows and own tabs stay as they are. list_tracks shows templateUpdate when a newer version is out, labelled like semver: patch changes only words, minor adds tabs or allowed values, major is for another schema version or takes allowed values away (rows already there may stop fitting). Ask the person before moving their sheet, and say which kind it is.
| Parameter | Type | Description |
|---|---|---|
| trackId * | string | From list_tracks. |
| templateId * | string |
{
"name": "change_template",
"title": "Change a track's sheet template",
"description": "Moves a track to another layout for its schema (a ready-made template like a monthly budget, by its id), or to its template's newest version: adds the tabs it brings and sets each column's allowed values. The person's rows and own tabs stay as they are. list_tracks shows templateUpdate when a newer version is out, labelled like semver: patch changes only words, minor adds tabs or allowed values, major is for another schema version or takes allowed values away (rows already there may stop fitting). Ask the person before moving their sheet, and say which kind it is.",
"inputSchema": {
"type": "object",
"required": [
"trackId",
"templateId"
],
"properties": {
"trackId": {
"type": "string",
"description": "From list_tracks."
},
"templateId": {
"type": "string"
}
},
"additionalProperties": false
},
"annotations": {
"title": "Change a track's sheet template",
"readOnlyHint": false,
"openWorldHint": false,
"destructiveHint": false
}
}For a sheet copied from a shared template sheet (copiedFrom in list_tracks): which version of the template it's on, the newest, and what updating adds, tab by tab. change new: the newer version adds the tab. changed: its author changed the tab, so the new version is added beside the sheet's own as addAs ("Budget (version 3)") for the person to compare. removed_by_you: the person deleted the tab, so it isn't brought back. Updating never changes, overwrites or removes anything already in the sheet. Without apply it only looks. With apply true it updates: tell the person what it adds and apply only when they say so.
| Parameter | Type | Description |
|---|---|---|
| apply | boolean | true updates the sheet; leave out to only look. |
| trackId * | string | From list_tracks. |
{
"name": "update_from_template",
"title": "Update a sheet copied from a template",
"description": "For a sheet copied from a shared template sheet (copiedFrom in list_tracks): which version of the template it's on, the newest, and what updating adds, tab by tab. change new: the newer version adds the tab. changed: its author changed the tab, so the new version is added beside the sheet's own as addAs (\"Budget (version 3)\") for the person to compare. removed_by_you: the person deleted the tab, so it isn't brought back. Updating never changes, overwrites or removes anything already in the sheet. Without apply it only looks. With apply true it updates: tell the person what it adds and apply only when they say so.",
"inputSchema": {
"type": "object",
"required": [
"trackId"
],
"properties": {
"apply": {
"type": "boolean",
"description": "true updates the sheet; leave out to only look."
},
"trackId": {
"type": "string",
"description": "From list_tracks."
}
},
"additionalProperties": false
},
"annotations": {
"title": "Update a sheet copied from a template",
"readOnlyHint": false,
"openWorldHint": false,
"destructiveHint": false
}
}Reports a community hack someone else shares: broken (it reads messages wrong or writes wrong values), private_data (its template or examples hold a real person's details), or harmful. Say what you saw in details, without the person's own data. A private_data report, or three reports of any kind, takes it out of search at once until someone shares a fixed version, and the TrackerHacker team looks at it. Copies people already have stay theirs.
| Parameter | Type | Description |
|---|---|---|
| reason * | string | one of ["broken","private_data","harmful"] |
| details | string | What's wrong, in general terms. |
| communityHackId * | string |
{
"name": "report_community_hack",
"title": "Report a shared email-reading rule (hack) that is broken or harmful",
"description": "Reports a community hack someone else shares: broken (it reads messages wrong or writes wrong values), private_data (its template or examples hold a real person's details), or harmful. Say what you saw in details, without the person's own data. A private_data report, or three reports of any kind, takes it out of search at once until someone shares a fixed version, and the TrackerHacker team looks at it. Copies people already have stay theirs.",
"inputSchema": {
"type": "object",
"required": [
"communityHackId",
"reason"
],
"properties": {
"reason": {
"enum": [
"broken",
"private_data",
"harmful"
],
"type": "string"
},
"details": {
"type": "string",
"description": "What's wrong, in general terms."
},
"communityHackId": {
"type": "string"
}
},
"additionalProperties": false
},
"annotations": {
"title": "Report a shared email-reading rule (hack) that is broken or harmful",
"readOnlyHint": false,
"openWorldHint": true,
"destructiveHint": true
}
}The track's form for adding a row by hand: its fields, its design (title, intro, thanks, askName, and each field's question, help, or hidden value), and its link for people without an account, if it has one.
| Parameter | Type | Description |
|---|---|---|
| trackId * | string | From list_tracks. |
{
"name": "get_form",
"title": "Get a track's form",
"description": "The track's form for adding a row by hand: its fields, its design (title, intro, thanks, askName, and each field's question, help, or hidden value), and its link for people without an account, if it has one.",
"inputSchema": {
"type": "object",
"required": [
"trackId"
],
"properties": {
"trackId": {
"type": "string",
"description": "From list_tracks."
}
},
"additionalProperties": false
},
"annotations": {
"title": "Get a track's form",
"readOnlyHint": true,
"openWorldHint": false,
"destructiveHint": false
}
}Sets how the track's form asks for a row: {title, intro, thanks, askName, fields: [{key, label, help, hidden, value}]}, fields by column key in the order asked; a hidden field always gets its value. null goes back to the template's design.
| Parameter | Type | Description |
|---|---|---|
| design * | ["object","null"] | |
| trackId * | string | From list_tracks. |
{
"name": "set_form",
"title": "Design a track's form",
"description": "Sets how the track's form asks for a row: {title, intro, thanks, askName, fields: [{key, label, help, hidden, value}]}, fields by column key in the order asked; a hidden field always gets its value. null goes back to the template's design.",
"inputSchema": {
"type": "object",
"required": [
"trackId",
"design"
],
"properties": {
"design": {
"type": [
"object",
"null"
]
},
"trackId": {
"type": "string",
"description": "From list_tracks."
}
},
"additionalProperties": false
},
"annotations": {
"title": "Design a track's form",
"readOnlyHint": false,
"openWorldHint": false,
"idempotentHint": true,
"destructiveHint": true
}
}Makes the link that lets anyone who has it add a row to the track through its form (volunteers logging hours, guests signing up), with a bot check. Ask the person first and tell them who they plan to give it to: anyone with the link can add rows. Made once: asking again gives the same link. The person turns it off or replaces it in the app.
| Parameter | Type | Description |
|---|---|---|
| trackId * | string | From list_tracks. |
{
"name": "share_form",
"title": "Make a form link for people without an account",
"description": "Makes the link that lets anyone who has it add a row to the track through its form (volunteers logging hours, guests signing up), with a bot check. Ask the person first and tell them who they plan to give it to: anyone with the link can add rows. Made once: asking again gives the same link. The person turns it off or replaces it in the app.",
"inputSchema": {
"type": "object",
"required": [
"trackId"
],
"properties": {
"trackId": {
"type": "string",
"description": "From list_tracks."
}
},
"additionalProperties": false
},
"annotations": {
"title": "Make a form link for people without an account",
"readOnlyHint": false,
"openWorldHint": true,
"idempotentHint": true,
"destructiveHint": false
}
}Turns on one of TrackerHacker's ready-made sources for a track (from find_hacks with its trackId, under ready): a service that posts to the sheet's link (Shopify, Stripe, GitHub), one TrackerHacker asks on a schedule (a social account's posts), or a reminder that asks the person. Attaches its hacks with the mappings that fill the sheet and returns what the person does next in that service: connect (steps, and a link to paste), webhookUrl, fetch (a scheduled fetch to add with scheduled_fetches, once the person gives what it asks for) or reminder. When the service already posts to another of the person's sheets on another topic, or TrackerHacker already asks it on a schedule for one, this sheet is filled through that link or fetch instead (alreadyConnected), with nothing new to set up. Call it once the person has said which source.
| Parameter | Type | Description |
|---|---|---|
| readyId * | string | From find_hacks with this trackId, under ready. |
| trackId * | string | From list_tracks. |
{
"name": "turn_on_ready_hack",
"title": "Turn on a ready-made source for a track",
"description": "Turns on one of TrackerHacker's ready-made sources for a track (from find_hacks with its trackId, under ready): a service that posts to the sheet's link (Shopify, Stripe, GitHub), one TrackerHacker asks on a schedule (a social account's posts), or a reminder that asks the person. Attaches its hacks with the mappings that fill the sheet and returns what the person does next in that service: connect (steps, and a link to paste), webhookUrl, fetch (a scheduled fetch to add with scheduled_fetches, once the person gives what it asks for) or reminder. When the service already posts to another of the person's sheets on another topic, or TrackerHacker already asks it on a schedule for one, this sheet is filled through that link or fetch instead (alreadyConnected), with nothing new to set up. Call it once the person has said which source.",
"inputSchema": {
"type": "object",
"required": [
"trackId",
"readyId"
],
"properties": {
"readyId": {
"type": "string",
"description": "From find_hacks with this trackId, under ready."
},
"trackId": {
"type": "string",
"description": "From list_tracks."
}
},
"additionalProperties": false
},
"annotations": {
"title": "Turn on a ready-made source for a track",
"readOnlyHint": false,
"openWorldHint": false,
"destructiveHint": false
}
}Searches the hacks people share with the community, by sender (like chase.com) or name. With trackId, what fills that track instead: TrackerHacker's ready-made services for its topic, then the community's email hacks that fill it. Each has its fields, how many people use copies, how many of those read a message in the last 30 days (working) or stopped matching (stopped), its stage (production: working for 5 people or more, a ready-made; beta: working for 2 or more; alpha: so far only its maker's emails, so check it reads the person's own emails, with test_hack, before relying on it), its note when it has one (a line on which emails it reads and which it leaves out), and an example message. Before building a hack for a sender, look here: a shared one that's working saves the person an AI suggestion. With communityHackId instead, one hack in full: its template and all its examples, to test_hack on the person's own messages before use_community_hack.
| Parameter | Type | Description |
|---|---|---|
| query | string | A sender's domain or address, or words in the hack's name. Leave out for the most used. |
| trackId | string | Only what fills this track's topic: the ready-made services first (turn_on_ready_hack), then community email hacks with the mapping that fills it (use_community_hack). |
| communityHackId | string | One hack in full, from an earlier search. |
{
"name": "find_hacks",
"title": "Search email-reading rules (hacks) other people shared",
"description": "Searches the hacks people share with the community, by sender (like chase.com) or name. With trackId, what fills that track instead: TrackerHacker's ready-made services for its topic, then the community's email hacks that fill it. Each has its fields, how many people use copies, how many of those read a message in the last 30 days (working) or stopped matching (stopped), its stage (production: working for 5 people or more, a ready-made; beta: working for 2 or more; alpha: so far only its maker's emails, so check it reads the person's own emails, with test_hack, before relying on it), its note when it has one (a line on which emails it reads and which it leaves out), and an example message. Before building a hack for a sender, look here: a shared one that's working saves the person an AI suggestion. With communityHackId instead, one hack in full: its template and all its examples, to test_hack on the person's own messages before use_community_hack.",
"inputSchema": {
"type": "object",
"properties": {
"query": {
"type": "string",
"description": "A sender's domain or address, or words in the hack's name. Leave out for the most used."
},
"trackId": {
"type": "string",
"description": "Only what fills this track's topic: the ready-made services first (turn_on_ready_hack), then community email hacks with the mapping that fills it (use_community_hack)."
},
"communityHackId": {
"type": "string",
"description": "One hack in full, from an earlier search."
}
},
"additionalProperties": false
},
"annotations": {
"title": "Search email-reading rules (hacks) other people shared",
"readOnlyHint": true,
"openWorldHint": false,
"destructiveHint": false
}
}Copies a community hack into the person's account and attaches it to a track, mapping its fields to columns by name unless you give a mapping (as in save_hack), then runs the track's Inbox again so messages already waiting become rows (inbox says how many). The copy is theirs; community hacks belong to the community and change only when a share keeps everything they read the same, which copies take by themselves. update_hack_from_community brings in a bigger change.
| Parameter | Type | Description |
|---|---|---|
| name | string | A name for the person's copy; the community hack's name if left out. |
| mapping | object | Column key to source, as in save_hack. |
| trackId * | string | From list_tracks. |
| confirmed | boolean | Only after the person looked at the rows this hack would make from their waiting emails and said they're right: copies it though they look wrong. |
| communityHackId * | string | From find_hacks. |
{
"name": "use_community_hack",
"title": "Copy a shared email-reading rule (hack) into a track",
"description": "Copies a community hack into the person's account and attaches it to a track, mapping its fields to columns by name unless you give a mapping (as in save_hack), then runs the track's Inbox again so messages already waiting become rows (inbox says how many). The copy is theirs; community hacks belong to the community and change only when a share keeps everything they read the same, which copies take by themselves. update_hack_from_community brings in a bigger change.",
"inputSchema": {
"type": "object",
"required": [
"communityHackId",
"trackId"
],
"properties": {
"name": {
"type": "string",
"description": "A name for the person's copy; the community hack's name if left out."
},
"mapping": {
"type": "object",
"description": "Column key to source, as in save_hack."
},
"trackId": {
"type": "string",
"description": "From list_tracks."
},
"confirmed": {
"type": "boolean",
"description": "Only after the person looked at the rows this hack would make from their waiting emails and said they're right: copies it though they look wrong."
},
"communityHackId": {
"type": "string",
"description": "From find_hacks."
}
},
"additionalProperties": false
},
"annotations": {
"title": "Copy a shared email-reading rule (hack) into a track",
"readOnlyHint": false,
"openWorldHint": false,
"destructiveHint": false
}
}Brings a hack the person copied from the community up to the community hack's latest version (list_tracks or check_tracks says when there is one). A copy nobody changed takes a minor or patch version by itself, so this is for a major version (it reads different emails, or changes fields: test_hack it on read_inbox's messages first) or a copy the person changed: the community hack's template and senders replace the copy's, and its tracks' Inboxes are run again (inbox says how many waiting messages became rows). Refused if the new version would no longer fill the columns its sheets need.
| Parameter | Type | Description |
|---|---|---|
| hackId * | string | The person's copy, from list_tracks. |
{
"name": "update_hack_from_community",
"title": "Update a copied email-reading rule to the community's latest version",
"description": "Brings a hack the person copied from the community up to the community hack's latest version (list_tracks or check_tracks says when there is one). A copy nobody changed takes a minor or patch version by itself, so this is for a major version (it reads different emails, or changes fields: test_hack it on read_inbox's messages first) or a copy the person changed: the community hack's template and senders replace the copy's, and its tracks' Inboxes are run again (inbox says how many waiting messages became rows). Refused if the new version would no longer fill the columns its sheets need.",
"inputSchema": {
"type": "object",
"required": [
"hackId"
],
"properties": {
"hackId": {
"type": "string",
"description": "The person's copy, from list_tracks."
}
},
"additionalProperties": false
},
"annotations": {
"title": "Update a copied email-reading rule to the community's latest version",
"readOnlyHint": false,
"openWorldHint": false,
"idempotentHint": true,
"destructiveHint": true
}
}Shares one of the person's hacks with everyone. Community hacks belong to the community, one for each kind of email a sender sends: the hack's wording goes into the community hack for the same kind of email when that keeps everything it reads the same (so every copy takes it), or starts a new one (status added, changed or same). It's set aside, with the reason, when it would read the community hack's emails another way; and when its fixed text has a name or number no one else's hack for these emails has (status waiting, with words), it's listed at once with those words masked as {{...}} (masked), so others can find and copy it, and the words go back in once someone else's hack, or an email the sender signed, has them too. The person's own hack never changes. Share it again after a fix so copies can take it. Leave out examples and TrackerHacker makes them up from the template itself (its fixed wording with made-up values, no AI); or give 1 to 5 example messages it reads, with every value made up: never the person's own messages. TrackerHacker refuses examples holding anything from the person's sheets or mail, addresses other than the sender's or example.com, and templates with a name or account number as fixed text. Works only if the person turned on "Let my assistant share what it builds" in Settings; otherwise tell them where it is.
| Parameter | Type | Description |
|---|---|---|
| name | string | The name everyone sees, like "Chase card alert"; the hack's own name if left out. |
| hackId * | string | The person's hack, from list_tracks. |
| examples | array | 1 to 5 made-up messages it reads, written like the real ones with other values. Leave out to have TrackerHacker make them up from the template. |
Template sheets people share: whole sheets built for something (a budget, a shop's orders), with their tabs, formulas, Glance cards and questions. install_template builds one in the person's Google Drive; each also has a copyUrl for copying it in Google Sheets, except one marked originalGone, whose author deleted its sheet: install_template still builds it from TrackerHacker's backup. Search with what the person tracks and the services or senders its rows come from: names, descriptions and the hacks for each template's topic are searched, so "shopify" or "chase" finds the template those fill. Templates by TrackerHacker LLC are the official ones.
| Parameter | Type | Description |
|---|---|---|
| query | string | Words like "card spending", or a bank, shop or service: "chase", "shopify". |
| category | string | Only templates in this template library category. |
{
"name": "find_templates",
"title": "Find track templates",
"description": "Template sheets people share: whole sheets built for something (a budget, a shop's orders), with their tabs, formulas, Glance cards and questions. install_template builds one in the person's Google Drive; each also has a copyUrl for copying it in Google Sheets, except one marked originalGone, whose author deleted its sheet: install_template still builds it from TrackerHacker's backup. Search with what the person tracks and the services or senders its rows come from: names, descriptions and the hacks for each template's topic are searched, so \"shopify\" or \"chase\" finds the template those fill. Templates by TrackerHacker LLC are the official ones.",
"inputSchema": {
"type": "object",
"properties": {
"query": {
"type": "string",
"description": "Words like \"card spending\", or a bank, shop or service: \"chase\", \"shopify\"."
},
"category": {
"enum": [
"spending",
"bills",
"orders",
"travel",
"health",
"food",
"home",
"business",
"coding",
"makers",
"other"
],
"type": "string",
"description": "Only templates in this template library category."
}
},
"additionalProperties": false
},
"annotations": {
"title": "Find track templates",
"readOnlyHint": true,
"openWorldHint": false,
"destructiveHint": false
}
}Builds a new sheet in the person's Google Drive from a template sheet people share (from find_templates), once the person has seen its columns and said yes, and makes it one of their tracks: its tabs, formulas, Glance cards, questions and example rows come along, and its form. Charts, colours and other formatting don't: for those the person copies it in Google Sheets (copyUrl) and connects the copy. A template with a formula that reaches outside the sheet is refused.
| Parameter | Type | Description |
|---|---|---|
| name | string | The track's name. Leave out for the template's. |
| spreadsheetId * | string | The template's spreadsheetId from find_templates. |
{
"name": "install_template",
"title": "Build a sheet from a shared template",
"description": "Builds a new sheet in the person's Google Drive from a template sheet people share (from find_templates), once the person has seen its columns and said yes, and makes it one of their tracks: its tabs, formulas, Glance cards, questions and example rows come along, and its form. Charts, colours and other formatting don't: for those the person copies it in Google Sheets (copyUrl) and connects the copy. A template with a formula that reaches outside the sheet is refused.",
"inputSchema": {
"type": "object",
"required": [
"spreadsheetId"
],
"properties": {
"name": {
"type": "string",
"description": "The track's name. Leave out for the template's."
},
"spreadsheetId": {
"type": "string",
"description": "The template's spreadsheetId from find_templates."
}
},
"additionalProperties": false
},
"annotations": {
"title": "Build a sheet from a shared template",
"readOnlyHint": false,
"openWorldHint": true,
"destructiveHint": false
}
}Starts tracking from a hack instead of a template, in one step: a service like Shopify or Instagram (a ready id from find_templates' hacks or find_hacks) or a community email hack for a sender like a bank (its id). It builds the topic's template, or uses the person's own track on that topic when they have one; a topic with no template gets a sheet of its columns on the TrackerHacker starter, and a hack that fills no topic gets a private topic made from what it reads (local is then sheet or topic). Then it turns the hack on with its setup steps. When the topic has more than one template it changes nothing and gives back choose: show the person those templates (name, author, copies) and call again with the templateId they pick. When the person has more than one track it could fill, it gives back chooseTrack: ask which, and call again with that trackId. Show the person the template first, as with install_template, and say they can start from the plain TrackerHacker starter instead (starter: true).
| Parameter | Type | Description |
|---|---|---|
| topic | string | Only for a hack that fills more than one topic: the topic id to start on. |
| hackId * | string | A ready-made source's id (like shopify) or a community hack's id. |
| starter | boolean | true makes a sheet of the topic's columns on the TrackerHacker starter instead of a template, when the person would rather start plain. Always an option. |
| trackId | string | Only after chooseTrack: the person's track to add the hack to. |
| templateId | string | The template's spreadsheetId, when the topic has more than one and the person picked one. |
Makes a Google Sheet the person already has into one of their tracks, from its link, so hacks can write to it: a copy of a template sheet (like a budget someone shared) keeps its own tabs and formulas; any other sheet gets the tabs a track writes to beside its own. Google lets TrackerHacker open a sheet only once the person confirms it, so this usually gives back a confirm_link: send it to the person, who taps one button and picks the sheet in Google's picker, then call list_tracks to see it. If the sheet is already shared as Editor with TrackerHacker's service account, it's connected at once.
| Parameter | Type | Description |
|---|---|---|
| link * | string | The sheet's link (https://docs.google.com/spreadsheets/d/...) or its id. |
| name | string | The track's name. Leave out for the sheet's title. |
| dataTab | string | A tab whose columns the person already wrote: it becomes the data tab as it is, and its headers and column formats become the sheet's own schema, which follows later column changes. With schemaId, that schema on this tab instead. |
| schemaId | string | For a sheet that isn't a template copy: what it tracks, a schema id. Transactions when left out. |
{
"name": "connect_sheet",
"title": "Connect a sheet by its link",
"description": "Makes a Google Sheet the person already has into one of their tracks, from its link, so hacks can write to it: a copy of a template sheet (like a budget someone shared) keeps its own tabs and formulas; any other sheet gets the tabs a track writes to beside its own. Google lets TrackerHacker open a sheet only once the person confirms it, so this usually gives back a confirm_link: send it to the person, who taps one button and picks the sheet in Google's picker, then call list_tracks to see it. If the sheet is already shared as Editor with TrackerHacker's service account, it's connected at once.",
"inputSchema": {
"type": "object",
"required": [
"link"
],
"properties": {
"link": {
"type": "string",
"description": "The sheet's link (https://docs.google.com/spreadsheets/d/...) or its id."
},
"name": {
"type": "string",
"description": "The track's name. Leave out for the sheet's title."
},
"dataTab": {
"type": "string",
"description": "A tab whose columns the person already wrote: it becomes the data tab as it is, and its headers and column formats become the sheet's own schema, which follows later column changes. With schemaId, that schema on this tab instead."
},
"schemaId": {
"type": "string",
"description": "For a sheet that isn't a template copy: what it tracks, a schema id. Transactions when left out."
}
},
"additionalProperties": false
},
"annotations": {
"title": "Connect a sheet by its link",
"readOnlyHint": false,
"openWorldHint": true,
"idempotentHint": true,
"destructiveHint": false
}
}Shares one of the person's sheets as a template others copy: its tabs, formulas, Glance cards and form go with it; each share is the next version. Only a sheet with nothing of the person's own, since a copy carries everything: set up a fresh track for sharing (start_tracking with forSharing) and add example rows with add_rows and example: true; any other rows get the share refused. Public needs the sheet's schema public (share_schema, when the person asks). Works only if the person turned on "Let my assistant share what it builds" in Settings.
| Parameter | Type | Description |
|---|---|---|
| name * | string | Up to 60 characters. |
| videos | array | Up to 3 YouTube links showing the template in use, from the person; its page shows each one's thumbnail and title. Leave it out to keep the ones it has; [] removes them. |
| trackId * | string | From list_tracks. |
| category | string | The template library page it's listed on (spending: Spending and budgets; bills: Bills and subscriptions; orders: Orders and deliveries; travel: Travel and bookings; health: Health and fitness; food: Food and nutrition; home: Home and family; business: Business; coding: Coding; makers: Bases for you… |
| visibility | string | public lists it for everyone. |
| description | string | Up to 300 characters: what it tracks and what's in it. |
Stops listing one of the person's template sheets. Copies people already made are theirs.
| Parameter | Type | Description |
|---|---|---|
| spreadsheetId * | string |
{
"name": "unshare_template",
"title": "Stop sharing a template",
"description": "Stops listing one of the person's template sheets. Copies people already made are theirs.",
"inputSchema": {
"type": "object",
"required": [
"spreadsheetId"
],
"properties": {
"spreadsheetId": {
"type": "string"
}
},
"additionalProperties": false
},
"annotations": {
"title": "Stop sharing a template",
"readOnlyHint": false,
"openWorldHint": true,
"idempotentHint": true,
"destructiveHint": true
}
}Gives a public template the person copied and connected 1 to 5 stars, with an optional short review (up to 280 characters, no links, email addresses or long numbers), shown on its public page under their public name, or as "A TrackerHacker user" when they haven't set one. Rate only when the person says how many stars, and use their own words for the review; rating again replaces it. To find which template a track was copied from, pass trackId alone: nothing is rated, and you get the template and the person's rating so far.
| Parameter | Type | Description |
|---|---|---|
| stars | integer | |
| review | string | Up to 280 characters, in the person's words. |
| trackId * | string | The track whose sheet is a copy of the template. |
{
"name": "rate_template",
"title": "Rate a template the person copied",
"description": "Gives a public template the person copied and connected 1 to 5 stars, with an optional short review (up to 280 characters, no links, email addresses or long numbers), shown on its public page under their public name, or as \"A TrackerHacker user\" when they haven't set one. Rate only when the person says how many stars, and use their own words for the review; rating again replaces it. To find which template a track was copied from, pass trackId alone: nothing is rated, and you get the template and the person's rating so far.",
"inputSchema": {
"type": "object",
"required": [
"trackId"
],
"properties": {
"stars": {
"type": "integer",
"maximum": 5,
"minimum": 1
},
"review": {
"type": "string",
"description": "Up to 280 characters, in the person's words."
},
"trackId": {
"type": "string",
"description": "The track whose sheet is a copy of the template."
}
},
"additionalProperties": false
},
"annotations": {
"title": "Rate a template the person copied",
"readOnlyHint": false,
"openWorldHint": true,
"idempotentHint": true,
"destructiveHint": true
}
}Lists the reviews of templates the person shares, newest first (hidden: reports hid its words from the page). With reviewId and reply, answers one as the template's author, once: answering again replaces it, and an empty reply takes it back. Up to 280 characters, no links; write the person's answer, not your own.
| Parameter | Type | Description |
|---|---|---|
| reply | string | |
| reviewId | string |
{
"name": "template_reviews",
"title": "Read and answer reviews of the person's templates",
"description": "Lists the reviews of templates the person shares, newest first (hidden: reports hid its words from the page). With reviewId and reply, answers one as the template's author, once: answering again replaces it, and an empty reply takes it back. Up to 280 characters, no links; write the person's answer, not your own.",
"inputSchema": {
"type": "object",
"properties": {
"reply": {
"type": "string"
},
"reviewId": {
"type": "string"
}
},
"additionalProperties": false
},
"annotations": {
"title": "Read and answer reviews of the person's templates",
"readOnlyHint": false,
"openWorldHint": true,
"idempotentHint": true,
"destructiveHint": false
}
}Sends a report to the TrackerHacker team: a bug (a tool that fails or does something wrong), a hack to make, an idea (what TrackerHacker would need to support what the person wants), praise (what they like) or a complaint (what annoys them, though nothing is broken). Show the person the report and get their yes first. Say what you called, what you expected and what happened, in general terms: never their emails, sheet values, names, amounts, card, account or phone numbers (use zeros, like $0.00 or card 0000; other amounts or long numbers are refused). Up to 5 a day. The team can reply only if the person gives a replyTo address.
| Parameter | Type | Description |
|---|---|---|
| kind * | string | one of ["bug","hack","idea","praise","complaint"] |
| tool | string | For a bug: the tool that went wrong. For praise or a complaint: what it's about, a tool or a part of TrackerHacker (notifications, glance, hacks, inbox, setup). |
| details * | string | What happened or what's needed, and why. Under 4000 characters, nothing of the person's. |
| replyTo | string | An address the team may reply to, only if the person gave it to you for this. |
| summary * | string | One line, under 120 characters. |
{
"name": "send_feedback",
"title": "Send feedback to the TrackerHacker team",
"description": "Sends a report to the TrackerHacker team: a bug (a tool that fails or does something wrong), a hack to make, an idea (what TrackerHacker would need to support what the person wants), praise (what they like) or a complaint (what annoys them, though nothing is broken). Show the person the report and get their yes first. Say what you called, what you expected and what happened, in general terms: never their emails, sheet values, names, amounts, card, account or phone numbers (use zeros, like $0.00 or card 0000; other amounts or long numbers are refused). Up to 5 a day. The team can reply only if the person gives a replyTo address.",
"inputSchema": {
"type": "object",
"required": [
"kind",
"summary",
"details"
],
"properties": {
"kind": {
"enum": [
"bug",
"hack",
"idea",
"praise",
"complaint"
],
"type": "string"
},
"tool": {
"type": "string",
"description": "For a bug: the tool that went wrong. For praise or a complaint: what it's about, a tool or a part of TrackerHacker (notifications, glance, hacks, inbox, setup)."
},
"details": {
"type": "string",
"description": "What happened or what's needed, and why. Under 4000 characters, nothing of the person's."
},
"replyTo": {
"type": "string",
"description": "An address the team may reply to, only if the person gave it to you for this."
},
"summary": {
"type": "string",
"description": "One line, under 120 characters."
}
},
"additionalProperties": false
},
"annotations": {
"title": "Send feedback to the TrackerHacker team",
"readOnlyHint": false,
"openWorldHint": true,
"idempotentHint": false,
"destructiveHint": false
}
}A track's blocking rules (rows they keep out of the sheet) and the columns a rule can name, with their types.
| Parameter | Type | Description |
|---|---|---|
| trackId * | string | From list_tracks. |
{
"name": "get_rules",
"title": "Get a track's blocking rules",
"description": "A track's blocking rules (rows they keep out of the sheet) and the columns a rule can name, with their types.",
"inputSchema": {
"type": "object",
"required": [
"trackId"
],
"properties": {
"trackId": {
"type": "string",
"description": "From list_tracks."
}
},
"additionalProperties": false
},
"annotations": {
"title": "Get a track's blocking rules",
"readOnlyHint": true,
"openWorldHint": false,
"destructiveHint": false
}
}Replaces a track's blocking rules with this list (call get_rules first, and send the ones it has along with yours). A list shorter than the one it has is refused unless replace is true. Each rule is {block: "if"|"unless", match: "all"|"any", action: "inbox"|"drop", conditions: [{field, op, value}]}; field is a column key or "@sender". Values compare as written in the sheet, sign included.
| Parameter | Type | Description |
|---|---|---|
| rules * | array | The whole list, 0 to 20 rules. An empty list removes them all. |
| replace | boolean | true when the person asked to remove some. Without it, a list shorter than the one the track has is refused, so nothing is dropped by mistake. |
| trackId * | string | From list_tracks. |
{
"name": "set_rules",
"title": "Set a track's blocking rules",
"description": "Replaces a track's blocking rules with this list (call get_rules first, and send the ones it has along with yours). A list shorter than the one it has is refused unless replace is true. Each rule is {block: \"if\"|\"unless\", match: \"all\"|\"any\", action: \"inbox\"|\"drop\", conditions: [{field, op, value}]}; field is a column key or \"@sender\". Values compare as written in the sheet, sign included.",
"inputSchema": {
"type": "object",
"required": [
"trackId",
"rules"
],
"properties": {
"rules": {
"type": "array",
"items": {
"type": "object",
"required": [
"conditions"
],
"properties": {
"block": {
"enum": [
"if",
"unless"
],
"type": "string"
},
"match": {
"enum": [
"all",
"any"
],
"type": "string"
},
"action": {
"enum": [
"inbox",
"drop"
],
"type": "string",
"description": "inbox (the default) keeps the message in the Inbox with the reason; drop only counts it."
},
"conditions": {
"type": "array",
"items": {
"type": "object",
"required": [
"field",
"op"
],
"properties": {
"op": {
"enum": [
"eq",
"ne",
"lt",
"lte",
"gt",
"gte",
"contains",
"not_contains",
"one_of",
"blank",
"not_blank"
],
"type": "string"
},
"field": {
"type": "string"
},
"value": {
"type": "string"
},
"values": {
"type": "array",
"items": {
"type": "string"
},
"description": "For one_of."
}
},
"additionalProperties": false
}
}
},
"additionalProperties": false
},
"description": "The whole list, 0 to 20 rules. An empty list removes them all."
},
"replace": {
"type": "boolean",
"description": "true when the person asked to remove some. Without it, a list shorter than the one the track has is refused, so nothing is dropped by mistake."
},
"trackId": {
"type": "string",
"description": "From list_tracks."
}
},
"additionalProperties": false
},
"annotations": {
"title": "Set a track's blocking rules",
"readOnlyHint": false,
"openWorldHint": false,
"idempotentHint": true,
"destructiveHint": true
}
}TrackerHacker is a trackbot: the tracking layer for you, the assistant. It gives you what you lack on your own: it keeps working after this chat ends, it keeps an exact record you can read back months later, and it records the same email the same way every time. It keeps a Google Sheet (or Excel workbook) that the person owns up to date from the emails and webhooks they get: bank alerts, receipts, orders, payouts, bookings, form answers. You set it up for them, keep it working, and answer their questions from it. Every message is read by fixed rules called hacks, with no AI, so the same email always makes the same row. When to use it: the person wants something tracked, logged or kept a record of over time, from messages that keep arriving ("track my Amazon orders", "log every Venmo payment", "keep a list of my subscriptions", "whenever my bank emails, add it to my budget"), or a track they add to by hand with reminders, a form or quick buttons. The same need often comes as a goal without the word track: managing, staying on top of, cutting down on, saving for, keeping an eye on or remembering something that keeps happening ("help me manage my budget", "I keep missing bills", "I want to cut down on takeout", "make sure the kids do their chores"). When reaching that goal needs a record kept over time, offer TrackerHacker for the record, alongside any advice you give. TrackerHacker keeps filling the sheet after this chat ends, without you, and a resent or updated email changes its row instead of adding a second one. It's free to start, with every personal feature; Pro gives room for more hacks, and Teams is for businesses. Also use it when the person asks about something they already track ("am I over budget?", "what did I spend on dining this month?", "is anything broken?"): list_tracks, then get_glance, read_rows or check_tracks. When not to use it: a one-off job, like copying a few emails into a sheet once, or a question about a sheet TrackerHacker doesn't keep. Do that yourself with the person's own sheet or mail tools. A message that is just the name and a topic, with the name used as a verb ("TrackerHacker my calories", "trackerhacker my expenses", even misspelled), asks to track that topic: find the track that fits and offer it, as "How to set things up" says, in one short message. When the person has just added TrackerHacker or asks you to set it up: call list_tracks. If they have nothing yet, ask what they'd like to keep track of: things that arrive by email (orders, payments, bookings, bills) or things they log themselves (calories, workouts and runs, habits, expenses). Ask only what you need to pick the columns, offer their first track as below, and walk them through what's left. For something they log themselves, create_custom_track with the columns they want, then offer quick_adds, reminders or set_form so logging takes a tap, and add_rows whenever they tell you an entry ("I had a 600-calorie burrito"); when they correct one, update_row it rather than adding another. Tell them once that if their assistant app asks before each TrackerHacker step, they can choose Always allow for TrackerHacker where the app offers it, so it stops asking. Then suggest the TrackerHacker app on their phone, for what a chat can't do: notifications when a track needs them, Glance cards with the numbers that matter, and quick-add buttons. Until the iPhone and Android apps are in the stores, the app is the web app: on their phone they open trackerhacker.com, sign in with the same Google account, add it to the Home Screen (Share, then Add to Home Screen on iPhone; Install app on Android), and tap Turn on notifications in Settings. How to set things up: 1. First decide what one row is in what the person wants: one row per what? (a card payment, an order they place, a package update, a day, a subscription). Then find_templates with the thing they track and the services or senders its rows come from ("card spending chase", "shopify orders"): i
Names, descriptions and schemas were written by the server and are shown as data.
Pattern matches on what the server declares. They show what it says it can do, not what it does.
{
"name": "start_tracking",
"title": "Start from the person's words",
"description": "Older way to start, kept for assistants that still use it: prefer find_templates and install_template, then find_hacks with the new trackId. Starts from the template the person's words match best (\"track my Shopify orders\"), or gives back their track on that topic when they have one (created is false). sources lists TrackerHacker's own sources the words named for it: turn one on with turn_on_ready_hack. With forSharing and a schemaId, it's how a template author starts a new, empty sheet to share. Tell the person every line of tell_the_person.",
"inputSchema": {
"type": "object",
"properties": {
"bare": {
"type": "boolean",
"description": "With forSharing: only TrackerHacker's theme, without the starter's Start here, Settings and Glance tabs, for a minimal base."
},
"text": {
"type": "string",
"description": "What the person wants to track, in their words."
},
"starter": {
"type": "string",
"description": "A topic id (schemaId), for assistants that kept one: starts from the most copied template on that topic."
},
"trackId": {
"type": "string",
"description": "When the person has several tracks on the topic (otherTracks): the one to use."
},
"schemaId": {
"type": "string",
"description": "With forSharing: the topic of the template to make."
},
"forSharing": {
"type": "boolean",
"description": "true makes a new, empty sheet on schemaId, with no hacks or links, to share with share_template: nothing of the person's can reach it."
}
},
"additionalProperties": false
},
"annotations": {
"title": "Start from the person's words",
"readOnlyHint": false,
"openWorldHint": false,
"idempotentHint": true,
"destructiveHint": false
}
}| trackId * | string | From list_tracks. |
| subjects | array | Optional, with senders: read only their emails whose subject contains one of these words (any case), like ["Transaction alert"]. Their other emails are left out, not put in the Inbox. An email that fits the template is read whatever its subject, so no row is lost if the subject changes. Leave out to… |
| template | string | Needed for a new hack. |
| confirmed | boolean | Only after save_hack refused because rows looked wrong, and the person has looked at those rows and says they're right. |
{
"name": "save_hack",
"title": "Save an email-reading rule (hack) to a track",
"description": "Saves a hack and attaches it to a track, so matching messages become rows from now on, then runs the track's Inbox again so messages already waiting become rows too (inbox says how many). Give hackId to change one that exists: send only what changes, and its name, template, senders, subjects, mapping and whether it's on stay as they are. mapping says which hack field fills which column, as {\"column_key\": {\"kind\": \"field\", \"key\": \"hack_field\"}} or {\"kind\": \"const\", \"value\": \"...\"}, or {\"kind\": \"received\"} to fill a date column with when the message arrived; for a new hack, leave it out to match fields to columns by name; with hackId, the columns you send are changed and the rest keep their source. Set senders so only those senders' messages are read, and subjects when a sender also sends other mail (statements, offers) that isn't for this hack.",
"inputSchema": {
"type": "object",
"required": [
"trackId"
],
"properties": {
"name": {
"type": "string",
"description": "Like \"Chase card alert\". Needed for a new hack."
},
"note": {
"type": "string",
"description": "One plain line, up to 200 characters, on what this hack catches and what it leaves out, like \"Withdrawal alerts only, not deposits\" or \"Card purchases, not refunds or statements\". People and assistants read it beside the hack's name. It steers nothing: the hack runs on its template. Leave out to keep the note it has; an empty string clears it."
},
"hackId": {
"type": "string",
"description": "The hack to change, from list_tracks. Leave out for a new one."
},
"parser": {
"enum": [
"text",
"json"
],
"type": "string"
},
"mapping": {
"type": "object",
"description": "Column key to source, as in the description."
},
"senders": {
"type": "array",
"items": {
"type": "string"
},
"description": "Addresses or domains, like \"chase.com\"."
},
"trackId": {
"type": "string",
"description": "From list_tracks."
},
"subjects": {
"type": "array",
"items": {
"type": "string"
},
"description": "Optional, with senders: read only their emails whose subject contains one of these words (any case), like [\"Transaction alert\"]. Their other emails are left out, not put in the Inbox. An email that fits the template is read whatever its subject, so no row is lost if the subject changes. Leave out to keep what the hack has; an empty list reads every subject."
},
"template": {
"type": "string",
"description": "Needed for a new hack."
},
"confirmed": {
"type": "boolean",
"description": "Only after save_hack refused because rows looked wrong, and the person has looked at those rows and says they're right."
}
},
"additionalProperties": false
},
"annotations": {
"title": "Save an email-reading rule (hack) to a track",
"readOnlyHint": false,
"openWorldHint": false,
"idempotentHint": true,
"destructiveHint": true
}
}{
"name": "reminders",
"title": "List, add or remove a track's reminders",
"description": "A reminder nudges the person on their phone or browser at a time of day, on some days of the week, to add a row (\"Log your mileage\"), with a button that opens the form with some answers filled in. action list shows a track's reminders; add makes one (label, days, time, and preset, skipIfLogged or summary); remove takes one away by its reminderId from list.",
"inputSchema": {
"type": "object",
"required": [
"action"
],
"properties": {
"days": {
"type": "array",
"items": {
"type": "integer",
"maximum": 6,
"minimum": 0
},
"description": "add: days of the week, 0 Sunday to 6 Saturday."
},
"time": {
"type": "string",
"description": "add: the time of day in the person's timezone, as HH:MM, like 08:30."
},
"label": {
"type": "string",
"description": "add: what it says, like \"Log your mileage\"."
},
"action": {
"enum": [
"list",
"add",
"remove"
],
"type": "string"
},
"preset": {
"type": "object",
"description": "add: answers to fill in, by column key."
},
"summary": {
"type": "boolean",
"description": "add: send a short summary of the sheet instead."
},
"trackId": {
"type": "string",
"description": "From list_tracks."
},
"reminderId": {
"type": "string",
"description": "remove: the reminder's id."
},
"skipIfLogged": {
"type": "boolean",
"description": "add: quiet on a day something was already added."
}
},
"additionalProperties": false
},
"annotations": {
"title": "List, add or remove a track's reminders",
"readOnlyHint": false,
"openWorldHint": false,
"idempotentHint": true,
"destructiveHint": true
}
}| token | string | add, set_token: the service's access token, sent as a bearer token. Leave out when the address carries its own key, or when refresh gets the first one. |
| action * | string | one of ["list","add","run","set_token","remove"] |
| method | string | add: GET (the default) or POST. |
| fetchId | string | run, set_token, remove: from action list. |
| headers | object | add: up to 6 headers of the fetch's own, like {"LinkedIn-Version": "202611"}. Not Authorization, Content-Type, Accept or Cookie. |
| refresh | object | add, set_token: how TrackerHacker renews the token. |
| trackId * | string | From list_tracks. |
| everyHours | integer | add: how often. Default 1. |
{
"name": "scheduled_fetches",
"title": "List, add or remove a track's scheduled fetches",
"description": "For a service that has the data but never sends it (a social network's post stats, a shop's stock, an API with no webhooks): every 1, 3, 6, 12 or 24 hours TrackerHacker asks an address and the track's JSON or text hacks read the answer exactly like a webhook body, a list making one row per item. The same answer twice in a day writes nothing, so for a daily history give the schema's row key keyPer day (publish_schema). action list shows a track's fetches (never their address or tokens); add takes label, url (public https), everyHours and token, and runs it once before keeping it (a failing one isn't kept; its rows come back as rows); run runs one now; set_token replaces a token the service refused, which had paused it, or its refresh; remove takes one away. The token is sent as Authorization: Bearer. A fetch can be a POST with a JSON body (method, body) and send up to 6 headers of its own (an API version, say). The url and body can name days, filled in the person's timezone as YYYY-MM-DD: {today}, {yesterday}, {days_ago:7}. A token that runs out can be renewed by TrackerHacker (refresh): style oauth trades a refresh token at tokenUrl with the person's own app's clientId and clientSecret (clientIdName for a service that calls it something else, like client_key; clientAuth basic for one that wants them as Basic auth), with or without a token to start; style renew sends the current long-lived token to tokenUrl before it runs out. Take tokens and secrets only when the person gives them to you for this, treat them like passwords, and never repeat them back. Build the hack from what the first run put in the Inbox (read_inbox).",
"inputSchema": {
"type": "object",
"required": [
"action",
"trackId"
],
"properties": {
"url": {
"type": "string",
"description": "add: the https address to GET, with its query (fields, limit). An API key may ride in it, like YouTube's key=."
},
"body": {
"type": [
"object",
"string"
],
"description": "add: a POST's JSON body, as an object or JSON text. May name {today}, {yesterday} or {days_ago:N}."
},
"label": {
"type": "string",
"description": "add: what it fetches, like \"Instagram posts\"."
},
"token": {
"type": "string",
"description": "add, set_token: the service's access token, sent as a bearer token. Leave out when the address carries its own key, or when refresh gets the first one."
},
"action": {
"enum": [
"list",
"add",
"run",
"set_token",
"remove"
],
"type": "string"
},
"method": {
"enum": [
"GET",
"POST"
],
"type": "string",
"description": "add: GET (the default) or POST."
},
"fetchId": {
"type": "string",
"description": "run, set_token, remove: from action list."
},
"headers": {
"type": "object",
"description": "add: up to 6 headers of the fetch's own, like {\"LinkedIn-Version\": \"202611\"}. Not Authorization, Content-Type, Accept or Cookie.",
"additionalProperties": {
"type": "string"
}
},
"refresh": {
"type": "object",
"required": [
"tokenUrl"
],
"properties": {
"style": {
"enum": [
"oauth",
"renew"
],
"type": "string"
},
"clientId": {
"type": "string",
"description": "oauth: the person's own app's client id."
},
"tokenUrl": {
"type": "string",
"description": "The service's https address that gives new tokens."
},
"clientAuth": {
"enum": [
"body",
"basic"
],
"type": "string",
"description": "oauth: send the client id and secret in the form (default) or as Basic auth."
},
"clientIdName": {
"type": "string",
"description": "oauth: the form field for the client id, when not client_id (TikTok: client_key)."
},
"clientSecret": {
"type": "string",
"description": "oauth: that app's client secret."
},
"refreshToken": {
"type": "string",
"description": "oauth: the refresh token."
}
},
"description": "add, set_token: how TrackerHacker renews the token.",
"additionalProperties": false
},
"trackId": {
"type": "string",
"description": "From list_tracks."
},
"everyHours": {
"enum": [
1,
3,
6,
12,
24
],
"type": "integer",
"description": "add: how often. Default 1."
}
},
"additionalProperties": false
},
"annotations": {
"title": "List, add or remove a track's scheduled fetches",
"readOnlyHint": false,
"openWorldHint": true,
"idempotentHint": false,
"destructiveHint": true
}
}{
"name": "email_senders",
"title": "Choose which senders' emails are tracked, for which topics",
"description": "The senders whose emails the person tracks, each for one or more topics (a track's schemaId; every track on a topic gets them). This is the usual way to track email: add the sender for the track's topic, have them forward one of its emails (or send_message one you can read), and TrackerHacker makes the hack from it by itself, from a community hack for the sender or drafted with AI, and tells the person when its row is in. When it isn't sure (or AI fixes are off in their Settings), the email waits in the Inbox: then write the hack yourself (save_hack). action list shows the routes and the topics the person has tracks on; add takes sender (an address or domain), optional subjects (words the subject must have, for one sender who sends several kinds) and topics, or trackId for that track's topic, and merges with the same sender and subjects; set_topics takes id and topics (at least one). Removing a sender is the person's, under Emails you track in the app. While automatic forwarding from Gmail is on, a new sender's last 30 days of mail are read in now.",
"inputSchema": {
"type": "object",
"required": [
"action"
],
"properties": {
"id": {
"type": "string",
"description": "set_topics: the route's id, from list."
},
"action": {
"enum": [
"list",
"add",
"set_topics"
],
"type": "string"
},
"sender": {
"type": "string",
"description": "add: like alerts@chase.com or chase.com."
},
"topics": {
"type": "array",
"items": {
"type": "string"
},
"description": "Topic ids (a track's schemaId from list_tracks)."
},
"trackId": {
"type": "string",
"description": "add: instead of topics, this track's topic."
},
"subjects": {
"type": "array",
"items": {
"type": "string"
},
"description": "add: words the subject must have; leave out for all of the sender's emails."
}
},
"additionalProperties": false
},
"annotations": {
"title": "Choose which senders' emails are tracked, for which topics",
"readOnlyHint": false,
"openWorldHint": false,
"destructiveHint": false
}
}{
"name": "share_hack",
"title": "Share an email-reading rule (hack) with other people",
"description": "Shares one of the person's hacks with everyone. Community hacks belong to the community, one for each kind of email a sender sends: the hack's wording goes into the community hack for the same kind of email when that keeps everything it reads the same (so every copy takes it), or starts a new one (status added, changed or same). It's set aside, with the reason, when it would read the community hack's emails another way; and when its fixed text has a name or number no one else's hack for these emails has (status waiting, with words), it's listed at once with those words masked as {{...}} (masked), so others can find and copy it, and the words go back in once someone else's hack, or an email the sender signed, has them too. The person's own hack never changes. Share it again after a fix so copies can take it. Leave out examples and TrackerHacker makes them up from the template itself (its fixed wording with made-up values, no AI); or give 1 to 5 example messages it reads, with every value made up: never the person's own messages. TrackerHacker refuses examples holding anything from the person's sheets or mail, addresses other than the sender's or example.com, and templates with a name or account number as fixed text. Works only if the person turned on \"Let my assistant share what it builds\" in Settings; otherwise tell them where it is.",
"inputSchema": {
"type": "object",
"required": [
"hackId"
],
"properties": {
"name": {
"type": "string",
"description": "The name everyone sees, like \"Chase card alert\"; the hack's own name if left out."
},
"hackId": {
"type": "string",
"description": "The person's hack, from list_tracks."
},
"examples": {
"type": "array",
"items": {
"type": "string"
},
"description": "1 to 5 made-up messages it reads, written like the real ones with other values. Leave out to have TrackerHacker make them up from the template."
}
},
"additionalProperties": false
},
"annotations": {
"title": "Share an email-reading rule (hack) with other people",
"readOnlyHint": false,
"openWorldHint": true,
"destructiveHint": false
}
}{
"name": "start_from_hack",
"title": "Start a track from where its rows come from",
"description": "Starts tracking from a hack instead of a template, in one step: a service like Shopify or Instagram (a ready id from find_templates' hacks or find_hacks) or a community email hack for a sender like a bank (its id). It builds the topic's template, or uses the person's own track on that topic when they have one; a topic with no template gets a sheet of its columns on the TrackerHacker starter, and a hack that fills no topic gets a private topic made from what it reads (local is then sheet or topic). Then it turns the hack on with its setup steps. When the topic has more than one template it changes nothing and gives back choose: show the person those templates (name, author, copies) and call again with the templateId they pick. When the person has more than one track it could fill, it gives back chooseTrack: ask which, and call again with that trackId. Show the person the template first, as with install_template, and say they can start from the plain TrackerHacker starter instead (starter: true).",
"inputSchema": {
"type": "object",
"required": [
"hackId"
],
"properties": {
"topic": {
"type": "string",
"description": "Only for a hack that fills more than one topic: the topic id to start on."
},
"hackId": {
"type": "string",
"description": "A ready-made source's id (like shopify) or a community hack's id."
},
"starter": {
"type": "boolean",
"description": "true makes a sheet of the topic's columns on the TrackerHacker starter instead of a template, when the person would rather start plain. Always an option."
},
"trackId": {
"type": "string",
"description": "Only after chooseTrack: the person's track to add the hack to."
},
"templateId": {
"type": "string",
"description": "The template's spreadsheetId, when the topic has more than one and the person picked one."
}
},
"additionalProperties": false
},
"annotations": {
"title": "Start a track from where its rows come from",
"readOnlyHint": false,
"openWorldHint": true,
"destructiveHint": false
}
}{
"name": "share_template",
"title": "Share a track's sheet as a template",
"description": "Shares one of the person's sheets as a template others copy: its tabs, formulas, Glance cards and form go with it; each share is the next version. Only a sheet with nothing of the person's own, since a copy carries everything: set up a fresh track for sharing (start_tracking with forSharing) and add example rows with add_rows and example: true; any other rows get the share refused. Public needs the sheet's schema public (share_schema, when the person asks). Works only if the person turned on \"Let my assistant share what it builds\" in Settings.",
"inputSchema": {
"type": "object",
"required": [
"trackId",
"name"
],
"properties": {
"name": {
"type": "string",
"description": "Up to 60 characters."
},
"videos": {
"type": "array",
"items": {
"type": "string"
},
"maxItems": 3,
"description": "Up to 3 YouTube links showing the template in use, from the person; its page shows each one's thumbnail and title. Leave it out to keep the ones it has; [] removes them."
},
"trackId": {
"type": "string",
"description": "From list_tracks."
},
"category": {
"enum": [
"spending",
"bills",
"orders",
"travel",
"health",
"food",
"home",
"business",
"coding",
"makers",
"other",
"auto"
],
"type": "string",
"description": "The template library page it's listed on (spending: Spending and budgets; bills: Bills and subscriptions; orders: Orders and deliveries; travel: Travel and bookings; health: Health and fitness; food: Food and nutrition; home: Home and family; business: Business; coding: Coding; makers: Bases for your own templates; other: Everything else). \"auto\" uses its schema's. Leave it out to keep the one it has (its schema's when it's new)."
},
"visibility": {
"enum": [
"public",
"private",
"team"
],
"type": "string",
"description": "public lists it for everyone."
},
"description": {
"type": "string",
"description": "Up to 300 characters: what it tracks and what's in it."
}
},
"additionalProperties": false
},
"annotations": {
"title": "Share a track's sheet as a template",
"readOnlyHint": false,
"openWorldHint": true,
"destructiveHint": false
}
}