Connected systems

Secrets

Stored values the agent can use without ever reading them

On this page(23 sections)

Store a secret
Names of the stored secrets
Make and store a random secret
Delete a secret
Every secret this sandbox holds, from everywhere
Show one secret's value
Which credentials need somebody's approval
Put a credential behind named approvers
Stop requiring approval for a credential
Which secrets are host-guarded, and where they may go
Turn a secret's host guard on or off, and set its hosts
Which programs each secret may be typed into
Set which programs a secret may be typed into
Type a secret into the focused window on one of your computers
The keyrings on your computers
Pair the keyrings on two of your computers
Ask the owner's computers for a credential by where it is used
The passwords this sandbox may use
Credentials this sandbox asked for that wait for an answer
This sandbox's uses of the owner's passwords
How a connection's credential reaches the agent, and what it may do
Set how a connection's credential reaches the agent, and its rules
Ask a named person to release a credential

Write a secret, list which names exist, delete one. Revealing a value is the deliberate exception and the only route that hands one back; everywhere else the daemon substitutes a secret by reference at the moment a command runs.

23 calls. Pick one to open it, or use the list on the right.

POST/secretsStore a secret

Writes one name and value where the agent's references resolve it, without a restart: desired-state/.env once DevOps is active, the sandbox's own secret store before that.

What you send

Field	Type	Where
`key`requiredThe name to store it under,…	string	body
`value`requiredThe value	string	body

What comes back

Field	Type
`ok`Always true	true

Try itanswered in this tab

curl

curl -X POST "$SANDBOX/secrets" \
  -H "x-intentic-control: $INTENTIC_TOKEN" \
  -H "content-type: application/json" \
  -d '{"key":"OPENAI_API_KEY","value":"…"}'

TypeScript

import { sandbox } from "@intentic/sandbox-client";

const result = await sandbox.secrets.set({
  "key": "OPENAI_API_KEY",
  "value": "…"
});

GET/secretsNames of the stored secrets

Which secrets exist here. Names only, never values.

What you send

Nothing. Call it as it is.

What comes back

Field	Type
`keys`The names that exist here	string[]

Try itanswered in this tab

curl

curl "$SANDBOX/secrets" \
  -H "x-intentic-control: $INTENTIC_TOKEN"

TypeScript

import { sandbox } from "@intentic/sandbox-client";

const result = await sandbox.secrets.list();

POST/secrets/generateMake and store a random secret

Makes a random value and stores it under a new name, where `set` would have put it, for a secret nobody has to find or paste (a session key, a signing secret, a password the task sets up itself). Answers the name and its length, never the value. Refused for a name something here already holds.

What you send

Field	Type	Where
`key`requiredThe name to store it under:…	string	body
`bytes`How much randomness, in bytes	integer	body
`format`How it is spelled: `hex` (0-9,…	"hex" \| "base64url" \| "alnum"	body

What comes back

Field	Type
`key`The name it is stored under	string
`length`How many characters it is, which…	integer
`stored`Where it was kept: desired-state/.env once…	"env" \| "sandbox"

Try itanswered in this tab

curl

curl -X POST "$SANDBOX/secrets/generate" \
  -H "x-intentic-control: $INTENTIC_TOKEN" \
  -H "content-type: application/json" \
  -d '{"key":"OPENAI_API_KEY","bytes":32,"format":"hex"}'

TypeScript

import { sandbox } from "@intentic/sandbox-client";

const result = await sandbox.secrets.generate({
  "key": "OPENAI_API_KEY",
  "bytes": 32,
  "format": "hex"
});

DELETE/secrets/{key}Delete a secret

Removes one by name.

What you send

Field	Type	Where
`key`requiredWhich secret, by name	string	address

What comes back

Field	Type
`ok`Always true	true

Try itanswered in this tab

curl

curl -X DELETE "$SANDBOX/secrets/OPENAI_API_KEY" \
  -H "x-intentic-control: $INTENTIC_TOKEN"

TypeScript

import { sandbox } from "@intentic/sandbox-client";

const result = await sandbox.secrets.remove({
  "key": "OPENAI_API_KEY"
});

GET/secrets/inventoryEvery secret this sandbox holds, from everywhere

One view across all the places secrets live here: what exists, where it came from and whether it is working. Never any values. This one always answers, even before there is a store to write to.

What you send

Nothing. Call it as it is.

What comes back

Field	Type
`entries`One entry per secret this sandbox…	object[]
`key`What identifies it	string
`kind`Where it came from: you set…	"env" \| "generated" \| "capability" \| "provider" … (5)
`label`A friendlier name, for entries that…	string
`status`Whether it exists and, for a…	"missing" \| "set" \| "connected"
`requiredBy`What is waiting on it	object[]
`resourceId`Which resource	string
`type`What kind of resource it is	string
`storedAt`Where it actually lives, in words	string
`revealable`Whether its value can be shown…	boolean
`ci`Whether a copy has been given…	object
`synced`Whether the pipeline has it	boolean
`pushedAt`When it was last sent there	string
`lastUse`The last time an agent actually…	object
`at`When, in milliseconds	number
`lane`How it was used: a command,…	"shell" \| "code" \| "browser" \| "gateway" … (7)
`detail`Where it went: the start of…	string
`approvedBy`Who released it for that use,…	string
`credential`How the agent gets this connection's…	object
`delivery`How the agent gets this connection's…	"gateway" \| "raw" \| "direct" \| "ssh-agent"
`rules`What the credential may do through…	object[]
`methods`The HTTP methods it covers (`DELETE`,…	string[]
`paths`The paths it covers, below the…	string[]
`action``allow` forwards it, `ask` holds it…	"allow" \| "ask" \| "deny"
`why`One line on what the rule…	string
`rulesFrom`Whose rules these are: the connector's…	"connector" \| "owner"
`gate`Who has to release this before…	object
`approvers`Who may release it, by email	string[]
`scope`How far one release goes: `use`…	"use" \| "conversation"
`hosts`Its host guard	object
`guard`Whether a use off the list,…	boolean
`list`The hosts it goes to unasked…	string[]
`source`Who set it: the owner, the…	"owner" \| "connector" \| "keyring"
`programs`Which programs on the owner's computers,…	object
`programs`Programs, by executable name or whole…	string[]
`packages`Android apps, by package name, it…	string[]
`anyField`Whether it may go into a…	boolean
`source`Who keeps the list: the owner,…	"owner" \| "keyring"
`device`Where a secret held on one…	object
`machine`Which computer's keyring holds it, by…	string
`mode`How the keyring answers this sandbox:…	"each-use" \| "while-here" \| "copy"
`online`Whether that computer answers now	boolean
`locked`Whether the keyring there is locked,…	boolean
`source`Where the value itself is read…	"keyring" \| "bitwarden" \| "1password" \| "keepassxc"

Try itanswered in this tab

curl

curl "$SANDBOX/secrets/inventory" \
  -H "x-intentic-control: $INTENTIC_TOKEN"

TypeScript

import { sandbox } from "@intentic/sandbox-client";

const result = await sandbox.secrets.inventory();

POST/secrets/revealShow one secret's value

The only call that hands a value back, and it is for the owner alone. Sent as a body rather than in the address, so the name never ends up in a log or a browser's history.

What you send

Field	Type	Where
`key`requiredWhich secret, by name	string	body

What comes back

Field	Type
`value`The value itself	string

Try itanswered in this tab

curl

curl -X POST "$SANDBOX/secrets/reveal" \
  -H "x-intentic-control: $INTENTIC_TOKEN" \
  -H "content-type: application/json" \
  -d '{"key":"OPENAI_API_KEY"}'

TypeScript

import { sandbox } from "@intentic/sandbox-client";

const result = await sandbox.secrets.reveal({
  "key": "OPENAI_API_KEY"
});

GET/secrets/gatesWhich credentials need somebody's approval

What is gated and who may release it. Names and addresses only, never values, and the agent may read it too: knowing a credential needs Bob is what stops it concluding the account is simply not connected.

What you send

Nothing. Call it as it is.

What comes back

Field	Type
`gates`Every gate in force	object[]
`subject`What is gated: a secret's name,…	string
`kind`Whether this gate covers one stored…	"secret" \| "capability"
`approvers`Exactly who may release it, by…	string[]
`scope`How far one release goes: `use`…	"use" \| "conversation"

Try itanswered in this tab

curl

curl "$SANDBOX/secrets/gates" \
  -H "x-intentic-control: $INTENTIC_TOKEN"

TypeScript

import { sandbox } from "@intentic/sandbox-client";

const result = await sandbox.secrets.gates();

PUT/secrets/gates/{subject}Put a credential behind named approvers

Names exactly who may release one secret or one connected account, and how far a single release goes. The owner's call alone. A signed-in browser or a mounted server cannot be released for one use, so those are always for the rest of the conversation.

What you send

Field	Type	Where
`subject`requiredWhat is gated: a secret's name,…	string	address
`kind`requiredWhether this gate covers one stored…	"secret" \| "capability"	body
`approvers`requiredExactly who may release it, by…	string[]	body
`scope`requiredHow far one release goes: `use`…	"use" \| "conversation"	body

What comes back

Field	Type
`ok`Always true	true

Try itanswered in this tab

curl

curl -X PUT "$SANDBOX/secrets/gates/Fix%20the%20flaky%20parser%20test" \
  -H "x-intentic-control: $INTENTIC_TOKEN" \
  -H "content-type: application/json" \
  -d '{"kind":"secret","approvers":["…","…"],"scope":"use"}'

TypeScript

import { sandbox } from "@intentic/sandbox-client";

const result = await sandbox.secrets.setGate({
  "subject": "Fix the flaky parser test",
  "kind": "secret",
  "approvers": [
    "…",
    "…"
  ],
  "scope": "use"
});

DELETE/secrets/gates/{subject}Stop requiring approval for a credential

Removes one gate, so the agent can use that credential the way it uses any other. The owner's call alone.

What you send

Field	Type	Where
`subject`requiredWhich gate, by the secret name…	string	address

What comes back

Field	Type
`ok`Always true	true

Try itanswered in this tab

curl

curl -X DELETE "$SANDBOX/secrets/gates/Fix%20the%20flaky%20parser%20test" \
  -H "x-intentic-control: $INTENTIC_TOKEN"

TypeScript

import { sandbox } from "@intentic/sandbox-client";

const result = await sandbox.secrets.removeGate({
  "subject": "Fix the flaky parser test"
});

GET/secrets/hostsWhich secrets are host-guarded, and where they may go

Every secret and connected account whose host guard is set, on or off, and its hosts. With the guard on, a use aimed off the list, or anywhere a command's text does not show, asks a person first, whatever the safety judge says. Names and hosts only, never values.

What you send

Nothing. Call it as it is.

What comes back

Field	Type
`guards`Every secret whose host guard has…	object[]
`subject`Which secret, by the name its…	string
`kind`Whether this gate covers one stored…	"secret" \| "capability"
`guard`On: a use off the list,…	boolean
`hosts`Where it goes without asking while…	string[]
`source`Who set it: the owner, the…	"owner" \| "connector" \| "keyring"

Try itanswered in this tab

curl

curl "$SANDBOX/secrets/hosts" \
  -H "x-intentic-control: $INTENTIC_TOKEN"

TypeScript

import { sandbox } from "@intentic/sandbox-client";

const result = await sandbox.secrets.hosts();

PUT/secrets/hosts/{subject}Turn a secret's host guard on or off, and set its hosts

Replaces one secret's host guard. Anybody who may use secrets can turn it on or take hosts away; turning it off or adding a host is the owner's: from the agent it raises a card for the owner in the live conversation and waits for their answer.

What you send

Field	Type	Where
`subject`requiredWhich secret, by name, or which…	string	address
`kind`Whether the subject is a secret…	"secret" \| "capability"	body
`guard`requiredWhether a use off the list,…	boolean	body
`hosts`requiredThe whole new list	string[]	body
`conversationId`Which conversation to ask the owner…	string	body

What comes back

Field	Type
`guard`Whether the guard is on now	boolean
`hosts`Where it goes without asking while…	string[]
`approvedBy`Who approved the change, when it…	string

Try itanswered in this tab

curl

curl -X PUT "$SANDBOX/secrets/hosts/Fix%20the%20flaky%20parser%20test" \
  -H "x-intentic-control: $INTENTIC_TOKEN" \
  -H "content-type: application/json" \
  -d '{"kind":"secret","guard":true,"hosts":["sandbox-a1b2c3d4e5f6.intentic.dev","sandbox-a1b2c3d4e5f6.intentic.dev"],"conversationId":"nightly-changelog"}'

TypeScript

import { sandbox } from "@intentic/sandbox-client";

const result = await sandbox.secrets.setHosts({
  "subject": "Fix the flaky parser test",
  "kind": "secret",
  "guard": true,
  "hosts": [
    "sandbox-a1b2c3d4e5f6.intentic.dev",
    "sandbox-a1b2c3d4e5f6.intentic.dev"
  ],
  "conversationId": "nightly-changelog"
});

GET/secrets/programsWhich programs each secret may be typed into

Every sandbox-held secret whose program list is set: the programs on the owner's computers and the phone apps it goes into unasked. A secret held in a computer's keyring carries its own list, shown on its inventory row. Names and programs only, never values.

What you send

Nothing. Call it as it is.

What comes back

Field	Type
`guards`Every sandbox-held secret whose program list…	object[]
`programs`Programs, by executable name or whole…	string[]
`packages`Android apps, by package name, it…	string[]
`anyField`Whether it may go into a…	boolean
`subject`Which secret, by the name its…	string

Try itanswered in this tab

curl

curl "$SANDBOX/secrets/programs" \
  -H "x-intentic-control: $INTENTIC_TOKEN"

TypeScript

import { sandbox } from "@intentic/sandbox-client";

const result = await sandbox.secrets.programs();

PUT/secrets/programs/{subject}Set which programs a secret may be typed into

Replaces one sandbox-held secret's program list. Taking programs away, or turning `anyField` off, is open to anybody who may use secrets; adding one is the owner's: from the agent it raises a card for the owner in the live conversation and waits. Refused for a secret a computer's keyring holds, whose list is changed on that computer.

What you send

Field	Type	Where
`subject`requiredWhich secret, by the name its…	string	address
`programs`requiredPrograms, by executable name or whole…	string[]	body
`packages`requiredAndroid apps, by package name, it…	string[]	body
`anyField`requiredWhether it may go into a…	boolean	body
`conversationId`Which conversation to ask the owner…	string	body

What comes back

Field	Type
`programs`Programs, by executable name or whole…	string[]
`packages`Android apps, by package name, it…	string[]
`anyField`Whether it may go into a…	boolean
`approvedBy`Who approved the change, when it…	string

Try itanswered in this tab

curl

curl -X PUT "$SANDBOX/secrets/programs/Fix%20the%20flaky%20parser%20test" \
  -H "x-intentic-control: $INTENTIC_TOKEN" \
  -H "content-type: application/json" \
  -d '{"programs":["…","…"],"packages":["…","…"],"anyField":true,"conversationId":"nightly-changelog"}'

TypeScript

import { sandbox } from "@intentic/sandbox-client";

const result = await sandbox.secrets.setPrograms({
  "subject": "Fix the flaky parser test",
  "programs": [
    "…",
    "…"
  ],
  "packages": [
    "…",
    "…"
  ],
  "anyField": true,
  "conversationId": "nightly-changelog"
});

POST/secrets/type-intoType a secret into the focused window on one of your computers

After a short countdown, types one secret into whatever has focus on the computer named, through its keyring, which checks the window and still asks there when the entry's share says to. Answers what it went into, never the value.

What you send

Field	Type	Where
`key`requiredWhich secret, by name	string	body
`device`requiredWhich computer, by its device card…	string	body
`countdownSeconds`How long to wait before typing,…	integer	body

What comes back

Field	Type
`program`What it was typed into	string
`field`Whether the focused field was a…	"password" \| "text"
`asked`Whether the person at the computer…	boolean

Try itanswered in this tab

curl

curl -X POST "$SANDBOX/secrets/type-into" \
  -H "x-intentic-control: $INTENTIC_TOKEN" \
  -H "content-type: application/json" \
  -d '{"key":"OPENAI_API_KEY","device":"…","countdownSeconds":3}'

TypeScript

import { sandbox } from "@intentic/sandbox-client";

const result = await sandbox.secrets.typeInto({
  "key": "OPENAI_API_KEY",
  "device": "…",
  "countdownSeconds": 3
});

GET/secrets/keyringsThe keyrings on your computers

Every connected computer with a keyring this sandbox can reach: whether it answers and is unlocked, how many of its entries are shared here, and whom it is paired with. Names and counts only, never values.

What you send

Nothing. Call it as it is.

What comes back

Field	Type
`keyrings`	object[]
`machine`The computer, by its device card	string
`online`Whether it answers now	boolean
`locked`Whether its keyring is locked, as…	boolean
`setUp`Whether its keyring answers with a…	boolean
`version`The keyring's release, as last heard	string
`pendingInbox`Values sent to be kept there…	integer
`shared`How many of its entries are…	integer
`sync`Its pairing with the owner's other…	object
`fingerprint`Its sync key's fingerprint, to compare…	string
`peers`The computers it is paired with,…	string[]

Try itanswered in this tab

curl

curl "$SANDBOX/secrets/keyrings" \
  -H "x-intentic-control: $INTENTIC_TOKEN"

TypeScript

import { sandbox } from "@intentic/sandbox-client";

const result = await sandbox.secrets.keyrings();

POST/secrets/keyrings/pairPair the keyrings on two of your computers

Asks each computer's keyring to pair with the other: each shows a prompt with both fingerprints, and only a yes on both pairs them. After that each keeps the other's entries in step, sealed between them and carried by this sandbox, which cannot open what it carries.

What you send

Field	Type	Where
`a`requiredOne computer, by its device card	string	body
`b`requiredThe other	string	body

What comes back

Field	Type
`fingerprints`Each keyring's sync-key fingerprint, as both…	object
`a`	string
`b`	string

Try itanswered in this tab

curl

curl -X POST "$SANDBOX/secrets/keyrings/pair" \
  -H "x-intentic-control: $INTENTIC_TOKEN" \
  -H "content-type: application/json" \
  -d '{"a":"…","b":"…"}'

TypeScript

import { sandbox } from "@intentic/sandbox-client";

const result = await sandbox.secrets.keyringPair({
  "a": "…",
  "b": "…"
});

POST/secrets/wantAsk the owner's computers for a credential by where it is used

Asks each of the owner's computers with Passwords set up, most recently used first, for a credential that works at the place named (a site, a program, an ssh target, a git host). The person there is asked whether this sandbox may use it, and on what terms. Answers the name a reference uses once allowed, or that the answer is awaited in Passwords. Never a value.

What you send

Field	Type	Where
`origin`requiredWhere it is to be used:…	object	body
`when kind is "site"`	shape	body
`host`requiredThe page's host, `github.com`; never a…	string	body
`when kind is "program"`	shape	body
`program`requiredA program, by its executable's file…	string	body
`label`The program's own name for people,…	string	body
`when kind is "package"`	shape	body
`package`requiredAn Android app, by its package…	string	body
`label`	string	body
`when kind is "ssh"`	shape	body
`target`required`user@host`, as ssh's prompt names it	string	body
`when kind is "ssh-key"`	shape	body
`path`required	string	body
`when kind is "sudo"`	shape	body
`user`	string	body
`when kind is "git"`	shape	body
`url`required`https://host`, as git's credential helper or…	string	body
`when kind is "prompt"`	shape	body
`text`requiredThe prompt's own words, `Password for…	string	body
`command`The command that asked, `npm login`,…	string	body
`sandbox`The sandbox whose terminal asked, for…	string	body
`username`The account wanted, when the agent…	string	body
`why`requiredWhat it is for, in words…	string	body
`conversationId`	string	body

What comes back

Field	Type
`when state is "allowed"`	shape
`name`The name a secret reference uses…	string
`machine`The computer whose keyring shares it	string
`message`	string
`when state is "pending"`	shape
`id`	string
`machine`	string
`message`Where the owner's answer is awaited	string
`when state is "denied"`	shape
`message`	string
`when state is "unknown"`	shape
`message`No keyring had it and nobody…	string

Try itanswered in this tab

curl

curl -X POST "$SANDBOX/secrets/want" \
  -H "x-intentic-control: $INTENTIC_TOKEN" \
  -H "content-type: application/json" \
  -d '{"origin":{"kind":"site","host":"sandbox-a1b2c3d4e5f6.intentic.dev"},"username":"…","why":"…","conversationId":"nightly-changelog"}'

TypeScript

import { sandbox } from "@intentic/sandbox-client";

const result = await sandbox.secrets.want({
  "origin": {
    "kind": "site",
    "host": "sandbox-a1b2c3d4e5f6.intentic.dev"
  },
  "username": "…",
  "why": "…",
  "conversationId": "nightly-changelog"
});

GET/secrets/passwordsThe passwords this sandbox may use

Every entry the keyrings on the owner's computers share with this sandbox, where each works and how this sandbox may use it, and each computer's Passwords state. Names and places only, never values.

What you send

Nothing. Call it as it is.

What comes back

Field	Type
`sandbox`This sandbox's own address, as the…	string
`items`	object[]
`name`	string
`title`	string
`kind`	"password" \| "text"
`origins`Where it works, from the entry's…	object[]
`when kind is "site"`	shape
`host`The page's host, `github.com`; never a…	string
`when kind is "program"`	shape
`program`A program, by its executable's file…	string
`label`The program's own name for people,…	string
`when kind is "package"`	shape
`package`An Android app, by its package…	string
`label`	string
`when kind is "ssh"`	shape
`target``user@host`, as ssh's prompt names it	string
`when kind is "ssh-key"`	shape
`path`	string
`when kind is "sudo"`	shape
`user`	string
`when kind is "git"`	shape
`url``https://host`, as git's credential helper or…	string
`when kind is "prompt"`	shape
`text`The prompt's own words, `Password for…	string
`command`The command that asked, `npm login`,…	string
`sandbox`The sandbox whose terminal asked, for…	string
`anyField`	boolean
`machine`The computer whose keyring keeps it	string
`mode`How this sandbox may use it	"each-use" \| "while-here" \| "copy"
`online`	boolean
`updatedAt`	number
`lastUsedAt`This sandbox's last use of it,…	number
`keyrings`	object[]
`machine`	string
`online`	boolean
`setUp`Answering, set up, and trusted by…	boolean
`locked`	boolean
`remember`	object
`browser`Sign-ins in a browser with the…	boolean
`terminal`ssh, sudo and git prompts on…	boolean
`apps`Password fields in programs on this…	boolean
`phone`The paired phone's autofill	boolean
`sandbox`Prompts that hide what is typed,…	boolean

Try itanswered in this tab

curl

curl "$SANDBOX/secrets/passwords" \
  -H "x-intentic-control: $INTENTIC_TOKEN"

TypeScript

import { sandbox } from "@intentic/sandbox-client";

const result = await sandbox.secrets.passwords();

GET/secrets/passwords/needsCredentials this sandbox asked for that wait for an answer

The needs this sandbox raised (`secrets want`) that the owner has not answered yet, and on which computer each waits.

What you send

Nothing. Call it as it is.

What comes back

Field	Type
`needs`	object[]
`id`	string
`origin`	object
`when kind is "site"`	shape
`host`The page's host, `github.com`; never a…	string
`when kind is "program"`	shape
`program`A program, by its executable's file…	string
`label`The program's own name for people,…	string
`when kind is "package"`	shape
`package`An Android app, by its package…	string
`label`	string
`when kind is "ssh"`	shape
`target``user@host`, as ssh's prompt names it	string
`when kind is "ssh-key"`	shape
`path`	string
`when kind is "sudo"`	shape
`user`	string
`when kind is "git"`	shape
`url``https://host`, as git's credential helper or…	string
`when kind is "prompt"`	shape
`text`The prompt's own words, `Password for…	string
`command`The command that asked, `npm login`,…	string
`sandbox`The sandbox whose terminal asked, for…	string
`username`	string
`detail`	string
`conversation`	string
`machine`The computer it was answered on,…	string
`state`	"pending" \| "allowed" \| "denied" \| "unknown"
`name`The entry it was answered with,…	string
`at`	integer

Try itanswered in this tab

curl

curl "$SANDBOX/secrets/passwords/needs" \
  -H "x-intentic-control: $INTENTIC_TOKEN"

TypeScript

import { sandbox } from "@intentic/sandbox-client";

const result = await sandbox.secrets.passwordNeeds();

GET/secrets/passwords/activityThis sandbox's uses of the owner's passwords

Each time this sandbox used a password one of the owner's keyrings keeps, newest first, from its own use ledger. Never a value.

What you send

Nothing. Call it as it is.

What comes back

Field	Type
`lines`	object[]
`at`	number
`name`	string
`lane`	string
`detail`	string
`approvedBy`	string

Try itanswered in this tab

curl

curl "$SANDBOX/secrets/passwords/activity" \
  -H "x-intentic-control: $INTENTIC_TOKEN"

TypeScript

import { sandbox } from "@intentic/sandbox-client";

const result = await sandbox.secrets.passwordActivity();

GET/secrets/policy/{subject}How a connection's credential reaches the agent, and what it may do

Whether the credential gateway holds this connection's credential or the agent is handed it, and the method and path rules the gateway enforces on every request it attaches it to. Names and rules only, never values.

What you send

Field	Type	Where
`subject`requiredWhich gate, by the secret name…	string	address

What comes back

Field	Type
`subject`The connection's id	string
`delivery`How the agent gets this connection's…	"gateway" \| "raw" \| "direct" \| "ssh-agent"
`rules`What the credential may do through…	object[]
`methods`The HTTP methods it covers (`DELETE`,…	string[]
`paths`The paths it covers, below the…	string[]
`action``allow` forwards it, `ask` holds it…	"allow" \| "ask" \| "deny"
`why`One line on what the rule…	string
`rulesFrom`Whose rules these are: the connector's…	"connector" \| "owner"

Try itanswered in this tab

curl

curl "$SANDBOX/secrets/policy/Fix%20the%20flaky%20parser%20test" \
  -H "x-intentic-control: $INTENTIC_TOKEN"

TypeScript

import { sandbox } from "@intentic/sandbox-client";

const result = await sandbox.secrets.policy({
  "subject": "Fix the flaky parser test"
});

PUT/secrets/policy/{subject}Set how a connection's credential reaches the agent, and its rules

The owner's alone, and never the agent's: handing the agent the credential itself, or replacing what the gateway lets it do, is a decision about the credential, not a use of it.

What you send

Field	Type	Where
`subject`requiredThe connection's id	string	address
`delivery`Hand the agent the credential itself…	"gateway" \| "raw"	body
`rules`The owner's own rules, replacing the…	object[] \| null	body
`methods`The HTTP methods it covers (`DELETE`,…	string[]	body
`paths`The paths it covers, below the…	string[]	body
`action`required`allow` forwards it, `ask` holds it…	"allow" \| "ask" \| "deny"	body
`why`One line on what the rule…	string	body

What comes back

Field	Type
`subject`The connection's id	string
`delivery`How the agent gets this connection's…	"gateway" \| "raw" \| "direct" \| "ssh-agent"
`rules`What the credential may do through…	object[]
`methods`The HTTP methods it covers (`DELETE`,…	string[]
`paths`The paths it covers, below the…	string[]
`action``allow` forwards it, `ask` holds it…	"allow" \| "ask" \| "deny"
`why`One line on what the rule…	string
`rulesFrom`Whose rules these are: the connector's…	"connector" \| "owner"

Try itanswered in this tab

curl

curl -X PUT "$SANDBOX/secrets/policy/Fix%20the%20flaky%20parser%20test" \
  -H "x-intentic-control: $INTENTIC_TOKEN" \
  -H "content-type: application/json" \
  -d '{"delivery":"gateway","rules":[{"methods":["…","…"],"paths":["src/app.ts","README.md"],"action":"allow","why":"…"},{"methods":["…","…"],"paths":["src/app.ts","README.md"],"action":"ask","why":"…"}]}'

TypeScript

import { sandbox } from "@intentic/sandbox-client";

const result = await sandbox.secrets.setPolicy({
  "subject": "Fix the flaky parser test",
  "delivery": "gateway",
  "rules": [
    {
      "methods": [
        "…",
        "…"
      ],
      "paths": [
        "src/app.ts",
        "README.md"
      ],
      "action": "allow",
      "why": "…"
    },
    {
      "methods": [
        "…",
        "…"
      ],
      "paths": [
        "src/app.ts",
        "README.md"
      ],
      "action": "ask",
      "why": "…"
    }
  ]
});

POST/secrets/requestAsk a named person to release a credential

Raises the release card in the live conversation and waits for one of the people named on it. Refused, rather than held, when there is nobody to ask: an unattended turn, no live conversation, or a click with no verified identity behind it.

What you send

Field	Type	Where
`subject`requiredWhat to ask for: the secret's…	string	body
`why`One line on what it is…	string	body
`conversationId`Which conversation to raise the card…	string	body

What comes back

Field	Type
`granted`Always true: a refusal is an…	true
`approvedBy`Who released it	string
`message`What the grant means in practice,…	string

Try itanswered in this tab

curl

curl -X POST "$SANDBOX/secrets/request" \
  -H "x-intentic-control: $INTENTIC_TOKEN" \
  -H "content-type: application/json" \
  -d '{"subject":"Fix the flaky parser test","why":"…","conversationId":"nightly-changelog"}'

TypeScript

import { sandbox } from "@intentic/sandbox-client";

const result = await sandbox.secrets.request({
  "subject": "Fix the flaky parser test",
  "why": "…",
  "conversationId": "nightly-changelog"
});